@aztec/stdlib 0.82.2 → 0.82.3-nightly.20250403

package/src/tests/factories.ts

@@ -44,7 +44,7 @@ import {
 import { type FieldsOf, makeHalfFullTuple, makeTuple } from '@aztec/foundation/array';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { compact } from '@aztec/foundation/collection';
-import { SchnorrSignature, poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { SchnorrSignature, poseidon2HashWithSeparator, sha256 } from '@aztec/foundation/crypto';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
 import type { Bufferable } from '@aztec/foundation/serialize';
@@ -55,7 +55,6 @@ import { ContractStorageRead } from '../avm/contract_storage_read.js';
 import { ContractStorageUpdateRequest } from '../avm/contract_storage_update_request.js';
 import {
   AvmAccumulatedData,
-  AvmAppendTreeHint,
   AvmBytecodeCommitmentHint,
   AvmCircuitInputs,
   AvmCircuitPublicInputs,
@@ -63,10 +62,13 @@ import {
   AvmContractInstanceHint,
   AvmEnqueuedCallHint,
   AvmExecutionHints,
-  AvmNullifierReadTreeHint,
-  AvmNullifierWriteTreeHint,
-  AvmPublicDataReadTreeHint,
-  AvmPublicDataWriteTreeHint,
+  AvmGetLeafPreimageHintNullifierTree,
+  AvmGetLeafPreimageHintPublicDataTree,
+  AvmGetLeafValueHint,
+  AvmGetPreviousValueIndexHint,
+  AvmGetSiblingPathHint,
+  AvmSequentialInsertHintNullifierTree,
+  AvmSequentialInsertHintPublicDataTree,
   RevertCode,
 } from '../avm/index.js';
 import { PublicDataHint } from '../avm/public_data_hint.js';
@@ -144,7 +146,8 @@ import { PublicTubeData } from '../rollup/public_tube_data.js';
 import { RootRollupInputs, RootRollupPublicInputs } from '../rollup/root_rollup.js';
 import { PrivateBaseStateDiffHints } from '../rollup/state_diff_hints.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import { NullifierLeafPreimage } from '../trees/nullifier_leaf.js';
+import { MerkleTreeId } from '../trees/merkle_tree_id.js';
+import { NullifierLeaf, NullifierLeafPreimage } from '../trees/nullifier_leaf.js';
 import { PublicDataTreeLeaf, PublicDataTreeLeafPreimage } from '../trees/public_data_leaf.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { CallContext } from '../tx/call_context.js';
@@ -990,13 +993,31 @@ export function makePublicDataTreeLeaf(seed = 0): PublicDataTreeLeaf {
   return new PublicDataTreeLeaf(new Fr(seed), new Fr(seed + 1));
 }
 
+/**
+ * Makes arbitrary nullifier leaf.
+ * @param seed - The seed to use for generating the nullifier leaf.
+ * @returns A nullifier leaf.
+ */
+export function makeNullifierLeaf(seed = 0): NullifierLeaf {
+  return new NullifierLeaf(new Fr(seed));
+}
+
+/**
+ * Makes arbitrary nullifier leaf preimages.
+ * @param seed - The seed to use for generating the nullifier leaf preimage.
+ * @returns A nullifier leaf preimage.
+ */
+export function makeNullifierLeafPreimage(seed = 0): NullifierLeafPreimage {
+  return new NullifierLeafPreimage(makeNullifierLeaf(seed), new Fr(seed + 1), BigInt(seed + 2));
+}
+
 /**
  * Makes arbitrary public data tree leaf preimages.
  * @param seed - The seed to use for generating the public data tree leaf preimage.
  * @returns A public data tree leaf preimage.
  */
 export function makePublicDataTreeLeafPreimage(seed = 0): PublicDataTreeLeafPreimage {
-  return new PublicDataTreeLeafPreimage(new Fr(seed), new Fr(seed + 1), new Fr(seed + 2), BigInt(seed + 3));
+  return new PublicDataTreeLeafPreimage(makePublicDataTreeLeaf(seed), new Fr(seed + 2), BigInt(seed + 3));
 }
 
 /**
@@ -1007,7 +1028,7 @@ export function makePublicDataTreeLeafPreimage(seed = 0): PublicDataTreeLeafPrei
 export function makePrivateBaseStateDiffHints(seed = 1): PrivateBaseStateDiffHints {
   const nullifierPredecessorPreimages = makeTuple(
     MAX_NULLIFIERS_PER_TX,
-    x => new NullifierLeafPreimage(fr(x), fr(x + 0x100), BigInt(x + 0x200)),
+    x => makeNullifierLeafPreimage(x),
     seed + 0x1000,
   );
 
@@ -1261,51 +1282,102 @@ export async function makeContractInstanceFromClassId(
   }).withAddress(address);
 }
 
-export function makeAvmTreeHints(seed = 0): AvmAppendTreeHint {
-  return new AvmAppendTreeHint(
-    new Fr(seed),
-    new Fr(seed + 1),
-    makeArray(10, i => new Fr(i), seed + 0x1000),
+export function makeAvmGetSiblingPathHint(seed = 0): AvmGetSiblingPathHint {
+  // We want a possibly large index, but non-random.
+  const index = BigInt(`0x${sha256(Buffer.from(seed.toString())).toString('hex')}`) % (1n << 64n);
+  return new AvmGetSiblingPathHint(
+    makeAppendOnlyTreeSnapshot(seed),
+    /*treeId=*/ (seed + 1) % 5,
+    /*index=*/ index,
+    makeArray(seed % 64, i => new Fr(i), seed + 10),
   );
 }
 
-export function makeAvmNullifierReadTreeHints(seed = 0): AvmNullifierReadTreeHint {
-  const lowNullifierPreimage = new NullifierLeafPreimage(new Fr(seed), new Fr(seed + 1), BigInt(seed + 2));
-  return new AvmNullifierReadTreeHint(
-    lowNullifierPreimage,
-    new Fr(seed + 1),
-    makeArray(10, i => new Fr(i), seed + 0x1000),
+export function makeAvmGetPreviousValueIndexHint(seed = 0): AvmGetPreviousValueIndexHint {
+  // We want a possibly large index, but non-random.
+  const index = BigInt(`0x${sha256(Buffer.from(seed.toString())).toString('hex')}`) % (1n << 64n);
+  const value = new Fr(BigInt(`0x${sha256(Buffer.from((seed + 2).toString())).toString('hex')}`) % (1n << 128n));
+  return new AvmGetPreviousValueIndexHint(
+    makeAppendOnlyTreeSnapshot(seed),
+    /*treeId=*/ (seed + 1) % 5,
+    value,
+    index,
+    /*alreadyPresent=*/ index % 2n === 0n,
+  );
+}
+
+export function makeAvmGetLeafPreimageHintPublicDataTree(seed = 0): AvmGetLeafPreimageHintPublicDataTree {
+  // We want a possibly large index, but non-random.
+  const index = BigInt(`0x${sha256(Buffer.from(seed.toString())).toString('hex')}`) % (1n << 64n);
+  return new AvmGetLeafPreimageHintPublicDataTree(
+    makeAppendOnlyTreeSnapshot(seed),
+    /*index=*/ index,
+    /*leafPreimage=*/ makePublicDataTreeLeafPreimage(seed + 3),
   );
 }
 
-export function makeAvmPublicDataReadTreeHints(seed = 0): AvmPublicDataReadTreeHint {
-  return new AvmPublicDataReadTreeHint(
-    new PublicDataTreeLeafPreimage(new Fr(seed), new Fr(seed + 1), new Fr(seed + 2), BigInt(seed + 3)),
-    new Fr(seed + 1),
-    makeArray(10, i => new Fr(i), seed + 0x1000),
+export function makeAvmGetLeafPreimageHintNullifierTree(seed = 0): AvmGetLeafPreimageHintNullifierTree {
+  // We want a possibly large index, but non-random.
+  const index = BigInt(`0x${sha256(Buffer.from(seed.toString())).toString('hex')}`) % (1n << 64n);
+  return new AvmGetLeafPreimageHintNullifierTree(
+    makeAppendOnlyTreeSnapshot(seed),
+    /*index=*/ index,
+    /*leafPreimage=*/ makeNullifierLeafPreimage(seed + 3),
   );
 }
 
-export function makeAvmNullifierInsertionTreeHints(seed = 0): AvmNullifierWriteTreeHint {
-  return new AvmNullifierWriteTreeHint(
-    makeAvmNullifierReadTreeHints(seed),
-    makeArray(20, i => new Fr(i), seed + 0x1000),
+export function makeAvmGetLeafValueHint(seed = 0): AvmGetLeafValueHint {
+  // We want a possibly large index, but non-random.
+  const index = BigInt(`0x${sha256(Buffer.from(seed.toString())).toString('hex')}`) % (1n << 64n);
+  return new AvmGetLeafValueHint(
+    makeAppendOnlyTreeSnapshot(seed),
+    /*treeId=*/ (seed + 1) % 5,
+    /*index=*/ index,
+    /*value=*/ new Fr(seed + 3),
   );
 }
 
-export function makeAvmStorageReadTreeHints(seed = 0): AvmPublicDataReadTreeHint {
-  return new AvmPublicDataReadTreeHint(
-    new PublicDataTreeLeafPreimage(new Fr(seed), new Fr(seed + 1), new Fr(seed + 2), BigInt(seed + 3)),
-    new Fr(seed + 1),
-    makeArray(10, i => new Fr(i), seed + 0x1000),
+export function makeAvmSequentialInsertHintPublicDataTree(seed = 0): AvmSequentialInsertHintPublicDataTree {
+  const lowLeavesWitnessData = {
+    leaf: makePublicDataTreeLeafPreimage(seed + 3),
+    index: BigInt(seed + 4),
+    path: makeArray(seed % 64, i => new Fr(i), seed + 5),
+  };
+  const insertionWitnessData = {
+    leaf: makePublicDataTreeLeafPreimage(seed + 6),
+    index: BigInt(seed + 7),
+    path: makeArray(seed % 64, i => new Fr(i), seed + 8),
+  };
+
+  return new AvmSequentialInsertHintPublicDataTree(
+    makeAppendOnlyTreeSnapshot(seed),
+    makeAppendOnlyTreeSnapshot(seed + 1),
+    MerkleTreeId.PUBLIC_DATA_TREE,
+    makePublicDataTreeLeaf(seed + 2),
+    lowLeavesWitnessData,
+    insertionWitnessData,
   );
 }
 
-export function makeAvmStorageUpdateTreeHints(seed = 0): AvmPublicDataWriteTreeHint {
-  return new AvmPublicDataWriteTreeHint(
-    makeAvmStorageReadTreeHints(seed),
-    new PublicDataTreeLeafPreimage(new Fr(seed), new Fr(seed + 1), new Fr(seed + 2), BigInt(seed + 3)),
-    makeArray(20, i => new Fr(i), seed + 0x1000),
+export function makeAvmSequentialInsertHintNullifierTree(seed = 0): AvmSequentialInsertHintNullifierTree {
+  const lowLeavesWitnessData = {
+    leaf: makeNullifierLeafPreimage(seed + 3),
+    index: BigInt(seed + 4),
+    path: makeArray(seed % 64, i => new Fr(i), seed + 5),
+  };
+  const insertionWitnessData = {
+    leaf: makeNullifierLeafPreimage(seed + 6),
+    index: BigInt(seed + 7),
+    path: makeArray(seed % 64, i => new Fr(i), seed + 8),
+  };
+
+  return new AvmSequentialInsertHintNullifierTree(
+    makeAppendOnlyTreeSnapshot(seed),
+    makeAppendOnlyTreeSnapshot(seed + 1),
+    MerkleTreeId.NULLIFIER_TREE,
+    makeNullifierLeaf(seed + 2),
+    lowLeavesWitnessData,
+    insertionWitnessData,
   );
 }
 
@@ -1373,13 +1445,25 @@ export async function makeAvmExecutionHints(
     contractInstances: makeArray(baseLength + 2, makeAvmContractInstanceHint, seed + 0x4700),
     contractClasses: makeArray(baseLength + 5, makeAvmContractClassHint, seed + 0x4900),
     bytecodeCommitments: await makeArrayAsync(baseLength + 5, makeAvmBytecodeCommitmentHint, seed + 0x4900),
-    publicDataReads: makeArray(baseLength + 7, makeAvmStorageReadTreeHints, seed + 0x4900),
-    publicDataWrites: makeArray(baseLength + 8, makeAvmStorageUpdateTreeHints, seed + 0x4a00),
-    nullifierReads: makeArray(baseLength + 9, makeAvmNullifierReadTreeHints, seed + 0x4b00),
-    nullifierWrites: makeArray(baseLength + 10, makeAvmNullifierInsertionTreeHints, seed + 0x4c00),
-    noteHashReads: makeArray(baseLength + 11, makeAvmTreeHints, seed + 0x4d00),
-    noteHashWrites: makeArray(baseLength + 12, makeAvmTreeHints, seed + 0x4e00),
-    l1ToL2MessageReads: makeArray(baseLength + 13, makeAvmTreeHints, seed + 0x4f00),
+    getSiblingPathHints: makeArray(baseLength + 5, makeAvmGetSiblingPathHint, seed + 0x4b00),
+    getPreviousValueIndexHints: makeArray(baseLength + 5, makeAvmGetPreviousValueIndexHint, seed + 0x4d00),
+    getLeafPreimageHintPublicDataTree: makeArray(
+      baseLength + 5,
+      makeAvmGetLeafPreimageHintPublicDataTree,
+      seed + 0x4f00,
+    ),
+    getLeafPreimageHintNullifierTree: makeArray(baseLength + 5, makeAvmGetLeafPreimageHintNullifierTree, seed + 0x5100),
+    getLeafValueHints: makeArray(baseLength + 5, makeAvmGetLeafValueHint, seed + 0x5300),
+    sequentialInsertHintsPublicDataTree: makeArray(
+      baseLength + 5,
+      makeAvmSequentialInsertHintPublicDataTree,
+      seed + 0x5500,
+    ),
+    sequentialInsertHintsNullifierTree: makeArray(
+      baseLength + 5,
+      makeAvmSequentialInsertHintNullifierTree,
+      seed + 0x5700,
+    ),
     ...overrides,
   };
 
@@ -1388,13 +1472,13 @@ export async function makeAvmExecutionHints(
     fields.contractInstances,
     fields.contractClasses,
     fields.bytecodeCommitments,
-    fields.publicDataReads,
-    fields.publicDataWrites,
-    fields.nullifierReads,
-    fields.nullifierWrites,
-    fields.noteHashReads,
-    fields.noteHashWrites,
-    fields.l1ToL2MessageReads,
+    fields.getSiblingPathHints,
+    fields.getPreviousValueIndexHints,
+    fields.getLeafPreimageHintPublicDataTree,
+    fields.getLeafPreimageHintNullifierTree,
+    fields.getLeafValueHints,
+    fields.sequentialInsertHintsPublicDataTree,
+    fields.sequentialInsertHintsNullifierTree,
   );
 }
 

package/src/tests/mocks.ts

@@ -73,6 +73,7 @@ export const mockTx = async (
   {
     numberOfNonRevertiblePublicCallRequests = MAX_ENQUEUED_CALLS_PER_TX / 2,
     numberOfRevertiblePublicCallRequests = MAX_ENQUEUED_CALLS_PER_TX / 2,
+    numberOfRevertibleNullifiers = 0,
     hasPublicTeardownCallRequest = false,
     publicCalldataSize = 2,
     feePayer,
@@ -80,6 +81,7 @@ export const mockTx = async (
   }: {
     numberOfNonRevertiblePublicCallRequests?: number;
     numberOfRevertiblePublicCallRequests?: number;
+    numberOfRevertibleNullifiers?: number;
     hasPublicTeardownCallRequest?: boolean;
     publicCalldataSize?: number;
     feePayer?: AztecAddress;
@@ -123,6 +125,11 @@ export const mockTx = async (
       .withPublicCallRequests(publicCallRequests.slice(numberOfRevertiblePublicCallRequests))
       .build();
 
+    for (let i = 0; i < numberOfRevertibleNullifiers; i++) {
+      const revertibleNullifier = new Nullifier(new Fr(seed + 2 + i), 0, Fr.ZERO);
+      revertibleBuilder.pushNullifier(revertibleNullifier.value);
+    }
+
     data.forPublic.revertibleAccumulatedData = revertibleBuilder
       .withPublicCallRequests(publicCallRequests.slice(0, numberOfRevertiblePublicCallRequests))
       .build();

package/src/trees/merkle_tree_id.ts

@@ -40,3 +40,15 @@ export type TreeHeights = typeof TREE_HEIGHTS;
 export function getTreeHeight<TID extends MerkleTreeId>(treeId: TID): TreeHeights[TID] {
   return TREE_HEIGHTS[treeId];
 }
+
+const TREE_NAMES = {
+  [MerkleTreeId.NULLIFIER_TREE]: 'NULLIFIER_TREE' as const,
+  [MerkleTreeId.NOTE_HASH_TREE]: 'NOTE_HASH_TREE' as const,
+  [MerkleTreeId.PUBLIC_DATA_TREE]: 'PUBLIC_DATA_TREE' as const,
+  [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: 'L1_TO_L2_MESSAGE_TREE' as const,
+  [MerkleTreeId.ARCHIVE]: 'ARCHIVE' as const,
+} as const;
+
+export function getTreeName<TID extends MerkleTreeId>(treeId: TID): (typeof TREE_NAMES)[TID] {
+  return TREE_NAMES[treeId];
+}

package/src/trees/nullifier_leaf.ts

@@ -15,11 +15,11 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
     /**
      * Leaf value inside the indexed tree's linked list.
      */
-    public nullifier: Fr,
+    public leaf: NullifierLeaf,
     /**
-     * Next value inside the indexed tree's linked list.
+     * Next nullifier inside the indexed tree's linked list.
      */
-    public nextNullifier: Fr,
+    public nextKey: Fr,
     /**
      * Index of the next leaf in the indexed tree's linked list.
      */
@@ -29,21 +29,23 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
   static get schema() {
     return z
       .object({
-        nullifier: schemas.Fr,
-        nextNullifier: schemas.Fr,
+        leaf: NullifierLeaf.schema,
+        nextKey: schemas.Fr,
         nextIndex: schemas.BigInt,
       })
-      .transform(
-        ({ nullifier, nextNullifier, nextIndex }) => new NullifierLeafPreimage(nullifier, nextNullifier, nextIndex),
-      );
+      .transform(({ leaf, nextKey, nextIndex }) => new NullifierLeafPreimage(leaf, nextKey, nextIndex));
+  }
+
+  static get leafSchema() {
+    return NullifierLeaf.schema;
   }
 
   getKey(): bigint {
-    return this.nullifier.toBigInt();
+    return this.leaf.getKey();
   }
 
   getNextKey(): bigint {
-    return this.nextNullifier.toBigInt();
+    return this.nextKey.toBigInt();
   }
 
   getNextIndex(): bigint {
@@ -51,7 +53,7 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
   }
 
   asLeaf(): NullifierLeaf {
-    return new NullifierLeaf(this.nullifier);
+    return this.leaf;
   }
 
   toBuffer(): Buffer {
@@ -60,8 +62,8 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
 
   toHashInputs(): Buffer[] {
     return [
-      Buffer.from(this.nullifier.toBuffer()),
-      Buffer.from(this.nextNullifier.toBuffer()),
+      ...this.leaf.toHashInputs(),
+      Buffer.from(this.nextKey.toBuffer()),
       Buffer.from(toBufferBE(this.nextIndex, 32)),
     ];
   }
@@ -71,28 +73,32 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
   }
 
   clone(): NullifierLeafPreimage {
-    return new NullifierLeafPreimage(this.nullifier, this.nextNullifier, this.nextIndex);
+    return new NullifierLeafPreimage(this.leaf.clone(), this.nextKey, this.nextIndex);
   }
 
   static random() {
-    return new NullifierLeafPreimage(Fr.random(), Fr.random(), BigInt(Math.floor(Math.random() * 1000)));
+    return new NullifierLeafPreimage(NullifierLeaf.random(), Fr.random(), BigInt(Math.floor(Math.random() * 1000)));
   }
 
   static empty(): NullifierLeafPreimage {
-    return new NullifierLeafPreimage(Fr.ZERO, Fr.ZERO, 0n);
+    return new NullifierLeafPreimage(NullifierLeaf.empty(), Fr.zero(), 0n);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): NullifierLeafPreimage {
     const reader = BufferReader.asReader(buffer);
-    return new NullifierLeafPreimage(reader.readObject(Fr), reader.readObject(Fr), toBigIntBE(reader.readBytes(32)));
+    return new NullifierLeafPreimage(
+      NullifierLeaf.fromBuffer(reader),
+      reader.readObject(Fr),
+      toBigIntBE(reader.readBytes(32)),
+    );
   }
 
   static fromLeaf(leaf: NullifierLeaf, nextKey: bigint, nextIndex: bigint): NullifierLeafPreimage {
-    return new NullifierLeafPreimage(leaf.nullifier, new Fr(nextKey), nextIndex);
+    return new NullifierLeafPreimage(leaf, new Fr(nextKey), nextIndex);
   }
 
   static clone(preimage: NullifierLeafPreimage): NullifierLeafPreimage {
-    return new NullifierLeafPreimage(preimage.nullifier, preimage.nextNullifier, preimage.nextIndex);
+    return preimage.clone();
   }
 }
 
@@ -115,6 +121,22 @@ export class NullifierLeaf implements IndexedTreeLeaf {
     return this.nullifier.toBuffer();
   }
 
+  clone(): NullifierLeaf {
+    return new NullifierLeaf(new Fr(this.nullifier));
+  }
+
+  toHashInputs(): Buffer[] {
+    return [Buffer.from(this.nullifier.toBuffer())];
+  }
+
+  static empty(): NullifierLeaf {
+    return new NullifierLeaf(Fr.ZERO);
+  }
+
+  static random(): NullifierLeaf {
+    return new NullifierLeaf(Fr.random());
+  }
+
   isEmpty(): boolean {
     return this.nullifier.isZero();
   }
@@ -127,7 +149,12 @@ export class NullifierLeaf implements IndexedTreeLeaf {
     return new NullifierLeaf(new Fr(key));
   }
 
-  static fromBuffer(buf: Buffer): NullifierLeaf {
-    return new NullifierLeaf(Fr.fromBuffer(buf));
+  static fromBuffer(buf: Buffer | BufferReader): NullifierLeaf {
+    const reader = BufferReader.asReader(buf);
+    return new NullifierLeaf(reader.readObject(Fr));
+  }
+
+  static get schema() {
+    return z.object({ nullifier: schemas.Fr }).transform(({ nullifier }) => new NullifierLeaf(nullifier));
   }
 }

package/src/trees/protocol_contract_leaf.ts

@@ -89,10 +89,6 @@ export class ProtocolContractLeafPreimage implements IndexedTreeLeafPreimage {
       toBigIntBE(reader.readBytes(32)),
     );
   }
-
-  static fromLeaf(leaf: ProtocolContractLeaf, nextKey: bigint, nextIndex: bigint): ProtocolContractLeafPreimage {
-    return new ProtocolContractLeafPreimage(leaf.address, new Fr(nextKey), nextIndex);
-  }
 }
 
 /**

package/src/trees/public_data_leaf.ts

@@ -13,17 +13,13 @@ import { z } from 'zod';
 export class PublicDataTreeLeafPreimage implements IndexedTreeLeafPreimage {
   constructor(
     /**
-     * The slot of the leaf
+     * The leaf (slot, value).
      */
-    public slot: Fr,
-    /**
-     * The value of the leaf
-     */
-    public value: Fr,
+    public leaf: PublicDataTreeLeaf,
     /**
-     * Next value inside the indexed tree's linked list.
+     * Next key (slot) inside the indexed tree's linked list.
      */
-    public nextSlot: Fr,
+    public nextKey: Fr,
     /**
      * Index of the next leaf in the indexed tree's linked list.
      */
@@ -33,22 +29,23 @@ export class PublicDataTreeLeafPreimage implements IndexedTreeLeafPreimage {
   static get schema() {
     return z
       .object({
-        slot: schemas.Fr,
-        value: schemas.Fr,
-        nextSlot: schemas.Fr,
+        leaf: PublicDataTreeLeaf.schema,
+        nextKey: schemas.Fr,
         nextIndex: schemas.BigInt,
       })
-      .transform(
-        ({ slot, value, nextSlot, nextIndex }) => new PublicDataTreeLeafPreimage(slot, value, nextSlot, nextIndex),
-      );
+      .transform(({ leaf, nextKey, nextIndex }) => new PublicDataTreeLeafPreimage(leaf, nextKey, nextIndex));
+  }
+
+  static get leafSchema() {
+    return PublicDataTreeLeaf.schema;
   }
 
   getKey(): bigint {
-    return this.slot.toBigInt();
+    return this.leaf.getKey();
   }
 
   getNextKey(): bigint {
-    return this.nextSlot.toBigInt();
+    return this.nextKey.toBigInt();
   }
 
   getNextIndex(): bigint {
@@ -56,7 +53,7 @@ export class PublicDataTreeLeafPreimage implements IndexedTreeLeafPreimage {
   }
 
   asLeaf(): PublicDataTreeLeaf {
-    return new PublicDataTreeLeaf(this.slot, this.value);
+    return this.leaf;
   }
 
   toBuffer(): Buffer {
@@ -65,45 +62,42 @@ export class PublicDataTreeLeafPreimage implements IndexedTreeLeafPreimage {
 
   toHashInputs(): Buffer[] {
     return [
-      Buffer.from(this.slot.toBuffer()),
-      Buffer.from(this.value.toBuffer()),
+      ...this.leaf.toHashInputs(),
       Buffer.from(toBufferBE(this.nextIndex, 32)),
-      Buffer.from(this.nextSlot.toBuffer()),
+      Buffer.from(this.nextKey.toBuffer()),
     ];
   }
 
   clone(): PublicDataTreeLeafPreimage {
-    return new PublicDataTreeLeafPreimage(this.slot, this.value, this.nextSlot, this.nextIndex);
+    return new PublicDataTreeLeafPreimage(this.leaf.clone(), this.nextKey, this.nextIndex);
   }
 
   static random() {
     return new PublicDataTreeLeafPreimage(
-      Fr.random(),
-      Fr.random(),
+      PublicDataTreeLeaf.buildDummy(BigInt(Math.floor(Math.random() * 1000))),
       Fr.random(),
       BigInt(Math.floor(Math.random() * 1000)),
     );
   }
 
   static empty(): PublicDataTreeLeafPreimage {
-    return new PublicDataTreeLeafPreimage(Fr.ZERO, Fr.ZERO, Fr.ZERO, 0n);
+    return new PublicDataTreeLeafPreimage(PublicDataTreeLeaf.empty(), Fr.ZERO, 0n);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): PublicDataTreeLeafPreimage {
     const reader = BufferReader.asReader(buffer);
-    const slot = Fr.fromBuffer(reader);
-    const value = Fr.fromBuffer(reader);
+    const value = PublicDataTreeLeaf.fromBuffer(reader);
     const nextIndex = toBigIntBE(reader.readBytes(32));
     const nextSlot = Fr.fromBuffer(reader);
-    return new PublicDataTreeLeafPreimage(slot, value, nextSlot, nextIndex);
+    return new PublicDataTreeLeafPreimage(value, nextSlot, nextIndex);
   }
 
   static fromLeaf(leaf: PublicDataTreeLeaf, nextKey: bigint, nextIndex: bigint): PublicDataTreeLeafPreimage {
-    return new PublicDataTreeLeafPreimage(leaf.slot, leaf.value, new Fr(nextKey), nextIndex);
+    return new PublicDataTreeLeafPreimage(leaf, new Fr(nextKey), nextIndex);
   }
 
   static clone(preimage: PublicDataTreeLeafPreimage): PublicDataTreeLeafPreimage {
-    return new PublicDataTreeLeafPreimage(preimage.slot, preimage.value, preimage.nextSlot, preimage.nextIndex);
+    return preimage.clone();
   }
 }
 
@@ -130,6 +124,14 @@ export class PublicDataTreeLeaf implements IndexedTreeLeaf {
     return serializeToBuffer([this.slot, this.value]);
   }
 
+  clone(): PublicDataTreeLeaf {
+    return new PublicDataTreeLeaf(this.slot, this.value);
+  }
+
+  toHashInputs(): Buffer[] {
+    return [this.slot.toBuffer(), this.value.toBuffer()];
+  }
+
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new PublicDataTreeLeaf(Fr.fromBuffer(reader), Fr.fromBuffer(reader));
@@ -161,4 +163,13 @@ export class PublicDataTreeLeaf implements IndexedTreeLeaf {
   static empty(): PublicDataTreeLeaf {
     return new PublicDataTreeLeaf(Fr.ZERO, Fr.ZERO);
   }
+
+  static get schema() {
+    return z
+      .object({
+        slot: schemas.Fr,
+        value: schemas.Fr,
+      })
+      .transform(({ slot, value }) => new PublicDataTreeLeaf(slot, value));
+  }
 }

package/src/trees/public_data_witness.ts

@@ -50,10 +50,10 @@ export class PublicDataWitness {
   public toFields(): Fr[] {
     return [
       new Fr(this.index),
-      new Fr(this.leafPreimage.slot),
-      new Fr(this.leafPreimage.value),
+      new Fr(this.leafPreimage.leaf.slot),
+      new Fr(this.leafPreimage.leaf.value),
       new Fr(this.leafPreimage.nextIndex),
-      new Fr(this.leafPreimage.nextSlot),
+      new Fr(this.leafPreimage.nextKey),
       ...this.siblingPath.toFields(),
     ];
   }
@@ -65,9 +65,9 @@ export class PublicDataWitness {
     // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
     return [
       new Fr(this.index).toString() as string,
-      new Fr(this.leafPreimage.slot).toString() as string,
-      new Fr(this.leafPreimage.value).toString() as string,
-      new Fr(this.leafPreimage.nextSlot).toString() as string,
+      new Fr(this.leafPreimage.leaf.slot).toString() as string,
+      new Fr(this.leafPreimage.leaf.value).toString() as string,
+      new Fr(this.leafPreimage.nextKey).toString() as string,
       new Fr(this.leafPreimage.nextIndex).toString() as string,
       this.siblingPath.toFields().map(fr => fr.toString()) as string[],
     ];

package/src/validators/index.ts

@@ -0,0 +1,3 @@
+export type * from './types.js';
+
+export * from './schemas.js';