@aztec/simulator 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/dest/public/hinting_db_sources.d.ts

@@ -1,70 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-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 contractClassIds;
-    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>;
-}
-/**
- * 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>;
-    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<(bigint | undefined)[]>;
-}
-//# sourceMappingURL=hinting_db_sources.d.ts.map

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

@@ -1 +0,0 @@
-{"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

@@ -1,297 +0,0 @@
-import { sha256Trunc } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import { AvmAppendLeavesHint, AvmBytecodeCommitmentHint, AvmCommitCheckpointHint, AvmContractClassHint, AvmContractInstanceHint, AvmCreateCheckpointHint, 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;
-    // We deduplicate contract classes because they include the whole bytecode.
-    contractClassIds;
-    constructor(db, hints){
-        this.db = db;
-        this.hints = hints;
-        this.contractClassIds = new Set();
-    }
-    async getContractInstance(address, timestamp) {
-        const instance = await this.db.getContractInstance(address, timestamp);
-        if (instance) {
-            // We don't need to hint the block number because it doesn't change.
-            this.hints.contractInstances.push(new AvmContractInstanceHint(instance.address, instance.salt, instance.deployer, instance.currentContractClassId, instance.originalContractClassId, instance.initializationHash, instance.publicKeys));
-        }
-        return instance;
-    }
-    async getContractClass(contractClassId) {
-        const contractClass = await this.db.getContractClass(contractClassId);
-        if (contractClass && !this.contractClassIds.has(contractClassId.toBigInt())) {
-            this.contractClassIds.add(contractClassId.toBigInt());
-            this.hints.contractClasses.push(new AvmContractClassHint(contractClass.id, contractClass.artifactHash, contractClass.privateFunctionsRoot, contractClass.packedBytecode));
-        }
-        return contractClass;
-    }
-    async getBytecodeCommitment(contractClassId) {
-        const commitment = await this.db.getBytecodeCommitment(contractClassId);
-        if (commitment) {
-            this.hints.bytecodeCommitments.push(new AvmBytecodeCommitmentHint(contractClassId, commitment));
-        }
-        return commitment;
-    }
-    async getDebugFunctionName(contractAddress, selector) {
-        return await this.db.getDebugFunctionName(contractAddress, selector);
-    }
-}
-/**
- * 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();
-        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}.`);
-    }
-    commitAllCheckpoints() {
-        throw new Error('commitAllCheckpoints is not supported in HintingMerkleWriteOperations.');
-    }
-    revertAllCheckpoints() {
-        throw new Error('revertAllCheckpoints 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();
-    }
-    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 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/public_tx_simulator/cpp_public_tx_simulator.d.ts

@@ -1,41 +0,0 @@
-import { type Logger } from '@aztec/foundation/log';
-import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
-import type { GlobalVariables, Tx } from '@aztec/stdlib/tx';
-import type { ExecutorMetricsInterface } from '../executor_metrics_interface.js';
-import type { PublicContractsDB } from '../public_db_sources.js';
-import { type PublicTxResult, PublicTxSimulator, type PublicTxSimulatorConfig } from './public_tx_simulator.js';
-import type { MeasuredPublicTxSimulatorInterface, PublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
-/**
- * C++ implementation of PublicTxSimulator using pre-collected hints.
- * This implementation runs TS simulation first to collect all hints,
- * then passes the complete AvmCircuitInputs (hints + public inputs)
- * to C++ to run hinted simulation.
- */
-export declare class CppPublicTxSimulatorHintedDbs extends PublicTxSimulator implements PublicTxSimulatorInterface {
-    protected log: Logger;
-    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, config?: Partial<PublicTxSimulatorConfig>);
-    /**
-     * Simulate a transaction's public portion using the C++ vm2 simulator with hinted DBs.
-     *
-     * This implementation:
-     * 1. Runs the full TypeScript simulation to generate AvmCircuitInputs (hints + public inputs)
-     * 2. Passes the complete AvmCircuitInputs to C++ to run hinted simulation
-     *
-     * @param tx - The transaction to simulate.
-     * @returns The result of the transaction's public execution.
-     */
-    simulate(tx: Tx): Promise<PublicTxResult>;
-}
-/**
- * Class to record metrics for simulation.
- *
- * Note(dbanks12): We might not be able to collect all the same metrics in C++ as we do in TS!
- * Unless we move some of the metrics collection to C++, we don't have inner functions exposed
- * to TS for tracking.
- */
-export declare class MeasuredCppPublicTxSimulatorHintedDbs extends CppPublicTxSimulatorHintedDbs implements MeasuredPublicTxSimulatorInterface {
-    protected readonly metrics: ExecutorMetricsInterface;
-    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, metrics: ExecutorMetricsInterface, config?: Partial<PublicTxSimulatorConfig>);
-    simulate(tx: Tx, txLabel?: string): Promise<PublicTxResult>;
-}
-//# sourceMappingURL=cpp_public_tx_simulator.d.ts.map

package/dest/public/public_tx_simulator/cpp_public_tx_simulator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cpp_public_tx_simulator.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/cpp_public_tx_simulator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAIlE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAE5D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AACjF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,KAAK,cAAc,EAAE,iBAAiB,EAAE,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAChH,OAAO,KAAK,EACV,kCAAkC,EAClC,0BAA0B,EAC3B,MAAM,oCAAoC,CAAC;AAE5C;;;;;GAKG;AACH,qBAAa,6BAA8B,SAAQ,iBAAkB,YAAW,0BAA0B;IACxG,UAAmB,GAAG,EAAE,MAAM,CAAC;gBAG7B,UAAU,EAAE,yBAAyB,EACrC,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EAChC,MAAM,CAAC,EAAE,OAAO,CAAC,uBAAuB,CAAC;IAM3C;;;;;;;;;OASG;IACmB,QAAQ,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;CAkDhE;AAED;;;;;;GAMG;AACH,qBAAa,qCACX,SAAQ,6BACR,YAAW,kCAAkC;IAM3C,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,wBAAwB;gBAHpD,UAAU,EAAE,yBAAyB,EACrC,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EACb,OAAO,EAAE,wBAAwB,EACpD,MAAM,CAAC,EAAE,OAAO,CAAC,uBAAuB,CAAC;IAKrB,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,OAAO,GAAE,MAAsB,GAAG,OAAO,CAAC,cAAc,CAAC;CAUjG"}

package/dest/public/public_tx_simulator/cpp_public_tx_simulator.js

@@ -1,89 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-import { avmSimulateWithHintedDbs } from '@aztec/native';
-import { deserializeFromMessagePack } from '@aztec/stdlib/avm';
-import { SimulationError } from '@aztec/stdlib/errors';
-import { PublicTxSimulator } from './public_tx_simulator.js';
-/**
- * C++ implementation of PublicTxSimulator using pre-collected hints.
- * This implementation runs TS simulation first to collect all hints,
- * then passes the complete AvmCircuitInputs (hints + public inputs)
- * to C++ to run hinted simulation.
- */ export class CppPublicTxSimulatorHintedDbs extends PublicTxSimulator {
-    log;
-    constructor(merkleTree, contractsDB, globalVariables, config){
-        super(merkleTree, contractsDB, globalVariables, config);
-        this.log = createLogger(`simulator:cpp_public_tx_simulator_hinted_dbs`);
-    }
-    /**
-   * Simulate a transaction's public portion using the C++ vm2 simulator with hinted DBs.
-   *
-   * This implementation:
-   * 1. Runs the full TypeScript simulation to generate AvmCircuitInputs (hints + public inputs)
-   * 2. Passes the complete AvmCircuitInputs to C++ to run hinted simulation
-   *
-   * @param tx - The transaction to simulate.
-   * @returns The result of the transaction's public execution.
-   */ async simulate(tx) {
-        const txHash = this.computeTxHash(tx);
-        this.log.debug(`C++ hinted DB simulation of ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, {
-            txHash
-        });
-        // First, run TS simulation to generate hints and public inputs
-        this.log.debug(`Running TS simulation for tx ${txHash}`);
-        let tsResult;
-        try {
-            // Run the full TypeScript simulation using the parent class
-            // This will modify the merkle tree with the transaction's state changes
-            tsResult = await super.simulate(tx);
-            this.log.debug(`TS simulation succeeded for tx ${txHash}`);
-        } catch (error) {
-            // If TS simulation fails, clear any partial contract additions and re-throw the error
-            this.contractsDB.clearContractsForTx();
-            throw error;
-        }
-        // Extract the full AvmCircuitInputs from the TS result
-        const avmCircuitInputs = tsResult.avmProvingRequest.inputs;
-        // Second, run C++ simulation with hinted DBs
-        this.log.debug(`Running C++ simulation with hinted DBs for tx ${txHash}`);
-        // Serialize to msgpack and call the C++ simulator
-        const inputBuffer = avmCircuitInputs.serializeWithMessagePack();
-        let resultBuffer;
-        try {
-            resultBuffer = await avmSimulateWithHintedDbs(inputBuffer);
-        } catch (error) {
-            throw new SimulationError(`C++ hinted simulation failed: ${error.message}`, []);
-        }
-        // Deserialize the msgpack result
-        const _success = deserializeFromMessagePack(resultBuffer);
-        this.log.debug(`C++ hinted simulation completed for tx ${txHash}`, {
-            txHash,
-            reverted: !tsResult.revertCode.isOK(),
-            tsGasUsed: tsResult.gasUsed.totalGas.l2Gas,
-            cppGasUsed: tsResult.gasUsed.totalGas.l2Gas
-        });
-        // TODO(dbanks12): C++ should return PublicTxResult (or something similar)
-        return tsResult;
-    }
-}
-/**
- * Class to record metrics for simulation.
- *
- * Note(dbanks12): We might not be able to collect all the same metrics in C++ as we do in TS!
- * Unless we move some of the metrics collection to C++, we don't have inner functions exposed
- * to TS for tracking.
- */ export class MeasuredCppPublicTxSimulatorHintedDbs extends CppPublicTxSimulatorHintedDbs {
-    metrics;
-    constructor(merkleTree, contractsDB, globalVariables, metrics, config){
-        super(merkleTree, contractsDB, globalVariables, config), this.metrics = metrics;
-    }
-    async simulate(tx, txLabel = 'unlabeledTx') {
-        this.metrics.startRecordingTxSimulation(txLabel);
-        let result;
-        try {
-            result = await super.simulate(tx);
-        } finally{
-            this.metrics.stopRecordingTxSimulation(txLabel, result?.revertCode);
-        }
-        return result;
-    }
-}

package/dest/public/public_tx_simulator/measured_public_tx_simulator.d.ts

@@ -1,24 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import type { Gas } from '@aztec/stdlib/gas';
-import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
-import { type GlobalVariables, PublicCallRequestWithCalldata, Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
-import type { AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
-import type { ExecutorMetricsInterface } from '../executor_metrics_interface.js';
-import type { PublicContractsDB } from '../public_db_sources.js';
-import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
-import { PublicTxContext } from './public_tx_context.js';
-import { type ProcessedPhase, type PublicTxResult, PublicTxSimulator, type PublicTxSimulatorConfig } from './public_tx_simulator.js';
-import type { MeasuredPublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
-/**
- * A public tx simulator that tracks miscellaneous simulation metrics without telemetry.
- */
-export declare class MeasuredPublicTxSimulator extends PublicTxSimulator implements MeasuredPublicTxSimulatorInterface {
-    protected readonly metrics: ExecutorMetricsInterface;
-    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, metrics: ExecutorMetricsInterface, config?: Partial<PublicTxSimulatorConfig>);
-    simulate(tx: Tx, txLabel?: string): Promise<PublicTxResult>;
-    protected insertNonRevertiblesFromPrivate(context: PublicTxContext, tx: Tx): Promise<void>;
-    protected insertRevertiblesFromPrivate(context: PublicTxContext, tx: Tx): Promise<void>;
-    protected simulatePhase(phase: TxExecutionPhase, context: PublicTxContext): Promise<ProcessedPhase>;
-    protected simulateEnqueuedCallInternal(stateManager: PublicPersistableStateManager, callRequest: PublicCallRequestWithCalldata, allocatedGas: Gas, transactionFee: Fr, fnName: string): Promise<AvmFinalizedCallResult>;
-}
-//# sourceMappingURL=measured_public_tx_simulator.d.ts.map

package/dest/public/public_tx_simulator/measured_public_tx_simulator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"measured_public_tx_simulator.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/measured_public_tx_simulator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAE7C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAE,KAAK,eAAe,EAAE,6BAA6B,EAAE,EAAE,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAE7G,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AACjF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AACjF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mCAAmC,CAAC;AACvF,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,iBAAiB,EACjB,KAAK,uBAAuB,EAC7B,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,oCAAoC,CAAC;AAE7F;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,iBAAkB,YAAW,kCAAkC;IAK1G,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,wBAAwB;gBAHpD,UAAU,EAAE,yBAAyB,EACrC,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EACb,OAAO,EAAE,wBAAwB,EACpD,MAAM,CAAC,EAAE,OAAO,CAAC,uBAAuB,CAAC;IAKrB,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,OAAO,GAAE,MAAsB,GAAG,OAAO,CAAC,cAAc,CAAC;cAWvE,+BAA+B,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,EAAE;cAMhE,4BAA4B,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,EAAE;cAM7D,aAAa,CAAC,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;cAOzF,4BAA4B,CACnD,YAAY,EAAE,6BAA6B,EAC3C,WAAW,EAAE,6BAA6B,EAC1C,YAAY,EAAE,GAAG,EACjB,cAAc,EAAE,EAAE,EAClB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,sBAAsB,CAAC;CAsCnC"}

package/dest/public/public_tx_simulator/measured_public_tx_simulator.js

@@ -1,51 +0,0 @@
-import { Timer } from '@aztec/foundation/timer';
-import { PublicTxSimulator } from './public_tx_simulator.js';
-/**
- * A public tx simulator that tracks miscellaneous simulation metrics without telemetry.
- */ export class MeasuredPublicTxSimulator extends PublicTxSimulator {
-    metrics;
-    constructor(merkleTree, contractsDB, globalVariables, metrics, config){
-        super(merkleTree, contractsDB, globalVariables, config), this.metrics = metrics;
-    }
-    async simulate(tx, txLabel = 'unlabeledTx') {
-        this.metrics.startRecordingTxSimulation(txLabel);
-        let avmResult;
-        try {
-            avmResult = await super.simulate(tx);
-        } finally{
-            this.metrics.stopRecordingTxSimulation(txLabel, avmResult?.revertCode);
-        }
-        return avmResult;
-    }
-    async insertNonRevertiblesFromPrivate(context, tx) {
-        const timer = new Timer();
-        await super.insertNonRevertiblesFromPrivate(context, tx);
-        this.metrics.recordPrivateEffectsInsertion(timer.us(), 'non-revertible');
-    }
-    async insertRevertiblesFromPrivate(context, tx) {
-        const timer = new Timer();
-        await super.insertRevertiblesFromPrivate(context, tx);
-        this.metrics.recordPrivateEffectsInsertion(timer.us(), 'revertible');
-    }
-    async simulatePhase(phase, context) {
-        const timer = new Timer();
-        const result = await super.simulatePhase(phase, context);
-        result.durationMs = timer.ms();
-        return result;
-    }
-    async simulateEnqueuedCallInternal(stateManager, callRequest, allocatedGas, transactionFee, fnName) {
-        const timer = new Timer();
-        const result = await super.simulateEnqueuedCallInternal(stateManager, callRequest, allocatedGas, transactionFee, fnName);
-        this.log.verbose(result.reverted ? `Simulation of enqueued public call ${fnName} reverted with reason ${result.revertReason?.message}.` : `Simulation of enqueued public call ${fnName} completed successfully.`, {
-            eventName: 'avm-simulation',
-            appCircuitName: fnName,
-            duration: timer.ms()
-        });
-        if (result.reverted) {
-            this.metrics.recordEnqueuedCallSimulationFailure(fnName, timer.ms(), allocatedGas.sub(result.gasLeft).l2Gas, result.totalInstructions);
-        } else {
-            this.metrics.recordEnqueuedCallSimulation(fnName, timer.ms(), allocatedGas.sub(result.gasLeft).l2Gas, result.totalInstructions);
-        }
-        return result;
-    }
-}