@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.0b941701

package/src/private/{providers/factory.ts → factory.ts}

@@ -4,14 +4,14 @@ import { promises as fs } from 'fs';
 
 import { NativeACVMSimulator } from './acvm_native.js';
 import { WASMSimulator } from './acvm_wasm.js';
-import type { SimulationProvider } from './simulation_provider.js';
+import type { CircuitSimulator } from './circuit_simulator.js';
 
-export type SimulationProviderConfig = {
+export type SimulatorConfig = {
   acvmBinaryPath?: string;
   acvmWorkingDirectory?: string;
 };
 
-export function getSimulationProviderConfigFromEnv() {
+export function getSimulatorConfigFromEnv() {
   const { ACVM_BINARY_PATH, ACVM_WORKING_DIRECTORY } = process.env;
   return {
     acvmWorkingDirectory: ACVM_WORKING_DIRECTORY ? ACVM_WORKING_DIRECTORY : undefined,
@@ -19,10 +19,10 @@ export function getSimulationProviderConfigFromEnv() {
   };
 }
 
-export async function createSimulationProvider(
-  config: SimulationProviderConfig,
+export async function createSimulator(
+  config: SimulatorConfig,
   logger: Logger = createLogger('simulator'),
-): Promise<SimulationProvider> {
+): Promise<CircuitSimulator> {
   if (config.acvmBinaryPath && config.acvmWorkingDirectory) {
     try {
       await fs.access(config.acvmBinaryPath, fs.constants.R_OK);

package/src/public/avm/avm_context.ts

@@ -1,11 +1,11 @@
-import type { Fr } from '@aztec/foundation/fields';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
+import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
 import type { AvmExecutionEnvironment } from './avm_execution_environment.js';
 import { type Gas, gasToGasLeft } from './avm_gas.js';
 import { AvmMachineState } from './avm_machine_state.js';
-import type { AvmSimulator } from './avm_simulator.js';
-import type { AvmPersistableStateManager } from './journal/journal.js';
+import type { AvmSimulatorInterface } from './avm_simulator_interface.js';
+import type { CallData } from './calldata.js';
 
 /**
  * An execution context includes the information necessary to initiate AVM
@@ -20,14 +20,14 @@ export class AvmContext {
    * @returns new AvmContext instance
    */
   constructor(
-    public persistableState: AvmPersistableStateManager,
+    public persistableState: PublicPersistableStateManager,
     public environment: AvmExecutionEnvironment,
     public machineState: AvmMachineState,
   ) {}
 
   // This is needed to break a dependency cycle created by the CALL opcode,
   // which needs to create a new simulator but cannot depend directly on AvmSimulator.
-  public provideSimulator?: (ctx: this) => Promise<AvmSimulator>;
+  public provideSimulator?: (context: AvmContext) => Promise<AvmSimulatorInterface>;
 
   /**
    * Prepare a new AVM context that will be ready for an external/nested call
@@ -45,7 +45,7 @@ export class AvmContext {
    */
   public async createNestedContractCallContext(
     address: AztecAddress,
-    calldata: Fr[],
+    calldata: CallData,
     allocatedGas: Gas,
     callType: 'CALL' | 'STATICCALL',
   ): Promise<AvmContext> {

package/src/public/avm/avm_contract_call_result.ts

@@ -1,4 +1,3 @@
-import type { Fr } from '@aztec/foundation/fields';
 import type { SimulationError } from '@aztec/stdlib/errors';
 import { Gas } from '@aztec/stdlib/gas';
 
@@ -6,6 +5,7 @@ import { inspect } from 'util';
 
 import { createSimulationError } from '../../common/errors.js';
 import type { Gas as AvmGas } from './avm_gas.js';
+import type { ReturnData } from './calldata.js';
 import type { AvmRevertReason } from './errors.js';
 
 /**
@@ -14,22 +14,33 @@ import type { AvmRevertReason } from './errors.js';
 export class AvmContractCallResult {
   constructor(
     public reverted: boolean,
-    public output: Fr[],
+    public output: ReturnData,
     public gasLeft: AvmGas,
     public revertReason?: AvmRevertReason,
+    public totalInstructions: number = 0, // including nested calls
   ) {}
 
   toString(): string {
-    let resultsStr = `reverted: ${this.reverted}, output: ${this.output}, gasLeft: ${inspect(this.gasLeft)}`;
+    let resultsStr = `reverted: ${this.reverted}, output: ${this.output.bestEffortReadAll(10)}${this.output.length() > 10 ? ' ...' : ''}, gasLeft: ${inspect(
+      this.gasLeft,
+    )}, totalInstructions: ${this.totalInstructions}`;
     if (this.revertReason) {
-      resultsStr += `, revertReason: ${this.revertReason}`;
+      resultsStr += `, revertReason: ${this.revertReason.message}`;
     }
     return resultsStr;
   }
 
   finalize(): AvmFinalizedCallResult {
-    const revertReason = this.revertReason ? createSimulationError(this.revertReason, this.output) : undefined;
-    return new AvmFinalizedCallResult(this.reverted, this.output, Gas.from(this.gasLeft), revertReason);
+    const revertReason = this.revertReason
+      ? createSimulationError(this.revertReason, this.output.bestEffortReadAll())
+      : undefined;
+    return new AvmFinalizedCallResult(
+      this.reverted,
+      this.output,
+      Gas.from(this.gasLeft),
+      revertReason,
+      this.totalInstructions,
+    );
   }
 }
 
@@ -40,15 +51,18 @@ export class AvmContractCallResult {
 export class AvmFinalizedCallResult {
   constructor(
     public reverted: boolean,
-    public output: Fr[],
+    public output: ReturnData,
     public gasLeft: Gas,
     public revertReason?: SimulationError,
+    public totalInstructions: number = 0, // including nested calls
   ) {}
 
   toString(): string {
-    let resultsStr = `reverted: ${this.reverted}, output: ${this.output}, gasLeft: ${inspect(this.gasLeft)}`;
+    let resultsStr = `reverted: ${this.reverted}, output: ${this.output.bestEffortReadAll(10)}${this.output.length() > 10 ? ' ...' : ''}, gasLeft: ${inspect(
+      this.gasLeft,
+    )}, totalInstructions: ${this.totalInstructions}`;
     if (this.revertReason) {
-      resultsStr += `, revertReason: ${this.revertReason}`;
+      resultsStr += `, revertReason: ${this.revertReason.message}`;
     }
     return resultsStr;
   }

package/src/public/avm/avm_execution_environment.ts

@@ -1,7 +1,10 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { PublicSimulatorConfig } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GlobalVariables } from '@aztec/stdlib/tx';
 
+import type { CallData } from './calldata.js';
+
 /**
  * Contains variables that remain constant during AVM execution
  * These variables are provided by the public kernel circuit
@@ -14,10 +17,15 @@ export class AvmExecutionEnvironment {
     public readonly transactionFee: Fr,
     public readonly globals: GlobalVariables,
     public readonly isStaticCall: boolean,
-    public readonly calldata: Fr[],
+    public readonly calldata: CallData,
+    public readonly config: PublicSimulatorConfig,
   ) {}
 
-  private deriveEnvironmentForNestedCallInternal(targetAddress: AztecAddress, calldata: Fr[], isStaticCall: boolean) {
+  private deriveEnvironmentForNestedCallInternal(
+    targetAddress: AztecAddress,
+    calldata: CallData,
+    isStaticCall: boolean,
+  ): AvmExecutionEnvironment {
     return new AvmExecutionEnvironment(
       /*address=*/ targetAddress,
       /*sender=*/ this.address,
@@ -26,14 +34,18 @@ export class AvmExecutionEnvironment {
       this.globals,
       isStaticCall,
       calldata,
+      this.config,
     );
   }
 
-  public deriveEnvironmentForNestedCall(targetAddress: AztecAddress, calldata: Fr[]): AvmExecutionEnvironment {
+  public deriveEnvironmentForNestedCall(targetAddress: AztecAddress, calldata: CallData): AvmExecutionEnvironment {
     return this.deriveEnvironmentForNestedCallInternal(targetAddress, calldata, /*isStaticCall=*/ false);
   }
 
-  public deriveEnvironmentForNestedStaticCall(targetAddress: AztecAddress, calldata: Fr[]): AvmExecutionEnvironment {
+  public deriveEnvironmentForNestedStaticCall(
+    targetAddress: AztecAddress,
+    calldata: CallData,
+  ): AvmExecutionEnvironment {
     return this.deriveEnvironmentForNestedCallInternal(targetAddress, calldata, /*isStaticCall=*/ true);
   }
 }

package/src/public/avm/avm_gas.ts

@@ -2,7 +2,6 @@ import * as c from '@aztec/constants';
 
 import { TypeTag } from './avm_memory_types.js';
 import { InstructionExecutionError } from './errors.js';
-import { Addressing, AddressingMode } from './opcodes/addressing_mode.js';
 import { Opcode } from './serialization/instruction_serialization.js';
 
 /** Gas counters in L1, L2, and DA. */
@@ -27,9 +26,9 @@ export function makeGas(gasCost: Partial<Gas>) {
 }
 
 /** Sums together multiple instances of Gas. */
-export function sumGas(...gases: Partial<Gas>[]) {
-  return gases.reduce(
-    (acc: Gas, gas) => ({
+export function sumGas(...gases: Partial<Gas>[]): Gas {
+  return gases.reduce<Gas>(
+    (acc, gas) => ({
       l2Gas: acc.l2Gas + (gas.l2Gas ?? 0),
       daGas: acc.daGas + (gas.daGas ?? 0),
     }),
@@ -105,13 +104,13 @@ const BASE_GAS_COSTS: Record<Opcode, Gas> = {
   [Opcode.MOV_8]: makeCost(c.AVM_MOV_BASE_L2_GAS, 0),
   [Opcode.MOV_16]: makeCost(c.AVM_MOV_BASE_L2_GAS, 0),
   [Opcode.SLOAD]: makeCost(c.AVM_SLOAD_BASE_L2_GAS, 0),
-  [Opcode.SSTORE]: makeCost(c.AVM_SSTORE_BASE_L2_GAS, c.AVM_SSTORE_BASE_DA_GAS),
+  [Opcode.SSTORE]: makeCost(c.AVM_SSTORE_BASE_L2_GAS, 0), // DA gas is dynamic
   [Opcode.NOTEHASHEXISTS]: makeCost(c.AVM_NOTEHASHEXISTS_BASE_L2_GAS, 0),
   [Opcode.EMITNOTEHASH]: makeCost(c.AVM_EMITNOTEHASH_BASE_L2_GAS, c.AVM_EMITNOTEHASH_BASE_DA_GAS),
   [Opcode.NULLIFIEREXISTS]: makeCost(c.AVM_NULLIFIEREXISTS_BASE_L2_GAS, 0),
   [Opcode.EMITNULLIFIER]: makeCost(c.AVM_EMITNULLIFIER_BASE_L2_GAS, c.AVM_EMITNULLIFIER_BASE_DA_GAS),
   [Opcode.L1TOL2MSGEXISTS]: makeCost(c.AVM_L1TOL2MSGEXISTS_BASE_L2_GAS, 0),
-  [Opcode.EMITUNENCRYPTEDLOG]: makeCost(c.AVM_EMITUNENCRYPTEDLOG_BASE_L2_GAS, 0),
+  [Opcode.EMITUNENCRYPTEDLOG]: makeCost(c.AVM_EMITUNENCRYPTEDLOG_BASE_L2_GAS, c.AVM_EMITUNENCRYPTEDLOG_BASE_DA_GAS),
   [Opcode.SENDL2TOL1MSG]: makeCost(c.AVM_SENDL2TOL1MSG_BASE_L2_GAS, c.AVM_SENDL2TOL1MSG_BASE_DA_GAS),
   [Opcode.GETCONTRACTINSTANCE]: makeCost(c.AVM_GETCONTRACTINSTANCE_BASE_L2_GAS, 0),
   [Opcode.CALL]: makeCost(c.AVM_CALL_BASE_L2_GAS, 0),
@@ -130,14 +129,16 @@ const BASE_GAS_COSTS: Record<Opcode, Gas> = {
 const DYNAMIC_GAS_COSTS = new Map<Opcode, Gas>([
   [Opcode.CALLDATACOPY, makeCost(c.AVM_CALLDATACOPY_DYN_L2_GAS, 0)],
   [Opcode.RETURNDATACOPY, makeCost(c.AVM_RETURNDATACOPY_DYN_L2_GAS, 0)],
+  // TODO: Call and static call based on bytecode length
   [Opcode.EMITUNENCRYPTEDLOG, makeCost(c.AVM_EMITUNENCRYPTEDLOG_DYN_L2_GAS, c.AVM_EMITUNENCRYPTEDLOG_DYN_DA_GAS)],
-  [Opcode.CALL, makeCost(c.AVM_CALL_DYN_L2_GAS, 0)],
-  [Opcode.STATICCALL, makeCost(c.AVM_STATICCALL_DYN_L2_GAS, 0)],
-  [Opcode.RETURN, makeCost(c.AVM_RETURN_DYN_L2_GAS, 0)],
-  [Opcode.REVERT_8, makeCost(c.AVM_REVERT_DYN_L2_GAS, 0)],
-  [Opcode.REVERT_16, makeCost(c.AVM_REVERT_DYN_L2_GAS, 0)],
-  [Opcode.DEBUGLOG, makeCost(c.AVM_DEBUGLOG_DYN_L2_GAS, 0)],
   [Opcode.TORADIXBE, makeCost(c.AVM_TORADIXBE_DYN_L2_GAS, 0)],
+  [Opcode.AND_8, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.AND_16, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.OR_8, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.OR_16, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.XOR_8, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.XOR_16, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
+  [Opcode.SSTORE, makeCost(0, c.AVM_SSTORE_DYN_DA_GAS)],
 ]);
 
 /** Returns the fixed base gas cost for a given opcode. */
@@ -145,35 +146,22 @@ export function getBaseGasCost(opcode: Opcode): Gas {
   return BASE_GAS_COSTS[opcode];
 }
 
-export function getDynamicGasCost(opcode: Opcode): Gas {
-  return DYNAMIC_GAS_COSTS.has(opcode) ? DYNAMIC_GAS_COSTS.get(opcode)! : makeCost(0, 0);
-}
-
-/** Returns the gas cost associated with the memory operations performed. */
-export function getMemoryGasCost(args: { reads?: number; writes?: number; indirect?: number }) {
-  const { reads, writes, indirect } = args;
-  const indirectCount = Addressing.fromWire(indirect ?? 0).count(AddressingMode.INDIRECT);
-  const l2MemoryGasCost =
-    (reads ?? 0) * GAS_COST_CONSTANTS.MEMORY_READ +
-    (writes ?? 0) * GAS_COST_CONSTANTS.MEMORY_WRITE +
-    indirectCount * GAS_COST_CONSTANTS.MEMORY_INDIRECT_READ_PENALTY;
-  return makeGas({ l2Gas: l2MemoryGasCost });
+export function computeAddressingCost(indirectOperandsCount: number, relativeOperandsCount: number): Gas {
+  return makeCost(
+    (relativeOperandsCount !== 0 ? c.AVM_ADDRESSING_BASE_RESOLUTION_L2_GAS : 0) +
+      indirectOperandsCount * c.AVM_ADDRESSING_INDIRECT_L2_GAS +
+      relativeOperandsCount * c.AVM_ADDRESSING_RELATIVE_L2_GAS,
+    0,
+  );
 }
 
-/** Constants used in base cost calculations. */
-export const GAS_COST_CONSTANTS = {
-  MEMORY_READ: 10,
-  MEMORY_INDIRECT_READ_PENALTY: 10,
-  MEMORY_WRITE: 100,
-};
-
-/** Returns gas cost for an operation on a given type tag based on the base cost per byte. */
-export function getGasCostForTypeTag(tag: TypeTag, baseCost: Gas) {
-  return mulGas(baseCost, getGasCostMultiplierFromTypeTag(tag));
+export function getDynamicGasCost(opcode: Opcode): Gas {
+  return DYNAMIC_GAS_COSTS.has(opcode) ? DYNAMIC_GAS_COSTS.get(opcode)! : makeCost(0, 0);
 }
 
-/** Returns a multiplier based on the size of the type represented by the tag. Throws on uninitialized or invalid. */
-function getGasCostMultiplierFromTypeTag(tag: TypeTag) {
+/** Returns a multiplier based on the byte size of the type represented by the integer tag.
+ * Used to account for necessary rows in the bitwise trace. Throws on invalid. */
+export function getBitwiseDynamicGasMultiplier(tag: TypeTag) {
   switch (tag) {
     case TypeTag.UINT1: // same as u8
       return 1;
@@ -188,7 +176,7 @@ function getGasCostMultiplierFromTypeTag(tag: TypeTag) {
     case TypeTag.UINT128:
       return 16;
     case TypeTag.FIELD:
-      return 32;
+      return 0; // Field is not allowed for bitwise operations. However we don't fail in gas, since we'll fail in bitwise.
     case TypeTag.INVALID:
       throw new InstructionExecutionError(`Invalid tag type for gas cost multiplier: ${TypeTag[tag]}`);
   }

package/src/public/avm/avm_machine_state.ts

@@ -1,7 +1,8 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { Gas } from './avm_gas.js';
 import { TaggedMemory } from './avm_memory_types.js';
+import { type ReturnData, ReturnDataArray } from './calldata.js';
 import { type AvmRevertReason, OutOfGasError } from './errors.js';
 
 /**
@@ -39,7 +40,7 @@ export class AvmMachineState {
   /** program counter of the next instruction, byte based */
   public nextPc: number = 0;
   /** return/revertdata of the last nested call. */
-  public nestedReturndata: Fr[] = [];
+  public nestedReturndata: ReturnData = new ReturnDataArray([]);
   /** Tracks whether the last external call was successful */
   public nestedCallSuccess: boolean = false;
   /**
@@ -66,7 +67,12 @@ export class AvmMachineState {
   /** Signals that execution has reverted normally (this does not cover exceptional halts) */
   private reverted: boolean = false;
   /** Output data must NOT be modified once it is set */
-  private output: Fr[] = [];
+  private output: ReturnData = new ReturnDataArray([]);
+
+  // Metrics only - not needed for execution
+  /** instruction counter, including nested calls */
+  public instrCounter: number = 0;
+  // End metrics only
 
   constructor(gasLeft: Gas);
   constructor(l2GasLeft: number, daGasLeft: number);
@@ -124,7 +130,7 @@ export class AvmMachineState {
    * Output data must NOT be modified once it is set
    * @param output
    */
-  public return(output: Fr[]) {
+  public return(output: ReturnData) {
     this.halted = true;
     this.output = output;
   }
@@ -134,7 +140,7 @@ export class AvmMachineState {
    * Output data must NOT be modified once it is set
    * @param output
    */
-  public revert(output: Fr[]) {
+  public revert(output: ReturnData) {
     this.halted = true;
     this.reverted = true;
     this.output = output;
@@ -148,7 +154,7 @@ export class AvmMachineState {
     return this.reverted;
   }
 
-  public getOutput(): Fr[] {
+  public getOutput(): ReturnData {
     return this.output;
   }
 

package/src/public/avm/avm_memory_types.ts

@@ -8,7 +8,7 @@ import {
   MEM_TAG_U128,
 } from '@aztec/constants';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import type { FunctionsOf } from '@aztec/foundation/types';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -32,6 +32,9 @@ export abstract class MemoryValue {
 
   // Use sparingly.
   public abstract toBigInt(): bigint;
+  public getTag(): TypeTag {
+    return TaggedMemory.getTag(this);
+  }
 
   // To Buffer
   public abstract toBuffer(): Buffer;
@@ -71,6 +74,7 @@ export abstract class IntegralValue extends MemoryValue {
  **/
 function UnsignedIntegerClassFactory(bits: number) {
   return class NewUintClass extends IntegralValue {
+    static readonly bits: number = bits;
     static readonly mod: bigint = 1n << BigInt(bits);
     static readonly bitmask: bigint = this.mod - 1n;
     public readonly n: bigint; // Cannot be private due to TS limitations.
@@ -78,6 +82,7 @@ function UnsignedIntegerClassFactory(bits: number) {
     public constructor(n: bigint | number) {
       super();
       this.n = BigInt(n);
+      assert(n >= 0n, `${this.constructor.name} cannot handle negative values: ${n}.`);
       assert(n < NewUintClass.mod, `Value ${n} is too large for ${this.constructor.name}.`);
     }
 
@@ -104,12 +109,20 @@ function UnsignedIntegerClassFactory(bits: number) {
 
     // No sign extension.
     public shr(rhs: NewUintClass): NewUintClass {
-      // Note that this.n is > 0 by class invariant.
+      // Note that this.n is >= 0 by class invariant.
       return this.build(this.n >> rhs.n);
     }
 
     public shl(rhs: NewUintClass): NewUintClass {
-      return this.build((this.n << rhs.n) & NewUintClass.bitmask);
+      const shiftAmount = rhs.n;
+      const bitSize = BigInt(NewUintClass.bits);
+
+      // Shifting by more than the bit size always results in 0
+      if (shiftAmount >= bitSize) {
+        return this.build(0n);
+      }
+
+      return this.build((this.n << shiftAmount) & NewUintClass.bitmask);
     }
 
     public and(rhs: NewUintClass): NewUintClass {
@@ -252,7 +265,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
   public getAs<T>(offset: number): T {
     assert(Number.isInteger(offset) && offset < TaggedMemory.MAX_MEMORY_SIZE);
     const word = this._mem.get(offset);
-    //TaggedMemory.log.trace(`get(${offset}) = ${word}`);
+    //TaggedMemory.log.trace(`Memory read: ${offset} -> ${word}`);
     if (word === undefined) {
       TaggedMemory.log.debug(`WARNING: Memory at offset ${offset} is undefined!`);
       return new Field(0) as T;
@@ -288,7 +301,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
   public set(offset: number, v: MemoryValue) {
     assert(Number.isInteger(offset) && offset < TaggedMemory.MAX_MEMORY_SIZE);
     this._mem.set(offset, v);
-    //TaggedMemory.log.trace(`set(${offset}, ${v})`);
+    //TaggedMemory.log.trace(`Memory write: ${offset} <- ${v}`);
   }
 
   public setSlice(offset: number, slice: MemoryValue[]) {
@@ -319,8 +332,8 @@ export class TaggedMemory implements TaggedMemoryInterface {
     }
   }
 
-  public checkIsValidMemoryOffsetTag(offset: number) {
-    this.checkTag(TypeTag.UINT32, offset);
+  public static isValidMemoryAddressTag(tag: TypeTag) {
+    return tag === TypeTag.UINT32;
   }
 
   public static checkIsIntegralTag(tag: TypeTag) {
@@ -356,6 +369,10 @@ export class TaggedMemory implements TaggedMemoryInterface {
    * Check tags for all memory in the specified range.
    */
   public checkTagsRange(tag: TypeTag, startOffset: number, size: number) {
+    if (startOffset + size > TaggedMemory.MAX_MEMORY_SIZE) {
+      throw new MemorySliceOutOfRangeError(startOffset, size);
+    }
+
     for (let offset = startOffset; offset < startOffset + size; offset++) {
       this.checkTag(tag, offset);
     }