@aztec/merkle-tree 0.7.10 → 0.8.5

package/src/test/standard_based_test_suite.ts

@@ -1,142 +0,0 @@
-import { CircuitsWasm } from '@aztec/circuits.js';
-import { IWasmModule } from '@aztec/foundation/wasm';
-import { Hasher, SiblingPath } from '@aztec/types';
-
-import { randomBytes } from 'crypto';
-import { default as levelup } from 'levelup';
-
-import { INITIAL_LEAF, Pedersen } from '../index.js';
-import { AppendOnlyTree } from '../interfaces/append_only_tree.js';
-import { UpdateOnlyTree } from '../interfaces/update_only_tree.js';
-import { appendLeaves } from './utils/append_leaves.js';
-import { createMemDown } from './utils/create_mem_down.js';
-
-const TEST_TREE_DEPTH = 2;
-
-export const standardBasedTreeTestSuite = (
-  testName: string,
-  createDb: (
-    levelup: levelup.LevelUp,
-    hasher: Hasher,
-    name: string,
-    depth: number,
-  ) => Promise<AppendOnlyTree | UpdateOnlyTree>,
-) => {
-  describe(testName, () => {
-    let wasm: IWasmModule;
-    let pedersen: Pedersen;
-    const values: Buffer[] = [];
-
-    beforeAll(async () => {
-      wasm = await CircuitsWasm.get();
-      pedersen = new Pedersen(wasm);
-
-      for (let i = 0; i < 4; ++i) {
-        const v = Buffer.alloc(32, i + 1);
-        v.writeUInt32BE(i, 28);
-        values[i] = v;
-      }
-    });
-
-    it('should have correct empty tree root for depth 32', async () => {
-      const db = levelup(createMemDown());
-      const tree = await createDb(db, pedersen, 'test', 32);
-      const root = tree.getRoot(false);
-      expect(root.toString('hex')).toEqual('20efbe2c7b675f26ab71689279908bbab33a6963e7e0dcb80e4c46583d094113');
-    });
-
-    it('should throw when appending beyond max index', async () => {
-      const db = levelup(createMemDown());
-      const tree = await createDb(db, pedersen, 'test', 2);
-      const leaves = Array.from({ length: 5 }, _ => randomBytes(32));
-      await expect(appendLeaves(tree, leaves)).rejects.toThrow();
-    });
-
-    it('should have correct root and sibling paths', async () => {
-      const db = levelup(createMemDown());
-      const tree = await createDb(db, pedersen, 'test', 2);
-
-      const level1ZeroHash = pedersen.compress(INITIAL_LEAF, INITIAL_LEAF);
-      expect(tree.getNumLeaves(false)).toEqual(0n);
-      expect(tree.getRoot(false)).toEqual(pedersen.compress(level1ZeroHash, level1ZeroHash));
-      expect(await tree.getSiblingPath(0n, false)).toEqual(
-        new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level1ZeroHash]),
-      );
-
-      await appendLeaves(tree, [values[0]]);
-      expect(tree.getNumLeaves(true)).toEqual(1n);
-      expect(tree.getNumLeaves(false)).toEqual(0n);
-      expect(tree.getRoot(true)).toEqual(pedersen.compress(pedersen.compress(values[0], INITIAL_LEAF), level1ZeroHash));
-      expect(await tree.getSiblingPath(0n, true)).toEqual(
-        new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level1ZeroHash]),
-      );
-      expect(tree.getRoot(false)).toEqual(pedersen.compress(level1ZeroHash, level1ZeroHash));
-      expect(await tree.getSiblingPath(0n, false)).toEqual(
-        new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level1ZeroHash]),
-      );
-
-      await appendLeaves(tree, [values[1]]);
-      expect(tree.getNumLeaves(true)).toEqual(2n);
-      expect(tree.getRoot(true)).toEqual(pedersen.compress(pedersen.compress(values[0], values[1]), level1ZeroHash));
-      expect(await tree.getSiblingPath(1n, true)).toEqual(
-        new SiblingPath(TEST_TREE_DEPTH, [values[0], level1ZeroHash]),
-      );
-      expect(tree.getNumLeaves(false)).toEqual(0n);
-      expect(tree.getRoot(false)).toEqual(pedersen.compress(level1ZeroHash, level1ZeroHash));
-      expect(await tree.getSiblingPath(1n, false)).toEqual(
-        new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level1ZeroHash]),
-      );
-
-      await appendLeaves(tree, [values[2]]);
-      expect(tree.getNumLeaves(true)).toEqual(3n);
-      expect(tree.getRoot(true)).toEqual(
-        pedersen.compress(pedersen.compress(values[0], values[1]), pedersen.compress(values[2], INITIAL_LEAF)),
-      );
-      expect(await tree.getSiblingPath(2n, true)).toEqual(
-        new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, pedersen.compress(values[0], values[1])]),
-      );
-      expect(tree.getNumLeaves(false)).toEqual(0n);
-      expect(tree.getRoot(false)).toEqual(pedersen.compress(level1ZeroHash, level1ZeroHash));
-      expect(await tree.getSiblingPath(2n, false)).toEqual(
-        new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level1ZeroHash]),
-      );
-
-      await appendLeaves(tree, [values[3]]);
-      expect(tree.getNumLeaves(true)).toEqual(4n);
-      expect(tree.getRoot(true)).toEqual(
-        pedersen.compress(pedersen.compress(values[0], values[1]), pedersen.compress(values[2], values[3])),
-      );
-      expect(await tree.getSiblingPath(3n, true)).toEqual(
-        new SiblingPath(TEST_TREE_DEPTH, [values[2], pedersen.compress(values[0], values[1])]),
-      );
-      expect(tree.getNumLeaves(false)).toEqual(0n);
-      expect(tree.getRoot(false)).toEqual(pedersen.compress(level1ZeroHash, level1ZeroHash));
-      expect(await tree.getSiblingPath(3n, false)).toEqual(
-        new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level1ZeroHash]),
-      );
-      // Lifted from memory_tree.test.cpp to ensure consistency.
-      //expect(root.toString('hex')).toEqual('0bf2e78afd70f72b0e6eafb03c41faef167a82441b05e517cdf35d813302061f');
-      expect(await tree.getSiblingPath(0n, true)).toEqual(
-        new SiblingPath(TEST_TREE_DEPTH, [values[1], pedersen.compress(values[2], values[3])]),
-      );
-      expect(await tree.getSiblingPath(1n, true)).toEqual(
-        new SiblingPath(TEST_TREE_DEPTH, [values[0], pedersen.compress(values[2], values[3])]),
-      );
-      expect(await tree.getSiblingPath(2n, true)).toEqual(
-        new SiblingPath(TEST_TREE_DEPTH, [values[3], pedersen.compress(values[0], values[1])]),
-      );
-      expect(await tree.getSiblingPath(3n, true)).toEqual(
-        new SiblingPath(TEST_TREE_DEPTH, [values[2], pedersen.compress(values[0], values[1])]),
-      );
-
-      await tree.commit();
-      // now committed state should equal uncommitted state
-      expect(await tree.getSiblingPath(0n, false)).toEqual(await tree.getSiblingPath(0n, true));
-      expect(await tree.getSiblingPath(1n, false)).toEqual(await tree.getSiblingPath(1n, true));
-      expect(await tree.getSiblingPath(2n, false)).toEqual(await tree.getSiblingPath(2n, true));
-      expect(await tree.getSiblingPath(3n, false)).toEqual(await tree.getSiblingPath(3n, true));
-      expect(tree.getNumLeaves(false)).toEqual(tree.getNumLeaves(true));
-      expect(tree.getRoot(false)).toEqual(tree.getRoot(true));
-    });
-  });
-};

package/src/test/test_suite.ts

@@ -1,165 +0,0 @@
-import { CircuitsWasm } from '@aztec/circuits.js';
-import { IWasmModule } from '@aztec/foundation/wasm';
-import { Hasher, SiblingPath } from '@aztec/types';
-
-import { default as levelup } from 'levelup';
-
-import { Pedersen } from '../index.js';
-import { AppendOnlyTree } from '../interfaces/append_only_tree.js';
-import { UpdateOnlyTree } from '../interfaces/update_only_tree.js';
-import { appendLeaves } from './utils/append_leaves.js';
-import { createMemDown } from './utils/create_mem_down.js';
-
-const expectSameTrees = async (
-  tree1: AppendOnlyTree | UpdateOnlyTree,
-  tree2: AppendOnlyTree | UpdateOnlyTree,
-  includeUncommitted = true,
-) => {
-  const size = tree1.getNumLeaves(includeUncommitted);
-  expect(size).toBe(tree2.getNumLeaves(includeUncommitted));
-  expect(tree1.getRoot(includeUncommitted).toString('hex')).toBe(tree2.getRoot(includeUncommitted).toString('hex'));
-
-  for (let i = 0; i < size; ++i) {
-    const siblingPath1 = await tree1.getSiblingPath(BigInt(i), includeUncommitted);
-    const siblingPath2 = await tree2.getSiblingPath(BigInt(i), includeUncommitted);
-    expect(siblingPath2).toStrictEqual(siblingPath1);
-  }
-};
-
-export const treeTestSuite = (
-  testName: string,
-  createDb: (
-    levelup: levelup.LevelUp,
-    hasher: Hasher,
-    name: string,
-    depth: number,
-  ) => Promise<AppendOnlyTree | UpdateOnlyTree>,
-  createFromName: (levelup: levelup.LevelUp, hasher: Hasher, name: string) => Promise<AppendOnlyTree | UpdateOnlyTree>,
-) => {
-  describe(testName, () => {
-    const values: Buffer[] = [];
-    let wasm: IWasmModule;
-    let pedersen: Pedersen;
-
-    beforeAll(() => {
-      for (let i = 0; i < 32; ++i) {
-        const v = Buffer.alloc(32, i + 1);
-        v.writeUInt32BE(i, 28);
-        values[i] = v;
-      }
-    });
-
-    beforeEach(async () => {
-      wasm = await CircuitsWasm.get();
-      pedersen = new Pedersen(wasm);
-    });
-
-    it('should revert changes on rollback', async () => {
-      const levelDownEmpty = createMemDown();
-      const dbEmpty = levelup(levelDownEmpty);
-      const emptyTree = await createDb(dbEmpty, pedersen, 'test', 10);
-
-      const levelDown = createMemDown();
-      const db = levelup(levelDown);
-      const tree = await createDb(db, pedersen, 'test2', 10);
-      await appendLeaves(tree, values.slice(0, 4));
-
-      const firstRoot = tree.getRoot(true);
-      expect(firstRoot).not.toEqual(emptyTree.getRoot(true));
-      // committed root should still be the empty root
-      expect(tree.getRoot(false)).toEqual(emptyTree.getRoot(false));
-
-      await tree.rollback();
-
-      // both committed and uncommitted trees should be equal to the empty tree
-      await expectSameTrees(tree, emptyTree, true);
-      await expectSameTrees(tree, emptyTree, false);
-
-      // append the leaves again
-      await appendLeaves(tree, values.slice(0, 4));
-
-      expect(tree.getRoot(true)).toEqual(firstRoot);
-      // committed root should still be the empty root
-      expect(tree.getRoot(false)).toEqual(emptyTree.getRoot(false));
-
-      expect(firstRoot).not.toEqual(emptyTree.getRoot(true));
-
-      await tree.rollback();
-
-      // both committed and uncommitted trees should be equal to the empty tree
-      await expectSameTrees(tree, emptyTree, true);
-      await expectSameTrees(tree, emptyTree, false);
-    });
-
-    it('should not revert changes after commit', async () => {
-      const levelDownEmpty = createMemDown();
-      const dbEmpty = levelup(levelDownEmpty);
-      const emptyTree = await createDb(dbEmpty, pedersen, 'test', 10);
-
-      const levelDown = createMemDown();
-      const db = levelup(levelDown);
-      const tree = await createDb(db, pedersen, 'test2', 10);
-      await appendLeaves(tree, values.slice(0, 4));
-
-      expect(tree.getRoot(true)).not.toEqual(emptyTree.getRoot(true));
-      // committed root should still be the empty root
-      expect(tree.getRoot(false)).toEqual(emptyTree.getRoot(false));
-
-      await tree.commit();
-      await tree.rollback();
-
-      expect(tree.getRoot(true)).not.toEqual(emptyTree.getRoot(true));
-      expect(tree.getRoot(false)).not.toEqual(emptyTree.getRoot(true));
-    });
-
-    it('should be able to restore from previous committed data', async () => {
-      const levelDown = createMemDown();
-      const db = levelup(levelDown);
-      const tree = await createDb(db, pedersen, 'test', 10);
-      await appendLeaves(tree, values.slice(0, 4));
-      await tree.commit();
-
-      const db2 = levelup(levelDown);
-      const tree2 = await createFromName(db2, pedersen, 'test');
-
-      // both committed and uncommitted should be equal to the restored data
-      expect(tree.getRoot(true)).toEqual(tree2.getRoot(true));
-      expect(tree.getRoot(false)).toEqual(tree2.getRoot(false));
-      for (let i = 0; i < 4; ++i) {
-        expect(await tree.getSiblingPath(BigInt(i), true)).toEqual(await tree2.getSiblingPath(BigInt(i), true));
-        expect(await tree.getSiblingPath(BigInt(i), false)).toEqual(await tree2.getSiblingPath(BigInt(i), false));
-      }
-    });
-
-    it('should throw an error if previous data does not exist for the given name', async () => {
-      const db = levelup(createMemDown());
-      await expect(
-        (async () => {
-          await createFromName(db, pedersen, 'a_whole_new_tree');
-        })(),
-      ).rejects.toThrow();
-    });
-
-    it('should serialize sibling path data to a buffer and be able to deserialize it back', async () => {
-      const db = levelup(createMemDown());
-      const tree = await createDb(db, pedersen, 'test', 10);
-      await appendLeaves(tree, values.slice(0, 1));
-
-      const siblingPath = await tree.getSiblingPath(0n, true);
-      const buf = siblingPath.toBuffer();
-      const recovered = SiblingPath.fromBuffer(buf);
-      expect(recovered).toEqual(siblingPath);
-      const deserialized = SiblingPath.deserialize(buf);
-      expect(deserialized.elem).toEqual(siblingPath);
-      expect(deserialized.adv).toBe(4 + 10 * 32);
-
-      const dummyData = Buffer.alloc(23, 1);
-      const paddedBuf = Buffer.concat([dummyData, buf]);
-      const recovered2 = SiblingPath.fromBuffer(paddedBuf, 23);
-      expect(recovered2).toEqual(siblingPath);
-      const deserialized2 = SiblingPath.deserialize(buf);
-      expect(deserialized2.elem).toEqual(siblingPath);
-      expect(deserialized2.adv).toBe(4 + 10 * 32);
-    });
-  });
-};

package/src/test/utils/append_leaves.ts

@@ -1,15 +0,0 @@
-import { AppendOnlyTree } from '../../interfaces/append_only_tree.js';
-import { UpdateOnlyTree } from '../../interfaces/update_only_tree.js';
-
-export const appendLeaves = async (tree: AppendOnlyTree | UpdateOnlyTree, leaves: Buffer[]) => {
-  if ('appendLeaves' in tree) {
-    // This branch is used by the standard tree test suite, which implements appendLeaves
-    await tree.appendLeaves(leaves);
-  } else {
-    // This branch is used by the sparse tree test suite, which does not implement appendLeaves
-    for (const value of leaves) {
-      const index = tree.getNumLeaves(true);
-      await tree.updateLeaf(value, index);
-    }
-  }
-};

package/src/test/utils/create_mem_down.ts

@@ -1,3 +0,0 @@
-import { type MemDown, default as memdown } from 'memdown';
-
-export const createMemDown = () => (memdown as any)() as MemDown<any, any>;

package/src/test/utils/pedersen_with_counter.ts

@@ -1,30 +0,0 @@
-import { Pedersen } from '../../index.js';
-
-/**
- * A test utility allowing us to count the number of times the compress function has been called.
- */
-export class PedersenWithCounter extends Pedersen {
-  /**
-   * The number of times the compress function has been called.
-   */
-  public compressCounter = 0;
-
-  /**
-   * Compresses two 32-byte hashes.
-   * @param lhs - The first hash.
-   * @param rhs - The second hash.
-   * @returns The new 32-byte hash.
-   */
-  public compress(lhs: Uint8Array, rhs: Uint8Array): Buffer {
-    this.compressCounter++;
-    return super.compress(lhs, rhs);
-  }
-
-  /**
-   * Resets the compress counter.
-   * @returns void
-   */
-  public resetCounter() {
-    this.compressCounter = 0;
-  }
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "extends": "..",
-  "compilerOptions": {
-    "outDir": "dest",
-    "rootDir": "src",
-    "tsBuildInfoFile": ".tsbuildinfo"
-  },
-  "references": [
-    {
-      "path": "../circuits.js"
-    },
-    {
-      "path": "../foundation"
-    },
-    {
-      "path": "../types"
-    }
-  ],
-  "include": ["src"]
-}