@aztec/simulator 2.1.0-rc.9 → 3.0.0-devnet.2

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,

package/src/public/fixtures/custom_bytecode_tester.ts

@@ -0,0 +1,49 @@
+import { FunctionType, emptyContractArtifact, emptyFunctionArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import type { PublicTxResult } from '../public_tx_simulator/public_tx_simulator.js';
+import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+
+/**
+ *
+ * Test custom bytecode (simulation or proving) with the provided bytecode.
+ * @param bytecode - The bytecode buffer to use
+ * @param tester - The tester to use (simulation or proving)
+ * @param txLabel - The label of the transaction
+ * @param contractName - The name of the contract (default: 'CustomBytecodeContract')
+ */
+export async function testCustomBytecode(
+  bytecode: Buffer,
+  tester: PublicTxSimulationTester,
+  txLabel: string,
+  contractName: string = 'CustomBytecodeContract',
+): Promise<PublicTxResult> {
+  const deployer = AztecAddress.fromNumber(42);
+
+  const contractArtifact = emptyContractArtifact();
+  contractArtifact.name = contractName;
+  contractArtifact.functions = [emptyFunctionArtifact()];
+  contractArtifact.functions[0].name = 'public_dispatch';
+  contractArtifact.functions[0].functionType = FunctionType.PUBLIC;
+  contractArtifact.functions[0].bytecode = bytecode;
+
+  const testContract = await tester.registerAndDeployContract(
+    /*constructorArgs=*/ [],
+    deployer,
+    /*contractArtifact=*/ contractArtifact,
+  );
+
+  // EXECUTE! This means that if using AvmProvingTester subclass, it will PROVE the transaction!
+  return await tester.executeTxWithLabel(
+    /*txLabel=*/ txLabel,
+    /*sender=*/ deployer,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        address: testContract.address,
+        fnName: 'public_dispatch',
+        args: [],
+      },
+    ],
+  );
+}