@aztec/stdlib 0.82.3 → 0.83.1-alpha-testnet.0

package/src/logs/{l1_payload/shared_secret_derivation.ts → shared_secret_derivation.ts}

@@ -1,8 +1,7 @@
 import { Grumpkin } from '@aztec/foundation/crypto';
 import type { GrumpkinScalar, Point } from '@aztec/foundation/fields';
 
-import type { AztecAddress } from '../../aztec-address/index.js';
-import type { PublicKey } from '../../keys/public_key.js';
+import type { PublicKey } from '../keys/public_key.js';
 
 /**
  * Derive an Elliptic Curve Diffie-Hellman (ECDH) Shared Secret.
@@ -13,6 +12,9 @@ import type { PublicKey } from '../../keys/public_key.js';
  * @param publicKey - The public key used to derive shared secret.
  * @returns A derived shared secret.
  * @throws If the publicKey is zero.
+ *
+ * TODO(#12656): This function is kept around because of the getSharedSecret oracle. Nuke this once returning
+ * the app-siloed secret.
  */
 export async function deriveEcdhSharedSecret(secretKey: GrumpkinScalar, publicKey: PublicKey): Promise<Point> {
   if (publicKey.isZero()) {
@@ -24,12 +26,3 @@ export async function deriveEcdhSharedSecret(secretKey: GrumpkinScalar, publicKe
   const sharedSecret = await curve.mul(publicKey, secretKey);
   return sharedSecret;
 }
-
-export async function deriveEcdhSharedSecretUsingAztecAddress(
-  secretKey: GrumpkinScalar,
-  address: AztecAddress,
-): Promise<Point> {
-  const addressPoint = await address.toAddressPoint();
-  const sharedSecret = await deriveEcdhSharedSecret(secretKey, addressPoint);
-  return sharedSecret;
-}

package/src/logs/tx_scoped_l2_log.ts

@@ -17,6 +17,11 @@ export class TxScopedL2Log {
      * with the log so the noteHashIndex can be reconstructed after decryption.
      */
     public dataStartIndexForTx: number,
+    /*
+     * The index of the log in the transaction. Note that public and private logs are in separate arrays in the tx
+     * effect and for this reason these indices are independent (a private and public log can have the same index).
+     */
+    public logIndexInTx: number,
     /*
      * The block this log is included in
      */
@@ -36,12 +41,13 @@ export class TxScopedL2Log {
       .object({
         txHash: TxHash.schema,
         dataStartIndexForTx: z.number(),
+        logIndexInTx: z.number(),
         blockNumber: z.number(),
         log: z.union([PrivateLog.schema, PublicLog.schema]),
       })
       .transform(
-        ({ txHash, dataStartIndexForTx, blockNumber, log }) =>
-          new TxScopedL2Log(txHash, dataStartIndexForTx, blockNumber, log),
+        ({ txHash, dataStartIndexForTx, logIndexInTx, blockNumber, log }) =>
+          new TxScopedL2Log(txHash, dataStartIndexForTx, logIndexInTx, blockNumber, log),
       );
   }
 
@@ -50,6 +56,7 @@ export class TxScopedL2Log {
     return Buffer.concat([
       this.txHash.toBuffer(),
       numToUInt32BE(this.dataStartIndexForTx),
+      numToUInt32BE(this.logIndexInTx),
       numToUInt32BE(this.blockNumber),
       boolToBuffer(isFromPublic),
       this.log.toBuffer(),
@@ -60,23 +67,25 @@ export class TxScopedL2Log {
     const reader = BufferReader.asReader(buffer);
     const txHash = reader.readObject(TxHash);
     const dataStartIndexForTx = reader.readNumber();
+    const logIndexInTx = reader.readNumber();
     const blockNumber = reader.readNumber();
     const isFromPublic = reader.readBoolean();
     const log = isFromPublic ? PublicLog.fromBuffer(reader) : PrivateLog.fromBuffer(reader);
 
-    return new TxScopedL2Log(txHash, dataStartIndexForTx, blockNumber, log);
+    return new TxScopedL2Log(txHash, dataStartIndexForTx, logIndexInTx, blockNumber, log);
   }
 
   static async random() {
     const isFromPublic = Math.random() < 0.5;
     const log = isFromPublic ? await PublicLog.random() : PrivateLog.random();
-    return new TxScopedL2Log(TxHash.random(), 1, 1, log);
+    return new TxScopedL2Log(TxHash.random(), 1, 1, 1, log);
   }
 
   equals(other: TxScopedL2Log) {
     return (
       this.txHash.equals(other.txHash) &&
       this.dataStartIndexForTx === other.dataStartIndexForTx &&
+      this.logIndexInTx === other.logIndexInTx &&
       this.blockNumber === other.blockNumber &&
       ((this.log instanceof PublicLog && other.log instanceof PublicLog) ||
         (this.log instanceof PrivateLog && other.log instanceof PrivateLog)) &&

package/src/note/note.ts

@@ -1,16 +1,72 @@
+import { randomInt } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
-import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
-import { Payload } from '../logs/l1_payload/payload.js';
+import { schemas } from '../schemas/index.js';
+import { Vector } from '../types/shared.js';
 
-export class Note extends Payload {
-  static override get schema() {
+/**
+ * The Note class represents a Note emitted from a Noir contract as a vector of Fr (finite field) elements.
+ * This data also represents a preimage to a note hash.
+ */
+export class Note extends Vector<Fr> {
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
     return schemas.Buffer.transform(Note.fromBuffer);
   }
 
-  static override fromBuffer(buffer: Buffer | BufferReader) {
+  /**
+   * Create a Note instance from a Buffer or BufferReader.
+   * The input 'buffer' can be either a Buffer containing the serialized Fr elements or a BufferReader instance.
+   * This function reads the Fr elements in the buffer and constructs a Note with them.
+   *
+   * @param buffer - The Buffer or BufferReader containing the serialized Fr elements.
+   * @returns A Note instance containing the deserialized Fr elements.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new Note(reader.readVector(Fr));
   }
+
+  /**
+   * Generates a random Note instance with a variable number of items.
+   * The number of items is determined by a random value between 1 and 10 (inclusive).
+   * Each item in the Note is generated using the Fr.random() method.
+   *
+   * @returns A randomly generated Note instance.
+   */
+  static random() {
+    const numItems = randomInt(10) + 1;
+    const items = Array.from({ length: numItems }, () => Fr.random());
+    return new Note(items);
+  }
+
+  /**
+   * Returns a hex representation of the note.
+   * @returns A hex string with the vector length as first element.
+   */
+  override toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /**
+   * Creates a new Note instance from a hex string.
+   * @param str - Hex representation.
+   * @returns A Note instance.
+   */
+  static fromString(str: string) {
+    return Note.fromBuffer(hexToBuffer(str));
+  }
+
+  get length() {
+    return this.items.length;
+  }
+
+  equals(other: Note) {
+    return this.items.every((item, index) => item.equals(other.items[index]));
+  }
 }

package/src/proofs/proof.ts

@@ -3,6 +3,8 @@ import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
+import { strict as assert } from 'assert';
+
 const EMPTY_PROOF_SIZE = 42;
 
 /**
@@ -17,6 +19,7 @@ export class Proof {
 
   // Honk proofs start with a 4 byte length prefix
   // the proof metadata starts immediately after
+  // TODO(https://github.com/AztecProtocol/barretenberg/issues/1312): Get rid of if possible.
   private readonly metadataOffset = 4;
 
   constructor(
@@ -62,19 +65,50 @@ export class Proof {
   }
 
   public withoutPublicInputs(): Buffer {
-    return Buffer.concat([this.buffer.subarray(this.metadataOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs)]);
+    if (this.isEmpty()) {
+      return this.buffer;
+    }
+    // We are indexing to this particular size because we are assuming the proof buffer looks like:
+    // [4 bytes of metadata for public inputs, binary public inputs, 4 bytes of metadata for proof, binary proof]
+    const proofStart = this.metadataOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs + this.metadataOffset;
+    assert(this.buffer.length >= proofStart, 'Proof buffer is not appropriately sized to call withoutPublicInputs()');
+    return this.buffer.subarray(proofStart);
   }
 
+  // This function assumes that the proof will contain an aggregation object and look something like:
+  // [4 bytes of metadata for public inputs, binary public inputs, 4 bytes of metadata for proof, aggregation object, rest of proof]
+  // We are extracting the binary public inputs and reading them as Frs, and also extracting the aggregation object.
   public extractPublicInputs(): Fr[] {
+    if (this.isEmpty()) {
+      // return array of this.numPublicInputs 0s
+      return new Array(this.numPublicInputs).fill(Fr.zero());
+    }
+    assert(this.numPublicInputs >= AGGREGATION_OBJECT_LENGTH, 'Proof does not contain an aggregation object');
+    const numInnerPublicInputs = this.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
     const reader = BufferReader.asReader(
-      this.buffer.subarray(this.metadataOffset, this.metadataOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs),
+      this.buffer.subarray(this.metadataOffset, this.metadataOffset + Fr.SIZE_IN_BYTES * numInnerPublicInputs),
     );
-    return reader.readArray(this.numPublicInputs, Fr);
+    let publicInputs = reader.readArray(numInnerPublicInputs, Fr);
+    // concatenate Fr[] with aggregation object
+    publicInputs = publicInputs.concat(this.extractAggregationObject());
+    return publicInputs;
   }
 
   public extractAggregationObject(): Fr[] {
-    const publicInputs = this.extractPublicInputs();
-    return publicInputs.slice(-1 * AGGREGATION_OBJECT_LENGTH);
+    if (this.isEmpty()) {
+      // return array of 16 0s
+      return new Array(16).fill(Fr.zero());
+    }
+    assert(this.numPublicInputs >= AGGREGATION_OBJECT_LENGTH, 'Proof does not contain an aggregation object');
+    const numInnerPublicInputs = this.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
+    // The aggregation object is currently stored after the initial inner public inputs and after the 4 byte proof metadata.
+    const reader = BufferReader.asReader(
+      this.buffer.subarray(
+        this.metadataOffset + Fr.SIZE_IN_BYTES * numInnerPublicInputs + this.metadataOffset,
+        this.metadataOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs + this.metadataOffset,
+      ),
+    );
+    return reader.readArray(AGGREGATION_OBJECT_LENGTH, Fr);
   }
 
   /**

package/src/snapshots/download.ts

@@ -40,7 +40,7 @@ export async function getLatestSnapshotMetadata(
 }
 
 export function getBasePath(metadata: SnapshotsIndexMetadata): string {
-  return `aztec-${metadata.l1ChainId}-${metadata.l2Version}-${metadata.rollupAddress}`;
+  return `aztec-${metadata.l1ChainId}-${metadata.rollupVersion}-${metadata.rollupAddress}`;
 }
 
 export function getSnapshotIndexPath(metadata: SnapshotsIndexMetadata): string {

package/src/snapshots/types.ts

@@ -27,7 +27,7 @@ export type SnapshotMetadata = {
 
 export type SnapshotsIndexMetadata = {
   l1ChainId: number;
-  l2Version: number;
+  rollupVersion: number;
   rollupAddress: EthAddress;
 };
 
@@ -37,7 +37,7 @@ export type SnapshotsIndex = SnapshotsIndexMetadata & {
 
 export const SnapshotsIndexSchema = z.object({
   l1ChainId: z.number(),
-  l2Version: z.number(),
+  rollupVersion: z.number(),
   rollupAddress: schemas.EthAddress,
   snapshots: z.array(
     z.object({

package/src/snapshots/upload.ts

@@ -6,7 +6,7 @@ import { getBasePath, getSnapshotIndex, getSnapshotIndexPath } from './download.
 import type { SnapshotDataKeys, SnapshotMetadata, SnapshotsIndex } from './types.js';
 
 export type UploadSnapshotMetadata = Pick<SnapshotMetadata, 'l2BlockNumber' | 'l2BlockHash' | 'l1BlockNumber'> &
-  Pick<SnapshotsIndex, 'l1ChainId' | 'l2Version' | 'rollupAddress'>;
+  Pick<SnapshotsIndex, 'l1ChainId' | 'rollupVersion' | 'rollupAddress'>;
 
 export async function uploadSnapshot(
   localPaths: Record<SnapshotDataKeys, string>,
@@ -45,9 +45,11 @@ export async function uploadSnapshot(
   return newSnapshotMetadata;
 }
 
-function createEmptyIndex(metadata: Pick<SnapshotsIndex, 'l1ChainId' | 'l2Version' | 'rollupAddress'>): SnapshotsIndex {
+function createEmptyIndex(
+  metadata: Pick<SnapshotsIndex, 'l1ChainId' | 'rollupVersion' | 'rollupAddress'>,
+): SnapshotsIndex {
   return {
-    ...pick(metadata, 'l1ChainId', 'l2Version', 'rollupAddress'),
+    ...pick(metadata, 'l1ChainId', 'rollupVersion', 'rollupAddress'),
     snapshots: [],
   };
 }

package/src/tests/factories.ts

@@ -67,6 +67,8 @@ import {
   AvmGetLeafValueHint,
   AvmGetPreviousValueIndexHint,
   AvmGetSiblingPathHint,
+  AvmSequentialInsertHintNullifierTree,
+  AvmSequentialInsertHintPublicDataTree,
   RevertCode,
 } from '../avm/index.js';
 import { PublicDataHint } from '../avm/public_data_hint.js';
@@ -144,6 +146,7 @@ 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 { 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';
@@ -999,13 +1002,22 @@ 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));
 }
 
 /**
@@ -1016,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,
   );
 
@@ -1300,9 +1312,7 @@ export function makeAvmGetLeafPreimageHintPublicDataTree(seed = 0): AvmGetLeafPr
   return new AvmGetLeafPreimageHintPublicDataTree(
     makeAppendOnlyTreeSnapshot(seed),
     /*index=*/ index,
-    /*leaf=*/ makePublicDataTreeLeaf(seed + 3),
-    /*nextIndex=*/ index + 1n,
-    /*nextValue*/ new Fr(seed + 0x500),
+    /*leafPreimage=*/ makePublicDataTreeLeafPreimage(seed + 3),
   );
 }
 
@@ -1312,9 +1322,7 @@ export function makeAvmGetLeafPreimageHintNullifierTree(seed = 0): AvmGetLeafPre
   return new AvmGetLeafPreimageHintNullifierTree(
     makeAppendOnlyTreeSnapshot(seed),
     /*index=*/ index,
-    /*leaf=*/ makeNullifierLeaf(seed + 3),
-    /*nextIndex=*/ index + 1n,
-    /*nextValue*/ new Fr(seed + 0x500),
+    /*leafPreimage=*/ makeNullifierLeafPreimage(seed + 3),
   );
 }
 
@@ -1329,6 +1337,50 @@ export function makeAvmGetLeafValueHint(seed = 0): AvmGetLeafValueHint {
   );
 }
 
+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 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,
+  );
+}
+
 /**
  * Makes arbitrary AvmContractInstanceHint.
  * @param seed - The seed to use for generating the state reference.
@@ -1402,6 +1454,16 @@ export async function makeAvmExecutionHints(
     ),
     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,
   };
 
@@ -1415,6 +1477,8 @@ export async function makeAvmExecutionHints(
     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/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.value, 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();
   }
 }
 
@@ -104,19 +110,35 @@ export class NullifierLeaf implements IndexedTreeLeaf {
     /**
      * Nullifier value.
      */
-    public value: Fr,
+    public nullifier: Fr,
   ) {}
 
   getKey(): bigint {
-    return this.value.toBigInt();
+    return this.nullifier.toBigInt();
   }
 
   toBuffer(): Buffer {
-    return this.value.toBuffer();
+    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.value.isZero();
+    return this.nullifier.isZero();
   }
 
   updateTo(_another: NullifierLeaf): NullifierLeaf {
@@ -127,11 +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({ value: schemas.Fr }).transform(({ value }) => new NullifierLeaf(value));
+    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);
-  }
 }
 
 /**