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

package/dest/public/public_processor/public_processor_metrics.d.ts

@@ -24,4 +24,4 @@ export declare class PublicProcessorMetrics {
     recordClassPublication(...events: ContractClassPublishedEvent[]): void;
     recordTreeInsertions(durationUs: number): void;
 }
-//# sourceMappingURL=public_processor_metrics.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX3Byb2Nlc3Nvcl9tZXRyaWNzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHVibGljL3B1YmxpY19wcm9jZXNzb3IvcHVibGljX3Byb2Nlc3Nvcl9tZXRyaWNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sMENBQTBDLENBQUM7QUFDNUYsT0FBTyxLQUFLLEVBQUUsR0FBRyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDN0MsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUN6RCxPQUFPLEVBS0wsS0FBSyxlQUFlLEVBQ3BCLEtBQUssTUFBTSxFQUVaLE1BQU0seUJBQXlCLENBQUM7QUFFakMscUJBQWEsc0JBQXNCO0lBQ2pDLFNBQWdCLE1BQU0sRUFBRSxNQUFNLENBQUM7SUFFL0IsT0FBTyxDQUFDLFVBQVUsQ0FBWTtJQUM5QixPQUFPLENBQUMsT0FBTyxDQUFnQjtJQUMvQixPQUFPLENBQUMsWUFBWSxDQUFnQjtJQUVwQyxPQUFPLENBQUMsYUFBYSxDQUFZO0lBQ2pDLE9BQU8sQ0FBQyxVQUFVLENBQWdCO0lBRWxDLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBWTtJQUNwQyxPQUFPLENBQUMsUUFBUSxDQUFRO0lBQ3hCLE9BQU8sQ0FBQyxpQkFBaUIsQ0FBWTtJQUNyQyxPQUFPLENBQUMsT0FBTyxDQUFZO0lBQzNCLE9BQU8sQ0FBQyxLQUFLLENBQVk7SUFFekIsT0FBTyxDQUFDLHFCQUFxQixDQUFZO0lBRXpDLFlBQVksTUFBTSxFQUFFLGVBQWUsRUFBRSxJQUFJLFNBQW9CLEVBeUI1RDtJQUVELG1CQUFtQixDQUFDLFNBQVMsRUFBRSxnQkFBZ0IsRUFBRSxVQUFVLEVBQUUsTUFBTSxRQUdsRTtJQUVELFFBQVEsQ0FBQyxVQUFVLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsT0FBTyxFQUFFLEdBQUcsUUFZNUQ7SUFFRCxZQUFZLENBQUMsUUFBUSxFQUFFLEdBQUcsRUFBRSxPQUFPLEVBQUUsTUFBTSxRQWdCMUM7SUFFRCxjQUFjLFNBSWI7SUFFRCxtQkFBbUIsQ0FBQyxTQUFTLEVBQUUsZ0JBQWdCLFFBRTlDO0lBRUQsc0JBQXNCLENBQUMsR0FBRyxNQUFNLEVBQUUsMkJBQTJCLEVBQUUsUUFTOUQ7SUFFRCxvQkFBb0IsQ0FBQyxVQUFVLEVBQUUsTUFBTSxRQUV0QztDQUNGIn0=

package/dest/public/public_processor/public_processor_metrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public_processor_metrics.d.ts","sourceRoot":"","sources":["../../../src/public/public_processor/public_processor_metrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,0CAA0C,CAAC;AAC5F,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAKL,KAAK,eAAe,EACpB,KAAK,MAAM,EAGZ,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,sBAAsB;IACjC,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,YAAY,CAAgB;IAEpC,OAAO,CAAC,aAAa,CAAY;IACjC,OAAO,CAAC,UAAU,CAAgB;IAElC,OAAO,CAAC,gBAAgB,CAAY;IACpC,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,iBAAiB,CAAY;IACrC,OAAO,CAAC,OAAO,CAAY;IAC3B,OAAO,CAAC,KAAK,CAAY;IAEzB,OAAO,CAAC,qBAAqB,CAAY;gBAE7B,MAAM,EAAE,eAAe,EAAE,IAAI,SAAoB;IA4D7D,mBAAmB,CAAC,SAAS,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM;IAKnE,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG;IAc7D,YAAY,CAAC,QAAQ,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM;IAkB3C,cAAc;IAMd,mBAAmB,CAAC,SAAS,EAAE,gBAAgB;IAI/C,sBAAsB,CAAC,GAAG,MAAM,EAAE,2BAA2B,EAAE;IAW/D,oBAAoB,CAAC,UAAU,EAAE,MAAM;CAGxC"}
+{"version":3,"file":"public_processor_metrics.d.ts","sourceRoot":"","sources":["../../../src/public/public_processor/public_processor_metrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,0CAA0C,CAAC;AAC5F,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAKL,KAAK,eAAe,EACpB,KAAK,MAAM,EAEZ,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,sBAAsB;IACjC,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,YAAY,CAAgB;IAEpC,OAAO,CAAC,aAAa,CAAY;IACjC,OAAO,CAAC,UAAU,CAAgB;IAElC,OAAO,CAAC,gBAAgB,CAAY;IACpC,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,iBAAiB,CAAY;IACrC,OAAO,CAAC,OAAO,CAAY;IAC3B,OAAO,CAAC,KAAK,CAAY;IAEzB,OAAO,CAAC,qBAAqB,CAAY;IAEzC,YAAY,MAAM,EAAE,eAAe,EAAE,IAAI,SAAoB,EAyB5D;IAED,mBAAmB,CAAC,SAAS,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,QAGlE;IAED,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,QAY5D;IAED,YAAY,CAAC,QAAQ,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,QAgB1C;IAED,cAAc,SAIb;IAED,mBAAmB,CAAC,SAAS,EAAE,gBAAgB,QAE9C;IAED,sBAAsB,CAAC,GAAG,MAAM,EAAE,2BAA2B,EAAE,QAS9D;IAED,oBAAoB,CAAC,UAAU,EAAE,MAAM,QAEtC;CACF"}

package/dest/public/public_processor/public_processor_metrics.js

@@ -1,4 +1,4 @@
-import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
+import { Attributes, Metrics } from '@aztec/telemetry-client';
 export class PublicProcessorMetrics {
     tracer;
     txDuration;
@@ -15,50 +15,17 @@ export class PublicProcessorMetrics {
     constructor(client, name = 'PublicProcessor'){
         this.tracer = client.getTracer(name);
         const meter = client.getMeter(name);
-        this.txDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TX_DURATION, {
-            description: 'How long it takes to process a transaction',
-            unit: 'ms',
-            valueType: ValueType.INT
-        });
-        this.txCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_TX_COUNT, {
-            description: 'Number of transactions processed'
-        });
-        this.txPhaseCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_TX_PHASE_COUNT, {
-            description: 'Number of phases processed'
-        });
-        this.phaseDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_PHASE_DURATION, {
-            description: 'How long it takes to process a phase',
-            unit: 'ms',
-            valueType: ValueType.INT
-        });
-        this.phaseCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_PHASE_COUNT, {
-            description: 'Number of failed phases'
-        });
-        this.bytecodeDeployed = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_DEPLOY_BYTECODE_SIZE, {
-            description: 'Size of deployed bytecode',
-            unit: 'By'
-        });
-        this.totalGas = meter.createGauge(Metrics.PUBLIC_PROCESSOR_TOTAL_GAS, {
-            description: 'Total gas used in block',
-            unit: 'gas'
-        });
-        this.totalGasHistogram = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TOTAL_GAS_HISTOGRAM, {
-            description: 'Total gas used in block as histogram',
-            unit: 'gas/block'
-        });
-        this.txGas = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TX_GAS, {
-            description: 'Gas used in transaction',
-            unit: 'gas/tx'
-        });
-        this.gasRate = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_GAS_RATE, {
-            description: 'L2 gas per second for complete block',
-            unit: 'gas/s'
-        });
-        this.treeInsertionDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TREE_INSERTION, {
-            description: 'How long it takes for tree insertion',
-            unit: 'us',
-            valueType: ValueType.INT
-        });
+        this.txDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TX_DURATION);
+        this.txCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_TX_COUNT);
+        this.txPhaseCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_TX_PHASE_COUNT);
+        this.phaseDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_PHASE_DURATION);
+        this.phaseCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_PHASE_COUNT);
+        this.bytecodeDeployed = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_DEPLOY_BYTECODE_SIZE);
+        this.totalGas = meter.createGauge(Metrics.PUBLIC_PROCESSOR_TOTAL_GAS);
+        this.totalGasHistogram = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TOTAL_GAS_HISTOGRAM);
+        this.txGas = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TX_GAS);
+        this.gasRate = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_GAS_RATE);
+        this.treeInsertionDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TREE_INSERTION);
     }
     recordPhaseDuration(phaseName, durationMs) {
         this.phaseCount.add(1, {

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

@@ -0,0 +1,18 @@
+import type { ContractProvider } from '@aztec/native';
+import type { GlobalVariables } from '@aztec/stdlib/tx';
+import type { PublicContractsDB } from '../public_db_sources.js';
+export declare class ContractProviderForCpp implements ContractProvider {
+    private contractsDB;
+    private globalVariables;
+    private log;
+    constructor(contractsDB: PublicContractsDB, globalVariables: GlobalVariables);
+    getContractInstance: (address: string) => Promise<Buffer<ArrayBufferLike> | undefined>;
+    getContractClass: (classId: string) => Promise<Buffer<ArrayBufferLike> | undefined>;
+    addContracts: (contractDeploymentDataBuffer: Buffer<ArrayBufferLike>) => Promise<void>;
+    getBytecodeCommitment: (classId: string) => Promise<Buffer<ArrayBufferLike> | undefined>;
+    getDebugFunctionName: (address: string, selector: string) => Promise<string | undefined>;
+    createCheckpoint: () => Promise<void>;
+    commitCheckpoint: () => Promise<void>;
+    revertCheckpoint: () => Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3RfcHJvdmlkZXJfZm9yX2NwcC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3B1YmxpYy9wdWJsaWNfdHhfc2ltdWxhdG9yL2NvbnRyYWN0X3Byb3ZpZGVyX2Zvcl9jcHAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFLdEQsT0FBTyxLQUFLLEVBQUUsZUFBZSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFeEQsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUVqRSxxQkFBYSxzQkFBdUIsWUFBVyxnQkFBZ0I7SUFJM0QsT0FBTyxDQUFDLFdBQVc7SUFDbkIsT0FBTyxDQUFDLGVBQWU7SUFKekIsT0FBTyxDQUFDLEdBQUcsQ0FBK0Q7SUFFMUUsWUFDVSxXQUFXLEVBQUUsaUJBQWlCLEVBQzlCLGVBQWUsRUFBRSxlQUFlLEVBQ3RDO0lBRUcsbUJBQW1CLG9FQWF4QjtJQUVLLGdCQUFnQixvRUFlckI7SUFFSyxZQUFZLDJFQVdqQjtJQUVLLHFCQUFxQixvRUFnQjFCO0lBRUssb0JBQW9CLHFFQXNCekI7SUFFSyxnQkFBZ0Isc0JBR3JCO0lBRUssZ0JBQWdCLHNCQUdyQjtJQUVLLGdCQUFnQixzQkFHckI7Q0FDSCJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract_provider_for_cpp.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/contract_provider_for_cpp.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAKtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,qBAAa,sBAAuB,YAAW,gBAAgB;IAI3D,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,eAAe;IAJzB,OAAO,CAAC,GAAG,CAA+D;IAE1E,YACU,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EACtC;IAEG,mBAAmB,oEAaxB;IAEK,gBAAgB,oEAerB;IAEK,YAAY,2EAWjB;IAEK,qBAAqB,oEAgB1B;IAEK,oBAAoB,qEAsBzB;IAEK,gBAAgB,sBAGrB;IAEK,gBAAgB,sBAGrB;IAEK,gBAAgB,sBAGrB;CACH"}

package/dest/public/public_tx_simulator/contract_provider_for_cpp.js

@@ -0,0 +1,98 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { deserializeFromMessagePack, serializeWithMessagePack } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { ContractDeploymentData } from '@aztec/stdlib/contract';
+export class ContractProviderForCpp {
+    contractsDB;
+    globalVariables;
+    log;
+    constructor(contractsDB, globalVariables){
+        this.contractsDB = contractsDB;
+        this.globalVariables = globalVariables;
+        this.log = createLogger('simulator:contract_provider_for_cpp');
+        this.getContractInstance = async (address)=>{
+            this.log.trace(`Contract provider callback: getContractInstance(${address})`);
+            const aztecAddr = AztecAddress.fromString(address);
+            const instance = await this.contractsDB.getContractInstance(aztecAddr, this.globalVariables.timestamp);
+            if (!instance) {
+                this.log.debug(`Contract instance not found: ${address}`);
+                return undefined;
+            }
+            return serializeWithMessagePack(instance);
+        };
+        this.getContractClass = async (classId)=>{
+            this.log.trace(`Contract provider callback: getContractClass(${classId})`);
+            // Parse classId string to Fr
+            const classIdFr = Fr.fromString(classId);
+            // Fetch contract class from the contracts DB
+            const contractClass = await this.contractsDB.getContractClass(classIdFr);
+            if (!contractClass) {
+                this.log.debug(`Contract class not found: ${classId}`);
+                return undefined;
+            }
+            return serializeWithMessagePack(contractClass);
+        };
+        this.addContracts = async (contractDeploymentDataBuffer)=>{
+            this.log.trace(`Contract provider callback: addContracts`);
+            const rawData = deserializeFromMessagePack(contractDeploymentDataBuffer);
+            // Construct ContractDeploymentData from plain object.
+            const contractDeploymentData = ContractDeploymentData.fromPlainObject(rawData);
+            // Add contracts to the contracts DB
+            this.log.trace(`Calling contractsDB.addContracts`);
+            await this.contractsDB.addContracts(contractDeploymentData);
+        };
+        this.getBytecodeCommitment = async (classId)=>{
+            this.log.trace(`Contract provider callback: getBytecodeCommitment(${classId})`);
+            // Parse classId string to Fr
+            const classIdFr = Fr.fromString(classId);
+            // Fetch bytecode commitment from the contracts DB
+            const commitment = await this.contractsDB.getBytecodeCommitment(classIdFr);
+            if (!commitment) {
+                this.log.debug(`Bytecode commitment not found: ${classId}`);
+                return undefined;
+            }
+            // Serialize the Fr to buffer
+            return serializeWithMessagePack(commitment);
+        };
+        this.getDebugFunctionName = async (address, selector)=>{
+            this.log.trace(`Contract provider callback: getDebugFunctionName(${address}, ${selector})`);
+            // Parse address and selector strings
+            const aztecAddr = AztecAddress.fromString(address);
+            const selectorFr = Fr.fromString(selector);
+            const functionSelector = FunctionSelector.fromFieldOrUndefined(selectorFr);
+            if (!functionSelector) {
+                this.log.trace(`calldata[0] is not a function selector: ${selector}`);
+                return undefined;
+            }
+            // Fetch debug function name from the contracts DB
+            const name = await this.contractsDB.getDebugFunctionName(aztecAddr, functionSelector);
+            if (!name) {
+                this.log.trace(`Debug function name not found for ${address}:${selector}`);
+                return undefined;
+            }
+            return name;
+        };
+        this.createCheckpoint = ()=>{
+            this.log.trace(`Contract provider callback: createCheckpoint`);
+            return Promise.resolve(this.contractsDB.createCheckpoint());
+        };
+        this.commitCheckpoint = ()=>{
+            this.log.trace(`Contract provider callback: commitCheckpoint`);
+            return Promise.resolve(this.contractsDB.commitCheckpoint());
+        };
+        this.revertCheckpoint = ()=>{
+            this.log.trace(`Contract provider callback: revertCheckpoint`);
+            return Promise.resolve(this.contractsDB.revertCheckpoint());
+        };
+    }
+    getContractInstance;
+    getContractClass;
+    addContracts;
+    getBytecodeCommitment;
+    getDebugFunctionName;
+    createCheckpoint;
+    commitCheckpoint;
+    revertCheckpoint;
+}

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

@@ -1,41 +1,53 @@
 import { type Logger } from '@aztec/foundation/log';
+import { type PublicSimulatorConfig, PublicTxResult } from '@aztec/stdlib/avm';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
 import type { GlobalVariables, Tx } from '@aztec/stdlib/tx';
+import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
 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 { PublicTxSimulator } 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.
+ * C++ implementation of PublicTxSimulator using the C++ simulator.
+ * The C++ simulator accesses the world state directly/natively within C++.
+ * For contract DB accesses, it makes callbacks through NAPI back to the TS PublicContractsDB cache.
  */
-export declare class CppPublicTxSimulatorHintedDbs extends PublicTxSimulator implements PublicTxSimulatorInterface {
+export declare class CppPublicTxSimulator extends PublicTxSimulator implements PublicTxSimulatorInterface {
     protected log: Logger;
-    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, config?: Partial<PublicTxSimulatorConfig>);
+    /** Current cancellation token for in-flight simulation. */
+    private cancellationToken?;
+    /** Current simulation promise, used to wait for completion after cancellation. */
+    private simulationPromise?;
+    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, config?: Partial<PublicSimulatorConfig>);
     /**
-     * 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
+     * Simulate a transaction's public portion using the C++ avvm simulator.
      *
      * @param tx - The transaction to simulate.
      * @returns The result of the transaction's public execution.
      */
     simulate(tx: Tx): Promise<PublicTxResult>;
+    /**
+     * Cancel the current simulation if one is in progress.
+     * This signals the C++ simulator to stop at the next opcode or before the next WorldState write.
+     * Safe to call even if no simulation is in progress.
+     *
+     * @param waitTimeoutMs - If provided, wait up to this many ms for the simulation to actually stop.
+     *                        This is important because C++ might be in the middle of a slow operation
+     *                        (e.g., pad_trees) and won't check the cancellation flag until it completes.
+     *                        Default timeout of 100ms after cancellation.
+     */
+    cancel(waitTimeoutMs?: number): Promise<void>;
 }
-/**
- * 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 {
+export declare class MeasuredCppPublicTxSimulator extends CppPublicTxSimulator implements MeasuredPublicTxSimulatorInterface {
     protected readonly metrics: ExecutorMetricsInterface;
-    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, metrics: ExecutorMetricsInterface, config?: Partial<PublicTxSimulatorConfig>);
+    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, metrics: ExecutorMetricsInterface, config?: Partial<PublicSimulatorConfig>);
     simulate(tx: Tx, txLabel?: string): Promise<PublicTxResult>;
 }
-//# sourceMappingURL=cpp_public_tx_simulator.d.ts.map
+/**
+ * A C++ public tx simulator that tracks runtime/production metrics with telemetry.
+ */
+export declare class TelemetryCppPublicTxSimulator extends MeasuredCppPublicTxSimulator {
+    readonly tracer: Tracer;
+    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, telemetryClient?: TelemetryClient, config?: Partial<PublicSimulatorConfig>);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"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"}
+{"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,EAA0B,MAAM,uBAAuB,CAAC;AAI5E,OAAO,EAGL,KAAK,qBAAqB,EAC1B,cAAc,EAEf,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAE5D,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,MAAM,EAAsB,MAAM,yBAAyB,CAAC;AAKhG,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AACjF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EACV,kCAAkC,EAClC,0BAA0B,EAC3B,MAAM,oCAAoC,CAAC;AAE5C;;;;GAIG;AACH,qBAAa,oBAAqB,SAAQ,iBAAkB,YAAW,0BAA0B;IAC/F,UAAmB,GAAG,EAAE,MAAM,CAAC;IAC/B,2DAA2D;IAC3D,OAAO,CAAC,iBAAiB,CAAC,CAAoB;IAC9C,kFAAkF;IAClF,OAAO,CAAC,iBAAiB,CAAC,CAAkB;IAE5C,YACE,UAAU,EAAE,yBAAyB,EACrC,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EAChC,MAAM,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,EAIxC;IAED;;;;;OAKG;IACmB,QAAQ,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC,CA+E9D;IAED;;;;;;;;;OASG;IACU,MAAM,CAAC,aAAa,GAAE,MAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAe9D;CACF;AAED,qBAAa,4BAA6B,SAAQ,oBAAqB,YAAW,kCAAkC;IAKhH,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,wBAAwB;IAJtD,YACE,UAAU,EAAE,yBAAyB,EACrC,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EACb,OAAO,EAAE,wBAAwB,EACpD,MAAM,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,EAGxC;IAEqB,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,OAAO,GAAE,MAAsB,GAAG,OAAO,CAAC,cAAc,CAAC,CAS/F;CACF;AAED;;GAEG;AACH,qBAAa,6BAA8B,SAAQ,4BAA4B;IAE7E,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,YACE,UAAU,EAAE,yBAAyB,EACrC,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EAChC,eAAe,GAAE,eAAsC,EACvD,MAAM,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,EAKxC;CACF"}

package/dest/public/public_tx_simulator/cpp_public_tx_simulator.js

@@ -1,77 +1,110 @@
-import { createLogger } from '@aztec/foundation/log';
-import { avmSimulateWithHintedDbs } from '@aztec/native';
-import { deserializeFromMessagePack } from '@aztec/stdlib/avm';
+import { createLogger, logLevel } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
+import { avmSimulate, cancelSimulation, createCancellationToken } from '@aztec/native';
+import { ProtocolContractsList } from '@aztec/protocol-contracts';
+import { AvmFastSimulationInputs, AvmTxHint, PublicTxResult, deserializeFromMessagePack } from '@aztec/stdlib/avm';
 import { SimulationError } from '@aztec/stdlib/errors';
+import { WorldStateRevisionWithHandle } from '@aztec/stdlib/world-state';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { strict as assert } from 'assert';
+import { ExecutorMetrics } from '../executor_metrics.js';
+import { ContractProviderForCpp } from './contract_provider_for_cpp.js';
 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 {
+ * C++ implementation of PublicTxSimulator using the C++ simulator.
+ * The C++ simulator accesses the world state directly/natively within C++.
+ * For contract DB accesses, it makes callbacks through NAPI back to the TS PublicContractsDB cache.
+ */ export class CppPublicTxSimulator extends PublicTxSimulator {
     log;
+    /** Current cancellation token for in-flight simulation. */ cancellationToken;
+    /** Current simulation promise, used to wait for completion after cancellation. */ simulationPromise;
     constructor(merkleTree, contractsDB, globalVariables, config){
         super(merkleTree, contractsDB, globalVariables, config);
-        this.log = createLogger(`simulator:cpp_public_tx_simulator_hinted_dbs`);
+        this.log = createLogger(`simulator:cpp_public_tx_simulator`);
     }
     /**
-   * 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
+   * Simulate a transaction's public portion using the C++ avvm simulator.
    *
    * @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}`, {
+        this.log.debug(`C++ 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}`);
+        // Using the "as WorldStateRevisionWithHandle" is a bit of a "trust me bro", hence the assert.
+        let wsRevision = this.merkleTree.getRevision();
+        assert(wsRevision instanceof WorldStateRevisionWithHandle, 'CppPublicTxSimulator a real NativeWorldStateInstance with a handle to the C++ WorldState object');
+        const wsCppHandle = wsRevision.handle;
+        wsRevision = wsRevision.toWorldStateRevision(); // for msgpack serialization, we don't include the handle in the type
+        this.log.trace(`Running C++ simulation with world state revision ${JSON.stringify(wsRevision)}`);
+        // Create the fast simulation inputs
+        const txHint = AvmTxHint.fromTx(tx, this.globalVariables.gasFees);
+        const protocolContracts = ProtocolContractsList;
+        const fastSimInputs = new AvmFastSimulationInputs(wsRevision, this.config, txHint, this.globalVariables, protocolContracts);
+        // Create contract provider for callbacks to TypeScript PublicContractsDB from C++
+        const contractProvider = new ContractProviderForCpp(this.contractsDB, this.globalVariables);
         // Serialize to msgpack and call the C++ simulator
-        const inputBuffer = avmCircuitInputs.serializeWithMessagePack();
+        this.log.trace(`Serializing fast simulation inputs to msgpack...`);
+        const inputBuffer = fastSimInputs.serializeWithMessagePack();
+        // Create cancellation token for this simulation
+        this.cancellationToken = createCancellationToken();
+        // Store the promise so cancel() can wait for it
+        this.log.debug(`Calling C++ simulator for tx ${txHash}`);
+        this.simulationPromise = avmSimulate(inputBuffer, contractProvider, wsCppHandle, logLevel, // TODO: re-enable logging
+        undefined, this.cancellationToken);
         let resultBuffer;
         try {
-            resultBuffer = await avmSimulateWithHintedDbs(inputBuffer);
+            resultBuffer = await this.simulationPromise;
         } catch (error) {
-            throw new SimulationError(`C++ hinted simulation failed: ${error.message}`, []);
+            // Check if this was a cancellation
+            if (error.message?.includes('Simulation cancelled')) {
+                throw new SimulationError(`C++ simulation cancelled`, []);
+            }
+            throw new SimulationError(`C++ simulation failed: ${error.message}`, []);
+        } finally{
+            this.cancellationToken = undefined;
+            this.simulationPromise = undefined;
         }
+        // If we've reached this point, C++ succeeded during simulation,
         // Deserialize the msgpack result
-        const _success = deserializeFromMessagePack(resultBuffer);
-        this.log.debug(`C++ hinted simulation completed for tx ${txHash}`, {
+        this.log.trace(`Deserializing C++ from buffer (size: ${resultBuffer.length})...`);
+        const cppResultJSON = deserializeFromMessagePack(resultBuffer);
+        this.log.trace(`Deserializing C++ result to PublicTxResult...`);
+        const cppResult = PublicTxResult.fromPlainObject(cppResultJSON);
+        this.log.trace(`C++ simulation completed for tx ${txHash}`, {
             txHash,
-            reverted: !tsResult.revertCode.isOK(),
-            tsGasUsed: tsResult.gasUsed.totalGas.l2Gas,
-            cppGasUsed: tsResult.gasUsed.totalGas.l2Gas
+            reverted: !cppResult.revertCode.isOK(),
+            cppGasUsed: cppResult.gasUsed.totalGas.l2Gas
         });
-        // TODO(dbanks12): C++ should return PublicTxResult (or something similar)
-        return tsResult;
+        return cppResult;
+    }
+    /**
+   * Cancel the current simulation if one is in progress.
+   * This signals the C++ simulator to stop at the next opcode or before the next WorldState write.
+   * Safe to call even if no simulation is in progress.
+   *
+   * @param waitTimeoutMs - If provided, wait up to this many ms for the simulation to actually stop.
+   *                        This is important because C++ might be in the middle of a slow operation
+   *                        (e.g., pad_trees) and won't check the cancellation flag until it completes.
+   *                        Default timeout of 100ms after cancellation.
+   */ async cancel(waitTimeoutMs = 100) {
+        if (this.cancellationToken) {
+            this.log.debug('Cancelling C++ simulation');
+            cancelSimulation(this.cancellationToken);
+        }
+        // Wait for the simulation to actually complete if not already done
+        if (this.simulationPromise) {
+            this.log.debug(`Waiting up to ${waitTimeoutMs}ms for C++ simulation to stop`);
+            await Promise.race([
+                this.simulationPromise.catch(()=>{}),
+                sleep(waitTimeoutMs)
+            ]);
+            this.log.debug('C++ simulation stopped or wait timed out');
+        }
     }
 }
-/**
- * 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 {
+export class MeasuredCppPublicTxSimulator extends CppPublicTxSimulator {
     metrics;
     constructor(merkleTree, contractsDB, globalVariables, metrics, config){
         super(merkleTree, contractsDB, globalVariables, config), this.metrics = metrics;
@@ -82,8 +115,18 @@ import { PublicTxSimulator } from './public_tx_simulator.js';
         try {
             result = await super.simulate(tx);
         } finally{
-            this.metrics.stopRecordingTxSimulation(txLabel, result?.revertCode);
+            this.metrics.stopRecordingTxSimulation(txLabel, result?.gasUsed, result?.revertCode);
         }
         return result;
     }
 }
+/**
+ * A C++ public tx simulator that tracks runtime/production metrics with telemetry.
+ */ export class TelemetryCppPublicTxSimulator extends MeasuredCppPublicTxSimulator {
+    /* tracer needed by trackSpans */ tracer;
+    constructor(merkleTree, contractsDB, globalVariables, telemetryClient = getTelemetryClient(), config){
+        const metrics = new ExecutorMetrics(telemetryClient, 'CppPublicTxSimulator');
+        super(merkleTree, contractsDB, globalVariables, metrics, config);
+        this.tracer = metrics.tracer;
+    }
+}

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

@@ -0,0 +1,42 @@
+import { type Logger } from '@aztec/foundation/log';
+import { type PublicSimulatorConfig, PublicTxResult } from '@aztec/stdlib/avm';
+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 { PublicTxSimulator } 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<PublicSimulatorConfig>);
+    /**
+     * 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<PublicSimulatorConfig>);
+    simulate(tx: Tx, txLabel?: string): Promise<PublicTxResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3BwX3B1YmxpY190eF9zaW11bGF0b3Jfd2l0aF9oaW50ZWRfZGJzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHVibGljL3B1YmxpY190eF9zaW11bGF0b3IvY3BwX3B1YmxpY190eF9zaW11bGF0b3Jfd2l0aF9oaW50ZWRfZGJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBMEIsTUFBTSx1QkFBdUIsQ0FBQztBQUU1RSxPQUFPLEVBRUwsS0FBSyxxQkFBcUIsRUFDMUIsY0FBYyxFQUVmLE1BQU0sbUJBQW1CLENBQUM7QUFFM0IsT0FBTyxLQUFLLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNyRSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsRUFBRSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFJNUQsT0FBTyxLQUFLLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUNqRixPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQzdELE9BQU8sS0FBSyxFQUNWLGtDQUFrQyxFQUNsQywwQkFBMEIsRUFDM0IsTUFBTSxvQ0FBb0MsQ0FBQztBQUU1Qzs7Ozs7R0FLRztBQUNILHFCQUFhLDZCQUE4QixTQUFRLGlCQUFrQixZQUFXLDBCQUEwQjtJQUN4RyxVQUFtQixHQUFHLEVBQUUsTUFBTSxDQUFDO0lBRS9CLFlBQ0UsVUFBVSxFQUFFLHlCQUF5QixFQUNyQyxXQUFXLEVBQUUsaUJBQWlCLEVBQzlCLGVBQWUsRUFBRSxlQUFlLEVBQ2hDLE1BQU0sQ0FBQyxFQUFFLE9BQU8sQ0FBQyxxQkFBcUIsQ0FBQyxFQUl4QztJQUVEOzs7Ozs7Ozs7T0FTRztJQUNtQixRQUFRLENBQUMsRUFBRSxFQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsY0FBYyxDQUFDLENBOEM5RDtDQUNGO0FBRUQ7Ozs7OztHQU1HO0FBQ0gscUJBQWEscUNBQ1gsU0FBUSw2QkFDUixZQUFXLGtDQUFrQztJQU0zQyxTQUFTLENBQUMsUUFBUSxDQUFDLE9BQU8sRUFBRSx3QkFBd0I7SUFKdEQsWUFDRSxVQUFVLEVBQUUseUJBQXlCLEVBQ3JDLFdBQVcsRUFBRSxpQkFBaUIsRUFDOUIsZUFBZSxFQUFFLGVBQWUsRUFDYixPQUFPLEVBQUUsd0JBQXdCLEVBQ3BELE1BQU0sQ0FBQyxFQUFFLE9BQU8sQ0FBQyxxQkFBcUIsQ0FBQyxFQUd4QztJQUVxQixRQUFRLENBQUMsRUFBRSxFQUFFLEVBQUUsRUFBRSxPQUFPLEdBQUUsTUFBc0IsR0FBRyxPQUFPLENBQUMsY0FBYyxDQUFDLENBUy9GO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"cpp_public_tx_simulator_with_hinted_dbs.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/cpp_public_tx_simulator_with_hinted_dbs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAA0B,MAAM,uBAAuB,CAAC;AAE5E,OAAO,EAEL,KAAK,qBAAqB,EAC1B,cAAc,EAEf,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAI5D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AACjF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,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;IAE/B,YACE,UAAU,EAAE,yBAAyB,EACrC,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EAChC,MAAM,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,EAIxC;IAED;;;;;;;;;OASG;IACmB,QAAQ,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC,CA8C9D;CACF;AAED;;;;;;GAMG;AACH,qBAAa,qCACX,SAAQ,6BACR,YAAW,kCAAkC;IAM3C,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,wBAAwB;IAJtD,YACE,UAAU,EAAE,yBAAyB,EACrC,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EACb,OAAO,EAAE,wBAAwB,EACpD,MAAM,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,EAGxC;IAEqB,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,OAAO,GAAE,MAAsB,GAAG,OAAO,CAAC,cAAc,CAAC,CAS/F;CACF"}

package/dest/public/public_tx_simulator/cpp_public_tx_simulator_with_hinted_dbs.js

@@ -0,0 +1,86 @@
+import { createLogger, logLevel } from '@aztec/foundation/log';
+import { avmSimulateWithHintedDbs } from '@aztec/native';
+import { AvmCircuitInputs, PublicTxResult, deserializeFromMessagePack } from '@aztec/stdlib/avm';
+import { SimulationError } from '@aztec/stdlib/errors';
+import { strict as assert } from 'assert';
+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}`);
+        // Run the full TypeScript simulation using the parent class
+        // This will modify the merkle tree with the transaction's state changes
+        const tsResult = await super.simulate(tx);
+        this.log.debug(`TS simulation succeeded for tx ${txHash}`);
+        // Extract the full AvmCircuitInputs from the TS result
+        const avmCircuitInputs = new AvmCircuitInputs(tsResult.hints, tsResult.publicInputs);
+        // 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, logLevel);
+        } catch (error) {
+            throw new SimulationError(`C++ hinted simulation failed: ${error.message}`, []);
+        }
+        // Deserialize the msgpack result
+        const cppResultJSON = deserializeFromMessagePack(resultBuffer);
+        const cppResult = PublicTxResult.fromPlainObject(cppResultJSON);
+        assert(cppResult.revertCode.equals(tsResult.revertCode));
+        assert(cppResult.gasUsed.totalGas.equals(tsResult.gasUsed.totalGas));
+        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(fcarreiro): complete this.
+        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?.gasUsed, result?.revertCode);
+        }
+        return result;
+    }
+}