@aztec/simulator 0.40.1 → 0.42.0

package/src/avm/journal/nullifiers.ts

@@ -12,21 +12,38 @@ import type { CommitmentsDB } from '../../index.js';
 export class Nullifiers {
   /** Cached nullifiers. */
   public cache: NullifierCache;
-  /** Parent's nullifier cache. Checked on cache-miss. */
-  private readonly parentCache: NullifierCache | undefined;
-  /** Reference to node storage. Checked on parent cache-miss. */
-  private readonly hostNullifiers: CommitmentsDB;
 
-  constructor(hostNullifiers: CommitmentsDB, parent?: Nullifiers) {
-    this.hostNullifiers = hostNullifiers;
-    this.parentCache = parent?.cache;
+  constructor(
+    /** Reference to node storage. Checked on parent cache-miss. */
+    private readonly hostNullifiers: CommitmentsDB,
+    /** Parent's nullifiers. Checked on this' cache-miss. */
+    private readonly parent?: Nullifiers | undefined,
+  ) {
     this.cache = new NullifierCache();
   }
 
+  /**
+   * Get a nullifier's existence in this' cache or parent's (recursively).
+   * DOES NOT CHECK HOST STORAGE!
+   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param nullifier - the nullifier to check for
+   * @returns exists: whether the nullifier exists in cache here or in parent's
+   */
+  private checkExistsHereOrParent(storageAddress: Fr, nullifier: Fr): boolean {
+    // First check this cache
+    let existsAsPending = this.cache.exists(storageAddress, nullifier);
+    // Then try parent's nullifier cache
+    if (!existsAsPending && this.parent) {
+      // Note: this will recurse to grandparent/etc until a cache-hit is encountered.
+      existsAsPending = this.parent.checkExistsHereOrParent(storageAddress, nullifier);
+    }
+    return existsAsPending;
+  }
+
   /**
    * Get a nullifier's existence status.
    * 1. Check cache.
-   * 2. Check parent's cache.
+   * 2. Check parent cache.
    * 3. Fall back to the host state.
    * 4. Not found! Nullifier does not exist.
    *
@@ -40,12 +57,8 @@ export class Nullifiers {
     storageAddress: Fr,
     nullifier: Fr,
   ): Promise<[/*exists=*/ boolean, /*isPending=*/ boolean, /*leafIndex=*/ Fr]> {
-    // First check this cache
-    let existsAsPending = this.cache.exists(storageAddress, nullifier);
-    // Then check parent's cache
-    if (!existsAsPending && this.parentCache) {
-      existsAsPending = this.parentCache?.exists(storageAddress, nullifier);
-    }
+    // Check this cache and parent's (recursively)
+    const existsAsPending = this.checkExistsHereOrParent(storageAddress, nullifier);
     // Finally try the host's Aztec state (a trip to the database)
     // If the value is found in the database, it will be associated with a leaf index!
     let leafIndex: bigint | undefined = undefined;

package/src/avm/journal/public_storage.ts

@@ -17,14 +17,13 @@ type PublicStorageReadResult = {
 export class PublicStorage {
   /** Cached storage writes. */
   private cache: PublicStorageCache;
-  /** Parent's storage cache. Checked on cache-miss. */
-  private readonly parentCache: PublicStorageCache | undefined;
-  /** Reference to node storage. Checked on parent cache-miss. */
-  private readonly hostPublicStorage: PublicStateDB;
 
-  constructor(hostPublicStorage: PublicStateDB, parent?: PublicStorage) {
-    this.hostPublicStorage = hostPublicStorage;
-    this.parentCache = parent?.cache;
+  constructor(
+    /** Reference to node storage. Checked on parent cache-miss. */
+    private readonly hostPublicStorage: PublicStateDB,
+    /** Parent's storage. Checked on this' cache-miss. */
+    private readonly parent?: PublicStorage,
+  ) {
     this.cache = new PublicStorageCache();
   }
 
@@ -35,10 +34,29 @@ export class PublicStorage {
     return this.cache;
   }
 
+  /**
+   * Read a storage value from this' cache or parent's (recursively).
+   * DOES NOT CHECK HOST STORAGE!
+   *
+   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param slot - the slot in the contract's storage being read from
+   * @returns value: the latest value written according to this cache or the parent's. undefined on cache miss.
+   */
+  public readHereOrParent(storageAddress: Fr, slot: Fr): Fr | undefined {
+    // First try check this storage cache
+    let value = this.cache.read(storageAddress, slot);
+    // Then try parent's storage cache
+    if (!value && this.parent) {
+      // Note: this will recurse to grandparent/etc until a cache-hit is encountered.
+      value = this.parent.readHereOrParent(storageAddress, slot);
+    }
+    return value;
+  }
+
   /**
    * Read a value from storage.
    * 1. Check cache.
-   * 2. Check parent's cache.
+   * 2. Check parent cache.
    * 3. Fall back to the host state.
    * 4. Not found! Value has never been written to before. Flag it as non-existent and return value zero.
    *
@@ -48,12 +66,8 @@ export class PublicStorage {
    */
   public async read(storageAddress: Fr, slot: Fr): Promise<PublicStorageReadResult> {
     let cached = false;
-    // First try check this storage cache
-    let value = this.cache.read(storageAddress, slot);
-    // Then try parent's storage cache (if it exists / written to earlier in this TX)
-    if (!value && this.parentCache) {
-      value = this.parentCache?.read(storageAddress, slot);
-    }
+    // Check this cache and parent's (recursively)
+    let value = this.readHereOrParent(storageAddress, slot);
     // Finally try the host's Aztec state (a trip to the database)
     if (!value) {
       value = await this.hostPublicStorage.storageRead(storageAddress, slot);
@@ -73,8 +87,8 @@ export class PublicStorage {
    * @param slot - the slot in the contract's storage being written to
    * @param value - the value being written to the slot
    */
-  public write(storageAddress: Fr, key: Fr, value: Fr) {
-    this.cache.write(storageAddress, key, value);
+  public write(storageAddress: Fr, slot: Fr, value: Fr) {
+    this.cache.write(storageAddress, slot, value);
   }
 
   /**

package/src/avm/journal/trace.ts

@@ -1,3 +1,4 @@
+import { AvmExecutionHints, AvmHint, Vector } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 
 import {
@@ -131,6 +132,7 @@ export class WorldStateAccessTrace {
       leafIndex: msgLeafIndex,
       msgHash: msgHash,
       exists: exists,
+      counter: new Fr(this.accessCounter),
       //endLifetime: Fr.ZERO, // FIXME
     };
     this.l1ToL2MessageChecks.push(traced);
@@ -169,4 +171,14 @@ export class WorldStateAccessTrace {
     // it is assumed that the incoming trace was initialized with this as parent, so accept counter
     this.accessCounter = incomingTrace.accessCounter;
   }
+
+  // TODO(dbanks12): should only return hints for one call.... shouldn't include nested calls (merged in traces)
+  public toHints(): AvmExecutionHints {
+    return new AvmExecutionHints(
+      new Vector(this.publicStorageReads.map(read => new AvmHint(read.counter, read.value))),
+      new Vector(this.noteHashChecks.map(check => new AvmHint(check.counter, new Fr(check.exists ? 1 : 0)))),
+      new Vector(this.nullifierChecks.map(check => new AvmHint(check.counter, new Fr(check.exists ? 1 : 0)))),
+      new Vector(this.l1ToL2MessageChecks.map(check => new AvmHint(check.counter, new Fr(check.exists ? 1 : 0)))),
+    );
+  }
 }

package/src/avm/journal/trace_types.ts

@@ -71,6 +71,7 @@ export type TracedL1toL2MessageCheck = {
   leafIndex: Fr;
   msgHash: Fr;
   exists: boolean;
+  counter: Fr;
   //endLifetime: Fr;
 };
 

package/src/avm/opcodes/accrued_substate.ts

@@ -1,11 +1,10 @@
 import type { AvmContext } from '../avm_context.js';
 import { Uint8 } from '../avm_memory_types.js';
-import { InstructionExecutionError } from '../errors.js';
+import { InstructionExecutionError, StaticCallAlterationError } from '../errors.js';
 import { NullifierCollisionError } from '../journal/nullifiers.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
-import { StaticCallStorageAlterError } from './storage.js';
 
 export class NoteHashExists extends Instruction {
   static type: string = 'NOTEHASHEXISTS';
@@ -65,7 +64,7 @@ export class EmitNoteHash extends Instruction {
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
     if (context.environment.isStaticCall) {
-      throw new StaticCallStorageAlterError();
+      throw new StaticCallAlterationError();
     }
 
     const noteHash = memory.get(this.noteHashOffset).toFr();
@@ -125,7 +124,7 @@ export class EmitNullifier extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
-      throw new StaticCallStorageAlterError();
+      throw new StaticCallAlterationError();
     }
 
     const memoryOperations = { reads: 1, indirect: this.indirect };
@@ -210,7 +209,7 @@ export class EmitUnencryptedLog extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
-      throw new StaticCallStorageAlterError();
+      throw new StaticCallAlterationError();
     }
 
     const memoryOperations = { reads: 1 + this.logSize, indirect: this.indirect };
@@ -244,7 +243,7 @@ export class SendL2ToL1Message extends Instruction {
 
   public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
-      throw new StaticCallStorageAlterError();
+      throw new StaticCallAlterationError();
     }
 
     const memoryOperations = { reads: 2, indirect: this.indirect };

package/src/avm/opcodes/arithmetic.ts

@@ -1,6 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import { getBaseGasCost, getGasCostForTypeTag, getMemoryGasCost, sumGas } from '../avm_gas.js';
-import { type Field, type MemoryOperations, type MemoryValue, TypeTag } from '../avm_memory_types.js';
+import { type Field, type MemoryValue, TypeTag } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Instruction } from './instruction.js';
 import { ThreeOperandInstruction } from './instruction_impl.js';
@@ -23,12 +22,6 @@ export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInst
     context.machineState.incrementPc();
   }
 
-  protected override gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }>) {
-    const baseGasCost = getGasCostForTypeTag(this.inTag, getBaseGasCost(this.opcode));
-    const memoryGasCost = getMemoryGasCost(memoryOps);
-    return sumGas(baseGasCost, memoryGasCost);
-  }
-
   protected abstract compute(a: MemoryValue, b: MemoryValue): MemoryValue;
 }
 
@@ -101,10 +94,4 @@ export class FieldDiv extends Instruction {
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
-
-  protected override gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }>) {
-    const baseGasCost = getGasCostForTypeTag(TypeTag.FIELD, getBaseGasCost(this.opcode));
-    const memoryGasCost = getMemoryGasCost(memoryOps);
-    return sumGas(baseGasCost, memoryGasCost);
-  }
 }

package/src/avm/opcodes/conversion.ts

@@ -50,7 +50,7 @@ export class ToRadixLE extends Instruction {
       value /= radixBN;
     }
 
-    const res = [...limbArray].map(byte => new Uint8(byte));
+    const res = limbArray.map(byte => new Uint8(byte));
     memory.setSlice(dstOffset, res);
 
     memory.assert(memoryOperations);

package/src/avm/opcodes/external_calls.ts

@@ -3,7 +3,7 @@ import { padArrayEnd } from '@aztec/foundation/collection';
 
 import { convertAvmResultsToPxResult, createPublicExecution } from '../../public/transitional_adaptors.js';
 import type { AvmContext } from '../avm_context.js';
-import { gasLeftToGas, sumGas } from '../avm_gas.js';
+import { gasLeftToGas } from '../avm_gas.js';
 import { Field, Uint8 } from '../avm_memory_types.js';
 import { type AvmContractCallResults } from '../avm_message_call_result.js';
 import { AvmSimulator } from '../avm_simulator.js';
@@ -40,7 +40,7 @@ abstract class ExternalCall extends Instruction {
     // 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)
-    private temporaryFunctionSelectorOffset: number,
+    private functionSelectorOffset: number,
   ) {
     super();
   }
@@ -57,33 +57,44 @@ abstract class ExternalCall extends Instruction {
     const callAddress = memory.getAs<Field>(addrOffset);
     const calldataSize = memory.get(argsSizeOffset).toNumber();
     const calldata = memory.getSlice(argsOffset, calldataSize).map(f => f.toFr());
-    const l2Gas = memory.get(gasOffset).toNumber();
-    const daGas = memory.getAs<Field>(gasOffset + 1).toNumber();
-    const functionSelector = memory.getAs<Field>(this.temporaryFunctionSelectorOffset).toFr();
+    const functionSelector = memory.getAs<Field>(this.functionSelectorOffset).toFr();
+    // If we are already in a static call, we propagate the environment.
+    const callType = context.environment.isStaticCall ? 'STATICCALL' : this.type;
 
-    const allocatedGas = { l2Gas, daGas };
+    // First we consume the gas for this operation.
     const memoryOperations = { reads: calldataSize + 5, writes: 1 + this.retSize, indirect: this.indirect };
-    const totalGas = sumGas(this.gasCost(memoryOperations), allocatedGas);
-    context.machineState.consumeGas(totalGas);
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    // Then we consume the gas allocated for the nested call. The excess will be refunded later.
+    // Gas allocation is capped by the amount of gas left in the current context.
+    // We have to do some dancing here because the gas allocation is a field,
+    // but in the machine state we track gas as a number.
+    const allocatedL2Gas = Number(BigIntMin(memory.get(gasOffset).toBigInt(), BigInt(context.machineState.l2GasLeft)));
+    const allocatedDaGas = Number(
+      BigIntMin(memory.get(gasOffset + 1).toBigInt(), BigInt(context.machineState.daGasLeft)),
+    );
+    const allocatedGas = { l2Gas: allocatedL2Gas, daGas: allocatedDaGas };
+    context.machineState.consumeGas(allocatedGas);
 
     // TRANSITIONAL: This should be removed once the kernel handles and entire enqueued call per circuit
     const nestedContext = context.createNestedContractCallContext(
       callAddress.toFr(),
       calldata,
       allocatedGas,
-      this.type,
+      callType,
       FunctionSelector.fromField(functionSelector),
     );
     const startSideEffectCounter = nestedContext.persistableState.trace.accessCounter;
 
     const oldStyleExecution = createPublicExecution(startSideEffectCounter, nestedContext.environment, calldata);
-    const nestedCallResults: AvmContractCallResults = await new AvmSimulator(nestedContext).execute();
+    const simulator = new AvmSimulator(nestedContext);
+    const nestedCallResults: AvmContractCallResults = await simulator.execute();
     const pxResults = convertAvmResultsToPxResult(
       nestedCallResults,
       startSideEffectCounter,
       oldStyleExecution,
       Gas.from(allocatedGas),
       nestedContext,
+      simulator.getBytecode(),
     );
     // store the old PublicExecutionResult object to maintain a recursive data structure for the old kernel
     context.persistableState.transitionalExecutionResult.nestedExecutions.push(pxResults);
@@ -215,3 +226,8 @@ export class Revert extends Instruction {
     memory.assert(memoryOperations);
   }
 }
+
+/** Returns the smaller of two bigints. */
+function BigIntMin(a: bigint, b: bigint): bigint {
+  return a < b ? a : b;
+}

package/src/avm/opcodes/instruction.ts

@@ -1,7 +1,7 @@
 import { strict as assert } from 'assert';
 
 import type { AvmContext } from '../avm_context.js';
-import { getBaseGasCost, getMemoryGasCost, sumGas } from '../avm_gas.js';
+import { getBaseGasCost, sumGas } from '../avm_gas.js';
 import { type MemoryOperations } from '../avm_memory_types.js';
 import { type BufferCursor } from '../serialization/buffer_cursor.js';
 import { Opcode, type OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
@@ -67,9 +67,11 @@ export abstract class Instruction {
    * @param memoryOps Memory operations performed by the instruction.
    * @returns Gas cost.
    */
-  protected gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }> = {}) {
+  protected gasCost(_memoryOps: Partial<MemoryOperations & { indirect: number }> = {}) {
     const baseGasCost = getBaseGasCost(this.opcode);
-    const memoryGasCost = getMemoryGasCost(memoryOps);
+    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/6861): reconsider.
+    // const memoryGasCost = getMemoryGasCost(memoryOps);
+    const memoryGasCost = { l2Gas: 0, daGas: 0 };
     return sumGas(baseGasCost, memoryGasCost);
   }
 

package/src/avm/opcodes/memory.ts

@@ -1,6 +1,5 @@
 import type { AvmContext } from '../avm_context.js';
-import { getBaseGasCost, getMemoryGasCost, sumGas } from '../avm_gas.js';
-import { Field, type MemoryOperations, TaggedMemory, TypeTag } from '../avm_memory_types.js';
+import { Field, TaggedMemory, TypeTag } from '../avm_memory_types.js';
 import { InstructionExecutionError } from '../errors.js';
 import { BufferCursor } from '../serialization/buffer_cursor.js';
 import { Opcode, OperandType, deserialize, serialize } from '../serialization/instruction_serialization.js';
@@ -216,10 +215,4 @@ export class CalldataCopy extends Instruction {
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
   }
-
-  protected override gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }> = {}) {
-    const baseGasCost = getBaseGasCost(this.opcode);
-    const memoryGasCost = getMemoryGasCost(memoryOps);
-    return sumGas(baseGasCost, memoryGasCost);
-  }
 }

package/src/avm/opcodes/storage.ts

@@ -1,9 +1,8 @@
 import { Fr } from '@aztec/foundation/fields';
 
 import type { AvmContext } from '../avm_context.js';
-import { type Gas, getBaseGasCost, getMemoryGasCost, mulGas, sumGas } from '../avm_gas.js';
-import { Field, type MemoryOperations } from '../avm_memory_types.js';
-import { InstructionExecutionError } from '../errors.js';
+import { Field } from '../avm_memory_types.js';
+import { StaticCallAlterationError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -26,12 +25,6 @@ abstract class BaseStorageInstruction extends Instruction {
   ) {
     super();
   }
-
-  protected override gasCost(memoryOps: Partial<MemoryOperations & { indirect: number }>): Gas {
-    const baseGasCost = mulGas(getBaseGasCost(this.opcode), this.size);
-    const memoryGasCost = getMemoryGasCost(memoryOps);
-    return sumGas(baseGasCost, memoryGasCost);
-  }
 }
 
 export class SStore extends BaseStorageInstruction {
@@ -44,7 +37,7 @@ export class SStore extends BaseStorageInstruction {
 
   public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
-      throw new StaticCallStorageAlterError();
+      throw new StaticCallAlterationError();
     }
 
     const memoryOperations = { reads: this.size + 1, indirect: this.indirect };
@@ -100,13 +93,3 @@ export class SLoad extends BaseStorageInstruction {
     memory.assert(memoryOperations);
   }
 }
-
-/**
- * Error is thrown when a static call attempts to alter storage
- */
-export class StaticCallStorageAlterError extends InstructionExecutionError {
-  constructor() {
-    super('Static calls cannot alter storage');
-    this.name = 'StaticCallStorageAlterError';
-  }
-}

package/src/avm/serialization/bytecode_serialization.ts

@@ -136,7 +136,7 @@ const INSTRUCTION_SET = () =>
     // Misc
     [DebugLog.opcode, DebugLog],
 
-    // //// Gadgets
+    // Gadgets
     [Keccak.opcode, Keccak],
     [Poseidon2.opcode, Poseidon2],
     [Sha256.opcode, Sha256],