@aztec/prover-client 0.66.0 → 0.67.1-devnet

package/src/mocks/test_context.ts

@@ -2,17 +2,22 @@ import { type BBProverConfig } from '@aztec/bb-prover';
 import {
   type L2Block,
   type ProcessedTx,
-  type ProcessedTxHandler,
   type PublicExecutionRequest,
   type ServerCircuitProver,
   type Tx,
   type TxValidator,
 } from '@aztec/circuit-types';
 import { makeBloatedProcessedTx } from '@aztec/circuit-types/test';
-import { type AppendOnlyTreeSnapshot, type Gas, type GlobalVariables, Header } from '@aztec/circuits.js';
+import {
+  type AppendOnlyTreeSnapshot,
+  BlockHeader,
+  type Gas,
+  type GlobalVariables,
+  TreeSnapshots,
+} from '@aztec/circuits.js';
 import { times } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
-import { type DebugLogger } from '@aztec/foundation/log';
+import { type Logger } from '@aztec/foundation/log';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types';
 import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
 import {
@@ -27,7 +32,7 @@ import { type MerkleTreeAdminDatabase } from '@aztec/world-state';
 import { NativeWorldStateService } from '@aztec/world-state/native';
 
 import { jest } from '@jest/globals';
-import * as fs from 'fs/promises';
+import { promises as fs } from 'fs';
 import { mock } from 'jest-mock-extended';
 
 import { TestCircuitProver } from '../../../bb-prover/src/test/test_circuit_prover.js';
@@ -37,10 +42,10 @@ import { buildBlock } from '../block_builder/light.js';
 import { ProvingOrchestrator } from '../orchestrator/index.js';
 import { MemoryProvingQueue } from '../prover-agent/memory-proving-queue.js';
 import { ProverAgent } from '../prover-agent/prover-agent.js';
-import { getEnvironmentConfig, getSimulationProvider, makeGlobals } from './fixtures.js';
+import { getEnvironmentConfig, getSimulationProvider, makeGlobals, updateExpectedTreesFromTxs } from './fixtures.js';
 
 export class TestContext {
-  private headers: Map<number, Header> = new Map();
+  private headers: Map<number, BlockHeader> = new Map();
 
   constructor(
     public publicTxSimulator: PublicTxSimulator,
@@ -53,7 +58,7 @@ export class TestContext {
     public orchestrator: TestProvingOrchestrator,
     public blockNumber: number,
     public directoriesToCleanup: string[],
-    public logger: DebugLogger,
+    public logger: Logger,
   ) {}
 
   public get epochProver() {
@@ -61,7 +66,7 @@ export class TestContext {
   }
 
   static async new(
-    logger: DebugLogger,
+    logger: Logger,
     proverCount = 4,
     createProver: (bbConfig: BBProverConfig) => Promise<ServerCircuitProver> = _ =>
       Promise.resolve(new TestCircuitProver(new NoopTelemetryClient(), new WASMSimulator())),
@@ -79,11 +84,11 @@ export class TestContext {
 
     worldStateDB.getMerkleInterface.mockReturnValue(publicDb);
 
-    const publicTxSimulator = new PublicTxSimulator(publicDb, worldStateDB, telemetry, globalVariables);
+    const publicTxSimulator = new PublicTxSimulator(publicDb, worldStateDB, telemetry, globalVariables, true);
     const processor = new PublicProcessor(
       publicDb,
       globalVariables,
-      Header.empty(),
+      BlockHeader.empty(),
       worldStateDB,
       publicTxSimulator,
       telemetry,
@@ -114,7 +119,7 @@ export class TestContext {
 
     const queue = new MemoryProvingQueue(telemetry);
     const orchestrator = new TestProvingOrchestrator(ws, queue, telemetry, Fr.ZERO);
-    const agent = new ProverAgent(localProver, proverCount);
+    const agent = new ProverAgent(localProver, proverCount, undefined, telemetry);
 
     queue.start();
     agent.start(queue);
@@ -138,9 +143,9 @@ export class TestContext {
     return this.worldState.fork();
   }
 
-  public getHeader(blockNumber: 0): Header;
-  public getHeader(blockNumber: number): Header | undefined;
-  public getHeader(blockNumber = 0) {
+  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);
   }
 
@@ -156,7 +161,7 @@ export class TestContext {
   public makeProcessedTx(seedOrOpts?: Parameters<typeof makeBloatedProcessedTx>[0] | number): ProcessedTx {
     const opts = typeof seedOrOpts === 'number' ? { seed: seedOrOpts } : seedOrOpts;
     const blockNum = (opts?.globalVariables ?? this.globalVariables).blockNumber.toNumber();
-    const header = this.getHeader(blockNum - 1);
+    const header = this.getBlockHeader(blockNum - 1);
     return makeBloatedProcessedTx({
       header,
       vkTreeRoot: getVKTreeRoot(),
@@ -180,6 +185,7 @@ export class TestContext {
     const txs = times(numTxs, i =>
       this.makeProcessedTx({ seed: i + blockNum * 1000, globalVariables, ...makeProcessedTxOpts(i) }),
     );
+    await this.setEndTreeRoots(txs);
 
     const block = await buildBlock(txs, globalVariables, msgs, db);
     this.headers.set(blockNum, block.header);
@@ -187,12 +193,7 @@ export class TestContext {
     return { block, txs, msgs };
   }
 
-  public async processPublicFunctions(
-    txs: Tx[],
-    maxTransactions: number,
-    txHandler?: ProcessedTxHandler,
-    txValidator?: TxValidator<ProcessedTx>,
-  ) {
+  public async processPublicFunctions(txs: Tx[], maxTransactions: number, txValidator?: TxValidator<ProcessedTx>) {
     const defaultExecutorImplementation = (
       _stateManager: AvmPersistableStateManager,
       executionRequest: PublicExecutionRequest,
@@ -217,16 +218,30 @@ export class TestContext {
     return await this.processPublicFunctionsWithMockExecutorImplementation(
       txs,
       maxTransactions,
-      txHandler,
       txValidator,
       defaultExecutorImplementation,
     );
   }
 
+  public async setEndTreeRoots(txs: ProcessedTx[]) {
+    const db = await this.worldState.fork();
+    for (const tx of txs) {
+      await updateExpectedTreesFromTxs(db, [tx]);
+      const stateReference = await db.getStateReference();
+      if (tx.avmProvingRequest) {
+        tx.avmProvingRequest.inputs.output.endTreeSnapshots = new TreeSnapshots(
+          stateReference.l1ToL2MessageTree,
+          stateReference.partial.noteHashTree,
+          stateReference.partial.nullifierTree,
+          stateReference.partial.publicDataTree,
+        );
+      }
+    }
+  }
+
   private async processPublicFunctionsWithMockExecutorImplementation(
     txs: Tx[],
     maxTransactions: number,
-    txHandler?: ProcessedTxHandler,
     txValidator?: TxValidator<ProcessedTx>,
     executorMock?: (
       stateManager: AvmPersistableStateManager,
@@ -254,7 +269,7 @@ export class TestContext {
     if (executorMock) {
       simulateInternal.mockImplementation(executorMock);
     }
-    return await this.publicProcessor.process(txs, maxTransactions, txHandler, txValidator);
+    return await this.publicProcessor.process(txs, maxTransactions, txValidator);
   }
 }
 

package/src/orchestrator/block-building-helpers.ts

@@ -10,13 +10,13 @@ import {
   ARCHIVE_HEIGHT,
   AppendOnlyTreeSnapshot,
   type BaseOrMergeRollupPublicInputs,
+  BlockHeader,
   BlockMergeRollupInputs,
   type BlockRootOrBlockMergePublicInputs,
   ConstantRollupData,
   ContentCommitment,
   Fr,
   type GlobalVariables,
-  Header,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
@@ -45,15 +45,17 @@ import {
   PublicDataTreeLeafPreimage,
   type RecursiveProof,
   RootRollupInputs,
+  type SpongeBlob,
   StateReference,
   VK_TREE_HEIGHT,
   type VerificationKeyAsFields,
 } from '@aztec/circuits.js';
 import { makeTuple } from '@aztec/foundation/array';
+import { Blob } from '@aztec/foundation/blob';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { sha256Trunc } from '@aztec/foundation/crypto';
-import { type DebugLogger } from '@aztec/foundation/log';
-import { type Tuple, assertLength, toFriendlyJSON } from '@aztec/foundation/serialize';
+import { type Logger } from '@aztec/foundation/log';
+import { type Tuple, assertLength, serializeToBuffer, toFriendlyJSON } from '@aztec/foundation/serialize';
 import { computeUnbalancedMerkleRoot } from '@aztec/foundation/trees';
 import { getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types';
 import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
@@ -76,6 +78,7 @@ export async function buildBaseRollupHints(
   tx: ProcessedTx,
   globalVariables: GlobalVariables,
   db: MerkleTreeWriteOperations,
+  startSpongeBlob: SpongeBlob,
 ) {
   // Get trees info before any changes hit
   const constants = await getConstantRollupData(globalVariables, db);
@@ -95,13 +98,6 @@ export async function buildBaseRollupHints(
     i < noteHashSubtreeSiblingPathArray.length ? noteHashSubtreeSiblingPathArray[i] : Fr.ZERO,
   );
 
-  // Create data hint for reading fee payer initial balance in Fee Juice
-  // If no fee payer is set, read hint should be empty
-  const leafSlot = computeFeePayerBalanceLeafSlot(tx.data.feePayer);
-  const feePayerFeeJuiceBalanceReadHint = tx.data.feePayer.isZero()
-    ? PublicDataHint.empty()
-    : await getPublicDataHint(db, leafSlot.toBigInt());
-
   // Update the note hash trees with the new items being inserted to get the new roots
   // that will be used by the next iteration of the base rollup circuit, skipping the empty ones
   const noteHashes = padArrayEnd(tx.txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX);
@@ -139,6 +135,10 @@ export async function buildBaseRollupHints(
     i < nullifierSubtreeSiblingPathArray.length ? nullifierSubtreeSiblingPathArray[i] : Fr.ZERO,
   );
 
+  // Append new data to startSpongeBlob
+  const inputSpongeBlob = startSpongeBlob.clone();
+  startSpongeBlob.absorb(tx.txEffect.toBlobFields());
+
   if (tx.avmProvingRequest) {
     // Build public base rollup hints
     const stateDiffHints = PublicBaseStateDiffHints.from({
@@ -183,8 +183,8 @@ export async function buildBaseRollupHints(
 
     return PublicBaseRollupHints.from({
       start,
+      startSpongeBlob: inputSpongeBlob,
       stateDiffHints,
-      feePayerFeeJuiceBalanceReadHint: feePayerFeeJuiceBalanceReadHint,
       archiveRootMembershipWitness,
       constants,
     });
@@ -197,6 +197,13 @@ export async function buildBaseRollupHints(
       throw new Error(`More than one public data write in a private only tx`);
     }
 
+    // Create data hint for reading fee payer initial balance in Fee Juice
+    // If no fee payer is set, read hint should be empty
+    const leafSlot = computeFeePayerBalanceLeafSlot(tx.data.feePayer);
+    const feePayerFeeJuiceBalanceReadHint = tx.data.feePayer.isZero()
+      ? PublicDataHint.empty()
+      : await getPublicDataHint(db, leafSlot.toBigInt());
+
     const feeWriteLowLeafPreimage =
       txPublicDataUpdateRequestInfo.lowPublicDataWritesPreimages[0] || PublicDataTreeLeafPreimage.empty();
     const feeWriteLowLeafMembershipWitness =
@@ -236,6 +243,7 @@ export async function buildBaseRollupHints(
 
     return PrivateBaseRollupHints.from({
       start,
+      startSpongeBlob: inputSpongeBlob,
       stateDiffHints,
       feePayerFeeJuiceBalanceReadHint: feePayerFeeJuiceBalanceReadHint,
       archiveRootMembershipWitness,
@@ -299,18 +307,17 @@ export function buildHeaderFromCircuitOutputs(
   parityPublicInputs: ParityPublicInputs,
   rootRollupOutputs: BlockRootOrBlockMergePublicInputs,
   updatedL1ToL2TreeSnapshot: AppendOnlyTreeSnapshot,
-  logger?: DebugLogger,
+  logger?: Logger,
 ) {
+  const blobsHash = rootRollupOutputs.blobPublicInputs[0].getBlobsHash();
   const contentCommitment = new ContentCommitment(
     new Fr(previousMergeData[0].numTxs + previousMergeData[1].numTxs),
-    sha256Trunc(
-      Buffer.concat([previousMergeData[0].txsEffectsHash.toBuffer(), previousMergeData[1].txsEffectsHash.toBuffer()]),
-    ),
+    blobsHash,
     parityPublicInputs.shaRoot.toBuffer(),
     sha256Trunc(Buffer.concat([previousMergeData[0].outHash.toBuffer(), previousMergeData[1].outHash.toBuffer()])),
   );
   const state = new StateReference(updatedL1ToL2TreeSnapshot, previousMergeData[1].end);
-  const header = new Header(
+  const header = new BlockHeader(
     rootRollupOutputs.previousArchive,
     contentCommitment,
     state,
@@ -360,10 +367,11 @@ export async function buildHeaderAndBodyFromTxs(
   const parityShaRoot = new MerkleTreeCalculator(parityHeight, Fr.ZERO.toBuffer(), hasher).computeTreeRoot(
     l1ToL2Messages.map(msg => msg.toBuffer()),
   );
+  const blobsHash = getBlobsHashFromBlobs(Blob.getBlobs(body.toBlobFields()));
 
   const contentCommitment = new ContentCommitment(
     new Fr(body.numberOfTxsIncludingPadded),
-    body.getTxsEffectsHash(),
+    blobsHash,
     parityShaRoot,
     outHash,
   );
@@ -371,15 +379,20 @@ export async function buildHeaderAndBodyFromTxs(
   const fees = body.txEffects.reduce((acc, tx) => acc.add(tx.transactionFee), Fr.ZERO);
   const manaUsed = txs.reduce((acc, tx) => acc.add(new Fr(tx.gasUsed.totalGas.l2Gas)), Fr.ZERO);
 
-  const header = new Header(previousArchive, contentCommitment, stateReference, globalVariables, fees, manaUsed);
+  const header = new BlockHeader(previousArchive, contentCommitment, stateReference, globalVariables, fees, manaUsed);
 
   return { header, body };
 }
 
+export function getBlobsHashFromBlobs(inputs: Blob[]): Buffer {
+  const blobHashes = serializeToBuffer(inputs.map(b => b.getEthVersionedBlobHash()));
+  return sha256Trunc(serializeToBuffer(blobHashes));
+}
+
 // Validate that the roots of all local trees match the output of the root circuit simulation
 export async function validateBlockRootOutput(
   blockRootOutput: BlockRootOrBlockMergePublicInputs,
-  blockHeader: Header,
+  blockHeader: BlockHeader,
   db: MerkleTreeReadOperations,
 ) {
   await Promise.all([
@@ -548,7 +561,7 @@ export async function getMembershipWitnessFor<N extends number>(
     return makeEmptyMembershipWitness(height);
   }
 
-  const index = await db.findLeafIndex(treeId, value.toBuffer());
+  const index = (await db.findLeafIndices(treeId, [value.toBuffer()]))[0];
   if (index === undefined) {
     throw new Error(`Leaf with value ${value} not found in tree ${MerkleTreeId[treeId]}`);
   }

package/src/orchestrator/block-proving-state.ts

@@ -14,6 +14,7 @@ import {
   type RECURSIVE_PROOF_LENGTH,
   type RecursiveProof,
   type RootParityInput,
+  SpongeBlob,
   type VerificationKeyAsFields,
 } from '@aztec/circuits.js';
 import { type Tuple } from '@aztec/foundation/serialize';
@@ -44,12 +45,13 @@ export class BlockProvingState {
   public blockRootRollupStarted: boolean = false;
   public finalProof: Proof | undefined;
   public block: L2Block | undefined;
+  public spongeBlobState: SpongeBlob | undefined;
+  public totalNumTxs: number;
   private txs: TxProvingState[] = [];
   public error: string | undefined;
 
   constructor(
     public readonly index: number,
-    public readonly totalNumTxs: number,
     public readonly globalVariables: GlobalVariables,
     public readonly newL1ToL2Messages: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>,
     public readonly messageTreeSnapshot: AppendOnlyTreeSnapshot,
@@ -61,6 +63,7 @@ export class BlockProvingState {
     private readonly parentEpoch: EpochProvingState,
   ) {
     this.rootParityInputs = Array.from({ length: NUM_BASE_PARITY_PER_ROOT_PARITY }).map(_ => undefined);
+    this.totalNumTxs = 0;
   }
 
   public get blockNumber() {
@@ -98,8 +101,21 @@ export class BlockProvingState {
     return [mergeLevel - 1n, thisIndex >> 1n, thisIndex & 1n];
   }
 
+  public startNewBlock(numTxs: number, numBlobFields: number) {
+    if (this.spongeBlobState) {
+      throw new Error(`Block ${this.blockNumber} already initalised.`);
+    }
+    // Initialise the sponge which will eventually absorb all tx effects to be added to the blob.
+    // Like l1 to l2 messages, we need to know beforehand how many effects will be absorbed.
+    this.spongeBlobState = SpongeBlob.init(numBlobFields);
+    this.totalNumTxs = numTxs;
+  }
+
   // Adds a transaction to the proving state, returns it's index
   public addNewTx(tx: TxProvingState) {
+    if (!this.spongeBlobState) {
+      throw new Error(`Invalid block proving state, call startNewBlock before adding transactions.`);
+    }
     this.txs.push(tx);
     return this.txs.length - 1;
   }
@@ -199,11 +215,6 @@ export class BlockProvingState {
     return this.rootParityInputs.findIndex(p => !p) === -1;
   }
 
-  // Returns true if we are still able to accept transactions, false otherwise
-  public isAcceptingTransactions() {
-    return this.totalNumTxs > this.txs.length;
-  }
-
   // Returns whether the proving state is still valid
   public verifyState() {
     return this.parentEpoch.verifyState();

package/src/orchestrator/epoch-proving-state.ts

@@ -97,7 +97,6 @@ export class EpochProvingState {
   // Adds a block to the proving state, returns its index
   // Will update the proving life cycle if this is the last block
   public startNewBlock(
-    numTxs: number,
     globalVariables: GlobalVariables,
     l1ToL2Messages: Fr[],
     messageTreeSnapshot: AppendOnlyTreeSnapshot,
@@ -110,7 +109,6 @@ export class EpochProvingState {
     const index = globalVariables.blockNumber.toNumber() - this.firstBlockNumber;
     const block = new BlockProvingState(
       index,
-      numTxs,
       globalVariables,
       padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
       messageTreeSnapshot,