@aztec/simulator 0.61.0 → 0.63.0

package/src/avm/errors.ts

@@ -21,6 +21,13 @@ export class NoBytecodeForContractError extends AvmExecutionError {
   }
 }
 
+export class ArithmeticError extends AvmExecutionError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ArithmeticError';
+  }
+}
+
 /**
  * Error is thrown when the program counter goes to an invalid location.
  * There is no instruction at the provided pc
@@ -78,18 +85,6 @@ export class StaticCallAlterationError extends InstructionExecutionError {
   }
 }
 
-/**
- * Error thrown to propagate a nested call's revert.
- * @param message - the error's message
- * @param nestedError - the revert reason of the nested call
- */
-export class RethrownError extends AvmExecutionError {
-  constructor(message: string, public nestedError: AvmRevertReason) {
-    super(message);
-    this.name = 'RethrownError';
-  }
-}
-
 /**
  * Meaningfully named alias for ExecutionError when used in the context of the AVM.
  * Maintains a recursive structure reflecting the AVM's external callstack/errorstack, where
@@ -101,22 +96,28 @@ export class AvmRevertReason extends ExecutionError {
   }
 }
 
-/**
- * Helper to create a "revert reason" error optionally with a nested error cause.
- *
- * @param message - the error message
- * @param context - the context of the AVM execution used to extract the failingFunction and noirCallStack
- * @param nestedError - the error that caused this one (if this is not the root-cause itself)
- */
-function createRevertReason(message: string, context: AvmContext, nestedError?: AvmRevertReason): AvmRevertReason {
+function createRevertReason(message: string, revertData: Fr[], context: AvmContext): AvmRevertReason {
   // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Properly fix this.
   // If the function selector is the public dispatch selector, we need to extract the actual function selector from the calldata.
   // We should remove this because the AVM (or public protocol) shouldn't be aware of the public dispatch calling convention.
   let functionSelector = context.environment.functionSelector;
-  const internalCallStack = context.machineState.internalCallStack;
+  // We drop the returnPc information.
+  const internalCallStack = context.machineState.internalCallStack.map(entry => entry.callPc);
   if (functionSelector.toField().equals(new Fr(PUBLIC_DISPATCH_SELECTOR)) && context.environment.calldata.length > 0) {
     functionSelector = FunctionSelector.fromField(context.environment.calldata[0]);
   }
+
+  // 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;
+  }
+
   return new AvmRevertReason(
     message,
     /*failingFunction=*/ {
@@ -129,16 +130,13 @@ function createRevertReason(message: string, context: AvmContext, nestedError?:
 }
 
 /**
- * Create a "revert reason" error for an exceptional halt,
- * creating the recursive structure if the halt was a RethrownError.
+ * 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 function revertReasonFromExceptionalHalt(haltingError: AvmExecutionError, context: AvmContext): AvmRevertReason {
-  // A RethrownError has a nested/child AvmRevertReason
-  const nestedError = haltingError instanceof RethrownError ? haltingError.nestedError : undefined;
-  return createRevertReason(haltingError.message, context, nestedError);
+  return createRevertReason(haltingError.message, [], context);
 }
 
 /**
@@ -148,26 +146,5 @@ export function revertReasonFromExceptionalHalt(haltingError: AvmExecutionError,
  * @param context - the context of the AVM execution used to extract the failingFunction and noirCallStack
  */
 export function revertReasonFromExplicitRevert(revertData: Fr[], context: AvmContext): AvmRevertReason {
-  const revertMessage = decodeRevertDataAsMessage(revertData);
-  return createRevertReason(revertMessage, context);
-}
-
-/**
- * Interpret revert data as a message string.
- *
- * @param revertData - output data of an explicit REVERT instruction
- */
-export function decodeRevertDataAsMessage(revertData: Fr[]): string {
-  if (revertData.length === 0) {
-    return 'Assertion failed';
-  } else {
-    try {
-      // We remove the first element which is the 'error selector'.
-      const revertOutput = revertData.slice(1);
-      // Try to interpret the output as a text string.
-      return 'Assertion failed: ' + String.fromCharCode(...revertOutput.map(fr => fr.toNumber()));
-    } catch (e) {
-      return 'Assertion failed: <cannot interpret as string>';
-    }
-  }
+  return createRevertReason('Assertion failed: ', revertData, context);
 }

package/src/avm/fixtures/index.ts

@@ -1,6 +1,6 @@
-import { isNoirCallStackUnresolved } from '@aztec/circuit-types';
+import { type MerkleTreeWriteOperations, isNoirCallStackUnresolved } from '@aztec/circuit-types';
 import { GasFees, GlobalVariables, MAX_L2_GAS_PER_ENQUEUED_CALL } from '@aztec/circuits.js';
-import { FunctionSelector, getFunctionDebugMetadata } from '@aztec/foundation/abi';
+import { type FunctionArtifact, 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';
@@ -10,7 +10,7 @@ import { strict as assert } from 'assert';
 import { mock } from 'jest-mock-extended';
 import merge from 'lodash.merge';
 
-import { type WorldStateDB, resolveAssertionMessage, traverseCauseChain } from '../../index.js';
+import { type WorldStateDB, resolveAssertionMessageFromRevertData, traverseCauseChain } from '../../index.js';
 import { type PublicSideEffectTraceInterface } from '../../public/side_effect_trace_interface.js';
 import { AvmContext } from '../avm_context.js';
 import { AvmExecutionEnvironment } from '../avm_execution_environment.js';
@@ -42,6 +42,8 @@ export function initPersistableStateManager(overrides?: {
   trace?: PublicSideEffectTraceInterface;
   publicStorage?: PublicStorage;
   nullifiers?: NullifierManager;
+  doMerkleOperations?: boolean;
+  merkleTrees?: MerkleTreeWriteOperations;
 }): AvmPersistableStateManager {
   const worldStateDB = overrides?.worldStateDB || mock<WorldStateDB>();
   return new AvmPersistableStateManager(
@@ -49,6 +51,8 @@ export function initPersistableStateManager(overrides?: {
     overrides?.trace || mock<PublicSideEffectTraceInterface>(),
     overrides?.publicStorage || new PublicStorage(worldStateDB),
     overrides?.nullifiers || new NullifierManager(worldStateDB),
+    overrides?.doMerkleOperations || false,
+    overrides?.merkleTrees || mock<MerkleTreeWriteOperations>(),
   );
 }
 
@@ -124,33 +128,33 @@ export function getAvmTestContractFunctionSelector(functionName: string): Functi
   return FunctionSelector.fromNameAndParameters(artifact.name, params);
 }
 
-export function getAvmTestContractBytecode(functionName: string): Buffer {
+export function getAvmTestContractArtifact(functionName: string): FunctionArtifact {
   const artifact = AvmTestContractArtifact.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 resolveAvmTestContractAssertionMessage(
   functionName: string,
   revertReason: AvmRevertReason,
+  output: Fr[],
 ): string | undefined {
-  const functionArtifact = AvmTestContractArtifact.functions.find(f => f.name === functionName)!;
-
   traverseCauseChain(revertReason, cause => {
     revertReason = cause as AvmRevertReason;
   });
 
+  const functionArtifact = AvmTestContractArtifact.functions.find(f => f.name === functionName);
   if (!functionArtifact || !revertReason.noirCallStack || !isNoirCallStackUnresolved(revertReason.noirCallStack)) {
     return undefined;
   }
 
-  const debugMetadata = getFunctionDebugMetadata(AvmTestContractArtifact, functionArtifact);
-  if (!debugMetadata) {
-    return undefined;
-  }
-
-  return resolveAssertionMessage(revertReason.noirCallStack, debugMetadata);
+  return resolveAssertionMessageFromRevertData(output, functionArtifact);
 }

package/src/avm/index.ts

@@ -1 +1,2 @@
 export * from './avm_simulator.js';
+export * from './journal/index.js';