@aztec/simulator 0.33.0 → 0.35.0

package/src/acvm/oracle/typed_oracle.ts

@@ -89,6 +89,14 @@ export abstract class TypedOracle {
     throw new OracleMethodNotAvailableError('packArguments');
   }
 
+  packReturns(_returns: Fr[]): Promise<Fr> {
+    throw new OracleMethodNotAvailableError('packReturns');
+  }
+
+  unpackReturns(_returnsHash: Fr): Promise<Fr[]> {
+    throw new OracleMethodNotAvailableError('unpackReturns');
+  }
+
   getNullifierKeyPair(_accountAddress: AztecAddress): Promise<KeyPair> {
     throw new OracleMethodNotAvailableError('getNullifierKeyPair');
   }

package/src/avm/avm_execution_environment.ts

@@ -1,4 +1,4 @@
-import { FunctionSelector, type GlobalVariables } from '@aztec/circuits.js';
+import { FunctionSelector, type GasSettings, type GlobalVariables, type Header } from '@aztec/circuits.js';
 import { computeVarArgsHash } from '@aztec/circuits.js/hash';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type EthAddress } from '@aztec/foundation/eth-address';
@@ -22,30 +22,21 @@ export class AvmContextInputs {
 export class AvmExecutionEnvironment {
   constructor(
     public readonly address: AztecAddress,
-
     public readonly storageAddress: AztecAddress,
-
     public readonly origin: AztecAddress,
-
     public readonly sender: AztecAddress,
-
     public readonly portal: EthAddress,
-
     public readonly feePerL1Gas: Fr,
-
     public readonly feePerL2Gas: Fr,
-
     public readonly feePerDaGas: Fr,
-
     public readonly contractCallDepth: 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
@@ -59,24 +50,27 @@ export class AvmExecutionEnvironment {
   }
 
   public deriveEnvironmentForNestedCall(
-    address: AztecAddress,
+    targetAddress: AztecAddress,
     calldata: Fr[],
     temporaryFunctionSelector: FunctionSelector = FunctionSelector.empty(),
   ): AvmExecutionEnvironment {
     return new AvmExecutionEnvironment(
-      address,
-      /*storageAddress=*/ address,
+      targetAddress,
+      /*storageAddress=*/ targetAddress,
       this.origin,
-      this.sender,
+      this.address,
       this.portal,
       this.feePerL1Gas,
       this.feePerL2Gas,
       this.feePerDaGas,
       this.contractCallDepth,
+      this.header,
       this.globals,
       this.isStaticCall,
       this.isDelegateCall,
       calldata,
+      this.gasSettings,
+      this.transactionFee,
       temporaryFunctionSelector,
     );
   }
@@ -96,10 +90,13 @@ export class AvmExecutionEnvironment {
       this.feePerL2Gas,
       this.feePerDaGas,
       this.contractCallDepth,
+      this.header,
       this.globals,
       /*isStaticCall=*/ true,
       this.isDelegateCall,
       calldata,
+      this.gasSettings,
+      this.transactionFee,
       temporaryFunctionSelector,
     );
   }
@@ -119,10 +116,13 @@ export class AvmExecutionEnvironment {
       this.feePerL2Gas,
       this.feePerDaGas,
       this.contractCallDepth,
+      this.header,
       this.globals,
       this.isStaticCall,
       /*isDelegateCall=*/ true,
       calldata,
+      this.gasSettings,
+      this.transactionFee,
       temporaryFunctionSelector,
     );
   }

package/src/avm/avm_gas.ts

@@ -127,7 +127,7 @@ export const GasCosts: Record<Opcode, Gas | typeof DynamicGasCost> = {
   [Opcode.REVERT]: TemporaryDefaultGasCost,
   // Gadgets
   [Opcode.KECCAK]: TemporaryDefaultGasCost,
-  [Opcode.POSEIDON]: TemporaryDefaultGasCost,
+  [Opcode.POSEIDON2]: TemporaryDefaultGasCost,
   [Opcode.SHA256]: TemporaryDefaultGasCost, // temp - may be removed, but alot of contracts rely on i: TemporaryDefaultGasCost,
   [Opcode.PEDERSEN]: TemporaryDefaultGasCost, // temp - may be removed, but alot of contracts rely on i: TemporaryDefaultGasCost,t
 };

package/src/avm/avm_machine_state.ts

@@ -44,10 +44,20 @@ export class AvmMachineState {
   /** Output data must NOT be modified once it is set */
   private output: Fr[] = [];
 
-  constructor(l1GasLeft: number, l2GasLeft: number, daGasLeft: number) {
-    this.l1GasLeft = l1GasLeft;
-    this.l2GasLeft = l2GasLeft;
-    this.daGasLeft = daGasLeft;
+  constructor(gasLeft: Gas);
+  constructor(l1GasLeft: number, l2GasLeft: number, daGasLeft: number);
+  constructor(gasLeftOrL1GasLeft: Gas | number, l2GasLeft?: number, daGasLeft?: number) {
+    if (typeof gasLeftOrL1GasLeft === 'object') {
+      ({ l1Gas: this.l1GasLeft, l2Gas: this.l2GasLeft, daGas: this.daGasLeft } = gasLeftOrL1GasLeft);
+    } else {
+      this.l1GasLeft = gasLeftOrL1GasLeft;
+      this.l2GasLeft = l2GasLeft!;
+      this.daGasLeft = daGasLeft!;
+    }
+  }
+
+  public get gasLeft(): Gas {
+    return { l1Gas: this.l1GasLeft, l2Gas: this.l2GasLeft, daGas: this.daGasLeft };
   }
 
   public static fromState(state: InitialAvmMachineState): AvmMachineState {
@@ -128,6 +138,17 @@ export class AvmMachineState {
     if (!this.halted) {
       throw new Error('Execution results are not ready! Execution is ongoing.');
     }
-    return new AvmContractCallResults(this.reverted, this.output);
+    let revertReason = undefined;
+    if (this.reverted && this.output.length > 0) {
+      try {
+        // Try to interpret the output as a text string.
+        revertReason = new Error(
+          'Reverted with output: ' + String.fromCharCode(...this.output.map(fr => fr.toNumber())),
+        );
+      } catch (e) {
+        revertReason = new Error('Reverted with non-string output');
+      }
+    }
+    return new AvmContractCallResults(this.reverted, this.output, revertReason);
   }
 }

package/src/avm/avm_memory_types.ts

@@ -238,9 +238,9 @@ export class TaggedMemory implements TaggedMemoryInterface {
   public getAs<T>(offset: number): T {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     const word = this._mem[offset];
-    TaggedMemory.log(`get(${offset}) = ${word}`);
+    TaggedMemory.log.debug(`get(${offset}) = ${word}`);
     if (word === undefined) {
-      TaggedMemory.log.warn(`Memory at offset ${offset} is undefined! This might be OK if it's stack dumping.`);
+      TaggedMemory.log.debug(`WARNING: Memory at offset ${offset} is undefined!`);
     }
     return word as T;
   }
@@ -249,7 +249,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     assert(offset + size < TaggedMemory.MAX_MEMORY_SIZE);
     const value = this._mem.slice(offset, offset + size);
-    TaggedMemory.log(`getSlice(${offset}, ${size}) = ${value}`);
+    TaggedMemory.log.debug(`getSlice(${offset}, ${size}) = ${value}`);
     assert(!value.some(e => e === undefined), 'Memory slice contains undefined values.');
     assert(value.length === size, `Expected slice of size ${size}, got ${value.length}.`);
     return value;
@@ -270,7 +270,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
   public set(offset: number, v: MemoryValue) {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     this._mem[offset] = v;
-    TaggedMemory.log(`set(${offset}, ${v})`);
+    TaggedMemory.log.debug(`set(${offset}, ${v})`);
   }
 
   public setSlice(offset: number, vs: MemoryValue[]) {
@@ -281,7 +281,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
       this._mem.length = offset + vs.length;
     }
     this._mem.splice(offset, vs.length, ...vs);
-    TaggedMemory.log(`setSlice(${offset}, ${vs})`);
+    TaggedMemory.log.debug(`setSlice(${offset}, ${vs})`);
   }
 
   public getTag(offset: number): TypeTag {

package/src/avm/avm_simulator.ts

@@ -62,33 +62,33 @@ export class AvmSimulator {
         );
 
         const gasLeft = `l1=${machineState.l1GasLeft} l2=${machineState.l2GasLeft} da=${machineState.daGasLeft}`;
-        this.log.debug(`@${machineState.pc} (${gasLeft}) ${instruction.toString()}`);
+        this.log.debug(`@${machineState.pc} ${instruction.toString()} (${gasLeft})`);
         // Execute the instruction.
         // Normal returns and reverts will return normally here.
         // "Exceptional halts" will throw.
         await instruction.execute(this.context);
 
         if (machineState.pc >= instructions.length) {
-          this.log('Passed end of program!');
+          this.log.warn('Passed end of program');
           throw new InvalidProgramCounterError(machineState.pc, /*max=*/ instructions.length);
         }
       }
 
       // Return results for processing by calling context
       const results = machineState.getResults();
-      this.log(`Context execution results: ${results.toString()}`);
+      this.log.debug(`Context execution results: ${results.toString()}`);
       return results;
     } catch (e) {
-      this.log('Exceptional halt');
+      this.log.verbose('Exceptional halt');
       if (!(e instanceof AvmExecutionError)) {
-        this.log(`Unknown error thrown by avm: ${e}`);
+        this.log.verbose(`Unknown error thrown by avm: ${e}`);
         throw e;
       }
 
       // Return results for processing by calling context
       // Note: "exceptional halts" cannot return data
       const results = new AvmContractCallResults(/*reverted=*/ true, /*output=*/ [], /*revertReason=*/ e);
-      this.log(`Context execution results: ${results.toString()}`);
+      this.log.debug(`Context execution results: ${results.toString()}`);
       return results;
     }
   }

package/src/avm/fixtures/index.ts

@@ -1,5 +1,5 @@
 import { SiblingPath } from '@aztec/circuit-types';
-import { GlobalVariables, L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/circuits.js';
+import { GasFees, GasSettings, GlobalVariables, Header, L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/circuits.js';
 import { FunctionSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -17,6 +17,7 @@ import {
 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';
 
@@ -67,10 +68,13 @@ export function initExecutionEnvironment(overrides?: Partial<AvmExecutionEnviron
     overrides?.feePerL2Gas ?? Fr.zero(),
     overrides?.feePerDaGas ?? Fr.zero(),
     overrides?.contractCallDepth ?? 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(),
   );
 }
@@ -86,6 +90,7 @@ export function initGlobalVariables(overrides?: Partial<GlobalVariables>): Globa
     overrides?.timestamp ?? Fr.zero(),
     overrides?.coinbase ?? EthAddress.ZERO,
     overrides?.feeRecipient ?? AztecAddress.zero(),
+    overrides?.gasFees ?? GasFees.empty(),
   );
 }
 
@@ -134,3 +139,11 @@ export function anyAvmContextInputs() {
   }
   return tv;
 }
+
+export function randomMemoryBytes(length: number): Uint8[] {
+  return [...Array(length)].map(_ => new Uint8(Math.floor(Math.random() * 255)));
+}
+
+export function randomMemoryFields(length: number): Field[] {
+  return [...Array(length)].map(_ => new Field(Fr.random()));
+}

package/src/avm/journal/journal.ts

@@ -2,21 +2,33 @@ import { UnencryptedL2Log } from '@aztec/circuit-types';
 import { AztecAddress, EthAddress, L2ToL1Message } from '@aztec/circuits.js';
 import { EventSelector } from '@aztec/foundation/abi';
 import { Fr } from '@aztec/foundation/fields';
+import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 
 import { type HostStorage } from './host_storage.js';
 import { Nullifiers } from './nullifiers.js';
 import { PublicStorage } from './public_storage.js';
 import { WorldStateAccessTrace } from './trace.js';
-import { type TracedL1toL2MessageCheck, type TracedNoteHashCheck, type TracedNullifierCheck } from './trace_types.js';
+import {
+  type TracedL1toL2MessageCheck,
+  type TracedNoteHash,
+  type TracedNoteHashCheck,
+  type TracedNullifier,
+  type TracedNullifierCheck,
+  type TracedPublicStorageRead,
+  type TracedPublicStorageWrite,
+} from './trace_types.js';
 
 /**
  * Data held within the journal
  */
 export type JournalData = {
+  storageWrites: TracedPublicStorageWrite[];
+  storageReads: TracedPublicStorageRead[];
+
   noteHashChecks: TracedNoteHashCheck[];
-  newNoteHashes: Fr[];
+  newNoteHashes: TracedNoteHash[];
   nullifierChecks: TracedNullifierCheck[];
-  newNullifiers: Fr[];
+  newNullifiers: TracedNullifier[];
   l1ToL2MessageChecks: TracedL1toL2MessageCheck[];
 
   newL1Messages: L2ToL1Message[];
@@ -24,11 +36,6 @@ export type JournalData = {
 
   /** contract address -\> key -\> value */
   currentStorageValue: Map<bigint, Map<bigint, Fr>>;
-
-  /** contract address -\> key -\> value[] (stored in order of access) */
-  storageWrites: Map<bigint, Map<bigint, Fr[]>>;
-  /** contract address -\> key -\> value[] (stored in order of access) */
-  storageReads: Map<bigint, Map<bigint, Fr[]>>;
 };
 
 /**
@@ -41,21 +48,23 @@ export type JournalData = {
  * Manages merging of successful/reverted child state into current state.
  */
 export class AvmPersistableStateManager {
+  private readonly log: DebugLogger = createDebugLogger('aztec:avm_simulator:state_manager');
   /** Reference to node storage */
   public readonly hostStorage: HostStorage;
 
+  // TODO: make members private once this is not used in transitional_adaptors.ts.
   /** World State */
   /** Public storage, including cached writes */
-  private publicStorage: PublicStorage;
+  public publicStorage: PublicStorage;
   /** Nullifier set, including cached/recently-emitted nullifiers */
-  private nullifiers: Nullifiers;
+  public nullifiers: Nullifiers;
 
   /** World State Access Trace */
-  private trace: WorldStateAccessTrace;
+  public trace: WorldStateAccessTrace;
 
   /** Accrued Substate **/
-  private newL1Messages: L2ToL1Message[] = [];
-  private newLogs: UnencryptedL2Log[] = [];
+  public newL1Messages: L2ToL1Message[] = [];
+  public newLogs: UnencryptedL2Log[] = [];
 
   constructor(hostStorage: HostStorage, parent?: AvmPersistableStateManager) {
     this.hostStorage = hostStorage;
@@ -79,6 +88,7 @@ export class AvmPersistableStateManager {
    * @param value - the value being written to the slot
    */
   public writeStorage(storageAddress: Fr, slot: Fr, value: Fr) {
+    this.log.debug(`storage(${storageAddress})@${slot} <- ${value}`);
     // Cache storage writes for later reference/reads
     this.publicStorage.write(storageAddress, slot, value);
     // Trace all storage writes (even reverted ones)
@@ -93,9 +103,10 @@ export class AvmPersistableStateManager {
    * @returns the latest value written to slot, or 0 if never written to before
    */
   public async readStorage(storageAddress: Fr, slot: Fr): Promise<Fr> {
-    const [_exists, value] = await this.publicStorage.read(storageAddress, slot);
+    const [exists, value] = await this.publicStorage.read(storageAddress, slot);
+    this.log.debug(`storage(${storageAddress})@${slot} ?? value: ${value}, exists: ${exists}.`);
     // We want to keep track of all performed reads (even reverted ones)
-    this.trace.tracePublicStorageRead(storageAddress, slot, value);
+    this.trace.tracePublicStorageRead(storageAddress, slot, value, exists);
     return Promise.resolve(value);
   }
 
@@ -111,6 +122,7 @@ export class AvmPersistableStateManager {
   public async checkNoteHashExists(storageAddress: Fr, noteHash: Fr, leafIndex: Fr): Promise<boolean> {
     const gotLeafIndex = await this.hostStorage.commitmentsDb.getCommitmentIndex(noteHash);
     const exists = gotLeafIndex === leafIndex.toBigInt();
+    this.log.debug(`noteHashes(${storageAddress})@${noteHash} ?? leafIndex: ${leafIndex}, exists: ${exists}.`);
     this.trace.traceNoteHashCheck(storageAddress, noteHash, exists, leafIndex);
     return Promise.resolve(exists);
   }
@@ -119,8 +131,9 @@ export class AvmPersistableStateManager {
    * Write a note hash, trace the write.
    * @param noteHash - the unsiloed note hash to write
    */
-  public writeNoteHash(noteHash: Fr) {
-    this.trace.traceNewNoteHash(/*storageAddress*/ Fr.ZERO, noteHash);
+  public writeNoteHash(storageAddress: Fr, noteHash: Fr) {
+    this.log.debug(`noteHashes(${storageAddress}) += @${noteHash}.`);
+    this.trace.traceNewNoteHash(storageAddress, noteHash);
   }
 
   /**
@@ -131,6 +144,9 @@ export class AvmPersistableStateManager {
    */
   public async checkNullifierExists(storageAddress: Fr, nullifier: Fr): Promise<boolean> {
     const [exists, isPending, leafIndex] = await this.nullifiers.checkExists(storageAddress, nullifier);
+    this.log.debug(
+      `nullifiers(${storageAddress})@${nullifier} ?? leafIndex: ${leafIndex}, pending: ${isPending}, exists: ${exists}.`,
+    );
     this.trace.traceNullifierCheck(storageAddress, nullifier, exists, isPending, leafIndex);
     return Promise.resolve(exists);
   }
@@ -141,6 +157,7 @@ export class AvmPersistableStateManager {
    * @param nullifier - the unsiloed nullifier to write
    */
   public async writeNullifier(storageAddress: Fr, nullifier: Fr) {
+    this.log.debug(`nullifiers(${storageAddress}) += ${nullifier}.`);
     // Cache pending nullifiers for later access
     await this.nullifiers.append(storageAddress, nullifier);
     // Trace all nullifier creations (even reverted ones)
@@ -171,6 +188,7 @@ export class AvmPersistableStateManager {
       // error getting message - doesn't exist!
       exists = false;
     }
+    this.log.debug(`l1ToL2Messages(${msgHash})@${msgLeafIndex} ?? exists: ${exists}.`);
     this.trace.traceL1ToL2MessageCheck(msgHash, msgLeafIndex, exists);
     return Promise.resolve(exists);
   }
@@ -181,11 +199,13 @@ export class AvmPersistableStateManager {
    * @param content - Message content.
    */
   public writeL1Message(recipient: EthAddress | Fr, content: Fr) {
+    this.log.debug(`L1Messages(${recipient}) += ${content}.`);
     const recipientAddress = recipient instanceof EthAddress ? recipient : EthAddress.fromField(recipient);
     this.newL1Messages.push(new L2ToL1Message(recipientAddress, content));
   }
 
   public writeLog(contractAddress: Fr, event: Fr, log: Fr[]) {
+    this.log.debug(`UnencryptedL2Log(${contractAddress}) += event ${event} with ${log.length} fields.`);
     this.newLogs.push(
       new UnencryptedL2Log(
         AztecAddress.fromField(contractAddress),