@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.017a351

package/dest/public/fuzzing/avm_simulator_bin.js

@@ -0,0 +1,118 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { PublicTxEffect, deserializeFromMessagePack, serializeWithMessagePack } from '@aztec/stdlib/avm';
+import { TreeSnapshots } from '@aztec/stdlib/tx';
+import { NativeWorldStateService } from '@aztec/world-state';
+import { createInterface } from 'readline';
+import { AvmFuzzerSimulator, FuzzerSimulationRequest } from './avm_fuzzer_simulator.js';
+/** Write data to stdout, letting Node handle buffering. */ function writeOutput(data) {
+    return new Promise((resolve, reject)=>{
+        process.stdout.write(data, (err)=>{
+            if (err) {
+                reject(err);
+            } else {
+                resolve();
+            }
+        });
+    });
+}
+// 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, rawPublicDataWrites, rawNoteHashes, protocolContracts) {
+    const worldStateService = await openExistingWorldState(dataDir, mapSizeKb);
+    const simulator = await AvmFuzzerSimulator.create(worldStateService, globals, protocolContracts);
+    await simulator.applyNoteHashes(rawNoteHashes);
+    // Register contract classes from C++ (must happen before public data writes to match C++ order)
+    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);
+    }
+    // Apply public data writes after contract registration (e.g., for bytecode upgrades)
+    // This must happen last to match C++ setup_fuzzer_state ordering
+    await simulator.applyPublicDataWrites(rawPublicDataWrites);
+    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,
+        publicTxEffect: result.publicTxEffect
+    };
+}
+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, request.publicDataWrites, request.noteHashes, request.protocolContracts);
+        // 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,
+            publicTxEffect: result.publicTxEffect
+        });
+        const base64Response = resultBuffer.toString('base64') + '\n';
+        await writeOutput(base64Response);
+    } catch (error) {
+        // If we error, treat as reverted
+        const errorResult = serializeWithMessagePack({
+            reverted: true,
+            output: [],
+            revertReason: `Unexpected Error ${error.message}`,
+            endTreeSnapshots: TreeSnapshots.empty(),
+            publicTxEffect: PublicTxEffect.empty()
+        });
+        await writeOutput(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,81 @@
+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<number>;
+    commitAllCheckpointsTo(_depth: number): Promise<void>;
+    revertAllCheckpointsTo(_depth: number): 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;
+    getSocketPath(): string;
+    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.asyncDispose](): 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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

package/dest/public/hinting_db_sources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hinting_db_sources.d.ts","sourceRoot":"","sources":["../../src/public/hinting_db_sources.ts"],"names":[],"mappings":"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"}

package/dest/public/hinting_db_sources.js

@@ -0,0 +1,359 @@
+var _computedKey;
+import { sha256Trunc } from '@aztec/foundation/crypto/sha256';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { AvmAppendLeavesHint, AvmBytecodeCommitmentHint, AvmCommitCheckpointHint, AvmContractClassHint, AvmContractDbCommitCheckpointHint, AvmContractDbCreateCheckpointHint, AvmContractDbRevertCheckpointHint, AvmContractInstanceHint, AvmCreateCheckpointHint, AvmDebugFunctionNameHint, AvmGetLeafPreimageHintNullifierTree, AvmGetLeafPreimageHintPublicDataTree, AvmGetLeafValueHint, AvmGetPreviousValueIndexHint, AvmGetSiblingPathHint, AvmRevertCheckpointHint, AvmSequentialInsertHintNullifierTree, AvmSequentialInsertHintPublicDataTree } from '@aztec/stdlib/avm';
+import { AppendOnlyTreeSnapshot, MerkleTreeId, NullifierLeaf, PublicDataTreeLeaf, getTreeName, merkleTreeIds } from '@aztec/stdlib/trees';
+import { TreeSnapshots } from '@aztec/stdlib/tx';
+import { strict as assert } from 'assert';
+/**
+ * A public contracts database that forwards requests and collects AVM hints.
+ */ export class HintingPublicContractsDB {
+    db;
+    hints;
+    static log = createLogger('simulator:hinting-public-contracts-db');
+    checkpointActionCounter;
+    nextCheckpointId;
+    checkpointStack;
+    constructor(db, hints){
+        this.db = db;
+        this.hints = hints;
+        this.checkpointActionCounter = 0;
+        this.nextCheckpointId = 1;
+        this.checkpointStack = [
+            0
+        ];
+    }
+    async getContractInstance(address, timestamp) {
+        const instance = await this.db.getContractInstance(address, timestamp);
+        if (instance) {
+            const hintKey = this.getHintKey();
+            this.hints.contractInstances.push(new AvmContractInstanceHint(hintKey, instance.address, instance.salt, instance.deployer, instance.currentContractClassId, instance.originalContractClassId, instance.initializationHash, instance.immutablesHash, instance.publicKeys));
+            HintingPublicContractsDB.log.trace(`[getContractInstance:${hintKey}] Added contract instance ${instance.address.toString()} to hints.`);
+        }
+        return instance;
+    }
+    async getContractClass(contractClassId) {
+        const contractClass = await this.db.getContractClass(contractClassId);
+        if (contractClass) {
+            const hintKey = this.getHintKey();
+            this.hints.contractClasses.push(new AvmContractClassHint(hintKey, contractClass.id, contractClass.artifactHash, contractClass.privateFunctionsRoot, contractClass.packedBytecode));
+            HintingPublicContractsDB.log.trace(`[getContractClass:${hintKey}] Added contract class ${contractClassId.toString()} to hints.`);
+        }
+        return contractClass;
+    }
+    async getBytecodeCommitment(contractClassId) {
+        const commitment = await this.db.getBytecodeCommitment(contractClassId);
+        if (commitment) {
+            const hintKey = this.getHintKey();
+            this.hints.bytecodeCommitments.push(new AvmBytecodeCommitmentHint(hintKey, contractClassId, commitment));
+            HintingPublicContractsDB.log.trace(`[getBytecodeCommitment:${hintKey}] Added bytecode commitment ${commitment.toString()} to hints for contract class ${contractClassId.toString()}.`);
+        }
+        return commitment;
+    }
+    async getDebugFunctionName(contractAddress, selector) {
+        const name = await this.db.getDebugFunctionName(contractAddress, selector);
+        if (name) {
+            HintingPublicContractsDB.log.debug(`[getDebugFunctionName] Adding debug function name ${name} to hints for contract ${contractAddress.toString()} and selector ${selector.toString()}.`);
+            // We hint selector as a field to make things way simpler in C++.
+            this.hints.debugFunctionNames.push(new AvmDebugFunctionNameHint(contractAddress, selector.toField(), name));
+        }
+        return name;
+    }
+    createCheckpoint() {
+        const hintKey = this.getHintKey();
+        this.checkpointActionCounter++;
+        const oldCheckpointId = this.getCurrentCheckpointId();
+        this.db.createCheckpoint();
+        const newCheckpointId = this.nextCheckpointId++;
+        this.checkpointStack.push(newCheckpointId);
+        this.hints.contractDbCreateCheckpointHints.push(new AvmContractDbCreateCheckpointHint(hintKey, oldCheckpointId, newCheckpointId));
+        HintingPublicContractsDB.log.trace(`[createCheckpoint:${hintKey}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId}.`);
+    }
+    commitCheckpoint() {
+        const hintKey = this.getHintKey();
+        this.checkpointActionCounter++;
+        const oldCheckpointId = this.getCurrentCheckpointId();
+        this.db.commitCheckpoint();
+        this.checkpointStack.pop();
+        const newCheckpointId = this.getCurrentCheckpointId();
+        this.hints.contractDbCommitCheckpointHints.push(new AvmContractDbCommitCheckpointHint(hintKey, oldCheckpointId, newCheckpointId));
+        HintingPublicContractsDB.log.trace(`[commitCheckpoint:${hintKey}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId}.`);
+    }
+    revertCheckpoint() {
+        const hintKey = this.getHintKey();
+        this.checkpointActionCounter++;
+        const oldCheckpointId = this.getCurrentCheckpointId();
+        this.db.revertCheckpoint();
+        this.checkpointStack.pop();
+        const newCheckpointId = this.getCurrentCheckpointId();
+        this.hints.contractDbRevertCheckpointHints.push(new AvmContractDbRevertCheckpointHint(hintKey, oldCheckpointId, newCheckpointId));
+        HintingPublicContractsDB.log.trace(`[revertCheckpoint:${hintKey}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId}.`);
+    }
+    // Private methods.
+    getHintKey() {
+        return this.checkpointActionCounter;
+    }
+    getCurrentCheckpointId() {
+        return this.checkpointStack[this.checkpointStack.length - 1];
+    }
+}
+_computedKey = Symbol.asyncDispose;
+/**
+ * A low-level merkle DB that collects hints.
+ */ export class HintingMerkleWriteOperations {
+    db;
+    hints;
+    static log = createLogger('simulator:hinting-merkle-db');
+    // This stack is only for debugging purposes.
+    // The top of the stack is the current checkpoint id.
+    // We need the stack to be non-empty and use 0 as an arbitrary initial checkpoint id.
+    // This is not necessarily a checkpoint that happened, but whatever tree state we start with.
+    checkpointStack;
+    nextCheckpointId;
+    checkpointActionCounter;
+    static async create(db, hints) {
+        const hintingTreesDB = new HintingMerkleWriteOperations(db, hints);
+        const startStateReference = await db.getStateReference();
+        hints.startingTreeRoots = new TreeSnapshots(startStateReference.l1ToL2MessageTree, startStateReference.partial.noteHashTree, startStateReference.partial.nullifierTree, startStateReference.partial.publicDataTree);
+        return hintingTreesDB;
+    }
+    // Use create() to instantiate.
+    constructor(db, hints){
+        this.db = db;
+        this.hints = hints;
+        this.checkpointStack = [
+            0
+        ];
+        this.nextCheckpointId = 1;
+        this.checkpointActionCounter = 0;
+    }
+    // Getters.
+    async getSiblingPath(treeId, index) {
+        const path = await this.db.getSiblingPath(treeId, index);
+        const key = await this.getHintKey(treeId);
+        this.hints.getSiblingPathHints.push(new AvmGetSiblingPathHint(key, treeId, index, path.toFields()));
+        return Promise.resolve(path);
+    }
+    async getPreviousValueIndex(treeId, value) {
+        const result = await this.db.getPreviousValueIndex(treeId, value);
+        if (result === undefined) {
+            throw new Error(`getPreviousValueIndex(${getTreeName(treeId)}, ${value}}) returned undefined. Possible wrong tree setup or corrupted state.`);
+        }
+        const key = await this.getHintKey(treeId);
+        this.hints.getPreviousValueIndexHints.push(new AvmGetPreviousValueIndexHint(key, treeId, new Fr(value), result.index, result.alreadyPresent));
+        return result;
+    }
+    async getLeafPreimage(treeId, index) {
+        const preimage = await this.db.getLeafPreimage(treeId, index);
+        if (preimage) {
+            const key = await this.getHintKey(treeId);
+            switch(treeId){
+                case MerkleTreeId.PUBLIC_DATA_TREE:
+                    this.hints.getLeafPreimageHintsPublicDataTree.push(new AvmGetLeafPreimageHintPublicDataTree(key, index, preimage));
+                    break;
+                case MerkleTreeId.NULLIFIER_TREE:
+                    this.hints.getLeafPreimageHintsNullifierTree.push(new AvmGetLeafPreimageHintNullifierTree(key, index, preimage));
+                    break;
+                default:
+                    // Use getLeafValue for the other trees.
+                    throw new Error('getLeafPreimage only supported for PublicDataTree and NullifierTree!');
+                    break;
+            }
+        }
+        return preimage;
+    }
+    async getLeafValue(treeId, index) {
+        // Use getLeafPreimage for PublicDataTree and NullifierTree.
+        assert(treeId == MerkleTreeId.NOTE_HASH_TREE || treeId == MerkleTreeId.L1_TO_L2_MESSAGE_TREE);
+        const value = await this.db.getLeafValue(treeId, index);
+        if (value) {
+            const key = await this.getHintKey(treeId);
+            // We can cast to Fr because we know the type of the tree.
+            this.hints.getLeafValueHints.push(new AvmGetLeafValueHint(key, treeId, index, value));
+        }
+        return value;
+    }
+    // State modification.
+    // FIXME(fcarreiro): This is a horrible interface (in the merkle ops). It's receiving the leaves as buffers,
+    // from a leaf class that is NOT the one that will be used to write. Make this type safe.
+    async sequentialInsert(treeId, leaves) {
+        // Use appendLeaf for NoteHashTree and L1ToL2MessageTree.
+        assert(treeId == MerkleTreeId.PUBLIC_DATA_TREE || treeId == MerkleTreeId.NULLIFIER_TREE);
+        // We only support 1 leaf at a time for now. Can easily be extended.
+        assert(leaves.length === 1, 'sequentialInsert supports only one leaf at a time!');
+        const beforeState = await this.getHintKey(treeId);
+        const result = await this.db.sequentialInsert(treeId, leaves);
+        const afterState = await this.getHintKey(treeId);
+        HintingMerkleWriteOperations.logTreeChange('sequentialInsert', beforeState, afterState, treeId);
+        switch(treeId){
+            case MerkleTreeId.PUBLIC_DATA_TREE:
+                this.hints.sequentialInsertHintsPublicDataTree.push(new AvmSequentialInsertHintPublicDataTree(beforeState, afterState, treeId, PublicDataTreeLeaf.fromBuffer(leaves[0]), {
+                    leaf: result.lowLeavesWitnessData[0].leafPreimage,
+                    index: result.lowLeavesWitnessData[0].index,
+                    path: result.lowLeavesWitnessData[0].siblingPath.toFields()
+                }, {
+                    leaf: result.insertionWitnessData[0].leafPreimage,
+                    index: result.insertionWitnessData[0].index,
+                    path: result.insertionWitnessData[0].siblingPath.toFields()
+                }));
+                break;
+            case MerkleTreeId.NULLIFIER_TREE:
+                this.hints.sequentialInsertHintsNullifierTree.push(new AvmSequentialInsertHintNullifierTree(beforeState, afterState, treeId, NullifierLeaf.fromBuffer(leaves[0]), {
+                    leaf: result.lowLeavesWitnessData[0].leafPreimage,
+                    index: result.lowLeavesWitnessData[0].index,
+                    path: result.lowLeavesWitnessData[0].siblingPath.toFields()
+                }, {
+                    leaf: result.insertionWitnessData[0].leafPreimage,
+                    index: result.insertionWitnessData[0].index,
+                    path: result.insertionWitnessData[0].siblingPath.toFields()
+                }));
+                break;
+            default:
+                throw new Error('sequentialInsert only supported for PublicDataTree and NullifierTree!');
+                break;
+        }
+        return result;
+    }
+    async appendLeaves(treeId, leaves) {
+        // Use sequentialInsert for PublicDataTree and NullifierTree.
+        assert(treeId == MerkleTreeId.NOTE_HASH_TREE || treeId == MerkleTreeId.L1_TO_L2_MESSAGE_TREE);
+        // We need to process each leaf individually because we need the sibling path after insertion, to be able to constraint the insertion.
+        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/13380): This can be changed if the world state appendLeaves returns the sibling paths.
+        if (leaves.length === 1) {
+            await this.appendLeafInternal(treeId, leaves[0]);
+            return;
+        } else {
+            // TODO(dbanks12): NON-HINTING! We skip hinting here for now because:
+            // 1. We only ever append multiple leaves (for now) when padding (all empty leaves).
+            // 2. We don't need hints per-item when padding.
+            // 3. In order to get per-item hints today, you need to append one-at-a-time (mentioned above), which is VERY slow.
+            await this.db.appendLeaves(treeId, leaves);
+        }
+    }
+    async createCheckpoint() {
+        const actionCounter = this.checkpointActionCounter++;
+        const oldCheckpointId = this.getCurrentCheckpointId();
+        const treesStateHash = await this.getTreesStateHash();
+        const depth = await this.db.createCheckpoint();
+        this.checkpointStack.push(this.nextCheckpointId++);
+        const newCheckpointId = this.getCurrentCheckpointId();
+        this.hints.createCheckpointHints.push(new AvmCreateCheckpointHint(actionCounter, oldCheckpointId, newCheckpointId));
+        HintingMerkleWriteOperations.log.trace(`[createCheckpoint:${actionCounter}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId} at trees state ${treesStateHash}.`);
+        return depth;
+    }
+    commitAllCheckpointsTo(_depth) {
+        throw new Error('commitAllCheckpointsTo is not supported in HintingMerkleWriteOperations.');
+    }
+    revertAllCheckpointsTo(_depth) {
+        throw new Error('revertAllCheckpointsTo is not supported in HintingMerkleWriteOperations.');
+    }
+    async commitCheckpoint() {
+        const actionCounter = this.checkpointActionCounter++;
+        const oldCheckpointId = this.getCurrentCheckpointId();
+        const treesStateHash = await this.getTreesStateHash();
+        await this.db.commitCheckpoint();
+        this.checkpointStack.pop();
+        const newCheckpointId = this.getCurrentCheckpointId();
+        this.hints.commitCheckpointHints.push(new AvmCommitCheckpointHint(actionCounter, oldCheckpointId, newCheckpointId));
+        HintingMerkleWriteOperations.log.trace(`[commitCheckpoint:${actionCounter}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId} at trees state ${treesStateHash}.`);
+    }
+    async revertCheckpoint() {
+        const actionCounter = this.checkpointActionCounter++;
+        const oldCheckpointId = this.getCurrentCheckpointId();
+        const treesStateHash = await this.getTreesStateHash();
+        const beforeState = {
+            [MerkleTreeId.PUBLIC_DATA_TREE]: await this.getHintKey(MerkleTreeId.PUBLIC_DATA_TREE),
+            [MerkleTreeId.NULLIFIER_TREE]: await this.getHintKey(MerkleTreeId.NULLIFIER_TREE),
+            [MerkleTreeId.NOTE_HASH_TREE]: await this.getHintKey(MerkleTreeId.NOTE_HASH_TREE),
+            [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: await this.getHintKey(MerkleTreeId.L1_TO_L2_MESSAGE_TREE),
+            [MerkleTreeId.ARCHIVE]: await this.getHintKey(MerkleTreeId.ARCHIVE)
+        };
+        await this.db.revertCheckpoint();
+        this.checkpointStack.pop();
+        const newCheckpointId = this.getCurrentCheckpointId();
+        const afterState = {
+            [MerkleTreeId.PUBLIC_DATA_TREE]: await this.getHintKey(MerkleTreeId.PUBLIC_DATA_TREE),
+            [MerkleTreeId.NULLIFIER_TREE]: await this.getHintKey(MerkleTreeId.NULLIFIER_TREE),
+            [MerkleTreeId.NOTE_HASH_TREE]: await this.getHintKey(MerkleTreeId.NOTE_HASH_TREE),
+            [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: await this.getHintKey(MerkleTreeId.L1_TO_L2_MESSAGE_TREE),
+            [MerkleTreeId.ARCHIVE]: await this.getHintKey(MerkleTreeId.ARCHIVE)
+        };
+        this.hints.revertCheckpointHints.push(AvmRevertCheckpointHint.create(actionCounter, oldCheckpointId, newCheckpointId, beforeState, afterState));
+        HintingMerkleWriteOperations.log.trace(`[revertCheckpoint:${actionCounter}] Checkpoint evolved ${oldCheckpointId} -> ${newCheckpointId} at trees state ${treesStateHash}.`);
+        for (const treeId of merkleTreeIds()){
+            HintingMerkleWriteOperations.logTreeChange('revertCheckpoint', beforeState[treeId], afterState[treeId], treeId);
+        }
+    }
+    // Private methods.
+    async getHintKey(treeId) {
+        const treeInfo = await this.db.getTreeInfo(treeId);
+        return new AppendOnlyTreeSnapshot(Fr.fromBuffer(treeInfo.root), Number(treeInfo.size));
+    }
+    getCurrentCheckpointId() {
+        return this.checkpointStack[this.checkpointStack.length - 1];
+    }
+    // For logging/debugging purposes.
+    async getTreesStateHash() {
+        const stateReferenceFields = (await this.db.getStateReference()).toFields();
+        return Fr.fromBuffer(sha256Trunc(Buffer.concat(stateReferenceFields.map((field)=>field.toBuffer()))));
+    }
+    static logTreeChange(action, beforeState, afterState, treeId) {
+        const treeName = getTreeName(treeId);
+        HintingMerkleWriteOperations.log.trace(`[${action}] ${treeName} tree state: ${beforeState.root}, ${beforeState.nextAvailableLeafIndex} -> ${afterState.root}, ${afterState.nextAvailableLeafIndex}.`);
+    }
+    async appendLeafInternal(treeId, leaf) {
+        // Use sequentialInsert for PublicDataTree and NullifierTree.
+        assert(treeId == MerkleTreeId.NOTE_HASH_TREE || treeId == MerkleTreeId.L1_TO_L2_MESSAGE_TREE);
+        const beforeState = await this.getHintKey(treeId);
+        await this.db.appendLeaves(treeId, [
+            leaf
+        ]);
+        const afterState = await this.getHintKey(treeId);
+        HintingMerkleWriteOperations.logTreeChange('appendLeaves', beforeState, afterState, treeId);
+        this.hints.appendLeavesHints.push(new AvmAppendLeavesHint(beforeState, afterState, treeId, [
+            leaf
+        ]));
+        return await this.getSiblingPath(treeId, BigInt(beforeState.nextAvailableLeafIndex));
+    }
+    // Non-hinted required methods from MerkleTreeWriteOperations interface
+    async getTreeInfo(treeId) {
+        return await this.db.getTreeInfo(treeId);
+    }
+    async getStateReference() {
+        return await this.db.getStateReference();
+    }
+    getInitialHeader() {
+        return this.db.getInitialHeader();
+    }
+    getRevision() {
+        return this.db.getRevision();
+    }
+    getSocketPath() {
+        return this.db.getSocketPath();
+    }
+    async updateArchive(header) {
+        return await this.db.updateArchive(header);
+    }
+    async batchInsert(treeId, leaves, subtreeHeight) {
+        return await this.db.batchInsert(treeId, leaves, subtreeHeight);
+    }
+    async close() {
+        return await this.db.close();
+    }
+    async [_computedKey]() {
+        await this.close();
+    }
+    async findLeafIndices(treeId, values) {
+        return await this.db.findLeafIndices(treeId, values);
+    }
+    findSiblingPaths(treeId, values) {
+        return this.db.findSiblingPaths(treeId, values);
+    }
+    async findLeafIndicesAfter(treeId, values, startIndex) {
+        return await this.db.findLeafIndicesAfter(treeId, values, startIndex);
+    }
+    async getBlockNumbersForLeafIndices(treeId, leafIndices) {
+        return await this.db.getBlockNumbersForLeafIndices(treeId, leafIndices);
+    }
+}

package/dest/public/index.d.ts

@@ -1,10 +1,7 @@
-export * from '../common/db_interfaces.js';
-export * from './public_tx_simulator/public_tx_simulator.js';
-export { type EnqueuedPublicCallExecutionResult, type PublicFunctionCallResult } from './execution.js';
-export * from './public_db_sources.js';
+export { PublicContractsDB } from './public_db_sources.js';
+export { GuardedMerkleTreeOperations } from './public_processor/guarded_merkle_tree.js';
 export { PublicProcessor, PublicProcessorFactory } from './public_processor/public_processor.js';
-export { SideEffectTrace } from './side_effect_trace.js';
-export { getExecutionRequestsByPhase } from './utils.js';
-export { PublicTxSimulationTester } from './fixtures/index.js';
-export * from './avm/index.js';
-//# sourceMappingURL=index.d.ts.map
+export { CppPublicTxSimulator, createPublicTxSimulatorForBlockBuilding, DumpingCppPublicTxSimulator, type PublicTxSimulatorInterface, TelemetryCppPublicTxSimulator, } from './public_tx_simulator/index.js';
+export type { PublicTxResult, PublicSimulatorConfig as PublicTxSimulatorConfig } from '@aztec/stdlib/avm';
+export { getCallRequestsWithCalldataByPhase } from './utils.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDM0QsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sMkNBQTJDLENBQUM7QUFDeEYsT0FBTyxFQUFFLGVBQWUsRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBQ2pHLE9BQU8sRUFDTCxvQkFBb0IsRUFDcEIsdUNBQXVDLEVBQ3ZDLDJCQUEyQixFQUMzQixLQUFLLDBCQUEwQixFQUMvQiw2QkFBNkIsR0FDOUIsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN4QyxZQUFZLEVBQUUsY0FBYyxFQUFFLHFCQUFxQixJQUFJLHVCQUF1QixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDMUcsT0FBTyxFQUFFLGtDQUFrQyxFQUFFLE1BQU0sWUFBWSxDQUFDIn0=

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/public/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8CAA8C,CAAC;AAC7D,OAAO,EAAE,KAAK,iCAAiC,EAAE,KAAK,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AACvG,cAAc,wBAAwB,CAAC;AACvC,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AACjG,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/public/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,2BAA2B,EAAE,MAAM,2CAA2C,CAAC;AACxF,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AACjG,OAAO,EACL,oBAAoB,EACpB,uCAAuC,EACvC,2BAA2B,EAC3B,KAAK,0BAA0B,EAC/B,6BAA6B,GAC9B,MAAM,gCAAgC,CAAC;AACxC,YAAY,EAAE,cAAc,EAAE,qBAAqB,IAAI,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAC1G,OAAO,EAAE,kCAAkC,EAAE,MAAM,YAAY,CAAC"}

package/dest/public/index.js

@@ -1,8 +1,5 @@
-export * from '../common/db_interfaces.js';
-export * from './public_tx_simulator/public_tx_simulator.js';
-export * from './public_db_sources.js';
+export { PublicContractsDB } from './public_db_sources.js';
+export { GuardedMerkleTreeOperations } from './public_processor/guarded_merkle_tree.js';
 export { PublicProcessor, PublicProcessorFactory } from './public_processor/public_processor.js';
-export { SideEffectTrace } from './side_effect_trace.js';
-export { getExecutionRequestsByPhase } from './utils.js';
-export { PublicTxSimulationTester } from './fixtures/index.js';
-export * from './avm/index.js';
+export { CppPublicTxSimulator, createPublicTxSimulatorForBlockBuilding, DumpingCppPublicTxSimulator, TelemetryCppPublicTxSimulator } from './public_tx_simulator/index.js';
+export { getCallRequestsWithCalldataByPhase } from './utils.js';