feat: merge-train/avm (#20604)

BEGIN_COMMIT_OVERRIDE
test: fix and unskip block building tests "processes txs until hitting
timetable" and "can call public function from different tx in same block
as deployed" (#19252)
feat: add public bytecode sizes to benchmarks dashboard (#20704)
feat(avm): enable proving during fuzzing (#20523)
END_COMMIT_OVERRIDE

Author: AztecBot

barretenberg/cpp/src/barretenberg/avm_fuzzer/fuzzer_lib.cpp

@@ -221,6 +221,11 @@ TxSimulationResult fuzz_prover(FuzzerWorldStateManager& ws_mgr, FuzzerContractDB
     bool check_circuit_result = avm_api.check_circuit(proving_inputs);
     BB_ASSERT(check_circuit_result,
               "check_circuit returned false in fuzzer with no exception, this indicates a failure");
+
+    // 6. Prove and verify
+    auto proof = avm_api.prove(proving_inputs);
+    bool verified = avm_api.verify(proof, proving_inputs.public_inputs);
+    BB_ASSERT(verified, "Proof verification failed");
 #else
     // In coverage builds, run simulate_for_witgen and tracegen instead of check_circuit
     // This gives us coverage the the event and tracegen code paths without the overhead of check_circuit

barretenberg/cpp/src/barretenberg/avm_fuzzer/fuzzer_lib.hpp

@@ -102,7 +102,7 @@ SimulatorResult fuzz_tx(bb::avm2::fuzzer::FuzzerWorldStateManager& ws_mgr,
                         bb::avm2::fuzzer::FuzzerContractDB& contract_db,
                         FuzzerTxData& tx_data);
 
-// Run the prover fuzzer: fast simulation, hint collection, comparison, and check_circuit
+// Run the prover fuzzer: fast simulation, hint collection, comparison, check_circuit, prove, and verify
 // Returns simulation result on success, throws if the input should be rejected
 TxSimulationResult fuzz_prover(bb::avm2::fuzzer::FuzzerWorldStateManager& ws_mgr,
                                bb::avm2::fuzzer::FuzzerContractDB& contract_db,

barretenberg/cpp/src/barretenberg/avm_fuzzer/prover.fuzzer.cpp

@@ -99,6 +99,7 @@ extern "C" int LLVMFuzzerInitialize(int*, char***)
     memset(l2_to_l1_msgs_counter, 0, sizeof(l2_to_l1_msgs_counter));
     memset(public_logs_counter, 0, sizeof(public_logs_counter));
 
+    bb::srs::init_file_crs_factory(bb::srs::bb_crs_path());
     FuzzerWorldStateManager::initialize();
     return 0;
 }

yarn-project/end-to-end/src/e2e_block_building.test.ts

@@ -15,7 +15,9 @@ import { StatefulTestContract } from '@aztec/noir-test-contracts.js/StatefulTest
 import { TestContract } from '@aztec/noir-test-contracts.js/Test';
 import type { SequencerClient } from '@aztec/sequencer-client';
 import type { TestSequencerClient } from '@aztec/sequencer-client/test';
+import { getAllFunctionAbis } from '@aztec/stdlib/abi';
 import { getProofSubmissionDeadlineEpoch } from '@aztec/stdlib/epoch-helpers';
+import { GasFees } from '@aztec/stdlib/gas';
 import { computeSiloedPrivateLogFirstField } from '@aztec/stdlib/hash';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import { TX_ERROR_EXISTING_NULLIFIER } from '@aztec/stdlib/tx';
@@ -72,36 +74,53 @@ describe('e2e_block_building', () => {
     });
 
     afterEach(async () => {
-      await aztecNodeAdmin.setConfig({ minTxsPerBlock: 1 });
+      await aztecNodeAdmin.setConfig({
+        fakeProcessingDelayPerTxMs: 0,
+        minTxsPerBlock: 1,
+        maxTxsPerBlock: undefined, // reset to default
+        enforceTimeTable: false, // reset to false (as it is in setup())
+      });
       // Clean up any mocks
       jest.restoreAllMocks();
     });
 
     afterAll(() => teardown());
 
     it('processes txs until hitting timetable', async () => {
-      // We send enough txs so they are spread across multiple blocks, but not
-      // so many so that we don't end up hitting a reorg or timing out the tx wait().
-      const TX_COUNT = 16;
+      const DEADLINE_S = 0.5; // half a second of building per block
+      const DEADLINE_MS = DEADLINE_S * 1000;
+      const MAX_TXS_FIT_IN_DEADLINE = 5; // via deadline and fake delay, we force this maximum to be true
+      const FAKE_DELAY_PER_TX_MS = DEADLINE_MS / MAX_TXS_FIT_IN_DEADLINE; // e.g. 100ms if 5 txs per 0.5s
+
+      // the minimum number of blocks we want to see
+      const EXPECTED_BLOCKS = 3;
+      // choose a tx count should ensure that we use EXPECTED_BLOCKS or more
+      // Note that we don't need to ensure that last block is _full_
+      const TX_COUNT = MAX_TXS_FIT_IN_DEADLINE * (EXPECTED_BLOCKS - 1) + 1;
+
+      // print out the test parameters
+      logger.info(`multi-block timetable test parameters:`);
+      logger.info(`  Deadline per block: ${DEADLINE_MS} ms`);
+      logger.info(`  Fake delay per tx: ${FAKE_DELAY_PER_TX_MS} ms`);
+      logger.info(`  Max txs that should fit in deadline: ${MAX_TXS_FIT_IN_DEADLINE}`);
+      logger.info(`  Total txs to send: ${TX_COUNT}`);
+      logger.info(`  Expected minimum blocks: ${EXPECTED_BLOCKS}`);
 
       const contract = await StatefulTestContract.deploy(wallet, ownerAddress, 1).send({ from: ownerAddress });
       logger.info(`Deployed stateful test contract at ${contract.address}`);
 
-      // We add a delay to every public tx processing
-      logger.info(`Updating aztec node config`);
+      // Configure sequencer with a small delay per tx and enforce timetable
       await aztecNodeAdmin.setConfig({
-        fakeProcessingDelayPerTxMs: 300,
+        fakeProcessingDelayPerTxMs: FAKE_DELAY_PER_TX_MS, // ensure that each tx takes at least this long
         minTxsPerBlock: 1,
-        maxTxsPerBlock: TX_COUNT,
+        maxTxsPerBlock: TX_COUNT, // intentionally large because we want to flex deadline, not this max
+        enforceTimeTable: true,
       });
 
-      // We also cheat the sequencer's timetable so it allocates little time to processing.
-      // This will leave the sequencer with just a few seconds to build the block, so it shouldn't
-      // be able to squeeze in more than a few txs in each. This is sensitive to the time it takes
-      // to pick up and validate the txs, so we may need to bump it to work on CI.
+      // Mock the timetable to limit time for block building.
       jest.spyOn(sequencer.sequencer.timetable, 'canStartNextBlock').mockImplementation((secondsIntoSlot: number) => ({
         canStart: true,
-        deadline: secondsIntoSlot + 1, // Give only 1 second for building
+        deadline: secondsIntoSlot + DEADLINE_S, // limit block-building time
         isLastBlock: true,
       }));
 
@@ -118,7 +137,7 @@ describe('e2e_block_building', () => {
       const receipts = await Promise.all(txHashes.map(txHash => waitForTx(aztecNode, txHash)));
       const blockNumbers = receipts.map(r => r.blockNumber!).sort((a, b) => a - b);
       logger.info(`Txs mined on blocks: ${unique(blockNumbers)}`);
-      expect(blockNumbers.at(-1)! - blockNumbers[0]).toBeGreaterThan(1);
+      expect(blockNumbers.at(-1)! - blockNumbers[0]).toBeGreaterThan(EXPECTED_BLOCKS - 1);
     });
 
     it('assembles a block with multiple txs', async () => {
@@ -225,7 +244,8 @@ describe('e2e_block_building', () => {
       logger.info(`Txs sent`);
     });
 
-    it.skip('can call public function from different tx in same block as deployed', async () => {
+    // Uses priority fees to guarantee the deploy tx is ordered before the call tx within the same block.
+    it('can call public function from different tx in same block as deployed', async () => {
       // Ensure both txs will land on the same block
       await aztecNodeAdmin.setConfig({ minTxsPerBlock: 2 });
 
@@ -239,13 +259,29 @@ describe('e2e_block_building', () => {
       const callInteraction = new ContractFunctionInteraction(
         wallet,
         deployerInstance.address,
-        TokenContract.artifact.functions.find(x => x.name === 'set_minter')!,
+        getAllFunctionAbis(TokenContract.artifact).find(x => x.name === 'set_minter')!,
         [minterAddress, true],
       );
 
+      // Use priority fees to guarantee ordering: deploy tx gets higher priority so the
+      // sequencer places it before the call tx in the block.
+      const highPriority = new GasFees(100, 100);
+      const lowPriority = new GasFees(1, 1);
+
+      const deployTxHash = await deployMethod.send({
+        from: ownerAddress,
+        fee: { gasSettings: { maxPriorityFeesPerGas: highPriority } },
+        wait: NO_WAIT,
+      });
+      const callTxHash = await callInteraction.send({
+        from: ownerAddress,
+        fee: { gasSettings: { maxPriorityFeesPerGas: lowPriority } },
+        wait: NO_WAIT,
+      });
+
       const [deployTxReceipt, callTxReceipt] = await Promise.all([
-        deployMethod.send({ from: ownerAddress, wait: { returnReceipt: true } }),
-        callInteraction.send({ from: ownerAddress }),
+        waitForTx(aztecNode, deployTxHash),
+        waitForTx(aztecNode, callTxHash),
       ]);
 
       expect(deployTxReceipt.blockNumber).toEqual(callTxReceipt.blockNumber);

yarn-project/simulator/src/public/fixtures/public_tx_simulation_tester.ts

@@ -169,6 +169,8 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     }
     const avmResult = await this.simulator.simulate(tx, fullTxLabel);
 
+    await this.#recordBytecodeSizes(fullTxLabel, [...setupCalls, ...appCalls, ...(teardownCall ? [teardownCall] : [])]);
+
     // Something like this is often useful for debugging:
     //if (avmResult.revertReason) {
     //  // resolve / enrich revert reason
@@ -285,6 +287,27 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
 
     return new PublicCallRequestWithCalldata(request, calldata);
   }
+
+  // WARNING: Deduplicates by artifact name, so two different artifacts with the same name
+  // in a single tx would only record the first one's bytecode size.
+  async #recordBytecodeSizes(txLabel: string, calls: TestEnqueuedCall[]) {
+    const seenArtifactNames = new Set<string>();
+    for (const call of calls) {
+      const artifact = await this.contractDataSource.getContractArtifact(call.address);
+      if (!artifact || seenArtifactNames.has(artifact.name)) {
+        continue;
+      }
+      seenArtifactNames.add(artifact.name);
+      const instance = await this.contractDataSource.getContract(call.address);
+      if (!instance) {
+        continue;
+      }
+      const contractClass = await this.contractDataSource.getContractClass(instance.currentContractClassId);
+      if (contractClass) {
+        this.metrics.recordBytecodeSize(txLabel, artifact.name, contractClass.packedBytecode.length);
+      }
+    }
+  }
 }
 
 export function defaultGlobals() {

yarn-project/simulator/src/public/test_executor_metrics.ts

@@ -21,6 +21,7 @@ export interface PublicTxMetrics {
   totalDurationMs: number;
   manaUsed: number | undefined;
   totalInstructionsExecuted: number;
+  bytecodeSizes: { contractName: string; sizeBytes: number }[];
   nonRevertiblePrivateInsertionsUs: number | undefined;
   revertiblePrivateInsertionsUs: number | undefined;
   enqueuedCalls: PublicEnqueuedCallMetrics[];
@@ -62,6 +63,7 @@ function createEmptyTxMetrics(): PublicTxMetrics {
     totalDurationMs: 0,
     manaUsed: 0,
     totalInstructionsExecuted: 0,
+    bytecodeSizes: [],
     nonRevertiblePrivateInsertionsUs: undefined,
     revertiblePrivateInsertionsUs: undefined,
     enqueuedCalls: [],
@@ -172,6 +174,12 @@ export class TestExecutorMetrics implements ExecutorMetricsInterface {
     }
   }
 
+  recordBytecodeSize(txLabel: string, contractName: string, sizeBytes: number) {
+    const txMetrics = this.txMetrics.get(txLabel);
+    assert(txMetrics, `Cannot record bytecode size for unknown tx label: ${txLabel}`);
+    txMetrics.bytecodeSizes.push({ contractName, sizeBytes });
+  }
+
   recordProverMetrics(txLabel: string, metrics: Partial<PublicTxMetrics>) {
     if (!this.txMetrics.has(txLabel)) {
       this.txMetrics.set(txLabel, createEmptyTxMetrics());
@@ -216,6 +224,15 @@ export class TestExecutorMetrics implements ExecutorMetricsInterface {
       ) {
         pretty += `${INDENT0}Total instructions executed: ${fmtNum(txMetrics.totalInstructionsExecuted)}\n`;
       }
+      if (
+        (filter === PublicTxMetricsFilter.TOTALS || filter === PublicTxMetricsFilter.ALL) &&
+        txMetrics.bytecodeSizes.length > 0
+      ) {
+        pretty += `${INDENT0}Bytecode sizes:\n`;
+        for (const { contractName, sizeBytes } of txMetrics.bytecodeSizes) {
+          pretty += `${INDENT1}${contractName}: ${fmtNum(sizeBytes, 'bytes')}\n`;
+        }
+      }
       if (filter === PublicTxMetricsFilter.DURATIONS || filter === PublicTxMetricsFilter.ALL) {
         pretty += `${INDENT0}Private insertions:\n`;
         pretty += `${INDENT1}Non-revertible: ${fmtNum(txMetrics.nonRevertiblePrivateInsertionsUs! / 1_000, 'ms')}\n`;
@@ -387,6 +404,13 @@ export class TestExecutorMetrics implements ExecutorMetricsInterface {
           });
         }
       }
+      for (const { contractName, sizeBytes } of txMetrics.bytecodeSizes) {
+        data.push({
+          name: `${txLabel}/bytecodeSizeBytes/${contractName}`,
+          value: sizeBytes,
+          unit: 'bytes',
+        });
+      }
     }
     return JSON.stringify(data, null, indent);
   }