@aztec/simulator 0.43.0 → 0.45.0

package/src/avm/avm_execution_environment.ts

@@ -1,15 +1,15 @@
-import { FunctionSelector, type GasSettings, type GlobalVariables, type Header } from '@aztec/circuits.js';
+import { FunctionSelector, type GlobalVariables, type Header } from '@aztec/circuits.js';
 import { computeVarArgsHash } from '@aztec/circuits.js/hash';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 
 export class AvmContextInputs {
-  static readonly SIZE = 3;
+  static readonly SIZE = 2;
 
-  constructor(private selector: Fr, private argsHash: Fr, private isStaticCall: boolean) {}
+  constructor(private argsHash: Fr, private isStaticCall: boolean) {}
 
   public toFields(): Fr[] {
-    return [this.selector, this.argsHash, new Fr(this.isStaticCall)];
+    return [this.argsHash, new Fr(this.isStaticCall)];
   }
 }
 
@@ -17,36 +17,24 @@ export class AvmContextInputs {
  * Contains variables that remain constant during AVM execution
  * These variables are provided by the public kernel circuit
  */
-// TODO(https://github.com/AztecProtocol/aztec-packages/issues/3992): gas not implemented
 export class AvmExecutionEnvironment {
   constructor(
     public readonly address: AztecAddress,
     public readonly storageAddress: AztecAddress,
     public readonly sender: AztecAddress,
-    public readonly feePerL2Gas: Fr,
-    public readonly feePerDaGas: Fr,
+    public readonly functionSelector: FunctionSelector, // may be temporary (#7224)
     public readonly contractCallDepth: Fr,
+    public readonly transactionFee: Fr,
     public readonly header: Header,
     public readonly globals: GlobalVariables,
     public readonly isStaticCall: boolean,
     public readonly isDelegateCall: boolean,
     public readonly calldata: Fr[],
-    public readonly gasSettings: GasSettings,
-    public readonly transactionFee: Fr,
-
-    // Function selector is temporary since eventually public contract bytecode will be one blob
-    // containing all functions, and function selector will become an application-level mechanism
-    // (e.g. first few bytes of calldata + compiler-generated jump table)
-    public readonly temporaryFunctionSelector: FunctionSelector,
   ) {
     // We encode some extra inputs (AvmContextInputs) in calldata.
     // This will have to go once we move away from one proof per call.
-    const inputs = new AvmContextInputs(
-      temporaryFunctionSelector.toField(),
-      computeVarArgsHash(calldata),
-      isStaticCall,
-    );
-    this.calldata = [...inputs.toFields(), ...calldata];
+    const inputs = new AvmContextInputs(computeVarArgsHash(calldata), isStaticCall).toFields();
+    this.calldata = [...inputs, ...calldata];
   }
 
   private deriveEnvironmentForNestedCallInternal(
@@ -60,17 +48,14 @@ export class AvmExecutionEnvironment {
       /*address=*/ targetAddress,
       /*storageAddress=*/ targetAddress,
       /*sender=*/ this.address,
-      this.feePerL2Gas,
-      this.feePerDaGas,
-      this.contractCallDepth,
+      functionSelector,
+      this.contractCallDepth.add(Fr.ONE),
+      this.transactionFee,
       this.header,
       this.globals,
       isStaticCall,
       isDelegateCall,
       calldata,
-      this.gasSettings,
-      this.transactionFee,
-      functionSelector,
     );
   }
 
@@ -109,4 +94,9 @@ export class AvmExecutionEnvironment {
   ): AvmExecutionEnvironment {
     throw new Error('Delegate calls not supported!');
   }
+
+  public getCalldataWithoutPrefix(): Fr[] {
+    // clip off the first few entries
+    return this.calldata.slice(AvmContextInputs.SIZE);
+  }
 }

package/src/avm/avm_gas.ts

@@ -76,7 +76,7 @@ const BaseGasCosts: Record<Opcode, Gas> = {
   [Opcode.FEEPERL2GAS]: DefaultBaseGasCost,
   [Opcode.FEEPERDAGAS]: DefaultBaseGasCost,
   [Opcode.TRANSACTIONFEE]: DefaultBaseGasCost,
-  [Opcode.CONTRACTCALLDEPTH]: DefaultBaseGasCost,
+  [Opcode.FUNCTIONSELECTOR]: DefaultBaseGasCost,
   [Opcode.CHAINID]: DefaultBaseGasCost,
   [Opcode.VERSION]: DefaultBaseGasCost,
   [Opcode.BLOCKNUMBER]: DefaultBaseGasCost,

package/src/avm/avm_simulator.ts

@@ -2,9 +2,9 @@ import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 
 import { strict as assert } from 'assert';
 
-import { decompressBytecodeIfCompressed, isAvmBytecode } from '../public/transitional_adaptors.js';
 import type { AvmContext } from './avm_context.js';
-import { AvmContractCallResults } from './avm_message_call_result.js';
+import { AvmContractCallResult } from './avm_contract_call_result.js';
+import { decompressBytecodeIfCompressed, isAvmBytecode } from './bytecode_utils.js';
 import {
   AvmExecutionError,
   InvalidProgramCounterError,
@@ -20,19 +20,16 @@ export class AvmSimulator {
   private bytecode: Buffer | undefined;
 
   constructor(private context: AvmContext) {
-    this.log = createDebugLogger(
-      `aztec:avm_simulator:core(f:${context.environment.temporaryFunctionSelector.toString()})`,
-    );
+    this.log = createDebugLogger(`aztec:avm_simulator:core(f:${context.environment.functionSelector.toString()})`);
   }
 
   /**
    * Fetch the bytecode and execute it in the current context.
    */
-  public async execute(): Promise<AvmContractCallResults> {
-    const selector = this.context.environment.temporaryFunctionSelector;
-    const bytecode = await this.context.persistableState.hostStorage.contractsDb.getBytecode(
+  public async execute(): Promise<AvmContractCallResult> {
+    const bytecode = await this.context.persistableState.getBytecode(
       this.context.environment.address,
-      selector,
+      this.context.environment.functionSelector,
     );
 
     // This assumes that we will not be able to send messages to accounts without code
@@ -55,7 +52,7 @@ export class AvmSimulator {
    * Executes the provided bytecode in the current context.
    * This method is useful for testing and debugging.
    */
-  public async executeBytecode(bytecode: Buffer): Promise<AvmContractCallResults> {
+  public async executeBytecode(bytecode: Buffer): Promise<AvmContractCallResult> {
     const decompressedBytecode = await decompressBytecodeIfCompressed(bytecode);
     assert(isAvmBytecode(decompressedBytecode), "AVM simulator can't execute non-AVM bytecode");
 
@@ -67,7 +64,7 @@ export class AvmSimulator {
    * Executes the provided instructions in the current context.
    * This method is useful for testing and debugging.
    */
-  public async executeInstructions(instructions: Instruction[]): Promise<AvmContractCallResults> {
+  public async executeInstructions(instructions: Instruction[]): Promise<AvmContractCallResult> {
     assert(instructions.length > 0);
     const { machineState } = this.context;
     try {
@@ -96,7 +93,7 @@ export class AvmSimulator {
       const output = machineState.getOutput();
       const reverted = machineState.getReverted();
       const revertReason = reverted ? revertReasonFromExplicitRevert(output, this.context) : undefined;
-      const results = new AvmContractCallResults(reverted, output, revertReason);
+      const results = new AvmContractCallResult(reverted, output, revertReason);
       this.log.debug(`Context execution results: ${results.toString()}`);
       // Return results for processing by calling context
       return results;
@@ -109,7 +106,7 @@ export class AvmSimulator {
 
       const revertReason = revertReasonFromExceptionalHalt(err, this.context);
       // Note: "exceptional halts" cannot return data, hence []
-      const results = new AvmContractCallResults(/*reverted=*/ true, /*output=*/ [], revertReason);
+      const results = new AvmContractCallResult(/*reverted=*/ true, /*output=*/ [], revertReason);
       this.log.debug(`Context execution results: ${results.toString()}`);
       // Return results for processing by calling context
       return results;

package/src/avm/bytecode_utils.ts

@@ -0,0 +1,32 @@
+import { promisify } from 'util';
+import { gunzip } from 'zlib';
+
+import { Mov } from '../avm/opcodes/memory.js';
+
+const AVM_MAGIC_SUFFIX = Buffer.from([
+  Mov.opcode, // opcode
+  0x00, // indirect
+  ...Buffer.from('000018ca', 'hex'), // srcOffset
+  ...Buffer.from('000018ca', 'hex'), // dstOffset
+]);
+
+export function markBytecodeAsAvm(bytecode: Buffer): Buffer {
+  return Buffer.concat([bytecode, AVM_MAGIC_SUFFIX]);
+}
+
+// This is just a helper function for the AVM simulator
+export async function decompressBytecodeIfCompressed(bytecode: Buffer): Promise<Buffer> {
+  try {
+    return await promisify(gunzip)(bytecode);
+  } catch {
+    // If the bytecode is not compressed, the gunzip call will throw an error
+    // In this case, we assume the bytecode is not compressed and continue.
+    return Promise.resolve(bytecode);
+  }
+}
+
+export async function isAvmBytecode(bytecode: Buffer): Promise<boolean> {
+  const decompressedBytecode = await decompressBytecodeIfCompressed(bytecode);
+  const magicSize = AVM_MAGIC_SUFFIX.length;
+  return decompressedBytecode.subarray(-magicSize).equals(AVM_MAGIC_SUFFIX);
+}

package/src/avm/errors.ts

@@ -113,7 +113,7 @@ function createRevertReason(message: string, context: AvmContext, nestedError?:
     message,
     /*failingFunction=*/ {
       contractAddress: context.environment.address,
-      functionSelector: context.environment.temporaryFunctionSelector,
+      functionSelector: context.environment.functionSelector,
     },
     /*noirCallStack=*/ [...context.machineState.internalCallStack, context.machineState.pc].map(pc => `0.${pc}`),
     /*options=*/ { cause: nestedError },

package/src/avm/fixtures/index.ts

@@ -1,23 +1,24 @@
-import { GasFees, GasSettings, GlobalVariables, Header } from '@aztec/circuits.js';
+import { GasFees, GlobalVariables, Header } from '@aztec/circuits.js';
 import { FunctionSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { AvmTestContractArtifact } from '@aztec/noir-contracts.js';
-import { SerializableContractInstance } from '@aztec/types/contracts';
 
 import { strict as assert } from 'assert';
 import { mock } from 'jest-mock-extended';
 import merge from 'lodash.merge';
 
 import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from '../../index.js';
+import { type PublicSideEffectTraceInterface } from '../../public/side_effect_trace_interface.js';
 import { AvmContext } from '../avm_context.js';
 import { AvmContextInputs, AvmExecutionEnvironment } from '../avm_execution_environment.js';
 import { AvmMachineState } from '../avm_machine_state.js';
 import { Field, Uint8 } from '../avm_memory_types.js';
 import { HostStorage } from '../journal/host_storage.js';
 import { AvmPersistableStateManager } from '../journal/journal.js';
-import { type TracedContractInstance } from '../journal/trace_types.js';
+import { NullifierManager } from '../journal/nullifiers.js';
+import { PublicStorage } from '../journal/public_storage.js';
 
 /**
  * Create a new AVM context with default values.
@@ -28,7 +29,7 @@ export function initContext(overrides?: {
   machineState?: AvmMachineState;
 }): AvmContext {
   return new AvmContext(
-    overrides?.persistableState || initMockPersistableStateManager(),
+    overrides?.persistableState || initPersistableStateManager(),
     overrides?.env || initExecutionEnvironment(),
     overrides?.machineState || initMachineState(),
   );
@@ -47,9 +48,20 @@ export function initHostStorage(overrides?: {
   );
 }
 
-/** Creates an empty state manager with mocked storage. */
-export function initMockPersistableStateManager(): AvmPersistableStateManager {
-  return new AvmPersistableStateManager(initHostStorage());
+/** Creates an empty state manager with mocked host storage. */
+export function initPersistableStateManager(overrides?: {
+  hostStorage?: HostStorage;
+  trace?: PublicSideEffectTraceInterface;
+  publicStorage?: PublicStorage;
+  nullifiers?: NullifierManager;
+}): AvmPersistableStateManager {
+  const hostStorage = overrides?.hostStorage || initHostStorage();
+  return new AvmPersistableStateManager(
+    hostStorage,
+    overrides?.trace || mock<PublicSideEffectTraceInterface>(),
+    overrides?.publicStorage || new PublicStorage(hostStorage.publicStateDb),
+    overrides?.nullifiers || new NullifierManager(hostStorage.commitmentsDb),
+  );
 }
 
 /**
@@ -60,17 +72,14 @@ export function initExecutionEnvironment(overrides?: Partial<AvmExecutionEnviron
     overrides?.address ?? AztecAddress.zero(),
     overrides?.storageAddress ?? AztecAddress.zero(),
     overrides?.sender ?? AztecAddress.zero(),
-    overrides?.feePerL2Gas ?? Fr.zero(),
-    overrides?.feePerDaGas ?? Fr.zero(),
+    overrides?.functionSelector ?? FunctionSelector.empty(),
     overrides?.contractCallDepth ?? Fr.zero(),
+    overrides?.transactionFee ?? Fr.zero(),
     overrides?.header ?? Header.empty(),
     overrides?.globals ?? GlobalVariables.empty(),
     overrides?.isStaticCall ?? false,
     overrides?.isDelegateCall ?? false,
     overrides?.calldata ?? [],
-    overrides?.gasSettings ?? GasSettings.empty(),
-    overrides?.transactionFee ?? Fr.ZERO,
-    overrides?.temporaryFunctionSelector ?? FunctionSelector.empty(),
   );
 }
 
@@ -138,14 +147,3 @@ export function getAvmTestContractBytecode(functionName: string): Buffer {
   );
   return artifact.bytecode;
 }
-
-export function randomTracedContractInstance(): TracedContractInstance {
-  const instance = SerializableContractInstance.random();
-  const address = AztecAddress.random();
-  return { exists: true, ...instance, address };
-}
-
-export function emptyTracedContractInstance(withAddress?: AztecAddress): TracedContractInstance {
-  const instance = SerializableContractInstance.empty().withAddress(withAddress ?? AztecAddress.zero());
-  return { exists: false, ...instance };
-}