@enbox/dwn-sdk-js 0.0.6 → 0.0.8

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

@@ -1,12 +1,3 @@
-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';
@@ -14,22 +5,22 @@ import { getBit, getDefaultHashes, hashEquals, hashKey, hashLeaf, initDefaultHas
 describe('SparseMerkleTree', () => {
     let store;
     let smt;
-    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+    beforeEach(async () => {
         store = new SMTStoreMemory();
         smt = new SparseMerkleTree(store);
-        yield smt.initialize();
-    }));
-    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
-        yield smt.close();
-    }));
+        await smt.initialize();
+    });
+    afterEach(async () => {
+        await 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();
+        it('should return the default empty root for a new tree', async () => {
+            const root = await smt.getRoot();
+            const defaultHashes = await 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();
+        });
+        it('should precompute default hashes for all 256 levels + leaf level', async () => {
+            const defaultHashes = await initDefaultHashes();
             expect(defaultHashes.length).toBe(SMT_DEPTH + 1);
             // Leaf level should be zero hash
             expect(hashEquals(defaultHashes[SMT_DEPTH], ZERO_HASH)).toBe(true);
@@ -37,223 +28,223 @@ describe('SparseMerkleTree', () => {
             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();
+        it('should change the root hash after inserting a single element', async () => {
+            const emptyRoot = await smt.getRoot();
+            await smt.insert('bafyreigtest1');
+            const newRoot = await smt.getRoot();
             expect(hashEquals(emptyRoot, newRoot)).toBe(false);
-        }));
-        it('should produce different roots for different values', () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        it('should produce different roots for different values', async () => {
             const storeA = new SMTStoreMemory();
             const smtA = new SparseMerkleTree(storeA);
-            yield smtA.initialize();
+            await 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();
+            await smtB.initialize();
+            await smtA.insert('bafyreigaaa');
+            await smtB.insert('bafyreigbbb');
+            const rootA = await smtA.getRoot();
+            const rootB = await 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* () {
+            await smtA.close();
+            await smtB.close();
+        });
+        it('should produce the same root regardless of insertion order', async () => {
             const cids = ['bafyreiA', 'bafyreiB', 'bafyreiC', 'bafyreiD', 'bafyreiE'];
             // Insert in forward order
             const storeA = new SMTStoreMemory();
             const smtA = new SparseMerkleTree(storeA);
-            yield smtA.initialize();
+            await smtA.initialize();
             for (const cid of cids) {
-                yield smtA.insert(cid);
+                await smtA.insert(cid);
             }
             // Insert in reverse order
             const storeB = new SMTStoreMemory();
             const smtB = new SparseMerkleTree(storeB);
-            yield smtB.initialize();
+            await smtB.initialize();
             for (const cid of [...cids].reverse()) {
-                yield smtB.insert(cid);
+                await smtB.insert(cid);
             }
-            const rootA = yield smtA.getRoot();
-            const rootB = yield smtB.getRoot();
+            const rootA = await smtA.getRoot();
+            const rootB = await 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* () {
+            await smtA.close();
+            await smtB.close();
+        });
+        it('should handle inserting many elements', async () => {
             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);
+                await smt.insert(cid);
             }
             // Verify all exist
             for (const cid of cids) {
-                expect(yield smt.has(cid)).toBe(true);
+                expect(await 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();
+        });
+        it('should handle re-inserting the same value (idempotent for same key)', async () => {
+            await smt.insert('bafyreigtest1');
+            const rootAfterFirst = await smt.getRoot();
+            await smt.insert('bafyreigtest1');
+            const rootAfterSecond = await 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);
-        }));
+        it('should return false for an empty tree', async () => {
+            expect(await smt.has('bafyreigtest1')).toBe(false);
+        });
+        it('should return true for an inserted element', async () => {
+            await smt.insert('bafyreigtest1');
+            expect(await smt.has('bafyreigtest1')).toBe(true);
+        });
+        it('should return false for an element not in the tree', async () => {
+            await smt.insert('bafyreigtest1');
+            expect(await smt.has('bafyreigtest2')).toBe(false);
+        });
+        it('should return false after deletion', async () => {
+            await smt.insert('bafyreigtest1');
+            expect(await smt.has('bafyreigtest1')).toBe(true);
+            await smt.delete('bafyreigtest1');
+            expect(await 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();
+        it('should return to empty root after inserting and deleting a single element', async () => {
+            const emptyRoot = await smt.getRoot();
+            await smt.insert('bafyreigtest1');
+            const nonEmptyRoot = await smt.getRoot();
             expect(hashEquals(emptyRoot, nonEmptyRoot)).toBe(false);
-            yield smt.delete('bafyreigtest1');
-            const rootAfterDelete = yield smt.getRoot();
+            await smt.delete('bafyreigtest1');
+            const rootAfterDelete = await 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();
+        });
+        it('should not change the root when deleting a non-existent element', async () => {
+            await smt.insert('bafyreigtest1');
+            const rootBefore = await smt.getRoot();
+            await smt.delete('bafyreigtest2');
+            const rootAfter = await 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* () {
+        });
+        it('should produce the same root regardless of insert-delete order', async () => {
             // 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');
+            await smtA.initialize();
+            await smtA.insert('bafyreiA');
+            await smtA.insert('bafyreiB');
+            await smtA.insert('bafyreiC');
+            await 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();
+            await smtB.initialize();
+            await smtB.insert('bafyreiA');
+            await smtB.insert('bafyreiC');
+            const rootA = await smtA.getRoot();
+            const rootB = await 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();
+            await smtA.close();
+            await smtB.close();
+        });
+        it('should handle deleting all elements to return to empty state', async () => {
+            const emptyRoot = await smt.getRoot();
             const cids = ['bafyreiA', 'bafyreiB', 'bafyreiC'];
             for (const cid of cids) {
-                yield smt.insert(cid);
+                await smt.insert(cid);
             }
             for (const cid of cids) {
-                yield smt.delete(cid);
+                await smt.delete(cid);
             }
-            const rootAfter = yield smt.getRoot();
+            const rootAfter = await 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');
+        });
+        it('should handle interleaved inserts and deletes', async () => {
+            await smt.insert('bafyreiA');
+            await smt.insert('bafyreiB');
+            await smt.delete('bafyreiA');
+            await smt.insert('bafyreiC');
+            await smt.delete('bafyreiB');
+            await 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);
-        }));
+            expect(await smt.has('bafyreiA')).toBe(false);
+            expect(await smt.has('bafyreiB')).toBe(false);
+            expect(await smt.has('bafyreiC')).toBe(true);
+            expect(await 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');
+        it('should generate a proof for an existing element (inclusion)', async () => {
+            await smt.insert('bafyreigtest1');
+            const proof = await 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');
+        });
+        it('should generate a proof for a non-existent element (non-inclusion)', async () => {
+            await smt.insert('bafyreigtest1');
+            const proof = await 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');
+                const expectedKeyHash = await 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');
+        });
+        it('should generate an empty proof for an empty tree', async () => {
+            const proof = await 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
+        it('should return default hash for empty subtree', async () => {
+            const defaultHashes = await initDefaultHashes();
+            const subtreeHash = await 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]);
+        });
+        it('should return different hashes for subtrees with different contents', async () => {
+            await smt.insert('bafyreigtest1');
+            await smt.insert('bafyreigtest2');
+            const leftHash = await smt.getSubtreeHash([false]);
+            const rightHash = await smt.getSubtreeHash([true]);
             // At least one should be non-default (elements distributed by hash)
-            const defaultHashes = yield initDefaultHashes();
+            const defaultHashes = await 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([]);
+        it('should return empty array for empty tree', async () => {
+            const leaves = await smt.getLeaves([]);
             expect(leaves).toEqual([]);
-        }));
-        it('should return all leaves for empty prefix', () => __awaiter(void 0, void 0, void 0, function* () {
+        });
+        it('should return all leaves for empty prefix', async () => {
             const cids = ['bafyreiA', 'bafyreiB', 'bafyreiC'];
             for (const cid of cids) {
-                yield smt.insert(cid);
+                await smt.insert(cid);
             }
-            const leaves = yield smt.getLeaves([]);
+            const leaves = await 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* () {
+        });
+        it('should return only leaves under the specified prefix', async () => {
             // 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);
+                await smt.insert(cid);
             }
             // Get leaves under left and right subtrees
-            const leftLeaves = yield smt.getLeaves([false]);
-            const rightLeaves = yield smt.getLeaves([true]);
+            const leftLeaves = await smt.getLeaves([false]);
+            const rightLeaves = await smt.getLeaves([true]);
             // Together they should contain all CIDs
             const allLeaves = [...leftLeaves, ...rightLeaves].sort();
             expect(allLeaves).toEqual([...cids].sort());
@@ -261,214 +252,214 @@ describe('SparseMerkleTree', () => {
             // (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* () {
+        it('should return empty diff for identical trees', async () => {
             const storeB = new SMTStoreMemory();
             const smtB = new SparseMerkleTree(storeB);
-            yield smtB.initialize();
+            await smtB.initialize();
             const cids = ['bafyreiA', 'bafyreiB', 'bafyreiC'];
             for (const cid of cids) {
-                yield smt.insert(cid);
-                yield smtB.insert(cid);
+                await smt.insert(cid);
+                await smtB.insert(cid);
             }
-            const diff = yield smt.diff(smtB);
+            const diff = await 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* () {
+            await smtB.close();
+        });
+        it('should return empty diff for two empty trees', async () => {
             const storeB = new SMTStoreMemory();
             const smtB = new SparseMerkleTree(storeB);
-            yield smtB.initialize();
-            const diff = yield smt.diff(smtB);
+            await smtB.initialize();
+            const diff = await 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* () {
+            await smtB.close();
+        });
+        it('should detect elements only in the local tree', async () => {
             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);
+            await smtB.initialize();
+            await smt.insert('bafyreiA');
+            await smt.insert('bafyreiB');
+            await smtB.insert('bafyreiA');
+            const diff = await 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* () {
+            await smtB.close();
+        });
+        it('should detect elements only in the remote tree', async () => {
             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);
+            await smtB.initialize();
+            await smt.insert('bafyreiA');
+            await smtB.insert('bafyreiA');
+            await smtB.insert('bafyreiB');
+            const diff = await 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* () {
+            await smtB.close();
+        });
+        it('should detect elements unique to each tree', async () => {
             const storeB = new SMTStoreMemory();
             const smtB = new SparseMerkleTree(storeB);
-            yield smtB.initialize();
+            await smtB.initialize();
             // Shared
-            yield smt.insert('bafyreiShared1');
-            yield smtB.insert('bafyreiShared1');
-            yield smt.insert('bafyreiShared2');
-            yield smtB.insert('bafyreiShared2');
+            await smt.insert('bafyreiShared1');
+            await smtB.insert('bafyreiShared1');
+            await smt.insert('bafyreiShared2');
+            await smtB.insert('bafyreiShared2');
             // Only local
-            yield smt.insert('bafyreiLocalOnly1');
-            yield smt.insert('bafyreiLocalOnly2');
+            await smt.insert('bafyreiLocalOnly1');
+            await smt.insert('bafyreiLocalOnly2');
             // Only remote
-            yield smtB.insert('bafyreiRemoteOnly1');
-            yield smtB.insert('bafyreiRemoteOnly2');
-            yield smtB.insert('bafyreiRemoteOnly3');
-            const diff = yield smt.diff(smtB);
+            await smtB.insert('bafyreiRemoteOnly1');
+            await smtB.insert('bafyreiRemoteOnly2');
+            await smtB.insert('bafyreiRemoteOnly3');
+            const diff = await 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* () {
+            await smtB.close();
+        });
+        it('should detect all differences when trees are completely disjoint', async () => {
             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);
+            await smtB.initialize();
+            await smt.insert('bafyreiA');
+            await smt.insert('bafyreiB');
+            await smtB.insert('bafyreiC');
+            await smtB.insert('bafyreiD');
+            const diff = await 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* () {
+            await smtB.close();
+        });
+        it('should detect differences in larger trees efficiently', async () => {
             const storeB = new SMTStoreMemory();
             const smtB = new SparseMerkleTree(storeB);
-            yield smtB.initialize();
+            await 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);
+                await smt.insert(cid);
+                await 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);
+                await 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);
+                await smtB.insert(cid);
                 remoteOnly.push(cid);
             }
-            const diff = yield smt.diff(smtB);
+            const diff = await 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* () {
+            await smtB.close();
+        });
+        it('should handle diff where local tree is empty', async () => {
             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);
+            await smtB.initialize();
+            await smtB.insert('bafyreiA');
+            await smtB.insert('bafyreiB');
+            const diff = await 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* () {
+            await smtB.close();
+        });
+        it('should handle diff where remote tree is empty', async () => {
             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);
+            await smtB.initialize();
+            await smt.insert('bafyreiA');
+            await smt.insert('bafyreiB');
+            const diff = await smt.diff(smtB);
             expect(diff.onlyLocal.sort()).toEqual(['bafyreiA', 'bafyreiB'].sort());
             expect(diff.onlyRemote).toEqual([]);
-            yield smtB.close();
-        }));
+            await 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();
+        it('should reset the tree to empty state', async () => {
+            const emptyRoot = await smt.getRoot();
+            await smt.insert('bafyreiA');
+            await smt.insert('bafyreiB');
+            await smt.clear();
+            const rootAfterClear = await smt.getRoot();
             expect(hashEquals(emptyRoot, rootAfterClear)).toBe(true);
-            expect(yield smt.has('bafyreiA')).toBe(false);
-            expect(yield smt.has('bafyreiB')).toBe(false);
-        }));
+            expect(await smt.has('bafyreiA')).toBe(false);
+            expect(await 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* () {
+        it('should return leaf hash when leaf matches the prefix', async () => {
             // Insert a single element — the tree stores it as a leaf near the root
-            yield smt.insert('bafyreiA');
-            const keyHash = yield hashKey('bafyreiA');
+            await smt.insert('bafyreiA');
+            const keyHash = await 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);
+            const subtreeHash = await smt.getSubtreeHash(matchingPrefix);
             // Should be the leaf hash (non-default) since the leaf is under this prefix
-            const expectedLeafHash = yield hashLeaf(keyHash, 'bafyreiA');
+            const expectedLeafHash = await 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();
+        });
+        it('should return default hash when leaf does not match the prefix', async () => {
+            await smt.insert('bafyreiA');
+            const keyHash = await hashKey('bafyreiA');
+            const defaultHashes = await 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);
+            const subtreeHash = await 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');
+        it('should return the leaf CID when leaf matches the prefix', async () => {
+            await smt.insert('bafyreiA');
+            const keyHash = await 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);
+            const leaves = await 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');
+        });
+        it('should return empty when leaf does not match the prefix', async () => {
+            await smt.insert('bafyreiA');
+            const keyHash = await 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);
+            const leaves = await 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* () {
+        it('should generate a multi-level proof with sibling hashes', async () => {
             // Insert two elements so the tree has internal nodes
-            yield smt.insert('bafyreiA');
-            yield smt.insert('bafyreiB');
-            const proof = yield smt.getProof('bafyreiA');
+            await smt.insert('bafyreiA');
+            await smt.insert('bafyreiB');
+            const proof = await 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* () {
+        });
+        it('should return empty proof when store node is missing (corrupted store)', async () => {
             // Test lines 503-505 of sparse-merkle-tree.ts: getNode returns undefined
             const realStore = new SMTStoreMemory();
             let corruptDuringProof = false;
@@ -480,28 +471,28 @@ describe('SparseMerkleTree', () => {
                 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* () {
+                getNode: async (hash) => {
                     if (corruptDuringProof) {
                         return undefined;
                     }
                     return realStore.getNode(hash);
-                }),
+                },
             };
             const corruptSmt = new SparseMerkleTree(corruptStore);
-            yield corruptSmt.initialize();
-            yield corruptSmt.insert('bafyreiProofCorrupt');
+            await corruptSmt.initialize();
+            await corruptSmt.insert('bafyreiProofCorrupt');
             // Now corrupt the store so getNode returns undefined during proof generation
             corruptDuringProof = true;
-            const proof = yield corruptSmt.getProof('bafyreiProofCorrupt');
+            const proof = await 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();
-        }));
+            await corruptSmt.close();
+        });
     });
     describe('diff edge cases', () => {
-        it('should detect local leaf not present in remote subtree', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should detect local leaf not present in remote subtree', async () => {
             // 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:
@@ -509,68 +500,68 @@ describe('SparseMerkleTree', () => {
             //   - Local has 1 element with the same prefix but a different CID
             const storeB = new SMTStoreMemory();
             const smtB = new SparseMerkleTree(storeB);
-            yield smtB.initialize();
+            await 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);
+                await smt.insert(cid);
+                await smtB.insert(cid);
             }
             // Add unique elements to each side
             const localOnly = 'bafyreig-local-unique-42';
-            yield smt.insert(localOnly);
+            await smt.insert(localOnly);
             const remoteOnly = 'bafyreig-remote-unique-99';
-            yield smtB.insert(remoteOnly);
-            const diff = yield smt.diff(smtB);
+            await smtB.insert(remoteOnly);
+            const diff = await 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* () {
+            await smtB.close();
+        });
+        it('should detect both-are-leaves diff when each tree has one unique element', async () => {
             // 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();
+            await 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);
+            await smt.insert('bafyreiOnlyInLocal');
+            await smtB.insert('bafyreiOnlyInRemote');
+            const diff = await 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* () {
+            await smtB.close();
+        });
+        it('should detect both-are-leaves diff with same key but different value', async () => {
             // 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();
+            await smtA.initialize();
             const storeB = new SMTStoreMemory();
             const smtB = new SparseMerkleTree(storeB);
-            yield smtB.initialize();
+            await 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 sharedKeyHash = await hashKey('bafyreiSharedKey');
+            const leafHashA = await 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');
+            await storeA.putNode(leafHashA, leafNodeA);
+            await storeA.setRoot(leafHashA);
+            const leafHashB = await 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);
+            await storeB.putNode(leafHashB, leafNodeB);
+            await storeB.setRoot(leafHashB);
+            const diff = await 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* () {
+            await smtA.close();
+            await smtB.close();
+        });
+        it('should handle diff with selectively corrupted nodes via fallback', async () => {
             // 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).
@@ -585,7 +576,7 @@ describe('SparseMerkleTree', () => {
                 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* () {
+                getNode: async (hash) => {
                     if (corruptDuringDiff) {
                         lookupCount++;
                         // Return the root node (first lookup) but corrupt child nodes
@@ -594,33 +585,33 @@ describe('SparseMerkleTree', () => {
                         }
                     }
                     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');
+            await corruptSmt.initialize();
+            await corruptSmt.insert('bafyreiCorrupt1');
+            await corruptSmt.insert('bafyreiCorrupt2');
+            await 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');
+            await normalSmt.initialize();
+            await normalSmt.insert('bafyreiNormal1');
+            await normalSmt.insert('bafyreiNormal2');
+            await normalSmt.insert('bafyreiNormal3');
             // Corrupt the store so child nodes are missing during diff
             corruptDuringDiff = true;
             lookupCount = 0;
-            const diff = yield normalSmt.diff(corruptSmt);
+            const diff = await 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* () {
+            await corruptSmt.close();
+            await normalSmt.close();
+        });
+        it('should handle diff where local node is missing but remote exists', async () => {
             // 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
@@ -636,7 +627,7 @@ describe('SparseMerkleTree', () => {
                 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* () {
+                getNode: async (hash) => {
                     if (corruptDuringDiff) {
                         lookupCount++;
                         // Return the root internal node (first lookup) but corrupt children
@@ -645,24 +636,24 @@ describe('SparseMerkleTree', () => {
                         }
                     }
                     return realStore.getNode(hash);
-                }),
+                },
             };
             // Build corrupt tree (local) with shared + unique elements
             const corruptSmt = new SparseMerkleTree(corruptStore);
-            yield corruptSmt.initialize();
+            await 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}`);
+                await corruptSmt.insert(`bafyreiShared-${i}`);
             }
-            yield corruptSmt.insert('bafyreiCorruptOnly');
+            await 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();
+            await normalSmt.initialize();
             for (let i = 0; i < 20; i++) {
-                yield normalSmt.insert(`bafyreiShared-${i}`);
+                await normalSmt.insert(`bafyreiShared-${i}`);
             }
-            yield normalSmt.insert('bafyreiNormalOnly');
+            await 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).
@@ -670,37 +661,37 @@ describe('SparseMerkleTree', () => {
             // while remoteNode will be a real internal/leaf node → hits lines 689-692.
             corruptDuringDiff = true;
             lookupCount = 0;
-            const diff = yield corruptSmt.diff(normalSmt);
+            const diff = await 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();
-        }));
+            await corruptSmt.close();
+            await 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');
+        it('should clean up internal nodes after deletion collapses the tree', async () => {
+            await smt.insert('bafyreiA');
+            await smt.insert('bafyreiB');
             const sizeAfterInserts = store.size;
-            yield smt.delete('bafyreiA');
-            yield smt.delete('bafyreiB');
+            await smt.delete('bafyreiA');
+            await 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();
+        it('should return default hashes after initialization', async () => {
+            await 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* () {
+        });
+        it('should throw when called before initDefaultHashes()', async () => {
             // Reset the module-level cache
             resetDefaultHashesForTesting();
             try {
@@ -711,8 +702,8 @@ describe('SMT Utility Functions', () => {
                 expect(e.message).toContain('Default hashes not initialized');
             }
             // Re-initialize so subsequent tests aren't affected
-            yield initDefaultHashes();
-        }));
+            await initDefaultHashes();
+        });
     });
     describe('hashEquals', () => {
         it('should return false for hashes of different lengths', () => {
@@ -722,20 +713,20 @@ describe('SMT Utility Functions', () => {
         });
     });
     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');
+        it('should produce consistent hashes for the same input', async () => {
+            const hash1 = await hashKey('bafyreigtest');
+            const hash2 = await 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');
+        });
+        it('should produce different hashes for different inputs', async () => {
+            const hash1 = await hashKey('bafyreigtest1');
+            const hash2 = await 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');
+        });
+        it('should produce 32-byte hashes', async () => {
+            const hash = await hashKey('bafyreigtest');
             expect(hash.length).toBe(32);
-        }));
+        });
     });
 });
 //# sourceMappingURL=sparse-merkle-tree.spec.js.map