@aztec/simulator 0.0.1-commit.24de95ac → 0.0.1-commit.2ed92850

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

@@ -5,7 +5,9 @@ import { Opcode, OperandType } from '../serialization/instruction_serialization.
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 
-abstract class BaseStorageInstruction extends Instruction {
+export class SStore extends Instruction {
+  static readonly type: string = 'SSTORE';
+  static readonly opcode = Opcode.SSTORE;
   // Informs (de)serialization. See Instruction.deserialize.
   public static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
@@ -15,21 +17,12 @@ abstract class BaseStorageInstruction extends Instruction {
   ];
 
   constructor(
-    protected indirect: number,
-    protected aOffset: number,
-    protected bOffset: number,
+    private addressingMode: number,
+    private srcOffset: number,
+    private slotOffset: number,
   ) {
     super();
   }
-}
-
-export class SStore extends BaseStorageInstruction {
-  static readonly type: string = 'SSTORE';
-  static readonly opcode = Opcode.SSTORE;
-
-  constructor(indirect: number, srcOffset: number, slotOffset: number) {
-    super(indirect, srcOffset, slotOffset);
-  }
 
   public async execute(context: AvmContext): Promise<void> {
     if (context.environment.isStaticCall) {
@@ -37,13 +30,13 @@ export class SStore extends BaseStorageInstruction {
     }
 
     const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
+    const addressing = Addressing.fromWire(this.addressingMode);
 
     context.machineState.consumeGas(
       this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
     );
 
-    const operands = [this.aOffset, this.bOffset];
+    const operands = [this.srcOffset, this.slotOffset];
     const [srcOffset, slotOffset] = addressing.resolve(operands, memory);
     // We read before tag checking since it's needed for gas cost calculation
     const slot = memory.get(slotOffset).toFr();
@@ -60,28 +53,43 @@ export class SStore extends BaseStorageInstruction {
   }
 }
 
-export class SLoad extends BaseStorageInstruction {
+export class SLoad extends Instruction {
   static readonly type: string = 'SLOAD';
   static readonly opcode = Opcode.SLOAD;
+  // Informs (de)serialization. See Instruction.deserialize.
+  public static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT16,
+    OperandType.UINT16,
+    OperandType.UINT16,
+  ];
 
-  constructor(indirect: number, slotOffset: number, dstOffset: number) {
-    super(indirect, slotOffset, dstOffset);
+  constructor(
+    private addressingMode: number,
+    private slotOffset: number,
+    private contractAddressOffset: number,
+    private dstOffset: number,
+  ) {
+    super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory;
-    const addressing = Addressing.fromWire(this.indirect);
+    const addressing = Addressing.fromWire(this.addressingMode);
 
     context.machineState.consumeGas(
       this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
     );
 
-    const operands = [this.aOffset, this.bOffset];
-    const [slotOffset, dstOffset] = addressing.resolve(operands, memory);
+    const operands = [this.slotOffset, this.contractAddressOffset, this.dstOffset];
+    const [slotOffset, contractAddressOffset, dstOffset] = addressing.resolve(operands, memory);
     memory.checkTag(TypeTag.FIELD, slotOffset);
+    memory.checkTag(TypeTag.FIELD, contractAddressOffset);
 
     const slot = memory.get(slotOffset).toFr();
-    const value = await context.persistableState.readStorage(context.environment.address, slot);
+    const contractAddress = memory.get(contractAddressOffset).toAztecAddress();
+    const value = await context.persistableState.readStorage(contractAddress, slot);
     memory.set(dstOffset, new Field(value));
   }
 }

package/src/public/avm/revert_reason.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { AvmContext } from './avm_context.js';
 import { type AvmExecutionError, AvmRevertReason } from './errors.js';
@@ -18,13 +18,16 @@ async function createRevertReason(message: string, revertData: Fr[], context: Av
     message = context.machineState.collectedRevertInfo.recursiveRevertReason.message;
   }
 
-  const fnName = await context.persistableState.getPublicFunctionDebugName(context.environment);
+  const { functionSelector, functionName } = await context.persistableState.getPublicFunctionSelectorAndName(
+    context.environment,
+  );
 
   return new AvmRevertReason(
     message,
     /*failingFunction=*/ {
       contractAddress: context.environment.address,
-      functionName: fnName,
+      functionSelector,
+      functionName,
     },
     /*noirCallStack=*/ [...internalCallStack, context.machineState.pc].map(pc => `0.${pc}`),
     /*options=*/ { cause: nestedError },

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

@@ -1,6 +1,13 @@
 import { type Bufferable, serializeToBuffer } from '@aztec/foundation/serialize';
 
-import { AvmExecutionError, AvmParsingError, InvalidOpcodeError, InvalidProgramCounterError } from '../errors.js';
+import {
+  AvmExecutionError,
+  AvmParsingError,
+  InvalidOpcodeError,
+  InvalidProgramCounterError,
+  InvalidTagValueError,
+  duringInstrFetch,
+} from '../errors.js';
 import {
   Add,
   And,
@@ -172,7 +179,7 @@ export function decodeInstructionFromBytecode(
   instructionSet: InstructionSet = INSTRUCTION_SET,
 ): [Instruction, number] {
   if (pc >= bytecode.length) {
-    throw new InvalidProgramCounterError(pc, bytecode.length);
+    throw new InvalidProgramCounterError(pc, bytecode.length - 1);
   }
 
   try {
@@ -182,7 +189,7 @@ export function decodeInstructionFromBytecode(
 
     if (opcode > MAX_OPCODE_VALUE) {
       throw new InvalidOpcodeError(
-        `Opcode ${opcode} (0x${opcode.toString(16)}) value is not in the range of valid opcodes.`,
+        `Opcode ${opcode} (0x${opcode.toString(16)}) value is not in the range of valid opcodes (at PC ${pc}).`,
       );
     }
 
@@ -192,13 +199,17 @@ export function decodeInstructionFromBytecode(
     }
 
     const instructionDeserializer: InstructionDeserializer = instructionDeserializerOrUndef;
+
     const instruction = instructionDeserializer(cursor);
     return [instruction, cursor.position() - startingPosition];
   } catch (error) {
-    if (error instanceof InvalidOpcodeError || error instanceof AvmExecutionError) {
-      throw error;
+    if (error instanceof InvalidTagValueError || error instanceof InvalidOpcodeError) {
+      throw duringInstrFetch(error, pc);
+    } else if (error instanceof AvmExecutionError) {
+      throw new AvmParsingError(`Instruction parsing error at pc ${pc}: ${error.message}`);
     } else {
-      throw new AvmParsingError(`${error}`);
+      const msg = error instanceof Error ? `: ${error.message}` : '';
+      throw new AvmParsingError(`Instruction fetching error at pc ${pc}${msg}`);
     }
   }
 }

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

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import { strict as assert } from 'assert';
 

package/src/public/avm/test_utils.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
 import type { jest } from '@jest/globals';

package/src/public/contracts_db_checkpoint.ts

@@ -0,0 +1,41 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+
+export class ContractsDbCheckpoint {
+  private instances: Map<string, ContractInstanceWithAddress> = new Map();
+  private classes: Map<string, ContractClassPublic> = new Map();
+  private bytecodeCommitments: Map<string, Fr> = new Map();
+
+  public addInstance(address: AztecAddress, instance: ContractInstanceWithAddress): void {
+    this.instances.set(address.toString(), instance);
+  }
+
+  public addClass(classId: Fr, contractClass: ContractClassPublic): void {
+    this.classes.set(classId.toString(), contractClass);
+  }
+
+  public addBytecodeCommitment(classId: Fr, commitment: Fr): void {
+    this.bytecodeCommitments.set(classId.toString(), commitment);
+  }
+
+  public getInstance(address: AztecAddress): ContractInstanceWithAddress | undefined {
+    return this.instances.get(address.toString());
+  }
+
+  public getClass(classId: Fr): ContractClassPublic | undefined {
+    return this.classes.get(classId.toString());
+  }
+
+  public getBytecodeCommitment(classId: Fr): Fr | undefined {
+    return this.bytecodeCommitments.get(classId.toString());
+  }
+
+  public deepCopy(): ContractsDbCheckpoint {
+    const copy = new ContractsDbCheckpoint();
+    this.instances.forEach((value, key) => copy.instances.set(key, value));
+    this.classes.forEach((value, key) => copy.classes.set(key, value));
+    this.bytecodeCommitments.forEach((value, key) => copy.bytecodeCommitments.set(key, value));
+    return copy;
+  }
+}

package/src/public/db_interfaces.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
@@ -58,4 +58,19 @@ export interface PublicContractsDBInterface {
    * @returns The name of the function or undefined if not found.
    */
   getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
+
+  /**
+   * Creates a checkpoint of the current contract state.
+   */
+  createCheckpoint(): void;
+
+  /**
+   * Commits the current checkpoint, merging its state with the parent.
+   */
+  commitCheckpoint(): void;
+
+  /**
+   * Reverts the current checkpoint, discarding its state.
+   */
+  revertCheckpoint(): void;
 }

package/src/public/debug_fn_name.ts

@@ -1,18 +1,52 @@
-import type { Fr } from '@aztec/foundation/fields';
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
+import type { CallData } from './avm/calldata.js';
 import type { PublicContractsDBInterface } from './db_interfaces.js';
 
 export async function getPublicFunctionDebugName(
   db: PublicContractsDBInterface,
   contractAddress: AztecAddress,
-  calldata: Fr[],
+  calldata: CallData,
 ): Promise<string> {
   // Public function is dispatched and therefore the target function is passed in the first argument.
-  if (!calldata[0]) {
+  const selectorField = calldata.read(0);
+  if (!selectorField) {
     return `<calldata[0] undefined> (Contract Address: ${contractAddress})`;
   }
-  const selector = FunctionSelector.fromField(calldata[0]);
-  return (await db.getDebugFunctionName(contractAddress, selector)) ?? selector.toString();
+  const fallbackName = `<calldata[0]:${selectorField.toString()}> (Contract Address: ${contractAddress})`;
+  const selector = FunctionSelector.fromFieldOrUndefined(selectorField);
+  if (!selector) {
+    return fallbackName;
+  }
+  return (await db.getDebugFunctionName(contractAddress, selector)) ?? fallbackName;
+}
+
+/**
+ * Get the function selector and optional debug name for a public function.
+ * Returns the selector and name separately, with name only populated if a debug name is available.
+ * @param db - The contracts database
+ * @param contractAddress - The contract address
+ * @param calldata - The calldata (selector is in calldata[0])
+ * @returns An object with functionSelector (always if calldata[0] exists) and functionName (only if debug name found)
+ */
+export async function getPublicFunctionSelectorAndName(
+  db: PublicContractsDBInterface,
+  contractAddress: AztecAddress,
+  calldata: CallData,
+): Promise<{ functionSelector?: FunctionSelector; functionName?: string }> {
+  // Public function is dispatched and therefore the target function is passed in the first argument.
+  const selectorField = calldata.read(0);
+  if (!selectorField) {
+    return {};
+  }
+  const selector = FunctionSelector.fromFieldOrUndefined(selectorField);
+  if (!selector) {
+    return {};
+  }
+  const debugName = await db.getDebugFunctionName(contractAddress, selector);
+  return {
+    functionSelector: selector,
+    functionName: debugName ?? undefined,
+  };
 }

package/src/public/executor_metrics.ts

@@ -1,4 +1,5 @@
 import type { RevertCode } from '@aztec/stdlib/avm';
+import type { GasUsed } from '@aztec/stdlib/gas';
 import {
   Attributes,
   type Histogram,
@@ -6,7 +7,6 @@ import {
   type TelemetryClient,
   type Tracer,
   type UpDownCounter,
-  ValueType,
 } from '@aztec/telemetry-client';
 
 import type { ExecutorMetricsInterface } from './executor_metrics_interface.js';
@@ -25,52 +25,26 @@ export class ExecutorMetrics implements ExecutorMetricsInterface {
     this.tracer = client.getTracer(name);
     const meter = client.getMeter(name);
 
-    this.fnCount = meter.createUpDownCounter(Metrics.PUBLIC_EXECUTOR_SIMULATION_COUNT, {
-      description: 'Number of functions executed',
-    });
+    this.fnCount = meter.createUpDownCounter(Metrics.PUBLIC_EXECUTOR_SIMULATION_COUNT);
 
-    this.fnDuration = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_DURATION, {
-      description: 'How long it takes to execute a function',
-      unit: 'ms',
-      valueType: ValueType.INT,
-    });
+    this.fnDuration = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_DURATION);
 
-    this.manaPerSecond = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_MANA_PER_SECOND, {
-      description: 'Mana used per second',
-      unit: 'mana/s',
-      valueType: ValueType.INT,
-    });
+    this.manaPerSecond = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_MANA_PER_SECOND);
 
-    this.manaUsed = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_MANA_USED, {
-      description: 'Total mana used',
-      unit: 'mana',
-      valueType: ValueType.INT,
-    });
+    this.manaUsed = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_MANA_USED);
 
-    this.totalInstructionsExecuted = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_TOTAL_INSTRUCTIONS, {
-      description: 'Total number of instructions executed',
-      unit: '#instructions',
-      valueType: ValueType.INT,
-    });
+    this.totalInstructionsExecuted = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_TOTAL_INSTRUCTIONS);
 
-    this.txHashing = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_TX_HASHING, {
-      description: 'Tx hashing time',
-      unit: 'ms',
-      valueType: ValueType.INT,
-    });
+    this.txHashing = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_TX_HASHING);
 
-    this.privateEffectsInsertions = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_PRIVATE_EFFECTS_INSERTION, {
-      description: 'Private effects insertion time',
-      unit: 'us',
-      valueType: ValueType.INT,
-    });
+    this.privateEffectsInsertions = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_PRIVATE_EFFECTS_INSERTION);
   }
 
   startRecordingTxSimulation(_txLabel: string) {
     // do nothing (unimplemented)
   }
 
-  stopRecordingTxSimulation(_txLabel: string, _revertedCode?: RevertCode) {
+  stopRecordingTxSimulation(_txLabel: string, _gasUsed?: GasUsed, _revertedCode?: RevertCode) {
     // do nothing (unimplemented)
   }
 

package/src/public/executor_metrics_interface.ts

@@ -1,8 +1,9 @@
 import type { RevertCode } from '@aztec/stdlib/avm';
+import type { GasUsed } from '@aztec/stdlib/gas';
 
 export interface ExecutorMetricsInterface {
   startRecordingTxSimulation(txLabel: string): void;
-  stopRecordingTxSimulation(txLabel: string, revertedCode?: RevertCode): void;
+  stopRecordingTxSimulation(txLabel: string, gasUsed?: GasUsed, revertedCode?: RevertCode): void;
   recordEnqueuedCallSimulation(fnName: string, durationMs: number, manaUsed: number, totalInstructions: number): void;
   recordEnqueuedCallSimulationFailure(
     fnName: string,

package/src/public/fixtures/amm_test.ts

@@ -1,6 +1,6 @@
 import { GeneratorIndex } from '@aztec/constants';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Logger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import type { ContractArtifact } from '@aztec/stdlib/abi';

package/src/public/fixtures/bulk_test.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Logger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import type { ContractArtifact } from '@aztec/stdlib/abi';
@@ -118,10 +118,10 @@ export async function megaBulkTest(
   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 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,
@@ -144,10 +144,10 @@ export async function megaBulkTest(
       { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField2) },
       { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField3) },
       { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField4) },
-      { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField5) },
-      { 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(argsField5) },
+      //{ 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) },
     ],
     /*teardownCall=*/ undefined,
     /*feePayer*/ undefined,

package/src/public/fixtures/custom_bytecode_tester.ts

@@ -1,49 +1,83 @@
 import { FunctionType, emptyContractArtifact, emptyFunctionArtifact } from '@aztec/stdlib/abi';
+import type { PublicTxResult } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
-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.
+ * Deploy a contract 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')
+ * @param tester - The tester to use
+ * @param contractName - The name of the contract
+ * @param deployer - The deployer address
+ * @returns The deployed contract instance
  */
-export async function testCustomBytecode(
+export async function deployCustomBytecode(
   bytecode: Buffer,
   tester: PublicTxSimulationTester,
-  txLabel: string,
   contractName: string = 'CustomBytecodeContract',
-): Promise<PublicTxResult> {
-  const deployer = AztecAddress.fromNumber(42);
-
+  deployer: AztecAddress = AztecAddress.fromNumber(42),
+): Promise<ContractInstanceWithAddress> {
   const contractArtifact = emptyContractArtifact();
   contractArtifact.name = contractName;
   contractArtifact.functions = [emptyFunctionArtifact()];
+  // We use name 'public_dispatch' since that is what is expected
+  // in a ContractArtifact. But function selectors are not required
+  // when executing since the custom bytecode likely has no dispatch.
   contractArtifact.functions[0].name = 'public_dispatch';
   contractArtifact.functions[0].functionType = FunctionType.PUBLIC;
   contractArtifact.functions[0].bytecode = bytecode;
 
-  const testContract = await tester.registerAndDeployContract(
+  // return the contract instance
+  return await tester.registerAndDeployContract(
     /*constructorArgs=*/ [],
     deployer,
     /*contractArtifact=*/ contractArtifact,
   );
+}
 
+/**
+ * Execute a custom bytecode contract.
+ * @param contract - The contract instance to execute
+ * @param tester - The tester to use
+ * @param txLabel - The label of the transaction
+ * @param calldata - The calldata to use
+ * @returns The execution result
+ */
+export async function executeCustomBytecode(
+  contract: ContractInstanceWithAddress,
+  tester: PublicTxSimulationTester,
+  txLabel: string = 'CustomBytecodeTest',
+  calldata: any[] = [],
+): Promise<PublicTxResult> {
   // EXECUTE! This means that if using AvmProvingTester subclass, it will PROVE the transaction!
   return await tester.executeTxWithLabel(
     /*txLabel=*/ txLabel,
-    /*sender=*/ deployer,
+    /*sender=*/ contract.deployer,
     /*setupCalls=*/ [],
-    /*appCalls=*/ [
-      {
-        address: testContract.address,
-        fnName: 'public_dispatch',
-        args: [],
-      },
-    ],
+    /*appCalls=*/ [{ address: contract.address, args: calldata }],
   );
 }
+
+/**
+ * Deploy and execute a custom bytecode contract.
+ * @param bytecode - The bytecode buffer to use
+ * @param tester - The tester to use
+ * @param txLabel - The label of the transaction
+ * @param contractName - The name of the contract
+ * @param deployer - The deployer address
+ * @param calldata - The calldata to use
+ * @returns The execution result
+ */
+export async function deployAndExecuteCustomBytecode(
+  bytecode: Buffer,
+  tester: PublicTxSimulationTester,
+  txLabel: string = 'CustomBytecodeTest',
+  contractName: string = 'CustomBytecodeContract',
+  deployer: AztecAddress = AztecAddress.fromNumber(42),
+  calldata: any[] = [],
+): Promise<PublicTxResult> {
+  const testContract = await deployCustomBytecode(bytecode, tester, contractName, deployer);
+  return await executeCustomBytecode(testContract, tester, txLabel, calldata);
+}