feat: merge-train/avm (#19040)

See
[merge-train-readme.md](https://github.com/AztecProtocol/aztec-packages/blob/next/.github/workflows/merge-train-readme.md).
This is a merge-train.

Author: AztecBot

barretenberg/cpp/src/barretenberg/vm2/testing/minimal_tx.testdata.bin

@@ -0,0 +1,69 @@
+import { createLogger } from '@aztec/foundation/log';
+import {
+  TestExecutorMetrics,
+  defaultGlobals,
+  getSpamConfigsPerOpcode,
+  testOpcodeSpamCase,
+} from '@aztec/simulator/public/fixtures';
+import { NativeWorldStateService } from '@aztec/world-state';
+
+import { mkdirSync, writeFileSync } from 'fs';
+import path from 'path';
+
+import { AvmProvingTester } from './avm_proving_tester.js';
+
+// NOTE: this test is meant to be run locally for measurements or via bb-prover/bootstrap.sh.
+// Set RUN_AVM_OPCODE_SPAM=1 to enable.
+const describeOrSkip = process.env.RUN_AVM_OPCODE_SPAM ? describe : describe.skip;
+
+describeOrSkip('AVM Opcode Spammer Proving Benchmarks', () => {
+  const logger = createLogger('avm-opcode-spam-proving');
+
+  // Get test cases from the spammer config (grouped by opcode)
+  // Limit to 2 configs per opcode otherwise this suite will take hours
+  const groupedSpamConfigs = getSpamConfigsPerOpcode(/*maxConfigsPerOpcode=*/ 2);
+
+  // Shared metrics instance for benchmark collection
+  const metrics = new TestExecutorMetrics();
+  // Full proving only (no check-circuit mode)
+  let worldStateService: NativeWorldStateService;
+  let tester: AvmProvingTester;
+
+  afterAll(() => {
+    if (process.env.BENCH_OUTPUT) {
+      mkdirSync(path.dirname(process.env.BENCH_OUTPUT), { recursive: true });
+      writeFileSync(process.env.BENCH_OUTPUT, metrics.toGithubActionBenchmarkJSON());
+    } else if (process.env.BENCH_OUTPUT_MD) {
+      writeFileSync(process.env.BENCH_OUTPUT_MD, metrics.toPrettyString());
+    } else {
+      logger.info(`\n`);
+      logger.info(metrics.toPrettyString());
+    }
+  });
+
+  beforeEach(async () => {
+    worldStateService = await NativeWorldStateService.tmp();
+    // FULL PROVING! Not check-circuit.
+    tester = await AvmProvingTester.new(
+      worldStateService,
+      /*checkCircuitOnly=*/ false,
+      /*globals=*/ defaultGlobals(),
+      metrics,
+    );
+    tester.setMetricsPrefix(`FullProving Opcode Spam`);
+  });
+
+  afterEach(async () => {
+    await worldStateService.close();
+  });
+
+  describe.each(groupedSpamConfigs)('$opcode', ({ configs }) => {
+    it.each(configs)(
+      '$label',
+      async config => {
+        await testOpcodeSpamCase(tester, config);
+      },
+      600_000,
+    );
+  });
+});

yarn-project/bb-prover/src/avm_proving_tests/avm_opcode_spam.test.ts

@@ -5,7 +5,7 @@ import { createLogger } from '@aztec/foundation/log';
 import { mapAvmCircuitPublicInputsToNoir } from '@aztec/noir-protocol-circuits-types/server';
 import { AvmTestContractArtifact } from '@aztec/noir-test-contracts.js/AvmTest';
 import { PublicTxSimulationTester, bulkTest, executeAvmMinimalPublicTx } from '@aztec/simulator/public/fixtures';
-import { AvmCircuitInputs } from '@aztec/stdlib/avm';
+import { AvmCircuitInputs, PublicSimulatorConfig } from '@aztec/stdlib/avm';
 import { RecursiveProof } from '@aztec/stdlib/proofs';
 import { VerificationKeyAsFields } from '@aztec/stdlib/vks';
 import { NativeWorldStateService } from '@aztec/world-state/native';
@@ -34,6 +34,15 @@ jest.setTimeout(120_000);
 
 const logger = createLogger('ivc-integration:test:avm-integration');
 
+const simConfig: PublicSimulatorConfig = PublicSimulatorConfig.from({
+  skipFeeEnforcement: false,
+  collectCallMetadata: true, // For results.
+  collectDebugLogs: false,
+  collectHints: true, // Required for proving!
+  collectPublicInputs: true, // Required for proving!
+  collectStatistics: false,
+});
+
 async function proveMockPublicBaseRollup(
   avmCircuitInputs: AvmCircuitInputs,
   bbWorkingDirectory: string,
@@ -107,7 +116,13 @@ describe('AVM Integration', () => {
     bbWorkingDirectory = await getWorkingDirectory('bb-avm-integration-');
 
     worldStateService = await NativeWorldStateService.tmp();
-    simTester = await PublicTxSimulationTester.create(worldStateService);
+    simTester = await PublicTxSimulationTester.create(
+      worldStateService,
+      /*globals=*/ undefined, // default
+      /*metrics=*/ undefined,
+      /*useCppSimulator=*/ true,
+      simConfig,
+    );
   });
 
   afterEach(async () => {

yarn-project/ivc-integration/src/avm_integration.test.ts

@@ -5,7 +5,7 @@ import { createLogger } from '@aztec/foundation/log';
 import { mapAvmCircuitPublicInputsToNoir } from '@aztec/noir-protocol-circuits-types/server';
 import { AvmTestContractArtifact } from '@aztec/noir-test-contracts.js/AvmTest';
 import { PublicTxSimulationTester, bulkTest } from '@aztec/simulator/public/fixtures';
-import { AvmCircuitInputs, AvmCircuitPublicInputs } from '@aztec/stdlib/avm';
+import { AvmCircuitInputs, AvmCircuitPublicInputs, PublicSimulatorConfig } from '@aztec/stdlib/avm';
 import { RecursiveProof } from '@aztec/stdlib/proofs';
 import { VerificationKeyAsFields } from '@aztec/stdlib/vks';
 import { NativeWorldStateService } from '@aztec/world-state/native';
@@ -38,6 +38,15 @@ jest.setTimeout(150_000);
 
 const logger = createLogger('ivc-integration:test:rollup-native');
 
+const simConfig: PublicSimulatorConfig = PublicSimulatorConfig.from({
+  skipFeeEnforcement: false,
+  collectCallMetadata: true, // For results.
+  collectDebugLogs: false,
+  collectHints: true, // Required for proving!
+  collectPublicInputs: true, // Required for proving!
+  collectStatistics: false,
+});
+
 describe('Rollup IVC Integration', () => {
   let bbBinaryPath: string;
 
@@ -72,7 +81,13 @@ describe('Rollup IVC Integration', () => {
     const avmWorkingDirectory = await getWorkingDirectory('bb-rollup-ivc-integration-avm-');
 
     const worldStateService = await NativeWorldStateService.tmp();
-    const simTester = await PublicTxSimulationTester.create(worldStateService);
+    const simTester = await PublicTxSimulationTester.create(
+      worldStateService,
+      /*globals=*/ undefined, // default
+      /*metrics=*/ undefined,
+      /*useCppSimulator=*/ true,
+      simConfig,
+    );
     const avmSimulationResult = await bulkTest(simTester, logger, AvmTestContractArtifact);
     await worldStateService.close();
     expect(avmSimulationResult.revertCode.isOK()).toBe(true);

yarn-project/ivc-integration/src/rollup_ivc_integration.test.ts

@@ -11,7 +11,7 @@
       "gasFees": { "feePerDaGas": "2", "feePerL2Gas": "3" }
     },
     "tx": {
-      "hash": "0x02440a894870f8078ce6065f76c2f598e2f3df9719f1a78038057c20eb096516",
+      "hash": "0x0fe93625c73eb2fd8131834fac90f24341cc1b87bdfa9c09f7f61c7f5f943bc5",
       "gasSettings": {
         "gasLimits": { "daGas": 12582912, "l2Gas": 6000000 },
         "teardownGasLimits": { "daGas": 0, "l2Gas": 0 },
@@ -34,9 +34,9 @@
             "msgSender": "0x000000000000000000000000000000000000000000000000000000000000002a",
             "contractAddress": "0x03deefb26b3b88ef515e0ce5bd1402ea3a7c12569597cddb19ce6260444d625f",
             "isStaticCall": false,
-            "calldataHash": "0x210b9efa10b8e4522089aa9b227e18fb47dbf4c9a53b37225416d7900600be65"
+            "calldataHash": "0x0d11f0bac132909f8a77a45be32a0dfad89702d957f3f1963b790545be3f966c"
           },
-          "calldata": ["0x000000000000000000000000000000000000000000000000000000000d6ab3ae"]
+          "calldata": []
         }
       ],
       "teardownEnqueuedCall": null,
@@ -856,7 +856,7 @@
         "msgSender": "0x000000000000000000000000000000000000000000000000000000000000002a",
         "contractAddress": "0x03deefb26b3b88ef515e0ce5bd1402ea3a7c12569597cddb19ce6260444d625f",
         "isStaticCall": false,
-        "calldataHash": "0x210b9efa10b8e4522089aa9b227e18fb47dbf4c9a53b37225416d7900600be65"
+        "calldataHash": "0x0d11f0bac132909f8a77a45be32a0dfad89702d957f3f1963b790545be3f966c"
       },
       {
         "msgSender": "0x0000000000000000000000000000000000000000000000000000000000000000",

yarn-project/simulator/artifacts/avm_minimal_inputs.json

@@ -416,7 +416,7 @@ const TAG_FOR_MEM_VAL = new Map<string, TypeTag>([
   ['Uint128', TypeTag.UINT128],
 ]);
 
-const VALID_TAGS = new Set([
+export const VALID_TAGS = new Set([
   TypeTag.FIELD,
   TypeTag.UINT1,
   TypeTag.UINT8,
@@ -426,7 +426,7 @@ const VALID_TAGS = new Set([
   TypeTag.UINT128,
 ]);
 
-const INTEGRAL_TAGS = new Set([
+export const INTEGRAL_TAGS = new Set([
   TypeTag.UINT1,
   TypeTag.UINT8,
   TypeTag.UINT16,

yarn-project/simulator/src/public/avm/avm_memory_types.ts

@@ -13,8 +13,12 @@ export async function getPublicFunctionDebugName(
   if (!calldata[0]) {
     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]:${calldata[0].toString()}> (Contract Address: ${contractAddress})`;
+  const selector = FunctionSelector.fromFieldOrUndefined(calldata[0]);
+  if (!selector) {
+    return fallbackName;
+  }
+  return (await db.getDebugFunctionName(contractAddress, selector)) ?? fallbackName;
 }
 
 /**
@@ -34,7 +38,10 @@ export async function getPublicFunctionSelectorAndName(
   if (!calldata[0]) {
     return {};
   }
-  const selector = FunctionSelector.fromField(calldata[0]);
+  const selector = FunctionSelector.fromFieldOrUndefined(calldata[0]);
+  if (!selector) {
+    return {};
+  }
   const debugName = await db.getDebugFunctionName(contractAddress, selector);
   return {
     functionSelector: selector,

yarn-project/simulator/src/public/debug_fn_name.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 { 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);
+}