@aztec/prover-client 0.71.0 → 0.72.1

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

@@ -11,7 +11,6 @@ import {
   type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
   MembershipWitness,
   type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-  type NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   NUM_BASE_PARITY_PER_ROOT_PARITY,
   type ParityPublicInputs,
   type RECURSIVE_PROOF_LENGTH,
@@ -24,6 +23,7 @@ import { SpongeBlob } from '@aztec/circuits.js/blobs';
 import {
   type BaseOrMergeRollupPublicInputs,
   type BlockRootOrBlockMergePublicInputs,
+  BlockRootRollupBlobData,
   BlockRootRollupData,
   BlockRootRollupInputs,
   ConstantRollupData,
@@ -68,14 +68,12 @@ export class BlockProvingState {
   constructor(
     public readonly index: number,
     public readonly globalVariables: GlobalVariables,
-    public readonly newL1ToL2Messages: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>,
-    private readonly messageTreeSnapshot: AppendOnlyTreeSnapshot,
-    private readonly messageTreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>,
-    private readonly messageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot,
-    private readonly archiveTreeSnapshot: AppendOnlyTreeSnapshot,
-    private readonly archiveTreeRootSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
+    public readonly newL1ToL2Messages: Fr[],
+    private readonly l1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>,
+    private readonly l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot,
+    private readonly lastArchiveSnapshot: AppendOnlyTreeSnapshot,
+    private readonly newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
     private readonly previousBlockHeader: BlockHeader,
-    private readonly previousBlockHash: Fr,
     private readonly parentEpoch: EpochProvingState,
   ) {
     this.baseParityProvingOutputs = Array.from({ length: NUM_BASE_PARITY_PER_ROOT_PARITY }).map(_ => undefined);
@@ -176,11 +174,8 @@ export class BlockProvingState {
   }
 
   public getBlockRootRollupTypeAndInputs(proverId: Fr) {
-    if (this.totalNumTxs === 0) {
-      return {
-        rollupType: 'empty-block-root-rollup' satisfies CircuitName,
-        inputs: this.#getEmptyBlockRootInputs(proverId),
-      };
+    if (!this.rootParityProvingOutput) {
+      throw new Error('Root parity is not ready.');
     }
 
     const proofs = this.#getChildProofsForBlockRoot();
@@ -189,41 +184,88 @@ export class BlockProvingState {
       throw new Error('At lease one child is not ready for the block root.');
     }
 
-    const previousRollupData = nonEmptyProofs.map(p => this.#getPreviousRollupData(p!));
     const data = this.#getBlockRootRollupData(proverId);
 
+    if (this.totalNumTxs === 0) {
+      const constants = ConstantRollupData.from({
+        lastArchive: this.lastArchiveSnapshot,
+        globalVariables: this.globalVariables,
+        vkTreeRoot: getVKTreeRoot(),
+        protocolContractTreeRoot,
+      });
+
+      return {
+        rollupType: 'empty-block-root-rollup' satisfies CircuitName,
+        inputs: EmptyBlockRootRollupInputs.from({
+          data,
+          constants,
+          isPadding: false,
+        }),
+      };
+    }
+
+    const previousRollupData = nonEmptyProofs.map(p => this.#getPreviousRollupData(p!));
+    const blobData = this.#getBlockRootRollupBlobData();
+
     if (previousRollupData.length === 1) {
       return {
         rollupType: 'single-tx-block-root-rollup' satisfies CircuitName,
-        inputs: new SingleTxBlockRootRollupInputs(previousRollupData as [PreviousRollupData], data),
+        inputs: new SingleTxBlockRootRollupInputs(previousRollupData as [PreviousRollupData], data, blobData),
       };
     } else {
       return {
         rollupType: 'block-root-rollup' satisfies CircuitName,
-        inputs: new BlockRootRollupInputs(previousRollupData as [PreviousRollupData, PreviousRollupData], data),
+        inputs: new BlockRootRollupInputs(
+          previousRollupData as [PreviousRollupData, PreviousRollupData],
+          data,
+          blobData,
+        ),
       };
     }
   }
 
+  public getPaddingBlockRootInputs(proverId: Fr) {
+    if (!this.rootParityProvingOutput) {
+      throw new Error('Root parity is not ready.');
+    }
+
+    // Use the new block header and archive of the current block as the previous header and archiver of the next padding block.
+    const newBlockHeader = this.buildHeaderFromProvingOutputs();
+    const newArchive = this.blockRootProvingOutput!.inputs.newArchive;
+
+    const data = BlockRootRollupData.from({
+      l1ToL2Roots: this.#getRootParityData(this.rootParityProvingOutput!),
+      l1ToL2MessageSubtreeSiblingPath: this.l1ToL2MessageSubtreeSiblingPath,
+      newArchiveSiblingPath: this.newArchiveSiblingPath,
+      previousBlockHeader: newBlockHeader,
+      proverId,
+    });
+
+    const constants = ConstantRollupData.from({
+      lastArchive: newArchive,
+      globalVariables: this.globalVariables,
+      vkTreeRoot: getVKTreeRoot(),
+      protocolContractTreeRoot,
+    });
+
+    return EmptyBlockRootRollupInputs.from({
+      data,
+      constants,
+      isPadding: true,
+    });
+  }
+
   public getRootParityInputs() {
     if (!this.baseParityProvingOutputs.every(p => !!p)) {
       throw new Error('At lease one base parity is not ready.');
     }
 
-    const children = this.baseParityProvingOutputs.map(p => this.#getRootParityInputFromProvingOutput(p!));
+    const children = this.baseParityProvingOutputs.map(p => this.#getRootParityData(p!));
     return new RootParityInputs(
       children as Tuple<RootParityInput<typeof RECURSIVE_PROOF_LENGTH>, typeof NUM_BASE_PARITY_PER_ROOT_PARITY>,
     );
   }
 
-  public getL1ToL2Roots() {
-    if (!this.rootParityProvingOutput) {
-      throw new Error('Root parity is not ready.');
-    }
-
-    return this.#getRootParityInputFromProvingOutput(this.rootParityProvingOutput);
-  }
-
   // Returns a specific transaction proving state
   public getTxProvingState(txIndex: number) {
     return this.txs[txIndex];
@@ -242,7 +284,7 @@ export class BlockProvingState {
       }
       endPartialState = lastRollup.inputs.end;
     }
-    const endState = new StateReference(this.messageTreeSnapshotAfterInsertion, endPartialState);
+    const endState = new StateReference(this.l1ToL2MessageTreeSnapshotAfterInsertion, endPartialState);
 
     return buildHeaderFromCircuitOutputs(
       previousRollupData.map(d => d.baseOrMergeRollupPublicInputs),
@@ -268,6 +310,10 @@ export class BlockProvingState {
     return this.baseParityProvingOutputs.every(p => !!p);
   }
 
+  public isComplete() {
+    return !!this.blockRootProvingOutput;
+  }
+
   // Returns whether the proving state is still valid
   public verifyState() {
     return this.parentEpoch.verifyState();
@@ -278,38 +324,20 @@ export class BlockProvingState {
     this.parentEpoch.reject(reason);
   }
 
-  #getEmptyBlockRootInputs(proverId: Fr) {
-    const l1ToL2Roots = this.getL1ToL2Roots();
-    const constants = ConstantRollupData.from({
-      lastArchive: this.archiveTreeSnapshot,
-      globalVariables: this.globalVariables,
-      vkTreeRoot: getVKTreeRoot(),
-      protocolContractTreeRoot,
-    });
-
-    return EmptyBlockRootRollupInputs.from({
-      l1ToL2Roots,
-      newL1ToL2MessageTreeRootSiblingPath: this.messageTreeRootSiblingPath,
-      startL1ToL2MessageTreeSnapshot: this.messageTreeSnapshot,
-      newArchiveSiblingPath: this.archiveTreeRootSiblingPath,
-      previousBlockHash: this.previousBlockHash,
-      previousPartialState: this.previousBlockHeader.state.partial,
-      constants,
+  #getBlockRootRollupData(proverId: Fr) {
+    return BlockRootRollupData.from({
+      l1ToL2Roots: this.#getRootParityData(this.rootParityProvingOutput!),
+      l1ToL2MessageSubtreeSiblingPath: this.l1ToL2MessageSubtreeSiblingPath,
+      newArchiveSiblingPath: this.newArchiveSiblingPath,
+      previousBlockHeader: this.previousBlockHeader,
       proverId,
-      isPadding: false,
     });
   }
 
-  #getBlockRootRollupData(proverId: Fr) {
+  #getBlockRootRollupBlobData() {
     const txEffects = this.txs.map(txProvingState => txProvingState.processedTx.txEffect);
     const { blobFields, blobCommitments, blobsHash } = buildBlobHints(txEffects);
-    return BlockRootRollupData.from({
-      l1ToL2Roots: this.getL1ToL2Roots(),
-      newL1ToL2MessageTreeRootSiblingPath: this.messageTreeRootSiblingPath,
-      startL1ToL2MessageTreeSnapshot: this.messageTreeSnapshot,
-      newArchiveSiblingPath: this.archiveTreeRootSiblingPath,
-      previousBlockHash: this.previousBlockHash,
-      proverId,
+    return BlockRootRollupBlobData.from({
       blobFields: padArrayEnd(blobFields, Fr.ZERO, FIELDS_PER_BLOB * BLOBS_PER_BLOCK),
       blobCommitments: padArrayEnd(blobCommitments, [Fr.ZERO, Fr.ZERO], BLOBS_PER_BLOCK),
       blobsHash,
@@ -342,11 +370,7 @@ export class BlockProvingState {
     );
   }
 
-  #getRootParityInputFromProvingOutput({
-    inputs,
-    proof,
-    verificationKey,
-  }: PublicInputsAndRecursiveProof<ParityPublicInputs>) {
+  #getRootParityData({ inputs, proof, verificationKey }: PublicInputsAndRecursiveProof<ParityPublicInputs>) {
     return new RootParityInput(
       proof,
       verificationKey.keyAsFields,

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

@@ -4,33 +4,27 @@ import {
   type PublicInputsAndRecursiveProof,
 } from '@aztec/circuit-types';
 import {
-  ARCHIVE_HEIGHT,
-  AppendOnlyTreeSnapshot,
+  type ARCHIVE_HEIGHT,
+  type AppendOnlyTreeSnapshot,
   type BlockHeader,
-  Fr,
+  type Fr,
   type GlobalVariables,
-  L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
+  type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
   MembershipWitness,
   type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   type TUBE_PROOF_LENGTH,
   VK_TREE_HEIGHT,
 } from '@aztec/circuits.js';
 import {
   BlockMergeRollupInputs,
   type BlockRootOrBlockMergePublicInputs,
-  ConstantRollupData,
-  EmptyBlockRootRollupInputs,
   PreviousRollupBlockData,
   RootRollupInputs,
   type RootRollupPublicInputs,
 } from '@aztec/circuits.js/rollup';
-import { makeTuple } from '@aztec/foundation/array';
-import { padArrayEnd } from '@aztec/foundation/collection';
 import { type Tuple } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
-import { getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vks';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vks';
 
 import { BlockProvingState } from './block-proving-state.js';
 
@@ -81,26 +75,22 @@ export class EpochProvingState {
   public startNewBlock(
     globalVariables: GlobalVariables,
     l1ToL2Messages: Fr[],
-    messageTreeSnapshot: AppendOnlyTreeSnapshot,
-    messageTreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>,
-    messageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot,
-    archiveTreeSnapshot: AppendOnlyTreeSnapshot,
-    archiveTreeRootSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
+    l1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>,
+    l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot,
+    lastArchiveSnapshot: AppendOnlyTreeSnapshot,
+    newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
     previousBlockHeader: BlockHeader,
-    previousBlockHash: Fr,
   ): BlockProvingState {
     const index = globalVariables.blockNumber.toNumber() - this.firstBlockNumber;
     const block = new BlockProvingState(
       index,
       globalVariables,
-      padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
-      messageTreeSnapshot,
-      messageTreeRootSiblingPath,
-      messageTreeSnapshotAfterInsertion,
-      archiveTreeSnapshot,
-      archiveTreeRootSiblingPath,
+      l1ToL2Messages,
+      l1ToL2MessageSubtreeSiblingPath,
+      l1ToL2MessageTreeSnapshotAfterInsertion,
+      lastArchiveSnapshot,
+      newArchiveSiblingPath,
       previousBlockHeader,
-      previousBlockHash,
       this,
     );
     this.blocks[index] = block;
@@ -182,30 +172,11 @@ export class EpochProvingState {
   }
 
   public getPaddingBlockRootInputs(proverId: Fr) {
-    const { block } = this.blocks[0] ?? {};
-    const l1ToL2Roots = this.blocks[0]?.getL1ToL2Roots();
-    if (!block || !l1ToL2Roots) {
+    if (!this.blocks[0]?.isComplete()) {
       throw new Error('Epoch needs one completed block in order to be padded.');
     }
 
-    const constants = ConstantRollupData.from({
-      lastArchive: block.archive,
-      globalVariables: block.header.globalVariables,
-      vkTreeRoot: getVKTreeRoot(),
-      protocolContractTreeRoot,
-    });
-
-    return EmptyBlockRootRollupInputs.from({
-      l1ToL2Roots,
-      newL1ToL2MessageTreeRootSiblingPath: makeTuple(L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, Fr.zero),
-      startL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot.zero(),
-      newArchiveSiblingPath: makeTuple(ARCHIVE_HEIGHT, Fr.zero),
-      previousBlockHash: block.header.hash(),
-      previousPartialState: block.header.state.partial,
-      constants,
-      proverId,
-      isPadding: true,
-    });
+    return this.blocks[0].getPaddingBlockRootInputs(proverId);
   }
 
   // Returns a specific transaction proving state

package/src/orchestrator/orchestrator.ts

@@ -18,16 +18,13 @@ import {
   AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS,
   type AppendOnlyTreeSnapshot,
   BaseParityInputs,
-  BlockHeader,
-  ContentCommitment,
+  type BlockHeader,
   Fr,
-  GlobalVariables,
+  type GlobalVariables,
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   NUM_BASE_PARITY_PER_ROOT_PARITY,
-  PartialStateReference,
-  StateReference,
   type TUBE_PROOF_LENGTH,
   VerificationKeyData,
   makeEmptyRecursiveProof,
@@ -39,12 +36,11 @@ import {
   SingleTxBlockRootRollupInputs,
   TubeInputs,
 } from '@aztec/circuits.js/rollup';
-import { makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { AbortError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
-import { type Tuple } from '@aztec/foundation/serialize';
+import { assertLength } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
 import { elapsed } from '@aztec/foundation/timer';
 import { type TreeNodeLocation } from '@aztec/foundation/trees';
@@ -140,7 +136,7 @@ export class ProvingOrchestrator implements EpochProver {
   @trackSpan('ProvingOrchestrator.startNewBlock', globalVariables => ({
     [Attributes.BLOCK_NUMBER]: globalVariables.blockNumber.toNumber(),
   }))
-  public async startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[]) {
+  public async startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[], previousBlockHeader: BlockHeader) {
     if (!this.provingState) {
       throw new Error(`Invalid proving state, call startNewEpoch before starting a block`);
     }
@@ -158,70 +154,21 @@ export class ProvingOrchestrator implements EpochProver {
     this.dbs.set(globalVariables.blockNumber.toNumber(), db);
 
     // we start the block by enqueueing all of the base parity circuits
-    let baseParityInputs: BaseParityInputs[] = [];
-    let l1ToL2MessagesPadded: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>;
-    try {
-      l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-    } catch (err) {
-      throw new Error('Too many L1 to L2 messages');
-    }
-    baseParityInputs = Array.from({ length: NUM_BASE_PARITY_PER_ROOT_PARITY }, (_, i) =>
-      BaseParityInputs.fromSlice(l1ToL2MessagesPadded, i, getVKTreeRoot()),
-    );
-
-    const messageTreeSnapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
-
-    const newL1ToL2MessageTreeRootSiblingPathArray = await getSubtreeSiblingPath(
-      MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
-      L1_TO_L2_MSG_SUBTREE_HEIGHT,
-      db,
-    );
-
-    const newL1ToL2MessageTreeRootSiblingPath = makeTuple(
-      L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
-      i =>
-        i < newL1ToL2MessageTreeRootSiblingPathArray.length ? newL1ToL2MessageTreeRootSiblingPathArray[i] : Fr.ZERO,
-      0,
-    );
-
-    // Update the local trees to include the new l1 to l2 messages
-    await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
-    const messageTreeSnapshotAfterInsertion = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
+    const { l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, baseParityInputs } =
+      await this.prepareBaseParityInputs(l1ToL2Messages, db);
 
     // Get archive snapshot before this block lands
-    const startArchiveSnapshot = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
+    const lastArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
     const newArchiveSiblingPath = await getRootTreeSiblingPath(MerkleTreeId.ARCHIVE, db);
-    const previousBlockHash = await db.getLeafValue(
-      MerkleTreeId.ARCHIVE,
-      BigInt(startArchiveSnapshot.nextAvailableLeafIndex - 1),
-    );
-
-    const partial = new PartialStateReference(
-      await getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE, db),
-      await getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE, db),
-      await getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE, db),
-    );
-    const state = new StateReference(messageTreeSnapshot, partial);
-    // TODO: Construct the full previousBlockHeader.
-    const previousBlockHeader = BlockHeader.from({
-      lastArchive: startArchiveSnapshot,
-      contentCommitment: ContentCommitment.empty(),
-      state,
-      globalVariables: GlobalVariables.empty(),
-      totalFees: Fr.ZERO,
-      totalManaUsed: Fr.ZERO,
-    });
 
     const blockProvingState = this.provingState!.startNewBlock(
       globalVariables,
-      l1ToL2MessagesPadded,
-      messageTreeSnapshot,
-      newL1ToL2MessageTreeRootSiblingPath,
-      messageTreeSnapshotAfterInsertion,
-      startArchiveSnapshot,
+      l1ToL2Messages,
+      l1ToL2MessageSubtreeSiblingPath,
+      l1ToL2MessageTreeSnapshotAfterInsertion,
+      lastArchive,
       newArchiveSiblingPath,
       previousBlockHeader,
-      previousBlockHash!,
     );
 
     // Enqueue base parity circuits for the block
@@ -502,6 +449,33 @@ export class ProvingOrchestrator implements EpochProver {
     setImmediate(safeJob);
   }
 
+  private async prepareBaseParityInputs(l1ToL2Messages: Fr[], db: MerkleTreeWriteOperations) {
+    const l1ToL2MessagesPadded = padArrayEnd(
+      l1ToL2Messages,
+      Fr.ZERO,
+      NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+      'Too many L1 to L2 messages',
+    );
+    const baseParityInputs = Array.from({ length: NUM_BASE_PARITY_PER_ROOT_PARITY }, (_, i) =>
+      BaseParityInputs.fromSlice(l1ToL2MessagesPadded, i, getVKTreeRoot()),
+    );
+
+    const l1ToL2MessageSubtreeSiblingPath = assertLength(
+      await getSubtreeSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, L1_TO_L2_MSG_SUBTREE_HEIGHT, db),
+      L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
+    );
+
+    // Update the local trees to include the new l1 to l2 messages
+    await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
+    const l1ToL2MessageTreeSnapshotAfterInsertion = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
+
+    return {
+      l1ToL2MessageSubtreeSiblingPath,
+      l1ToL2MessageTreeSnapshotAfterInsertion,
+      baseParityInputs,
+    };
+  }
+
   // Updates the merkle trees for a transaction. The first enqueued job for a transaction
   @trackSpan('ProvingOrchestrator.prepareBaseRollupInputs', (_, tx) => ({
     [Attributes.TX_HASH]: tx.hash.toString(),

package/src/prover-agent/rpc.ts

@@ -1,14 +1,14 @@
 import { ProverAgentApiSchema, type ProvingJobSource, ProvingJobSourceSchema } from '@aztec/circuit-types';
-import { createSafeJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
-import { createSafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
+import { createSafeJsonRpcClient } from '@aztec/foundation/json-rpc/client';
+import { createTracedJsonRpcServer, makeTracedFetch } from '@aztec/telemetry-client';
 
 import { type ProverAgent } from './prover-agent.js';
 
 export function createProvingJobSourceServer(queue: ProvingJobSource) {
-  return createSafeJsonRpcServer(queue, ProvingJobSourceSchema);
+  return createTracedJsonRpcServer(queue, ProvingJobSourceSchema);
 }
 
-export function createProvingJobSourceClient(url: string, fetch = makeFetch([1, 2, 3], false)): ProvingJobSource {
+export function createProvingJobSourceClient(url: string, fetch = makeTracedFetch([1, 2, 3], false)): ProvingJobSource {
   return createSafeJsonRpcClient(url, ProvingJobSourceSchema, false, 'provingJobSource', fetch);
 }
 
@@ -18,5 +18,5 @@ export function createProvingJobSourceClient(url: string, fetch = makeFetch([1,
  * @returns An JSON-RPC HTTP server
  */
 export function createProverAgentRpcServer(agent: ProverAgent) {
-  return createSafeJsonRpcServer(agent, ProverAgentApiSchema);
+  return createTracedJsonRpcServer(agent, ProverAgentApiSchema);
 }

package/src/prover-client/server-epoch-prover.ts

@@ -35,8 +35,12 @@ export class ServerEpochProver implements EpochProver {
     await this.facade.stop();
     await this.orchestrator.stop();
   }
-  startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[]): Promise<void> {
-    return this.orchestrator.startNewBlock(globalVariables, l1ToL2Messages);
+  startNewBlock(
+    globalVariables: GlobalVariables,
+    l1ToL2Messages: Fr[],
+    previousBlockHeader: BlockHeader,
+  ): Promise<void> {
+    return this.orchestrator.startNewBlock(globalVariables, l1ToL2Messages, previousBlockHeader);
   }
   addTxs(txs: ProcessedTx[]): Promise<void> {
     return this.orchestrator.addTxs(txs);

package/src/proving_broker/rpc.ts

@@ -9,9 +9,10 @@ import {
   ProvingJobStatus,
   ProvingRequestType,
 } from '@aztec/circuit-types';
-import { createSafeJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
-import { type SafeJsonRpcServer, createSafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
+import { createSafeJsonRpcClient } from '@aztec/foundation/json-rpc/client';
+import { type SafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
 import { type ApiSchemaFor, optional } from '@aztec/foundation/schemas';
+import { createTracedJsonRpcServer, makeTracedFetch } from '@aztec/telemetry-client';
 
 import { z } from 'zod';
 
@@ -47,17 +48,23 @@ export const ProvingJobBrokerSchema: ApiSchemaFor<ProvingJobBroker> = {
 };
 
 export function createProvingBrokerServer(broker: ProvingJobBroker): SafeJsonRpcServer {
-  return createSafeJsonRpcServer(broker, ProvingJobBrokerSchema);
+  return createTracedJsonRpcServer(broker, ProvingJobBrokerSchema);
 }
 
-export function createProvingJobBrokerClient(url: string, fetch = makeFetch([1, 2, 3], false)): ProvingJobBroker {
+export function createProvingJobBrokerClient(url: string, fetch = makeTracedFetch([1, 2, 3], false)): ProvingJobBroker {
   return createSafeJsonRpcClient(url, ProvingJobBrokerSchema, false, 'proverBroker', fetch);
 }
 
-export function createProvingJobProducerClient(url: string, fetch = makeFetch([1, 2, 3], false)): ProvingJobProducer {
+export function createProvingJobProducerClient(
+  url: string,
+  fetch = makeTracedFetch([1, 2, 3], false),
+): ProvingJobProducer {
   return createSafeJsonRpcClient(url, ProvingJobProducerSchema, false, 'provingJobProducer', fetch);
 }
 
-export function createProvingJobConsumerClient(url: string, fetch = makeFetch([1, 2, 3], false)): ProvingJobConsumer {
+export function createProvingJobConsumerClient(
+  url: string,
+  fetch = makeTracedFetch([1, 2, 3], false),
+): ProvingJobConsumer {
   return createSafeJsonRpcClient(url, ProvingJobConsumerSchema, false, 'provingJobConsumer', fetch);
 }