@aztec/stdlib 0.77.0-testnet-ignition.17

package/dest/tests/fixtures.d.ts

@@ -0,0 +1,6 @@
+import { type ContractArtifact } from '../abi/index.js';
+export declare function getBenchmarkContractArtifact(): ContractArtifact;
+export declare function getTestContractArtifact(): ContractArtifact;
+export declare function getTokenContractArtifact(): ContractArtifact;
+export declare function getPathToFixture(name: string): string;
+//# sourceMappingURL=fixtures.d.ts.map

package/dest/tests/fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/tests/fixtures.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,gBAAgB,EAAwB,MAAM,iBAAiB,CAAC;AAI9E,wBAAgB,4BAA4B,IAAI,gBAAgB,CAI/D;AAGD,wBAAgB,uBAAuB,IAAI,gBAAgB,CAI1D;AAGD,wBAAgB,wBAAwB,IAAI,gBAAgB,CAI3D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,UAE5C"}

package/dest/tests/fixtures.js

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

package/dest/tests/index.d.ts

@@ -0,0 +1,3 @@
+export * from './factories.js';
+export * from './mocks.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/tests/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tests/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC"}

package/dest/tests/index.js

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

package/dest/tests/jest.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 declare function equalL2Blocks(a: any, b: any): boolean | undefined;
+//# sourceMappingURL=jest.d.ts.map

package/dest/tests/jest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest.d.ts","sourceRoot":"","sources":["../../src/tests/jest.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,uBAe3C"}

package/dest/tests/jest.js

@@ -0,0 +1,26 @@
+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, b) {
+    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/dest/tests/mocks.d.ts

@@ -0,0 +1,43 @@
+import { Secp256k1Signer } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import type { ContractArtifact } from '../abi/abi.js';
+import { AztecAddress } from '../aztec-address/index.js';
+import type { ContractInstanceWithAddress } from '../contract/index.js';
+import { ExtendedNote, UniqueNote } from '../note/extended_note.js';
+import { BlockAttestation } from '../p2p/block_attestation.js';
+import { BlockProposal } from '../p2p/block_proposal.js';
+import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import { BlockHeader, PrivateCallExecutionResult, PrivateExecutionResult, Tx } from '../tx/index.js';
+import { TxSimulationResult } from '../tx/simulated_tx.js';
+import { TxHash } from '../tx/tx_hash.js';
+export declare const randomTxHash: () => TxHash;
+export declare const randomExtendedNote: ({ note, owner, contractAddress, txHash, storageSlot, noteTypeId, }?: Partial<ExtendedNote>) => Promise<ExtendedNote>;
+export declare const randomUniqueNote: ({ note, owner, contractAddress, txHash, storageSlot, noteTypeId, nonce, }?: Partial<UniqueNote>) => Promise<UniqueNote>;
+export declare const mockPrivateCallExecutionResult: (seed?: number, numberOfNonRevertiblePublicCallRequests?: number, numberOfRevertiblePublicCallRequests?: number, hasPublicTeardownCallRequest?: boolean) => Promise<PrivateCallExecutionResult>;
+export declare const mockPrivateExecutionResult: (seed?: number) => Promise<PrivateExecutionResult>;
+export declare const mockTx: (seed?: number, { numberOfNonRevertiblePublicCallRequests, numberOfRevertiblePublicCallRequests, hasPublicTeardownCallRequest, feePayer, clientIvcProof, }?: {
+    numberOfNonRevertiblePublicCallRequests?: number;
+    numberOfRevertiblePublicCallRequests?: number;
+    hasPublicTeardownCallRequest?: boolean;
+    feePayer?: AztecAddress;
+    clientIvcProof?: ClientIvcProof;
+}) => Promise<Tx>;
+export declare const mockTxForRollup: (seed?: number) => Promise<Tx>;
+export declare const mockSimulatedTx: (seed?: number) => Promise<TxSimulationResult>;
+export declare const randomContractArtifact: () => ContractArtifact;
+export declare const randomContractInstanceWithAddress: (opts?: {
+    contractClassId?: Fr;
+}, address?: AztecAddress) => Promise<ContractInstanceWithAddress>;
+export declare const randomDeployedContract: () => Promise<{
+    artifact: ContractArtifact;
+    instance: ContractInstanceWithAddress;
+}>;
+export interface MakeConsensusPayloadOptions {
+    signer?: Secp256k1Signer;
+    header?: BlockHeader;
+    archive?: Fr;
+    txHashes?: TxHash[];
+}
+export declare const makeBlockProposal: (options?: MakeConsensusPayloadOptions) => Promise<BlockProposal>;
+export declare const makeBlockAttestation: (options?: MakeConsensusPayloadOptions) => Promise<BlockAttestation>;
+//# sourceMappingURL=mocks.d.ts.map

package/dest/tests/mocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mocks.d.ts","sourceRoot":"","sources":["../../src/tests/mocks.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAe,MAAM,0BAA0B,CAAC;AACxE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAIzD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AAWxE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAEpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAGzD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EACL,WAAW,EAGX,0BAA0B,EAC1B,sBAAsB,EAEtB,EAAE,EACH,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,kBAAkB,EAAiC,MAAM,uBAAuB,CAAC;AAE1F,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAG1C,eAAO,MAAM,YAAY,QAAO,MAAyB,CAAC;AAE1D,eAAO,MAAM,kBAAkB,wEAO5B,QAAQ,YAAY,CAAC,0BASvB,CAAC;AAEF,eAAO,MAAM,gBAAgB,+EAQ1B,QAAQ,UAAU,CAAC,wBAUrB,CAAC;AAEF,eAAO,MAAM,8BAA8B,iMA8C1C,CAAC;AAEF,eAAO,MAAM,0BAA0B,oDAEtC,CAAC;AAEF,eAAO,MAAM,MAAM,+JAQd;IACD,uCAAuC,CAAC,EAAE,MAAM,CAAC;IACjD,oCAAoC,CAAC,EAAE,MAAM,CAAC;IAC9C,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC,gBAsDF,CAAC;AAEF,eAAO,MAAM,eAAe,gCAC2E,CAAC;AAExG,eAAO,MAAM,eAAe,gDAgB3B,CAAC;AAEF,eAAO,MAAM,sBAAsB,QAAO,gBAUxC,CAAC;AAEH,eAAO,MAAM,iCAAiC,UACtC;IAAE,eAAe,CAAC,EAAE,EAAE,CAAA;CAAE,YACpB,YAAY,KACrB,QAAQ,2BAA2B,CAUrC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;EAIlC,CAAC;AAEF,MAAM,WAAW,2BAA2B;IAC1C,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,OAAO,CAAC,EAAE,EAAE,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAyBD,eAAO,MAAM,iBAAiB,aAAoB,2BAA2B,KAAG,QAAQ,aAAa,CAGpG,CAAC;AAGF,eAAO,MAAM,oBAAoB,aAAoB,2BAA2B,KAAG,QAAQ,gBAAgB,CAG1G,CAAC"}

package/dest/tests/mocks.js

@@ -0,0 +1,179 @@
+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 { 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 { 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 { 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.random();
+export const randomExtendedNote = async ({ note = Note.random(), owner = undefined, contractAddress = undefined, txHash = randomTxHash(), storageSlot = Fr.random(), noteTypeId = NoteSelector.random() } = {})=>{
+    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() } = {})=>{
+    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 = [];
+    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() } = {})=>{
+    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 = [];
+    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 = ()=>({
+        name: randomBytes(4).toString('hex'),
+        functions: [],
+        outputs: {
+            structs: {},
+            globals: {}
+        },
+        fileMap: {},
+        storageLayout: {},
+        notes: {}
+    });
+export const randomContractInstanceWithAddress = async (opts = {}, address)=>{
+    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
+        })
+    };
+};
+const makeAndSignConsensusPayload = async (domainSeparator, options)=>{
+    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)=>{
+    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)=>{
+    const { payload, signature } = await makeAndSignConsensusPayload(SignatureDomainSeparator.blockAttestation, options);
+    return new BlockAttestation(payload, signature);
+};

package/dest/trees/append_only_tree_snapshot.d.ts

@@ -0,0 +1,70 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+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 declare class AppendOnlyTreeSnapshot {
+    /**
+     * Root of the append only tree when taking the snapshot.
+     */
+    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.
+     */
+    nextAvailableLeafIndex: UInt32;
+    constructor(
+    /**
+     * Root of the append only tree when taking the snapshot.
+     */
+    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.
+     */
+    nextAvailableLeafIndex: UInt32);
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        root: z.ZodType<Fr, any, string>;
+        nextAvailableLeafIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        root: Fr;
+        nextAvailableLeafIndex: number;
+    }, {
+        root: string;
+        nextAvailableLeafIndex: string | number | bigint;
+    }>, AppendOnlyTreeSnapshot, {
+        root: string;
+        nextAvailableLeafIndex: string | number | bigint;
+    }>;
+    getSize(): number;
+    toBuffer(): Buffer;
+    toFields(): Fr[];
+    toString(): string;
+    static fromBuffer(buffer: Buffer | BufferReader): AppendOnlyTreeSnapshot;
+    static fromString(str: string): AppendOnlyTreeSnapshot;
+    static fromFields(fields: Fr[] | FieldReader): AppendOnlyTreeSnapshot;
+    static zero(): AppendOnlyTreeSnapshot;
+    isZero(): boolean;
+    [inspect.custom](): string;
+    equals(other: this): boolean;
+    static random(): AppendOnlyTreeSnapshot;
+}
+//# sourceMappingURL=append_only_tree_snapshot.d.ts.map

package/dest/trees/append_only_tree_snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"append_only_tree_snapshot.d.ts","sourceRoot":"","sources":["../../src/trees/append_only_tree_snapshot.ts"],"names":[],"mappings":";;;AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,6BAA6B,CAAC;AAG3F,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;GAIG;AACH,qBAAa,sBAAsB;IAE/B;;OAEG;IACI,IAAI,EAAE,EAAE;IACf;;;;;;;;OAQG;IACI,sBAAsB,EAAE,MAAM;;IAbrC;;OAEG;IACI,IAAI,EAAE,EAAE;IACf;;;;;;;;OAQG;IACI,sBAAsB,EAAE,MAAM;IAGvC,MAAM,KAAK,MAAM;;;;;;;;;;;;OAOhB;IAED,OAAO;IAIP,QAAQ;IAIR,QAAQ,IAAI,EAAE,EAAE;IAIhB,QAAQ,IAAI,MAAM;IAIlB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,sBAAsB;IAKxE,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,sBAAsB;IAItD,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,sBAAsB;IAMrE,MAAM,CAAC,IAAI;IAIX,MAAM,IAAI,OAAO;IAIjB,CAAC,OAAO,CAAC,MAAM,CAAC;IAMT,MAAM,CAAC,KAAK,EAAE,IAAI;IAIzB,MAAM,CAAC,MAAM;CAGd"}

package/dest/trees/append_only_tree_snapshot.js

@@ -0,0 +1,75 @@
+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';
+/**
+ * Snapshot of an append only tree.
+ *
+ * Used in circuits to verify that tree insertions are performed correctly.
+ */ export class AppendOnlyTreeSnapshot {
+    root;
+    nextAvailableLeafIndex;
+    constructor(/**
+     * Root of the append only tree when taking the snapshot.
+     */ root, /**
+     * 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.
+     */ nextAvailableLeafIndex){
+        this.root = root;
+        this.nextAvailableLeafIndex = nextAvailableLeafIndex;
+    }
+    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() {
+        return [
+            this.root,
+            new Fr(this.nextAvailableLeafIndex)
+        ];
+    }
+    toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new AppendOnlyTreeSnapshot(Fr.fromBuffer(reader), reader.readNumber());
+    }
+    static fromString(str) {
+        return AppendOnlyTreeSnapshot.fromBuffer(hexToBuffer(str));
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new AppendOnlyTreeSnapshot(reader.readField(), Number(reader.readField().toBigInt()));
+    }
+    static zero() {
+        return new AppendOnlyTreeSnapshot(Fr.ZERO, 0);
+    }
+    isZero() {
+        return this.root.isZero() && this.nextAvailableLeafIndex === 0;
+    }
+    [inspect.custom]() {
+        return `AppendOnlyTreeSnapshot { root: ${this.root.toString()}, nextAvailableLeafIndex: ${this.nextAvailableLeafIndex} }`;
+    }
+    equals(other) {
+        return this.root.equals(other.root) && this.nextAvailableLeafIndex === other.nextAvailableLeafIndex;
+    }
+    static random() {
+        return new AppendOnlyTreeSnapshot(Fr.random(), Math.floor(Math.random() * 1000));
+    }
+}

package/dest/trees/index.d.ts

@@ -0,0 +1,9 @@
+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';
+//# sourceMappingURL=index.d.ts.map

package/dest/trees/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/trees/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,mCAAmC,CAAC;AAClD,cAAc,0BAA0B,CAAC;AACzC,cAAc,yCAAyC,CAAC"}

package/dest/trees/index.js

@@ -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/dest/trees/merkle_tree_id.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Defines the possible Merkle tree IDs.
+ * @remarks The MerkleTrees class expects these to start from zero and be in incremental order.
+ */
+export declare enum MerkleTreeId {
+    NULLIFIER_TREE = 0,// 0
+    NOTE_HASH_TREE = 1,// 1
+    PUBLIC_DATA_TREE = 2,// 2
+    L1_TO_L2_MESSAGE_TREE = 3,// 3
+    ARCHIVE = 4
+}
+export declare const merkleTreeIds: () => MerkleTreeId[];
+declare const TREE_HEIGHTS: {
+    readonly 1: 40;
+    readonly 4: 29;
+    readonly 3: 39;
+    readonly 0: 40;
+    readonly 2: 40;
+};
+export type TreeHeights = typeof TREE_HEIGHTS;
+export declare function getTreeHeight<TID extends MerkleTreeId>(treeId: TID): TreeHeights[TID];
+export {};
+//# sourceMappingURL=merkle_tree_id.d.ts.map

package/dest/trees/merkle_tree_id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merkle_tree_id.d.ts","sourceRoot":"","sources":["../../src/trees/merkle_tree_id.ts"],"names":[],"mappings":"AAaA;;;GAGG;AACH,oBAAY,YAAY;IACtB,cAAc,IAAoB,CAAE,IAAI;IACxC,cAAc,IAAoB,CAAE,IAAI;IACxC,gBAAgB,IAAsB,CAAE,IAAI;IAC5C,qBAAqB,IAA2B,CAAE,IAAI;IACtD,OAAO,IAAkB;CAC1B;AAED,eAAO,MAAM,aAAa,sBAEzB,CAAC;AAEF,QAAA,MAAM,YAAY;;;;;;CAMR,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,OAAO,YAAY,CAAC;AAE9C,wBAAgB,aAAa,CAAC,GAAG,SAAS,YAAY,EAAE,MAAM,EAAE,GAAG,GAAG,WAAW,CAAC,GAAG,CAAC,CAErF"}

package/dest/trees/merkle_tree_id.js

@@ -0,0 +1,25 @@
+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 var MerkleTreeId = /*#__PURE__*/ function(MerkleTreeId) {
+    MerkleTreeId[MerkleTreeId["NULLIFIER_TREE"] = NULLIFIER_TREE_ID] = "NULLIFIER_TREE";
+    MerkleTreeId[MerkleTreeId["NOTE_HASH_TREE"] = NOTE_HASH_TREE_ID] = "NOTE_HASH_TREE";
+    MerkleTreeId[MerkleTreeId["PUBLIC_DATA_TREE"] = PUBLIC_DATA_TREE_ID] = "PUBLIC_DATA_TREE";
+    MerkleTreeId[MerkleTreeId["L1_TO_L2_MESSAGE_TREE"] = L1_TO_L2_MESSAGE_TREE_ID] = "L1_TO_L2_MESSAGE_TREE";
+    MerkleTreeId[MerkleTreeId["ARCHIVE"] = ARCHIVE_TREE_ID] = "ARCHIVE";
+    return MerkleTreeId;
+}({});
+export const merkleTreeIds = ()=>{
+    return Object.values(MerkleTreeId).filter((v)=>!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
+};
+export function getTreeHeight(treeId) {
+    return TREE_HEIGHTS[treeId];
+}

package/dest/trees/nullifier_leaf.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+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 declare class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
+    /**
+     * Leaf value inside the indexed tree's linked list.
+     */
+    nullifier: Fr;
+    /**
+     * Next value inside the indexed tree's linked list.
+     */
+    nextNullifier: Fr;
+    /**
+     * Index of the next leaf in the indexed tree's linked list.
+     */
+    nextIndex: bigint;
+    constructor(
+    /**
+     * Leaf value inside the indexed tree's linked list.
+     */
+    nullifier: Fr, 
+    /**
+     * Next value inside the indexed tree's linked list.
+     */
+    nextNullifier: Fr, 
+    /**
+     * Index of the next leaf in the indexed tree's linked list.
+     */
+    nextIndex: bigint);
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        nullifier: z.ZodType<Fr, any, string>;
+        nextNullifier: z.ZodType<Fr, any, string>;
+        nextIndex: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    }, "strip", z.ZodTypeAny, {
+        nullifier: Fr;
+        nextNullifier: Fr;
+        nextIndex: bigint;
+    }, {
+        nullifier: string;
+        nextNullifier: string;
+        nextIndex: string | number | bigint;
+    }>, NullifierLeafPreimage, {
+        nullifier: string;
+        nextNullifier: string;
+        nextIndex: string | number | bigint;
+    }>;
+    getKey(): bigint;
+    getNextKey(): bigint;
+    getNextIndex(): bigint;
+    asLeaf(): NullifierLeaf;
+    toBuffer(): Buffer;
+    toHashInputs(): Buffer[];
+    toFields(): Fr[];
+    clone(): NullifierLeafPreimage;
+    static random(): NullifierLeafPreimage;
+    static empty(): NullifierLeafPreimage;
+    static fromBuffer(buffer: Buffer | BufferReader): NullifierLeafPreimage;
+    static fromLeaf(leaf: NullifierLeaf, nextKey: bigint, nextIndex: bigint): NullifierLeafPreimage;
+    static clone(preimage: NullifierLeafPreimage): NullifierLeafPreimage;
+}
+/**
+ * A nullifier to be inserted in the nullifier tree.
+ */
+export declare class NullifierLeaf implements IndexedTreeLeaf {
+    /**
+     * Nullifier value.
+     */
+    nullifier: Fr;
+    constructor(
+    /**
+     * Nullifier value.
+     */
+    nullifier: Fr);
+    getKey(): bigint;
+    toBuffer(): Buffer;
+    isEmpty(): boolean;
+    updateTo(_another: NullifierLeaf): NullifierLeaf;
+    static buildDummy(key: bigint): NullifierLeaf;
+    static fromBuffer(buf: Buffer): NullifierLeaf;
+}
+//# sourceMappingURL=nullifier_leaf.d.ts.map

package/dest/trees/nullifier_leaf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullifier_leaf.d.ts","sourceRoot":"","sources":["../../src/trees/nullifier_leaf.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAExF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,qBAAa,qBAAsB,YAAW,uBAAuB;IAEjE;;OAEG;IACI,SAAS,EAAE,EAAE;IACpB;;OAEG;IACI,aAAa,EAAE,EAAE;IACxB;;OAEG;IACI,SAAS,EAAE,MAAM;;IAXxB;;OAEG;IACI,SAAS,EAAE,EAAE;IACpB;;OAEG;IACI,aAAa,EAAE,EAAE;IACxB;;OAEG;IACI,SAAS,EAAE,MAAM;IAG1B,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;OAUhB;IAED,MAAM,IAAI,MAAM;IAIhB,UAAU,IAAI,MAAM;IAIpB,YAAY,IAAI,MAAM;IAItB,MAAM,IAAI,aAAa;IAIvB,QAAQ,IAAI,MAAM;IAIlB,YAAY,IAAI,MAAM,EAAE;IAQxB,QAAQ,IAAI,EAAE,EAAE;IAIhB,KAAK,IAAI,qBAAqB;IAI9B,MAAM,CAAC,MAAM;IAIb,MAAM,CAAC,KAAK,IAAI,qBAAqB;IAIrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,qBAAqB;IAKvE,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,qBAAqB;IAI/F,MAAM,CAAC,KAAK,CAAC,QAAQ,EAAE,qBAAqB,GAAG,qBAAqB;CAGrE;AAED;;GAEG;AACH,qBAAa,aAAc,YAAW,eAAe;IAEjD;;OAEG;IACI,SAAS,EAAE,EAAE;;IAHpB;;OAEG;IACI,SAAS,EAAE,EAAE;IAGtB,MAAM,IAAI,MAAM;IAIhB,QAAQ,IAAI,MAAM;IAIlB,OAAO,IAAI,OAAO;IAIlB,QAAQ,CAAC,QAAQ,EAAE,aAAa,GAAG,aAAa;IAIhD,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa;IAI7C,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa;CAG9C"}