@aztec/prover-client 0.67.1 → 0.68.0

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

@@ -9,11 +9,7 @@ import {
 import {
   ARCHIVE_HEIGHT,
   AppendOnlyTreeSnapshot,
-  type BaseOrMergeRollupPublicInputs,
   BlockHeader,
-  BlockMergeRollupInputs,
-  type BlockRootOrBlockMergePublicInputs,
-  ConstantRollupData,
   ContentCommitment,
   Fr,
   type GlobalVariables,
@@ -21,7 +17,6 @@ import {
   MAX_NULLIFIERS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   MembershipWitness,
-  MergeRollupInputs,
   MerkleTreeCalculator,
   type NESTED_RECURSIVE_PROOF_LENGTH,
   NOTE_HASH_SUBTREE_HEIGHT,
@@ -34,26 +29,35 @@ import {
   PUBLIC_DATA_TREE_HEIGHT,
   type ParityPublicInputs,
   PartialStateReference,
-  PreviousRollupBlockData,
-  PreviousRollupData,
-  PrivateBaseRollupHints,
-  PrivateBaseStateDiffHints,
-  PublicBaseRollupHints,
-  PublicBaseStateDiffHints,
   PublicDataHint,
   PublicDataTreeLeaf,
   PublicDataTreeLeafPreimage,
   type RecursiveProof,
-  RootRollupInputs,
   StateReference,
   VK_TREE_HEIGHT,
   type VerificationKeyAsFields,
 } from '@aztec/circuits.js';
+import { type SpongeBlob } from '@aztec/circuits.js/blobs';
+import {
+  type BaseOrMergeRollupPublicInputs,
+  BlockMergeRollupInputs,
+  type BlockRootOrBlockMergePublicInputs,
+  ConstantRollupData,
+  MergeRollupInputs,
+  PreviousRollupBlockData,
+  PreviousRollupData,
+  PrivateBaseRollupHints,
+  PrivateBaseStateDiffHints,
+  PublicBaseRollupHints,
+  PublicBaseStateDiffHints,
+  RootRollupInputs,
+} from '@aztec/circuits.js/rollup';
 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 Logger } from '@aztec/foundation/log';
-import { type Tuple, assertLength, toFriendlyJSON } from '@aztec/foundation/serialize';
+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 +80,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);
@@ -132,6 +137,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({
@@ -176,6 +185,7 @@ export async function buildBaseRollupHints(
 
     return PublicBaseRollupHints.from({
       start,
+      startSpongeBlob: inputSpongeBlob,
       stateDiffHints,
       archiveRootMembershipWitness,
       constants,
@@ -235,6 +245,7 @@ export async function buildBaseRollupHints(
 
     return PrivateBaseRollupHints.from({
       start,
+      startSpongeBlob: inputSpongeBlob,
       stateDiffHints,
       feePayerFeeJuiceBalanceReadHint: feePayerFeeJuiceBalanceReadHint,
       archiveRootMembershipWitness,
@@ -300,11 +311,10 @@ export function buildHeaderFromCircuitOutputs(
   updatedL1ToL2TreeSnapshot: AppendOnlyTreeSnapshot,
   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()])),
   );
@@ -359,10 +369,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,
   );
@@ -375,6 +386,11 @@ export async function buildHeaderAndBodyFromTxs(
   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,
@@ -547,7 +563,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

@@ -2,8 +2,6 @@ import { type L2Block, type MerkleTreeId } from '@aztec/circuit-types';
 import {
   type ARCHIVE_HEIGHT,
   type AppendOnlyTreeSnapshot,
-  type BaseOrMergeRollupPublicInputs,
-  type BlockRootOrBlockMergePublicInputs,
   type Fr,
   type GlobalVariables,
   type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
@@ -16,6 +14,8 @@ import {
   type RootParityInput,
   type VerificationKeyAsFields,
 } from '@aztec/circuits.js';
+import { SpongeBlob } from '@aztec/circuits.js/blobs';
+import { type BaseOrMergeRollupPublicInputs, type BlockRootOrBlockMergePublicInputs } from '@aztec/circuits.js/rollup';
 import { type Tuple } from '@aztec/foundation/serialize';
 
 import { type EpochProvingState } from './epoch-proving-state.js';
@@ -44,12 +44,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 +62,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 +100,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 +214,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

@@ -2,7 +2,6 @@ import { type MerkleTreeId } from '@aztec/circuit-types';
 import {
   type ARCHIVE_HEIGHT,
   type AppendOnlyTreeSnapshot,
-  type BlockRootOrBlockMergePublicInputs,
   Fr,
   type GlobalVariables,
   type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
@@ -10,9 +9,9 @@ import {
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   type Proof,
   type RecursiveProof,
-  type RootRollupPublicInputs,
   type VerificationKeyAsFields,
 } from '@aztec/circuits.js';
+import { type BlockRootOrBlockMergePublicInputs, type RootRollupPublicInputs } from '@aztec/circuits.js/rollup';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { type Tuple } from '@aztec/foundation/serialize';
 
@@ -97,7 +96,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 +108,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,

package/src/orchestrator/orchestrator.ts

@@ -4,6 +4,7 @@ import {
   type ProcessedTx,
   type ServerCircuitProver,
   makeEmptyProcessedTx,
+  toNumBlobFields,
 } from '@aztec/circuit-types';
 import {
   type EpochProver,
@@ -16,13 +17,10 @@ import {
   AVM_PROOF_LENGTH_IN_FIELDS,
   AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS,
   type AppendOnlyTreeSnapshot,
-  type BaseOrMergeRollupPublicInputs,
+  BLOBS_PER_BLOCK,
   BaseParityInputs,
-  type BaseRollupHints,
   type BlockHeader,
-  type BlockRootOrBlockMergePublicInputs,
-  BlockRootRollupInputs,
-  EmptyBlockRootRollupInputs,
+  FIELDS_PER_BLOB,
   Fr,
   type GlobalVariables,
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
@@ -39,8 +37,18 @@ import {
   VerificationKeyData,
   makeEmptyRecursiveProof,
 } from '@aztec/circuits.js';
+import { BlobPublicInputs } from '@aztec/circuits.js/blobs';
+import {
+  type BaseOrMergeRollupPublicInputs,
+  type BaseRollupHints,
+  type BlockRootOrBlockMergePublicInputs,
+  BlockRootRollupInputs,
+  EmptyBlockRootRollupInputs,
+} from '@aztec/circuits.js/rollup';
 import { makeTuple } from '@aztec/foundation/array';
+import { Blob } from '@aztec/foundation/blob';
 import { maxBy, padArrayEnd } from '@aztec/foundation/collection';
+import { sha256ToField } from '@aztec/foundation/crypto';
 import { AbortError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
@@ -139,17 +147,14 @@ export class ProvingOrchestrator implements EpochProver {
 
   /**
    * Starts off a new block
-   * @param numTxs - The total number of transactions in the block.
    * @param globalVariables - The global variables for the block
    * @param l1ToL2Messages - The l1 to l2 messages for the block
-   * @param verificationKeys - The private kernel verification keys
    * @returns A proving ticket, containing a promise notifying of proving completion
    */
-  @trackSpan('ProvingOrchestrator.startNewBlock', (numTxs, globalVariables) => ({
-    [Attributes.BLOCK_SIZE]: numTxs,
+  @trackSpan('ProvingOrchestrator.startNewBlock', globalVariables => ({
     [Attributes.BLOCK_NUMBER]: globalVariables.blockNumber.toNumber(),
   }))
-  public async startNewBlock(numTxs: number, globalVariables: GlobalVariables, l1ToL2Messages: Fr[]) {
+  public async startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[]) {
     if (!this.provingState) {
       throw new Error(`Invalid proving state, call startNewEpoch before starting a block`);
     }
@@ -158,12 +163,8 @@ export class ProvingOrchestrator implements EpochProver {
       throw new Error(`Epoch not accepting further blocks`);
     }
 
-    if (!Number.isInteger(numTxs) || numTxs < 2) {
-      throw new Error(`Invalid number of txs for block (got ${numTxs})`);
-    }
-
     logger.info(
-      `Starting block ${globalVariables.blockNumber.toNumber()} for slot ${globalVariables.slotNumber.toNumber()} with ${numTxs} transactions`,
+      `Starting block ${globalVariables.blockNumber.toNumber()} for slot ${globalVariables.slotNumber.toNumber()}`,
     );
 
     // Fork world state at the end of the immediately previous block
@@ -210,7 +211,6 @@ export class ProvingOrchestrator implements EpochProver {
     );
 
     const blockProvingState = this.provingState!.startNewBlock(
-      numTxs,
       globalVariables,
       l1ToL2MessagesPadded,
       messageTreeSnapshot,
@@ -228,47 +228,56 @@ export class ProvingOrchestrator implements EpochProver {
   }
 
   /**
-   * The interface to add a simulated transaction to the scheduler
-   * @param tx - The transaction to be proven
+   * The interface to add simulated transactions to the scheduler
+   * @param txs - The transactions to be proven
    */
-  @trackSpan('ProvingOrchestrator.addNewTx', tx => ({
-    [Attributes.TX_HASH]: tx.hash.toString(),
+  @trackSpan('ProvingOrchestrator.addTxs', txs => ({
+    [Attributes.BLOCK_TXS_COUNT]: txs.length,
   }))
-  public async addNewTx(tx: ProcessedTx): Promise<void> {
-    const blockNumber = tx.constants.globalVariables.blockNumber.toNumber();
-    try {
-      const provingState = this.provingState?.getBlockProvingStateByBlockNumber(blockNumber);
-      if (!provingState) {
-        throw new Error(`Block proving state for ${blockNumber} not found`);
-      }
-
-      if (!provingState.isAcceptingTransactions()) {
-        throw new Error(`Rollup not accepting further transactions`);
-      }
+  public async addTxs(txs: ProcessedTx[]): Promise<void> {
+    if (!txs.length) {
+      // To avoid an ugly throw below. If we require an empty block, we can just call setBlockCompleted
+      // on a block with no txs. We cannot do that here because we cannot find the blockNumber without any txs.
+      logger.warn(`Provided no txs to orchestrator addTxs.`);
+      return;
+    }
+    const blockNumber = txs[0].constants.globalVariables.blockNumber.toNumber();
+    const provingState = this.provingState?.getBlockProvingStateByBlockNumber(blockNumber!);
+    if (!provingState) {
+      throw new Error(`Block proving state for ${blockNumber} not found`);
+    }
 
-      if (!provingState.verifyState()) {
-        throw new Error(`Invalid proving state when adding a tx`);
-      }
+    const numBlobFields = toNumBlobFields(txs);
+    provingState.startNewBlock(Math.max(2, txs.length), numBlobFields);
 
-      validateTx(tx);
+    logger.info(
+      `Adding ${txs.length} transactions with ${numBlobFields} blob fields to block ${provingState?.blockNumber}`,
+    );
+    for (const tx of txs) {
+      try {
+        if (!provingState.verifyState()) {
+          throw new Error(`Invalid proving state when adding a tx`);
+        }
 
-      logger.info(`Received transaction: ${tx.hash}`);
+        validateTx(tx);
 
-      if (tx.isEmpty) {
-        logger.warn(`Ignoring empty transaction ${tx.hash} - it will not be added to this block`);
-        return;
-      }
+        logger.info(`Received transaction: ${tx.hash}`);
 
-      const [hints, treeSnapshots] = await this.prepareTransaction(tx, provingState);
-      this.enqueueFirstProofs(hints, treeSnapshots, tx, provingState);
+        if (tx.isEmpty) {
+          logger.warn(`Ignoring empty transaction ${tx.hash} - it will not be added to this block`);
+          continue;
+        }
 
-      if (provingState.transactionsReceived === provingState.totalNumTxs) {
-        logger.verbose(`All transactions received for block ${provingState.globalVariables.blockNumber}.`);
+        const [hints, treeSnapshots] = await this.prepareTransaction(tx, provingState);
+        this.enqueueFirstProofs(hints, treeSnapshots, tx, provingState);
+      } catch (err: any) {
+        throw new Error(`Error adding transaction ${tx.hash.toString()} to block ${blockNumber}: ${err.message}`, {
+          cause: err,
+        });
       }
-    } catch (err: any) {
-      throw new Error(`Error adding transaction ${tx.hash.toString()} to block ${blockNumber}: ${err.message}`, {
-        cause: err,
-      });
+    }
+    if (provingState.transactionsReceived === provingState.totalNumTxs) {
+      logger.verbose(`All transactions received for block ${provingState.globalVariables.blockNumber}.`);
     }
   }
 
@@ -285,6 +294,12 @@ export class ProvingOrchestrator implements EpochProver {
       throw new Error(`Block proving state for ${blockNumber} not found`);
     }
 
+    if (!provingState.spongeBlobState) {
+      // If we are completing an empty block, initialise the provingState.
+      // We will have 2 padding txs, and => no blob fields.
+      provingState.startNewBlock(2, 0);
+    }
+
     if (!provingState.verifyState()) {
       throw new Error(`Block proving failed: ${provingState.error}`);
     }
@@ -326,7 +341,7 @@ export class ProvingOrchestrator implements EpochProver {
     }
 
     // And build the block header
-    logger.verbose(`Block ${provingState.globalVariables.blockNumber} completed. Assembling header.`);
+    logger.verbose(`Block ${blockNumber} completed. Assembling header.`);
     await this.buildBlock(provingState, expectedHeader);
 
     // If the proofs were faster than the block building, then we need to try the block root rollup again here
@@ -435,14 +450,6 @@ export class ProvingOrchestrator implements EpochProver {
     const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
     const l2Block = new L2Block(newArchive, header, body);
 
-    if (!l2Block.body.getTxsEffectsHash().equals(header.contentCommitment.txsEffectsHash)) {
-      throw new Error(
-        `Txs effects hash mismatch, ${l2Block.body
-          .getTxsEffectsHash()
-          .toString('hex')} == ${header.contentCommitment.txsEffectsHash.toString('hex')} `,
-      );
-    }
-
     await this.verifyBuiltBlockAgainstSyncedState(l2Block, newArchive);
 
     logger.verbose(`Orchestrator finalised block ${l2Block.number}`);
@@ -566,6 +573,22 @@ export class ProvingOrchestrator implements EpochProver {
     );
   }
 
+  /**
+   * Collect all new nullifiers, commitments, and contracts from all txs in a block
+   * @returns The array of non empty tx effects.
+   */
+  private extractTxEffects(provingState: BlockProvingState) {
+    // Note: this check should ensure that we have all txs and their effects ready.
+    if (!provingState.finalRootParityInput?.publicInputs.shaRoot) {
+      throw new Error(`Invalid proving state, a block must be ready to be proven before its effects can be extracted.`);
+    }
+    const nonEmptyTxEffects = provingState.allTxs
+      .map(txProvingState => txProvingState.processedTx.txEffect)
+      .filter(txEffect => !txEffect.isEmpty());
+
+    return nonEmptyTxEffects;
+  }
+
   /**
    * Returns the proof for the current epoch.
    */
@@ -692,7 +715,7 @@ export class ProvingOrchestrator implements EpochProver {
     provingState: BlockProvingState | undefined,
     tx: ProcessedTx,
   ): Promise<[BaseRollupHints, TreeSnapshots] | undefined> {
-    if (!provingState?.verifyState()) {
+    if (!provingState?.verifyState() || !provingState.spongeBlobState) {
       logger.debug('Not preparing base rollup inputs, state invalid');
       return;
     }
@@ -701,7 +724,9 @@ export class ProvingOrchestrator implements EpochProver {
 
     // We build the base rollup inputs using a mock proof and verification key.
     // These will be overwritten later once we have proven the tube circuit and any public kernels
-    const [ms, hints] = await elapsed(buildBaseRollupHints(tx, provingState.globalVariables, db));
+    const [ms, hints] = await elapsed(
+      buildBaseRollupHints(tx, provingState.globalVariables, db, provingState.spongeBlobState),
+    );
 
     if (!tx.isEmpty) {
       this.metrics.recordBaseRollupInputs(ms);
@@ -774,7 +799,7 @@ export class ProvingOrchestrator implements EpochProver {
     );
   }
 
-  // Enqueues the tub circuit for a given transaction index
+  // Enqueues the tube circuit for a given transaction index
   // Once completed, will enqueue the next circuit, either a public kernel or the base rollup
   private enqueueTube(provingState: BlockProvingState, txIndex: number) {
     if (!provingState?.verifyState()) {
@@ -856,9 +881,14 @@ export class ProvingOrchestrator implements EpochProver {
     provingState.blockRootRollupStarted = true;
     const mergeInputData = provingState.getMergeInputs(0);
     const rootParityInput = provingState.finalRootParityInput!;
+    const blobFields = this.extractTxEffects(provingState)
+      .map(tx => tx.toBlobFields())
+      .flat();
+    const blobs = Blob.getBlobs(blobFields);
+    const blobsHash = sha256ToField(blobs.map(b => b.getEthVersionedBlobHash()));
 
     logger.debug(
-      `Enqueuing block root rollup for block ${provingState.blockNumber} with ${provingState.newL1ToL2Messages.length} l1 to l2 msgs`,
+      `Enqueuing block root rollup for block ${provingState.blockNumber} with ${provingState.newL1ToL2Messages.length} l1 to l2 msgs and ${blobs.length} blobs.`,
     );
 
     const previousRollupData: BlockRootRollupInputs['previousRollupData'] = makeTuple(2, i =>
@@ -879,6 +909,13 @@ export class ProvingOrchestrator implements EpochProver {
       newArchiveSiblingPath: provingState.archiveTreeRootSiblingPath,
       previousBlockHash: provingState.previousBlockHash,
       proverId: this.proverId,
+      blobFields: padArrayEnd(blobFields, Fr.ZERO, FIELDS_PER_BLOB * BLOBS_PER_BLOCK),
+      blobCommitments: padArrayEnd(
+        blobs.map(b => b.commitmentToFields()),
+        [Fr.ZERO, Fr.ZERO],
+        BLOBS_PER_BLOCK,
+      ),
+      blobsHash: blobsHash,
     });
 
     this.deferredProving(
@@ -903,6 +940,17 @@ export class ProvingOrchestrator implements EpochProver {
 
         provingState.blockRootRollupPublicInputs = result.inputs;
         provingState.finalProof = result.proof.binaryProof;
+        const blobOutputs = result.inputs.blobPublicInputs[0];
+        blobOutputs.inner.forEach((blobOutput, i) => {
+          if (!blobOutput.isEmpty() && !blobOutput.equals(BlobPublicInputs.fromBlob(blobs[i]))) {
+            throw new Error(
+              `Rollup circuits produced mismatched blob evaluation:
+              z: ${blobOutput.z} == ${blobs[i].challengeZ},
+              y: ${blobOutput.y.toString(16)} == ${blobs[i].evaluationY.toString('hex')},
+              C: ${blobOutput.kzgCommitment} == ${blobs[i].commitmentToFields()}`,
+            );
+          }
+        });
 
         logger.debug(`Completed proof for block root rollup for ${provingState.block?.number}`);
         // validatePartialState(result.inputs.end, tx.treeSnapshots); // TODO(palla/prover)
@@ -1196,10 +1244,13 @@ export class ProvingOrchestrator implements EpochProver {
           return await this.prover.getAvmProof(inputs, signal, provingState.epochNumber);
         } catch (err) {
           if (process.env.AVM_PROVING_STRICT) {
+            logger.error(`Error thrown when proving AVM circuit with AVM_PROVING_STRICT on`, err);
             throw err;
           } else {
             logger.warn(
-              `Error thrown when proving AVM circuit, but AVM_PROVING_STRICT is off, so faking AVM proof and carrying on. Error: ${err}.`,
+              `Error thrown when proving AVM circuit but AVM_PROVING_STRICT is off. Faking AVM proof and carrying on. ${inspect(
+                err,
+              )}.`,
             );
             return {
               proof: makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS),

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

@@ -3,6 +3,11 @@ import {
   type AVM_PROOF_LENGTH_IN_FIELDS,
   AVM_VK_INDEX,
   type AppendOnlyTreeSnapshot,
+  type TUBE_PROOF_LENGTH,
+  TUBE_VK_INDEX,
+  VkWitnessData,
+} from '@aztec/circuits.js';
+import {
   AvmProofData,
   type BaseRollupHints,
   PrivateBaseRollupHints,
@@ -11,11 +16,8 @@ import {
   PublicBaseRollupHints,
   PublicBaseRollupInputs,
   PublicTubeData,
-  type TUBE_PROOF_LENGTH,
-  TUBE_VK_INDEX,
   TubeInputs,
-  VkWitnessData,
-} from '@aztec/circuits.js';
+} from '@aztec/circuits.js/rollup';
 import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types';
 
 /**

package/src/prover-agent/memory-proving-queue.ts

@@ -11,31 +11,33 @@ import {
 import type {
   AVM_PROOF_LENGTH_IN_FIELDS,
   AvmCircuitInputs,
-  BaseOrMergeRollupPublicInputs,
   BaseParityInputs,
-  BlockMergeRollupInputs,
-  BlockRootOrBlockMergePublicInputs,
-  BlockRootRollupInputs,
-  EmptyBlockRootRollupInputs,
   KernelCircuitPublicInputs,
-  MergeRollupInputs,
   NESTED_RECURSIVE_PROOF_LENGTH,
   ParityPublicInputs,
-  PrivateBaseRollupInputs,
   PrivateKernelEmptyInputData,
-  PublicBaseRollupInputs,
   RECURSIVE_PROOF_LENGTH,
   RootParityInputs,
-  RootRollupInputs,
-  RootRollupPublicInputs,
-  TubeInputs,
 } from '@aztec/circuits.js';
+import {
+  type BaseOrMergeRollupPublicInputs,
+  type BlockMergeRollupInputs,
+  type BlockRootOrBlockMergePublicInputs,
+  type BlockRootRollupInputs,
+  type EmptyBlockRootRollupInputs,
+  type MergeRollupInputs,
+  type PrivateBaseRollupInputs,
+  type PublicBaseRollupInputs,
+  type RootRollupInputs,
+  type RootRollupPublicInputs,
+  type TubeInputs,
+} from '@aztec/circuits.js/rollup';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { AbortError, TimeoutError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { type PromiseWithResolvers, RunningPromise, promiseWithResolvers } from '@aztec/foundation/promise';
 import { PriorityMemoryQueue } from '@aztec/foundation/queue';
-import { type TelemetryClient } from '@aztec/telemetry-client';
+import { type TelemetryClient, type Tracer, trackSpan } from '@aztec/telemetry-client';
 
 import { InlineProofStore, type ProofStore } from '../proving_broker/proof_store.js';
 import { ProvingQueueMetrics } from './queue_metrics.js';
@@ -65,6 +67,8 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
   private runningPromise: RunningPromise;
   private metrics: ProvingQueueMetrics;
 
+  public readonly tracer: Tracer;
+
   constructor(
     client: TelemetryClient,
     /** Timeout the job if an agent doesn't report back in this time */
@@ -75,8 +79,9 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     private timeSource = defaultTimeSource,
     private proofStore: ProofStore = new InlineProofStore(),
   ) {
+    this.tracer = client.getTracer('MemoryProvingQueue');
     this.metrics = new ProvingQueueMetrics(client, 'MemoryProvingQueue');
-    this.runningPromise = new RunningPromise(this.poll, pollingIntervalMs);
+    this.runningPromise = new RunningPromise(this.poll.bind(this), this.log, pollingIntervalMs);
   }
 
   public start() {
@@ -202,7 +207,8 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     return this.jobsInProgress.has(jobId);
   }
 
-  private poll = () => {
+  @trackSpan('MemoryProvingQueue.poll')
+  private poll() {
     const now = this.timeSource();
     this.metrics.recordQueueSize(this.queue.length());
 
@@ -220,7 +226,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
         this.queue.put(job);
       }
     }
-  };
+  }
 
   private async enqueue<T extends ProvingRequestType>(
     type: T,