@aztec/prover-client 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/mocks/fixtures.ts

@@ -1,16 +1,16 @@
-import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_TREE_HEIGHT } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { randomBytes } from '@aztec/foundation/crypto';
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { randomBytes } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import type { Logger } from '@aztec/foundation/log';
+import type { FieldsOf } from '@aztec/foundation/types';
 import { fileURLToPath } from '@aztec/foundation/url';
-import { NativeACVMSimulator, type SimulationProvider, WASMSimulatorWithBlobs } from '@aztec/simulator/server';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
+import { type CircuitSimulator, NativeACVMSimulator, WASMSimulatorWithBlobs } from '@aztec/simulator/server';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { GasFees } from '@aztec/stdlib/gas';
-import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
-import type { ProcessedTx } from '@aztec/stdlib/tx';
+import { CheckpointConstantData } from '@aztec/stdlib/rollup';
 import { GlobalVariables } from '@aztec/stdlib/tx';
 
 import { promises as fs } from 'fs';
@@ -32,7 +32,7 @@ export const getEnvironmentConfig = async (logger: Logger) => {
   try {
     const expectedBBPath = BB_BINARY_PATH
       ? BB_BINARY_PATH
-      : `${path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../barretenberg/', BB_RELEASE_DIR)}/bb`;
+      : `${path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../barretenberg/', BB_RELEASE_DIR)}/bb-avm`;
     await fs.access(expectedBBPath, fs.constants.R_OK);
     const tempWorkingDirectory = `${TEMP_DIR}/${randomBytes(4).toString('hex')}`;
     const bbWorkingDirectory = BB_WORKING_DIRECTORY ? BB_WORKING_DIRECTORY : `${tempWorkingDirectory}/bb`;
@@ -64,10 +64,10 @@ export const getEnvironmentConfig = async (logger: Logger) => {
   }
 };
 
-export async function getSimulationProvider(
+export async function getSimulator(
   config: { acvmWorkingDirectory: string | undefined; acvmBinaryPath: string | undefined },
   logger?: Logger,
-): Promise<SimulationProvider> {
+): Promise<CircuitSimulator> {
   if (config.acvmBinaryPath && config.acvmWorkingDirectory) {
     try {
       await fs.access(config.acvmBinaryPath, fs.constants.R_OK);
@@ -75,7 +75,8 @@ export async function getSimulationProvider(
       logger?.info(
         `Using native ACVM at ${config.acvmBinaryPath} and working directory ${config.acvmWorkingDirectory}`,
       );
-      return new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath);
+      const acvmLogger = logger?.createChild('acvm-native');
+      return new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath, undefined, acvmLogger);
     } catch {
       logger?.warn(`Failed to access ACVM at ${config.acvmBinaryPath}, falling back to WASM`);
     }
@@ -84,34 +85,39 @@ export async function getSimulationProvider(
   return new WASMSimulatorWithBlobs();
 }
 
-// Updates the expectedDb trees based on the new note hashes, contracts, and nullifiers from these txs
-export const updateExpectedTreesFromTxs = async (db: MerkleTreeWriteOperations, txs: ProcessedTx[]) => {
-  await db.appendLeaves(
-    MerkleTreeId.NOTE_HASH_TREE,
-    txs.flatMap(tx => padArrayEnd(tx.txEffect.noteHashes, Fr.zero(), MAX_NOTE_HASHES_PER_TX)),
-  );
-  await db.batchInsert(
-    MerkleTreeId.NULLIFIER_TREE,
-    txs.flatMap(tx => padArrayEnd(tx.txEffect.nullifiers, Fr.zero(), MAX_NULLIFIERS_PER_TX).map(x => x.toBuffer())),
-    NULLIFIER_TREE_HEIGHT,
-  );
-  for (const tx of txs) {
-    await db.sequentialInsert(
-      MerkleTreeId.PUBLIC_DATA_TREE,
-      tx.txEffect.publicDataWrites.map(write => write.toBuffer()),
-    );
-  }
+export const makeGlobals = (
+  blockNumber: number,
+  slotNumber = blockNumber,
+  overrides: Partial<FieldsOf<GlobalVariables> & FieldsOf<CheckpointConstantData>> = {},
+) => {
+  const checkpointConstants = makeCheckpointConstants(slotNumber, overrides);
+  return GlobalVariables.from({
+    chainId: checkpointConstants.chainId,
+    version: checkpointConstants.version,
+    blockNumber: BlockNumber(blockNumber) /** block number */,
+    slotNumber: SlotNumber(slotNumber) /** slot number */,
+    timestamp: BigInt(blockNumber * 123) /** block number * 123 as pseudo-timestamp for testing */,
+    coinbase: checkpointConstants.coinbase,
+    feeRecipient: checkpointConstants.feeRecipient,
+    gasFees: checkpointConstants.gasFees,
+    ...overrides,
+  });
 };
 
-export const makeGlobals = (blockNumber: number) => {
-  return new GlobalVariables(
-    Fr.ZERO,
-    Fr.ZERO,
-    new Fr(blockNumber) /** block number */,
-    new Fr(blockNumber) /** slot number */,
-    new Fr(blockNumber) /** timestamp */,
-    EthAddress.ZERO,
-    AztecAddress.ZERO,
-    GasFees.empty(),
-  );
+export const makeCheckpointConstants = (
+  slotNumber: number,
+  overrides: Partial<FieldsOf<CheckpointConstantData>> = {},
+) => {
+  return CheckpointConstantData.from({
+    chainId: Fr.ZERO,
+    version: Fr.ZERO,
+    vkTreeRoot: getVKTreeRoot(),
+    protocolContractsHash,
+    proverId: Fr.ZERO,
+    slotNumber: SlotNumber(slotNumber),
+    coinbase: EthAddress.ZERO,
+    feeRecipient: AztecAddress.ZERO,
+    gasFees: GasFees.empty(),
+    ...overrides,
+  });
 };

package/src/mocks/test_context.ts

@@ -1,56 +1,67 @@
 import type { BBProverConfig } from '@aztec/bb-prover';
-import { times, timesParallel } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { TestCircuitProver } from '@aztec/bb-prover';
+import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { padArrayEnd, times, timesAsync } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Logger } from '@aztec/foundation/log';
-import { TestDateProvider } from '@aztec/foundation/timer';
+import type { FieldsOf } from '@aztec/foundation/types';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { ProtocolContractsList } from '@aztec/protocol-contracts';
 import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
-import {
-  PublicProcessor,
-  PublicTxSimulationTester,
-  PublicTxSimulator,
-  SimpleContractDataSource,
-  WorldStateDB,
-} from '@aztec/simulator/server';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2Block } from '@aztec/stdlib/block';
-import type { ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
-import { makeBloatedProcessedTx } from '@aztec/stdlib/testing';
-import { type AppendOnlyTreeSnapshot, PublicDataTreeLeaf } from '@aztec/stdlib/trees';
-import { type BlockHeader, type GlobalVariables, type ProcessedTx, TreeSnapshots, type Tx } from '@aztec/stdlib/tx';
+import { EthAddress } from '@aztec/stdlib/block';
+import type { Checkpoint } from '@aztec/stdlib/checkpoint';
+import type { MerkleTreeWriteOperations, ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
+import type { CheckpointConstantData } from '@aztec/stdlib/rollup';
+import { mockProcessedTx } from '@aztec/stdlib/testing';
+import { MerkleTreeId, PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import {
+  type BlockHeader,
+  type GlobalVariables,
+  type ProcessedTx,
+  StateReference,
+  TreeSnapshots,
+} from '@aztec/stdlib/tx';
+import type { GenesisData } from '@aztec/stdlib/world-state';
 import type { MerkleTreeAdminDatabase } from '@aztec/world-state';
 import { NativeWorldStateService } from '@aztec/world-state/native';
 
 import { promises as fs } from 'fs';
 
-import { TestCircuitProver } from '../../../bb-prover/src/test/test_circuit_prover.js';
-import { buildBlock } from '../block_builder/light.js';
+import { LightweightCheckpointBuilder } from '../light/lightweight_checkpoint_builder.js';
+import {
+  buildFinalBlobChallenges,
+  getTreeSnapshot,
+  insertSideEffects,
+} from '../orchestrator/block-building-helpers.js';
+import type { BlockProvingState } from '../orchestrator/block-proving-state.js';
 import { ProvingOrchestrator } from '../orchestrator/index.js';
 import { BrokerCircuitProverFacade } from '../proving_broker/broker_prover_facade.js';
 import { TestBroker } from '../test/mock_prover.js';
-import { getEnvironmentConfig, getSimulationProvider, makeGlobals, updateExpectedTreesFromTxs } from './fixtures.js';
+import { getEnvironmentConfig, getSimulator, makeCheckpointConstants, makeGlobals } from './fixtures.js';
 
 export class TestContext {
   private headers: Map<number, BlockHeader> = new Map();
+  private checkpoints: Checkpoint[] = [];
+  private checkpointOutHashes: Fr[] = [];
+  private nextCheckpointIndex = 0;
+  private nextCheckpointNumber = CheckpointNumber(1);
+  private nextBlockNumber = 1;
+  private epochNumber = 1;
   private feePayerBalance: Fr;
 
   constructor(
-    public publicTxSimulator: PublicTxSimulator,
     public worldState: MerkleTreeAdminDatabase,
-    public publicProcessor: PublicProcessor,
-    public globalVariables: GlobalVariables,
     public prover: ServerCircuitProver,
     public broker: TestBroker,
     public brokerProverFacade: BrokerCircuitProverFacade,
     public orchestrator: TestProvingOrchestrator,
-    public blockNumber: number,
-    public feePayer: AztecAddress,
+    private feePayer: AztecAddress,
     initialFeePayerBalance: Fr,
-    public directoriesToCleanup: string[],
-    public tester: PublicTxSimulationTester,
-    public logger: Logger,
+    private directoriesToCleanup: string[],
+    private logger: Logger,
   ) {
     this.feePayerBalance = initialFeePayerBalance;
   }
@@ -61,40 +72,26 @@ export class TestContext {
 
   static async new(
     logger: Logger,
-    proverCount = 4,
-    createProver: (bbConfig: BBProverConfig) => Promise<ServerCircuitProver> = async (bbConfig: BBProverConfig) =>
-      new TestCircuitProver(await getSimulationProvider(bbConfig, logger)),
-    blockNumber = 1,
+    {
+      proverCount = 4,
+      createProver = async (bbConfig: BBProverConfig) => new TestCircuitProver(await getSimulator(bbConfig, logger)),
+    }: {
+      proverCount?: number;
+      createProver?: (bbConfig: BBProverConfig) => Promise<ServerCircuitProver>;
+    } = {},
   ) {
     const directoriesToCleanup: string[] = [];
-    const globalVariables = makeGlobals(blockNumber);
 
     const feePayer = AztecAddress.fromNumber(42222);
     const initialFeePayerBalance = new Fr(10n ** 20n);
     const feePayerSlot = await computeFeePayerBalanceLeafSlot(feePayer);
-    const prefilledPublicData = [new PublicDataTreeLeaf(feePayerSlot, initialFeePayerBalance)];
+    const genesis: GenesisData = {
+      prefilledPublicData: [new PublicDataTreeLeaf(feePayerSlot, initialFeePayerBalance)],
+      genesisTimestamp: 0n,
+    };
 
     // Separated dbs for public processor and prover - see public_processor for context
-    const ws = await NativeWorldStateService.tmp(
-      undefined /* rollupAddress */,
-      true /* cleanupTmpDir */,
-      prefilledPublicData,
-    );
-    const publicDb = await ws.fork();
-
-    const contractDataSource = new SimpleContractDataSource();
-    const worldStateDB = new WorldStateDB(publicDb, contractDataSource);
-
-    const tester = new PublicTxSimulationTester(worldStateDB, contractDataSource, publicDb);
-
-    const publicTxSimulator = new PublicTxSimulator(publicDb, worldStateDB, globalVariables, true);
-    const processor = new PublicProcessor(
-      publicDb,
-      globalVariables,
-      worldStateDB,
-      publicTxSimulator,
-      new TestDateProvider(),
-    );
+    const ws = await NativeWorldStateService.tmp(/*cleanupTmpDir=*/ true, genesis);
 
     let localProver: ServerCircuitProver;
     const config = await getEnvironmentConfig(logger);
@@ -107,6 +104,10 @@ export class TestContext {
         bbBinaryPath: config.expectedBBPath,
         bbWorkingDirectory: config.bbWorkingDirectory,
         bbSkipCleanup: config.bbSkipCleanup,
+        numConcurrentIVCVerifiers: 8,
+        bbIVCConcurrency: 1,
+        bbChonkVerifyMaxBatch: 16,
+        bbChonkVerifyConcurrency: 6,
       };
       localProver = await createProver(bbConfig);
     }
@@ -117,25 +118,20 @@ export class TestContext {
 
     const broker = new TestBroker(proverCount, localProver);
     const facade = new BrokerCircuitProverFacade(broker);
-    const orchestrator = new TestProvingOrchestrator(ws, facade, Fr.ZERO);
+    const orchestrator = new TestProvingOrchestrator(ws, facade, EthAddress.ZERO, false, 10);
 
     await broker.start();
     facade.start();
 
     return new this(
-      publicTxSimulator,
       ws,
-      processor,
-      globalVariables,
       localProver,
       broker,
       facade,
       orchestrator,
-      blockNumber,
       feePayer,
       initialFeePayerBalance,
       directoriesToCleanup,
-      tester,
       logger,
     );
   }
@@ -144,19 +140,10 @@ export class TestContext {
     return this.worldState.fork();
   }
 
-  public getBlockHeader(blockNumber: 0): BlockHeader;
-  public getBlockHeader(blockNumber: number): BlockHeader | undefined;
-  public getBlockHeader(blockNumber = 0) {
-    return blockNumber === 0 ? this.worldState.getCommitted().getInitialHeader() : this.headers.get(blockNumber);
-  }
-
-  public getPreviousBlockHeader(currentBlockNumber = this.blockNumber): BlockHeader {
-    return this.getBlockHeader(currentBlockNumber - 1)!;
-  }
-
   async cleanup() {
     await this.brokerProverFacade.stop();
     await this.broker.stop();
+    await this.worldState.close();
     for (const dir of this.directoriesToCleanup.filter(x => x !== '')) {
       try {
         await fs.rm(dir, { recursive: true, force: true, maxRetries: 3 });
@@ -166,77 +153,204 @@ export class TestContext {
     }
   }
 
-  public async makeProcessedTx(opts?: Parameters<typeof makeBloatedProcessedTx>[0]): Promise<ProcessedTx>;
-  public async makeProcessedTx(seed?: number): Promise<ProcessedTx>;
-  public async makeProcessedTx(
-    seedOrOpts?: Parameters<typeof makeBloatedProcessedTx>[0] | number,
-  ): Promise<ProcessedTx> {
-    const opts = typeof seedOrOpts === 'number' ? { seed: seedOrOpts } : seedOrOpts;
-    const blockNum = (opts?.globalVariables ?? this.globalVariables).blockNumber.toNumber();
-    const header = this.getBlockHeader(blockNum - 1);
-    const tx = await makeBloatedProcessedTx({
-      header,
+  public startNewEpoch() {
+    this.checkpoints = [];
+    this.checkpointOutHashes = [];
+    this.nextCheckpointIndex = 0;
+    this.epochNumber++;
+  }
+
+  // Return blob fields of all checkpoints in the epoch.
+  public getBlobFields() {
+    return this.checkpoints.map(checkpoint => checkpoint.toBlobFields());
+  }
+
+  public async getFinalBlobChallenges() {
+    const blobFields = this.getBlobFields();
+    return await buildFinalBlobChallenges(blobFields);
+  }
+
+  public async makeCheckpoint(
+    numBlocks: number,
+    {
+      numTxsPerBlock = 0,
+      numL1ToL2Messages = 0,
+      makeProcessedTxOpts = () => ({}),
+      ...constantOpts
+    }: {
+      numTxsPerBlock?: number | number[];
+      numL1ToL2Messages?: number;
+      makeProcessedTxOpts?: (
+        blockGlobalVariables: GlobalVariables,
+        txIndex: number,
+      ) => Partial<Parameters<typeof mockProcessedTx>[0]>;
+    } & Partial<FieldsOf<CheckpointConstantData>> = {},
+  ) {
+    if (numBlocks === 0) {
+      throw new Error(
+        'Cannot make a checkpoint with 0 blocks. Crate an empty block (numTxsPerBlock = 0) if there are no txs.',
+      );
+    }
+
+    const checkpointIndex = this.nextCheckpointIndex++;
+    const checkpointNumber = this.nextCheckpointNumber;
+    this.nextCheckpointNumber++;
+    const slotNumber = checkpointNumber * 15; // times an arbitrary number to make it different to the checkpoint number
+
+    const constants = makeCheckpointConstants(slotNumber, constantOpts);
+
+    const fork = await this.worldState.fork();
+
+    // Build l1 to l2 messages.
+    const l1ToL2Messages = times(numL1ToL2Messages, i => new Fr(slotNumber * 100 + i));
+    await fork.appendLeaves(
+      MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
+      padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
+    );
+    const newL1ToL2Snapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, fork);
+
+    const startBlockNumber = this.nextBlockNumber;
+    const previousBlockHeader = this.getBlockHeader(BlockNumber(startBlockNumber - 1));
+    // All blocks in the same slot/checkpoint share the same timestamp.
+    const timestamp = BigInt(slotNumber * 26);
+
+    // Build global variables.
+    const blockGlobalVariables = times(numBlocks, i =>
+      makeGlobals(startBlockNumber + i, slotNumber, {
+        coinbase: constants.coinbase,
+        feeRecipient: constants.feeRecipient,
+        gasFees: constants.gasFees,
+        timestamp,
+      }),
+    );
+    this.nextBlockNumber += numBlocks;
+
+    // Build txs.
+    let totalTxs = 0;
+    const blockEndStates: StateReference[] = [];
+    const blockTxs = await timesAsync(numBlocks, async blockIndex => {
+      const txIndexOffset = totalTxs;
+      const numTxs = typeof numTxsPerBlock === 'number' ? numTxsPerBlock : numTxsPerBlock[blockIndex];
+      totalTxs += numTxs;
+      const txs = await timesAsync(numTxs, txIndex =>
+        this.makeProcessedTx({
+          seed: (txIndexOffset + txIndex + 1) * 321 + (checkpointIndex + 1) * 123456 + this.epochNumber * 0x99999,
+          globalVariables: blockGlobalVariables[blockIndex],
+          anchorBlockHeader: previousBlockHeader,
+          newL1ToL2Snapshot,
+          ...makeProcessedTxOpts(blockGlobalVariables[blockIndex], txIndexOffset + txIndex),
+        }),
+      );
+
+      // Insert side effects into the trees.
+      const endState = await this.updateTrees(txs, fork);
+      blockEndStates.push(endState);
+
+      return txs;
+    });
+
+    const cleanFork = await this.worldState.fork();
+    const previousCheckpointOutHashes = this.checkpointOutHashes;
+    const builder = await LightweightCheckpointBuilder.startNewCheckpoint(
+      checkpointNumber,
+      { ...constants, timestamp },
+      l1ToL2Messages,
+      previousCheckpointOutHashes,
+      cleanFork,
+    );
+
+    // Add tx effects to db and build block headers.
+    const blocks = [];
+    for (let i = 0; i < numBlocks; i++) {
+      const txs = blockTxs[i];
+      const state = blockEndStates[i];
+
+      const { block } = await builder.addBlock(blockGlobalVariables[i], txs, {
+        expectedEndState: state,
+        insertTxsEffects: true,
+      });
+
+      const header = block.header;
+      this.headers.set(block.number, header);
+
+      const blockMsgs = block.indexWithinCheckpoint === 0 ? l1ToL2Messages : [];
+      await this.worldState.handleL2BlockAndMessages(block, blockMsgs);
+
+      blocks.push({ header, txs });
+    }
+
+    const checkpoint = await builder.completeCheckpoint();
+    this.checkpoints.push(checkpoint);
+    this.checkpointOutHashes.push(checkpoint.getCheckpointOutHash());
+
+    return {
+      constants,
+      checkpoint,
+      header: checkpoint.header,
+      blocks,
+      l1ToL2Messages,
+      previousBlockHeader,
+    };
+  }
+
+  private async makeProcessedTx(opts: Parameters<typeof mockProcessedTx>[0] = {}): Promise<ProcessedTx> {
+    const tx = await mockProcessedTx({
       vkTreeRoot: getVKTreeRoot(),
-      protocolContractTreeRoot,
-      globalVariables: this.globalVariables,
+      protocolContracts: ProtocolContractsList,
       feePayer: this.feePayer,
       ...opts,
     });
+
     this.feePayerBalance = new Fr(this.feePayerBalance.toBigInt() - tx.txEffect.transactionFee.toBigInt());
-    if (opts?.privateOnly) {
-      const feePayerSlot = await computeFeePayerBalanceLeafSlot(this.feePayer);
-      tx.txEffect.publicDataWrites[0] = new PublicDataWrite(feePayerSlot, this.feePayerBalance);
-    }
-    return tx;
-  }
 
-  /** Creates a block with the given number of txs and adds it to world-state */
-  public async makePendingBlock(
-    numTxs: number,
-    numMsgs: number = 0,
-    blockNumOrGlobals: GlobalVariables | number = this.globalVariables,
-    makeProcessedTxOpts: (index: number) => Partial<Parameters<typeof makeBloatedProcessedTx>[0]> = () => ({}),
-  ) {
-    const globalVariables = typeof blockNumOrGlobals === 'number' ? makeGlobals(blockNumOrGlobals) : blockNumOrGlobals;
-    const blockNum = globalVariables.blockNumber.toNumber();
-    const db = await this.worldState.fork();
-    const msgs = times(numMsgs, i => new Fr(blockNum * 100 + i));
-    const txs = await timesParallel(numTxs, i =>
-      this.makeProcessedTx({ seed: i + blockNum * 1000, globalVariables, ...makeProcessedTxOpts(i) }),
-    );
-    await this.setTreeRoots(txs);
+    const feePayerSlot = await computeFeePayerBalanceLeafSlot(this.feePayer);
+    const feePaymentPublicDataWrite = new PublicDataWrite(feePayerSlot, this.feePayerBalance);
+    tx.txEffect.publicDataWrites[0] = feePaymentPublicDataWrite;
+    if (tx.avmProvingRequest) {
+      tx.avmProvingRequest.inputs.publicInputs.accumulatedData.publicDataWrites[0] = feePaymentPublicDataWrite;
+    }
 
-    const block = await buildBlock(txs, globalVariables, msgs, db);
-    this.headers.set(blockNum, block.header);
-    await this.worldState.handleL2BlockAndMessages(block, msgs);
-    return { block, txs, msgs };
+    return tx;
   }
 
-  public async processPublicFunctions(txs: Tx[], maxTransactions: number) {
-    return await this.publicProcessor.process(txs, { maxTransactions });
+  private getBlockHeader(blockNumber: BlockNumber): BlockHeader {
+    if (Number(blockNumber) > 0 && Number(blockNumber) >= this.nextBlockNumber) {
+      throw new Error(`Block header not built for block number ${blockNumber}.`);
+    }
+    return Number(blockNumber) === 0
+      ? this.worldState.getCommitted().getInitialHeader()
+      : this.headers.get(Number(blockNumber))!;
   }
 
-  public async setTreeRoots(txs: ProcessedTx[]) {
-    const db = await this.worldState.fork();
+  private async updateTrees(txs: ProcessedTx[], fork: MerkleTreeWriteOperations) {
+    let startStateReference = await fork.getStateReference();
+    let endStateReference = startStateReference;
     for (const tx of txs) {
-      const startStateReference = await db.getStateReference();
-      await updateExpectedTreesFromTxs(db, [tx]);
-      const endStateReference = await db.getStateReference();
+      await insertSideEffects(tx, fork);
+      endStateReference = await fork.getStateReference();
+
       if (tx.avmProvingRequest) {
+        // Update the trees in the avm public inputs so that the proof won't fail.
+        const l1ToL2MessageTree = tx.avmProvingRequest.inputs.publicInputs.startTreeSnapshots.l1ToL2MessageTree;
         tx.avmProvingRequest.inputs.publicInputs.startTreeSnapshots = new TreeSnapshots(
-          startStateReference.l1ToL2MessageTree,
+          l1ToL2MessageTree,
           startStateReference.partial.noteHashTree,
           startStateReference.partial.nullifierTree,
           startStateReference.partial.publicDataTree,
         );
+
         tx.avmProvingRequest.inputs.publicInputs.endTreeSnapshots = new TreeSnapshots(
-          endStateReference.l1ToL2MessageTree,
+          l1ToL2MessageTree,
           endStateReference.partial.noteHashTree,
           endStateReference.partial.nullifierTree,
           endStateReference.partial.publicDataTree,
         );
       }
+
+      startStateReference = endStateReference;
     }
+
+    return endStateReference;
   }
 }
 
@@ -245,12 +359,9 @@ class TestProvingOrchestrator extends ProvingOrchestrator {
 
   // Disable this check by default, since it requires seeding world state with the block being built
   // This is only enabled in some tests with multiple blocks that populate the pending chain via makePendingBlock
-  protected override verifyBuiltBlockAgainstSyncedState(
-    l2Block: L2Block,
-    newArchive: AppendOnlyTreeSnapshot,
-  ): Promise<void> {
+  protected override verifyBuiltBlockAgainstSyncedState(provingState: BlockProvingState): Promise<void> {
     if (this.isVerifyBuiltBlockAgainstSyncedStateEnabled) {
-      return super.verifyBuiltBlockAgainstSyncedState(l2Block, newArchive);
+      return super.verifyBuiltBlockAgainstSyncedState(provingState);
     }
     return Promise.resolve();
   }