@enbox/dwn-sdk-js 0.4.0 → 0.4.2

package/dist/types/src/smt/smt-utils.d.ts

@@ -1,58 +0,0 @@
-/**
- * Utility functions for the Sparse Merkle Tree.
- * Uses SHA-256 from multiformats (already a dependency of dwn-sdk-js).
- */
-import type { Hash } from '../types/smt-types.js';
-/** The tree depth — one level per bit of a SHA-256 hash. */
-export declare const SMT_DEPTH = 256;
-/** A constant zero hash (32 bytes of 0x00). */
-export declare const ZERO_HASH: Hash;
-export declare function getDefaultHashes(): Hash[];
-/**
- * Reset the cached default hashes. Only used by tests to verify the
- * uninitialized code path in `getDefaultHashes()`.
- * @internal
- */
-export declare function resetDefaultHashesForTesting(): void;
-/**
- * Initialize the default hashes array. Must be called once before using the SMT.
- * This is async because sha256.digest is async.
- */
-export declare function initDefaultHashes(): Promise<Hash[]>;
-/**
- * Hash two child hashes together: H(left || right).
- * Uses SHA-256 via multiformats.
- */
-export declare function hashChildren(left: Hash, right: Hash): Promise<Hash>;
-/**
- * Hash a leaf node: H(0x00 || keyHash || valueCid_bytes).
- * The 0x00 prefix distinguishes leaf hashes from internal node hashes,
- * preventing second-preimage attacks.
- */
-export declare function hashLeaf(keyHash: Hash, valueCid: string): Promise<Hash>;
-/**
- * Compute SHA-256 of a string (used to hash messageCid into the 256-bit key space).
- */
-export declare function hashKey(key: string): Promise<Hash>;
-/**
- * Extract the bit at a given depth from a 256-bit hash.
- * Depth 0 is the most significant bit of the first byte.
- *
- * @param hash - The 32-byte hash.
- * @param depth - The bit position (0 = MSB of byte 0, 255 = LSB of byte 31).
- * @returns `true` for 1 (right), `false` for 0 (left).
- */
-export declare function getBit(hash: Hash, depth: number): boolean;
-/**
- * Compare two hashes for equality.
- */
-export declare function hashEquals(a: Hash, b: Hash): boolean;
-/**
- * Convert a hash to a hex string for use as a store key.
- */
-export declare function hashToHex(hash: Hash): string;
-/**
- * Convert a hex string back to a Hash.
- */
-export declare function hexToHash(hex: string): Hash;
-//# sourceMappingURL=smt-utils.d.ts.map

package/dist/types/src/smt/smt-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"smt-utils.d.ts","sourceRoot":"","sources":["../../../../src/smt/smt-utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAIlD,4DAA4D;AAC5D,eAAO,MAAM,SAAS,MAAM,CAAC;AAE7B,+CAA+C;AAC/C,eAAO,MAAM,SAAS,EAAE,IAAyB,CAAC;AAalD,wBAAgB,gBAAgB,IAAI,IAAI,EAAE,CAQzC;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,IAAI,IAAI,CAEnD;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC,CAczD;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAOzE;AAED;;;;GAIG;AACH,wBAAsB,QAAQ,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAS7E;AAED;;GAEG;AACH,wBAAsB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIxD;AAED;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAIzD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,OAAO,CAUpD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAE5C;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAM3C"}

package/dist/types/src/smt/sparse-merkle-tree.d.ts

@@ -1,124 +0,0 @@
-/**
- * Sparse Merkle Tree (SMT) implementation.
- *
- * A 256-level binary trie where:
- * - Keys are SHA-256 hashes of messageCids (uniformly distributed across 2^256 key space)
- * - Leaves store the messageCid value
- * - Internal nodes store H(leftChild || rightChild)
- * - Empty subtrees are represented implicitly via precomputed default hashes
- *
- * Key properties:
- * - Deterministic: the same set of key-value pairs always produces the same root hash
- * - O(log n) insert, delete, and proof operations (practically O(256) worst case)
- * - Supports inclusion and non-inclusion proofs
- * - Root hash provides a fingerprint of the entire set for O(1) comparison
- */
-import type { Hash, SMTDiffResult, SMTNodeStore, SMTProof } from '../types/smt-types.js';
-export declare class SparseMerkleTree {
-    private readonly store;
-    private defaultHashes;
-    constructor(store: SMTNodeStore);
-    /**
-     * Initialize the SMT. Must be called before any operations.
-     * Opens the store and precomputes default hashes.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Close the underlying store.
-     */
-    close(): Promise<void>;
-    /**
-     * Clear all data from the tree.
-     */
-    clear(): Promise<void>;
-    /**
-     * Get the current root hash. Returns the default empty root if no root is set.
-     */
-    getRoot(): Promise<Hash>;
-    /**
-     * Insert a messageCid into the tree.
-     * The key is SHA-256(messageCid), the value is the messageCid string.
-     *
-     * @returns the new root hash after insertion
-     */
-    insert(messageCid: string): Promise<Hash>;
-    /**
-     * Delete a messageCid from the tree.
-     *
-     * @returns the new root hash after deletion
-     */
-    delete(messageCid: string): Promise<Hash>;
-    /**
-     * Check if a messageCid exists in the tree.
-     */
-    has(messageCid: string): Promise<boolean>;
-    /**
-     * Generate a membership proof (inclusion or non-inclusion) for a messageCid.
-     */
-    getProof(messageCid: string): Promise<SMTProof>;
-    /**
-     * Get the hash of a subtree at a given bit prefix.
-     * Used by the sync protocol for tree walking.
-     *
-     * @param prefix - array of booleans representing the path (false=left, true=right)
-     * @returns the hash of the subtree at that prefix
-     */
-    getSubtreeHash(prefix: boolean[]): Promise<Hash>;
-    /**
-     * Get all leaf messageCids under a given prefix.
-     * Used by the sync protocol for tree walking.
-     */
-    getLeaves(prefix: boolean[]): Promise<string[]>;
-    /**
-     * Compute a local diff between this tree and another tree's state,
-     * given access to the other tree instance.
-     *
-     * This is used for same-process diffing (e.g., in tests or local operations).
-     * For remote diffing, the sync protocol exchanges subtree hashes via messages.
-     */
-    diff(other: SparseMerkleTree): Promise<SMTDiffResult>;
-    /**
-     * Recursively insert a leaf into the tree, returning the new hash for the subtree at `depth`.
-     */
-    private insertAtNode;
-    /**
-     * When two leaves collide at the same position in the tree, push them down
-     * until their key paths diverge, creating internal nodes along the way.
-     *
-     * For example, if two leaves share the first 3 bits but diverge at bit 3,
-     * and we're currently at depth 0, we need to create internal nodes at depths
-     * 0, 1, and 2 (where one child is the chain and the other is a default hash),
-     * plus the divergence node at depth 3 where the two leaves split.
-     */
-    private splitLeaves;
-    /**
-     * Recursively delete a key from the tree, returning the new hash for the subtree at `depth`.
-     */
-    private deleteAtNode;
-    /**
-     * Check if a key exists at the given node.
-     */
-    private existsAtNode;
-    /**
-     * Generate a proof for the given key at the given node.
-     */
-    private generateProof;
-    /**
-     * Compute the subtree hash for a leaf that exists above the target prefix depth.
-     * The leaf's effective position is determined by its keyHash bits.
-     */
-    private computeSubtreeHashForLeaf;
-    /**
-     * Check if a leaf's keyHash matches a given prefix.
-     */
-    private leafMatchesPrefix;
-    /**
-     * Collect all leaf messageCids in the subtree rooted at the given hash.
-     */
-    private collectLeaves;
-    /**
-     * Recursively diff two subtrees, collecting leaves that exist only in one or the other.
-     */
-    private diffAtNode;
-}
-//# sourceMappingURL=sparse-merkle-tree.d.ts.map

package/dist/types/src/smt/sparse-merkle-tree.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sparse-merkle-tree.d.ts","sourceRoot":"","sources":["../../../../src/smt/sparse-merkle-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,EAAgC,YAAY,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAIvH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,aAAa,CAAU;gBAEnB,KAAK,EAAE,YAAY;IAI/B;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAKjC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ9B;;;;;OAKG;IACG,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB/C;;;;OAIG;IACG,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAU/C;;OAEG;IACG,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAM/C;;OAEG;IACG,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAMrD;;;;;;OAMG;IACG,cAAc,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAgCtD;;;OAGG;IACG,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAmCrD;;;;;;OAMG;IACG,IAAI,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,aAAa,CAAC;IAkB3D;;OAEG;YACW,YAAY;IAyE1B;;;;;;;;OAQG;YACW,WAAW;IAoEzB;;OAEG;YACW,YAAY;IA6E1B;;OAEG;YACW,YAAY;IA4B1B;;OAEG;YACW,aAAa;IAsC3B;;;OAGG;YACW,yBAAyB;IAiBvC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IASzB;;OAEG;YACW,aAAa;IAqB3B;;OAEG;YACW,UAAU;CA2GzB"}

package/dist/types/src/state-index/state-index-level.d.ts

@@ -1,83 +0,0 @@
-/**
- * LevelDB-backed implementation of the StateIndex interface.
- *
- * Manages per-tenant Sparse Merkle Trees (global + per-protocol sub-trees).
- *
- * All data lives within a single LevelDB instance, partitioned by sublevels:
- *   {tenant}/global/        -> SMT nodes + root for the tenant's global tree
- *   {tenant}/proto/{proto}/ -> SMT nodes + root for a protocol-scoped tree
- *   {tenant}/meta/{cid}     -> JSON(indexes) for reverse lookup during deletion
- */
-import type { Hash } from '../types/smt-types.js';
-import type { KeyValues } from '../types/query-types.js';
-import type { StateIndex } from '../types/state-index.js';
-import { createLevelDatabase } from '../store/level-wrapper.js';
-export type StateIndexLevelConfig = {
-    /**
-     * Must be a directory path (relative or absolute) where LevelDB will store its files,
-     * or in browsers, the name of the IDBDatabase to be opened.
-     */
-    location?: string;
-    createLevelDatabase?: typeof createLevelDatabase;
-};
-export declare class StateIndexLevel implements StateIndex {
-    private readonly config;
-    private db;
-    /**
-     * Cache of per-tenant global SMTs. Lazily populated on first access.
-     * Stores promises to avoid race conditions when multiple concurrent operations
-     * trigger lazy initialization of the same tenant's SMT.
-     */
-    private readonly globalTrees;
-    /**
-     * Cache of per-tenant, per-protocol SMTs. Key format: `{tenant}\x00{protocol}`
-     * Stores promises to avoid race conditions (same reason as globalTrees).
-     */
-    private readonly protocolTrees;
-    constructor(config?: StateIndexLevelConfig);
-    open(): Promise<void>;
-    close(): Promise<void>;
-    clear(): Promise<void>;
-    insert(tenant: string, messageCid: string, indexes: KeyValues): Promise<void>;
-    delete(tenant: string, messageCids: string[]): Promise<void>;
-    getRoot(tenant: string): Promise<Hash>;
-    getProtocolRoot(tenant: string, protocol: string): Promise<Hash>;
-    getSubtreeHash(tenant: string, prefix: boolean[]): Promise<Hash>;
-    getProtocolSubtreeHash(tenant: string, protocol: string, prefix: boolean[]): Promise<Hash>;
-    getLeaves(tenant: string, prefix: boolean[]): Promise<string[]>;
-    getProtocolLeaves(tenant: string, protocol: string, prefix: boolean[]): Promise<string[]>;
-    /**
-     * Get or create the global SMT for a tenant.
-     * Uses a promise-based cache to prevent concurrent callers from racing to
-     * initialize the same tenant's SMT twice.
-     */
-    private getGlobalTree;
-    /**
-     * Get or create a protocol-scoped SMT for a tenant.
-     * Uses a promise-based cache to prevent concurrent callers from racing to
-     * initialize the same tenant's SMT twice.
-     */
-    private getProtocolTree;
-    /**
-     * Create and initialize a new SparseMerkleTree backed by a sublevel chain
-     * within the single LevelDB instance.
-     */
-    private createTree;
-    /**
-     * Store the indexes for a messageCid so we can look up the protocol during deletion.
-     */
-    private storeIndexes;
-    /**
-     * Get the stored indexes for a messageCid.
-     */
-    private getStoredIndexes;
-    /**
-     * Delete the stored indexes for a messageCid.
-     */
-    private deleteStoredIndexes;
-    /**
-     * Get the metadata partition for a tenant.
-     */
-    private getMetaPartition;
-}
-//# sourceMappingURL=state-index-level.d.ts.map

package/dist/types/src/state-index/state-index-level.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"state-index-level.d.ts","sourceRoot":"","sources":["../../../../src/state-index/state-index-level.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAK1D,OAAO,EAAE,mBAAmB,EAAgB,MAAM,2BAA2B,CAAC;AAE9E,MAAM,MAAM,qBAAqB,GAAG;IAClC;;;OAGG;IACH,QAAQ,CAAC,EAAG,MAAM,CAAC;IACnB,mBAAmB,CAAC,EAAG,OAAO,mBAAmB,CAAC;CACnD,CAAC;AAEF,qBAAa,eAAgB,YAAW,UAAU;IAChD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwB;IAC/C,OAAO,CAAC,EAAE,CAAwB;IAElC;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqD;IAEjF;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqD;gBAEvE,MAAM,CAAC,EAAE,qBAAqB;IAQpC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAYrB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAOtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAOtB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB7E,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAwB5D,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKtC,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKhE,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAKhE,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAK1F,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAK/D,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAO/F;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAWrB;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAYvB;;;OAGG;YACW,UAAU;IAYxB;;OAEG;YACW,YAAY;IAO1B;;OAEG;YACW,gBAAgB;IAS9B;;OAEG;YACW,mBAAmB;IAKjC;;OAEG;YACW,gBAAgB;CAG/B"}

package/dist/types/src/types/smt-types.d.ts

@@ -1,81 +0,0 @@
-/**
- * Types for the Sparse Merkle Tree implementation.
- */
-/**
- * A 32-byte hash (SHA-256 output).
- */
-export type Hash = Uint8Array;
-/**
- * Represents the path through the tree as a sequence of bits derived from the key hash.
- * Each bit determines whether to go left (0) or right (1) at each depth level.
- */
-export type BitPath = boolean[];
-/**
- * A node in the Sparse Merkle Tree.
- *
- * - `internal`: has left and right child hashes but no leaf data
- * - `leaf`: has a key hash and value (the messageCid) but no children
- * - empty subtrees are represented implicitly via precomputed default hashes
- */
-export type SMTNode = SMTInternalNode | SMTLeafNode;
-export type SMTInternalNode = {
-    type: 'internal';
-    leftHash: Hash;
-    rightHash: Hash;
-};
-export type SMTLeafNode = {
-    type: 'leaf';
-    keyHash: Hash;
-    valueCid: string;
-};
-/**
- * An inclusion or non-inclusion proof for a key in the SMT.
- *
- * - `siblings`: the sibling hashes along the path from leaf to root
- * - `leafNode`: the leaf node at the path (undefined if non-inclusion proof for an empty slot)
- * - `depth`: the depth at which the proof terminates
- */
-export type SMTProof = {
-    siblings: Hash[];
-    leafNode: SMTLeafNode | undefined;
-    depth: number;
-};
-/**
- * Result of diffing two SMT roots.
- */
-export type SMTDiffResult = {
-    /** messageCids present in the local tree but not the remote tree */
-    onlyLocal: string[];
-    /** messageCids present in the remote tree but not the local tree */
-    onlyRemote: string[];
-};
-/**
- * Interface for persisting SMT nodes. Implementations can use LevelDB, SQL, or in-memory maps.
- * Nodes are keyed by their hash. The root hash is stored separately.
- */
-export interface SMTNodeStore {
-    open(): Promise<void>;
-    close(): Promise<void>;
-    clear(): Promise<void>;
-    /**
-     * Get a node by its hash. Returns undefined if not found.
-     */
-    getNode(hash: Hash): Promise<SMTNode | undefined>;
-    /**
-     * Store a node, keyed by its hash.
-     */
-    putNode(hash: Hash, node: SMTNode): Promise<void>;
-    /**
-     * Delete a node by its hash.
-     */
-    deleteNode(hash: Hash): Promise<void>;
-    /**
-     * Get the current root hash. Returns undefined if no root has been set.
-     */
-    getRoot(): Promise<Hash | undefined>;
-    /**
-     * Set the root hash.
-     */
-    setRoot(hash: Hash): Promise<void>;
-}
-//# sourceMappingURL=smt-types.d.ts.map

package/dist/types/src/types/smt-types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"smt-types.d.ts","sourceRoot":"","sources":["../../../../src/types/smt-types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,MAAM,IAAI,GAAG,UAAU,CAAC;AAE9B;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG,OAAO,EAAE,CAAC;AAEhC;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,GACf,eAAe,GACf,WAAW,CAAC;AAEhB,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAG,UAAU,CAAC;IAClB,QAAQ,EAAG,IAAI,CAAC;IAChB,SAAS,EAAG,IAAI,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAG,MAAM,CAAC;IACd,OAAO,EAAG,IAAI,CAAC;IACf,QAAQ,EAAG,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,EAAG,IAAI,EAAE,CAAC;IAClB,QAAQ,EAAG,WAAW,GAAG,SAAS,CAAC;IACnC,KAAK,EAAG,MAAM,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,oEAAoE;IACpE,SAAS,EAAG,MAAM,EAAE,CAAC;IACrB,oEAAoE;IACpE,UAAU,EAAG,MAAM,EAAE,CAAC;CACvB,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAAC;IAElD;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAElD;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtC;;OAEG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAAC;IAErC;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpC"}

package/dist/types/src/types/state-index.d.ts

@@ -1,90 +0,0 @@
-import type { Hash } from './smt-types.js';
-import type { KeyValues } from './query-types.js';
-/**
- * A Sparse Merkle Tree-backed state index that tracks the set of messageCids
- * for each tenant. Replaces the EventLog as the mechanism for sync state tracking.
- *
- * Key differences from EventLog:
- * - No watermark ordering — the SMT is a set, not a log
- * - Root hash provides O(1) "are we in sync?" comparison
- * - Supports subtree hashing for O(log n) set reconciliation
- * - Per-protocol sub-trees for scoped sync
- */
-export interface StateIndex {
-    /**
-     * Opens a connection to the underlying store.
-     */
-    open(): Promise<void>;
-    /**
-     * Closes the connection to the underlying store.
-     */
-    close(): Promise<void>;
-    /**
-     * Clears all data. Mainly used for cleaning up in test environments.
-     */
-    clear(): Promise<void>;
-    /**
-     * Insert a message into the state index.
-     *
-     * @param tenant - the tenant's DID
-     * @param messageCid - the CID of the message
-     * @param indexes - key-value pairs from the message (used to extract `protocol` for
-     *   per-protocol sub-tree maintenance, and stored for reverse lookup during deletion)
-     */
-    insert(tenant: string, messageCid: string, indexes: KeyValues): Promise<void>;
-    /**
-     * Delete messages from the state index.
-     *
-     * @param tenant - the tenant's DID
-     * @param messageCids - the CIDs of the messages to remove
-     */
-    delete(tenant: string, messageCids: string[]): Promise<void>;
-    /**
-     * Get the SMT root hash for a tenant's global state (all protocols).
-     *
-     * @param tenant - the tenant's DID
-     * @returns the root hash. Returns the default empty root if no messages exist.
-     */
-    getRoot(tenant: string): Promise<Hash>;
-    /**
-     * Get the SMT root hash for a specific protocol's state within a tenant.
-     *
-     * @param tenant - the tenant's DID
-     * @param protocol - the protocol URI
-     * @returns the root hash. Returns the default empty root if no messages exist for this protocol.
-     */
-    getProtocolRoot(tenant: string, protocol: string): Promise<Hash>;
-    /**
-     * Get the hash of a subtree at a given bit prefix within a tenant's global tree.
-     * Used by the sync protocol for tree walking during set reconciliation.
-     *
-     * @param tenant - the tenant's DID
-     * @param prefix - array of booleans representing the path (false=left, true=right)
-     */
-    getSubtreeHash(tenant: string, prefix: boolean[]): Promise<Hash>;
-    /**
-     * Get the hash of a subtree at a given bit prefix within a protocol-scoped tree.
-     *
-     * @param tenant - the tenant's DID
-     * @param protocol - the protocol URI
-     * @param prefix - array of booleans representing the path (false=left, true=right)
-     */
-    getProtocolSubtreeHash(tenant: string, protocol: string, prefix: boolean[]): Promise<Hash>;
-    /**
-     * Get all leaf messageCids under a given prefix in the tenant's global tree.
-     * Used by the sync protocol to enumerate leaves in a divergent subtree.
-     *
-     * @param tenant - the tenant's DID
-     * @param prefix - array of booleans representing the path
-     */
-    getLeaves(tenant: string, prefix: boolean[]): Promise<string[]>;
-    /**
-     * Get all leaf messageCids under a given prefix in a protocol-scoped tree.
-     *
-     * @param tenant - the tenant's DID
-     * @param protocol - the protocol URI
-     * @param prefix - array of booleans representing the path
-     */
-    getProtocolLeaves(tenant: string, protocol: string, prefix: boolean[]): Promise<string[]>;
-}
-//# sourceMappingURL=state-index.d.ts.map

package/dist/types/src/types/state-index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"state-index.d.ts","sourceRoot":"","sources":["../../../../src/types/state-index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtB;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;;;;;;OAOG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE9E;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE7D;;;;;OAKG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvC;;;;;;OAMG;IACH,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjE;;;;;;OAMG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjE;;;;;;OAMG;IACH,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3F;;;;;;OAMG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAEhE;;;;;;OAMG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CAC3F"}

package/dist/types/tests/event-emitter-event-log.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=event-emitter-event-log.spec.d.ts.map

package/dist/types/tests/event-emitter-event-log.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"event-emitter-event-log.spec.d.ts","sourceRoot":"","sources":["../../../tests/event-emitter-event-log.spec.ts"],"names":[],"mappings":""}

package/dist/types/tests/handlers/messages-sync.spec.d.ts

@@ -1,2 +0,0 @@
-export declare function testMessagesSyncHandler(): void;
-//# sourceMappingURL=messages-sync.spec.d.ts.map

package/dist/types/tests/handlers/messages-sync.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"messages-sync.spec.d.ts","sourceRoot":"","sources":["../../../../tests/handlers/messages-sync.spec.ts"],"names":[],"mappings":"AAoCA,wBAAgB,uBAAuB,IAAI,IAAI,CAwuC9C"}

package/dist/types/tests/smt/smt-store-level.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=smt-store-level.spec.d.ts.map

package/dist/types/tests/smt/smt-store-level.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"smt-store-level.spec.d.ts","sourceRoot":"","sources":["../../../../tests/smt/smt-store-level.spec.ts"],"names":[],"mappings":""}

package/dist/types/tests/smt/sparse-merkle-tree.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=sparse-merkle-tree.spec.d.ts.map

package/dist/types/tests/smt/sparse-merkle-tree.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sparse-merkle-tree.spec.d.ts","sourceRoot":"","sources":["../../../../tests/smt/sparse-merkle-tree.spec.ts"],"names":[],"mappings":""}

package/dist/types/tests/state-index/state-index-level.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=state-index-level.spec.d.ts.map

package/dist/types/tests/state-index/state-index-level.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"state-index-level.spec.d.ts","sourceRoot":"","sources":["../../../../tests/state-index/state-index-level.spec.ts"],"names":[],"mappings":""}

package/src/core/record-chain.ts

@@ -1,99 +0,0 @@
-import type { Filter } from '../types/query-types.js';
-import type { MessageStore } from '../types/message-store.js';
-import type { RecordsWriteMessage } from '../types/records-types.js';
-
-import { RecordsWrite } from '../interfaces/records-write.js';
-import { DwnError, DwnErrorCode } from './dwn-error.js';
-import { DwnInterfaceName, DwnMethodName } from '../enums/dwn-interface-method.js';
-
-/**
- * Fetches the initial RecordsWrite message associated with the given (tenant + recordId).
- */
-export async function fetchInitialWrite(
-  tenant: string,
-  recordId: string,
-  messageStore: MessageStore
-): Promise<RecordsWriteMessage | undefined> {
-
-  const query: Filter = {
-    interface : DwnInterfaceName.Records,
-    method    : DwnMethodName.Write,
-    recordId  : recordId
-  };
-  const { messages } = await messageStore.query(tenant, [query]);
-
-  if (messages.length === 0) {
-    return undefined;
-  }
-
-  const initialWrite = await RecordsWrite.getInitialWrite(messages);
-  return initialWrite;
-}
-
-/**
- * Constructs the chain of EXISTING records in the datastore where the first record is the root initial `RecordsWrite` of the record chain
- * and last record is the initial `RecordsWrite` of the descendant record specified.
- * @param descendantRecordId The ID of the descendent record to start constructing the record chain from by repeatedly looking up the parent.
- * @returns the record chain where each record is represented by its initial `RecordsWrite`;
- *          returns empty array if `descendantRecordId` is `undefined`.
- * @throws {DwnError} if `descendantRecordId` is defined but any initial `RecordsWrite` is not found in the chain of records.
- */
-export async function constructRecordChain(
-  tenant: string,
-  descendantRecordId: string | undefined,
-  messageStore: MessageStore
-): Promise<RecordsWriteMessage[]> {
-
-  if (descendantRecordId === undefined) {
-    return [];
-  }
-
-  const recordChain: RecordsWriteMessage[] = [];
-
-  // keep walking up the chain from the inbound message's parent, until there is no more parent
-  let currentRecordId: string | undefined = descendantRecordId;
-  while (currentRecordId !== undefined) {
-
-    const initialWrite = await fetchInitialWrite(tenant, currentRecordId, messageStore);
-
-    // RecordsWrite needed should be available since we perform necessary checks at the time of writes,
-    // eg. check the immediate parent in `verifyProtocolPathAndContextId` at the time of writing,
-    // so if this condition is triggered, it means there is an unexpected bug that caused an incomplete chain.
-    // We add additional defensive check here because returning an unexpected/incorrect record chain could lead to security vulnerabilities.
-    if (initialWrite === undefined) {
-      throw new DwnError(
-        DwnErrorCode.ProtocolAuthorizationParentNotFoundConstructingRecordChain,
-        `Unexpected error that should never trigger: no parent found with ID ${currentRecordId} when constructing record chain.`
-      );
-    }
-
-    recordChain.push(initialWrite);
-    currentRecordId = initialWrite.descriptor.parentId;
-  }
-
-  return recordChain.reverse(); // root record first
-}
-
-/**
- * Determines the timestamp that governs which protocol definition version applies to the given RecordsWrite.
- * For an update, this is the initial write's `messageTimestamp` (the protocol version is locked at creation time).
- * For a new initial write, returns `undefined` — the latest protocol definition should be used because the
- * record is being created now and must conform to the current protocol rules.
- */
-export async function getGoverningTimestamp(
-  tenant: string,
-  incomingMessage: RecordsWrite,
-  messageStore: MessageStore,
-): Promise<string | undefined> {
-  const existingInitialWrite = await fetchInitialWrite(
-    tenant, incomingMessage.message.recordId, messageStore
-  );
-
-  if (existingInitialWrite !== undefined) {
-    // update case: use the initial write's timestamp
-    return existingInitialWrite.descriptor.messageTimestamp;
-  }
-
-  // initial write case: validate against the latest protocol definition
-  return undefined;
-}