@aztec/prover-client 0.0.1-commit.b655e406 → 0.0.1-commit.c7c42ec

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

@@ -1,17 +1,23 @@
-import { BatchedBlobAccumulator, type FinalBlobBatchingChallenges, SpongeBlob } from '@aztec/blob-lib';
+import {
+  BatchedBlobAccumulator,
+  type FinalBlobBatchingChallenges,
+  SpongeBlob,
+  encodeCheckpointBlobDataFromBlocks,
+} from '@aztec/blob-lib';
 import {
   type ARCHIVE_HEIGHT,
-  BLOBS_PER_BLOCK,
+  BLOBS_PER_CHECKPOINT,
   FIELDS_PER_BLOB,
   type L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
   type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   NUM_MSGS_PER_BASE_PARITY,
 } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { BLS12Point, Fr } from '@aztec/foundation/fields';
+import { BLS12Point } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
-import { getCheckpointBlobFields } from '@aztec/stdlib/checkpoint';
 import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
 import { ParityBasePrivateInputs } from '@aztec/stdlib/parity';
 import {
@@ -44,13 +50,12 @@ export class CheckpointProvingState {
   private endBlobAccumulator: BatchedBlobAccumulator | undefined;
   private blobFields: Fr[] | undefined;
   private error: string | undefined;
-  public readonly firstBlockNumber: number;
+  public readonly firstBlockNumber: BlockNumber;
 
   constructor(
     public readonly index: number,
     public readonly constants: CheckpointConstantData,
     public readonly totalNumBlocks: number,
-    private readonly totalNumBlobFields: number,
     private readonly finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
     private readonly headerOfLastBlockInPreviousCheckpoint: BlockHeader,
     private readonly lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
@@ -71,21 +76,21 @@ export class CheckpointProvingState {
     private onBlobAccumulatorSet: (checkpoint: CheckpointProvingState) => void,
   ) {
     this.blockProofs = new UnbalancedTreeStore(totalNumBlocks);
-    this.firstBlockNumber = headerOfLastBlockInPreviousCheckpoint.globalVariables.blockNumber + 1;
+    this.firstBlockNumber = BlockNumber(headerOfLastBlockInPreviousCheckpoint.globalVariables.blockNumber + 1);
   }
 
   public get epochNumber(): number {
     return this.parentEpoch.epochNumber;
   }
 
-  public async startNewBlock(
-    blockNumber: number,
+  public startNewBlock(
+    blockNumber: BlockNumber,
     timestamp: UInt64,
     totalNumTxs: number,
     lastArchiveTreeSnapshot: AppendOnlyTreeSnapshot,
     lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
-  ): Promise<BlockProvingState> {
-    const index = blockNumber - this.firstBlockNumber;
+  ): BlockProvingState {
+    const index = Number(blockNumber) - Number(this.firstBlockNumber);
     if (index >= this.totalNumBlocks) {
       throw new Error(`Unable to start a new block at index ${index}. Expected at most ${this.totalNumBlocks} blocks.`);
     }
@@ -98,8 +103,7 @@ export class CheckpointProvingState {
     const lastL1ToL2MessageSubtreeRootSiblingPath =
       index === 0 ? this.lastL1ToL2MessageSubtreeRootSiblingPath : this.newL1ToL2MessageSubtreeRootSiblingPath;
 
-    const startSpongeBlob =
-      index === 0 ? await SpongeBlob.init(this.totalNumBlobFields) : this.blocks[index - 1]?.getEndSpongeBlob();
+    const startSpongeBlob = index === 0 ? SpongeBlob.init() : this.blocks[index - 1]?.getEndSpongeBlob();
     if (!startSpongeBlob) {
       throw new Error(
         'Cannot start a new block before the trees have progressed from the tx effects in the previous block.',
@@ -192,12 +196,12 @@ export class CheckpointProvingState {
   }
 
   public async accumulateBlobs(startBlobAccumulator: BatchedBlobAccumulator) {
-    if (this.isAcceptingBlocks() || this.blocks.some(b => b!.isAcceptingTxs())) {
+    if (this.isAcceptingBlocks() || this.blocks.some(b => !b?.hasEndState())) {
       return;
     }
 
-    this.blobFields = getCheckpointBlobFields(this.blocks.map(b => b!.getTxEffects()));
-    this.endBlobAccumulator = await accumulateBlobs(this.blobFields, startBlobAccumulator);
+    this.blobFields = encodeCheckpointBlobDataFromBlocks(this.blocks.map(b => b!.getBlockBlobData()));
+    this.endBlobAccumulator = await accumulateBlobs(this.blobFields!, startBlobAccumulator);
     this.startBlobAccumulator = startBlobAccumulator;
 
     this.onBlobAccumulatorSet(this);
@@ -246,8 +250,8 @@ export class CheckpointProvingState {
       previousArchiveSiblingPath: this.lastArchiveSiblingPath,
       startBlobAccumulator: this.startBlobAccumulator.toBlobAccumulator(),
       finalBlobChallenges: this.finalBlobBatchingChallenges,
-      blobFields: padArrayEnd(blobFields, Fr.ZERO, FIELDS_PER_BLOB * BLOBS_PER_BLOCK),
-      blobCommitments: padArrayEnd(blobCommitments, BLS12Point.ZERO, BLOBS_PER_BLOCK),
+      blobFields: padArrayEnd(blobFields, Fr.ZERO, FIELDS_PER_BLOB * BLOBS_PER_CHECKPOINT),
+      blobCommitments: padArrayEnd(blobCommitments, BLS12Point.ZERO, BLOBS_PER_CHECKPOINT),
       blobsHash,
     });
 
@@ -258,8 +262,8 @@ export class CheckpointProvingState {
       : new CheckpointRootRollupPrivateInputs([left, right], hints);
   }
 
-  public getBlockProvingStateByBlockNumber(blockNumber: number) {
-    const index = blockNumber - this.firstBlockNumber;
+  public getBlockProvingStateByBlockNumber(blockNumber: BlockNumber) {
+    const index = Number(blockNumber) - Number(this.firstBlockNumber);
     return this.blocks[index];
   }
 

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

@@ -5,7 +5,8 @@ import type {
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
 } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/fields';
+import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
 import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
@@ -66,7 +67,7 @@ export class EpochProvingState {
   >();
 
   constructor(
-    public readonly epochNumber: number,
+    public readonly epochNumber: EpochNumber,
     public readonly totalNumCheckpoints: number,
     private readonly finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
     private onCheckpointBlobAccumulatorSet: (checkpoint: CheckpointProvingState) => void,
@@ -83,7 +84,6 @@ export class EpochProvingState {
     checkpointIndex: number,
     constants: CheckpointConstantData,
     totalNumBlocks: number,
-    totalNumBlobFields: number,
     previousBlockHeader: BlockHeader,
     lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
     l1ToL2Messages: Fr[],
@@ -102,7 +102,6 @@ export class EpochProvingState {
       checkpointIndex,
       constants,
       totalNumBlocks,
-      totalNumBlobFields,
       this.finalBlobBatchingChallenges,
       previousBlockHeader,
       lastArchiveSiblingPath,
@@ -127,13 +126,16 @@ export class EpochProvingState {
     return this.checkpoints[index];
   }
 
-  public getCheckpointProvingStateByBlockNumber(blockNumber: number) {
+  public getCheckpointProvingStateByBlockNumber(blockNumber: BlockNumber) {
     return this.checkpoints.find(
-      c => c && blockNumber >= c.firstBlockNumber && blockNumber < c.firstBlockNumber + c.totalNumBlocks,
+      c =>
+        c &&
+        Number(blockNumber) >= Number(c.firstBlockNumber) &&
+        Number(blockNumber) < Number(c.firstBlockNumber) + c.totalNumBlocks,
     );
   }
 
-  public getBlockProvingStateByBlockNumber(blockNumber: number) {
+  public getBlockProvingStateByBlockNumber(blockNumber: BlockNumber) {
     return this.getCheckpointProvingStateByBlockNumber(blockNumber)?.getBlockProvingStateByBlockNumber(blockNumber);
   }
 

package/src/orchestrator/orchestrator.ts

@@ -1,4 +1,4 @@
-import { BatchedBlob, FinalBlobBatchingChallenges, SpongeBlob } from '@aztec/blob-lib';
+import { BatchedBlob, FinalBlobBatchingChallenges, SpongeBlob } from '@aztec/blob-lib/types';
 import {
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
@@ -6,22 +6,23 @@ import {
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   NUM_BASE_PARITY_PER_ROOT_PARITY,
 } from '@aztec/constants';
+import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { AbortError } from '@aztec/foundation/error';
-import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 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';
-import { readAvmMinimalPublicTxInputsFromFile } from '@aztec/simulator/public/fixtures';
-import { EthAddress, createBlockEndMarker } from '@aztec/stdlib/block';
+import { EthAddress } from '@aztec/stdlib/block';
 import type {
   EpochProver,
   ForkMerkleTreeOperations,
   MerkleTreeWriteOperations,
   PublicInputsAndRecursiveProof,
+  ReadonlyWorldStateAccess,
   ServerCircuitProver,
 } from '@aztec/stdlib/interfaces/server';
 import type { Proof } from '@aztec/stdlib/proofs';
@@ -54,7 +55,6 @@ import {
 import { inspect } from 'util';
 
 import {
-  buildBlockHeaderFromTxs,
   buildHeaderFromCircuitOutputs,
   getLastSiblingPath,
   getPublicChonkVerifierPrivateInputsFromTx,
@@ -93,10 +93,11 @@ export class ProvingOrchestrator implements EpochProver {
 
   private provingPromise: Promise<ProvingResult> | undefined = undefined;
   private metrics: ProvingOrchestratorMetrics;
-  private dbs: Map<number, MerkleTreeWriteOperations> = new Map();
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+  private dbs: Map<BlockNumber, MerkleTreeWriteOperations> = new Map();
 
   constructor(
-    private dbProvider: ForkMerkleTreeOperations,
+    private dbProvider: ReadonlyWorldStateAccess & ForkMerkleTreeOperations,
     private prover: ServerCircuitProver,
     private readonly proverId: EthAddress,
     telemetryClient: TelemetryClient = getTelemetryClient(),
@@ -118,7 +119,7 @@ export class ProvingOrchestrator implements EpochProver {
   }
 
   public startNewEpoch(
-    epochNumber: number,
+    epochNumber: EpochNumber,
     totalNumCheckpoints: number,
     finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
   ) {
@@ -147,7 +148,6 @@ export class ProvingOrchestrator implements EpochProver {
     constants: CheckpointConstantData,
     l1ToL2Messages: Fr[],
     totalNumBlocks: number,
-    totalNumBlobFields: number,
     headerOfLastBlockInPreviousCheckpoint: BlockHeader,
   ) {
     if (!this.provingState) {
@@ -162,7 +162,7 @@ export class ProvingOrchestrator implements EpochProver {
     const lastBlockNumber = headerOfLastBlockInPreviousCheckpoint.globalVariables.blockNumber;
     const db = await this.dbProvider.fork(lastBlockNumber);
 
-    const firstBlockNumber = lastBlockNumber + 1;
+    const firstBlockNumber = BlockNumber(lastBlockNumber + 1);
     this.dbs.set(firstBlockNumber, db);
 
     // Get archive sibling path before any block in this checkpoint lands.
@@ -180,7 +180,6 @@ export class ProvingOrchestrator implements EpochProver {
       checkpointIndex,
       constants,
       totalNumBlocks,
-      totalNumBlobFields,
       headerOfLastBlockInPreviousCheckpoint,
       lastArchiveSiblingPath,
       l1ToL2Messages,
@@ -201,7 +200,7 @@ export class ProvingOrchestrator implements EpochProver {
   @trackSpan('ProvingOrchestrator.startNewBlock', blockNumber => ({
     [Attributes.BLOCK_NUMBER]: blockNumber,
   }))
-  public async startNewBlock(blockNumber: number, timestamp: UInt64, totalNumTxs: number) {
+  public async startNewBlock(blockNumber: BlockNumber, timestamp: UInt64, totalNumTxs: number) {
     if (!this.provingState) {
       throw new Error('Empty epoch proving state. Call startNewEpoch before starting a block.');
     }
@@ -216,12 +215,12 @@ export class ProvingOrchestrator implements EpochProver {
     }
 
     const constants = checkpointProvingState.constants;
-    logger.info(`Starting block ${blockNumber} for slot ${constants.slotNumber.toNumber()}.`);
+    logger.info(`Starting block ${blockNumber} for slot ${constants.slotNumber}.`);
 
     // Fork the db only when it's not already set. The db for the first block is set in `startNewCheckpoint`.
     if (!this.dbs.has(blockNumber)) {
       // Fork world state at the end of the immediately previous block
-      const db = await this.dbProvider.fork(blockNumber - 1);
+      const db = await this.dbProvider.fork(BlockNumber(blockNumber - 1));
       this.dbs.set(blockNumber, db);
     }
     const db = this.dbs.get(blockNumber)!;
@@ -230,7 +229,7 @@ export class ProvingOrchestrator implements EpochProver {
     const lastArchiveTreeSnapshot = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
     const lastArchiveSiblingPath = await getRootTreeSiblingPath(MerkleTreeId.ARCHIVE, db);
 
-    const blockProvingState = await checkpointProvingState.startNewBlock(
+    const blockProvingState = checkpointProvingState.startNewBlock(
       blockNumber,
       timestamp,
       totalNumTxs,
@@ -248,8 +247,12 @@ export class ProvingOrchestrator implements EpochProver {
     // Because `addTxs` won't be called for a block without txs, and that's where the sponge blob state is computed.
     // We need to set its end sponge blob here, which will become the start sponge blob for the next block.
     if (totalNumTxs === 0) {
+      const endState = await db.getStateReference();
+      blockProvingState.setEndState(endState);
+
       const endSpongeBlob = blockProvingState.getStartSpongeBlob().clone();
-      await endSpongeBlob.absorb([createBlockEndMarker(0)]);
+      const blockEndBlobFields = blockProvingState.getBlockEndBlobFields();
+      await endSpongeBlob.absorb(blockEndBlobFields);
       blockProvingState.setEndSpongeBlob(endSpongeBlob);
 
       // And also try to accumulate the blobs as far as we can:
@@ -276,7 +279,7 @@ export class ProvingOrchestrator implements EpochProver {
       return;
     }
 
-    const blockNumber = txs[0].globalVariables.blockNumber;
+    const blockNumber = BlockNumber(txs[0].globalVariables.blockNumber);
     const provingState = this.provingState.getBlockProvingStateByBlockNumber(blockNumber!);
     if (!provingState) {
       throw new Error(`Proving state for block ${blockNumber} not found. Call startNewBlock first.`);
@@ -307,7 +310,7 @@ export class ProvingOrchestrator implements EpochProver {
 
         validateTx(tx);
 
-        logger.info(`Received transaction: ${tx.hash}`);
+        logger.debug(`Received transaction: ${tx.hash}`);
 
         const startSpongeBlob = spongeBlobState.clone();
         const [hints, treeSnapshots] = await this.prepareBaseRollupInputs(
@@ -341,7 +344,11 @@ export class ProvingOrchestrator implements EpochProver {
       }
     }
 
-    await spongeBlobState.absorb([createBlockEndMarker(txs.length)]);
+    const endState = await db.getStateReference();
+    provingState.setEndState(endState);
+
+    const blockEndBlobFields = provingState.getBlockEndBlobFields();
+    await spongeBlobState.absorb(blockEndBlobFields);
 
     provingState.setEndSpongeBlob(spongeBlobState);
 
@@ -382,10 +389,10 @@ export class ProvingOrchestrator implements EpochProver {
    * Marks the block as completed.
    * Computes the block header and updates the archive tree.
    */
-  @trackSpan('ProvingOrchestrator.setBlockCompleted', (blockNumber: number) => ({
+  @trackSpan('ProvingOrchestrator.setBlockCompleted', (blockNumber: BlockNumber) => ({
     [Attributes.BLOCK_NUMBER]: blockNumber,
   }))
-  public async setBlockCompleted(blockNumber: number, expectedHeader?: BlockHeader): Promise<BlockHeader> {
+  public async setBlockCompleted(blockNumber: BlockNumber, expectedHeader?: BlockHeader): Promise<BlockHeader> {
     const provingState = this.provingState?.getBlockProvingStateByBlockNumber(blockNumber);
     if (!provingState) {
       throw new Error(`Block proving state for ${blockNumber} not found`);
@@ -408,39 +415,25 @@ export class ProvingOrchestrator implements EpochProver {
       );
     }
 
-    // And build the block header
+    // Given we've applied every change from this block, now assemble the block header:
     logger.verbose(`Block ${blockNumber} completed. Assembling header.`);
-    const header = await this.buildL2BlockHeader(provingState, expectedHeader);
-
-    await this.verifyBuiltBlockAgainstSyncedState(provingState);
-
-    return header;
-  }
-
-  private async buildL2BlockHeader(provingState: BlockProvingState, expectedHeader?: BlockHeader) {
-    // Collect all txs in this block to build the header. The function calling this has made sure that all txs have been added.
-    const txs = provingState.getProcessedTxs();
-
-    const startSpongeBlob = provingState.getStartSpongeBlob();
-
-    // Get db for this block
-    const db = this.dbs.get(provingState.blockNumber)!;
-
-    // Given we've applied every change from this block, now assemble the block header
-    // and update the archive tree, so we're ready to start processing the next block
-    const header = await buildBlockHeaderFromTxs(txs, provingState.getGlobalVariables(), startSpongeBlob, db);
+    const header = await provingState.buildBlockHeader();
 
     if (expectedHeader && !header.equals(expectedHeader)) {
       logger.error(`Block header mismatch: header=${header} expectedHeader=${expectedHeader}`);
       throw new Error('Block header mismatch');
     }
 
+    // Get db for this block
+    const db = this.dbs.get(provingState.blockNumber)!;
+
+    // Update the archive tree, so we're ready to start processing the next block:
     logger.verbose(
       `Updating archive tree with block ${provingState.blockNumber} header ${(await header.hash()).toString()}`,
     );
     await db.updateArchive(header);
 
-    provingState.setBuiltBlockHeader(header);
+    await this.verifyBuiltBlockAgainstSyncedState(provingState);
 
     return header;
   }
@@ -1214,8 +1207,6 @@ export class ProvingOrchestrator implements EpochProver {
 
     const txProvingState = provingState.getTxProvingState(txIndex);
 
-    // This function tries to do AVM proving. If there is a failure, it fakes the proof unless AVM_PROVING_STRICT is defined.
-    // Nothing downstream depends on the AVM proof yet. So having this mode lets us incrementally build the AVM circuit.
     const doAvmProving = wrapCallbackInSpan(
       this.tracer,
       'ProvingOrchestrator.prover.getAvmProof',
@@ -1224,30 +1215,7 @@ export class ProvingOrchestrator implements EpochProver {
       },
       async (signal: AbortSignal) => {
         const inputs = txProvingState.getAvmInputs();
-        try {
-          // TODO(#14234)[Unconditional PIs validation]: Remove the whole try-catch logic and
-          // just keep the next line but removing the second argument (false).
-          return await this.prover.getAvmProof(inputs, false, 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. Use snapshotted
-               AVM inputs and carrying on. ${inspect(err)}.`,
-            );
-
-            try {
-              this.metrics.incAvmFallback();
-              const snapshotAvmPrivateInputs = readAvmMinimalPublicTxInputsFromFile();
-              return await this.prover.getAvmProof(snapshotAvmPrivateInputs, true, signal, provingState.epochNumber);
-            } catch (err) {
-              logger.error(`Error thrown when proving snapshotted AVM inputs.`, err);
-              throw err;
-            }
-          }
-        }
+        return await this.prover.getAvmProof(inputs, signal, provingState.epochNumber);
       },
     );
 

package/src/orchestrator/orchestrator_metrics.ts

@@ -1,17 +1,9 @@
-import {
-  type Histogram,
-  Metrics,
-  type TelemetryClient,
-  type Tracer,
-  type UpDownCounter,
-  ValueType,
-} from '@aztec/telemetry-client';
+import { type Histogram, Metrics, type TelemetryClient, type Tracer, ValueType } from '@aztec/telemetry-client';
 
 export class ProvingOrchestratorMetrics {
   public readonly tracer: Tracer;
 
   private baseRollupInputsDuration: Histogram;
-  private avmFallbackCount: UpDownCounter;
 
   constructor(client: TelemetryClient, name = 'ProvingOrchestrator') {
     this.tracer = client.getTracer(name);
@@ -22,20 +14,9 @@ export class ProvingOrchestratorMetrics {
       description: 'Duration to build base rollup inputs',
       valueType: ValueType.INT,
     });
-
-    this.avmFallbackCount = meter.createUpDownCounter(Metrics.PROVING_ORCHESTRATOR_AVM_FALLBACK_COUNT, {
-      description: 'How many times the AVM fallback was used',
-      valueType: ValueType.INT,
-    });
-
-    this.avmFallbackCount.add(0);
   }
 
   recordBaseRollupInputs(durationMs: number) {
     this.baseRollupInputsDuration.record(Math.ceil(durationMs));
   }
-
-  incAvmFallback() {
-    this.avmFallbackCount.add(1);
-  }
 }

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

@@ -1,14 +1,9 @@
-import {
-  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
-  AVM_VK_INDEX,
-  NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-} from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/fields';
+import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { getVkData } from '@aztec/noir-protocol-circuits-types/server/vks';
-import { getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
 import type { ProofAndVerificationKey, PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
-import { ProofData } from '@aztec/stdlib/proofs';
+import { ProofData, ProofDataForFixedVk } from '@aztec/stdlib/proofs';
 import {
   type BaseRollupHints,
   PrivateBaseRollupHints,
@@ -20,7 +15,6 @@ import {
 import type { CircuitName } from '@aztec/stdlib/stats';
 import type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
 import type { ProcessedTx } from '@aztec/stdlib/tx';
-import { VerificationKeyData, VkData } from '@aztec/stdlib/vks';
 
 import {
   getChonkProofFromTx,
@@ -120,19 +114,11 @@ export class TxProvingState {
 
     const publicChonkVerifierProofData = toProofData(this.publicChonkVerifier);
 
-    const avmProofData = new ProofData(
+    const avmProofData = new ProofDataForFixedVk(
       this.processedTx.avmProvingRequest.inputs.publicInputs,
       this.avm.proof,
-      this.#getVkData(this.avm!.verificationKey, AVM_VK_INDEX),
     );
 
     return new PublicTxBaseRollupPrivateInputs(publicChonkVerifierProofData, avmProofData, this.baseRollupHints);
   }
-
-  #getVkData(verificationKey: VerificationKeyData, vkIndex: number) {
-    // TODO(#17162): Add avm vk hash to the tree and call `getVkData('AVM')` instead.
-    // Below will return a path to an empty leaf.
-    const vkPath = getVKSiblingPath(vkIndex);
-    return new VkData(verificationKey, vkIndex, vkPath);
-  }
 }

package/src/prover-client/factory.ts

@@ -1,4 +1,8 @@
-import type { ForkMerkleTreeOperations, ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import type {
+  ForkMerkleTreeOperations,
+  ProvingJobBroker,
+  ReadonlyWorldStateAccess,
+} from '@aztec/stdlib/interfaces/server';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import type { ProverClientConfig } from '../config.js';
@@ -6,7 +10,7 @@ import { ProverClient } from './prover-client.js';
 
 export function createProverClient(
   config: ProverClientConfig,
-  worldState: ForkMerkleTreeOperations,
+  worldState: ForkMerkleTreeOperations & ReadonlyWorldStateAccess,
   broker: ProvingJobBroker,
   telemetry: TelemetryClient = getTelemetryClient(),
 ) {

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

@@ -11,6 +11,7 @@ import {
   type ProvingJobBroker,
   type ProvingJobConsumer,
   type ProvingJobProducer,
+  type ReadonlyWorldStateAccess,
   type ServerCircuitProver,
   tryStop,
 } from '@aztec/stdlib/interfaces/server';
@@ -33,7 +34,7 @@ export class ProverClient implements EpochProverManager {
 
   private constructor(
     private config: ProverClientConfig,
-    private worldState: ForkMerkleTreeOperations,
+    private worldState: ForkMerkleTreeOperations & ReadonlyWorldStateAccess,
     private orchestratorClient: ProvingJobProducer,
     private agentClient?: ProvingJobConsumer,
     private telemetry: TelemetryClient = getTelemetryClient(),
@@ -99,7 +100,7 @@ export class ProverClient implements EpochProverManager {
    */
   public static async new(
     config: ProverClientConfig,
-    worldState: ForkMerkleTreeOperations,
+    worldState: ForkMerkleTreeOperations & ReadonlyWorldStateAccess,
     broker: ProvingJobBroker,
     telemetry: TelemetryClient = getTelemetryClient(),
   ) {

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

@@ -1,5 +1,6 @@
-import type { BatchedBlob, FinalBlobBatchingChallenges } from '@aztec/blob-lib';
-import type { Fr } from '@aztec/foundation/fields';
+import type { BatchedBlob, FinalBlobBatchingChallenges } from '@aztec/blob-lib/types';
+import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/stdlib/block';
 import type { EpochProver } from '@aztec/stdlib/interfaces/server';
 import type { Proof } from '@aztec/stdlib/proofs';
@@ -18,7 +19,7 @@ export class ServerEpochProver implements EpochProver {
   ) {}
 
   startNewEpoch(
-    epochNumber: number,
+    epochNumber: EpochNumber,
     totalNumCheckpoints: number,
     finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
   ): void {
@@ -30,7 +31,6 @@ export class ServerEpochProver implements EpochProver {
     constants: CheckpointConstantData,
     l1ToL2Messages: Fr[],
     totalNumBlocks: number,
-    totalNumBlobFields: number,
     headerOfLastBlockInPreviousCheckpoint: BlockHeader,
   ): Promise<void> {
     return this.orchestrator.startNewCheckpoint(
@@ -38,14 +38,13 @@ export class ServerEpochProver implements EpochProver {
       constants,
       l1ToL2Messages,
       totalNumBlocks,
-      totalNumBlobFields,
       headerOfLastBlockInPreviousCheckpoint,
     );
   }
   startChonkVerifierCircuits(txs: Tx[]): Promise<void> {
     return this.orchestrator.startChonkVerifierCircuits(txs);
   }
-  setBlockCompleted(blockNumber: number, expectedBlockHeader?: BlockHeader): Promise<BlockHeader> {
+  setBlockCompleted(blockNumber: BlockNumber, expectedBlockHeader?: BlockHeader): Promise<BlockHeader> {
     return this.orchestrator.setBlockCompleted(blockNumber, expectedBlockHeader);
   }
   finalizeEpoch(): Promise<{ publicInputs: RootRollupPublicInputs; proof: Proof; batchedBlobInputs: BatchedBlob }> {
@@ -61,7 +60,7 @@ export class ServerEpochProver implements EpochProver {
     await this.facade.stop();
     await this.orchestrator.stop();
   }
-  startNewBlock(blockNumber: number, timestamp: UInt64, totalNumTxs: number): Promise<void> {
+  startNewBlock(blockNumber: BlockNumber, timestamp: UInt64, totalNumTxs: number): Promise<void> {
     return this.orchestrator.startNewBlock(blockNumber, timestamp, totalNumTxs);
   }
   addTxs(txs: ProcessedTx[]): Promise<void> {