@aztec/simulator 0.85.0 → 0.86.0

package/src/public/avm/fixtures/initializers.ts

@@ -0,0 +1,101 @@
+import { MAX_L2_GAS_PER_TX_PUBLIC_PORTION } from '@aztec/constants';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasFees } from '@aztec/stdlib/gas';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+
+import { mock } from 'jest-mock-extended';
+
+import type { PublicContractsDB, PublicTreesDB } from '../../public_db_sources.js';
+import type { PublicSideEffectTraceInterface } from '../../side_effect_trace_interface.js';
+import { NullifierManager } from '../../state_manager/nullifiers.js';
+import { PublicStorage } from '../../state_manager/public_storage.js';
+import { PublicPersistableStateManager } from '../../state_manager/state_manager.js';
+import { AvmContext } from '../avm_context.js';
+import { AvmExecutionEnvironment } from '../avm_execution_environment.js';
+import { AvmMachineState } from '../avm_machine_state.js';
+import { AvmSimulator } from '../avm_simulator.js';
+import { DEFAULT_BLOCK_NUMBER } from './utils.js';
+
+/**
+ * Create a new AVM context with default values.
+ */
+export function initContext(overrides?: {
+  persistableState?: PublicPersistableStateManager;
+  env?: AvmExecutionEnvironment;
+  machineState?: AvmMachineState;
+}): AvmContext {
+  const ctx = new AvmContext(
+    overrides?.persistableState || initPersistableStateManager(),
+    overrides?.env || initExecutionEnvironment(),
+    overrides?.machineState || initMachineState(),
+  );
+  ctx.provideSimulator = AvmSimulator.build;
+  return ctx;
+}
+
+/** Creates an empty state manager with mocked host storage. */
+export function initPersistableStateManager(overrides?: {
+  treesDB?: PublicTreesDB;
+  contractsDB?: PublicContractsDB;
+  trace?: PublicSideEffectTraceInterface;
+  publicStorage?: PublicStorage;
+  nullifiers?: NullifierManager;
+  doMerkleOperations?: boolean;
+  firstNullifier?: Fr;
+  blockNumber?: number;
+}): PublicPersistableStateManager {
+  const treesDB = overrides?.treesDB || mock<PublicTreesDB>();
+  return new PublicPersistableStateManager(
+    treesDB,
+    overrides?.contractsDB || mock<PublicContractsDB>(),
+    overrides?.trace || mock<PublicSideEffectTraceInterface>(),
+    overrides?.firstNullifier || new Fr(27),
+    overrides?.blockNumber || DEFAULT_BLOCK_NUMBER,
+    overrides?.doMerkleOperations || false,
+    overrides?.publicStorage,
+    overrides?.nullifiers,
+  );
+}
+
+/**
+ * Create an empty instance of the Execution Environment where all values are zero, unless overridden in the overrides object
+ */
+export function initExecutionEnvironment(overrides?: Partial<AvmExecutionEnvironment>): AvmExecutionEnvironment {
+  return new AvmExecutionEnvironment(
+    overrides?.address ?? AztecAddress.zero(),
+    overrides?.sender ?? AztecAddress.zero(),
+    overrides?.contractCallDepth ?? Fr.zero(),
+    overrides?.transactionFee ?? Fr.zero(),
+    overrides?.globals ?? GlobalVariables.empty(),
+    overrides?.isStaticCall ?? false,
+    overrides?.calldata ?? [],
+  );
+}
+
+/**
+ * Create an empty instance of the Execution Environment where all values are zero, unless overridden in the overrides object
+ */
+export function initGlobalVariables(overrides?: Partial<GlobalVariables>): GlobalVariables {
+  return new GlobalVariables(
+    overrides?.chainId ?? Fr.zero(),
+    overrides?.version ?? Fr.zero(),
+    overrides?.blockNumber ?? Fr.zero(),
+    overrides?.slotNumber ?? Fr.zero(),
+    overrides?.timestamp ?? Fr.zero(),
+    overrides?.coinbase ?? EthAddress.ZERO,
+    overrides?.feeRecipient ?? AztecAddress.zero(),
+    overrides?.gasFees ?? GasFees.empty(),
+  );
+}
+
+/**
+ * Create an empty instance of the Machine State where all values are set to a large enough amount, unless overridden in the overrides object
+ */
+export function initMachineState(overrides?: Partial<AvmMachineState>): AvmMachineState {
+  return AvmMachineState.fromState({
+    l2GasLeft: overrides?.l2GasLeft ?? MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
+    daGasLeft: overrides?.daGasLeft ?? 1e8,
+  });
+}

package/src/public/avm/fixtures/utils.ts

@@ -0,0 +1,213 @@
+import { DEPLOYER_CONTRACT_ADDRESS } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { AvmGadgetsTestContract } from '@aztec/noir-contracts.js/AvmGadgetsTest';
+import { AvmTestContract } from '@aztec/noir-contracts.js/AvmTest';
+import {
+  type ContractArtifact,
+  type FunctionAbi,
+  type FunctionArtifact,
+  FunctionSelector,
+  getAllFunctionAbis,
+} from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import {
+  type ContractClassPublic,
+  type ContractInstanceWithAddress,
+  computeInitializationHash,
+} from '@aztec/stdlib/contract';
+import { isNoirCallStackUnresolved } from '@aztec/stdlib/errors';
+import { siloNullifier } from '@aztec/stdlib/hash';
+import { deriveKeys } from '@aztec/stdlib/keys';
+import { makeContractClassPublic, makeContractInstanceFromClassId } from '@aztec/stdlib/testing';
+
+import { strict as assert } from 'assert';
+import merge from 'lodash.merge';
+
+import { resolveAssertionMessageFromRevertData, traverseCauseChain } from '../../../common/index.js';
+import { Field, Uint8, Uint32, Uint64 } from '../avm_memory_types.js';
+import type { AvmRevertReason } from '../errors.js';
+
+export const PUBLIC_DISPATCH_FN_NAME = 'public_dispatch';
+export const DEFAULT_BLOCK_NUMBER = 42;
+
+/**
+ * Create a new object with all the same properties as the original, except for the ones in the overrides object.
+ */
+export function allSameExcept(original: any, overrides: any): any {
+  return merge({}, original, overrides);
+}
+
+export function randomMemoryBytes(length: number): Uint8[] {
+  return [...Array(length)].map(_ => new Uint8(Math.floor(Math.random() * 255)));
+}
+
+export function randomMemoryUint32s(length: number): Uint32[] {
+  return [...Array(length)].map(_ => new Uint32(Math.floor(Math.random() * 255)));
+}
+
+export function randomMemoryUint64s(length: number): Uint64[] {
+  return [...Array(length)].map(_ => new Uint64(Math.floor(Math.random() * 255)));
+}
+
+export function randomMemoryFields(length: number): Field[] {
+  return [...Array(length)].map(_ => new Field(Fr.random()));
+}
+
+export function getFunctionSelector(
+  functionName: string,
+  contractArtifact: ContractArtifact,
+): Promise<FunctionSelector> {
+  const fnArtifact = getAllFunctionAbis(contractArtifact).find(f => f.name === functionName)!;
+  assert(!!fnArtifact, `Function ${functionName} not found in ${contractArtifact.name}`);
+  const params = fnArtifact.parameters;
+  return FunctionSelector.fromNameAndParameters(fnArtifact.name, params);
+}
+
+export function getContractFunctionArtifact(
+  functionName: string,
+  contractArtifact: ContractArtifact,
+): FunctionArtifact | undefined {
+  return contractArtifact.functions.find(f => f.name === functionName);
+}
+
+export function getContractFunctionAbi(
+  functionName: string,
+  contractArtifact: ContractArtifact,
+): FunctionAbi | undefined {
+  return (
+    contractArtifact.functions.find(f => f.name === functionName) ??
+    contractArtifact.nonDispatchPublicFunctions.find(f => f.name === functionName)
+  );
+}
+
+export function resolveContractAssertionMessage(
+  functionName: string,
+  revertReason: AvmRevertReason,
+  output: Fr[],
+  contractArtifact: ContractArtifact,
+): string | undefined {
+  traverseCauseChain(revertReason, cause => {
+    revertReason = cause as AvmRevertReason;
+  });
+
+  const functionArtifact = getAllFunctionAbis(contractArtifact).find(f => f.name === functionName);
+  if (!functionArtifact || !revertReason.noirCallStack || !isNoirCallStackUnresolved(revertReason.noirCallStack)) {
+    return undefined;
+  }
+
+  return resolveAssertionMessageFromRevertData(output, functionArtifact);
+}
+
+export function getAvmTestContractFunctionSelector(functionName: string): Promise<FunctionSelector> {
+  return getFunctionSelector(functionName, AvmTestContract.artifactForPublic);
+}
+
+export function getAvmGadgetsTestContractFunctionSelector(functionName: string): Promise<FunctionSelector> {
+  const artifact = getAllFunctionAbis(AvmGadgetsTestContract.artifactForPublic).find(f => f.name === functionName)!;
+  assert(!!artifact, `Function ${functionName} not found in AvmGadgetsTestContractArtifact`);
+  const params = artifact.parameters;
+  return FunctionSelector.fromNameAndParameters(artifact.name, params);
+}
+
+export function getAvmTestContractArtifact(functionName: string): FunctionArtifact {
+  const artifact = getContractFunctionArtifact(functionName, AvmTestContract.artifactForPublic) as FunctionArtifact;
+  assert(
+    !!artifact?.bytecode,
+    `No bytecode found for function ${functionName}. Try re-running bootstrap.sh on the repository root.`,
+  );
+  return artifact;
+}
+
+export function getAvmGadgetsTestContractArtifact(functionName: string): FunctionArtifact {
+  const artifact = AvmGadgetsTestContract.artifactForPublic.functions.find(f => f.name === functionName)!;
+  assert(
+    !!artifact?.bytecode,
+    `No bytecode found for function ${functionName}. Try re-running bootstrap.sh on the repository root.`,
+  );
+  return artifact;
+}
+
+export function getAvmTestContractBytecode(functionName: string): Buffer {
+  const artifact = getAvmTestContractArtifact(functionName);
+  return artifact.bytecode;
+}
+
+export function getAvmGadgetsTestContractBytecode(functionName: string): Buffer {
+  const artifact = getAvmGadgetsTestContractArtifact(functionName);
+  return artifact.bytecode;
+}
+
+export function resolveAvmTestContractAssertionMessage(
+  functionName: string,
+  revertReason: AvmRevertReason,
+  output: Fr[],
+): string | undefined {
+  return resolveContractAssertionMessage(functionName, revertReason, output, AvmTestContract.artifactForPublic);
+}
+
+export function resolveAvmGadgetsTestContractAssertionMessage(
+  functionName: string,
+  revertReason: AvmRevertReason,
+  output: Fr[],
+): string | undefined {
+  traverseCauseChain(revertReason, cause => {
+    revertReason = cause as AvmRevertReason;
+  });
+
+  const functionArtifact = AvmGadgetsTestContract.artifactForPublic.functions.find(f => f.name === functionName);
+  if (!functionArtifact || !revertReason.noirCallStack || !isNoirCallStackUnresolved(revertReason.noirCallStack)) {
+    return undefined;
+  }
+
+  return resolveAssertionMessageFromRevertData(output, functionArtifact);
+}
+
+/**
+ * Create a contract class and instance given constructor args, artifact, etc.
+ * NOTE: This is useful for testing real-ish contract class registration and instance deployment TXs (via logs)
+ * @param constructorArgs - The constructor arguments for the contract.
+ * @param deployer - The deployer of the contract.
+ * @param contractArtifact - The contract artifact for the contract.
+ * @param seed - The seed for the contract.
+ * @param originalContractClassId - The original contract class ID (if upgraded)
+ * @returns The contract class, instance, and contract address nullifier.
+ */
+export async function createContractClassAndInstance(
+  constructorArgs: any[],
+  deployer: AztecAddress,
+  contractArtifact: ContractArtifact,
+  seed = 0,
+  originalContractClassId?: Fr, // if previously upgraded
+): Promise<{
+  contractClass: ContractClassPublic;
+  contractInstance: ContractInstanceWithAddress;
+  contractAddressNullifier: Fr;
+}> {
+  const bytecode = (getContractFunctionArtifact(PUBLIC_DISPATCH_FN_NAME, contractArtifact) as FunctionArtifact)!
+    .bytecode;
+  const contractClass = await makeContractClassPublic(seed, bytecode);
+
+  const constructorAbi = getContractFunctionAbi('constructor', contractArtifact);
+  const { publicKeys } = await deriveKeys(Fr.random());
+  const initializationHash = await computeInitializationHash(constructorAbi, constructorArgs);
+  const contractInstance =
+    originalContractClassId === undefined
+      ? await makeContractInstanceFromClassId(contractClass.id, seed, {
+          deployer,
+          initializationHash,
+          publicKeys,
+        })
+      : await makeContractInstanceFromClassId(originalContractClassId, seed, {
+          deployer,
+          initializationHash,
+          currentClassId: contractClass.id,
+          publicKeys,
+        });
+
+  const contractAddressNullifier = await siloNullifier(
+    AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
+    contractInstance.address.toField(),
+  );
+
+  return { contractClass, contractInstance, contractAddressNullifier };
+}

package/src/public/avm/index.ts

@@ -1,2 +1 @@
 export * from './avm_simulator.js';
-export * from './fixtures/simple_contract_data_source.js';

package/src/public/avm/opcodes/accrued_substate.ts

@@ -181,11 +181,7 @@ export class L1ToL2MessageExists extends Instruction {
 
     const msgHash = memory.get(msgHashOffset).toFr();
     const msgLeafIndex = memory.get(msgLeafIndexOffset).toFr();
-    const exists = await context.persistableState.checkL1ToL2MessageExists(
-      context.environment.address,
-      msgHash,
-      msgLeafIndex,
-    );
+    const exists = await context.persistableState.checkL1ToL2MessageExists(msgHash, msgLeafIndex);
     memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
   }
 }

package/src/public/avm/opcodes/external_calls.ts

@@ -9,16 +9,18 @@ abstract class ExternalCall extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
-    OperandType.UINT8, // Indirect
-    OperandType.UINT16,
-    OperandType.UINT16,
-    OperandType.UINT16,
-    OperandType.UINT16,
+    OperandType.UINT16, // Indirect
+    OperandType.UINT16, // L2 gas offset
+    OperandType.UINT16, // DA gas offset
+    OperandType.UINT16, // Address offset
+    OperandType.UINT16, // Args offset
+    OperandType.UINT16, // Args size offset
   ];
 
   constructor(
     private indirect: number,
-    private gasOffset: number,
+    private l2GasOffset: number,
+    private daGasOffset: number,
     private addrOffset: number,
     private argsOffset: number,
     private argsSizeOffset: number,
@@ -28,10 +30,12 @@ abstract class ExternalCall extends Instruction {
 
   public async execute(context: AvmContext) {
     const memory = context.machineState.memory;
-    const operands = [this.gasOffset, this.addrOffset, this.argsOffset, this.argsSizeOffset];
+    const operands = [this.l2GasOffset, this.daGasOffset, this.addrOffset, this.argsOffset, this.argsSizeOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [gasOffset, addrOffset, argsOffset, argsSizeOffset] = addressing.resolve(operands, memory);
-    memory.checkTags(TypeTag.FIELD, gasOffset, gasOffset + 1);
+    const [l2GasOffset, daGasOffset, addrOffset, argsOffset, argsSizeOffset] = addressing.resolve(operands, memory);
+    // TODO: Should be U32
+    memory.checkTags(TypeTag.FIELD, l2GasOffset);
+    memory.checkTags(TypeTag.FIELD, daGasOffset);
     memory.checkTag(TypeTag.FIELD, addrOffset);
     memory.checkTag(TypeTag.UINT32, argsSizeOffset);
 
@@ -49,9 +53,11 @@ abstract class ExternalCall extends Instruction {
     // 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 allocatedL2Gas = Number(
+      BigIntMin(memory.get(l2GasOffset).toBigInt(), BigInt(context.machineState.l2GasLeft)),
+    );
     const allocatedDaGas = Number(
-      BigIntMin(memory.get(gasOffset + 1).toBigInt(), BigInt(context.machineState.daGasLeft)),
+      BigIntMin(memory.get(daGasOffset).toBigInt(), BigInt(context.machineState.daGasLeft)),
     );
     const allocatedGas = { l2Gas: allocatedL2Gas, daGas: allocatedDaGas };
     context.machineState.consumeGas(allocatedGas);

package/src/public/avm/opcodes/instruction.ts

@@ -1,9 +1,10 @@
+import type { Bufferable } from '@aztec/foundation/serialize';
+
 import { strict as assert } from 'assert';
 
 import type { AvmContext } from '../avm_context.js';
 import { type Gas, getBaseGasCost, getDynamicGasCost, mulGas, sumGas } from '../avm_gas.js';
 import type { BufferCursor } from '../serialization/buffer_cursor.js';
-import type { Serializable } from '../serialization/bytecode_serialization.js';
 import { Opcode, type OperandType, deserialize, serializeAs } from '../serialization/instruction_serialization.js';
 
 type InstructionConstructor = {
@@ -44,19 +45,19 @@ export abstract class Instruction {
   }
 
   // Default deserialization which uses Class.opcode and Class.wireFormat.
-  public static deserialize(
+  public static fromBuffer(
     this: InstructionConstructor & { wireFormat: OperandType[]; as: any },
     buf: BufferCursor | Buffer,
   ): Instruction {
-    return this.as(this.wireFormat).deserialize(buf);
+    return this.as(this.wireFormat).fromBuffer(buf);
   }
 
   // Default serialization which uses Class.opcode and Class.wireFormat.
-  public serialize(): Buffer {
+  public toBuffer(): Buffer {
     const klass = this.constructor as any;
     assert(klass.opcode !== undefined && klass.opcode !== null);
     assert(klass.wireFormat !== undefined && klass.wireFormat !== null);
-    return this.as(klass.opcode, klass.wireFormat).serialize();
+    return this.as(klass.opcode, klass.wireFormat).toBuffer();
   }
 
   /**
@@ -65,8 +66,8 @@ export abstract class Instruction {
    * @param wireFormat The wire format of the instruction.
    * @returns The new instruction instance.
    */
-  public as(opcode: Opcode, wireFormat: OperandType[]): Instruction & Serializable {
-    return Object.defineProperty(this, 'serialize', {
+  public as(opcode: Opcode, wireFormat: OperandType[]): Instruction & Bufferable {
+    return Object.defineProperty(this, 'toBuffer', {
       value: (): Buffer => {
         return serializeAs(wireFormat, opcode, this);
       },
@@ -82,7 +83,7 @@ export abstract class Instruction {
    */
   public static as(this: InstructionConstructor, wireFormat: OperandType[]) {
     return Object.assign(this, {
-      deserialize: (buf: BufferCursor | Buffer): Instruction => {
+      fromBuffer: (buf: BufferCursor | Buffer): Instruction => {
         const res = deserialize(buf, wireFormat);
         const args = res.slice(1); // Remove opcode.
         return new this(...args);

package/src/public/avm/revert_reason.ts

@@ -0,0 +1,55 @@
+import type { Fr } from '@aztec/foundation/fields';
+
+import type { AvmContext } from './avm_context.js';
+import { type AvmExecutionError, AvmRevertReason } from './errors.js';
+
+async function createRevertReason(message: string, revertData: Fr[], context: AvmContext): Promise<AvmRevertReason> {
+  // We drop the returnPc information.
+  const internalCallStack = context.machineState.internalCallStack.map(entry => entry.callPc);
+
+  // If we are reverting due to the same error that we have been tracking, we use the nested error as the cause.
+  let nestedError = undefined;
+  const revertDataEquals = (a: Fr[], b: Fr[]) => a.length === b.length && a.every((v, i) => v.equals(b[i]));
+  if (
+    context.machineState.collectedRevertInfo &&
+    revertDataEquals(context.machineState.collectedRevertInfo.revertDataRepresentative, revertData)
+  ) {
+    nestedError = context.machineState.collectedRevertInfo.recursiveRevertReason;
+    message = context.machineState.collectedRevertInfo.recursiveRevertReason.message;
+  }
+
+  const fnName = await context.persistableState.getPublicFunctionDebugName(context.environment);
+
+  return new AvmRevertReason(
+    message,
+    /*failingFunction=*/ {
+      contractAddress: context.environment.address,
+      functionName: fnName,
+    },
+    /*noirCallStack=*/ [...internalCallStack, context.machineState.pc].map(pc => `0.${pc}`),
+    /*options=*/ { cause: nestedError },
+  );
+}
+
+/**
+ * Create a "revert reason" error for an exceptional halt.
+ *
+ * @param haltingError - the lower-level error causing the exceptional halt
+ * @param context - the context of the AVM execution used to extract the failingFunction and noirCallStack
+ */
+export async function revertReasonFromExceptionalHalt(
+  haltingError: AvmExecutionError,
+  context: AvmContext,
+): Promise<AvmRevertReason> {
+  return await createRevertReason(haltingError.message, [], context);
+}
+
+/**
+ * Create a "revert reason" error for an explicit revert (a root cause).
+ *
+ * @param revertData - output data of the explicit REVERT instruction
+ * @param context - the context of the AVM execution used to extract the failingFunction and noirCallStack
+ */
+export async function revertReasonFromExplicitRevert(revertData: Fr[], context: AvmContext): Promise<AvmRevertReason> {
+  return await createRevertReason('Assertion failed: ', revertData, context);
+}