@totemsdk/proofgraph 0.1.0

package/dist/canonical.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Canonical JSON and ID rules for @totemsdk/proofgraph.
+ *
+ * canonicalJson is implemented fresh — @totemsdk/identity and @totemsdk/proof
+ * each have their own copy; none of them export it publicly.
+ *
+ * ID rules:
+ *   Node:  type + ":" + refId  (e.g. "proof:totem:proof:abc123")
+ *   Edge:  sha3_256("totem-proofgraph-edge" + type + from + to + (proofId||'') + dataHash)
+ *   Graph: sha3_256("totem-proofgraph" + canonicalJson(nodeHashes) + canonicalJson(sortedEdges))
+ *          — node.createdAt and graph.metadata excluded from graphId (time-variant / mutable)
+ */
+import type { ProofGraphNode, ProofGraphEdge } from './types.js';
+export declare function toHex(bytes: Uint8Array): string;
+export declare function canonicalJson(value: unknown): string;
+export declare function computeNodeId(type: string, refId: string): string;
+export declare function computeEdgeId(type: string, from: string, to: string, proofId: string | undefined, data: Record<string, unknown> | undefined): string;
+export declare function computeProofGraphId(nodes: ProofGraphNode[], edges: ProofGraphEdge[]): string;
+export declare function recomputeGraphId(graph: {
+    nodes: ProofGraphNode[];
+    edges: ProofGraphEdge[];
+}): string;

package/dist/canonical.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Canonical JSON and ID rules for @totemsdk/proofgraph.
+ *
+ * canonicalJson is implemented fresh — @totemsdk/identity and @totemsdk/proof
+ * each have their own copy; none of them export it publicly.
+ *
+ * ID rules:
+ *   Node:  type + ":" + refId  (e.g. "proof:totem:proof:abc123")
+ *   Edge:  sha3_256("totem-proofgraph-edge" + type + from + to + (proofId||'') + dataHash)
+ *   Graph: sha3_256("totem-proofgraph" + canonicalJson(nodeHashes) + canonicalJson(sortedEdges))
+ *          — node.createdAt and graph.metadata excluded from graphId (time-variant / mutable)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHex = toHex;
+exports.canonicalJson = canonicalJson;
+exports.computeNodeId = computeNodeId;
+exports.computeEdgeId = computeEdgeId;
+exports.computeProofGraphId = computeProofGraphId;
+exports.recomputeGraphId = recomputeGraphId;
+const sha3_js_1 = require("@noble/hashes/sha3.js");
+function toHex(bytes) {
+    return Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+function canonicalJson(value) {
+    if (value === null || typeof value !== 'object') {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return '[' + value.map(canonicalJson).join(',') + ']';
+    }
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    const pairs = keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(obj[k])}`);
+    return '{' + pairs.join(',') + '}';
+}
+function computeNodeId(type, refId) {
+    return `${type}:${refId}`;
+}
+function computeEdgeId(type, from, to, proofId, data) {
+    const canonicalDataHash = toHex((0, sha3_js_1.sha3_256)(new TextEncoder().encode(canonicalJson(data ?? {}))));
+    const input = 'totem-proofgraph-edge' + type + from + to + (proofId ?? '') + canonicalDataHash;
+    return toHex((0, sha3_js_1.sha3_256)(new TextEncoder().encode(input)));
+}
+/**
+ * Content-stable projection of a node for graphId computation.
+ * Strips createdAt (time-variant) so equivalent logical content always
+ * produces the same graphId regardless of when nodes were created.
+ */
+function nodeForHashing(node) {
+    const { createdAt: _createdAt, ...rest } = node;
+    return rest;
+}
+function computeProofGraphId(nodes, edges) {
+    const sortedNodes = [...nodes]
+        .sort((a, b) => a.id.localeCompare(b.id))
+        .map(nodeForHashing);
+    const sortedEdges = [...edges].sort((a, b) => a.id.localeCompare(b.id));
+    const input = 'totem-proofgraph' + canonicalJson(sortedNodes) + canonicalJson(sortedEdges);
+    return toHex((0, sha3_js_1.sha3_256)(new TextEncoder().encode(input)));
+}
+function recomputeGraphId(graph) {
+    return computeProofGraphId(graph.nodes, graph.edges);
+}

package/dist/graph.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Proof graph mutation functions — all pure, all returning NEW graphs.
+ *
+ * Immutable pattern: every mutation returns a brand-new ProofGraph with a
+ * recomputed graphId. Nodes and edges are deduplicated by ID so adding the
+ * same proof twice is idempotent.
+ */
+import type { SignedProof } from '@totemsdk/proof';
+import type { SignedIdentityClaim, TotemIdentityDocument } from '@totemsdk/identity';
+import type { SignedManifest } from '@totemsdk/manifest';
+import type { ProofGraph, ProofGraphEdge, ProofGraphEdgeType, ProofGraphNodeType, ReceiptLikeInput, AnchorInput } from './types.js';
+/**
+ * Create an empty ProofGraph.
+ */
+export declare function createProofGraph(metadata?: Record<string, unknown>): ProofGraph;
+/**
+ * Attach or replace mutable metadata. Does NOT affect graphId.
+ */
+export declare function setGraphMetadata(graph: ProofGraph, metadata: Record<string, unknown>): ProofGraph;
+/**
+ * Build a ProofGraphEdge with a deterministic ID from its fields.
+ * Convenience helper so callers don't need to import computeEdgeId.
+ */
+export declare function buildEdge(type: ProofGraphEdgeType, from: string, to: string, proofId?: string, data?: Record<string, unknown>): ProofGraphEdge;
+/**
+ * Add a node directly (type + refId pair). Idempotent — skipped if the node already exists.
+ */
+export declare function addNode(graph: ProofGraph, type: ProofGraphNodeType, refId: string, data?: Record<string, unknown>): ProofGraph;
+/**
+ * Append a ProofGraphEdge and recompute graphId. Idempotent by edge ID.
+ * Spec API: addEdge(graph, edge). Use buildEdge() to construct the edge object.
+ */
+export declare function addEdge(graph: ProofGraph, edge: ProofGraphEdge): ProofGraph;
+/**
+ * Index a TotemIdentityDocument into the graph.
+ * Creates an 'identity' node with refId = doc.id.
+ */
+export declare function addIdentityDocument(graph: ProofGraph, doc: TotemIdentityDocument): ProofGraph;
+/**
+ * Index a SignedProof into the graph.
+ *
+ * Nodes created:
+ *   proof      — proofId (stores the full SignedProof in .data)
+ *   identity   — signature.address (issuer key address)
+ *   subject    — proof.subject.id
+ *   evidence   — ev.id (one per evidence ref)
+ *   anchor     — anchor.hash (if present)
+ *
+ * Edges created (all referencing the proofId):
+ *   proves      proof → subject
+ *   issued_by   proof → identity (signer)
+ *   about       proof → subject
+ *   references  proof → evidence (one per evidence ref, in array order)
+ *   anchored_to proof → anchor (if present)
+ */
+export declare function addProof(graph: ProofGraph, signedProof: SignedProof): ProofGraph;
+/**
+ * Index a SignedIdentityClaim into the graph.
+ *
+ * Nodes created:
+ *   identity-claim — claim.id (stores the full signed claim in .data)
+ *   address        — issuer address
+ *   address/identity — target address (for delegates_to / rotates_to / revokes)
+ *
+ * Edges created based on claim.type:
+ *   all types    → issued_by  (claim-node → issuer address)
+ *   delegates_to → delegates_to edge (claim-node → delegated address)
+ *   revokes      → revokes edge      (claim-node → subject identity)
+ *   rotates_to   → controls edge     (claim-node → new address)
+ */
+export declare function addIdentityClaim(graph: ProofGraph, signedClaim: SignedIdentityClaim): ProofGraph;
+/**
+ * Index a SignedManifest into the graph.
+ *
+ * Nodes created:
+ *   manifest — computed manifest ID (stores manifest content in .data)
+ *   address  — resolved author/agent/operator address
+ *
+ * Edge created:
+ *   manifests_as  manifest → address
+ */
+export declare function addManifest(graph: ProofGraph, signedManifest: SignedManifest): ProofGraph;
+/**
+ * Add a receipt-like node (payment, subscription, claim receipt) to the graph.
+ * If receipt.proofId is set, adds a 'supports' edge from the receipt to that proof.
+ */
+export declare function addReceiptLike(graph: ProofGraph, receipt: ReceiptLikeInput): ProofGraph;
+/**
+ * Add a standalone anchor node. If anchor.proofId is set, adds an 'anchored_to'
+ * edge from the proof to this anchor.
+ */
+export declare function addAnchor(graph: ProofGraph, anchor: AnchorInput): ProofGraph;

package/dist/graph.js

@@ -0,0 +1,268 @@
+"use strict";
+/**
+ * Proof graph mutation functions — all pure, all returning NEW graphs.
+ *
+ * Immutable pattern: every mutation returns a brand-new ProofGraph with a
+ * recomputed graphId. Nodes and edges are deduplicated by ID so adding the
+ * same proof twice is idempotent.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProofGraph = createProofGraph;
+exports.setGraphMetadata = setGraphMetadata;
+exports.buildEdge = buildEdge;
+exports.addNode = addNode;
+exports.addEdge = addEdge;
+exports.addIdentityDocument = addIdentityDocument;
+exports.addProof = addProof;
+exports.addIdentityClaim = addIdentityClaim;
+exports.addManifest = addManifest;
+exports.addReceiptLike = addReceiptLike;
+exports.addAnchor = addAnchor;
+const manifest_1 = require("@totemsdk/manifest");
+const canonical_js_1 = require("./canonical.js");
+function makeNode(type, refId, data) {
+    return {
+        id: (0, canonical_js_1.computeNodeId)(type, refId),
+        type,
+        refId,
+        ...(data !== undefined ? { data } : {}),
+        createdAt: Date.now(),
+    };
+}
+function makeEdge(type, from, to, proofId, data) {
+    return {
+        id: (0, canonical_js_1.computeEdgeId)(type, from, to, proofId, data),
+        type,
+        from,
+        to,
+        ...(proofId !== undefined ? { proofId } : {}),
+        ...(data !== undefined ? { data } : {}),
+    };
+}
+function mergeNodes(existing, incoming) {
+    const byId = new Map(existing.map((n) => [n.id, n]));
+    for (const node of incoming) {
+        if (!byId.has(node.id)) {
+            byId.set(node.id, node);
+        }
+    }
+    return Array.from(byId.values());
+}
+function mergeEdges(existing, incoming) {
+    const byId = new Map(existing.map((e) => [e.id, e]));
+    for (const edge of incoming) {
+        if (!byId.has(edge.id)) {
+            byId.set(edge.id, edge);
+        }
+    }
+    return Array.from(byId.values());
+}
+function rebuild(graph, newNodes, newEdges) {
+    const nodes = mergeNodes(graph.nodes, newNodes);
+    const edges = mergeEdges(graph.edges, newEdges);
+    return {
+        ...graph,
+        nodes,
+        edges,
+        graphId: (0, canonical_js_1.computeProofGraphId)(nodes, edges),
+    };
+}
+/**
+ * Create an empty ProofGraph.
+ */
+function createProofGraph(metadata) {
+    const nodes = [];
+    const edges = [];
+    return {
+        graphId: (0, canonical_js_1.computeProofGraphId)(nodes, edges),
+        nodes,
+        edges,
+        createdAt: Date.now(),
+        ...(metadata !== undefined ? { metadata } : {}),
+    };
+}
+/**
+ * Attach or replace mutable metadata. Does NOT affect graphId.
+ */
+function setGraphMetadata(graph, metadata) {
+    return { ...graph, metadata };
+}
+/**
+ * Build a ProofGraphEdge with a deterministic ID from its fields.
+ * Convenience helper so callers don't need to import computeEdgeId.
+ */
+function buildEdge(type, from, to, proofId, data) {
+    return makeEdge(type, from, to, proofId, data);
+}
+/**
+ * Add a node directly (type + refId pair). Idempotent — skipped if the node already exists.
+ */
+function addNode(graph, type, refId, data) {
+    return rebuild(graph, [makeNode(type, refId, data)], []);
+}
+/**
+ * Append a ProofGraphEdge and recompute graphId. Idempotent by edge ID.
+ * Spec API: addEdge(graph, edge). Use buildEdge() to construct the edge object.
+ */
+function addEdge(graph, edge) {
+    const edges = mergeEdges(graph.edges, [edge]);
+    return {
+        ...graph,
+        edges,
+        graphId: (0, canonical_js_1.computeProofGraphId)(graph.nodes, edges),
+    };
+}
+/**
+ * Index a TotemIdentityDocument into the graph.
+ * Creates an 'identity' node with refId = doc.id.
+ */
+function addIdentityDocument(graph, doc) {
+    return rebuild(graph, [makeNode('identity', doc.id, { ...doc })], []);
+}
+/**
+ * Index a SignedProof into the graph.
+ *
+ * Nodes created:
+ *   proof      — proofId (stores the full SignedProof in .data)
+ *   identity   — signature.address (issuer key address)
+ *   subject    — proof.subject.id
+ *   evidence   — ev.id (one per evidence ref)
+ *   anchor     — anchor.hash (if present)
+ *
+ * Edges created (all referencing the proofId):
+ *   proves      proof → subject
+ *   issued_by   proof → identity (signer)
+ *   about       proof → subject
+ *   references  proof → evidence (one per evidence ref, in array order)
+ *   anchored_to proof → anchor (if present)
+ */
+function addProof(graph, signedProof) {
+    const proofNode = makeNode('proof', signedProof.proofId, {
+        ...signedProof,
+    });
+    const identityNode = makeNode('identity', signedProof.signature.address);
+    const subjectNode = makeNode('subject', signedProof.subject.id);
+    const newNodes = [proofNode, identityNode, subjectNode];
+    const newEdges = [
+        makeEdge('proves', signedProof.proofId, signedProof.subject.id, signedProof.proofId),
+        makeEdge('issued_by', signedProof.proofId, signedProof.signature.address, signedProof.proofId),
+        makeEdge('about', signedProof.proofId, signedProof.subject.id, signedProof.proofId),
+    ];
+    if (signedProof.evidence) {
+        for (const ev of signedProof.evidence) {
+            newNodes.push(makeNode('evidence', ev.id));
+            newEdges.push(makeEdge('references', signedProof.proofId, ev.id, signedProof.proofId));
+        }
+    }
+    if (signedProof.anchor) {
+        newNodes.push(makeNode('anchor', signedProof.anchor.hash));
+        newEdges.push(makeEdge('anchored_to', signedProof.proofId, signedProof.anchor.hash, signedProof.proofId));
+    }
+    return rebuild(graph, newNodes, newEdges);
+}
+/**
+ * Index a SignedIdentityClaim into the graph.
+ *
+ * Nodes created:
+ *   identity-claim — claim.id (stores the full signed claim in .data)
+ *   address        — issuer address
+ *   address/identity — target address (for delegates_to / rotates_to / revokes)
+ *
+ * Edges created based on claim.type:
+ *   all types    → issued_by  (claim-node → issuer address)
+ *   delegates_to → delegates_to edge (claim-node → delegated address)
+ *   revokes      → revokes edge      (claim-node → subject identity)
+ *   rotates_to   → controls edge     (claim-node → new address)
+ */
+function addIdentityClaim(graph, signedClaim) {
+    const { claim } = signedClaim;
+    const claimNode = makeNode('identity-claim', claim.id, {
+        ...signedClaim,
+    });
+    const issuerNode = makeNode('address', claim.issuer);
+    const newNodes = [claimNode, issuerNode];
+    const newEdges = [
+        makeEdge('issued_by', claim.id, claim.issuer),
+    ];
+    if (claim.type === 'delegates_to') {
+        newNodes.push(makeNode('address', claim.object));
+        newEdges.push(makeEdge('delegates_to', claim.id, claim.object));
+    }
+    else if (claim.type === 'revokes') {
+        newNodes.push(makeNode('identity', claim.subject));
+        newEdges.push(makeEdge('revokes', claim.id, claim.subject));
+    }
+    else if (claim.type === 'rotates_to') {
+        newNodes.push(makeNode('address', claim.object));
+        newEdges.push(makeEdge('controls', claim.id, claim.object));
+    }
+    return rebuild(graph, newNodes, newEdges);
+}
+/**
+ * Resolve the author address from a manifest based on its type.
+ * AppManifest / DAppManifest → authorAddress
+ * CapabilityManifest         → agentAddress
+ * EdgeServiceManifest        → operatorAddress
+ * Falls back to signedManifest.authorAddress if the manifest type is unknown.
+ */
+function resolveManifestAddress(signedManifest) {
+    const m = signedManifest.manifest;
+    if (m['type'] === 'capability' && typeof m['agentAddress'] === 'string') {
+        return m['agentAddress'];
+    }
+    if (m['type'] === 'edge-service' && typeof m['operatorAddress'] === 'string') {
+        return m['operatorAddress'];
+    }
+    if (typeof m['authorAddress'] === 'string') {
+        return m['authorAddress'];
+    }
+    return signedManifest.authorAddress;
+}
+/**
+ * Index a SignedManifest into the graph.
+ *
+ * Nodes created:
+ *   manifest — computed manifest ID (stores manifest content in .data)
+ *   address  — resolved author/agent/operator address
+ *
+ * Edge created:
+ *   manifests_as  manifest → address
+ */
+function addManifest(graph, signedManifest) {
+    const manifestId = (0, manifest_1.computeManifestId)(signedManifest.manifest);
+    const address = resolveManifestAddress(signedManifest);
+    const manifestNode = makeNode('manifest', manifestId, {
+        ...signedManifest,
+    });
+    const addressNode = makeNode('address', address);
+    return rebuild(graph, [manifestNode, addressNode], [
+        makeEdge('manifests_as', manifestId, address),
+    ]);
+}
+/**
+ * Add a receipt-like node (payment, subscription, claim receipt) to the graph.
+ * If receipt.proofId is set, adds a 'supports' edge from the receipt to that proof.
+ */
+function addReceiptLike(graph, receipt) {
+    const { id, data, proofId } = receipt;
+    const receiptNode = makeNode('receipt', id, data);
+    const newEdges = [];
+    if (proofId !== undefined) {
+        newEdges.push(makeEdge('supports', id, proofId, proofId));
+    }
+    return rebuild(graph, [receiptNode], newEdges);
+}
+/**
+ * Add a standalone anchor node. If anchor.proofId is set, adds an 'anchored_to'
+ * edge from the proof to this anchor.
+ */
+function addAnchor(graph, anchor) {
+    const { hash, proofId, ...rest } = anchor;
+    const nodeData = { ...rest };
+    const anchorNode = makeNode('anchor', hash, Object.keys(nodeData).length > 0 ? nodeData : undefined);
+    const newEdges = [];
+    if (proofId !== undefined) {
+        newEdges.push(makeEdge('anchored_to', proofId, hash, proofId));
+    }
+    return rebuild(graph, [anchorNode], newEdges);
+}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module @totemsdk/proofgraph
+ *
+ * Local deterministic proof relationship graph for Totem Edge.
+ *
+ * Indexes SignedProofs, SignedIdentityClaims, SignedManifests, identity
+ * documents, and custom evidence nodes into an immutable, queryable DAG
+ * keyed by a content-derived graphId. Pure package — no network, no DHT,
+ * no blockchain submission, no crypto reimplementation.
+ *
+ * Usage:
+ *   const g0 = createProofGraph();
+ *   const g1 = addProof(g0, signedProof);
+ *   const result = verifyProofGraph(g1);
+ */
+export type { ProofGraphNodeType, ProofGraphEdgeType, ProofGraphNode, ProofGraphEdge, ProofGraph, ProofGraphVerifyResult, ProofGraphStoragePort, ReceiptLikeInput, AnchorInput, } from './types.js';
+export { toHex, canonicalJson, computeNodeId, computeEdgeId, computeProofGraphId, recomputeGraphId, } from './canonical.js';
+export { createProofGraph, setGraphMetadata, buildEdge, addNode, addEdge, addIdentityDocument, addProof, addIdentityClaim, addManifest, addReceiptLike, addAnchor, } from './graph.js';
+export { findNode, getEdgesFrom, getEdgesTo, getEdgesByType, getProofNodes, findProofsBySubject, findProofsByIssuer, findAnchorsForProof, findRevocations, findSupersessions, findConflicts, getEvidenceTrail, getProofLineage, resolveCurrentProofSet, getManifestsForAddress, getEdgesBetween, reachableFrom, } from './query.js';
+export { verifyProofGraph, verifyGraphProofs, } from './verify.js';
+export { exportProofGraph, importProofGraph, } from './io.js';

package/dist/index.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * @module @totemsdk/proofgraph
+ *
+ * Local deterministic proof relationship graph for Totem Edge.
+ *
+ * Indexes SignedProofs, SignedIdentityClaims, SignedManifests, identity
+ * documents, and custom evidence nodes into an immutable, queryable DAG
+ * keyed by a content-derived graphId. Pure package — no network, no DHT,
+ * no blockchain submission, no crypto reimplementation.
+ *
+ * Usage:
+ *   const g0 = createProofGraph();
+ *   const g1 = addProof(g0, signedProof);
+ *   const result = verifyProofGraph(g1);
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importProofGraph = exports.exportProofGraph = exports.verifyGraphProofs = exports.verifyProofGraph = exports.reachableFrom = exports.getEdgesBetween = exports.getManifestsForAddress = exports.resolveCurrentProofSet = exports.getProofLineage = exports.getEvidenceTrail = exports.findConflicts = exports.findSupersessions = exports.findRevocations = exports.findAnchorsForProof = exports.findProofsByIssuer = exports.findProofsBySubject = exports.getProofNodes = exports.getEdgesByType = exports.getEdgesTo = exports.getEdgesFrom = exports.findNode = exports.addAnchor = exports.addReceiptLike = exports.addManifest = exports.addIdentityClaim = exports.addProof = exports.addIdentityDocument = exports.addEdge = exports.addNode = exports.buildEdge = exports.setGraphMetadata = exports.createProofGraph = exports.recomputeGraphId = exports.computeProofGraphId = exports.computeEdgeId = exports.computeNodeId = exports.canonicalJson = exports.toHex = void 0;
+var canonical_js_1 = require("./canonical.js");
+Object.defineProperty(exports, "toHex", { enumerable: true, get: function () { return canonical_js_1.toHex; } });
+Object.defineProperty(exports, "canonicalJson", { enumerable: true, get: function () { return canonical_js_1.canonicalJson; } });
+Object.defineProperty(exports, "computeNodeId", { enumerable: true, get: function () { return canonical_js_1.computeNodeId; } });
+Object.defineProperty(exports, "computeEdgeId", { enumerable: true, get: function () { return canonical_js_1.computeEdgeId; } });
+Object.defineProperty(exports, "computeProofGraphId", { enumerable: true, get: function () { return canonical_js_1.computeProofGraphId; } });
+Object.defineProperty(exports, "recomputeGraphId", { enumerable: true, get: function () { return canonical_js_1.recomputeGraphId; } });
+var graph_js_1 = require("./graph.js");
+Object.defineProperty(exports, "createProofGraph", { enumerable: true, get: function () { return graph_js_1.createProofGraph; } });
+Object.defineProperty(exports, "setGraphMetadata", { enumerable: true, get: function () { return graph_js_1.setGraphMetadata; } });
+Object.defineProperty(exports, "buildEdge", { enumerable: true, get: function () { return graph_js_1.buildEdge; } });
+Object.defineProperty(exports, "addNode", { enumerable: true, get: function () { return graph_js_1.addNode; } });
+Object.defineProperty(exports, "addEdge", { enumerable: true, get: function () { return graph_js_1.addEdge; } });
+Object.defineProperty(exports, "addIdentityDocument", { enumerable: true, get: function () { return graph_js_1.addIdentityDocument; } });
+Object.defineProperty(exports, "addProof", { enumerable: true, get: function () { return graph_js_1.addProof; } });
+Object.defineProperty(exports, "addIdentityClaim", { enumerable: true, get: function () { return graph_js_1.addIdentityClaim; } });
+Object.defineProperty(exports, "addManifest", { enumerable: true, get: function () { return graph_js_1.addManifest; } });
+Object.defineProperty(exports, "addReceiptLike", { enumerable: true, get: function () { return graph_js_1.addReceiptLike; } });
+Object.defineProperty(exports, "addAnchor", { enumerable: true, get: function () { return graph_js_1.addAnchor; } });
+var query_js_1 = require("./query.js");
+Object.defineProperty(exports, "findNode", { enumerable: true, get: function () { return query_js_1.findNode; } });
+Object.defineProperty(exports, "getEdgesFrom", { enumerable: true, get: function () { return query_js_1.getEdgesFrom; } });
+Object.defineProperty(exports, "getEdgesTo", { enumerable: true, get: function () { return query_js_1.getEdgesTo; } });
+Object.defineProperty(exports, "getEdgesByType", { enumerable: true, get: function () { return query_js_1.getEdgesByType; } });
+Object.defineProperty(exports, "getProofNodes", { enumerable: true, get: function () { return query_js_1.getProofNodes; } });
+Object.defineProperty(exports, "findProofsBySubject", { enumerable: true, get: function () { return query_js_1.findProofsBySubject; } });
+Object.defineProperty(exports, "findProofsByIssuer", { enumerable: true, get: function () { return query_js_1.findProofsByIssuer; } });
+Object.defineProperty(exports, "findAnchorsForProof", { enumerable: true, get: function () { return query_js_1.findAnchorsForProof; } });
+Object.defineProperty(exports, "findRevocations", { enumerable: true, get: function () { return query_js_1.findRevocations; } });
+Object.defineProperty(exports, "findSupersessions", { enumerable: true, get: function () { return query_js_1.findSupersessions; } });
+Object.defineProperty(exports, "findConflicts", { enumerable: true, get: function () { return query_js_1.findConflicts; } });
+Object.defineProperty(exports, "getEvidenceTrail", { enumerable: true, get: function () { return query_js_1.getEvidenceTrail; } });
+Object.defineProperty(exports, "getProofLineage", { enumerable: true, get: function () { return query_js_1.getProofLineage; } });
+Object.defineProperty(exports, "resolveCurrentProofSet", { enumerable: true, get: function () { return query_js_1.resolveCurrentProofSet; } });
+Object.defineProperty(exports, "getManifestsForAddress", { enumerable: true, get: function () { return query_js_1.getManifestsForAddress; } });
+Object.defineProperty(exports, "getEdgesBetween", { enumerable: true, get: function () { return query_js_1.getEdgesBetween; } });
+Object.defineProperty(exports, "reachableFrom", { enumerable: true, get: function () { return query_js_1.reachableFrom; } });
+var verify_js_1 = require("./verify.js");
+Object.defineProperty(exports, "verifyProofGraph", { enumerable: true, get: function () { return verify_js_1.verifyProofGraph; } });
+Object.defineProperty(exports, "verifyGraphProofs", { enumerable: true, get: function () { return verify_js_1.verifyGraphProofs; } });
+var io_js_1 = require("./io.js");
+Object.defineProperty(exports, "exportProofGraph", { enumerable: true, get: function () { return io_js_1.exportProofGraph; } });
+Object.defineProperty(exports, "importProofGraph", { enumerable: true, get: function () { return io_js_1.importProofGraph; } });

package/dist/io.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Serialization helpers for ProofGraph.
+ *
+ * exportProofGraph:  JSON-stringify the graph for storage or transport.
+ * importProofGraph:  parse JSON, recompute graphId, throw if it doesn't match.
+ *
+ * The graphId guards against silent corruption in transit.
+ */
+import type { ProofGraph } from './types.js';
+/**
+ * Serialize a ProofGraph to a JSON string.
+ * The stored graphId was computed at mutation time and is included as-is.
+ */
+export declare function exportProofGraph(graph: ProofGraph): string;
+/**
+ * Deserialize a ProofGraph from a JSON string.
+ *
+ * Recomputes the graphId from nodes + edges. Throws if the recomputed value
+ * does not match the stored graphId — indicates tampering or data corruption.
+ *
+ * @throws Error if graphId verification fails.
+ */
+export declare function importProofGraph(json: string): ProofGraph;

package/dist/io.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Serialization helpers for ProofGraph.
+ *
+ * exportProofGraph:  JSON-stringify the graph for storage or transport.
+ * importProofGraph:  parse JSON, recompute graphId, throw if it doesn't match.
+ *
+ * The graphId guards against silent corruption in transit.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportProofGraph = exportProofGraph;
+exports.importProofGraph = importProofGraph;
+const canonical_js_1 = require("./canonical.js");
+/**
+ * Serialize a ProofGraph to a JSON string.
+ * The stored graphId was computed at mutation time and is included as-is.
+ */
+function exportProofGraph(graph) {
+    return JSON.stringify(graph);
+}
+/**
+ * Deserialize a ProofGraph from a JSON string.
+ *
+ * Recomputes the graphId from nodes + edges. Throws if the recomputed value
+ * does not match the stored graphId — indicates tampering or data corruption.
+ *
+ * @throws Error if graphId verification fails.
+ */
+function importProofGraph(json) {
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch (err) {
+        throw new Error(`importProofGraph: invalid JSON — ${err.message}`);
+    }
+    const graph = parsed;
+    if (!graph || typeof graph !== 'object') {
+        throw new Error('importProofGraph: parsed value is not an object');
+    }
+    if (!Array.isArray(graph.nodes) || !Array.isArray(graph.edges)) {
+        throw new Error('importProofGraph: missing nodes or edges arrays');
+    }
+    const recomputed = (0, canonical_js_1.recomputeGraphId)(graph);
+    if (recomputed !== graph.graphId) {
+        throw new Error(`importProofGraph: graphId mismatch — stored="${graph.graphId}" recomputed="${recomputed}"`);
+    }
+    return graph;
+}

package/dist/query.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Query helpers for ProofGraph — pure read-only utilities.
+ *
+ * All functions receive a ProofGraph and return data without mutating the graph.
+ * Function names match the @totemsdk/proofgraph public API spec exactly.
+ */
+import type { ProofGraph, ProofGraphNode, ProofGraphEdge, ProofGraphEdgeType } from './types.js';
+/**
+ * Find a node by its composed node ID (type:refId) or by refId alone.
+ */
+export declare function findNode(graph: ProofGraph, id: string): ProofGraphNode | undefined;
+/**
+ * Return all outgoing edges from a node (identified by node ID or refId).
+ */
+export declare function getEdgesFrom(graph: ProofGraph, nodeIdOrRefId: string): ProofGraphEdge[];
+/**
+ * Return all incoming edges to a node (identified by node ID or refId).
+ */
+export declare function getEdgesTo(graph: ProofGraph, nodeIdOrRefId: string): ProofGraphEdge[];
+/**
+ * Return all edges of a given type.
+ */
+export declare function getEdgesByType(graph: ProofGraph, type: ProofGraphEdgeType): ProofGraphEdge[];
+/**
+ * Return all proof nodes in the graph.
+ */
+export declare function getProofNodes(graph: ProofGraph): ProofGraphNode[];
+/**
+ * Find all 'proof' nodes connected to a subject via 'about' OR 'proves' edges.
+ */
+export declare function findProofsBySubject(graph: ProofGraph, subjectId: string): ProofGraphNode[];
+/**
+ * Find all 'proof' nodes issued by a given address (via 'issued_by' edges).
+ */
+export declare function findProofsByIssuer(graph: ProofGraph, issuerId: string): ProofGraphNode[];
+/**
+ * Find all 'anchor' nodes linked to a proof via 'anchored_to' edges.
+ */
+export declare function findAnchorsForProof(graph: ProofGraph, proofId: string): ProofGraphNode[];
+/**
+ * Find all 'revokes' edges whose target is the given proof node.
+ */
+export declare function findRevocations(graph: ProofGraph, proofId: string): ProofGraphEdge[];
+/**
+ * Find all 'supersedes' edges whose target is the given proof node.
+ */
+export declare function findSupersessions(graph: ProofGraph, proofId: string): ProofGraphEdge[];
+/**
+ * Find all 'conflicts_with' edges involving the given proof node (in either direction).
+ */
+export declare function findConflicts(graph: ProofGraph, proofId: string): ProofGraphEdge[];
+/**
+ * Traverse 'references' edges from a proof to its evidence nodes.
+ * Returns nodes in insertion order (the order edges were added, which matches
+ * the original evidence array order from addProof).
+ */
+export declare function getEvidenceTrail(graph: ProofGraph, proofId: string): ProofGraphNode[];
+/**
+ * Recursively traverse 'derived_from' edges from a proof node.
+ * Returns the ordered chain of ancestor proof nodes (closest ancestor first).
+ * Terminates on cycle detection.
+ */
+export declare function getProofLineage(graph: ProofGraph, proofId: string, _visited?: Set<string>): ProofGraphNode[];
+/**
+ * Return all proof nodes that are NOT the target of any 'revokes' or 'supersedes' edge.
+ * These are the current / active proofs in the graph.
+ */
+export declare function resolveCurrentProofSet(graph: ProofGraph): ProofGraphNode[];
+/**
+ * Return all manifest nodes linked to a given address via 'manifests_as' edges.
+ */
+export declare function getManifestsForAddress(graph: ProofGraph, address: string): ProofGraphNode[];
+/**
+ * Return all edges between two nodes (in either direction).
+ */
+export declare function getEdgesBetween(graph: ProofGraph, refIdA: string, refIdB: string): ProofGraphEdge[];
+/**
+ * Return the set of all node refIds reachable from a given node via directed edges.
+ * Includes the start node itself.
+ */
+export declare function reachableFrom(graph: ProofGraph, startRefId: string, _visited?: Set<string>): Set<string>;

package/dist/query.js

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * Query helpers for ProofGraph — pure read-only utilities.
+ *
+ * All functions receive a ProofGraph and return data without mutating the graph.
+ * Function names match the @totemsdk/proofgraph public API spec exactly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNode = findNode;
+exports.getEdgesFrom = getEdgesFrom;
+exports.getEdgesTo = getEdgesTo;
+exports.getEdgesByType = getEdgesByType;
+exports.getProofNodes = getProofNodes;
+exports.findProofsBySubject = findProofsBySubject;
+exports.findProofsByIssuer = findProofsByIssuer;
+exports.findAnchorsForProof = findAnchorsForProof;
+exports.findRevocations = findRevocations;
+exports.findSupersessions = findSupersessions;
+exports.findConflicts = findConflicts;
+exports.getEvidenceTrail = getEvidenceTrail;
+exports.getProofLineage = getProofLineage;
+exports.resolveCurrentProofSet = resolveCurrentProofSet;
+exports.getManifestsForAddress = getManifestsForAddress;
+exports.getEdgesBetween = getEdgesBetween;
+exports.reachableFrom = reachableFrom;
+/**
+ * Find a node by its composed node ID (type:refId) or by refId alone.
+ */
+function findNode(graph, id) {
+    return graph.nodes.find((n) => n.id === id || n.refId === id);
+}
+/**
+ * Return all outgoing edges from a node (identified by node ID or refId).
+ */
+function getEdgesFrom(graph, nodeIdOrRefId) {
+    const node = findNode(graph, nodeIdOrRefId);
+    if (!node)
+        return [];
+    return graph.edges.filter((e) => e.from === node.refId);
+}
+/**
+ * Return all incoming edges to a node (identified by node ID or refId).
+ */
+function getEdgesTo(graph, nodeIdOrRefId) {
+    const node = findNode(graph, nodeIdOrRefId);
+    if (!node)
+        return [];
+    return graph.edges.filter((e) => e.to === node.refId);
+}
+/**
+ * Return all edges of a given type.
+ */
+function getEdgesByType(graph, type) {
+    return graph.edges.filter((e) => e.type === type);
+}
+/**
+ * Return all proof nodes in the graph.
+ */
+function getProofNodes(graph) {
+    return graph.nodes.filter((n) => n.type === 'proof');
+}
+/**
+ * Find all 'proof' nodes connected to a subject via 'about' OR 'proves' edges.
+ */
+function findProofsBySubject(graph, subjectId) {
+    const relevantEdges = graph.edges.filter((e) => (e.type === 'about' || e.type === 'proves') && e.to === subjectId);
+    const proofRefIds = new Set(relevantEdges.map((e) => e.from));
+    return graph.nodes.filter((n) => proofRefIds.has(n.refId) && n.type === 'proof');
+}
+/**
+ * Find all 'proof' nodes issued by a given address (via 'issued_by' edges).
+ */
+function findProofsByIssuer(graph, issuerId) {
+    const issuedEdges = graph.edges.filter((e) => e.type === 'issued_by' && e.to === issuerId);
+    const proofRefIds = new Set(issuedEdges.map((e) => e.from));
+    return graph.nodes.filter((n) => proofRefIds.has(n.refId) && n.type === 'proof');
+}
+/**
+ * Find all 'anchor' nodes linked to a proof via 'anchored_to' edges.
+ */
+function findAnchorsForProof(graph, proofId) {
+    const anchoredEdges = graph.edges.filter((e) => e.type === 'anchored_to' && e.from === proofId);
+    const anchorRefIds = new Set(anchoredEdges.map((e) => e.to));
+    return graph.nodes.filter((n) => anchorRefIds.has(n.refId) && n.type === 'anchor');
+}
+/**
+ * Find all 'revokes' edges whose target is the given proof node.
+ */
+function findRevocations(graph, proofId) {
+    return graph.edges.filter((e) => e.type === 'revokes' && e.to === proofId);
+}
+/**
+ * Find all 'supersedes' edges whose target is the given proof node.
+ */
+function findSupersessions(graph, proofId) {
+    return graph.edges.filter((e) => e.type === 'supersedes' && e.to === proofId);
+}
+/**
+ * Find all 'conflicts_with' edges involving the given proof node (in either direction).
+ */
+function findConflicts(graph, proofId) {
+    return graph.edges.filter((e) => e.type === 'conflicts_with' &&
+        (e.from === proofId || e.to === proofId));
+}
+/**
+ * Traverse 'references' edges from a proof to its evidence nodes.
+ * Returns nodes in insertion order (the order edges were added, which matches
+ * the original evidence array order from addProof).
+ */
+function getEvidenceTrail(graph, proofId) {
+    const refEdges = graph.edges.filter((e) => e.type === 'references' && e.from === proofId);
+    return refEdges
+        .map((e) => graph.nodes.find((n) => n.refId === e.to && n.type === 'evidence'))
+        .filter((n) => n !== undefined);
+}
+/**
+ * Recursively traverse 'derived_from' edges from a proof node.
+ * Returns the ordered chain of ancestor proof nodes (closest ancestor first).
+ * Terminates on cycle detection.
+ */
+function getProofLineage(graph, proofId, _visited = new Set()) {
+    if (_visited.has(proofId))
+        return [];
+    _visited.add(proofId);
+    const derivedEdges = graph.edges.filter((e) => e.type === 'derived_from' && e.from === proofId);
+    const result = [];
+    for (const edge of derivedEdges) {
+        const node = graph.nodes.find((n) => n.refId === edge.to);
+        if (node) {
+            result.push(node);
+            result.push(...getProofLineage(graph, edge.to, _visited));
+        }
+    }
+    return result;
+}
+/**
+ * Return all proof nodes that are NOT the target of any 'revokes' or 'supersedes' edge.
+ * These are the current / active proofs in the graph.
+ */
+function resolveCurrentProofSet(graph) {
+    const supersededOrRevoked = new Set();
+    for (const edge of graph.edges) {
+        if (edge.type === 'revokes' || edge.type === 'supersedes') {
+            supersededOrRevoked.add(edge.to);
+        }
+    }
+    return graph.nodes.filter((n) => n.type === 'proof' && !supersededOrRevoked.has(n.refId));
+}
+/**
+ * Return all manifest nodes linked to a given address via 'manifests_as' edges.
+ */
+function getManifestsForAddress(graph, address) {
+    const manifestEdges = graph.edges.filter((e) => e.type === 'manifests_as' && e.to === address);
+    const manifestRefIds = new Set(manifestEdges.map((e) => e.from));
+    return graph.nodes.filter((n) => manifestRefIds.has(n.refId) && n.type === 'manifest');
+}
+/**
+ * Return all edges between two nodes (in either direction).
+ */
+function getEdgesBetween(graph, refIdA, refIdB) {
+    return graph.edges.filter((e) => (e.from === refIdA && e.to === refIdB) ||
+        (e.from === refIdB && e.to === refIdA));
+}
+/**
+ * Return the set of all node refIds reachable from a given node via directed edges.
+ * Includes the start node itself.
+ */
+function reachableFrom(graph, startRefId, _visited = new Set()) {
+    if (_visited.has(startRefId))
+        return _visited;
+    _visited.add(startRefId);
+    const outgoing = graph.edges.filter((e) => e.from === startRefId);
+    for (const edge of outgoing) {
+        reachableFrom(graph, edge.to, _visited);
+    }
+    return _visited;
+}

package/dist/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @totemsdk/proofgraph — Type definitions
+ *
+ * Pure schema — no network, no DHT, no blockchain submission, no crypto.
+ */
+export type ProofGraphNodeType = 'proof' | 'identity' | 'identity-claim' | 'manifest' | 'address' | 'subject' | 'evidence' | 'anchor' | 'receipt' | 'payment' | 'device' | 'service' | 'policy' | 'custom';
+export type ProofGraphEdgeType = 'proves' | 'issued_by' | 'signed_by' | 'about' | 'references' | 'derived_from' | 'supports' | 'contradicts' | 'supersedes' | 'revokes' | 'anchored_to' | 'delegates_to' | 'controls' | 'depends_on' | 'manifests_as' | 'conflicts_with';
+export interface ProofGraphNode {
+    id: string;
+    type: ProofGraphNodeType;
+    refId: string;
+    data?: Record<string, unknown>;
+    createdAt: number;
+}
+export interface ProofGraphEdge {
+    id: string;
+    type: ProofGraphEdgeType;
+    from: string;
+    to: string;
+    proofId?: string;
+    data?: Record<string, unknown>;
+}
+export interface ProofGraph {
+    graphId: string;
+    nodes: ProofGraphNode[];
+    edges: ProofGraphEdge[];
+    createdAt: number;
+    metadata?: Record<string, unknown>;
+}
+export interface ProofGraphVerifyResult {
+    valid: boolean;
+    invalidProofs: string[];
+    reason?: string;
+}
+/**
+ * Input object for addReceiptLike.
+ */
+export interface ReceiptLikeInput {
+    id: string;
+    data?: Record<string, unknown>;
+    proofId?: string;
+}
+/**
+ * Input object for addAnchor.
+ */
+export interface AnchorInput {
+    hash: string;
+    provider?: string;
+    txId?: string;
+    confirmedAt?: number;
+    metadata?: Record<string, unknown>;
+    proofId?: string;
+}
+/**
+ * Storage port — interface only, no concrete implementation in this package.
+ * Adapters (SQLite, LevelDB, in-memory) live in consumer packages.
+ */
+export interface ProofGraphStoragePort {
+    save(graph: ProofGraph): Promise<void>;
+    load(graphId: string): Promise<ProofGraph | null>;
+    findByNodeId(id: string): Promise<ProofGraph | null>;
+}

package/dist/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * @totemsdk/proofgraph — Type definitions
+ *
+ * Pure schema — no network, no DHT, no blockchain submission, no crypto.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/verify.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Graph-level verification.
+ *
+ * verifyProofGraph: iterates proof nodes, recovers SignedProof from node.data,
+ * and delegates to @totemsdk/proof's verifyProof for each one.
+ * Never reimplements cryptography.
+ *
+ * verifyGraphProofs: same logic, returns the list of invalid proof IDs (string[]).
+ */
+import type { ProofGraph, ProofGraphVerifyResult } from './types.js';
+/**
+ * Verify every proof node stored in the graph.
+ *
+ * Iterates nodes of type 'proof', casts node.data back to SignedProof,
+ * and calls proofModule.verifyProof() from @totemsdk/proof.
+ * Returns { valid: true } if ALL proofs pass; otherwise lists the failing proofIds.
+ */
+export declare function verifyProofGraph(graph: ProofGraph, _options?: Record<string, unknown>): ProofGraphVerifyResult;
+/**
+ * Returns the list of invalid proof IDs in the graph.
+ * Equivalent to verifyProofGraph(graph).invalidProofs.
+ */
+export declare function verifyGraphProofs(graph: ProofGraph): string[];

package/dist/verify.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Graph-level verification.
+ *
+ * verifyProofGraph: iterates proof nodes, recovers SignedProof from node.data,
+ * and delegates to @totemsdk/proof's verifyProof for each one.
+ * Never reimplements cryptography.
+ *
+ * verifyGraphProofs: same logic, returns the list of invalid proof IDs (string[]).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyProofGraph = verifyProofGraph;
+exports.verifyGraphProofs = verifyGraphProofs;
+const proofModule = __importStar(require("@totemsdk/proof"));
+/**
+ * Verify every proof node stored in the graph.
+ *
+ * Iterates nodes of type 'proof', casts node.data back to SignedProof,
+ * and calls proofModule.verifyProof() from @totemsdk/proof.
+ * Returns { valid: true } if ALL proofs pass; otherwise lists the failing proofIds.
+ */
+function verifyProofGraph(graph, _options) {
+    const invalidProofs = [];
+    for (const node of graph.nodes) {
+        if (node.type !== 'proof' || !node.data)
+            continue;
+        const signedProof = node.data;
+        const result = proofModule.verifyProof(signedProof);
+        if (!result.valid) {
+            invalidProofs.push(node.refId);
+        }
+    }
+    return {
+        valid: invalidProofs.length === 0,
+        invalidProofs,
+    };
+}
+/**
+ * Returns the list of invalid proof IDs in the graph.
+ * Equivalent to verifyProofGraph(graph).invalidProofs.
+ */
+function verifyGraphProofs(graph) {
+    return verifyProofGraph(graph).invalidProofs;
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@totemsdk/proofgraph",
+  "version": "0.1.0",
+  "description": "Local deterministic proof relationship graph for Totem Edge — indexes proofs, identities, manifests, and subjects into a queryable DAG",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@totemsdk/proof": "0.1.0",
+    "@totemsdk/core": "1.1.0",
+    "@totemsdk/manifest": "0.1.2",
+    "@totemsdk/identity": "0.1.2"
+  },
+  "peerDependencies": {
+    "@noble/hashes": "^2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@noble/hashes": {
+      "optional": false
+    }
+  },
+  "devDependencies": {
+    "@noble/hashes": "^2.2.0",
+    "@types/jest": "^29.0.0",
+    "@types/node": "^20.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "author": "Totem SDK",
+  "homepage": "https://totemsdk.com",
+  "keywords": [
+    "totem",
+    "totemsdk",
+    "minima",
+    "proof",
+    "graph",
+    "dag",
+    "identity"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "test": "jest --passWithNoTests"
+  }
+}