@aztec/simulator 3.0.0-canary.a9708bd → 3.0.0-devnet.3

package/src/public/avm/avm_simulator.ts

@@ -6,7 +6,7 @@ import type { GlobalVariables } from '@aztec/stdlib/tx';
 
 import { strict as assert } from 'assert';
 
-import { SideEffectLimitReachedError } from '../side_effect_errors.js';
+import { CheckedPublicExecutionError } from '../public_errors.js';
 import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
 import { AvmContext } from './avm_context.js';
 import { AvmContractCallResult } from './avm_contract_call_result.js';
@@ -14,7 +14,7 @@ import { AvmExecutionEnvironment } from './avm_execution_environment.js';
 import type { Gas } from './avm_gas.js';
 import { AvmMachineState } from './avm_machine_state.js';
 import type { AvmSimulatorInterface } from './avm_simulator_interface.js';
-import { AvmExecutionError, AvmRevertReason, InvalidProgramCounterError } from './errors.js';
+import { AvmRevertReason, InvalidProgramCounterError } from './errors.js';
 import type { Instruction } from './opcodes/instruction.js';
 import { revertReasonFromExceptionalHalt, revertReasonFromExplicitRevert } from './revert_reason.js';
 import {
@@ -76,6 +76,7 @@ export class AvmSimulator implements AvmSimulatorInterface {
     calldata: Fr[],
     allocatedGas: Gas,
     clientInitiatedSimulation: boolean = false,
+    maxDebugLogMemoryReads?: number,
   ) {
     const avmExecutionEnv = new AvmExecutionEnvironment(
       address,
@@ -86,6 +87,7 @@ export class AvmSimulator implements AvmSimulatorInterface {
       isStaticCall,
       calldata,
       clientInitiatedSimulation,
+      maxDebugLogMemoryReads,
     );
 
     const avmMachineState = new AvmMachineState(allocatedGas);
@@ -97,22 +99,13 @@ export class AvmSimulator implements AvmSimulatorInterface {
    * Fetch the bytecode and execute it in the current context.
    */
   public async execute(): Promise<AvmContractCallResult> {
-    let bytecode: Buffer | undefined;
-    try {
-      bytecode = await this.context.persistableState.getBytecode(this.context.environment.address);
-    } catch (err: any) {
-      if (!(err instanceof AvmExecutionError || err instanceof SideEffectLimitReachedError)) {
-        this.log.error(`Unknown error thrown by AVM during bytecode retrieval: ${err}`);
-        throw err;
-      }
-      return await this.handleFailureToRetrieveBytecode(
-        `Bytecode retrieval for contract '${this.context.environment.address}' failed with ${err.message}. Reverting...`,
-      );
-    }
+    const bytecode = await this.context.persistableState.getBytecode(this.context.environment.address);
+    // getBytecode returns undefined if bytecode is not found or if the limit of contract calls to unique class IDs is reached.
+    // If it throws an error that reaches this point, it is a bug.
 
     if (!bytecode) {
       return await this.handleFailureToRetrieveBytecode(
-        `No bytecode found at: ${this.context.environment.address}. Reverting...`,
+        `No bytecode found, or limit encountered for max calls to unique contract class IDs. Contract address: ${this.context.environment.address}. Reverting...`,
       );
     }
 
@@ -135,6 +128,7 @@ export class AvmSimulator implements AvmSimulatorInterface {
     assert(bytecode.length > 0, "AVM simulator can't execute empty bytecode");
 
     this.bytecode = bytecode;
+    let instructionName = 'NONE'; // This is used for logging purposes
 
     const { machineState } = this.context;
     const callStartGas = machineState.gasLeft; // Save gas before executing instruction (for profiling)
@@ -163,6 +157,7 @@ export class AvmSimulator implements AvmSimulatorInterface {
         }
         machineState.nextPc = machineState.pc + bytesRead;
 
+        instructionName = instruction.constructor.name;
         // Execute the instruction.
         // Normal returns and reverts will return normally here.
         // "Exceptional halts" will throw.
@@ -211,18 +206,12 @@ export class AvmSimulator implements AvmSimulatorInterface {
       // Return results for processing by calling context
       return results;
     } catch (err: any) {
-      this.log.verbose('Exceptional halt (revert by something other than REVERT opcode)');
-      // FIXME: weird that we have to do this OutOfGasError check because:
-      // 1. OutOfGasError is an AvmExecutionError, so that check should cover both
-      // 2. We should at least be able to do instanceof OutOfGasError instead of checking the constructor name
-      if (
-        !(
-          err.constructor.name == 'OutOfGasError' ||
-          err instanceof AvmExecutionError ||
-          err instanceof SideEffectLimitReachedError
-        )
-      ) {
-        this.log.error(`Unknown error thrown by AVM: ${err}`);
+      this.log.info(
+        `Exceptional halt (revert by something other than REVERT opcode) for instruction
+         ${instructionName} at pc ${machineState.pc} and instruction counter ${machineState.instrCounter}`,
+      );
+      if (!(err instanceof CheckedPublicExecutionError)) {
+        this.log.error(`Unchecked/unknown error thrown by AVM. This is a bug. Error: ${err}`);
         throw err;
       }
 

package/src/public/avm/errors.ts

@@ -1,26 +1,19 @@
 import type { Point } from '@aztec/foundation/fields';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { FailingFunction, NoirCallStack } from '@aztec/stdlib/errors';
 
 import { ExecutionError } from '../../common/errors.js';
+import { CheckedPublicExecutionError } from '../public_errors.js';
 
 /**
  * Avm-specific errors should derive from this
  */
-export abstract class AvmExecutionError extends Error {
+export abstract class AvmExecutionError extends CheckedPublicExecutionError {
   constructor(message: string) {
     super(message);
     this.name = 'AvmExecutionError';
   }
 }
 
-export class NoBytecodeForContractError extends AvmExecutionError {
-  constructor(contractAddress: AztecAddress) {
-    super(`No bytecode found at: ${contractAddress}`);
-    this.name = 'NoBytecodeFoundInterpreterError';
-  }
-}
-
 export class ArithmeticError extends AvmExecutionError {
   constructor(message: string) {
     super(message);
@@ -129,22 +122,12 @@ export class OutOfGasError extends AvmExecutionError {
 }
 
 /**
- * Error is thrown when the supplied points length is not a multiple of 3. Specific for MSM opcode.
- */
-export class MSMPointsLengthError extends AvmExecutionError {
-  constructor(pointsReadLength: number) {
-    super(`Points vector length should be a multiple of 3, was ${pointsReadLength}`);
-    this.name = 'MSMPointsLengthError';
-  }
-}
-
-/**
- * Error is thrown when one of the supplied points does not lie on the Grumpkin curve. Specific for MSM opcode.
+ * Error is thrown when one of the supplied points does not lie on the Grumpkin curve. Specific for ECADD opcode.
  */
-export class MSMPointNotOnCurveError extends AvmExecutionError {
-  constructor(point: Point) {
-    super(`Point ${point.toString()} is not on the curve.`);
-    this.name = 'MSMPointNotOnCurveError';
+export class EcAddPointNotOnCurveError extends AvmExecutionError {
+  constructor(pointIndex: number, point: Point) {
+    super(`EcAdd point${pointIndex} (${point.toString()}) is not on the curve.`);
+    this.name = 'EcAddPointNotOnCurveError';
   }
 }
 

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

@@ -37,9 +37,11 @@ export class AvmSimulationTester extends BaseAvmSimulationTester {
     super(contractDataSource, merkleTrees);
   }
 
-  static async create(): Promise<AvmSimulationTester> {
+  static async create(
+    worldStateService: NativeWorldStateService, // make sure to close this later
+  ): Promise<AvmSimulationTester> {
     const contractDataSource = new SimpleContractDataSource();
-    const merkleTrees = await (await NativeWorldStateService.tmp()).fork();
+    const merkleTrees = await worldStateService.fork();
     const treesDB = new PublicTreesDB(merkleTrees);
     const contractsDB = new PublicContractsDB(contractDataSource);
     const trace = new SideEffectTrace();

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

@@ -2,7 +2,9 @@ import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { getCanonicalAuthRegistry } from '@aztec/protocol-contracts/auth-registry';
 import { computeFeePayerBalanceStorageSlot, getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
+import { getCanonicalInstanceRegistry } from '@aztec/protocol-contracts/instance-registry';
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -88,6 +90,36 @@ export abstract class BaseAvmSimulationTester {
     return feeJuice.instance;
   }
 
+  async registerAuthContract(): Promise<ContractInstanceWithAddress> {
+    const authRegistry = await getCanonicalAuthRegistry();
+    const authRegistryContractClassPublic = {
+      ...authRegistry.contractClass,
+      privateFunctions: [],
+      utilityFunctions: [],
+    };
+    await this.contractDataSource.addNewContract(
+      authRegistry.artifact,
+      authRegistryContractClassPublic,
+      authRegistry.instance,
+    );
+    return authRegistry.instance;
+  }
+
+  async registerInstanceRegistryContract(): Promise<ContractInstanceWithAddress> {
+    const instanceRegistry = await getCanonicalInstanceRegistry();
+    const instanceRegistryContractClassPublic = {
+      ...instanceRegistry.contractClass,
+      privateFunctions: [],
+      utilityFunctions: [],
+    };
+    await this.contractDataSource.addNewContract(
+      instanceRegistry.artifact,
+      instanceRegistryContractClassPublic,
+      instanceRegistry.instance,
+    );
+    return instanceRegistry.instance;
+  }
+
   async addContractInstance(contractInstance: ContractInstanceWithAddress, skipNullifierInsertion = false) {
     if (!skipNullifierInsertion) {
       await this.insertContractAddressNullifier(contractInstance.address);

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

@@ -1,4 +1,4 @@
-import { AVM_MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
+import { AVM_MAX_PROCESSABLE_L2_GAS, DEFAULT_MAX_DEBUG_LOG_MEMORY_READS } from '@aztec/constants';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -73,6 +73,7 @@ export function initExecutionEnvironment(overrides?: Partial<AvmExecutionEnviron
     overrides?.isStaticCall ?? false,
     overrides?.calldata ?? [],
     overrides?.clientInitiatedSimulation ?? true, // default to true for testing even though internal default is false
+    overrides?.maxDebugLogMemoryReads ?? DEFAULT_MAX_DEBUG_LOG_MEMORY_READS,
   );
 }
 

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

@@ -1,4 +1,4 @@
-import { NullifierCollisionError } from '../../state_manager/nullifiers.js';
+import { NullifierCollisionError } from '../../side_effect_errors.js';
 import type { AvmContext } from '../avm_context.js';
 import { TypeTag, Uint1 } from '../avm_memory_types.js';
 import { InstructionExecutionError, StaticCallAlterationError } from '../errors.js';
@@ -219,8 +219,8 @@ export class EmitUnencryptedLog extends Instruction {
 
   constructor(
     private indirect: number,
-    private logOffset: number,
     private logSizeOffset: number,
+    private logOffset: number,
   ) {
     super();
   }
@@ -237,8 +237,8 @@ export class EmitUnencryptedLog extends Instruction {
       this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
     );
 
-    const operands = [this.logOffset, this.logSizeOffset];
-    const [logOffset, logSizeOffset] = addressing.resolve(operands, memory);
+    const operands = [this.logSizeOffset, this.logOffset];
+    const [logSizeOffset, logOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.UINT32, logSizeOffset);
     const logSize = memory.get(logSizeOffset).toNumber();
     memory.checkTagsRange(TypeTag.FIELD, logOffset, logSize);

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

@@ -2,6 +2,8 @@ import { AVM_MAX_OPERANDS } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import type { Tuple } from '@aztec/foundation/serialize';
 
+import { strict as assert } from 'assert';
+
 import { MemoryValue, TaggedMemory, type TaggedMemoryInterface, TypeTag } from '../avm_memory_types.js';
 import { RelativeAddressOutOfRangeError, TagCheckError } from '../errors.js';
 
@@ -20,9 +22,7 @@ export class Addressing {
   ) {}
 
   public static fromModes(modes: AddressingMode[]): Addressing {
-    if (modes.length > AVM_MAX_OPERANDS) {
-      throw new Error('Too many operands for addressing mode');
-    }
+    assert(modes.length <= AVM_MAX_OPERANDS, 'Too many operands for addressing mode');
     return new Addressing(padArrayEnd(modes, AddressingMode.DIRECT, AVM_MAX_OPERANDS));
   }
 

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

@@ -80,6 +80,10 @@ export class ToRadixBE extends Instruction {
       value /= radixBN;
     }
 
+    if (value !== 0n) {
+      throw new InvalidToRadixInputsError(`Field failed to decompose in ${numLimbs} limbs.`);
+    }
+
     const outputType = outputBits != 0 ? Uint1 : Uint8;
     const res = limbArray.map(byte => new outputType(byte));
     memory.setSlice(dstOffset, res);

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

@@ -3,6 +3,7 @@ import { Point } from '@aztec/foundation/fields';
 
 import type { AvmContext } from '../avm_context.js';
 import { Field, TypeTag, Uint1 } from '../avm_memory_types.js';
+import { EcAddPointNotOnCurveError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -65,7 +66,7 @@ export class EcAdd extends Instruction {
     const p1IsInfinite = memory.get(p1IsInfiniteOffset).toNumber() === 1;
     const p1 = new Point(p1X.toFr(), p1Y.toFr(), p1IsInfinite);
     if (!p1.isOnGrumpkin()) {
-      throw new Error(`Point1 is not on the curve`);
+      throw new EcAddPointNotOnCurveError(/*pointIndex=*/ 1, p1);
     }
 
     const p2X = memory.get(p2XOffset);
@@ -74,7 +75,7 @@ export class EcAdd extends Instruction {
     const p2IsInfinite = memory.get(p2IsInfiniteOffset).toNumber() === 1;
     const p2 = new Point(p2X.toFr(), p2Y.toFr(), p2IsInfinite);
     if (!p2.isOnGrumpkin()) {
-      throw new Error(`Point1 is not on the curve`);
+      throw new EcAddPointNotOnCurveError(/*pointIndex=*/ 2, p2);
     }
 
     const grumpkin = new Grumpkin();

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

@@ -20,8 +20,8 @@ export enum EnvironmentVariable {
   DAGASLEFT,
 }
 
-function getValue(e: EnvironmentVariable, ctx: AvmContext) {
-  switch (e) {
+function getValue(varEnum: EnvironmentVariable, ctx: AvmContext) {
+  switch (varEnum) {
     case EnvironmentVariable.ADDRESS:
       return new Field(ctx.environment.address.toField());
     case EnvironmentVariable.SENDER:
@@ -47,7 +47,7 @@ function getValue(e: EnvironmentVariable, ctx: AvmContext) {
     case EnvironmentVariable.DAGASLEFT:
       return new Uint32(ctx.machineState.daGasLeft);
     default:
-      throw new Error(`Unknown environment variable ${e}`);
+      throw new InstructionExecutionError(`Invalid GETENVVAR var enum ${varEnum}`);
   }
 }
 
@@ -77,13 +77,11 @@ export class GetEnvVar extends Instruction {
       this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
     );
 
-    if (!(this.varEnum in EnvironmentVariable)) {
-      throw new InstructionExecutionError(`Invalid GETENVVAR var enum ${this.varEnum}`);
-    }
-
     const operands = [this.dstOffset];
     const [dstOffset] = addressing.resolve(operands, memory);
 
-    memory.set(dstOffset, getValue(this.varEnum as EnvironmentVariable, context));
+    const value = getValue(this.varEnum as EnvironmentVariable, context);
+
+    memory.set(dstOffset, value);
   }
 }

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

@@ -36,6 +36,8 @@ export abstract class Instruction {
    * @returns Thee string representation.
    */
   public toString(): string {
+    // Note: we could have this be the actual wire opcode if `bytecode_serialization.ts` were to
+    // pass it into the class' static `Instruction.as(this, wireFormat)` method.
     let instructionStr = this.constructor.name + ': ';
     // assumes that all properties are flags or operands
     for (const prop of Object.getOwnPropertyNames(this) as (keyof Instruction)[]) {
@@ -114,9 +116,7 @@ export abstract class Instruction {
    */
   public get type(): string {
     const type = 'type' in this.constructor && (this.constructor.type as string);
-    if (!type) {
-      throw new Error(`Instruction class ${this.constructor.name} does not have a static 'type' property defined.`);
-    }
+    assert(!!type, `Instruction class ${this.constructor.name} does not have a static 'type' property defined.`);
     return type;
   }
 
@@ -126,9 +126,11 @@ export abstract class Instruction {
    */
   public get opcode(): Opcode {
     const opcode = 'opcode' in this.constructor ? (this.constructor.opcode as Opcode) : undefined;
-    if (opcode === undefined || Opcode[opcode] === undefined) {
-      throw new Error(`Instruction class ${this.constructor.name} does not have a static 'opcode' property defined.`);
-    }
+    assert(
+      opcode !== undefined,
+      `Instruction class ${this.constructor.name} does not have a static 'opcode' property defined.`,
+    );
+    assert(Opcode[opcode] !== undefined, `Invalid opcode ${opcode} for instruction class ${this.constructor.name}.`);
     return opcode;
   }
 }

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

@@ -1,4 +1,4 @@
-import { applyStringFormatting, createLogger } from '@aztec/foundation/log';
+import { LogLevels, applyStringFormatting, createLogger } from '@aztec/foundation/log';
 
 import type { AvmContext } from '../avm_context.js';
 import { TypeTag } from '../avm_memory_types.js';
@@ -15,6 +15,7 @@ export class DebugLog extends Instruction {
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8, // Opcode
     OperandType.UINT8, // Indirect
+    OperandType.UINT16, // level memory address
     OperandType.UINT16, // message memory address
     OperandType.UINT16, // fields memory address
     OperandType.UINT16, // fields size address
@@ -23,6 +24,7 @@ export class DebugLog extends Instruction {
 
   constructor(
     private indirect: number,
+    private levelOffset: number,
     private messageOffset: number,
     private fieldsOffset: number,
     private fieldsSizeOffset: number,
@@ -39,16 +41,30 @@ export class DebugLog extends Instruction {
       this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
     );
 
-    const operands = [this.messageOffset, this.fieldsOffset, this.fieldsSizeOffset];
-    const [messageOffset, fieldsOffset, fieldsSizeOffset] = addressing.resolve(operands, memory);
+    const operands = [this.levelOffset, this.messageOffset, this.fieldsOffset, this.fieldsSizeOffset];
+    const [levelOffset, messageOffset, fieldsOffset, fieldsSizeOffset] = addressing.resolve(operands, memory);
 
-    // DebugLog is a no-op except when doing client-initiated simulation with debug logging enabled.
+    // DebugLog is a no-op except when doing client-initiated simulation.
     // Note that we still do address resolution and basic tag-checking (above)
     // To avoid a special-case in the witness generator and circuit.
-    if (context.environment.clientInitiatedSimulation && DebugLog.logger.isLevelEnabled('verbose')) {
+    if (context.environment.clientInitiatedSimulation) {
+      memory.checkTag(TypeTag.UINT8, levelOffset);
+      const levelNumber = memory.get(levelOffset).toNumber();
       memory.checkTag(TypeTag.UINT32, fieldsSizeOffset);
       const fieldsSize = memory.get(fieldsSizeOffset).toNumber();
 
+      const memoryReads = 1 /* level */ + 1 /* fieldsSize */ + this.messageSize /* message */ + fieldsSize; /* fields */
+      if (
+        context.persistableState.getDebugLogMemoryReads() + memoryReads >
+        context.environment.maxDebugLogMemoryReads
+      ) {
+        // Regular error on purpose: this is not a recoverable error.
+        throw new Error(
+          `Max debug log memory reads exceeded: ${context.persistableState.getDebugLogMemoryReads() + memoryReads} > ${context.environment.maxDebugLogMemoryReads}`,
+        );
+      }
+      context.persistableState.writeDebugLogMemoryReads(memoryReads);
+
       const rawMessage = memory.getSlice(messageOffset, this.messageSize);
       const fields = memory.getSlice(fieldsOffset, fieldsSize);
 
@@ -57,12 +73,30 @@ export class DebugLog extends Instruction {
 
       // Interpret str<N> = [u8; N] to string.
       const messageAsStr = rawMessage.map(field => String.fromCharCode(field.toNumber())).join('');
-      const formattedStr = applyStringFormatting(
+
+      if (!LogLevels[levelNumber]) {
+        // Regular error on purpose: this is not a recoverable error.
+        throw new Error(`Invalid debug log level: ${levelNumber}`);
+      }
+
+      const level = LogLevels[levelNumber];
+
+      context.persistableState.writeDebugLog(
+        context.environment.address,
+        level,
         messageAsStr,
         fields.map(field => field.toFr()),
       );
 
-      DebugLog.logger.verbose(formattedStr);
+      // Skips string formatting if the level is disabled.
+      if (DebugLog.logger.isLevelEnabled(level)) {
+        const formattedStr = applyStringFormatting(
+          messageAsStr,
+          fields.map(field => field.toFr()),
+        );
+
+        DebugLog.logger[level](formattedStr);
+      }
     }
   }
 }

package/src/public/avm/serialization/instruction_serialization.ts

@@ -124,6 +124,18 @@ const OPERAND_SPEC = new Map<OperandType, [number, (offset: number) => OperandNa
   [OperandType.TAG, [1, Buffer.prototype.readUint8, Buffer.prototype.writeUint8]],
 ]);
 
+/**
+ * Returns the size of an operand in bytes.
+ * Should not be called with unknown operand types.
+ * @param operandType
+ * @returns number size in bytes
+ * @throws AssertionError if the operand type is unknown
+ */
+export function getOperandSize(operandType: OperandType): number {
+  assert(OPERAND_SPEC.has(operandType), `Unknown operand type: ${operandType}`);
+  return OPERAND_SPEC.get(operandType)![0];
+}
+
 function readUintBE(buf: Buffer, offset: number, totalBytes: number): bigint {
   let value: bigint = 0n;
   for (let i = 0; i < totalBytes; ++i) {

package/src/public/avm/test_utils.ts

@@ -27,13 +27,12 @@ export function mockStorageReadWithMap(worldStateDB: PublicTreesDB, mockedStorag
   );
 }
 
-export function mockNoteHashExists(worldStateDB: PublicTreesDB, _leafIndex: bigint, value?: Fr) {
+export function mockGetNoteHash(worldStateDB: PublicTreesDB, _leafIndex: bigint, value?: Fr) {
   (worldStateDB as jest.Mocked<PublicTreesDB>).getNoteHash.mockImplementation((index: bigint) => {
-    if (index == _leafIndex) {
+    if (index == _leafIndex && value) {
       return Promise.resolve(value);
     } else {
-      // This is ok for now since the traceing functions handle it
-      return Promise.resolve(undefined);
+      return Promise.resolve(Fr.ZERO);
     }
   });
 }
@@ -42,19 +41,12 @@ export function mockCheckNullifierExists(worldStateDB: PublicTreesDB, exists: bo
   (worldStateDB as jest.Mocked<PublicTreesDB>).checkNullifierExists.mockResolvedValue(exists);
 }
 
-export function mockL1ToL2MessageExists(
-  worldStateDB: PublicTreesDB,
-  leafIndex: bigint,
-  value: Fr,
-  valueAtOtherIndices?: Fr,
-) {
+export function mockGetL1ToL2LeafValue(worldStateDB: PublicTreesDB, leafIndex: bigint, value?: Fr) {
   (worldStateDB as jest.Mocked<PublicTreesDB>).getL1ToL2LeafValue.mockImplementation((index: bigint) => {
-    if (index == leafIndex) {
+    if (index == leafIndex && value) {
       return Promise.resolve(value);
     } else {
-      // any indices other than mockAtLeafIndex will return a different value
-      // (or undefined if no value is specified for other indices)
-      return Promise.resolve(valueAtOtherIndices!);
+      return Promise.resolve(Fr.ZERO!);
     }
   });
 }

package/src/public/fixtures/bulk_test.ts

@@ -20,11 +20,19 @@ export async function bulkTest(
     avmTestContractArtifact,
   );
 
+  // Needed since we invoke the Fee Juice Contract in the bulk test.registerFeeJuiceContract
+  await tester.registerFeeJuiceContract();
+  // Register multiple different protocol contracts (to ensure we don't dedup bytecode hashing events):
+  await tester.registerAuthContract();
+  await tester.registerInstanceRegistryContract();
+
   // Get a deployed contract instance to pass to the contract
   // for it to use as "expected" values when testing contract instance retrieval.
   const expectContractInstance = avmTestContract;
   const argsField = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsU8 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+  const argsU8 = [1, 2, 3, 4, 5, 6, 7, 8].map(x => new Fr(x));
+  argsU8.push(new Fr(2n ** 128n + 9n)); // Trigger truncation from large (> 128 bits) value (canonical decomposition event)
+  argsU8.push(new Fr(2n ** 125n + 10n)); // Trigger truncation from small (< 128 bits) value (no canonical decomposition event)
   const args = [
     argsField,
     argsU8,
@@ -45,6 +53,26 @@ export async function bulkTest(
         fnName: 'bulk_testing',
         args,
       },
+      // 3 calls creating calldata + asserting calldata copy:
+      {
+        address: avmTestContract.address,
+        fnName: 'assert_calldata_copy_large',
+        args: [Array.from({ length: 300 }, () => Fr.random()), /* with_selector: */ true],
+      },
+      {
+        address: avmTestContract.address,
+        fnName: 'assert_calldata_copy',
+        args: [argsField.slice(3), /* with_selector: */ true],
+      },
+      {
+        address: avmTestContract.address,
+        fnName: 'assert_calldata_copy_large',
+        args: [Array.from({ length: 300 }, () => Fr.random()), /* with_selector: */ true],
+      },
+      // 3 calls to external contracts
+      { address: avmTestContract.address, fnName: 'call_fee_juice', args: [] },
+      { address: avmTestContract.address, fnName: 'call_auth_registry', args: [] },
+      { address: avmTestContract.address, fnName: 'call_instance_registry', args: [] },
     ],
     /*teardownCall=*/ undefined,
     /*feePayer*/ undefined,
@@ -78,25 +106,22 @@ export async function megaBulkTest(
     deployer,
     avmTestContractArtifact,
   );
+
+  // Needed since we invoke the Fee Juice Contract in the bulk test.registerFeeJuiceContract
+  await tester.registerFeeJuiceContract();
+
   // Get a deployed contract instance to pass to the contract
   // for it to use as "expected" values when testing contract instance retrieval.
   const expectContractInstance = avmTestContract;
   const argsField0 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsField1 = [2, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsField2 = [3, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsField3 = [4, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsField4 = [5, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsField5 = [6, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsField6 = [7, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsField7 = [8, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsField8 = [9, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsField9 = [10, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsField10 = [11, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsField11 = [12, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsField12 = [13, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsField13 = [14, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsField14 = [15, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsField15 = [16, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+  const argsField1 = [3, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+  const argsField2 = [5, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+  const argsField3 = [7, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+  const argsField4 = [9, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+  const argsField5 = [11, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+  const argsField6 = [13, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+  const argsField7 = [15, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+  const argsField8 = [17, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
   const argsU8 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
   const genArgs = (argsField: Fr[]) => [
     argsField,
@@ -123,13 +148,6 @@ export async function megaBulkTest(
       { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField6) },
       { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField7) },
       { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField8) },
-      { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField9) },
-      { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField10) },
-      { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField11) },
-      { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField12) },
-      { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField13) },
-      { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField14) },
-      { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField15) },
     ],
     /*teardownCall=*/ undefined,
     /*feePayer*/ undefined,