@enbox/dwn-sdk-js 0.0.2 → 0.0.4

package/dist/esm/tests/smt/sparse-merkle-tree.spec.js

@@ -0,0 +1,741 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { SMTStoreMemory } from '../../src/smt/smt-store-memory.js';
+import { SparseMerkleTree } from '../../src/smt/sparse-merkle-tree.js';
+import { getBit, getDefaultHashes, hashEquals, hashKey, hashLeaf, initDefaultHashes, resetDefaultHashesForTesting, SMT_DEPTH, ZERO_HASH } from '../../src/smt/smt-utils.js';
+describe('SparseMerkleTree', () => {
+    let store;
+    let smt;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        store = new SMTStoreMemory();
+        smt = new SparseMerkleTree(store);
+        yield smt.initialize();
+    }));
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        yield smt.close();
+    }));
+    describe('initialization', () => {
+        it('should return the default empty root for a new tree', () => __awaiter(void 0, void 0, void 0, function* () {
+            const root = yield smt.getRoot();
+            const defaultHashes = yield initDefaultHashes();
+            expect(hashEquals(root, defaultHashes[0])).toBe(true);
+        }));
+        it('should precompute default hashes for all 256 levels + leaf level', () => __awaiter(void 0, void 0, void 0, function* () {
+            const defaultHashes = yield initDefaultHashes();
+            expect(defaultHashes.length).toBe(SMT_DEPTH + 1);
+            // Leaf level should be zero hash
+            expect(hashEquals(defaultHashes[SMT_DEPTH], ZERO_HASH)).toBe(true);
+            // Each level should be different from its neighbor
+            for (let i = 0; i < SMT_DEPTH; i++) {
+                expect(hashEquals(defaultHashes[i], defaultHashes[i + 1])).toBe(false);
+            }
+        }));
+    });
+    describe('insert', () => {
+        it('should change the root hash after inserting a single element', () => __awaiter(void 0, void 0, void 0, function* () {
+            const emptyRoot = yield smt.getRoot();
+            yield smt.insert('bafyreigtest1');
+            const newRoot = yield smt.getRoot();
+            expect(hashEquals(emptyRoot, newRoot)).toBe(false);
+        }));
+        it('should produce different roots for different values', () => __awaiter(void 0, void 0, void 0, function* () {
+            const storeA = new SMTStoreMemory();
+            const smtA = new SparseMerkleTree(storeA);
+            yield smtA.initialize();
+            const storeB = new SMTStoreMemory();
+            const smtB = new SparseMerkleTree(storeB);
+            yield smtB.initialize();
+            yield smtA.insert('bafyreigaaa');
+            yield smtB.insert('bafyreigbbb');
+            const rootA = yield smtA.getRoot();
+            const rootB = yield smtB.getRoot();
+            expect(hashEquals(rootA, rootB)).toBe(false);
+            yield smtA.close();
+            yield smtB.close();
+        }));
+        it('should produce the same root regardless of insertion order', () => __awaiter(void 0, void 0, void 0, function* () {
+            const cids = ['bafyreiA', 'bafyreiB', 'bafyreiC', 'bafyreiD', 'bafyreiE'];
+            // Insert in forward order
+            const storeA = new SMTStoreMemory();
+            const smtA = new SparseMerkleTree(storeA);
+            yield smtA.initialize();
+            for (const cid of cids) {
+                yield smtA.insert(cid);
+            }
+            // Insert in reverse order
+            const storeB = new SMTStoreMemory();
+            const smtB = new SparseMerkleTree(storeB);
+            yield smtB.initialize();
+            for (const cid of [...cids].reverse()) {
+                yield smtB.insert(cid);
+            }
+            const rootA = yield smtA.getRoot();
+            const rootB = yield smtB.getRoot();
+            expect(hashEquals(rootA, rootB)).toBe(true);
+            yield smtA.close();
+            yield smtB.close();
+        }));
+        it('should handle inserting many elements', () => __awaiter(void 0, void 0, void 0, function* () {
+            const cids = [];
+            for (let i = 0; i < 100; i++) {
+                cids.push(`bafyreig-test-${i.toString().padStart(4, '0')}`);
+            }
+            for (const cid of cids) {
+                yield smt.insert(cid);
+            }
+            // Verify all exist
+            for (const cid of cids) {
+                expect(yield smt.has(cid)).toBe(true);
+            }
+        }));
+        it('should handle re-inserting the same value (idempotent for same key)', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield smt.insert('bafyreigtest1');
+            const rootAfterFirst = yield smt.getRoot();
+            yield smt.insert('bafyreigtest1');
+            const rootAfterSecond = yield smt.getRoot();
+            expect(hashEquals(rootAfterFirst, rootAfterSecond)).toBe(true);
+        }));
+    });
+    describe('has', () => {
+        it('should return false for an empty tree', () => __awaiter(void 0, void 0, void 0, function* () {
+            expect(yield smt.has('bafyreigtest1')).toBe(false);
+        }));
+        it('should return true for an inserted element', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield smt.insert('bafyreigtest1');
+            expect(yield smt.has('bafyreigtest1')).toBe(true);
+        }));
+        it('should return false for an element not in the tree', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield smt.insert('bafyreigtest1');
+            expect(yield smt.has('bafyreigtest2')).toBe(false);
+        }));
+        it('should return false after deletion', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield smt.insert('bafyreigtest1');
+            expect(yield smt.has('bafyreigtest1')).toBe(true);
+            yield smt.delete('bafyreigtest1');
+            expect(yield smt.has('bafyreigtest1')).toBe(false);
+        }));
+    });
+    describe('delete', () => {
+        it('should return to empty root after inserting and deleting a single element', () => __awaiter(void 0, void 0, void 0, function* () {
+            const emptyRoot = yield smt.getRoot();
+            yield smt.insert('bafyreigtest1');
+            const nonEmptyRoot = yield smt.getRoot();
+            expect(hashEquals(emptyRoot, nonEmptyRoot)).toBe(false);
+            yield smt.delete('bafyreigtest1');
+            const rootAfterDelete = yield smt.getRoot();
+            expect(hashEquals(emptyRoot, rootAfterDelete)).toBe(true);
+        }));
+        it('should not change the root when deleting a non-existent element', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield smt.insert('bafyreigtest1');
+            const rootBefore = yield smt.getRoot();
+            yield smt.delete('bafyreigtest2');
+            const rootAfter = yield smt.getRoot();
+            expect(hashEquals(rootBefore, rootAfter)).toBe(true);
+        }));
+        it('should produce the same root regardless of insert-delete order', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Insert A, B, C then delete B
+            const storeA = new SMTStoreMemory();
+            const smtA = new SparseMerkleTree(storeA);
+            yield smtA.initialize();
+            yield smtA.insert('bafyreiA');
+            yield smtA.insert('bafyreiB');
+            yield smtA.insert('bafyreiC');
+            yield smtA.delete('bafyreiB');
+            // Insert A, C only (never insert B)
+            const storeB = new SMTStoreMemory();
+            const smtB = new SparseMerkleTree(storeB);
+            yield smtB.initialize();
+            yield smtB.insert('bafyreiA');
+            yield smtB.insert('bafyreiC');
+            const rootA = yield smtA.getRoot();
+            const rootB = yield smtB.getRoot();
+            expect(hashEquals(rootA, rootB)).toBe(true);
+            yield smtA.close();
+            yield smtB.close();
+        }));
+        it('should handle deleting all elements to return to empty state', () => __awaiter(void 0, void 0, void 0, function* () {
+            const emptyRoot = yield smt.getRoot();
+            const cids = ['bafyreiA', 'bafyreiB', 'bafyreiC'];
+            for (const cid of cids) {
+                yield smt.insert(cid);
+            }
+            for (const cid of cids) {
+                yield smt.delete(cid);
+            }
+            const rootAfter = yield smt.getRoot();
+            expect(hashEquals(emptyRoot, rootAfter)).toBe(true);
+        }));
+        it('should handle interleaved inserts and deletes', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield smt.insert('bafyreiA');
+            yield smt.insert('bafyreiB');
+            yield smt.delete('bafyreiA');
+            yield smt.insert('bafyreiC');
+            yield smt.delete('bafyreiB');
+            yield smt.insert('bafyreiD');
+            // Should have C and D
+            expect(yield smt.has('bafyreiA')).toBe(false);
+            expect(yield smt.has('bafyreiB')).toBe(false);
+            expect(yield smt.has('bafyreiC')).toBe(true);
+            expect(yield smt.has('bafyreiD')).toBe(true);
+        }));
+    });
+    describe('proof', () => {
+        it('should generate a proof for an existing element (inclusion)', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield smt.insert('bafyreigtest1');
+            const proof = yield smt.getProof('bafyreigtest1');
+            expect(proof.leafNode).toBeDefined();
+            expect(proof.leafNode.valueCid).toBe('bafyreigtest1');
+            expect(proof.leafNode.type).toBe('leaf');
+        }));
+        it('should generate a proof for a non-existent element (non-inclusion)', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield smt.insert('bafyreigtest1');
+            const proof = yield smt.getProof('bafyreigtest2');
+            // Either the leaf is undefined (empty slot) or it's a different key
+            if (proof.leafNode !== undefined) {
+                // The proof terminates at a leaf with a different key
+                const expectedKeyHash = yield hashKey('bafyreigtest2');
+                expect(hashEquals(proof.leafNode.keyHash, expectedKeyHash)).toBe(false);
+            }
+        }));
+        it('should generate an empty proof for an empty tree', () => __awaiter(void 0, void 0, void 0, function* () {
+            const proof = yield smt.getProof('bafyreigtest1');
+            expect(proof.leafNode).toBeUndefined();
+            expect(proof.siblings.length).toBe(0);
+        }));
+    });
+    describe('getSubtreeHash', () => {
+        it('should return default hash for empty subtree', () => __awaiter(void 0, void 0, void 0, function* () {
+            const defaultHashes = yield initDefaultHashes();
+            const subtreeHash = yield smt.getSubtreeHash([false]); // left child of root
+            expect(hashEquals(subtreeHash, defaultHashes[1])).toBe(true);
+        }));
+        it('should return different hashes for subtrees with different contents', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield smt.insert('bafyreigtest1');
+            yield smt.insert('bafyreigtest2');
+            const leftHash = yield smt.getSubtreeHash([false]);
+            const rightHash = yield smt.getSubtreeHash([true]);
+            // At least one should be non-default (elements distributed by hash)
+            const defaultHashes = yield initDefaultHashes();
+            const leftIsDefault = hashEquals(leftHash, defaultHashes[1]);
+            const rightIsDefault = hashEquals(rightHash, defaultHashes[1]);
+            expect(leftIsDefault && rightIsDefault).toBe(false);
+        }));
+    });
+    describe('getLeaves', () => {
+        it('should return empty array for empty tree', () => __awaiter(void 0, void 0, void 0, function* () {
+            const leaves = yield smt.getLeaves([]);
+            expect(leaves).toEqual([]);
+        }));
+        it('should return all leaves for empty prefix', () => __awaiter(void 0, void 0, void 0, function* () {
+            const cids = ['bafyreiA', 'bafyreiB', 'bafyreiC'];
+            for (const cid of cids) {
+                yield smt.insert(cid);
+            }
+            const leaves = yield smt.getLeaves([]);
+            expect(leaves.sort()).toEqual([...cids].sort());
+        }));
+        it('should return only leaves under the specified prefix', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Insert multiple elements and verify prefix filtering works
+            const cids = [];
+            for (let i = 0; i < 20; i++) {
+                cids.push(`bafyreig-prefix-test-${i}`);
+            }
+            for (const cid of cids) {
+                yield smt.insert(cid);
+            }
+            // Get leaves under left and right subtrees
+            const leftLeaves = yield smt.getLeaves([false]);
+            const rightLeaves = yield smt.getLeaves([true]);
+            // Together they should contain all CIDs
+            const allLeaves = [...leftLeaves, ...rightLeaves].sort();
+            expect(allLeaves).toEqual([...cids].sort());
+            // Neither should be empty (with 20 random-ish hashes, both sides should have elements)
+            // (This is probabilistic but 20 elements should reliably split)
+            expect(leftLeaves.length).toBeGreaterThan(0);
+            expect(rightLeaves.length).toBeGreaterThan(0);
+        }));
+    });
+    describe('diff', () => {
+        it('should return empty diff for identical trees', () => __awaiter(void 0, void 0, void 0, function* () {
+            const storeB = new SMTStoreMemory();
+            const smtB = new SparseMerkleTree(storeB);
+            yield smtB.initialize();
+            const cids = ['bafyreiA', 'bafyreiB', 'bafyreiC'];
+            for (const cid of cids) {
+                yield smt.insert(cid);
+                yield smtB.insert(cid);
+            }
+            const diff = yield smt.diff(smtB);
+            expect(diff.onlyLocal).toEqual([]);
+            expect(diff.onlyRemote).toEqual([]);
+            yield smtB.close();
+        }));
+        it('should return empty diff for two empty trees', () => __awaiter(void 0, void 0, void 0, function* () {
+            const storeB = new SMTStoreMemory();
+            const smtB = new SparseMerkleTree(storeB);
+            yield smtB.initialize();
+            const diff = yield smt.diff(smtB);
+            expect(diff.onlyLocal).toEqual([]);
+            expect(diff.onlyRemote).toEqual([]);
+            yield smtB.close();
+        }));
+        it('should detect elements only in the local tree', () => __awaiter(void 0, void 0, void 0, function* () {
+            const storeB = new SMTStoreMemory();
+            const smtB = new SparseMerkleTree(storeB);
+            yield smtB.initialize();
+            yield smt.insert('bafyreiA');
+            yield smt.insert('bafyreiB');
+            yield smtB.insert('bafyreiA');
+            const diff = yield smt.diff(smtB);
+            expect(diff.onlyLocal.sort()).toEqual(['bafyreiB']);
+            expect(diff.onlyRemote).toEqual([]);
+            yield smtB.close();
+        }));
+        it('should detect elements only in the remote tree', () => __awaiter(void 0, void 0, void 0, function* () {
+            const storeB = new SMTStoreMemory();
+            const smtB = new SparseMerkleTree(storeB);
+            yield smtB.initialize();
+            yield smt.insert('bafyreiA');
+            yield smtB.insert('bafyreiA');
+            yield smtB.insert('bafyreiB');
+            const diff = yield smt.diff(smtB);
+            expect(diff.onlyLocal).toEqual([]);
+            expect(diff.onlyRemote.sort()).toEqual(['bafyreiB']);
+            yield smtB.close();
+        }));
+        it('should detect elements unique to each tree', () => __awaiter(void 0, void 0, void 0, function* () {
+            const storeB = new SMTStoreMemory();
+            const smtB = new SparseMerkleTree(storeB);
+            yield smtB.initialize();
+            // Shared
+            yield smt.insert('bafyreiShared1');
+            yield smtB.insert('bafyreiShared1');
+            yield smt.insert('bafyreiShared2');
+            yield smtB.insert('bafyreiShared2');
+            // Only local
+            yield smt.insert('bafyreiLocalOnly1');
+            yield smt.insert('bafyreiLocalOnly2');
+            // Only remote
+            yield smtB.insert('bafyreiRemoteOnly1');
+            yield smtB.insert('bafyreiRemoteOnly2');
+            yield smtB.insert('bafyreiRemoteOnly3');
+            const diff = yield smt.diff(smtB);
+            expect(diff.onlyLocal.sort()).toEqual(['bafyreiLocalOnly1', 'bafyreiLocalOnly2'].sort());
+            expect(diff.onlyRemote.sort()).toEqual(['bafyreiRemoteOnly1', 'bafyreiRemoteOnly2', 'bafyreiRemoteOnly3'].sort());
+            yield smtB.close();
+        }));
+        it('should detect all differences when trees are completely disjoint', () => __awaiter(void 0, void 0, void 0, function* () {
+            const storeB = new SMTStoreMemory();
+            const smtB = new SparseMerkleTree(storeB);
+            yield smtB.initialize();
+            yield smt.insert('bafyreiA');
+            yield smt.insert('bafyreiB');
+            yield smtB.insert('bafyreiC');
+            yield smtB.insert('bafyreiD');
+            const diff = yield smt.diff(smtB);
+            expect(diff.onlyLocal.sort()).toEqual(['bafyreiA', 'bafyreiB'].sort());
+            expect(diff.onlyRemote.sort()).toEqual(['bafyreiC', 'bafyreiD'].sort());
+            yield smtB.close();
+        }));
+        it('should detect differences in larger trees efficiently', () => __awaiter(void 0, void 0, void 0, function* () {
+            const storeB = new SMTStoreMemory();
+            const smtB = new SparseMerkleTree(storeB);
+            yield smtB.initialize();
+            // Both trees share 50 elements
+            for (let i = 0; i < 50; i++) {
+                const cid = `bafyreig-shared-${i.toString().padStart(3, '0')}`;
+                yield smt.insert(cid);
+                yield smtB.insert(cid);
+            }
+            // Local has 5 unique elements
+            const localOnly = [];
+            for (let i = 0; i < 5; i++) {
+                const cid = `bafyreig-local-${i}`;
+                yield smt.insert(cid);
+                localOnly.push(cid);
+            }
+            // Remote has 3 unique elements
+            const remoteOnly = [];
+            for (let i = 0; i < 3; i++) {
+                const cid = `bafyreig-remote-${i}`;
+                yield smtB.insert(cid);
+                remoteOnly.push(cid);
+            }
+            const diff = yield smt.diff(smtB);
+            expect(diff.onlyLocal.sort()).toEqual(localOnly.sort());
+            expect(diff.onlyRemote.sort()).toEqual(remoteOnly.sort());
+            yield smtB.close();
+        }));
+        it('should handle diff where local tree is empty', () => __awaiter(void 0, void 0, void 0, function* () {
+            const storeB = new SMTStoreMemory();
+            const smtB = new SparseMerkleTree(storeB);
+            yield smtB.initialize();
+            yield smtB.insert('bafyreiA');
+            yield smtB.insert('bafyreiB');
+            const diff = yield smt.diff(smtB);
+            expect(diff.onlyLocal).toEqual([]);
+            expect(diff.onlyRemote.sort()).toEqual(['bafyreiA', 'bafyreiB'].sort());
+            yield smtB.close();
+        }));
+        it('should handle diff where remote tree is empty', () => __awaiter(void 0, void 0, void 0, function* () {
+            const storeB = new SMTStoreMemory();
+            const smtB = new SparseMerkleTree(storeB);
+            yield smtB.initialize();
+            yield smt.insert('bafyreiA');
+            yield smt.insert('bafyreiB');
+            const diff = yield smt.diff(smtB);
+            expect(diff.onlyLocal.sort()).toEqual(['bafyreiA', 'bafyreiB'].sort());
+            expect(diff.onlyRemote).toEqual([]);
+            yield smtB.close();
+        }));
+    });
+    describe('clear', () => {
+        it('should reset the tree to empty state', () => __awaiter(void 0, void 0, void 0, function* () {
+            const emptyRoot = yield smt.getRoot();
+            yield smt.insert('bafyreiA');
+            yield smt.insert('bafyreiB');
+            yield smt.clear();
+            const rootAfterClear = yield smt.getRoot();
+            expect(hashEquals(emptyRoot, rootAfterClear)).toBe(true);
+            expect(yield smt.has('bafyreiA')).toBe(false);
+            expect(yield smt.has('bafyreiB')).toBe(false);
+        }));
+    });
+    describe('getSubtreeHash with leaf at shallow depth', () => {
+        it('should return leaf hash when leaf matches the prefix', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Insert a single element — the tree stores it as a leaf near the root
+            yield smt.insert('bafyreiA');
+            const keyHash = yield hashKey('bafyreiA');
+            // Build a deep prefix that follows the leaf's keyHash bits
+            const matchingPrefix = [];
+            for (let i = 0; i < 8; i++) {
+                matchingPrefix.push(getBit(keyHash, i));
+            }
+            const subtreeHash = yield smt.getSubtreeHash(matchingPrefix);
+            // Should be the leaf hash (non-default) since the leaf is under this prefix
+            const expectedLeafHash = yield hashLeaf(keyHash, 'bafyreiA');
+            expect(hashEquals(subtreeHash, expectedLeafHash)).toBe(true);
+        }));
+        it('should return default hash when leaf does not match the prefix', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield smt.insert('bafyreiA');
+            const keyHash = yield hashKey('bafyreiA');
+            const defaultHashes = yield initDefaultHashes();
+            // Build a prefix that diverges from the leaf's keyHash at bit 0
+            const firstBit = getBit(keyHash, 0);
+            const nonMatchingPrefix = [!firstBit]; // opposite of the first bit
+            const subtreeHash = yield smt.getSubtreeHash(nonMatchingPrefix);
+            expect(hashEquals(subtreeHash, defaultHashes[1])).toBe(true);
+        }));
+    });
+    describe('getLeaves with leaf at shallow depth', () => {
+        it('should return the leaf CID when leaf matches the prefix', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield smt.insert('bafyreiA');
+            const keyHash = yield hashKey('bafyreiA');
+            // Build a prefix that matches the leaf's keyHash bits
+            const matchingPrefix = [];
+            for (let i = 0; i < 4; i++) {
+                matchingPrefix.push(getBit(keyHash, i));
+            }
+            const leaves = yield smt.getLeaves(matchingPrefix);
+            expect(leaves).toEqual(['bafyreiA']);
+        }));
+        it('should return empty when leaf does not match the prefix', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield smt.insert('bafyreiA');
+            const keyHash = yield hashKey('bafyreiA');
+            // Build a prefix that diverges from the leaf's keyHash
+            const firstBit = getBit(keyHash, 0);
+            const nonMatchingPrefix = [!firstBit];
+            const leaves = yield smt.getLeaves(nonMatchingPrefix);
+            expect(leaves).toEqual([]);
+        }));
+    });
+    describe('proof', () => {
+        it('should generate a multi-level proof with sibling hashes', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Insert two elements so the tree has internal nodes
+            yield smt.insert('bafyreiA');
+            yield smt.insert('bafyreiB');
+            const proof = yield smt.getProof('bafyreiA');
+            expect(proof.leafNode).toBeDefined();
+            expect(proof.leafNode.valueCid).toBe('bafyreiA');
+            // With two elements, there should be at least one sibling hash
+            expect(proof.siblings.length).toBeGreaterThan(0);
+        }));
+        it('should return empty proof when store node is missing (corrupted store)', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Test lines 503-505 of sparse-merkle-tree.ts: getNode returns undefined
+            const realStore = new SMTStoreMemory();
+            let corruptDuringProof = false;
+            const corruptStore = {
+                open: () => realStore.open(),
+                close: () => realStore.close(),
+                clear: () => realStore.clear(),
+                getRoot: () => realStore.getRoot(),
+                setRoot: (hash) => realStore.setRoot(hash),
+                putNode: (hash, node) => realStore.putNode(hash, node),
+                deleteNode: (hash) => realStore.deleteNode(hash),
+                getNode: (hash) => __awaiter(void 0, void 0, void 0, function* () {
+                    if (corruptDuringProof) {
+                        return undefined;
+                    }
+                    return realStore.getNode(hash);
+                }),
+            };
+            const corruptSmt = new SparseMerkleTree(corruptStore);
+            yield corruptSmt.initialize();
+            yield corruptSmt.insert('bafyreiProofCorrupt');
+            // Now corrupt the store so getNode returns undefined during proof generation
+            corruptDuringProof = true;
+            const proof = yield corruptSmt.getProof('bafyreiProofCorrupt');
+            // Should return a proof without a leaf node since the node is missing
+            expect(proof.leafNode).toBeUndefined();
+            expect(proof.siblings).toHaveLength(0);
+            corruptDuringProof = false;
+            yield corruptSmt.close();
+        }));
+    });
+    describe('diff edge cases', () => {
+        it('should detect local leaf not present in remote subtree', () => __awaiter(void 0, void 0, void 0, function* () {
+            // We need a scenario where local has a single leaf at a node while remote
+            // has an internal subtree at the same position, and the local leaf is NOT
+            // in the remote set. This happens when:
+            //   - Remote has 2+ elements that share a prefix
+            //   - Local has 1 element with the same prefix but a different CID
+            const storeB = new SMTStoreMemory();
+            const smtB = new SparseMerkleTree(storeB);
+            yield smtB.initialize();
+            // Insert many elements into both trees so they develop deep structure
+            const sharedCids = [];
+            for (let i = 0; i < 30; i++) {
+                const cid = `bafyreig-shared-${i}`;
+                sharedCids.push(cid);
+                yield smt.insert(cid);
+                yield smtB.insert(cid);
+            }
+            // Add unique elements to each side
+            const localOnly = 'bafyreig-local-unique-42';
+            yield smt.insert(localOnly);
+            const remoteOnly = 'bafyreig-remote-unique-99';
+            yield smtB.insert(remoteOnly);
+            const diff = yield smt.diff(smtB);
+            expect(diff.onlyLocal).toContain(localOnly);
+            expect(diff.onlyRemote).toContain(remoteOnly);
+            yield smtB.close();
+        }));
+        it('should detect both-are-leaves diff when each tree has one unique element', () => __awaiter(void 0, void 0, void 0, function* () {
+            // When each tree has exactly one element, the root IS a leaf hash.
+            // diffAtNode at depth 0 encounters two leaf nodes → hits lines 632-643.
+            const storeB = new SMTStoreMemory();
+            const smtB = new SparseMerkleTree(storeB);
+            yield smtB.initialize();
+            // Each tree has exactly one unique element (different keys → line 633-636)
+            yield smt.insert('bafyreiOnlyInLocal');
+            yield smtB.insert('bafyreiOnlyInRemote');
+            const diff = yield smt.diff(smtB);
+            expect(diff.onlyLocal).toEqual(['bafyreiOnlyInLocal']);
+            expect(diff.onlyRemote).toEqual(['bafyreiOnlyInRemote']);
+            yield smtB.close();
+        }));
+        it('should detect both-are-leaves diff with same key but different value', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Test lines 637-640: same keyHash, different valueCid.
+            // Since keyHash = hash(valueCid), this can't happen organically.
+            // We simulate it by directly placing leaf nodes in the store.
+            const storeA = new SMTStoreMemory();
+            const smtA = new SparseMerkleTree(storeA);
+            yield smtA.initialize();
+            const storeB = new SMTStoreMemory();
+            const smtB = new SparseMerkleTree(storeB);
+            yield smtB.initialize();
+            // Insert the same CID into both, then manually alter one tree's leaf to have a different valueCid
+            // but the same keyHash, by manipulating the store directly.
+            const sharedKeyHash = yield hashKey('bafyreiSharedKey');
+            const leafHashA = yield hashLeaf(sharedKeyHash, 'valueCidA');
+            const leafNodeA = { type: 'leaf', keyHash: sharedKeyHash, valueCid: 'valueCidA' };
+            yield storeA.putNode(leafHashA, leafNodeA);
+            yield storeA.setRoot(leafHashA);
+            const leafHashB = yield hashLeaf(sharedKeyHash, 'valueCidB');
+            const leafNodeB = { type: 'leaf', keyHash: sharedKeyHash, valueCid: 'valueCidB' };
+            yield storeB.putNode(leafHashB, leafNodeB);
+            yield storeB.setRoot(leafHashB);
+            const diff = yield smtA.diff(smtB);
+            // Same key, different value → both appear as unique
+            expect(diff.onlyLocal).toEqual(['valueCidA']);
+            expect(diff.onlyRemote).toEqual(['valueCidB']);
+            yield smtA.close();
+            yield smtB.close();
+        }));
+        it('should handle diff with selectively corrupted nodes via fallback', () => __awaiter(void 0, void 0, void 0, function* () {
+            // To hit lines 687-696, we need both trees to have internal root nodes
+            // (so the recursion goes through line 682-684 into children), and then
+            // at the child level, one node is missing (getNode returns undefined).
+            const realStore = new SMTStoreMemory();
+            let corruptDuringDiff = false;
+            let lookupCount = 0;
+            const corruptStore = {
+                open: () => realStore.open(),
+                close: () => realStore.close(),
+                clear: () => realStore.clear(),
+                getRoot: () => realStore.getRoot(),
+                setRoot: (hash) => realStore.setRoot(hash),
+                putNode: (hash, node) => realStore.putNode(hash, node),
+                deleteNode: (hash) => realStore.deleteNode(hash),
+                getNode: (hash) => __awaiter(void 0, void 0, void 0, function* () {
+                    if (corruptDuringDiff) {
+                        lookupCount++;
+                        // Return the root node (first lookup) but corrupt child nodes
+                        if (lookupCount > 1) {
+                            return undefined;
+                        }
+                    }
+                    return realStore.getNode(hash);
+                }),
+            };
+            // Build the corrupt tree with multiple elements (so root = internal node)
+            const corruptSmt = new SparseMerkleTree(corruptStore);
+            yield corruptSmt.initialize();
+            yield corruptSmt.insert('bafyreiCorrupt1');
+            yield corruptSmt.insert('bafyreiCorrupt2');
+            yield corruptSmt.insert('bafyreiCorrupt3');
+            // Build normal tree with multiple elements (so root = internal node too)
+            const normalStore = new SMTStoreMemory();
+            const normalSmt = new SparseMerkleTree(normalStore);
+            yield normalSmt.initialize();
+            yield normalSmt.insert('bafyreiNormal1');
+            yield normalSmt.insert('bafyreiNormal2');
+            yield normalSmt.insert('bafyreiNormal3');
+            // Corrupt the store so child nodes are missing during diff
+            corruptDuringDiff = true;
+            lookupCount = 0;
+            const diff = yield normalSmt.diff(corruptSmt);
+            // The diff should still complete — fallback collects leaves from the other side
+            // Normal tree's elements should be in onlyLocal
+            expect(diff.onlyLocal.sort()).toEqual(['bafyreiNormal1', 'bafyreiNormal2', 'bafyreiNormal3'].sort());
+            corruptDuringDiff = false;
+            yield corruptSmt.close();
+            yield normalSmt.close();
+        }));
+        it('should handle diff where local node is missing but remote exists', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Test lines 689-692: localNode is undefined while remoteNode exists.
+            // Both trees need non-default hashes at the SAME child position so the
+            // recursion reaches line 628 (both load nodes). We achieve this by sharing
+            // elements so both trees have populated subtrees at the same positions.
+            const realStore = new SMTStoreMemory();
+            let corruptDuringDiff = false;
+            let lookupCount = 0;
+            const corruptStore = {
+                open: () => realStore.open(),
+                close: () => realStore.close(),
+                clear: () => realStore.clear(),
+                getRoot: () => realStore.getRoot(),
+                setRoot: (hash) => realStore.setRoot(hash),
+                putNode: (hash, node) => realStore.putNode(hash, node),
+                deleteNode: (hash) => realStore.deleteNode(hash),
+                getNode: (hash) => __awaiter(void 0, void 0, void 0, function* () {
+                    if (corruptDuringDiff) {
+                        lookupCount++;
+                        // Return the root internal node (first lookup) but corrupt children
+                        if (lookupCount > 1) {
+                            return undefined;
+                        }
+                    }
+                    return realStore.getNode(hash);
+                }),
+            };
+            // Build corrupt tree (local) with shared + unique elements
+            const corruptSmt = new SparseMerkleTree(corruptStore);
+            yield corruptSmt.initialize();
+            // Add many shared elements so both subtrees (left/right) are populated
+            for (let i = 0; i < 20; i++) {
+                yield corruptSmt.insert(`bafyreiShared-${i}`);
+            }
+            yield corruptSmt.insert('bafyreiCorruptOnly');
+            // Build normal tree (remote) with the same shared elements + different unique
+            const normalStore = new SMTStoreMemory();
+            const normalSmt = new SparseMerkleTree(normalStore);
+            yield normalSmt.initialize();
+            for (let i = 0; i < 20; i++) {
+                yield normalSmt.insert(`bafyreiShared-${i}`);
+            }
+            yield normalSmt.insert('bafyreiNormalOnly');
+            // corruptSmt is local, normalSmt is remote
+            // The roots differ (different unique elements), both are internal nodes,
+            // and both have non-default children at the same positions (shared elements).
+            // When diffAtNode recurses into children, localNode will be undefined (corrupt)
+            // while remoteNode will be a real internal/leaf node → hits lines 689-692.
+            corruptDuringDiff = true;
+            lookupCount = 0;
+            const diff = yield corruptSmt.diff(normalSmt);
+            // The diff should complete. Remote leaves should appear in onlyRemote
+            // since the corrupt local can't prove they exist locally.
+            expect(diff.onlyRemote.length).toBeGreaterThan(0);
+            corruptDuringDiff = false;
+            yield corruptSmt.close();
+            yield normalSmt.close();
+        }));
+    });
+    describe('node storage efficiency', () => {
+        it('should clean up internal nodes after deletion collapses the tree', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield smt.insert('bafyreiA');
+            yield smt.insert('bafyreiB');
+            const sizeAfterInserts = store.size;
+            yield smt.delete('bafyreiA');
+            yield smt.delete('bafyreiB');
+            const sizeAfterDeletes = store.size;
+            // After deleting everything, the store should have fewer nodes than after inserts
+            expect(sizeAfterDeletes).toBeLessThan(sizeAfterInserts);
+        }));
+    });
+});
+describe('SMT Utility Functions', () => {
+    describe('getDefaultHashes', () => {
+        it('should return default hashes after initialization', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield initDefaultHashes();
+            const hashes = getDefaultHashes();
+            expect(hashes).toHaveLength(SMT_DEPTH + 1);
+            expect(hashEquals(hashes[SMT_DEPTH], ZERO_HASH)).toBe(true);
+        }));
+        it('should throw when called before initDefaultHashes()', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Reset the module-level cache
+            resetDefaultHashesForTesting();
+            try {
+                getDefaultHashes();
+                throw new Error('Expected an error');
+            }
+            catch (e) {
+                expect(e.message).toContain('Default hashes not initialized');
+            }
+            // Re-initialize so subsequent tests aren't affected
+            yield initDefaultHashes();
+        }));
+    });
+    describe('hashEquals', () => {
+        it('should return false for hashes of different lengths', () => {
+            const a = new Uint8Array(32);
+            const b = new Uint8Array(16);
+            expect(hashEquals(a, b)).toBe(false);
+        });
+    });
+    describe('hashKey', () => {
+        it('should produce consistent hashes for the same input', () => __awaiter(void 0, void 0, void 0, function* () {
+            const hash1 = yield hashKey('bafyreigtest');
+            const hash2 = yield hashKey('bafyreigtest');
+            expect(hashEquals(hash1, hash2)).toBe(true);
+        }));
+        it('should produce different hashes for different inputs', () => __awaiter(void 0, void 0, void 0, function* () {
+            const hash1 = yield hashKey('bafyreigtest1');
+            const hash2 = yield hashKey('bafyreigtest2');
+            expect(hashEquals(hash1, hash2)).toBe(false);
+        }));
+        it('should produce 32-byte hashes', () => __awaiter(void 0, void 0, void 0, function* () {
+            const hash = yield hashKey('bafyreigtest');
+            expect(hash.length).toBe(32);
+        }));
+    });
+});
+//# sourceMappingURL=sparse-merkle-tree.spec.js.map