@aztec/simulator 0.0.0-test.0 → 0.0.1-commit.03f7ef2

package/dest/public/fixtures/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/public/fixtures/utils.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAI9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAC/F,OAAO,EAAE,GAAG,EAAwB,MAAM,mBAAmB,CAAC;AAW9D,OAAO,EAAE,KAAK,sBAAsB,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAKnE;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,cAAc,EAAE,EAAE,EAClB,sBAAsB,EAAE,sBAAsB,EAAE,EAChD,oBAAoB,EAAE,sBAAsB,EAAE,EAC9C,wBAAwB,CAAC,EAAE,sBAAsB,EACjD,QAAQ,eAAsB,EAC9B,gBAAgB,GAAE,GAAiB,GAClC,OAAO,CAAC,EAAE,CAAC,CAkDb;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,eAAsB,EAAE,gBAAgB,GAAE,GAAqB,GAAG,EAAE,CAoBlH;AAED,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,EAAE,EACN,aAAa,EAAE,mBAAmB,EAClC,sBAAsB,UAAQ,iBAiC/B;AAED,wBAAsB,0BAA0B,CAC9C,EAAE,EAAE,EAAE,EACN,gBAAgB,EAAE,2BAA2B,EAC7C,sBAAsB,UAAQ,iBA0C/B"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/public/fixtures/utils.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAGpD,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAC/F,OAAO,EAAE,GAAG,EAAwB,MAAM,mBAAmB,CAAC;AAU9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,OAAO,EAEL,eAAe,EAEf,6BAA6B,EAC7B,EAAE,EAGH,MAAM,kBAAkB,CAAC;AAI1B,MAAM,MAAM,qBAAqB,GAAG;IAClC,UAAU,CAAC,EAAE;QACX,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC;QAClB,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC;QAClB,UAAU,CAAC,EAAE,mBAAmB,EAAE,CAAC;KACpC,CAAC;IACF,aAAa,CAAC,EAAE;QACd,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC;QAClB,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC;QAClB,UAAU,CAAC,EAAE,mBAAmB,EAAE,CAAC;KACpC,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,iBAAiB,EAAE,qBAAqB,EACxC,iBAAiB,EAAE,6BAA6B,EAAE,EAClD,eAAe,EAAE,6BAA6B,EAAE,EAChD,mBAAmB,CAAC,EAAE,6BAA6B,EACnD,QAAQ,eAAsB,EAC9B,gBAAgB,GAAE,GAAiB,EACnC,OAAO,GAAE,eAAyC,GACjD,OAAO,CAAC,EAAE,CAAC,CA8Fb;AAED,wBAAsB,sBAAsB,CAC1C,QAAQ,eAAsB,EAC9B,gBAAgB,GAAE,GAAqB,GACtC,OAAO,CAAC,EAAE,CAAC,CA0Bb;AAED,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,EAAE,EACN,aAAa,EAAE,mBAAmB,EAClC,sBAAsB,UAAQ,iBA6B/B;AAED,wBAAsB,0BAA0B,CAC9C,EAAE,EAAE,EAAE,EACN,gBAAgB,EAAE,2BAA2B,EAC7C,sBAAsB,UAAQ,iBA0C/B"}

package/dest/public/fixtures/utils.js

@@ -1,84 +1,130 @@
-import { CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS, DEFAULT_GAS_LIMIT, DEPLOYER_CONTRACT_ADDRESS, MAX_L2_GAS_PER_TX_PUBLIC_PORTION, PRIVATE_LOG_SIZE_IN_FIELDS, REGISTERER_CONTRACT_ADDRESS, REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { assertLength } from '@aztec/foundation/serialize';
-import { DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG } from '@aztec/protocol-contracts';
+import { CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE, CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT, DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT, PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG } from '@aztec/protocol-contracts';
 import { bufferAsFields } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { Gas, GasFees, GasSettings } from '@aztec/stdlib/gas';
 import { siloNullifier } from '@aztec/stdlib/hash';
-import { PartialPrivateTailPublicInputsForPublic, PartialPrivateTailPublicInputsForRollup, PrivateKernelTailCircuitPublicInputs, RollupValidationRequests, ScopedLogHash, countAccumulatedItems } from '@aztec/stdlib/kernel';
-import { ContractClassLog, PrivateLog } from '@aztec/stdlib/logs';
-import { Tx } from '@aztec/stdlib/tx';
-import { BlockHeader, TxConstantData, TxContext } from '@aztec/stdlib/tx';
+import { LogHash, PartialPrivateTailPublicInputsForPublic, PartialPrivateTailPublicInputsForRollup, PrivateKernelTailCircuitPublicInputs, countAccumulatedItems } from '@aztec/stdlib/kernel';
+import { ContractClassLogFields, PrivateLog } from '@aztec/stdlib/logs';
+import { ChonkProof } from '@aztec/stdlib/proofs';
+import { BlockHeader, GlobalVariables, HashedValues, Tx, TxConstantData, TxContext } from '@aztec/stdlib/tx';
 import { strict as assert } from 'assert';
 /**
  * Craft a carrier transaction for some public calls for simulation by PublicTxSimulator.
- */ export async function createTxForPublicCalls(firstNullifier, setupExecutionRequests, appExecutionRequests, teardownExecutionRequest, feePayer = AztecAddress.zero(), gasUsedByPrivate = Gas.empty()) {
-    assert(setupExecutionRequests.length > 0 || appExecutionRequests.length > 0 || teardownExecutionRequest !== undefined, "Can't create public tx with no enqueued calls");
-    const setupCallRequests = await Promise.all(setupExecutionRequests.map((er)=>er.toCallRequest()));
-    const appCallRequests = await Promise.all(appExecutionRequests.map((er)=>er.toCallRequest()));
+ */ export async function createTxForPublicCalls(privateInsertions, setupCallRequests, appCallRequests, teardownCallRequest, feePayer = AztecAddress.zero(), gasUsedByPrivate = Gas.empty(), globals = GlobalVariables.empty()) {
+    assert(setupCallRequests.length > 0 || appCallRequests.length > 0 || teardownCallRequest !== undefined, "Can't create public tx with no enqueued calls");
     // use max limits
-    const gasLimits = new Gas(DEFAULT_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
+    const gasLimits = new Gas(DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT);
     const forPublic = PartialPrivateTailPublicInputsForPublic.empty();
-    // TODO(#9269): Remove this fake nullifier method as we move away from 1st nullifier as hash.
-    forPublic.nonRevertibleAccumulatedData.nullifiers[0] = firstNullifier;
-    // We reverse order because the simulator expects it to be like a "stack" of calls to pop from
-    for(let i = setupCallRequests.length - 1; i >= 0; i--){
-        forPublic.nonRevertibleAccumulatedData.publicCallRequests[i] = setupCallRequests[i];
+    // Non revertible private insertions
+    if (!privateInsertions.nonRevertible?.nullifiers?.length) {
+        throw new Error('At least one non-revertible nullifier is required');
     }
-    for(let i = appCallRequests.length - 1; i >= 0; i--){
-        forPublic.revertibleAccumulatedData.publicCallRequests[i] = appCallRequests[i];
+    for(let i = 0; i < privateInsertions.nonRevertible.nullifiers.length; i++){
+        assert(i < forPublic.nonRevertibleAccumulatedData.nullifiers.length, 'Nullifier index out of bounds');
+        forPublic.nonRevertibleAccumulatedData.nullifiers[i] = privateInsertions.nonRevertible.nullifiers[i];
     }
-    if (teardownExecutionRequest) {
-        forPublic.publicTeardownCallRequest = await teardownExecutionRequest.toCallRequest();
+    if (privateInsertions.nonRevertible.noteHashes) {
+        for(let i = 0; i < privateInsertions.nonRevertible.noteHashes.length; i++){
+            assert(i < forPublic.nonRevertibleAccumulatedData.noteHashes.length, 'Note hash index out of bounds');
+            forPublic.nonRevertibleAccumulatedData.noteHashes[i] = privateInsertions.nonRevertible.noteHashes[i];
+        }
+    }
+    if (privateInsertions.nonRevertible.l2ToL1Msgs) {
+        for(let i = 0; i < privateInsertions.nonRevertible.l2ToL1Msgs.length; i++){
+            assert(i < forPublic.nonRevertibleAccumulatedData.l2ToL1Msgs.length, 'L2 to L1 message index out of bounds');
+            forPublic.nonRevertibleAccumulatedData.l2ToL1Msgs[i] = privateInsertions.nonRevertible.l2ToL1Msgs[i];
+        }
+    }
+    // Revertible private insertions
+    if (privateInsertions.revertible) {
+        if (privateInsertions.revertible.noteHashes) {
+            for(let i = 0; i < privateInsertions.revertible.noteHashes.length; i++){
+                assert(i < forPublic.revertibleAccumulatedData.noteHashes.length, 'Note hash index out of bounds');
+                forPublic.revertibleAccumulatedData.noteHashes[i] = privateInsertions.revertible.noteHashes[i];
+            }
+        }
+        if (privateInsertions.revertible.nullifiers) {
+            for(let i = 0; i < privateInsertions.revertible.nullifiers.length; i++){
+                assert(i < forPublic.revertibleAccumulatedData.nullifiers.length, 'Nullifier index out of bounds');
+                forPublic.revertibleAccumulatedData.nullifiers[i] = privateInsertions.revertible.nullifiers[i];
+            }
+        }
+        if (privateInsertions.revertible.l2ToL1Msgs) {
+            for(let i = 0; i < privateInsertions.revertible.l2ToL1Msgs.length; i++){
+                assert(i < forPublic.revertibleAccumulatedData.l2ToL1Msgs.length, 'L2 to L1 message index out of bounds');
+                forPublic.revertibleAccumulatedData.l2ToL1Msgs[i] = privateInsertions.revertible.l2ToL1Msgs[i];
+            }
+        }
+    }
+    for(let i = 0; i < setupCallRequests.length; i++){
+        forPublic.nonRevertibleAccumulatedData.publicCallRequests[i] = setupCallRequests[i].request;
+    }
+    for(let i = 0; i < appCallRequests.length; i++){
+        forPublic.revertibleAccumulatedData.publicCallRequests[i] = appCallRequests[i].request;
+    }
+    if (teardownCallRequest) {
+        forPublic.publicTeardownCallRequest = teardownCallRequest.request;
     }
     const maxFeesPerGas = feePayer.isZero() ? GasFees.empty() : new GasFees(10, 10);
-    const teardownGasLimits = teardownExecutionRequest ? gasLimits : Gas.empty();
+    const teardownGasLimits = teardownCallRequest ? new Gas(DEFAULT_TEARDOWN_DA_GAS_LIMIT, DEFAULT_TEARDOWN_L2_GAS_LIMIT) : Gas.empty();
     const gasSettings = new GasSettings(gasLimits, teardownGasLimits, maxFeesPerGas, GasFees.empty());
     const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
-    const constantData = new TxConstantData(BlockHeader.empty(), txContext, Fr.zero(), Fr.zero());
-    const txData = new PrivateKernelTailCircuitPublicInputs(constantData, RollupValidationRequests.empty(), /*gasUsed=*/ gasUsedByPrivate, feePayer, forPublic);
-    const tx = Tx.newWithTxData(txData, teardownExecutionRequest);
-    // Reverse order because the simulator expects it to be like a "stack" of calls to pop from.
-    // Also push app calls before setup calls for this reason.
-    for(let i = appExecutionRequests.length - 1; i >= 0; i--){
-        tx.enqueuedPublicFunctionCalls.push(appExecutionRequests[i]);
-    }
-    for(let i = setupExecutionRequests.length - 1; i >= 0; i--){
-        tx.enqueuedPublicFunctionCalls.push(setupExecutionRequests[i]);
-    }
-    return tx;
+    const header = BlockHeader.empty({
+        globalVariables: globals
+    });
+    const constantData = new TxConstantData(header, txContext, Fr.zero(), Fr.zero());
+    const includeByTimestamp = 0n; // Not used in the simulator.
+    const txData = new PrivateKernelTailCircuitPublicInputs(constantData, /*gasUsed=*/ gasUsedByPrivate, feePayer, includeByTimestamp, forPublic);
+    const calldata = [
+        ...setupCallRequests,
+        ...appCallRequests,
+        ...teardownCallRequest ? [
+            teardownCallRequest
+        ] : []
+    ].map((r)=>new HashedValues(r.calldata, r.request.calldataHash));
+    return await Tx.create({
+        data: txData,
+        chonkProof: ChonkProof.random(),
+        contractClassLogFields: [],
+        publicFunctionCalldata: calldata
+    });
 }
-export function createTxForPrivateOnly(feePayer = AztecAddress.zero(), gasUsedByPrivate = new Gas(10, 10)) {
+export async function createTxForPrivateOnly(feePayer = AztecAddress.zero(), gasUsedByPrivate = new Gas(10, 10)) {
     // use max limits
-    const gasLimits = new Gas(DEFAULT_GAS_LIMIT, MAX_L2_GAS_PER_TX_PUBLIC_PORTION);
+    const gasLimits = new Gas(DEFAULT_DA_GAS_LIMIT, DEFAULT_L2_GAS_LIMIT);
     const forRollup = PartialPrivateTailPublicInputsForRollup.empty();
     const maxFeesPerGas = feePayer.isZero() ? GasFees.empty() : new GasFees(10, 10);
     const gasSettings = new GasSettings(gasLimits, Gas.empty(), maxFeesPerGas, GasFees.empty());
     const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
     const constantData = new TxConstantData(BlockHeader.empty(), txContext, Fr.zero(), Fr.zero());
-    const txData = new PrivateKernelTailCircuitPublicInputs(constantData, RollupValidationRequests.empty(), /*gasUsed=*/ gasUsedByPrivate, feePayer, /*forPublic=*/ undefined, forRollup);
-    return Tx.newWithTxData(txData);
+    const includeByTimestamp = 0n; // Not used in the simulator.
+    const txData = new PrivateKernelTailCircuitPublicInputs(constantData, /*gasUsed=*/ gasUsedByPrivate, feePayer, includeByTimestamp, /*forPublic=*/ undefined, forRollup);
+    return await Tx.create({
+        data: txData,
+        chonkProof: ChonkProof.empty(),
+        contractClassLogFields: [],
+        publicFunctionCalldata: []
+    });
 }
 export async function addNewContractClassToTx(tx, contractClass, skipNullifierInsertion = false) {
     const contractClassLogFields = [
-        new Fr(REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE),
+        new Fr(CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE),
         contractClass.id,
         new Fr(contractClass.version),
         new Fr(contractClass.artifactHash),
         new Fr(contractClass.privateFunctionsRoot),
         ...bufferAsFields(contractClass.packedBytecode, Math.ceil(contractClass.packedBytecode.length / 31) + 1)
     ];
-    const contractClassLog = ContractClassLog.fromFields([
-        new Fr(REGISTERER_CONTRACT_ADDRESS),
-        ...contractClassLogFields.concat(new Array(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS - contractClassLogFields.length).fill(Fr.ZERO))
-    ]);
-    const contractClassLogHash = ScopedLogHash.fromFields([
-        await contractClassLog.hash(),
-        new Fr(7),
-        new Fr(contractClassLog.getEmittedLength()),
-        new Fr(REGISTERER_CONTRACT_ADDRESS)
-    ]);
+    const contractAddress = new AztecAddress(new Fr(CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS));
+    const emittedLength = contractClassLogFields.length;
+    const logFields = ContractClassLogFields.fromEmittedFields(contractClassLogFields);
+    const contractClassLogHash = LogHash.from({
+        value: await logFields.hash(),
+        length: emittedLength
+    }).scope(contractAddress);
     const accumulatedData = tx.data.forPublic ? tx.data.forPublic.revertibleAccumulatedData : tx.data.forRollup.end;
     if (!skipNullifierInsertion) {
         const nextNullifierIndex = countAccumulatedItems(accumulatedData.nullifiers);
@@ -86,7 +132,7 @@ export async function addNewContractClassToTx(tx, contractClass, skipNullifierIn
     }
     const nextLogIndex = countAccumulatedItems(accumulatedData.contractClassLogsHashes);
     accumulatedData.contractClassLogsHashes[nextLogIndex] = contractClassLogHash;
-    tx.contractClassLogs.push(contractClassLog);
+    tx.contractClassLogFields.push(logFields);
 }
 export async function addNewContractInstanceToTx(tx, contractInstance, skipNullifierInsertion = false) {
     // can't use publicKeys.toFields() because it includes isInfinite which
@@ -101,21 +147,18 @@ export async function addNewContractInstanceToTx(tx, contractInstance, skipNulli
         contractInstance.publicKeys.masterTaggingPublicKey.x,
         contractInstance.publicKeys.masterTaggingPublicKey.y
     ];
-    const fields = [
-        DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_TAG,
+    const logFields = [
+        CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG,
         contractInstance.address.toField(),
         new Fr(contractInstance.version),
         new Fr(contractInstance.salt),
         contractInstance.currentContractClassId,
         contractInstance.initializationHash,
         ...publicKeysAsFields,
-        contractInstance.deployer.toField(),
-        new Fr(0),
-        new Fr(0),
-        new Fr(0)
+        contractInstance.deployer.toField()
     ];
-    const contractInstanceLog = new PrivateLog(assertLength(fields, PRIVATE_LOG_SIZE_IN_FIELDS));
-    const contractAddressNullifier = await siloNullifier(AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS), contractInstance.address.toField());
+    const contractInstanceLog = new PrivateLog(padArrayEnd(logFields, Fr.ZERO, PRIVATE_LOG_SIZE_IN_FIELDS), logFields.length);
+    const contractAddressNullifier = await siloNullifier(AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS), contractInstance.address.toField());
     const accumulatedData = tx.data.forPublic ? tx.data.forPublic.revertibleAccumulatedData : tx.data.forRollup.end;
     if (!skipNullifierInsertion) {
         const nextNullifierIndex = countAccumulatedItems(accumulatedData.nullifiers);

package/dest/public/fuzzing/avm_fuzzer_simulator.d.ts

@@ -0,0 +1,46 @@
+import { AvmTxHint, type PublicTxResult } from '@aztec/stdlib/avm';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+import type { NativeWorldStateService } from '@aztec/world-state';
+import { BaseAvmSimulationTester } from '../avm/fixtures/base_avm_simulation_tester.js';
+import { SimpleContractDataSource } from '../fixtures/simple_contract_data_source.js';
+/**
+ * Request structure for fuzzer simulation communication from C++.
+ * Matches the C++ FuzzerSimulationRequest struct
+ */
+export declare class FuzzerSimulationRequest {
+    readonly wsDataDir: string;
+    readonly wsMapSizeKb: number;
+    readonly tx: AvmTxHint;
+    readonly globals: GlobalVariables;
+    readonly contractClasses: any[];
+    readonly contractInstances: [any, any][];
+    constructor(wsDataDir: string, wsMapSizeKb: number, tx: AvmTxHint, globals: GlobalVariables, contractClasses: any[], contractInstances: [any, any][]);
+    static fromPlainObject(obj: any): FuzzerSimulationRequest;
+}
+/**
+ * A simulator class for the AVM fuzzer that extends BaseAvmSimulationTester.
+ * It provides methods for registering contracts from C++ msgpack data and simulating transactions.
+ */
+export declare class AvmFuzzerSimulator extends BaseAvmSimulationTester {
+    private simulator;
+    constructor(merkleTrees: MerkleTreeWriteOperations, contractDataSource: SimpleContractDataSource, globals: GlobalVariables);
+    /**
+     * Static factory method to create an AvmFuzzerSimulator.
+     */
+    static create(worldStateService: NativeWorldStateService, globals: GlobalVariables): Promise<AvmFuzzerSimulator>;
+    /**
+     * Simulate a transaction from a C++ AvmTxHint.
+     */
+    simulate(txHint: AvmTxHint): Promise<PublicTxResult>;
+    /**
+     * Add a contract class from C++ raw msgpack data.
+     */
+    addContractClassFromCpp(rawClass: any): Promise<void>;
+    /**
+     * Add a contract instance from C++ raw msgpack data.
+     * This also inserts the contract address nullifier into the nullifier tree.
+     */
+    addContractInstanceFromCpp(rawAddress: any, rawInstance: any): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXZtX2Z1enplcl9zaW11bGF0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wdWJsaWMvZnV6emluZy9hdm1fZnV6emVyX3NpbXVsYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFTQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssY0FBYyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFZbkUsT0FBTyxLQUFLLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNyRSxPQUFPLEVBQWUsZUFBZSxFQUF1RCxNQUFNLGtCQUFrQixDQUFDO0FBQ3JILE9BQU8sS0FBSyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFbEUsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sK0NBQStDLENBQUM7QUFDeEYsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sNENBQTRDLENBQUM7QUFJdEY7OztHQUdHO0FBQ0gscUJBQWEsdUJBQXVCO2FBRWhCLFNBQVMsRUFBRSxNQUFNO2FBQ2pCLFdBQVcsRUFBRSxNQUFNO2FBQ25CLEVBQUUsRUFBRSxTQUFTO2FBQ2IsT0FBTyxFQUFFLGVBQWU7YUFDeEIsZUFBZSxFQUFFLEdBQUcsRUFBRTthQUN0QixpQkFBaUIsRUFBRSxDQUFDLEdBQUcsRUFBRSxHQUFHLENBQUMsRUFBRTtJQU5qRCxZQUNrQixTQUFTLEVBQUUsTUFBTSxFQUNqQixXQUFXLEVBQUUsTUFBTSxFQUNuQixFQUFFLEVBQUUsU0FBUyxFQUNiLE9BQU8sRUFBRSxlQUFlLEVBQ3hCLGVBQWUsRUFBRSxHQUFHLEVBQUUsRUFDdEIsaUJBQWlCLEVBQUUsQ0FBQyxHQUFHLEVBQUUsR0FBRyxDQUFDLEVBQUUsRUFDN0M7SUFFSixNQUFNLENBQUMsZUFBZSxDQUFDLEdBQUcsRUFBRSxHQUFHLEdBQUcsdUJBQXVCLENBWXhEO0NBQ0Y7QUFtSEQ7OztHQUdHO0FBQ0gscUJBQWEsa0JBQW1CLFNBQVEsdUJBQXVCO0lBQzdELE9BQU8sQ0FBQyxTQUFTLENBQW9CO0lBRXJDLFlBQ0UsV0FBVyxFQUFFLHlCQUF5QixFQUN0QyxrQkFBa0IsRUFBRSx3QkFBd0IsRUFDNUMsT0FBTyxFQUFFLGVBQWUsRUFXekI7SUFFRDs7T0FFRztJQUNILE9BQW9CLE1BQU0sQ0FDeEIsaUJBQWlCLEVBQUUsdUJBQXVCLEVBQzFDLE9BQU8sRUFBRSxlQUFlLEdBQ3ZCLE9BQU8sQ0FBQyxrQkFBa0IsQ0FBQyxDQUk3QjtJQUVEOztPQUVHO0lBQ1UsUUFBUSxDQUFDLE1BQU0sRUFBRSxTQUFTLEdBQUcsT0FBTyxDQUFDLGNBQWMsQ0FBQyxDQVVoRTtJQUVEOztPQUVHO0lBQ1UsdUJBQXVCLENBQUMsUUFBUSxFQUFFLEdBQUcsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBR2pFO0lBRUQ7OztPQUdHO0lBQ1UsMEJBQTBCLENBQUMsVUFBVSxFQUFFLEdBQUcsRUFBRSxXQUFXLEVBQUUsR0FBRyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FJeEY7Q0FDRiJ9

package/dest/public/fuzzing/avm_fuzzer_simulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avm_fuzzer_simulator.d.ts","sourceRoot":"","sources":["../../../src/public/fuzzing/avm_fuzzer_simulator.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAYnE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAe,eAAe,EAAuD,MAAM,kBAAkB,CAAC;AACrH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAElE,OAAO,EAAE,uBAAuB,EAAE,MAAM,+CAA+C,CAAC;AACxF,OAAO,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AAItF;;;GAGG;AACH,qBAAa,uBAAuB;aAEhB,SAAS,EAAE,MAAM;aACjB,WAAW,EAAE,MAAM;aACnB,EAAE,EAAE,SAAS;aACb,OAAO,EAAE,eAAe;aACxB,eAAe,EAAE,GAAG,EAAE;aACtB,iBAAiB,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE;IANjD,YACkB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,EAAE,EAAE,SAAS,EACb,OAAO,EAAE,eAAe,EACxB,eAAe,EAAE,GAAG,EAAE,EACtB,iBAAiB,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAC7C;IAEJ,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,uBAAuB,CAYxD;CACF;AAmHD;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,uBAAuB;IAC7D,OAAO,CAAC,SAAS,CAAoB;IAErC,YACE,WAAW,EAAE,yBAAyB,EACtC,kBAAkB,EAAE,wBAAwB,EAC5C,OAAO,EAAE,eAAe,EAWzB;IAED;;OAEG;IACH,OAAoB,MAAM,CACxB,iBAAiB,EAAE,uBAAuB,EAC1C,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,kBAAkB,CAAC,CAI7B;IAED;;OAEG;IACU,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,cAAc,CAAC,CAUhE;IAED;;OAEG;IACU,uBAAuB,CAAC,QAAQ,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAGjE;IAED;;;OAGG;IACU,0BAA0B,CAAC,UAAU,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAIxF;CACF"}

package/dest/public/fuzzing/avm_fuzzer_simulator.js

@@ -0,0 +1,139 @@
+import { MAX_ENQUEUED_CALLS_PER_TX, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_PRIVATE_LOGS_PER_TX } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { AvmTxHint } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { contractClassPublicFromPlainObject, contractInstanceWithAddressFromPlainObject } from '@aztec/stdlib/contract';
+import { PartialPrivateTailPublicInputsForPublic, PrivateKernelTailCircuitPublicInputs, PrivateToPublicAccumulatedData, PublicCallRequest } from '@aztec/stdlib/kernel';
+import { PrivateLog } from '@aztec/stdlib/logs';
+import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
+import { ChonkProof } from '@aztec/stdlib/proofs';
+import { BlockHeader, GlobalVariables, HashedValues, Tx, TxConstantData, TxContext, TxHash } from '@aztec/stdlib/tx';
+import { BaseAvmSimulationTester } from '../avm/fixtures/base_avm_simulation_tester.js';
+import { SimpleContractDataSource } from '../fixtures/simple_contract_data_source.js';
+import { PublicContractsDB } from '../public_db_sources.js';
+import { PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
+/**
+ * Request structure for fuzzer simulation communication from C++.
+ * Matches the C++ FuzzerSimulationRequest struct
+ */ export class FuzzerSimulationRequest {
+    wsDataDir;
+    wsMapSizeKb;
+    tx;
+    globals;
+    contractClasses;
+    contractInstances;
+    constructor(wsDataDir, wsMapSizeKb, tx, globals, contractClasses, contractInstances){
+        this.wsDataDir = wsDataDir;
+        this.wsMapSizeKb = wsMapSizeKb;
+        this.tx = tx;
+        this.globals = globals;
+        this.contractClasses = contractClasses;
+        this.contractInstances = contractInstances;
+    }
+    static fromPlainObject(obj) {
+        if (obj instanceof FuzzerSimulationRequest) {
+            return obj;
+        }
+        return new FuzzerSimulationRequest(obj.wsDataDir, obj.wsMapSizeKb, AvmTxHint.fromPlainObject(obj.tx), GlobalVariables.fromPlainObject(obj.globals), obj.contractClasses, obj.contractInstances);
+    }
+}
+/**
+ * Creates a TypeScript Tx object from a deserialized C++ Tx (AvmTxHint-like structure).
+ * This allows using PublicTxSimulator.simulate() with fuzzer-generated transactions.
+ */ async function createTxFromHint(cppTx) {
+    // Create TxHash from the C++ tx hash string
+    if (!cppTx.hash) {
+        throw new Error(`cppTx.hash is undefined. Keys: ${Object.keys(cppTx || {}).join(', ')}`);
+    }
+    const txHash = TxHash.fromString(cppTx.hash);
+    // Extract PublicCallRequest instances from enqueued calls
+    const setupCallRequests = cppTx.setupEnqueuedCalls.map((call)=>call.request);
+    const paddedSetupCalls = padArrayEnd(setupCallRequests, PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX);
+    const appLogicCallRequests = cppTx.appLogicEnqueuedCalls.map((call)=>call.request);
+    const paddedAppLogicCalls = padArrayEnd(appLogicCallRequests, PublicCallRequest.empty(), MAX_ENQUEUED_CALLS_PER_TX);
+    // Build non-revertible accumulated data from C++ tx
+    const emptyNonRevertible = PrivateToPublicAccumulatedData.empty();
+    const nonRevertibleAccumulatedData = new PrivateToPublicAccumulatedData(padArrayEnd(cppTx.nonRevertibleAccumulatedData.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX), padArrayEnd(cppTx.nonRevertibleAccumulatedData.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX), padArrayEnd(cppTx.nonRevertibleAccumulatedData.l2ToL1Messages, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX), padArrayEnd(cppTx.nonRevertibleContractDeploymentData.privateLogs, PrivateLog.empty(), MAX_PRIVATE_LOGS_PER_TX), emptyNonRevertible.contractClassLogsHashes, paddedSetupCalls);
+    // Build revertible accumulated data from C++ tx
+    const emptyRevertible = PrivateToPublicAccumulatedData.empty();
+    const revertibleAccumulatedData = new PrivateToPublicAccumulatedData(padArrayEnd(cppTx.revertibleAccumulatedData.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX), padArrayEnd(cppTx.revertibleAccumulatedData.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX), padArrayEnd(cppTx.revertibleAccumulatedData.l2ToL1Messages, ScopedL2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_TX), padArrayEnd(cppTx.revertibleContractDeploymentData.privateLogs, PrivateLog.empty(), MAX_PRIVATE_LOGS_PER_TX), emptyRevertible.contractClassLogsHashes, paddedAppLogicCalls);
+    // Build teardown call request (if exists)
+    const teardownCallRequest = cppTx.teardownEnqueuedCall?.request ?? PublicCallRequest.empty();
+    // Create forPublic structure
+    const forPublic = new PartialPrivateTailPublicInputsForPublic(nonRevertibleAccumulatedData, revertibleAccumulatedData, teardownCallRequest);
+    // Build TxContext - gasSettings is already a proper GasSettings after AvmTxHint.fromPlainObject
+    const txContext = new TxContext(Fr.ZERO, Fr.ZERO, cppTx.gasSettings);
+    // Build TxConstantData
+    const constants = new TxConstantData(BlockHeader.empty(), txContext, Fr.ZERO, Fr.ZERO);
+    const data = new PrivateKernelTailCircuitPublicInputs(constants, cppTx.gasUsedByPrivate, cppTx.feePayer, 0n, forPublic, undefined);
+    // Build publicFunctionCalldata from all enqueued calls
+    // Calldata is already Fr[] after AvmTxHint.fromPlainObject
+    const publicFunctionCalldata = [];
+    // Add setup calls
+    for (const call of cppTx.setupEnqueuedCalls || []){
+        publicFunctionCalldata.push(await HashedValues.fromCalldata(call.calldata));
+    }
+    // Add app logic calls
+    for (const call of cppTx.appLogicEnqueuedCalls || []){
+        publicFunctionCalldata.push(await HashedValues.fromCalldata(call.calldata));
+    }
+    // Add teardown call if present
+    if (cppTx.teardownEnqueuedCall) {
+        publicFunctionCalldata.push(await HashedValues.fromCalldata(cppTx.teardownEnqueuedCall.calldata));
+    }
+    // Extract contract class log fields from ContractDeploymentData
+    const contractClassLogFields = [
+        ...cppTx.nonRevertibleContractDeploymentData.contractClassLogs.map((log)=>log.fields),
+        ...cppTx.revertibleContractDeploymentData.contractClassLogs.map((log)=>log.fields)
+    ];
+    // Create the Tx
+    return new Tx(txHash, data, ChonkProof.empty(), contractClassLogFields, publicFunctionCalldata);
+}
+/**
+ * A simulator class for the AVM fuzzer that extends BaseAvmSimulationTester.
+ * It provides methods for registering contracts from C++ msgpack data and simulating transactions.
+ */ export class AvmFuzzerSimulator extends BaseAvmSimulationTester {
+    simulator;
+    constructor(merkleTrees, contractDataSource, globals){
+        super(contractDataSource, merkleTrees);
+        const contractsDb = new PublicContractsDB(contractDataSource);
+        this.simulator = new PublicTxSimulator(merkleTrees, contractsDb, globals, {
+            skipFeeEnforcement: false,
+            collectDebugLogs: false,
+            collectHints: false,
+            collectStatistics: false,
+            collectCallMetadata: false
+        });
+    }
+    /**
+   * Static factory method to create an AvmFuzzerSimulator.
+   */ static async create(worldStateService, globals) {
+        const contractDataSource = new SimpleContractDataSource();
+        const merkleTrees = await worldStateService.fork();
+        return new AvmFuzzerSimulator(merkleTrees, contractDataSource, globals);
+    }
+    /**
+   * Simulate a transaction from a C++ AvmTxHint.
+   */ async simulate(txHint) {
+        // Compute fee from gas limits and max fees per gas (upper bound on fee)
+        const totalFee = BigInt(txHint.gasSettings.gasLimits.daGas) * txHint.gasSettings.maxFeesPerGas.feePerDaGas + BigInt(txHint.gasSettings.gasLimits.l2Gas) * txHint.gasSettings.maxFeesPerGas.feePerL2Gas;
+        await this.setFeePayerBalance(txHint.feePayer, new Fr(totalFee));
+        const tx = await createTxFromHint(txHint);
+        return await this.simulator.simulate(tx);
+    }
+    /**
+   * Add a contract class from C++ raw msgpack data.
+   */ async addContractClassFromCpp(rawClass) {
+        const contractClass = contractClassPublicFromPlainObject(rawClass);
+        await this.contractDataSource.addContractClass(contractClass);
+    }
+    /**
+   * Add a contract instance from C++ raw msgpack data.
+   * This also inserts the contract address nullifier into the nullifier tree.
+   */ async addContractInstanceFromCpp(rawAddress, rawInstance) {
+        const address = AztecAddress.fromPlainObject(rawAddress);
+        const instance = contractInstanceWithAddressFromPlainObject(address, rawInstance);
+        await this.addContractInstance(instance);
+    }
+}

package/dest/public/fuzzing/avm_simulator_bin.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXZtX3NpbXVsYXRvcl9iaW4uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wdWJsaWMvZnV6emluZy9hdm1fc2ltdWxhdG9yX2Jpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dest/public/fuzzing/avm_simulator_bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avm_simulator_bin.d.ts","sourceRoot":"","sources":["../../../src/public/fuzzing/avm_simulator_bin.ts"],"names":[],"mappings":""}

package/dest/public/fuzzing/avm_simulator_bin.js

@@ -0,0 +1,100 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { deserializeFromMessagePack, serializeWithMessagePack } from '@aztec/stdlib/avm';
+import { TreeSnapshots } from '@aztec/stdlib/tx';
+import { NativeWorldStateService } from '@aztec/world-state';
+import { writeSync } from 'fs';
+import { createInterface } from 'readline';
+import { AvmFuzzerSimulator, FuzzerSimulationRequest } from './avm_fuzzer_simulator.js';
+// This cache holds opened world states to avoid reopening them for each invocation.
+// It's a map so that in the future we could support multiple world states (if we had multiple fuzzers).
+const worldStateCache = new Map();
+async function openExistingWorldState(dataDir, mapSizeKb) {
+    const cached = worldStateCache.get(dataDir);
+    if (cached) {
+        return cached;
+    }
+    const ws = await NativeWorldStateService.new(EthAddress.ZERO, dataDir, {
+        archiveTreeMapSizeKb: mapSizeKb,
+        nullifierTreeMapSizeKb: mapSizeKb,
+        noteHashTreeMapSizeKb: mapSizeKb,
+        messageTreeMapSizeKb: mapSizeKb,
+        publicDataTreeMapSizeKb: mapSizeKb
+    });
+    worldStateCache.set(dataDir, ws);
+    return ws;
+}
+async function simulateWithFuzzer(dataDir, mapSizeKb, txHint, globals, rawContractClasses, rawContractInstances) {
+    const worldStateService = await openExistingWorldState(dataDir, mapSizeKb);
+    const simulator = await AvmFuzzerSimulator.create(worldStateService, globals);
+    // Register contract classes from C++
+    for (const rawClass of rawContractClasses){
+        await simulator.addContractClassFromCpp(rawClass);
+    }
+    // Register contract instances from C++
+    for (const [rawAddress, rawInstance] of rawContractInstances){
+        await simulator.addContractInstanceFromCpp(rawAddress, rawInstance);
+    }
+    const result = await simulator.simulate(txHint);
+    const output = result.getAppLogicReturnValues().flatMap((rv)=>rv?.values?.filter((v)=>v != null) ?? []);
+    return {
+        reverted: !result.revertCode.isOK(),
+        output,
+        revertReason: result.findRevertReason()?.message,
+        publicInputs: result.publicInputs
+    };
+}
+async function execute(base64Line) {
+    try {
+        // Decode base64 and deserialize the entire request from msgpack
+        const buffer = Buffer.from(base64Line.trim(), 'base64');
+        const rawRequest = deserializeFromMessagePack(buffer);
+        const request = FuzzerSimulationRequest.fromPlainObject(rawRequest);
+        // Run the TS simulation
+        const result = await simulateWithFuzzer(request.wsDataDir, request.wsMapSizeKb, request.tx, request.globals, request.contractClasses, request.contractInstances);
+        // Serialize the result to msgpack and encode it in base64 for output
+        const resultBuffer = serializeWithMessagePack({
+            reverted: result.reverted,
+            output: result.output,
+            revertReason: result.revertReason ?? '',
+            endTreeSnapshots: result.publicInputs.endTreeSnapshots
+        });
+        writeSync(process.stdout.fd, resultBuffer.toString('base64') + '\n');
+    } catch (error) {
+        // If we error, treat as reverted
+        const errorResult = serializeWithMessagePack({
+            reverted: true,
+            output: [],
+            revertReason: `Unexpected Error ${error.message}`,
+            endTreeSnapshots: TreeSnapshots.empty()
+        });
+        writeSync(process.stdout.fd, errorResult.toString('base64') + '\n');
+    }
+}
+function mainLoop() {
+    const rl = createInterface({
+        input: process.stdin,
+        terminal: false
+    });
+    // Process lines sequentially to avoid race conditions in responses
+    const lineQueue = [];
+    let processing = false;
+    async function processQueue() {
+        if (processing || lineQueue.length === 0) {
+            return;
+        }
+        processing = true;
+        while(lineQueue.length > 0){
+            const line = lineQueue.shift();
+            await execute(line);
+        }
+        processing = false;
+    }
+    rl.on('line', (line)=>{
+        if (line.trim()) {
+            lineQueue.push(line);
+            void processQueue();
+        }
+    });
+    rl.on('close', ()=>process.exit(0));
+}
+void mainLoop();

package/dest/public/hinting_db_sources.d.ts

@@ -0,0 +1,80 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { IndexedTreeLeafPreimage, SiblingPath } from '@aztec/foundation/trees';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import { type AvmExecutionHints } from '@aztec/stdlib/avm';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import { type BatchInsertionResult, type IndexedTreeId, MerkleTreeId, type MerkleTreeLeafType, type MerkleTreeWriteOperations, type SequentialInsertionResult, type TreeHeights } from '@aztec/stdlib/trees';
+import type { UInt64 } from '@aztec/stdlib/types';
+import type { WorldStateRevision } from '@aztec/stdlib/world-state';
+import type { PublicContractsDBInterface } from './db_interfaces.js';
+/**
+ * A public contracts database that forwards requests and collects AVM hints.
+ */
+export declare class HintingPublicContractsDB implements PublicContractsDBInterface {
+    private readonly db;
+    private hints;
+    private static readonly log;
+    private checkpointActionCounter;
+    private nextCheckpointId;
+    private checkpointStack;
+    constructor(db: PublicContractsDBInterface, hints: AvmExecutionHints);
+    getContractInstance(address: AztecAddress, timestamp: UInt64): Promise<ContractInstanceWithAddress | undefined>;
+    getContractClass(contractClassId: Fr): Promise<ContractClassPublic | undefined>;
+    getBytecodeCommitment(contractClassId: Fr): Promise<Fr | undefined>;
+    getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
+    createCheckpoint(): void;
+    commitCheckpoint(): void;
+    revertCheckpoint(): void;
+    private getHintKey;
+    private getCurrentCheckpointId;
+}
+/**
+ * A low-level merkle DB that collects hints.
+ */
+export declare class HintingMerkleWriteOperations implements MerkleTreeWriteOperations {
+    private db;
+    private hints;
+    private static readonly log;
+    private checkpointStack;
+    private nextCheckpointId;
+    private checkpointActionCounter;
+    static create(db: MerkleTreeWriteOperations, hints: AvmExecutionHints): Promise<HintingMerkleWriteOperations>;
+    private constructor();
+    getSiblingPath<ID extends MerkleTreeId>(treeId: ID, index: bigint): Promise<SiblingPath<TreeHeights[ID]>>;
+    getPreviousValueIndex<ID extends IndexedTreeId>(treeId: ID, value: bigint): Promise<{
+        index: bigint;
+        alreadyPresent: boolean;
+    } | undefined>;
+    getLeafPreimage<ID extends IndexedTreeId>(treeId: ID, index: bigint): Promise<IndexedTreeLeafPreimage | undefined>;
+    getLeafValue<ID extends MerkleTreeId>(treeId: ID, index: bigint): Promise<MerkleTreeLeafType<typeof treeId> | undefined>;
+    sequentialInsert<TreeHeight extends number, ID extends IndexedTreeId>(treeId: ID, leaves: Buffer[]): Promise<SequentialInsertionResult<TreeHeight>>;
+    appendLeaves<ID extends MerkleTreeId>(treeId: ID, leaves: MerkleTreeLeafType<ID>[]): Promise<void>;
+    createCheckpoint(): Promise<void>;
+    commitAllCheckpoints(): Promise<void>;
+    revertAllCheckpoints(): Promise<void>;
+    commitCheckpoint(): Promise<void>;
+    revertCheckpoint(): Promise<void>;
+    private getHintKey;
+    private getCurrentCheckpointId;
+    private getTreesStateHash;
+    private static logTreeChange;
+    private appendLeafInternal;
+    getTreeInfo(treeId: MerkleTreeId): Promise<import("@aztec/stdlib/trees").TreeInfo>;
+    getStateReference(): Promise<import("@aztec/stdlib/tx").StateReference>;
+    getInitialHeader(): import("@aztec/stdlib/tx").BlockHeader;
+    getRevision(): WorldStateRevision;
+    updateArchive(header: any): Promise<void>;
+    batchInsert<TreeHeight extends number, SubtreeSiblingPathHeight extends number, ID extends IndexedTreeId>(treeId: ID, leaves: Buffer[], subtreeHeight: number): Promise<BatchInsertionResult<TreeHeight, SubtreeSiblingPathHeight>>;
+    close(): Promise<void>;
+    [Symbol.dispose](): Promise<void>;
+    findLeafIndices<ID extends MerkleTreeId>(treeId: ID, values: MerkleTreeLeafType<ID>[]): Promise<(bigint | undefined)[]>;
+    findSiblingPaths<ID extends MerkleTreeId>(treeId: ID, values: MerkleTreeLeafType<ID>[]): Promise<({
+        path: SiblingPath<TreeHeights[ID]>;
+        index: bigint;
+    } | undefined)[]>;
+    findLeafIndicesAfter<ID extends MerkleTreeId>(treeId: ID, values: MerkleTreeLeafType<ID>[], startIndex: bigint): Promise<(bigint | undefined)[]>;
+    getBlockNumbersForLeafIndices<ID extends MerkleTreeId>(treeId: ID, leafIndices: bigint[]): Promise<(BlockNumber | undefined)[]>;
+}
+//# sourceMappingURL=data:application/json;base64,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