@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/src/public/debug_fn_name.ts

@@ -0,0 +1,52 @@
+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: CallData,
+): Promise<string> {
+  // Public function is dispatched and therefore the target function is passed in the first argument.
+  const selectorField = calldata.read(0);
+  if (!selectorField) {
+    return `<calldata[0] undefined> (Contract Address: ${contractAddress})`;
+  }
+  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,3 +1,5 @@
+import type { RevertCode } from '@aztec/stdlib/avm';
+import type { GasUsed } from '@aztec/stdlib/gas';
 import {
   Attributes,
   type Histogram,
@@ -5,50 +7,69 @@ import {
   type TelemetryClient,
   type Tracer,
   type UpDownCounter,
-  ValueType,
+  createUpDownCounterWithDefault,
 } from '@aztec/telemetry-client';
 
-export class ExecutorMetrics {
+import type { ExecutorMetricsInterface } from './executor_metrics_interface.js';
+
+export class ExecutorMetrics implements ExecutorMetricsInterface {
   public readonly tracer: Tracer;
   private fnCount: UpDownCounter;
   private fnDuration: Histogram;
   private manaPerSecond: Histogram;
+  private manaUsed: Histogram;
+  private totalInstructionsExecuted: Histogram;
+  private txHashing: Histogram;
   private privateEffectsInsertions: Histogram;
 
   constructor(client: TelemetryClient, name = 'PublicExecutor') {
     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 = createUpDownCounterWithDefault(meter, Metrics.PUBLIC_EXECUTOR_SIMULATION_COUNT, {
+      [Attributes.OK]: [true, false],
     });
 
-    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.privateEffectsInsertions = meter.createHistogram(Metrics.PUBLIC_EXECUTION_PRIVATE_EFFECTS_INSERTION, {
-      description: 'Private effects insertion time',
-      unit: 'us',
-      valueType: ValueType.INT,
-    });
+    this.manaUsed = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_MANA_USED);
+
+    this.totalInstructionsExecuted = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_TOTAL_INSTRUCTIONS);
+
+    this.txHashing = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_TX_HASHING);
+
+    this.privateEffectsInsertions = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_PRIVATE_EFFECTS_INSERTION);
+  }
+
+  startRecordingTxSimulation(_txLabel: string) {
+    // do nothing (unimplemented)
   }
 
-  recordFunctionSimulation(durationMs: number, manaUsed: number, fnName: string) {
+  stopRecordingTxSimulation(_txLabel: string, _gasUsed?: GasUsed, _revertedCode?: RevertCode) {
+    // do nothing (unimplemented)
+  }
+
+  recordEnqueuedCallSimulation(
+    fnName: string,
+    durationMs: number,
+    manaUsed: number,
+    totalInstructionsExecuted: number,
+  ) {
     this.fnCount.add(1, {
       [Attributes.OK]: true,
       [Attributes.APP_CIRCUIT_NAME]: fnName,
-      [Attributes.MANA_USED]: manaUsed,
     });
-    this.fnDuration.record(Math.ceil(durationMs));
+    this.manaUsed.record(Math.ceil(manaUsed), {
+      [Attributes.APP_CIRCUIT_NAME]: fnName,
+    });
+    this.totalInstructionsExecuted.record(Math.ceil(totalInstructionsExecuted), {
+      [Attributes.APP_CIRCUIT_NAME]: fnName,
+    });
+    this.fnDuration.record(Math.ceil(durationMs), {
+      [Attributes.APP_CIRCUIT_NAME]: fnName,
+    });
     if (durationMs > 0 && manaUsed > 0) {
       const manaPerSecond = Math.round((manaUsed * 1000) / durationMs);
       this.manaPerSecond.record(manaPerSecond, {
@@ -57,7 +78,12 @@ export class ExecutorMetrics {
     }
   }
 
-  recordFunctionSimulationFailure() {
+  recordEnqueuedCallSimulationFailure(
+    _fnName: string,
+    _durationMs: number,
+    _manaUsed: number,
+    _totalInstructionsExecuted: number,
+  ) {
     this.fnCount.add(1, {
       [Attributes.OK]: false,
     });

package/src/public/executor_metrics_interface.ts

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

package/src/public/fixtures/amm_test.ts

@@ -0,0 +1,331 @@
+import { GeneratorIndex } from '@aztec/constants';
+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';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+
+import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+import { setUpToken } from './token_test.js';
+
+const INITIAL_TOKEN_BALANCE = 1_000_000_000n;
+/**
+ * THIS TEST IS BRITTLE! If it breaks, don't try fixing it.
+ * `.skip` it or literally just delete it and notify AVM team.
+ * You do NOT need permission to remove this test!
+ */
+export async function ammTest(
+  tester: PublicTxSimulationTester,
+  logger: Logger,
+  tokenArtifact: ContractArtifact,
+  ammArtifact: ContractArtifact,
+  expectToBeTrue: (x: boolean) => void,
+) {
+  const timer = new Timer();
+
+  const admin = AztecAddress.fromNumber(42);
+  const sender = AztecAddress.fromNumber(111);
+
+  logger.debug(`Deploying tokens`);
+  const token0 = await setUpToken(tester, tokenArtifact, admin, expectToBeTrue, /*seed=*/ 0);
+  const token1 = await setUpToken(tester, tokenArtifact, admin, expectToBeTrue, /*seed=*/ 1);
+  const liquidityToken = await setUpToken(tester, tokenArtifact, admin, expectToBeTrue, /*seed=*/ 2);
+  logger.debug(`Deploying AMM`);
+  const constructorArgs = [token0, token1, liquidityToken];
+  const amm = await tester.registerAndDeployContract(
+    constructorArgs,
+    /*deployer=*/ admin,
+    ammArtifact,
+    /*skipNullifierInsertion=*/ false,
+    /*seed=*/ 3,
+  );
+
+  // EXECUTE! This means that if using AvmProvingTester subclass, it will PROVE the transaction!
+  const ammConstructorResult = await tester.executeTxWithLabel(
+    /*txLabel=*/ 'AMM/constructor',
+    /*sender=*/ admin,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        fnName: 'constructor',
+        args: constructorArgs,
+        address: amm.address,
+      },
+    ],
+  );
+  expectToBeTrue(ammConstructorResult.revertCode.isOK());
+
+  logger.debug(`Setting AMM as minter for liquidity token`);
+
+  // set the AMM as the minter for the liquidity token
+  // EXECUTE! This means that if using AvmProvingTester subclass, it will PROVE the transaction!
+  const setMinterResult = await tester.executeTxWithLabel(
+    /*txLabel=*/ 'AMM/set_minter',
+    /*sender=*/ admin,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        fnName: 'set_minter',
+        args: [/*minter=*/ amm, /*approve=*/ true],
+        address: liquidityToken.address,
+      },
+    ],
+  );
+  expectToBeTrue(setMinterResult.revertCode.isOK());
+
+  logger.debug(`Adding liquidity`);
+  const amount0Max = (INITIAL_TOKEN_BALANCE * 6n) / 10n;
+  const amount0Min = (INITIAL_TOKEN_BALANCE * 4n) / 10n;
+  const amount1Max = (INITIAL_TOKEN_BALANCE * 5n) / 10n;
+  const amount1Min = (INITIAL_TOKEN_BALANCE * 4n) / 10n;
+
+  const addLiquidityResult = await addLiquidity(
+    tester,
+    sender,
+    /*amm=*/ amm,
+    /*token0=*/ token0,
+    /*token1=*/ token1,
+    /*liquidityToken=*/ liquidityToken,
+    /*amount0Max=*/ amount0Max,
+    /*amount1Max=*/ amount1Max,
+    /*amount0Min=*/ amount0Min,
+    /*amount1Min=*/ amount1Min,
+  );
+  expectToBeTrue(addLiquidityResult.revertCode.isOK());
+
+  logger.debug(`Swapping tokens`);
+  const swapResult = await swapExactTokensForTokens(
+    tester,
+    sender,
+    /*amm=*/ amm,
+    /*tokenIn=*/ token0,
+    /*tokenOut=*/ token1,
+    /*amountIn=*/ amount0Min / 10n, // something smaller than total liquidity
+    /*amountOutMin=*/ amount1Min / 100n, // something even smaller
+  );
+  expectToBeTrue(swapResult.revertCode.isOK());
+
+  logger.debug(`Removing liquidity`);
+  const removeLiquidityResult = await removeLiquidity(
+    tester,
+    sender,
+    /*amm=*/ amm,
+    /*token0=*/ token0,
+    /*token1=*/ token1,
+    /*liquidityToken=*/ liquidityToken,
+    /*liquidity=*/ 100n,
+    /*amount0Min=*/ 1n, // remove some tiny amount
+    /*amount1Min=*/ 1n,
+  );
+  expectToBeTrue(removeLiquidityResult.revertCode.isOK());
+
+  logger.info(`AMM public tx simulator test took ${timer.ms()}ms\n`);
+}
+
+async function addLiquidity(
+  tester: PublicTxSimulationTester,
+  sender: AztecAddress,
+  amm: ContractInstanceWithAddress,
+  token0: ContractInstanceWithAddress,
+  token1: ContractInstanceWithAddress,
+  liquidityToken: ContractInstanceWithAddress,
+  amount0Max: bigint,
+  amount1Max: bigint,
+  amount0Min: bigint,
+  amount1Min: bigint,
+  _nonce?: bigint,
+) {
+  const refundToken0PartialNote = {
+    commitment: new Fr(42),
+  };
+  const refundToken1PartialNote = {
+    commitment: new Fr(66),
+  };
+  const liquidityPartialNote = {
+    commitment: new Fr(99),
+  };
+  const refundToken0PartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
+    refundToken0PartialNote,
+    amm.address,
+  );
+  const refundToken1PartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
+    refundToken1PartialNote,
+    amm.address,
+  );
+  const liquidityPartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
+    liquidityPartialNote,
+    amm.address,
+  );
+
+  // We need to inject the validity commitments into the nullifier tree as that would be performed by the private token
+  // functions that are not invoked in this test.
+  await tester.insertNullifier(token0.address, refundToken0PartialNoteValidityCommitment);
+  await tester.insertNullifier(token1.address, refundToken1PartialNoteValidityCommitment);
+  await tester.insertNullifier(liquidityToken.address, liquidityPartialNoteValidityCommitment);
+
+  // EXECUTE! This means that if using AvmProvingTester subclass, it will PROVE the transaction!
+  return await tester.executeTxWithLabel(
+    /*txLabel=*/ 'AMM/add_liquidity',
+    /*sender=*/ sender,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      // token0.transfer_to_public enqueues a call to _increase_public_balance
+      {
+        sender: token0.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_increase_public_balance',
+        args: [/*to=*/ amm.address, /*amount=*/ amount0Max],
+        address: token0.address,
+      },
+      // token1.transfer_to_public enqueues a call to _increase_public_balance
+      {
+        sender: token1.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_increase_public_balance',
+        args: [/*to=*/ amm.address, /*amount=*/ amount1Max],
+        address: token1.address,
+      },
+      // amm.add_liquidity enqueues a call to _add_liquidity
+      {
+        sender: amm.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_add_liquidity',
+        args: [
+          /*config=*/ {
+            token0: token0.address,
+            token1: token1.address,
+            // eslint-disable-next-line camelcase
+            liquidity_token: liquidityToken.address,
+          },
+          refundToken0PartialNote,
+          refundToken1PartialNote,
+          liquidityPartialNote,
+          amount0Max,
+          amount1Max,
+          amount0Min,
+          amount1Min,
+        ],
+        address: amm.address,
+      },
+    ],
+  );
+}
+
+async function swapExactTokensForTokens(
+  tester: PublicTxSimulationTester,
+  sender: AztecAddress,
+  amm: ContractInstanceWithAddress,
+  tokenIn: ContractInstanceWithAddress,
+  tokenOut: ContractInstanceWithAddress,
+  amountIn: bigint,
+  amountOutMin: bigint,
+  _nonce?: bigint,
+) {
+  const tokenOutPartialNote = {
+    commitment: new Fr(166),
+  };
+  const tokenOutPartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
+    tokenOutPartialNote,
+    amm.address,
+  );
+
+  // We need to inject the validity commitment into the nullifier tree as that would be performed by the private token
+  // function that is not invoked in this test.
+  await tester.insertNullifier(tokenOut.address, tokenOutPartialNoteValidityCommitment);
+
+  // EXECUTE! This means that if using AvmProvingTester subclass, it will PROVE the transaction!
+  return await tester.executeTxWithLabel(
+    /*txLabel=*/ 'AMM/swap_exact_tokens_for_tokens',
+    /*sender=*/ sender,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      // tokenIn.transfer_to_public enqueues a call to _increase_public_balance
+      {
+        sender: tokenIn.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_increase_public_balance',
+        args: [/*to=*/ amm.address, /*amount=*/ amountIn],
+        address: tokenIn.address,
+      },
+      {
+        sender: amm.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_swap_exact_tokens_for_tokens',
+        args: [tokenIn.address, tokenOut.address, amountIn, amountOutMin, tokenOutPartialNote],
+        address: amm.address,
+      },
+    ],
+  );
+}
+
+async function removeLiquidity(
+  tester: PublicTxSimulationTester,
+  sender: AztecAddress,
+  amm: ContractInstanceWithAddress,
+  token0: ContractInstanceWithAddress,
+  token1: ContractInstanceWithAddress,
+  liquidityToken: ContractInstanceWithAddress,
+  liquidity: bigint,
+  amount0Min: bigint,
+  amount1Min: bigint,
+  _nonce?: bigint,
+) {
+  const token0PartialNote = {
+    commitment: new Fr(111),
+  };
+  const token1PartialNote = {
+    commitment: new Fr(222),
+  };
+  const token0PartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
+    token0PartialNote,
+    amm.address,
+  );
+  const token1PartialNoteValidityCommitment = await computePartialNoteValidityCommitment(
+    token1PartialNote,
+    amm.address,
+  );
+
+  // We need to inject the validity commitments into the nullifier tree as that would be performed by the private token
+  // functions that are not invoked in this test.
+  await tester.insertNullifier(token0.address, token0PartialNoteValidityCommitment);
+  await tester.insertNullifier(token1.address, token1PartialNoteValidityCommitment);
+
+  // EXECUTE! This means that if using AvmProvingTester subclass, it will PROVE the transaction!
+  return await tester.executeTxWithLabel(
+    /*txLabel=*/ 'AMM/remove_liquidity',
+    /*sender=*/ sender,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      // liquidityToken.transfer_to_public enqueues a call to _increase_public_balance
+      {
+        sender: liquidityToken.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_increase_public_balance',
+        args: [/*to=*/ amm.address, /*amount=*/ liquidity],
+        address: liquidityToken.address,
+      },
+      // amm.remove_liquidity enqueues a call to _remove_liquidity
+      {
+        sender: amm.address, // INTERNAL FUNCTION! Sender must be 'this'.
+        fnName: '_remove_liquidity',
+        args: [
+          /*config=*/ {
+            token0: token0.address,
+            token1: token1.address,
+            // eslint-disable-next-line camelcase
+            liquidity_token: liquidityToken.address,
+          },
+          liquidity,
+          token0PartialNote,
+          token1PartialNote,
+          amount0Min,
+          amount1Min,
+        ],
+        address: amm.address,
+      },
+    ],
+  );
+}
+
+async function computePartialNoteValidityCommitment(partialNote: { commitment: Fr }, completer: AztecAddress) {
+  return await poseidon2HashWithSeparator(
+    [partialNote.commitment, completer],
+    GeneratorIndex.PARTIAL_NOTE_VALIDITY_COMMITMENT,
+  );
+}

package/src/public/fixtures/bulk_test.ts

@@ -0,0 +1,169 @@
+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';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+
+export async function bulkTest(
+  tester: PublicTxSimulationTester,
+  logger: Logger,
+  avmTestContractArtifact: ContractArtifact,
+) {
+  const timer = new Timer();
+
+  const deployer = AztecAddress.fromNumber(42);
+  const avmTestContract = await tester.registerAndDeployContract(
+    /*constructorArgs=*/ [],
+    deployer,
+    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].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,
+    /*getInstanceForAddress=*/ expectContractInstance.address,
+    /*expectedDeployer=*/ expectContractInstance.deployer,
+    /*expectedClassId=*/ expectContractInstance.currentContractClassId,
+    /*expectedInitializationHash=*/ expectContractInstance.initializationHash,
+    /*skip_strictly_limited_side_effects=*/ false,
+  ];
+
+  const bulkResult = await tester.executeTxWithLabel(
+    /*txLabel=*/ 'AvmTest/bulk_testing',
+    /*sender=*/ deployer,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        address: avmTestContract.address,
+        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,
+    /*privateInsertions=*/ {
+      nonRevertible: {
+        nullifiers: [new Fr(420000)],
+        noteHashes: [new Fr(420001)],
+      },
+      revertible: {
+        nullifiers: [new Fr(420002)],
+        noteHashes: [new Fr(420003)],
+      },
+    },
+  );
+
+  logger.info(`Bulk test took ${timer.ms()}ms\n`);
+
+  return bulkResult;
+}
+
+export async function megaBulkTest(
+  tester: PublicTxSimulationTester,
+  logger: Logger,
+  avmTestContractArtifact: ContractArtifact,
+) {
+  const timer = new Timer();
+
+  const deployer = AztecAddress.fromNumber(42);
+  const avmTestContract = await tester.registerAndDeployContract(
+    /*constructorArgs=*/ [],
+    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 = [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,
+    argsU8,
+    /*getInstanceForAddress=*/ expectContractInstance.address.toField(),
+    /*expectedDeployer=*/ expectContractInstance.deployer.toField(),
+    /*expectedClassId=*/ expectContractInstance.currentContractClassId.toField(),
+    /*expectedInitializationHash=*/ expectContractInstance.initializationHash.toField(),
+    // Must skip strictly limited side effects (logs, messages) so we can spam the bulk test several times.
+    /*skip_strictly_limited_side_effects=*/ true,
+  ];
+
+  const bulkResult = await tester.executeTxWithLabel(
+    /*txLabel=*/ 'AvmTest/mega_bulk_testing',
+    /*sender=*/ deployer,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField0) },
+      { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField1) },
+      { 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) },
+    ],
+    /*teardownCall=*/ undefined,
+    /*feePayer*/ undefined,
+    /*privateInsertions=*/ {
+      nonRevertible: {
+        nullifiers: [new Fr(420000)],
+        noteHashes: [new Fr(420001)],
+      },
+      revertible: {
+        nullifiers: [new Fr(420002)],
+        noteHashes: [new Fr(420003)],
+      },
+    },
+  );
+
+  logger.info(`Mega bulk test took ${timer.ms()}ms\n`);
+
+  return bulkResult;
+}