@aztec/stdlib 0.77.0-testnet-ignition.17

package/src/tests/fixtures.ts

@@ -0,0 +1,31 @@
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+import { type ContractArtifact, loadContractArtifact } from '../abi/index.js';
+import type { NoirCompiledContract } from '../noir/index.js';
+
+// Copied from the build output for the contract `Benchmarking` in noir-contracts
+export function getBenchmarkContractArtifact(): ContractArtifact {
+  const path = getPathToFixture('Benchmarking.test.json');
+  const content = JSON.parse(readFileSync(path).toString()) as NoirCompiledContract;
+  return loadContractArtifact(content);
+}
+
+// Copied from the build output for the contract `Test` in noir-contracts
+export function getTestContractArtifact(): ContractArtifact {
+  const path = getPathToFixture('Test.test.json');
+  const content = JSON.parse(readFileSync(path).toString()) as NoirCompiledContract;
+  return loadContractArtifact(content);
+}
+
+// Copied from the build output for the contract `Token` in noir-contracts
+export function getTokenContractArtifact(): ContractArtifact {
+  const path = getPathToFixture('Token.test.json');
+  const content = JSON.parse(readFileSync(path).toString()) as NoirCompiledContract;
+  return loadContractArtifact(content);
+}
+
+export function getPathToFixture(name: string) {
+  return resolve(dirname(fileURLToPath(import.meta.url)), `../../fixtures/${name}`);
+}

package/src/tests/index.ts

@@ -0,0 +1,2 @@
+export * from './factories.js';
+export * from './mocks.js';

package/src/tests/jest.ts

@@ -0,0 +1,29 @@
+import { L2Block } from '../block/l2_block.js';
+
+/**
+ * Checks if two objects are the same L2Block.
+ *
+ * Sometimes we might be comparing two L2Block instances that represent the same block but one of them might not have
+ * calculated and filled its `blockHash` property (which is computed on demand). This function ensures both objects
+ * are really the same L2Block.
+ *
+ * @param a - An object
+ * @param b - Another object
+ * @returns True if both a and b are the same L2Block
+ */
+export function equalL2Blocks(a: any, b: any) {
+  const aAsL2Block = a && a instanceof L2Block ? a : undefined;
+  const bAsL2Block = b && b instanceof L2Block ? b : undefined;
+
+  if (aAsL2Block && bAsL2Block) {
+    // we got two L2Block instances, so we can compare them
+    // use a custom comparator because the blockHash property is lazily computed and one instance might not have it
+    return aAsL2Block.toBuffer().equals(bAsL2Block.toBuffer());
+  } else if (aAsL2Block || bAsL2Block) {
+    // one value is an L2block and the other isn't. Definitely not equal.
+    return false;
+  } else {
+    // we don't know what they are, tell Jest to keep looking
+    return undefined;
+  }
+}

package/src/tests/mocks.ts

@@ -0,0 +1,300 @@
+import { MAX_ENQUEUED_CALLS_PER_TX } from '@aztec/constants';
+import { times } from '@aztec/foundation/collection';
+import { Secp256k1Signer, randomBytes } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+
+import type { ContractArtifact } from '../abi/abi.js';
+import { NoteSelector } from '../abi/note_selector.js';
+import { AztecAddress } from '../aztec-address/index.js';
+import { computeContractAddressFromInstance } from '../contract/contract_address.js';
+import { getContractClassFromArtifact } from '../contract/contract_class.js';
+import { SerializableContractInstance } from '../contract/contract_instance.js';
+import type { ContractInstanceWithAddress } from '../contract/index.js';
+import { GasFees } from '../gas/gas_fees.js';
+import { GasSettings } from '../gas/gas_settings.js';
+import { computeVarArgsHash } from '../hash/hash.js';
+import { Nullifier } from '../kernel/nullifier.js';
+import { PrivateCircuitPublicInputs } from '../kernel/private_circuit_public_inputs.js';
+import {
+  PartialPrivateTailPublicInputsForPublic,
+  PrivateKernelTailCircuitPublicInputs,
+} from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import { PrivateToPublicAccumulatedDataBuilder } from '../kernel/private_to_public_accumulated_data_builder.js';
+import { ExtendedNote, UniqueNote } from '../note/extended_note.js';
+import { Note } from '../note/note.js';
+import { BlockAttestation } from '../p2p/block_attestation.js';
+import { BlockProposal } from '../p2p/block_proposal.js';
+import { ConsensusPayload } from '../p2p/consensus_payload.js';
+import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from '../p2p/signature_utils.js';
+import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import {
+  BlockHeader,
+  CallContext,
+  CountedPublicExecutionRequest,
+  PrivateCallExecutionResult,
+  PrivateExecutionResult,
+  PublicExecutionRequest,
+  Tx,
+} from '../tx/index.js';
+import { PublicSimulationOutput } from '../tx/public_simulation_output.js';
+import { TxSimulationResult, accumulatePrivateReturnValues } from '../tx/simulated_tx.js';
+import { TxEffect } from '../tx/tx_effect.js';
+import { TxHash } from '../tx/tx_hash.js';
+import { makeCombinedConstantData, makeGas, makeHeader, makePublicCallRequest } from './factories.js';
+
+export const randomTxHash = (): TxHash => TxHash.random();
+
+export const randomExtendedNote = async ({
+  note = Note.random(),
+  owner = undefined,
+  contractAddress = undefined,
+  txHash = randomTxHash(),
+  storageSlot = Fr.random(),
+  noteTypeId = NoteSelector.random(),
+}: Partial<ExtendedNote> = {}) => {
+  return new ExtendedNote(
+    note,
+    owner ?? (await AztecAddress.random()),
+    contractAddress ?? (await AztecAddress.random()),
+    storageSlot,
+    noteTypeId,
+    txHash,
+  );
+};
+
+export const randomUniqueNote = async ({
+  note = Note.random(),
+  owner = undefined,
+  contractAddress = undefined,
+  txHash = randomTxHash(),
+  storageSlot = Fr.random(),
+  noteTypeId = NoteSelector.random(),
+  nonce = Fr.random(),
+}: Partial<UniqueNote> = {}) => {
+  return new UniqueNote(
+    note,
+    owner ?? (await AztecAddress.random()),
+    contractAddress ?? (await AztecAddress.random()),
+    storageSlot,
+    noteTypeId,
+    txHash,
+    nonce,
+  );
+};
+
+export const mockPrivateCallExecutionResult = async (
+  seed = 1,
+  numberOfNonRevertiblePublicCallRequests = MAX_ENQUEUED_CALLS_PER_TX / 2,
+  numberOfRevertiblePublicCallRequests = MAX_ENQUEUED_CALLS_PER_TX / 2,
+  hasPublicTeardownCallRequest = false,
+) => {
+  const totalPublicCallRequests =
+    numberOfNonRevertiblePublicCallRequests +
+    numberOfRevertiblePublicCallRequests +
+    (hasPublicTeardownCallRequest ? 1 : 0);
+  const isForPublic = totalPublicCallRequests > 0;
+  let enqueuedPublicFunctionCalls: PublicExecutionRequest[] = [];
+  let publicTeardownFunctionCall = PublicExecutionRequest.empty();
+  if (isForPublic) {
+    const publicCallRequests = times(totalPublicCallRequests, i => makePublicCallRequest(seed + 0x102 + i)).reverse(); // Reverse it so that they are sorted by counters in descending order.
+    const publicFunctionArgs = times(totalPublicCallRequests, i => [new Fr(seed + i * 100), new Fr(seed + i * 101)]);
+    for (let i = 0; i < publicCallRequests.length; i++) {
+      const r = publicCallRequests[i];
+      r.argsHash = await computeVarArgsHash(publicFunctionArgs[i]);
+      i++;
+    }
+
+    if (hasPublicTeardownCallRequest) {
+      const request = publicCallRequests.shift()!;
+      const args = publicFunctionArgs.shift()!;
+      publicTeardownFunctionCall = new PublicExecutionRequest(CallContext.fromFields(request.toFields()), args);
+    }
+
+    enqueuedPublicFunctionCalls = publicCallRequests.map(
+      (r, i) => new PublicExecutionRequest(CallContext.fromFields(r.toFields()), publicFunctionArgs[i]),
+    );
+  }
+  return new PrivateCallExecutionResult(
+    Buffer.from(''),
+    Buffer.from(''),
+    new Map(),
+    PrivateCircuitPublicInputs.empty(),
+    new Map(),
+    [],
+    new Map(),
+    [],
+    [],
+    enqueuedPublicFunctionCalls.map((call, index) => new CountedPublicExecutionRequest(call, index)),
+    publicTeardownFunctionCall,
+    [],
+  );
+};
+
+export const mockPrivateExecutionResult = async (seed = 1) => {
+  return new PrivateExecutionResult(await mockPrivateCallExecutionResult(seed), Fr.zero());
+};
+
+export const mockTx = async (
+  seed = 1,
+  {
+    numberOfNonRevertiblePublicCallRequests = MAX_ENQUEUED_CALLS_PER_TX / 2,
+    numberOfRevertiblePublicCallRequests = MAX_ENQUEUED_CALLS_PER_TX / 2,
+    hasPublicTeardownCallRequest = false,
+    feePayer,
+    clientIvcProof = ClientIvcProof.empty(),
+  }: {
+    numberOfNonRevertiblePublicCallRequests?: number;
+    numberOfRevertiblePublicCallRequests?: number;
+    hasPublicTeardownCallRequest?: boolean;
+    feePayer?: AztecAddress;
+    clientIvcProof?: ClientIvcProof;
+  } = {},
+) => {
+  const totalPublicCallRequests =
+    numberOfNonRevertiblePublicCallRequests +
+    numberOfRevertiblePublicCallRequests +
+    (hasPublicTeardownCallRequest ? 1 : 0);
+  const isForPublic = totalPublicCallRequests > 0;
+  const data = PrivateKernelTailCircuitPublicInputs.empty();
+  const firstNullifier = new Nullifier(new Fr(seed + 1), 0, Fr.ZERO);
+  data.constants.txContext.gasSettings = GasSettings.default({ maxFeesPerGas: new GasFees(10, 10) });
+  data.feePayer = feePayer ?? (await AztecAddress.random());
+
+  let enqueuedPublicFunctionCalls: PublicExecutionRequest[] = [];
+  let publicTeardownFunctionCall = PublicExecutionRequest.empty();
+  if (!isForPublic) {
+    data.forRollup!.end.nullifiers[0] = firstNullifier.value;
+  } else {
+    data.forRollup = undefined;
+    data.forPublic = PartialPrivateTailPublicInputsForPublic.empty();
+
+    const revertibleBuilder = new PrivateToPublicAccumulatedDataBuilder();
+    const nonRevertibleBuilder = new PrivateToPublicAccumulatedDataBuilder();
+
+    const publicCallRequests = times(totalPublicCallRequests, i => makePublicCallRequest(seed + 0x102 + i)).reverse(); // Reverse it so that they are sorted by counters in descending order.
+    const publicFunctionArgs = times(totalPublicCallRequests, i => [new Fr(seed + i * 100), new Fr(seed + i * 101)]);
+    for (let i = 0; i < publicCallRequests.length; i++) {
+      const r = publicCallRequests[i];
+      r.argsHash = await computeVarArgsHash(publicFunctionArgs[i]);
+    }
+
+    if (hasPublicTeardownCallRequest) {
+      const request = publicCallRequests.shift()!;
+      data.forPublic.publicTeardownCallRequest = request;
+      const args = publicFunctionArgs.shift()!;
+      publicTeardownFunctionCall = new PublicExecutionRequest(CallContext.fromFields(request.toFields()), args);
+    }
+
+    enqueuedPublicFunctionCalls = publicCallRequests.map(
+      (r, i) => new PublicExecutionRequest(CallContext.fromFields(r.toFields()), publicFunctionArgs[i]),
+    );
+
+    data.forPublic.nonRevertibleAccumulatedData = nonRevertibleBuilder
+      .pushNullifier(firstNullifier.value)
+      .withPublicCallRequests(publicCallRequests.slice(numberOfRevertiblePublicCallRequests))
+      .build();
+
+    data.forPublic.revertibleAccumulatedData = revertibleBuilder
+      .withPublicCallRequests(publicCallRequests.slice(0, numberOfRevertiblePublicCallRequests))
+      .build();
+  }
+
+  const tx = new Tx(data, clientIvcProof, [], enqueuedPublicFunctionCalls, publicTeardownFunctionCall);
+
+  return tx;
+};
+
+export const mockTxForRollup = (seed = 1) =>
+  mockTx(seed, { numberOfNonRevertiblePublicCallRequests: 0, numberOfRevertiblePublicCallRequests: 0 });
+
+export const mockSimulatedTx = async (seed = 1) => {
+  const privateExecutionResult = await mockPrivateExecutionResult(seed);
+  const tx = await mockTx(seed);
+  const output = new PublicSimulationOutput(
+    undefined,
+    makeCombinedConstantData(),
+    await TxEffect.random(),
+    [accumulatePrivateReturnValues(privateExecutionResult)],
+    {
+      totalGas: makeGas(),
+      teardownGas: makeGas(),
+      publicGas: makeGas(),
+      billedGas: makeGas(),
+    },
+  );
+  return new TxSimulationResult(privateExecutionResult, tx.data, output);
+};
+
+export const randomContractArtifact = (): ContractArtifact => ({
+  name: randomBytes(4).toString('hex'),
+  functions: [],
+  outputs: {
+    structs: {},
+    globals: {},
+  },
+  fileMap: {},
+  storageLayout: {},
+  notes: {},
+});
+
+export const randomContractInstanceWithAddress = async (
+  opts: { contractClassId?: Fr } = {},
+  address?: AztecAddress,
+): Promise<ContractInstanceWithAddress> => {
+  const instance = await SerializableContractInstance.random(
+    opts.contractClassId
+      ? {
+          currentContractClassId: opts.contractClassId,
+          originalContractClassId: opts.contractClassId,
+        }
+      : undefined,
+  );
+  return instance.withAddress(address ?? (await computeContractAddressFromInstance(instance)));
+};
+
+export const randomDeployedContract = async () => {
+  const artifact = randomContractArtifact();
+  const { id: contractClassId } = await getContractClassFromArtifact(artifact);
+  return { artifact, instance: await randomContractInstanceWithAddress({ contractClassId }) };
+};
+
+export interface MakeConsensusPayloadOptions {
+  signer?: Secp256k1Signer;
+  header?: BlockHeader;
+  archive?: Fr;
+  txHashes?: TxHash[];
+}
+
+const makeAndSignConsensusPayload = async (
+  domainSeparator: SignatureDomainSeparator,
+  options?: MakeConsensusPayloadOptions,
+) => {
+  const {
+    signer = Secp256k1Signer.random(),
+    header = makeHeader(1),
+    archive = Fr.random(),
+    txHashes = [0, 1, 2, 3, 4, 5].map(() => TxHash.random()),
+  } = options ?? {};
+
+  const payload = ConsensusPayload.fromFields({
+    header,
+    archive,
+    txHashes,
+  });
+
+  const hash = await getHashedSignaturePayloadEthSignedMessage(payload, domainSeparator);
+  const signature = signer.sign(hash);
+
+  return { payload, signature };
+};
+
+export const makeBlockProposal = async (options?: MakeConsensusPayloadOptions): Promise<BlockProposal> => {
+  const { payload, signature } = await makeAndSignConsensusPayload(SignatureDomainSeparator.blockProposal, options);
+  return new BlockProposal(payload, signature);
+};
+
+// TODO(https://github.com/AztecProtocol/aztec-packages/issues/8028)
+export const makeBlockAttestation = async (options?: MakeConsensusPayloadOptions): Promise<BlockAttestation> => {
+  const { payload, signature } = await makeAndSignConsensusPayload(SignatureDomainSeparator.blockAttestation, options);
+  return new BlockAttestation(payload, signature);
+};

package/src/trees/append_only_tree_snapshot.ts

@@ -0,0 +1,95 @@
+import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+
+import { inspect } from 'util';
+import { z } from 'zod';
+
+import type { UInt32 } from '../types/shared.js';
+
+/**
+ * Snapshot of an append only tree.
+ *
+ * Used in circuits to verify that tree insertions are performed correctly.
+ */
+export class AppendOnlyTreeSnapshot {
+  constructor(
+    /**
+     * Root of the append only tree when taking the snapshot.
+     */
+    public root: Fr,
+    /**
+     * Index of the next available leaf in the append only tree.
+     *
+     * Note: We include the next available leaf index in the snapshot so that the snapshot can be used to verify that
+     *       the insertion was performed at the correct place. If we only verified tree root then it could happen that
+     *       some leaves would get overwritten and the tree root check would still pass.
+     *       TLDR: We need to store the next available leaf index to ensure that the "append only" property was
+     *             preserved when verifying state transitions.
+     */
+    public nextAvailableLeafIndex: UInt32,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        root: schemas.Fr,
+        nextAvailableLeafIndex: schemas.UInt32,
+      })
+      .transform(({ root, nextAvailableLeafIndex }) => new AppendOnlyTreeSnapshot(root, nextAvailableLeafIndex));
+  }
+
+  getSize() {
+    return this.root.size + 4;
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.root, this.nextAvailableLeafIndex);
+  }
+
+  toFields(): Fr[] {
+    return [this.root, new Fr(this.nextAvailableLeafIndex)];
+  }
+
+  toString(): string {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): AppendOnlyTreeSnapshot {
+    const reader = BufferReader.asReader(buffer);
+    return new AppendOnlyTreeSnapshot(Fr.fromBuffer(reader), reader.readNumber());
+  }
+
+  static fromString(str: string): AppendOnlyTreeSnapshot {
+    return AppendOnlyTreeSnapshot.fromBuffer(hexToBuffer(str));
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): AppendOnlyTreeSnapshot {
+    const reader = FieldReader.asReader(fields);
+
+    return new AppendOnlyTreeSnapshot(reader.readField(), Number(reader.readField().toBigInt()));
+  }
+
+  static zero() {
+    return new AppendOnlyTreeSnapshot(Fr.ZERO, 0);
+  }
+
+  isZero(): boolean {
+    return this.root.isZero() && this.nextAvailableLeafIndex === 0;
+  }
+
+  [inspect.custom]() {
+    return `AppendOnlyTreeSnapshot { root: ${this.root.toString()}, nextAvailableLeafIndex: ${
+      this.nextAvailableLeafIndex
+    } }`;
+  }
+
+  public equals(other: this) {
+    return this.root.equals(other.root) && this.nextAvailableLeafIndex === other.nextAvailableLeafIndex;
+  }
+
+  static random() {
+    return new AppendOnlyTreeSnapshot(Fr.random(), Math.floor(Math.random() * 1000));
+  }
+}

package/src/trees/index.ts

@@ -0,0 +1,8 @@
+export * from './nullifier_leaf.js';
+export * from './protocol_contract_leaf.js';
+export * from './public_data_leaf.js';
+export * from './append_only_tree_snapshot.js';
+export * from './merkle_tree_id.js';
+export * from './nullifier_membership_witness.js';
+export * from './public_data_witness.js';
+export * from '../interfaces/merkle_tree_operations.js';

package/src/trees/merkle_tree_id.ts

@@ -0,0 +1,42 @@
+import {
+  ARCHIVE_HEIGHT,
+  ARCHIVE_TREE_ID,
+  L1_TO_L2_MESSAGE_TREE_ID,
+  L1_TO_L2_MSG_TREE_HEIGHT,
+  NOTE_HASH_TREE_HEIGHT,
+  NOTE_HASH_TREE_ID,
+  NULLIFIER_TREE_HEIGHT,
+  NULLIFIER_TREE_ID,
+  PUBLIC_DATA_TREE_HEIGHT,
+  PUBLIC_DATA_TREE_ID,
+} from '@aztec/constants';
+
+/**
+ * Defines the possible Merkle tree IDs.
+ * @remarks The MerkleTrees class expects these to start from zero and be in incremental order.
+ */
+export enum MerkleTreeId {
+  NULLIFIER_TREE = NULLIFIER_TREE_ID, // 0
+  NOTE_HASH_TREE = NOTE_HASH_TREE_ID, // 1
+  PUBLIC_DATA_TREE = PUBLIC_DATA_TREE_ID, // 2
+  L1_TO_L2_MESSAGE_TREE = L1_TO_L2_MESSAGE_TREE_ID, // 3
+  ARCHIVE = ARCHIVE_TREE_ID, // 4
+}
+
+export const merkleTreeIds = () => {
+  return Object.values(MerkleTreeId).filter((v): v is MerkleTreeId => !isNaN(Number(v)));
+};
+
+const TREE_HEIGHTS = {
+  [MerkleTreeId.NOTE_HASH_TREE]: NOTE_HASH_TREE_HEIGHT,
+  [MerkleTreeId.ARCHIVE]: ARCHIVE_HEIGHT,
+  [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: L1_TO_L2_MSG_TREE_HEIGHT,
+  [MerkleTreeId.NULLIFIER_TREE]: NULLIFIER_TREE_HEIGHT,
+  [MerkleTreeId.PUBLIC_DATA_TREE]: PUBLIC_DATA_TREE_HEIGHT,
+} as const;
+
+export type TreeHeights = typeof TREE_HEIGHTS;
+
+export function getTreeHeight<TID extends MerkleTreeId>(treeId: TID): TreeHeights[TID] {
+  return TREE_HEIGHTS[treeId];
+}

package/src/trees/nullifier_leaf.ts

@@ -0,0 +1,133 @@
+import { toBigIntBE, toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader } from '@aztec/foundation/serialize';
+import type { IndexedTreeLeaf, IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
+
+import { z } from 'zod';
+
+/**
+ * Class containing the data of a preimage of a single leaf in the nullifier tree.
+ * Note: It's called preimage because this data gets hashed before being inserted as a node into the `IndexedTree`.
+ */
+export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
+  constructor(
+    /**
+     * Leaf value inside the indexed tree's linked list.
+     */
+    public nullifier: Fr,
+    /**
+     * Next value inside the indexed tree's linked list.
+     */
+    public nextNullifier: Fr,
+    /**
+     * Index of the next leaf in the indexed tree's linked list.
+     */
+    public nextIndex: bigint,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        nullifier: schemas.Fr,
+        nextNullifier: schemas.Fr,
+        nextIndex: schemas.BigInt,
+      })
+      .transform(
+        ({ nullifier, nextNullifier, nextIndex }) => new NullifierLeafPreimage(nullifier, nextNullifier, nextIndex),
+      );
+  }
+
+  getKey(): bigint {
+    return this.nullifier.toBigInt();
+  }
+
+  getNextKey(): bigint {
+    return this.nextNullifier.toBigInt();
+  }
+
+  getNextIndex(): bigint {
+    return this.nextIndex;
+  }
+
+  asLeaf(): NullifierLeaf {
+    return new NullifierLeaf(this.nullifier);
+  }
+
+  toBuffer(): Buffer {
+    return Buffer.concat(this.toHashInputs());
+  }
+
+  toHashInputs(): Buffer[] {
+    return [
+      Buffer.from(this.nullifier.toBuffer()),
+      Buffer.from(this.nextNullifier.toBuffer()),
+      Buffer.from(toBufferBE(this.nextIndex, 32)),
+    ];
+  }
+
+  toFields(): Fr[] {
+    return this.toHashInputs().map(buf => Fr.fromBuffer(buf));
+  }
+
+  clone(): NullifierLeafPreimage {
+    return new NullifierLeafPreimage(this.nullifier, this.nextNullifier, this.nextIndex);
+  }
+
+  static random() {
+    return new NullifierLeafPreimage(Fr.random(), Fr.random(), BigInt(Math.floor(Math.random() * 1000)));
+  }
+
+  static empty(): NullifierLeafPreimage {
+    return new NullifierLeafPreimage(Fr.ZERO, 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)));
+  }
+
+  static fromLeaf(leaf: NullifierLeaf, nextKey: bigint, nextIndex: bigint): NullifierLeafPreimage {
+    return new NullifierLeafPreimage(leaf.nullifier, new Fr(nextKey), nextIndex);
+  }
+
+  static clone(preimage: NullifierLeafPreimage): NullifierLeafPreimage {
+    return new NullifierLeafPreimage(preimage.nullifier, preimage.nextNullifier, preimage.nextIndex);
+  }
+}
+
+/**
+ * A nullifier to be inserted in the nullifier tree.
+ */
+export class NullifierLeaf implements IndexedTreeLeaf {
+  constructor(
+    /**
+     * Nullifier value.
+     */
+    public nullifier: Fr,
+  ) {}
+
+  getKey(): bigint {
+    return this.nullifier.toBigInt();
+  }
+
+  toBuffer(): Buffer {
+    return this.nullifier.toBuffer();
+  }
+
+  isEmpty(): boolean {
+    return this.nullifier.isZero();
+  }
+
+  updateTo(_another: NullifierLeaf): NullifierLeaf {
+    throw new Error('Nullifiers are create only');
+  }
+
+  static buildDummy(key: bigint): NullifierLeaf {
+    return new NullifierLeaf(new Fr(key));
+  }
+
+  static fromBuffer(buf: Buffer): NullifierLeaf {
+    return new NullifierLeaf(Fr.fromBuffer(buf));
+  }
+}