@aztec/simulator 0.63.1 → 0.64.0

package/src/public/enqueued_call_side_effect_trace.ts

@@ -62,9 +62,8 @@ import { createDebugLogger } from '@aztec/foundation/log';
 
 import { assert } from 'console';
 
-import { type AvmContractCallResult } from '../avm/avm_contract_call_result.js';
+import { type AvmContractCallResult, type AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
 import { type AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
-import { createSimulationError } from '../common/errors.js';
 import { type EnqueuedPublicCallExecutionResultWithSideEffects, type PublicFunctionCallResult } from './execution.js';
 import { SideEffectLimitReachedError } from './side_effect_errors.js';
 import { type PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
@@ -188,7 +187,10 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
 
   public merge(forkedTrace: this, reverted: boolean = false) {
     // sanity check to avoid merging the same forked trace twice
-    assert(!this.alreadyMergedIntoParent, 'Cannot merge a forked trace that has already been merged into its parent!');
+    assert(
+      !forkedTrace.alreadyMergedIntoParent,
+      'Cannot merge a forked trace that has already been merged into its parent!',
+    );
     forkedTrace.alreadyMergedIntoParent = true;
 
     // TODO(dbanks12): accept & merge forked trace's hints!
@@ -318,7 +320,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
   public traceNewNoteHash(
     contractAddress: AztecAddress,
     noteHash: Fr,
-    leafIndex: Fr,
+    leafIndex: Fr = Fr.zero(),
     path: Fr[] = emptyNoteHashPath(),
   ) {
     if (this.noteHashes.length + this.previousSideEffectArrayLengths.noteHashes >= MAX_NOTE_HASHES_PER_TX) {
@@ -510,8 +512,6 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     nestedEnvironment: AvmExecutionEnvironment,
     /** How much gas was available for this public execution. */
     startGasLeft: Gas,
-    /** How much gas was left after this public execution. */
-    endGasLeft: Gas,
     /** Bytecode used for this execution. */
     _bytecode: Buffer,
     /** The call's results */
@@ -524,7 +524,10 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     // Store end side effect counter before it gets updated by absorbing nested call trace
     const endSideEffectCounter = new Fr(this.sideEffectCounter);
 
-    const gasUsed = new Gas(startGasLeft.daGas - endGasLeft.daGas, startGasLeft.l2Gas - endGasLeft.l2Gas);
+    const gasUsed = new Gas(
+      startGasLeft.daGas - avmCallResults.gasLeft.daGas,
+      startGasLeft.l2Gas - avmCallResults.gasLeft.l2Gas,
+    );
 
     this.avmCircuitHints.externalCalls.items.push(
       new AvmExternalCallHint(
@@ -576,19 +579,15 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
    * Get the results of public execution.
    */
   public toPublicEnqueuedCallExecutionResult(
-    /** How much gas was left after this public execution. */
-    endGasLeft: Gas,
     /** The call's results */
-    avmCallResults: AvmContractCallResult,
+    avmCallResults: AvmFinalizedCallResult,
   ): EnqueuedPublicCallExecutionResultWithSideEffects {
     return {
-      endGasLeft,
+      endGasLeft: Gas.from(avmCallResults.gasLeft),
       endSideEffectCounter: new Fr(this.sideEffectCounter),
       returnValues: avmCallResults.output,
       reverted: avmCallResults.reverted,
-      revertReason: avmCallResults.revertReason
-        ? createSimulationError(avmCallResults.revertReason, avmCallResults.output)
-        : undefined,
+      revertReason: avmCallResults.revertReason,
       sideEffects: {
         publicDataWrites: this.publicDataWrites,
         noteHashes: this.noteHashes,
@@ -652,12 +651,10 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     _avmEnvironment: AvmExecutionEnvironment,
     /** How much gas was available for this public execution. */
     _startGasLeft: Gas,
-    /** How much gas was left after this public execution. */
-    _endGasLeft: Gas,
     /** Bytecode used for this execution. */
     _bytecode: Buffer,
     /** The call's results */
-    _avmCallResults: AvmContractCallResult,
+    _avmCallResults: AvmFinalizedCallResult,
     /** Function name for logging */
     _functionName: string = 'unknown',
   ): PublicFunctionCallResult {

package/src/public/executor_metrics.ts

@@ -10,7 +10,6 @@ import {
 export class ExecutorMetrics {
   private fnCount: UpDownCounter;
   private fnDuration: Histogram;
-  private bytecodeSize: Histogram;
 
   constructor(client: TelemetryClient, name = 'PublicExecutor') {
     const meter = client.getMeter(name);
@@ -24,19 +23,12 @@ export class ExecutorMetrics {
       unit: 'ms',
       valueType: ValueType.INT,
     });
-
-    this.bytecodeSize = meter.createHistogram(Metrics.PUBLIC_EXECUTION_SIMULATION_BYTECODE_SIZE, {
-      description: 'Size of the function bytecode',
-      unit: 'By',
-      valueType: ValueType.INT,
-    });
   }
 
-  recordFunctionSimulation(bytecodeSize: number, durationMs: number) {
+  recordFunctionSimulation(durationMs: number) {
     this.fnCount.add(1, {
       [Attributes.OK]: true,
     });
-    this.bytecodeSize.record(bytecodeSize);
     this.fnDuration.record(Math.ceil(durationMs));
   }
 

package/src/public/fixtures/index.ts

@@ -0,0 +1,158 @@
+import { PublicExecutionRequest, Tx } from '@aztec/circuit-types';
+import {
+  type AvmCircuitInputs,
+  CallContext,
+  DEFAULT_GAS_LIMIT,
+  Gas,
+  GasFees,
+  GasSettings,
+  GlobalVariables,
+  Header,
+  MAX_L2_GAS_PER_ENQUEUED_CALL,
+  PartialPrivateTailPublicInputsForPublic,
+  PrivateKernelTailCircuitPublicInputs,
+  type PublicFunction,
+  PublicKeys,
+  RollupValidationRequests,
+  SerializableContractInstance,
+  TxConstantData,
+  TxContext,
+} from '@aztec/circuits.js';
+import { makeContractClassPublic, makeContractInstanceFromClassId } from '@aztec/circuits.js/testing';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Fr, Point } from '@aztec/foundation/fields';
+import { openTmpStore } from '@aztec/kv-store/utils';
+import { PublicTxSimulator, type WorldStateDB } from '@aztec/simulator';
+import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
+import { MerkleTrees } from '@aztec/world-state';
+
+import { mock } from 'jest-mock-extended';
+
+import { getAvmTestContractBytecode, getAvmTestContractFunctionSelector } from '../../avm/fixtures/index.js';
+
+const TIMESTAMP = new Fr(99833);
+
+/**
+ * If assertionErrString is set, we expect a (non exceptional halting) revert due to a failing assertion and
+ * we check that the revert reason error contains this string. However, the circuit must correctly prove the
+ * execution.
+ */
+export async function simulateAvmTestContractGenerateCircuitInputs(
+  functionName: string,
+  calldata: Fr[] = [],
+  assertionErrString?: string,
+): Promise<AvmCircuitInputs> {
+  const sender = AztecAddress.random();
+  const functionSelector = getAvmTestContractFunctionSelector(functionName);
+  calldata = [functionSelector.toField(), ...calldata];
+
+  const globalVariables = GlobalVariables.empty();
+  globalVariables.gasFees = GasFees.default();
+  globalVariables.timestamp = TIMESTAMP;
+
+  const worldStateDB = mock<WorldStateDB>();
+  const telemetry = new NoopTelemetryClient();
+  const merkleTrees = await (await MerkleTrees.new(openTmpStore(), telemetry)).fork();
+  worldStateDB.getMerkleInterface.mockReturnValue(merkleTrees);
+
+  // Top level contract call
+  const bytecode = getAvmTestContractBytecode('public_dispatch');
+  const dispatchSelector = getAvmTestContractFunctionSelector('public_dispatch');
+  const publicFn: PublicFunction = { bytecode, selector: dispatchSelector };
+  const contractClass = makeContractClassPublic(0, publicFn);
+  const contractInstance = makeContractInstanceFromClassId(contractClass.id);
+
+  // The values here should match those in `avm_simulator.test.ts`
+  const instanceGet = new SerializableContractInstance({
+    version: 1,
+    salt: new Fr(0x123),
+    deployer: new AztecAddress(new Fr(0x456)),
+    contractClassId: new Fr(0x789),
+    initializationHash: new Fr(0x101112),
+    publicKeys: new PublicKeys(
+      new Point(new Fr(0x131415), new Fr(0x161718), false),
+      new Point(new Fr(0x192021), new Fr(0x222324), false),
+      new Point(new Fr(0x252627), new Fr(0x282930), false),
+      new Point(new Fr(0x313233), new Fr(0x343536), false),
+    ),
+  }).withAddress(contractInstance.address);
+  worldStateDB.getContractInstance
+    .mockResolvedValueOnce(contractInstance)
+    .mockResolvedValueOnce(instanceGet) // test gets deployer
+    .mockResolvedValueOnce(instanceGet) // test gets class id
+    .mockResolvedValueOnce(instanceGet) // test gets init hash
+    .mockResolvedValue(contractInstance);
+  worldStateDB.getContractClass.mockResolvedValue(contractClass);
+  worldStateDB.getBytecode.mockResolvedValue(bytecode);
+
+  const storageValue = new Fr(5);
+  worldStateDB.storageRead.mockResolvedValue(Promise.resolve(storageValue));
+
+  const simulator = new PublicTxSimulator(
+    merkleTrees,
+    worldStateDB,
+    new NoopTelemetryClient(),
+    globalVariables,
+    /*doMerkleOperations=*/ true,
+  );
+
+  const callContext = new CallContext(sender, contractInstance.address, dispatchSelector, /*isStaticCall=*/ false);
+  const executionRequest = new PublicExecutionRequest(callContext, calldata);
+
+  const tx: Tx = createTxForPublicCall(executionRequest);
+
+  const avmResult = await simulator.simulate(tx);
+
+  if (assertionErrString == undefined) {
+    expect(avmResult.revertCode.isOK()).toBe(true);
+  } else {
+    // Explicit revert when an assertion failed.
+    expect(avmResult.revertCode.isOK()).toBe(false);
+    expect(avmResult.revertReason).toBeDefined();
+    expect(avmResult.revertReason?.getMessage()).toContain(assertionErrString);
+  }
+
+  const avmCircuitInputs: AvmCircuitInputs = avmResult.avmProvingRequest.inputs;
+  return avmCircuitInputs;
+}
+
+/**
+ * Craft a carrier transaction for a public call for simulation by PublicTxSimulator.
+ */
+export function createTxForPublicCall(
+  executionRequest: PublicExecutionRequest,
+  gasUsedByPrivate: Gas = Gas.empty(),
+  isTeardown: boolean = false,
+): Tx {
+  const callRequest = executionRequest.toCallRequest();
+  // use max limits
+  const gasLimits = new Gas(DEFAULT_GAS_LIMIT, MAX_L2_GAS_PER_ENQUEUED_CALL);
+
+  const forPublic = PartialPrivateTailPublicInputsForPublic.empty();
+  // TODO(#9269): Remove this fake nullifier method as we move away from 1st nullifier as hash.
+  forPublic.nonRevertibleAccumulatedData.nullifiers[0] = Fr.random(); // fake tx nullifier
+  if (isTeardown) {
+    forPublic.publicTeardownCallRequest = callRequest;
+  } else {
+    forPublic.revertibleAccumulatedData.publicCallRequests[0] = callRequest;
+  }
+
+  const teardownGasLimits = isTeardown ? gasLimits : Gas.empty();
+  const gasSettings = new GasSettings(gasLimits, teardownGasLimits, GasFees.empty());
+  const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
+  const constantData = new TxConstantData(Header.empty(), txContext, Fr.zero(), Fr.zero());
+
+  const txData = new PrivateKernelTailCircuitPublicInputs(
+    constantData,
+    RollupValidationRequests.empty(),
+    /*gasUsed=*/ gasUsedByPrivate,
+    AztecAddress.zero(),
+    forPublic,
+  );
+  const tx = isTeardown ? Tx.newWithTxData(txData, executionRequest) : Tx.newWithTxData(txData);
+  if (!isTeardown) {
+    tx.enqueuedPublicFunctionCalls[0] = executionRequest;
+  }
+
+  return tx;
+}

package/src/public/index.ts

@@ -1,10 +1,6 @@
 export * from './db_interfaces.js';
 export * from './public_tx_simulator.js';
-export {
-  type EnqueuedPublicCallExecutionResult as PublicExecutionResult,
-  type PublicFunctionCallResult,
-} from './execution.js';
-export { PublicExecutor } from './executor.js';
+export { type EnqueuedPublicCallExecutionResult, type PublicFunctionCallResult } from './execution.js';
 export * from './fee_payment.js';
 export * from './public_db_sources.js';
 export { PublicProcessor, PublicProcessorFactory } from './public_processor.js';

package/src/public/public_processor.ts

@@ -20,9 +20,7 @@ import {
   type Header,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
-  MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   NULLIFIER_SUBTREE_HEIGHT,
-  PUBLIC_DATA_SUBTREE_HEIGHT,
   PublicDataWrite,
 } from '@aztec/circuits.js';
 import { padArrayEnd } from '@aztec/foundation/collection';
@@ -31,7 +29,6 @@ import { Timer } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { Attributes, type TelemetryClient, type Tracer, trackSpan } from '@aztec/telemetry-client';
 
-import { PublicExecutor } from './executor.js';
 import { computeFeePayerBalanceLeafSlot, computeFeePayerBalanceStorageSlot } from './fee_payment.js';
 import { WorldStateDB } from './public_db_sources.js';
 import { PublicProcessorMetrics } from './public_processor_metrics.js';
@@ -54,18 +51,17 @@ export class PublicProcessorFactory {
     maybeHistoricalHeader: Header | undefined,
     globalVariables: GlobalVariables,
   ): PublicProcessor {
-    const { telemetryClient } = this;
     const historicalHeader = maybeHistoricalHeader ?? merkleTree.getInitialHeader();
 
     const worldStateDB = new WorldStateDB(merkleTree, this.contractDataSource);
-    const publicExecutor = new PublicExecutor(worldStateDB, telemetryClient);
+    const publicTxSimulator = new PublicTxSimulator(merkleTree, worldStateDB, this.telemetryClient, globalVariables);
 
-    return PublicProcessor.create(
+    return new PublicProcessor(
       merkleTree,
-      publicExecutor,
       globalVariables,
       historicalHeader,
       worldStateDB,
+      publicTxSimulator,
       this.telemetryClient,
     );
   }
@@ -89,19 +85,6 @@ export class PublicProcessor {
     this.metrics = new PublicProcessorMetrics(telemetryClient, 'PublicProcessor');
   }
 
-  static create(
-    db: MerkleTreeWriteOperations,
-    publicExecutor: PublicExecutor,
-    globalVariables: GlobalVariables,
-    historicalHeader: Header,
-    worldStateDB: WorldStateDB,
-    telemetryClient: TelemetryClient,
-  ) {
-    const publicTxSimulator = PublicTxSimulator.create(db, publicExecutor, globalVariables, worldStateDB);
-
-    return new PublicProcessor(db, globalVariables, historicalHeader, worldStateDB, publicTxSimulator, telemetryClient);
-  }
-
   get tracer(): Tracer {
     return this.metrics.tracer;
   }
@@ -184,15 +167,10 @@ export class PublicProcessor {
           }
         }
 
-        const allPublicDataWrites = padArrayEnd(
-          processedTx.txEffect.publicDataWrites,
-          PublicDataWrite.empty(),
-          MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-        );
         await this.db.batchInsert(
           MerkleTreeId.PUBLIC_DATA_TREE,
-          allPublicDataWrites.map(x => x.toBuffer()),
-          PUBLIC_DATA_SUBTREE_HEIGHT,
+          processedTx.txEffect.publicDataWrites.map(x => x.toBuffer()),
+          0,
         );
         result.push(processedTx);
         returns = returns.concat(returnValues ?? []);

package/src/public/public_tx_context.ts

@@ -25,10 +25,10 @@ import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { strict as assert } from 'assert';
 import { inspect } from 'util';
 
+import { type AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
 import { AvmPersistableStateManager } from '../avm/index.js';
 import { DualSideEffectTrace } from './dual_side_effect_trace.js';
 import { PublicEnqueuedCallSideEffectTrace, SideEffectArrayLengths } from './enqueued_call_side_effect_trace.js';
-import { type EnqueuedPublicCallExecutionResult } from './execution.js';
 import { type WorldStateDB } from './public_db_sources.js';
 import { PublicSideEffectTrace } from './side_effect_trace.js';
 import { generateAvmCircuitPublicInputs, generateAvmProvingRequest } from './transitional_adapters.js';
@@ -70,6 +70,7 @@ export class PublicTxContext {
     private readonly nonRevertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
     private readonly revertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
     public trace: PublicEnqueuedCallSideEffectTrace, // FIXME(dbanks12): should be private
+    private doMerkleOperations: boolean,
   ) {
     this.log = createDebugLogger(`aztec:public_tx_context`);
     this.gasUsed = startGasUsed;
@@ -80,6 +81,7 @@ export class PublicTxContext {
     worldStateDB: WorldStateDB,
     tx: Tx,
     globalVariables: GlobalVariables,
+    doMerkleOperations: boolean,
   ) {
     const nonRevertibleAccumulatedDataFromPrivate = tx.data.forPublic!.nonRevertibleAccumulatedData;
     const revertibleAccumulatedDataFromPrivate = tx.data.forPublic!.revertibleAccumulatedData;
@@ -109,10 +111,11 @@ export class PublicTxContext {
     const trace = new DualSideEffectTrace(innerCallTrace, enqueuedCallTrace);
 
     // Transaction level state manager that will be forked for revertible phases.
-    const txStateManager = AvmPersistableStateManager.newWithPendingSiloedNullifiers(
+    const txStateManager = await AvmPersistableStateManager.newWithPendingSiloedNullifiers(
       worldStateDB,
       trace,
       nonRevertibleNullifiersFromPrivate,
+      doMerkleOperations,
     );
 
     return new PublicTxContext(
@@ -131,6 +134,7 @@ export class PublicTxContext {
       tx.data.forPublic!.nonRevertibleAccumulatedData,
       tx.data.forPublic!.revertibleAccumulatedData,
       enqueuedCallTrace,
+      doMerkleOperations,
     );
   }
 
@@ -340,26 +344,27 @@ export class PublicTxContext {
   }
 
   // TODO(dbanks12): remove once AVM proves entire public tx
-  async updateProvingRequest(
+  updateProvingRequest(
     real: boolean,
     phase: TxExecutionPhase,
-    worldStateDB: WorldStateDB,
+    fnName: string,
     stateManager: AvmPersistableStateManager,
     executionRequest: PublicExecutionRequest,
-    result: EnqueuedPublicCallExecutionResult,
+    result: AvmFinalizedCallResult,
     allocatedGas: Gas,
   ) {
     if (this.avmProvingRequest === undefined) {
       // Propagate the very first avmProvingRequest of the tx for now.
       // Eventually this will be the proof for the entire public portion of the transaction.
-      this.avmProvingRequest = await generateAvmProvingRequest(
+      this.avmProvingRequest = generateAvmProvingRequest(
         real,
-        worldStateDB,
+        fnName,
         stateManager,
         this.historicalHeader,
         this.globalVariables,
         executionRequest,
-        result,
+        // TODO(dbanks12): do we need this return type unless we are doing an isolated call?
+        stateManager.trace.toPublicEnqueuedCallExecutionResult(result),
         allocatedGas,
         this.getTransactionFee(phase),
       );