@aztec/simulator 0.71.0 → 0.73.0

package/src/avm/fixtures/base_avm_simulation_tester.ts

@@ -0,0 +1,104 @@
+import { MerkleTreeId, type MerkleTreeWriteOperations } from '@aztec/circuit-types';
+import {
+  type ContractClassPublic,
+  type ContractInstanceWithAddress,
+  DEPLOYER_CONTRACT_ADDRESS,
+  PUBLIC_DISPATCH_SELECTOR,
+  PublicDataWrite,
+  computeInitializationHash,
+} from '@aztec/circuits.js';
+import { computePublicDataTreeLeafSlot, siloNullifier } from '@aztec/circuits.js/hash';
+import { makeContractClassPublic, makeContractInstanceFromClassId } from '@aztec/circuits.js/testing';
+import { type ContractArtifact, FunctionSelector } from '@aztec/foundation/abi';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { type Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+
+import { computeFeePayerBalanceStorageSlot } from '../../server.js';
+import { PUBLIC_DISPATCH_FN_NAME, getContractFunctionArtifact } from './index.js';
+import { type SimpleContractDataSource } from './simple_contract_data_source.js';
+
+/**
+ * An abstract test class that enables tests of real apps in the AVM without requiring e2e tests.
+ * It enables this by letting us (1) perform pseudo-contract-deployments (and registrations)
+ * that trigger merkle tree operations and (2) maintain a contract data source to store
+ * and retrieve contract classes and instances.
+ *
+ * This class is meant to be extended when writing tests for a specific simulation interface.
+ * For example, has been extended for testing of the core AvmSimulator, and again for the PublicTxSimulator,
+ * both of which benefit from such pseudo-deployments by populating merkle trees and a contract data source
+ * with contract information.
+ */
+export abstract class BaseAvmSimulationTester {
+  public logger = createLogger('avm-simulation-tester');
+
+  constructor(
+    public contractDataSource: SimpleContractDataSource,
+    public merkleTrees: MerkleTreeWriteOperations,
+    /* May want to skip contract deployment tree ops to test failed contract address nullifier checks on CALL */
+    private skipContractDeployments = false,
+  ) {}
+
+  async setFeePayerBalance(feePayer: AztecAddress, balance: Fr) {
+    const feeJuiceAddress = ProtocolContractAddress.FeeJuice;
+    const balanceSlot = await computeFeePayerBalanceStorageSlot(feePayer);
+    await this.setPublicStorage(feeJuiceAddress, balanceSlot, balance);
+  }
+
+  async setPublicStorage(address: AztecAddress, slot: Fr, value: Fr) {
+    const leafSlot = await computePublicDataTreeLeafSlot(address, slot);
+    // get existing preimage
+    const publicDataWrite = new PublicDataWrite(leafSlot, value);
+    await this.merkleTrees.batchInsert(MerkleTreeId.PUBLIC_DATA_TREE, [publicDataWrite.toBuffer()], 0);
+  }
+
+  /**
+   * Derive the contract class and instance with some seed.
+   * Add both to the contract data source along with the contract artifact.
+   */
+  async registerAndDeployContract(
+    constructorArgs: any[],
+    deployer: AztecAddress,
+    contractArtifact: ContractArtifact,
+    seed = 0,
+  ): Promise<ContractInstanceWithAddress> {
+    const bytecode = getContractFunctionArtifact(PUBLIC_DISPATCH_FN_NAME, contractArtifact)!.bytecode;
+    const contractClass = await makeContractClassPublic(
+      seed,
+      /*publicDispatchFunction=*/ { bytecode, selector: new FunctionSelector(PUBLIC_DISPATCH_SELECTOR) },
+    );
+
+    const constructorAbi = getContractFunctionArtifact('constructor', contractArtifact);
+    const initializationHash = await computeInitializationHash(constructorAbi, constructorArgs);
+    const contractInstance = await makeContractInstanceFromClassId(contractClass.id, seed, {
+      deployer,
+      initializationHash,
+    });
+
+    await this.addContractClass(contractClass, contractArtifact);
+    await this.addContractInstance(contractInstance);
+    return contractInstance;
+  }
+
+  getFirstContractInstance(): ContractInstanceWithAddress {
+    return this.contractDataSource.getFirstContractInstance();
+  }
+
+  addContractClass(contractClass: ContractClassPublic, contractArtifact: ContractArtifact): Promise<void> {
+    this.logger.debug(`Adding contract class with Id ${contractClass.id}`);
+    this.contractDataSource.addContractArtifact(contractClass.id, contractArtifact);
+    return this.contractDataSource.addContractClass(contractClass);
+  }
+
+  async addContractInstance(contractInstance: ContractInstanceWithAddress) {
+    if (!this.skipContractDeployments) {
+      const contractAddressNullifier = await siloNullifier(
+        AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
+        contractInstance.address.toField(),
+      );
+      await this.merkleTrees.batchInsert(MerkleTreeId.NULLIFIER_TREE, [contractAddressNullifier.toBuffer()], 0);
+    }
+    await this.contractDataSource.addContractInstance(contractInstance);
+  }
+}

package/src/avm/fixtures/index.ts

@@ -1,6 +1,6 @@
 import { isNoirCallStackUnresolved } from '@aztec/circuit-types';
 import { GasFees, GlobalVariables, MAX_L2_GAS_PER_TX_PUBLIC_PORTION } from '@aztec/circuits.js';
-import { type FunctionArtifact, FunctionSelector } from '@aztec/foundation/abi';
+import { type ContractArtifact, 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';
@@ -23,6 +23,8 @@ import { AvmPersistableStateManager } from '../journal/journal.js';
 import { NullifierManager } from '../journal/nullifiers.js';
 import { PublicStorage } from '../journal/public_storage.js';
 
+export const PUBLIC_DISPATCH_FN_NAME = 'public_dispatch';
+
 /**
  * Create a new AVM context with default values.
  */
@@ -124,15 +126,51 @@ export function randomMemoryFields(length: number): Field[] {
   return [...Array(length)].map(_ => new Field(Fr.random()));
 }
 
-export function getAvmTestContractFunctionSelector(functionName: string): FunctionSelector {
-  const artifact = AvmTestContractArtifact.functions.find(f => f.name === functionName)!;
-  assert(!!artifact, `Function ${functionName} not found in AvmTestContractArtifact`);
-  const params = artifact.parameters;
-  return FunctionSelector.fromNameAndParameters(artifact.name, params);
+export function getFunctionSelector(
+  functionName: string,
+  contractArtifact: ContractArtifact,
+): Promise<FunctionSelector> {
+  const fnArtifact = contractArtifact.functions.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 {
+  const artifact = contractArtifact.functions.find(f => f.name === functionName)!;
+  if (!artifact) {
+    return undefined;
+  }
+  return artifact;
+}
+
+export function resolveContractAssertionMessage(
+  functionName: string,
+  revertReason: AvmRevertReason,
+  output: Fr[],
+  contractArtifact: ContractArtifact,
+): string | undefined {
+  traverseCauseChain(revertReason, cause => {
+    revertReason = cause as AvmRevertReason;
+  });
+
+  const functionArtifact = contractArtifact.functions.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, AvmTestContractArtifact);
 }
 
 export function getAvmTestContractArtifact(functionName: string): FunctionArtifact {
-  const artifact = AvmTestContractArtifact.functions.find(f => f.name === functionName)!;
+  const artifact = getContractFunctionArtifact(functionName, AvmTestContractArtifact);
   assert(
     !!artifact?.bytecode,
     `No bytecode found for function ${functionName}. Try re-running bootstrap.sh on the repository root.`,
@@ -150,14 +188,5 @@ export function resolveAvmTestContractAssertionMessage(
   revertReason: AvmRevertReason,
   output: Fr[],
 ): string | undefined {
-  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;
-  }
-
-  return resolveAssertionMessageFromRevertData(output, functionArtifact);
+  return resolveContractAssertionMessage(functionName, revertReason, output, AvmTestContractArtifact);
 }

package/src/avm/fixtures/simple_contract_data_source.ts

@@ -0,0 +1,98 @@
+import {
+  type ContractClassPublic,
+  type ContractDataSource,
+  type ContractInstanceWithAddress,
+  type FunctionSelector,
+  type PublicFunction,
+  computePublicBytecodeCommitment,
+} from '@aztec/circuits.js';
+import { type ContractArtifact } from '@aztec/foundation/abi';
+import { type AztecAddress } from '@aztec/foundation/aztec-address';
+import { type Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+
+import { PUBLIC_DISPATCH_FN_NAME } from './index.js';
+
+/**
+ * This class is used during public/avm testing to function as a database of
+ * contract contract classes and instances. Tests can populate it with classes
+ * and instances and then probe it via the ContractDataSource interface.
+ *
+ * This class does not include any real merkle trees & merkle operations.
+ */
+export class SimpleContractDataSource implements ContractDataSource {
+  public logger = createLogger('simple-contract-data-source');
+
+  // maps contract class ID to class
+  private contractClasses: Map<string, ContractClassPublic> = new Map();
+  // maps contract instance address to instance
+  private contractInstances: Map<string, ContractInstanceWithAddress> = new Map();
+  // maps contract instance address to address
+  private contractArtifacts: Map<string, ContractArtifact> = new Map();
+
+  /////////////////////////////////////////////////////////////
+  // Helper functions not in the contract data source interface
+  getFirstContractInstance(): ContractInstanceWithAddress {
+    return this.contractInstances.values().next().value;
+  }
+
+  addContractArtifact(classId: Fr, artifact: ContractArtifact): void {
+    this.contractArtifacts.set(classId.toString(), artifact);
+  }
+
+  /////////////////////////////////////////////////////////////
+  // ContractDataSource function impelementations
+  getPublicFunction(_address: AztecAddress, _selector: FunctionSelector): Promise<PublicFunction> {
+    throw new Error('Method not implemented.');
+  }
+
+  getBlockNumber(): Promise<number> {
+    throw new Error('Method not implemented.');
+  }
+
+  getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
+    return Promise.resolve(this.contractClasses.get(id.toString()));
+  }
+
+  async getBytecodeCommitment(id: Fr): Promise<Fr | undefined> {
+    const contractClass = await this.getContractClass(id);
+    return Promise.resolve(computePublicBytecodeCommitment(contractClass!.packedBytecode));
+  }
+
+  getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+    return Promise.resolve(this.contractInstances.get(address.toString()));
+  }
+
+  getContractClassIds(): Promise<Fr[]> {
+    throw new Error('Method not implemented.');
+  }
+
+  async getContractArtifact(address: AztecAddress): Promise<ContractArtifact | undefined> {
+    const contractInstance = await this.getContract(address);
+    if (!contractInstance) {
+      this.logger.warn(`Contract not found at address: ${address}`);
+      return undefined;
+    }
+    this.logger.debug(`Retrieved contract artifact for address: ${address}`);
+    this.logger.debug(`Contract class ID: ${contractInstance.contractClassId}`);
+    return Promise.resolve(this.contractArtifacts.get(contractInstance!.contractClassId.toString()));
+  }
+
+  getContractFunctionName(_address: AztecAddress, _selector: FunctionSelector): Promise<string> {
+    return Promise.resolve(PUBLIC_DISPATCH_FN_NAME);
+  }
+
+  registerContractFunctionSignatures(_address: AztecAddress, _signatures: string[]): Promise<void> {
+    return Promise.resolve();
+  }
+
+  addContractClass(contractClass: ContractClassPublic): Promise<void> {
+    this.contractClasses.set(contractClass.id.toString(), contractClass);
+    return Promise.resolve();
+  }
+
+  addContractInstance(contractInstance: ContractInstanceWithAddress): Promise<void> {
+    this.contractInstances.set(contractInstance.address.toString(), contractInstance);
+    return Promise.resolve();
+  }
+}

package/src/avm/journal/journal.ts

@@ -72,7 +72,7 @@ export class AvmPersistableStateManager {
     trace: PublicSideEffectTraceInterface,
     doMerkleOperations: boolean = false,
     firstNullifier: Fr,
-  ) {
+  ): Promise<AvmPersistableStateManager> {
     const ephemeralForest = await AvmEphemeralForest.create(worldStateDB.getMerkleInterface());
     return new AvmPersistableStateManager(
       worldStateDB,
@@ -126,11 +126,12 @@ export class AvmPersistableStateManager {
     this.trace.merge(forkedState.trace, reverted);
     if (reverted) {
       if (this.doMerkleOperations) {
-        this.log.debug(
+        this.log.trace(
           `Rolled back nullifier tree to root ${this.merkleTrees.treeMap.get(MerkleTreeId.NULLIFIER_TREE)!.getRoot()}`,
         );
       }
     } else {
+      this.log.trace('Merging forked state into parent...');
       this.merkleTrees = forkedState.merkleTrees;
     }
   }
@@ -144,7 +145,7 @@ export class AvmPersistableStateManager {
    */
   public async writeStorage(contractAddress: AztecAddress, slot: Fr, value: Fr, protocolWrite = false): Promise<void> {
     this.log.debug(`Storage write (address=${contractAddress}, slot=${slot}): value=${value}`);
-    const leafSlot = computePublicDataTreeLeafSlot(contractAddress, slot);
+    const leafSlot = await computePublicDataTreeLeafSlot(contractAddress, slot);
     this.log.debug(`leafSlot=${leafSlot}`);
     // Cache storage writes for later reference/reads
     this.publicStorage.write(contractAddress, slot, value);
@@ -169,7 +170,7 @@ export class AvmPersistableStateManager {
         );
       }
 
-      this.trace.tracePublicStorageWrite(
+      await this.trace.tracePublicStorageWrite(
         contractAddress,
         slot,
         value,
@@ -181,7 +182,7 @@ export class AvmPersistableStateManager {
         insertionPath,
       );
     } else {
-      this.trace.tracePublicStorageWrite(contractAddress, slot, value, protocolWrite);
+      await this.trace.tracePublicStorageWrite(contractAddress, slot, value, protocolWrite);
     }
   }
 
@@ -195,7 +196,7 @@ export class AvmPersistableStateManager {
   public async readStorage(contractAddress: AztecAddress, slot: Fr): Promise<Fr> {
     const { value, cached } = await this.publicStorage.read(contractAddress, slot);
     this.log.debug(`Storage read  (address=${contractAddress}, slot=${slot}): value=${value}, cached=${cached}`);
-    const leafSlot = computePublicDataTreeLeafSlot(contractAddress, slot);
+    const leafSlot = await computePublicDataTreeLeafSlot(contractAddress, slot);
     this.log.debug(`leafSlot=${leafSlot}`);
 
     if (this.doMerkleOperations) {
@@ -283,34 +284,34 @@ export class AvmPersistableStateManager {
    * Write a raw note hash, silo it and make it unique, then trace the write.
    * @param noteHash - the unsiloed note hash to write
    */
-  public writeNoteHash(contractAddress: AztecAddress, noteHash: Fr): void {
-    const siloedNoteHash = siloNoteHash(contractAddress, noteHash);
+  public async writeNoteHash(contractAddress: AztecAddress, noteHash: Fr): Promise<void> {
+    const siloedNoteHash = await siloNoteHash(contractAddress, noteHash);
 
-    this.writeSiloedNoteHash(siloedNoteHash);
+    await this.writeSiloedNoteHash(siloedNoteHash);
   }
 
   /**
    * Write a note hash, make it unique, trace the write.
    * @param noteHash - the non unique note hash to write
    */
-  public writeSiloedNoteHash(noteHash: Fr): void {
-    const nonce = computeNoteHashNonce(this.firstNullifier, this.trace.getNoteHashCount());
-    const uniqueNoteHash = computeUniqueNoteHash(nonce, noteHash);
+  public async writeSiloedNoteHash(noteHash: Fr): Promise<void> {
+    const nonce = await computeNoteHashNonce(this.firstNullifier, this.trace.getNoteHashCount());
+    const uniqueNoteHash = await computeUniqueNoteHash(nonce, noteHash);
 
-    this.writeUniqueNoteHash(uniqueNoteHash);
+    await this.writeUniqueNoteHash(uniqueNoteHash);
   }
 
   /**
    * Write a note hash, trace the write.
    * @param noteHash - the siloed unique hash to write
    */
-  public writeUniqueNoteHash(noteHash: Fr): void {
+  public async writeUniqueNoteHash(noteHash: Fr): Promise<void> {
     this.log.debug(`noteHashes += @${noteHash}.`);
 
     if (this.doMerkleOperations) {
       // Should write a helper for this
       const leafIndex = new Fr(this.merkleTrees.treeMap.get(MerkleTreeId.NOTE_HASH_TREE)!.leafCount);
-      const insertionPath = this.merkleTrees.appendNoteHash(noteHash);
+      const insertionPath = await this.merkleTrees.appendNoteHash(noteHash);
       this.trace.traceNewNoteHash(noteHash, leafIndex, insertionPath);
     } else {
       this.trace.traceNewNoteHash(noteHash);
@@ -325,7 +326,7 @@ export class AvmPersistableStateManager {
    */
   public async checkNullifierExists(contractAddress: AztecAddress, nullifier: Fr): Promise<boolean> {
     this.log.debug(`Checking existence of nullifier (address=${contractAddress}, nullifier=${nullifier})`);
-    const siloedNullifier = siloNullifier(contractAddress, nullifier);
+    const siloedNullifier = await siloNullifier(contractAddress, nullifier);
     const [exists, leafOrLowLeafPreimage, leafOrLowLeafIndex, leafOrLowLeafPath] = await this.getNullifierMembership(
       siloedNullifier,
     );
@@ -407,7 +408,7 @@ export class AvmPersistableStateManager {
    */
   public async writeNullifier(contractAddress: AztecAddress, nullifier: Fr) {
     this.log.debug(`Inserting new nullifier (address=${nullifier}, nullifier=${contractAddress})`);
-    const siloedNullifier = siloNullifier(contractAddress, nullifier);
+    const siloedNullifier = await siloNullifier(contractAddress, nullifier);
     await this.writeSiloedNullifier(siloedNullifier);
   }
 
@@ -447,13 +448,15 @@ export class AvmPersistableStateManager {
         await this.nullifiers.append(siloedNullifier);
         // We append the new nullifier
         this.log.debug(
-          `Nullifier tree root before insertion ${this.merkleTrees.treeMap
+          `Nullifier tree root before insertion ${await this.merkleTrees.treeMap
             .get(MerkleTreeId.NULLIFIER_TREE)!
             .getRoot()}`,
         );
         const appendResult = await this.merkleTrees.appendNullifier(siloedNullifier);
         this.log.debug(
-          `Nullifier tree root after insertion ${this.merkleTrees.treeMap.get(MerkleTreeId.NULLIFIER_TREE)!.getRoot()}`,
+          `Nullifier tree root after insertion ${await this.merkleTrees.treeMap
+            .get(MerkleTreeId.NULLIFIER_TREE)!
+            .getRoot()}`,
         );
         const lowLeafPreimage = appendResult.lowWitness.preimage as NullifierLeafPreimage;
         const lowLeafIndex = appendResult.lowWitness.index;
@@ -524,14 +527,13 @@ export class AvmPersistableStateManager {
   }
 
   /**
-   * Write an unencrypted log
+   * Write a public log
    * @param contractAddress - address of the contract that emitted the log
-   * @param event - log event selector
    * @param log - log contents
    */
-  public writeUnencryptedLog(contractAddress: AztecAddress, log: Fr[]) {
-    this.log.debug(`UnencryptedL2Log(${contractAddress}) += event with ${log.length} fields.`);
-    this.trace.traceUnencryptedLog(contractAddress, log);
+  public writePublicLog(contractAddress: AztecAddress, log: Fr[]) {
+    this.log.debug(`PublicLog(${contractAddress}) += event with ${log.length} fields.`);
+    this.trace.tracePublicLog(contractAddress, log);
   }
 
   /**
@@ -551,7 +553,7 @@ export class AvmPersistableStateManager {
       new Array<Fr>(),
     ];
     if (!contractAddressIsCanonical(contractAddress)) {
-      const contractAddressNullifier = siloNullifier(
+      const contractAddressNullifier = await siloNullifier(
         AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
         contractAddress.toField(),
       );
@@ -616,7 +618,7 @@ export class AvmPersistableStateManager {
       new Array<Fr>(),
     ];
     if (!contractAddressIsCanonical(contractAddress)) {
-      const contractAddressNullifier = siloNullifier(
+      const contractAddressNullifier = await siloNullifier(
         AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
         contractAddress.toField(),
       );

package/src/avm/opcodes/accrued_substate.ts

@@ -70,7 +70,7 @@ export class EmitNoteHash extends Instruction {
     }
 
     const noteHash = memory.get(noteHashOffset).toFr();
-    context.persistableState.writeNoteHash(context.environment.address, noteHash);
+    await context.persistableState.writeNoteHash(context.environment.address, noteHash);
 
     memory.assert({ reads: 1, addressing });
   }
@@ -201,6 +201,7 @@ export class L1ToL2MessageExists extends Instruction {
 }
 
 export class EmitUnencryptedLog extends Instruction {
+  // TODO(#11124): rename unencrypted -> public
   static type: string = 'EMITUNENCRYPTEDLOG';
   static readonly opcode: Opcode = Opcode.EMITUNENCRYPTEDLOG;
   // Informs (de)serialization. See Instruction.deserialize.
@@ -228,7 +229,7 @@ export class EmitUnencryptedLog extends Instruction {
 
     context.machineState.consumeGas(this.gasCost(logSize));
     const log = memory.getSlice(logOffset, logSize).map(f => f.toFr());
-    context.persistableState.writeUnencryptedLog(contractAddress, log);
+    context.persistableState.writePublicLog(contractAddress, log);
 
     memory.assert({ reads: 1 + logSize, addressing });
   }

package/src/avm/opcodes/conversion.ts

@@ -1,12 +1,12 @@
 import { type AvmContext } from '../avm_context.js';
 import { TypeTag, Uint1, Uint8 } from '../avm_memory_types.js';
-import { InstructionExecutionError } from '../errors.js';
+import { InvalidToRadixInputsError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 
 export class ToRadixBE extends Instruction {
-  static type: string = 'TORADIXLE';
+  static type: string = 'TORADIXBE';
   static readonly opcode: Opcode = Opcode.TORADIXBE;
 
   // Informs (de)serialization. See Instruction.deserialize.
@@ -49,12 +49,21 @@ export class ToRadixBE extends Instruction {
 
     let value: bigint = memory.get(srcOffset).toBigInt();
     const radix: bigint = memory.get(radixOffset).toBigInt();
-    if (numLimbs < 1) {
-      throw new InstructionExecutionError(`ToRadixBE instruction's numLimbs should be > 0 (was ${numLimbs})`);
+
+    if (radix < 2 || radix > 256) {
+      throw new InvalidToRadixInputsError(`ToRadixBE instruction's radix should be in range [2,256] (was ${radix}).`);
     }
-    if (radix > 256) {
-      throw new InstructionExecutionError(`ToRadixBE instruction's radix should be <= 256 (was ${radix})`);
+
+    if (numLimbs < 1 && value != BigInt(0n)) {
+      throw new InvalidToRadixInputsError(
+        `ToRadixBE instruction's input value is not zero (was ${value}) but numLimbs zero.`,
+      );
     }
+
+    if (outputBits != 0 && radix != BigInt(2n)) {
+      throw new InvalidToRadixInputsError(`Radix ${radix} is not equal to 2 and bit mode is activated.`);
+    }
+
     const radixBN: bigint = BigInt(radix);
     const limbArray = new Array(numLimbs);
 

package/src/avm/opcodes/ec_add.ts

@@ -81,7 +81,7 @@ export class EcAdd extends Instruction {
     } else if (p2IsInfinite) {
       dest = p1;
     } else {
-      dest = grumpkin.add(p1, p2);
+      dest = await grumpkin.add(p1, p2);
     }
 
     // Important to use setSlice() and not set() in the two following statements as

package/src/avm/opcodes/hashing.ts

@@ -34,7 +34,7 @@ export class Poseidon2 extends Instruction {
     const inputState = memory.getSlice(inputOffset, Poseidon2.stateSize);
     memory.checkTagsRange(TypeTag.FIELD, inputOffset, Poseidon2.stateSize);
 
-    const outputState = poseidon2Permutation(inputState);
+    const outputState = await poseidon2Permutation(inputState);
     memory.setSlice(
       outputOffset,
       outputState.map(word => new Field(word)),

package/src/avm/opcodes/multi_scalar_mul.ts

@@ -95,20 +95,22 @@ export class MultiScalarMul extends Instruction {
     const [firstBaseScalarPair, ...rest]: Array<[Point, Fq]> = grumpkinPoints.map((p, idx) => [p, scalarFqVector[idx]]);
     // Fold the points and scalars into a single point
     // We have to ensure get the first point, since the identity element (point at infinity) isn't quite working in ts
-    const outputPoint = rest.reduce((acc, curr) => {
+    let acc = await grumpkin.mul(firstBaseScalarPair[0], firstBaseScalarPair[1]);
+    for (const curr of rest) {
       if (curr[1] === Fq.ZERO) {
         // If we multiply by 0, the result will the point at infinity - so we ignore it
-        return acc;
+        continue;
       } else if (curr[0].inf) {
         // If we multiply the point at infinity by a scalar, it's still the point at infinity
-        return acc;
+        continue;
       } else if (acc.inf) {
         // If we accumulator is the point at infinity, we can just return the current point
-        return curr[0];
+        acc = curr[0];
       } else {
-        return grumpkin.add(acc, grumpkin.mul(curr[0], curr[1]));
+        acc = await grumpkin.add(acc, await grumpkin.mul(curr[0], curr[1]));
       }
-    }, grumpkin.mul(firstBaseScalarPair[0], firstBaseScalarPair[1]));
+    }
+    const outputPoint = acc;
 
     // Important to use setSlice() and not set() in the two following statements as
     // this checks that the offsets lie within memory range.

package/src/avm/test_utils.ts

@@ -11,11 +11,10 @@ import { mock } from 'jest-mock-extended';
 import { type WorldStateDB } from '../public/public_db_sources.js';
 import { type PublicSideEffectTraceInterface } from '../public/side_effect_trace_interface.js';
 
-export function mockGetBytecode(worldStateDB: WorldStateDB, bytecode: Buffer) {
+export async function mockGetBytecode(worldStateDB: WorldStateDB, bytecode: Buffer) {
+  const commitment = await computePublicBytecodeCommitment(bytecode);
   (worldStateDB as jest.Mocked<WorldStateDB>).getBytecode.mockResolvedValue(bytecode);
-  (worldStateDB as jest.Mocked<WorldStateDB>).getBytecodeCommitment.mockResolvedValue(
-    computePublicBytecodeCommitment(bytecode),
-  );
+  (worldStateDB as jest.Mocked<WorldStateDB>).getBytecodeCommitment.mockResolvedValue(commitment);
 }
 
 export function mockTraceFork(trace: PublicSideEffectTraceInterface, nestedTrace?: PublicSideEffectTraceInterface) {