interface ProofGraph {
  graphId: string;           // SHA3-256 over all node/edge content IDs
  nodes: ProofGraphNode[];
  edges: ProofGraphEdge[];
  createdAt: number;         // Unix ms — excluded from graphId
  metadata?: Record<string, unknown>;  // Also excluded from graphId
}

interface ProofGraphNode {
  id: string;                // computeNodeId(type, refId, data)
  type: ProofGraphNodeType;
  refId: string;             // External ID (proofId, address, evidenceId, …)
  createdAt: number;         // Unix ms — excluded from graphId hash
  data?: Record<string, unknown>;
}

type ProofGraphNodeType =
  | 'proof' | 'subject' | 'issuer' | 'evidence'
  | 'anchor' | 'manifest' | 'address' | 'identity'
  | 'receipt';

interface ProofGraphEdge {
  id: string;                // computeEdgeId(type, from, to)
  type: ProofGraphEdgeType;
  from: string;              // source node refId
  to: string;                // target node refId
  contextId?: string;        // e.g. the proofId that caused this edge
}

type ProofGraphEdgeType =
  | 'issued_by' | 'about' | 'proves' | 'has_evidence'
  | 'anchored_to' | 'revokes' | 'supersedes' | 'delegates_to'
  | 'derived_from' | 'manifests_as' | 'controls' | 'supports';

interface ProofGraphVerifyResult {
  valid: boolean;
  invalidProofs: string[];   // proofIds that failed verification
  checkedCount: number;
}

interface ReceiptLikeInput {
  id: string;
  data?: Record<string, unknown>;
  proofId?: string;          // If set, adds a 'supports' edge from receipt → proof
}

interface AnchorInput {
  hash: string;              // Used as the node's refId
  proofId?: string;          // If set, adds an 'anchored_to' edge from proof → anchor
  [key: string]: unknown;    // Additional fields stored as node data
}

import {
  createProofGraph,
  addProof,
  addAnchor,
  verifyProofGraph,
  findProofsBySubject,
  resolveCurrentProofSet,
  exportProofGraph,
  importProofGraph,
} from '@totemsdk/proofgraph';
import { createProof, signProof, createAnchorCommitment } from '@totemsdk/proof';

// 1. Build a signed proof
const unsigned = createProof({
  kind: 'ownership',
  subject: { id: 'totem:subject:asset:nft-001', kind: 'nft' },
  issuer: 'MxROOT...',
});
const signed = signProof(unsigned, seed, keyIndex);

// 2. Build the graph
let graph = createProofGraph();
graph = addProof(graph, signed);

// 3. Add an on-chain anchor
graph = addAnchor(graph, {
  hash: createAnchorCommitment(signed),
  proofId: signed.proofId,
  txId: '0xabc...',
});

// 4. Query
const forAsset = findProofsBySubject(graph, 'totem:subject:asset:nft-001');
console.log('Proofs:', forAsset.length);

const active = resolveCurrentProofSet(graph);
console.log('Active proofs:', active.length);

// 5. Verify all signatures
const result = verifyProofGraph(graph);
console.assert(result.valid, result.invalidProofs);

// 6. Serialize / deserialize (graphId is verified on import)
const json = exportProofGraph(graph);
const restored = importProofGraph(json);
console.assert(restored.graphId === graph.graphId);

import type { ProofGraphStoragePort, ProofGraph } from '@totemsdk/proofgraph';

class MyStorage implements ProofGraphStoragePort {
  async save(graph: ProofGraph): Promise<void> { /* ... */ }
  async load(graphId: string): Promise<ProofGraph | null> { /* ... */ }
}