@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.0208eb9

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

@@ -1,6 +1,6 @@
-import type { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
+import type { ContractClassPublishedEvent } from '@aztec/protocol-contracts/class-registry';
 import type { Gas } from '@aztec/stdlib/gas';
-import type { TxExecutionPhase } from '@aztec/stdlib/tx';
+import { TxExecutionPhase } from '@aztec/stdlib/tx';
 import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
 export declare class PublicProcessorMetrics {
     readonly tracer: Tracer;
@@ -21,7 +21,7 @@ export declare class PublicProcessorMetrics {
     recordAllTxs(totalGas: Gas, gasRate: number): void;
     recordFailedTx(): void;
     recordRevertedPhase(phaseName: TxExecutionPhase): void;
-    recordClassRegistration(...events: ContractClassRegisteredEvent[]): void;
+    recordClassPublication(...events: ContractClassPublishedEvent[]): void;
     recordTreeInsertions(durationUs: number): void;
 }
-//# sourceMappingURL=public_processor_metrics.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX3Byb2Nlc3Nvcl9tZXRyaWNzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHVibGljL3B1YmxpY19wcm9jZXNzb3IvcHVibGljX3Byb2Nlc3Nvcl9tZXRyaWNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sMENBQTBDLENBQUM7QUFDNUYsT0FBTyxLQUFLLEVBQUUsR0FBRyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDN0MsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDcEQsT0FBTyxFQUtMLEtBQUssZUFBZSxFQUNwQixLQUFLLE1BQU0sRUFHWixNQUFNLHlCQUF5QixDQUFDO0FBRWpDLHFCQUFhLHNCQUFzQjtJQUNqQyxTQUFnQixNQUFNLEVBQUUsTUFBTSxDQUFDO0lBRS9CLE9BQU8sQ0FBQyxVQUFVLENBQVk7SUFDOUIsT0FBTyxDQUFDLE9BQU8sQ0FBZ0I7SUFDL0IsT0FBTyxDQUFDLFlBQVksQ0FBZ0I7SUFFcEMsT0FBTyxDQUFDLGFBQWEsQ0FBWTtJQUNqQyxPQUFPLENBQUMsVUFBVSxDQUFnQjtJQUVsQyxPQUFPLENBQUMsZ0JBQWdCLENBQVk7SUFDcEMsT0FBTyxDQUFDLFFBQVEsQ0FBUTtJQUN4QixPQUFPLENBQUMsaUJBQWlCLENBQVk7SUFDckMsT0FBTyxDQUFDLE9BQU8sQ0FBWTtJQUMzQixPQUFPLENBQUMsS0FBSyxDQUFZO0lBRXpCLE9BQU8sQ0FBQyxxQkFBcUIsQ0FBWTtJQUV6QyxZQUFZLE1BQU0sRUFBRSxlQUFlLEVBQUUsSUFBSSxTQUFvQixFQThCNUQ7SUFFRCxtQkFBbUIsQ0FBQyxTQUFTLEVBQUUsZ0JBQWdCLEVBQUUsVUFBVSxFQUFFLE1BQU0sUUFHbEU7SUFFRCxRQUFRLENBQUMsVUFBVSxFQUFFLE1BQU0sRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxHQUFHLFFBWTVEO0lBRUQsWUFBWSxDQUFDLFFBQVEsRUFBRSxHQUFHLEVBQUUsT0FBTyxFQUFFLE1BQU0sUUFnQjFDO0lBRUQsY0FBYyxTQUliO0lBRUQsbUJBQW1CLENBQUMsU0FBUyxFQUFFLGdCQUFnQixRQUU5QztJQUVELHNCQUFzQixDQUFDLEdBQUcsTUFBTSxFQUFFLDJCQUEyQixFQUFFLFFBUzlEO0lBRUQsb0JBQW9CLENBQUMsVUFBVSxFQUFFLE1BQU0sUUFFdEM7Q0FDRiJ9

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,4BAA4B,EAAE,MAAM,4CAA4C,CAAC;AAC/F,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,uBAAuB,CAAC,GAAG,MAAM,EAAE,4BAA4B,EAAE;IAWjE,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,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,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;IAEzC,YAAY,MAAM,EAAE,eAAe,EAAE,IAAI,SAAoB,EA8B5D;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,5 @@
-import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
+import { TxExecutionPhase } from '@aztec/stdlib/tx';
+import { Attributes, Metrics, createUpDownCounterWithDefault } from '@aztec/telemetry-client';
 export class PublicProcessorMetrics {
     tracer;
     txDuration;
@@ -15,50 +16,32 @@ 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 = createUpDownCounterWithDefault(meter, Metrics.PUBLIC_PROCESSOR_TX_COUNT, {
+            [Attributes.OK]: [
+                true,
+                false
+            ]
+        });
+        this.txPhaseCount = createUpDownCounterWithDefault(meter, Metrics.PUBLIC_PROCESSOR_TX_PHASE_COUNT);
+        this.phaseDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_PHASE_DURATION);
+        this.phaseCount = createUpDownCounterWithDefault(meter, Metrics.PUBLIC_PROCESSOR_PHASE_COUNT, {
+            [Attributes.TX_PHASE_NAME]: [
+                TxExecutionPhase.SETUP,
+                TxExecutionPhase.APP_LOGIC,
+                TxExecutionPhase.TEARDOWN
+            ],
+            [Attributes.OK]: [
+                true,
+                false
+            ]
+        });
+        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, {
@@ -110,7 +93,7 @@ export class PublicProcessorMetrics {
             [Attributes.OK]: false
         });
     }
-    recordClassRegistration(...events) {
+    recordClassPublication(...events) {
         let totalBytecode = 0;
         for (const event of events){
             totalBytecode += event.packedPublicBytecode.length;

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

@@ -0,0 +1,19 @@
+import { type LoggerBindings } from '@aztec/foundation/log';
+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, bindings?: LoggerBindings);
+    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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3RfcHJvdmlkZXJfZm9yX2NwcC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3B1YmxpYy9wdWJsaWNfdHhfc2ltdWxhdG9yL2NvbnRyYWN0X3Byb3ZpZGVyX2Zvcl9jcHAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFlLEtBQUssY0FBYyxFQUFnQixNQUFNLHVCQUF1QixDQUFDO0FBQ3ZGLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sZUFBZSxDQUFDO0FBS3RELE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRXhELE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFakUscUJBQWEsc0JBQXVCLFlBQVcsZ0JBQWdCO0lBSTNELE9BQU8sQ0FBQyxXQUFXO0lBQ25CLE9BQU8sQ0FBQyxlQUFlO0lBSnpCLE9BQU8sQ0FBQyxHQUFHLENBQVM7SUFFcEIsWUFDVSxXQUFXLEVBQUUsaUJBQWlCLEVBQzlCLGVBQWUsRUFBRSxlQUFlLEVBQ3hDLFFBQVEsQ0FBQyxFQUFFLGNBQWMsRUFHMUI7SUFFTSxtQkFBbUIsb0VBYXhCO0lBRUssZ0JBQWdCLG9FQWVyQjtJQUVLLFlBQVksMkVBV2pCO0lBRUsscUJBQXFCLG9FQWdCMUI7SUFFSyxvQkFBb0IscUVBc0J6QjtJQUVLLGdCQUFnQixzQkFHckI7SUFFSyxnQkFBZ0Isc0JBR3JCO0lBRUssZ0JBQWdCLHNCQUdyQjtDQUNIIn0=

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":"AACA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,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,CAAS;IAEpB,YACU,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EACxC,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAEM,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, bindings){
+        this.contractsDB = contractsDB;
+        this.globalVariables = globalVariables;
+        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());
+        };
+        this.log = createLogger('simulator:contract_provider_for_cpp', bindings);
+    }
+    getContractInstance;
+    getContractClass;
+    addContracts;
+    getBytecodeCommitment;
+    getDebugFunctionName;
+    createCheckpoint;
+    commitCheckpoint;
+    revertCheckpoint;
+}

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

@@ -0,0 +1,53 @@
+import { type Logger, type LoggerBindings } 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 { PublicTxSimulator } from './public_tx_simulator.js';
+import type { MeasuredPublicTxSimulatorInterface, PublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
+/**
+ * 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 CppPublicTxSimulator extends PublicTxSimulator implements PublicTxSimulatorInterface {
+    protected log: Logger;
+    /** 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>, bindings?: LoggerBindings);
+    /**
+     * 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>;
+}
+export declare class MeasuredCppPublicTxSimulator extends CppPublicTxSimulator implements MeasuredPublicTxSimulatorInterface {
+    protected readonly metrics: ExecutorMetricsInterface;
+    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, metrics: ExecutorMetricsInterface, config?: Partial<PublicSimulatorConfig>, bindings?: LoggerBindings);
+    simulate(tx: Tx, txLabel?: string): Promise<PublicTxResult>;
+}
+/**
+ * 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>, bindings?: LoggerBindings);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +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,EAAE,KAAK,cAAc,EAA0B,MAAM,uBAAuB,CAAC;AAIjG,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,EACvC,QAAQ,CAAC,EAAE,cAAc,EAI1B;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,EACvC,QAAQ,CAAC,EAAE,cAAc,EAG1B;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,EACvC,QAAQ,CAAC,EAAE,cAAc,EAK1B;CACF"}

package/dest/public/public_tx_simulator/cpp_public_tx_simulator.js

@@ -0,0 +1,132 @@
+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 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, bindings){
+        super(merkleTree, contractsDB, globalVariables, config, undefined, bindings);
+        this.log = createLogger(`simulator:cpp_public_tx_simulator`, bindings);
+    }
+    /**
+   * 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++ simulation of ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, {
+            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, this.bindings);
+        // Serialize to msgpack and call the C++ simulator
+        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 this.simulationPromise;
+        } catch (error) {
+            // 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
+        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: !cppResult.revertCode.isOK(),
+            cppGasUsed: cppResult.gasUsed.totalGas.l2Gas
+        });
+        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');
+        }
+    }
+}
+export class MeasuredCppPublicTxSimulator extends CppPublicTxSimulator {
+    metrics;
+    constructor(merkleTree, contractsDB, globalVariables, metrics, config, bindings){
+        super(merkleTree, contractsDB, globalVariables, config, bindings), 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;
+    }
+}
+/**
+ * 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, bindings){
+        const metrics = new ExecutorMetrics(telemetryClient, 'CppPublicTxSimulator');
+        super(merkleTree, contractsDB, globalVariables, metrics, config, bindings);
+        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, type LoggerBindings } 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>, bindings?: LoggerBindings);
+    /**
+     * 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>, bindings?: LoggerBindings);
+    simulate(tx: Tx, txLabel?: string): Promise<PublicTxResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3BwX3B1YmxpY190eF9zaW11bGF0b3Jfd2l0aF9oaW50ZWRfZGJzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHVibGljL3B1YmxpY190eF9zaW11bGF0b3IvY3BwX3B1YmxpY190eF9zaW11bGF0b3Jfd2l0aF9oaW50ZWRfZGJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBRSxLQUFLLGNBQWMsRUFBMEIsTUFBTSx1QkFBdUIsQ0FBQztBQUVqRyxPQUFPLEVBRUwsS0FBSyxxQkFBcUIsRUFDMUIsY0FBYyxFQUVmLE1BQU0sbUJBQW1CLENBQUM7QUFFM0IsT0FBTyxLQUFLLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNyRSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsRUFBRSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFJNUQsT0FBTyxLQUFLLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUNqRixPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQzdELE9BQU8sS0FBSyxFQUNWLGtDQUFrQyxFQUNsQywwQkFBMEIsRUFDM0IsTUFBTSxvQ0FBb0MsQ0FBQztBQUU1Qzs7Ozs7R0FLRztBQUNILHFCQUFhLDZCQUE4QixTQUFRLGlCQUFrQixZQUFXLDBCQUEwQjtJQUN4RyxVQUFtQixHQUFHLEVBQUUsTUFBTSxDQUFDO0lBRS9CLFlBQ0UsVUFBVSxFQUFFLHlCQUF5QixFQUNyQyxXQUFXLEVBQUUsaUJBQWlCLEVBQzlCLGVBQWUsRUFBRSxlQUFlLEVBQ2hDLE1BQU0sQ0FBQyxFQUFFLE9BQU8sQ0FBQyxxQkFBcUIsQ0FBQyxFQUN2QyxRQUFRLENBQUMsRUFBRSxjQUFjLEVBSTFCO0lBRUQ7Ozs7Ozs7OztPQVNHO0lBQ21CLFFBQVEsQ0FBQyxFQUFFLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0E4QzlEO0NBQ0Y7QUFFRDs7Ozs7O0dBTUc7QUFDSCxxQkFBYSxxQ0FDWCxTQUFRLDZCQUNSLFlBQVcsa0NBQWtDO0lBTTNDLFNBQVMsQ0FBQyxRQUFRLENBQUMsT0FBTyxFQUFFLHdCQUF3QjtJQUp0RCxZQUNFLFVBQVUsRUFBRSx5QkFBeUIsRUFDckMsV0FBVyxFQUFFLGlCQUFpQixFQUM5QixlQUFlLEVBQUUsZUFBZSxFQUNiLE9BQU8sRUFBRSx3QkFBd0IsRUFDcEQsTUFBTSxDQUFDLEVBQUUsT0FBTyxDQUFDLHFCQUFxQixDQUFDLEVBQ3ZDLFFBQVEsQ0FBQyxFQUFFLGNBQWMsRUFHMUI7SUFFcUIsUUFBUSxDQUFDLEVBQUUsRUFBRSxFQUFFLEVBQUUsT0FBTyxHQUFFLE1BQXNCLEdBQUcsT0FBTyxDQUFDLGNBQWMsQ0FBQyxDQVMvRjtDQUNGIn0=

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,EAAE,KAAK,cAAc,EAA0B,MAAM,uBAAuB,CAAC;AAEjG,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,EACvC,QAAQ,CAAC,EAAE,cAAc,EAI1B;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,EACvC,QAAQ,CAAC,EAAE,cAAc,EAG1B;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, bindings){
+        super(merkleTree, contractsDB, globalVariables, config, undefined, bindings);
+        this.log = createLogger(`simulator:cpp_public_tx_simulator_hinted_dbs`, bindings);
+    }
+    /**
+   * 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, bindings){
+        super(merkleTree, contractsDB, globalVariables, config, bindings), 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;
+    }
+}

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

@@ -0,0 +1,30 @@
+import { type Logger, type LoggerBindings } 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';
+/**
+ * An implementation of PublicTxSimulator that first simulates in C++, then TS, an compares the results.
+ * 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 CppVsTsPublicTxSimulator extends PublicTxSimulator implements PublicTxSimulatorInterface {
+    protected log: Logger;
+    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, config?: Partial<PublicSimulatorConfig>, bindings?: LoggerBindings);
+    /**
+     * 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>;
+}
+export declare class MeasuredCppVsTsPublicTxSimulator extends CppVsTsPublicTxSimulator implements MeasuredPublicTxSimulatorInterface {
+    protected readonly metrics: ExecutorMetricsInterface;
+    constructor(merkleTree: MerkleTreeWriteOperations, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, metrics: ExecutorMetricsInterface, config?: Partial<PublicSimulatorConfig>, bindings?: LoggerBindings);
+    simulate(tx: Tx, txLabel?: string): Promise<PublicTxResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3BwX3ZzX3RzX3B1YmxpY190eF9zaW11bGF0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wdWJsaWMvcHVibGljX3R4X3NpbXVsYXRvci9jcHBfdnNfdHNfcHVibGljX3R4X3NpbXVsYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQUUsS0FBSyxjQUFjLEVBQTBCLE1BQU0sdUJBQXVCLENBQUM7QUFHakcsT0FBTyxFQUdMLEtBQUsscUJBQXFCLEVBQzFCLGNBQWMsRUFFZixNQUFNLG1CQUFtQixDQUFDO0FBRTNCLE9BQU8sS0FBSyxFQUFFLHlCQUF5QixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDckUsT0FBTyxLQUFLLEVBQUUsZUFBZSxFQUFrQixFQUFFLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUs1RSxPQUFPLEtBQUssRUFBRSx3QkFBd0IsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQ2pGLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFakUsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDN0QsT0FBTyxLQUFLLEVBQ1Ysa0NBQWtDLEVBQ2xDLDBCQUEwQixFQUMzQixNQUFNLG9DQUFvQyxDQUFDO0FBRTVDOzs7O0dBSUc7QUFDSCxxQkFBYSx3QkFBeUIsU0FBUSxpQkFBa0IsWUFBVywwQkFBMEI7SUFDbkcsVUFBbUIsR0FBRyxFQUFFLE1BQU0sQ0FBQztJQUUvQixZQUNFLFVBQVUsRUFBRSx5QkFBeUIsRUFDckMsV0FBVyxFQUFFLGlCQUFpQixFQUM5QixlQUFlLEVBQUUsZUFBZSxFQUNoQyxNQUFNLENBQUMsRUFBRSxPQUFPLENBQUMscUJBQXFCLENBQUMsRUFDdkMsUUFBUSxDQUFDLEVBQUUsY0FBYyxFQUkxQjtJQUVEOzs7OztPQUtHO0lBQ21CLFFBQVEsQ0FBQyxFQUFFLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0ErSjlEO0NBQ0Y7QUFFRCxxQkFBYSxnQ0FDWCxTQUFRLHdCQUNSLFlBQVcsa0NBQWtDO0lBTTNDLFNBQVMsQ0FBQyxRQUFRLENBQUMsT0FBTyxFQUFFLHdCQUF3QjtJQUp0RCxZQUNFLFVBQVUsRUFBRSx5QkFBeUIsRUFDckMsV0FBVyxFQUFFLGlCQUFpQixFQUM5QixlQUFlLEVBQUUsZUFBZSxFQUNiLE9BQU8sRUFBRSx3QkFBd0IsRUFDcEQsTUFBTSxDQUFDLEVBQUUsT0FBTyxDQUFDLHFCQUFxQixDQUFDLEVBQ3ZDLFFBQVEsQ0FBQyxFQUFFLGNBQWMsRUFHMUI7SUFFcUIsUUFBUSxDQUFDLEVBQUUsRUFBRSxFQUFFLEVBQUUsT0FBTyxHQUFFLE1BQXNCLEdBQUcsT0FBTyxDQUFDLGNBQWMsQ0FBQyxDQVMvRjtDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"cpp_vs_ts_public_tx_simulator.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/cpp_vs_ts_public_tx_simulator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAA0B,MAAM,uBAAuB,CAAC;AAGjG,OAAO,EAGL,KAAK,qBAAqB,EAC1B,cAAc,EAEf,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAkB,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAK5E,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,wBAAyB,SAAQ,iBAAkB,YAAW,0BAA0B;IACnG,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,EACvC,QAAQ,CAAC,EAAE,cAAc,EAI1B;IAED;;;;;OAKG;IACmB,QAAQ,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC,CA+J9D;CACF;AAED,qBAAa,gCACX,SAAQ,wBACR,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,EACvC,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAEqB,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,OAAO,GAAE,MAAsB,GAAG,OAAO,CAAC,cAAc,CAAC,CAS/F;CACF"}