@aztec/prover-client 0.57.0 → 0.58.0

package/src/orchestrator/orchestrator.ts

@@ -16,7 +16,7 @@ import {
   mapProvingRequestTypeToCircuitName,
   toTxEffect,
 } from '@aztec/circuit-types';
-import { type EpochProver } from '@aztec/circuit-types/interfaces';
+import { type EpochProver, type MerkleTreeWriteOperations } from '@aztec/circuit-types/interfaces';
 import { type CircuitName } from '@aztec/circuit-types/stats';
 import {
   AvmCircuitInputs,
@@ -28,6 +28,7 @@ import {
   EmptyBlockRootRollupInputs,
   Fr,
   type GlobalVariables,
+  type Header,
   type KernelCircuitPublicInputs,
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
@@ -41,6 +42,7 @@ import {
   type RecursiveProof,
   type RootParityInput,
   RootParityInputs,
+  TUBE_INDEX,
   type TUBE_PROOF_LENGTH,
   TubeInputs,
   type VMCircuitPublicInputs,
@@ -57,9 +59,9 @@ import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { type Tuple } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
 import { elapsed } from '@aztec/foundation/timer';
-import { getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types';
+import { TubeVk, getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
 import { Attributes, type TelemetryClient, type Tracer, trackSpan, wrapCallbackInSpan } from '@aztec/telemetry-client';
-import { type MerkleTreeOperations } from '@aztec/world-state';
 
 import { inspect } from 'util';
 
@@ -112,7 +114,7 @@ export class ProvingOrchestrator implements EpochProver {
   private metrics: ProvingOrchestratorMetrics;
 
   constructor(
-    private db: MerkleTreeOperations,
+    private db: MerkleTreeWriteOperations,
     private prover: ServerCircuitProver,
     telemetryClient: TelemetryClient,
     private readonly proverId: Fr = Fr.ZERO,
@@ -299,12 +301,16 @@ export class ProvingOrchestrator implements EpochProver {
       [Attributes.BLOCK_TXS_COUNT]: block.transactionsReceived,
     };
   })
-  public async setBlockCompleted(): Promise<L2Block> {
+  public async setBlockCompleted(expectedHeader?: Header): Promise<L2Block> {
     const provingState = this.provingState?.currentBlock;
     if (!provingState) {
       throw new Error(`Invalid proving state, call startNewBlock before adding transactions or completing the block`);
     }
 
+    if (!provingState.verifyState()) {
+      throw new Error(`Block proving failed: ${provingState.error}`);
+    }
+
     // We may need to pad the rollup with empty transactions
     const paddingTxCount = provingState.totalNumTxs - provingState.transactionsReceived;
     if (paddingTxCount > 0 && provingState.totalNumTxs > 2) {
@@ -325,6 +331,7 @@ export class ProvingOrchestrator implements EpochProver {
         provingState.globalVariables.chainId,
         provingState.globalVariables.version,
         getVKTreeRoot(),
+        protocolContractTreeRoot,
       );
       const txInputs: Array<{ inputs: BaseRollupInputs; snapshot: TreeSnapshots }> = [];
       for (let i = 0; i < paddingTxCount; i++) {
@@ -342,7 +349,7 @@ export class ProvingOrchestrator implements EpochProver {
 
     // And build the block header
     logger.verbose(`Block ${provingState.globalVariables.blockNumber} completed. Assembling header.`);
-    await this.buildBlock(provingState);
+    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
     this.checkAndEnqueueBlockRootRollup(provingState);
@@ -367,16 +374,16 @@ export class ProvingOrchestrator implements EpochProver {
       [Attributes.EPOCH_SIZE]: this.provingState.totalNumBlocks,
     };
   })
-  private padEpoch() {
+  private padEpoch(): Promise<void> {
     const provingState = this.provingState!;
     const lastBlock = provingState.currentBlock?.block;
     if (!lastBlock) {
-      throw new Error(`Epoch needs at least one completed block in order to be padded`);
+      return Promise.reject(new Error(`Epoch needs at least one completed block in order to be padded`));
     }
 
     const paddingBlockCount = Math.max(2, provingState.totalNumBlocks) - provingState.blocks.length;
     if (paddingBlockCount === 0) {
-      return;
+      return Promise.resolve();
     }
 
     logger.debug(`Padding epoch proof with ${paddingBlockCount} empty block proofs`);
@@ -386,6 +393,7 @@ export class ProvingOrchestrator implements EpochProver {
       blockHash: lastBlock.header.hash(),
       globalVariables: lastBlock.header.globalVariables,
       vkTreeRoot: getVKTreeRoot(),
+      protocolContractTreeRoot,
       proverId: this.proverId,
     });
 
@@ -415,9 +423,10 @@ export class ProvingOrchestrator implements EpochProver {
         }
       },
     );
+    return Promise.resolve();
   }
 
-  private async buildBlock(provingState: BlockProvingState) {
+  private async buildBlock(provingState: BlockProvingState, expectedHeader?: Header) {
     // Collect all new nullifiers, commitments, and contracts from all txs in this block to build body
     const gasFees = provingState.globalVariables.gasFees;
     const nonEmptyTxEffects: TxEffect[] = provingState!.allTxs
@@ -434,6 +443,11 @@ export class ProvingOrchestrator implements EpochProver {
       this.db,
     );
 
+    if (expectedHeader && !header.equals(expectedHeader)) {
+      logger.error(`Block header mismatch: header=${header} expectedHeader=${expectedHeader}`);
+      throw new Error('Block header mismatch');
+    }
+
     logger.verbose(`Updating archive tree with block ${provingState.blockNumber} header ${header.hash().toString()}`);
     await this.db.updateArchive(header);
 
@@ -486,6 +500,7 @@ export class ProvingOrchestrator implements EpochProver {
               unprovenPaddingTx.data.constants.txContext.chainId,
               unprovenPaddingTx.data.constants.txContext.version,
               getVKTreeRoot(),
+              protocolContractTreeRoot,
             ),
             signal,
             provingState.epochNumber,
@@ -566,7 +581,7 @@ export class ProvingOrchestrator implements EpochProver {
       throw new Error(`Invalid proving state, an epoch must be proven before it can be finalised`);
     }
 
-    this.padEpoch();
+    await this.padEpoch();
 
     const result = await this.provingPromise!;
     if (result.status === 'failure') {
@@ -700,7 +715,7 @@ export class ProvingOrchestrator implements EpochProver {
         makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
         provingState.globalVariables,
         this.db,
-        VerificationKeyData.makeFake(),
+        TubeVk,
       ),
     );
 
@@ -832,8 +847,14 @@ export class ProvingOrchestrator implements EpochProver {
       ),
       result => {
         logger.debug(`Completed tube proof for tx index: ${txIndex}`);
-        const nextKernelRequest = txProvingState.getNextPublicKernelFromTubeProof(result.tubeProof, result.tubeVK);
-        this.checkAndEnqueueNextTxCircuit(provingState, txIndex, result.tubeProof, result.tubeVK, nextKernelRequest);
+        const nextKernelRequest = txProvingState.getNextPublicKernelFromTubeProof(result.proof, result.verificationKey);
+        this.checkAndEnqueueNextTxCircuit(
+          provingState,
+          txIndex,
+          result.proof,
+          result.verificationKey,
+          nextKernelRequest,
+        );
       },
     );
   }
@@ -1217,7 +1238,10 @@ export class ProvingOrchestrator implements EpochProver {
               logger.warn(
                 `Error thrown when proving AVM circuit, but AVM_PROVING_STRICT is off, so faking AVM proof and carrying on. Error: ${err}.`,
               );
-              return { proof: makeEmptyProof(), verificationKey: VerificationKeyData.makeFake() };
+              return {
+                proof: makeEmptyProof(),
+                verificationKey: VerificationKeyData.makeFakeHonk(),
+              };
             }
           }
         },
@@ -1270,7 +1294,12 @@ export class ProvingOrchestrator implements EpochProver {
       // Take the final proof and assign it to the base rollup inputs
       txProvingState.baseRollupInputs.kernelData.proof = proof;
       txProvingState.baseRollupInputs.kernelData.vk = verificationKey;
-      txProvingState.baseRollupInputs.kernelData.vkIndex = getVKIndex(verificationKey);
+      try {
+        txProvingState.baseRollupInputs.kernelData.vkIndex = getVKIndex(verificationKey);
+      } catch (_ignored) {
+        // TODO(#7410) The VK for the tube won't be in the tree for now, so we manually set it to the tube vk index
+        txProvingState.baseRollupInputs.kernelData.vkIndex = TUBE_INDEX;
+      }
       txProvingState.baseRollupInputs.kernelData.vkPath = getVKSiblingPath(
         txProvingState.baseRollupInputs.kernelData.vkIndex,
       );

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

@@ -1,5 +1,5 @@
 import {
-  type AvmProofAndVerificationKey,
+  type ProofAndVerificationKey,
   type ProvingJob,
   type ProvingJobSource,
   type ProvingRequest,
@@ -21,6 +21,7 @@ import type {
   MergeRollupInputs,
   NESTED_RECURSIVE_PROOF_LENGTH,
   PrivateKernelEmptyInputData,
+  Proof,
   PublicKernelCircuitPrivateInputs,
   PublicKernelCircuitPublicInputs,
   PublicKernelInnerCircuitPrivateInputs,
@@ -33,7 +34,6 @@ import type {
   RootRollupPublicInputs,
   TubeInputs,
   VMCircuitPublicInputs,
-  VerificationKeyData,
 } from '@aztec/circuits.js';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { AbortError, TimeoutError } from '@aztec/foundation/error';
@@ -280,7 +280,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     inputs: TubeInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<{ tubeVK: VerificationKeyData; tubeProof: RecursiveProof<typeof RECURSIVE_PROOF_LENGTH> }> {
+  ): Promise<ProofAndVerificationKey<RecursiveProof<typeof RECURSIVE_PROOF_LENGTH>>> {
     return this.enqueue({ type: ProvingRequestType.TUBE_PROOF, inputs }, signal, epochNumber);
   }
 
@@ -427,7 +427,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     inputs: AvmCircuitInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<AvmProofAndVerificationKey> {
+  ): Promise<ProofAndVerificationKey<Proof>> {
     return this.enqueue({ type: ProvingRequestType.PUBLIC_VM, inputs }, signal, epochNumber);
   }
 

package/src/prover-agent/rpc.ts

@@ -1,7 +1,6 @@
 import { type ProvingJobSource } from '@aztec/circuit-types';
 import {
   AvmCircuitInputs,
-  AvmVerificationKeyData,
   AztecAddress,
   BaseOrMergeRollupPublicInputs,
   BaseParityInputs,
@@ -41,7 +40,6 @@ export function createProvingJobSourceServer(queue: ProvingJobSource): JsonRpcSe
   return new JsonRpcServer(
     queue,
     {
-      AvmVerificationKeyData,
       AvmCircuitInputs,
       BaseOrMergeRollupPublicInputs,
       BaseParityInputs,
@@ -83,7 +81,6 @@ export function createProvingJobSourceClient(
   return createJsonRpcClient(
     url,
     {
-      AvmVerificationKeyData,
       AvmCircuitInputs,
       BaseOrMergeRollupPublicInputs,
       BaseParityInputs,

package/src/test/mock_prover.ts

@@ -1,11 +1,12 @@
 import {
+  type ProofAndVerificationKey,
   type PublicInputsAndRecursiveProof,
-  type PublicInputsAndTubeProof,
   type ServerCircuitProver,
+  makeProofAndVerificationKey,
   makePublicInputsAndRecursiveProof,
 } from '@aztec/circuit-types';
 import {
-  AvmVerificationKeyData,
+  AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS,
   type BaseOrMergeRollupPublicInputs,
   type BlockRootOrBlockMergePublicInputs,
   type KernelCircuitPublicInputs,
@@ -13,6 +14,7 @@ import {
   RECURSIVE_PROOF_LENGTH,
   type RecursiveProof,
   type RootRollupPublicInputs,
+  TUBE_PROOF_LENGTH,
   type VMCircuitPublicInputs,
   VerificationKeyData,
   makeEmptyProof,
@@ -33,10 +35,10 @@ export class MockProver implements ServerCircuitProver {
 
   getAvmProof() {
     return Promise.resolve(
-      Promise.resolve({
-        proof: makeEmptyProof(),
-        verificationKey: AvmVerificationKeyData.makeFake(),
-      }),
+      makeProofAndVerificationKey(
+        makeEmptyProof(),
+        VerificationKeyData.makeFake(AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS),
+      ),
     );
   }
 
@@ -53,7 +55,7 @@ export class MockProver implements ServerCircuitProver {
       makePublicInputsAndRecursiveProof(
         makeBaseOrMergeRollupPublicInputs(),
         makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
-        VerificationKeyData.makeFake(),
+        VerificationKeyData.makeFakeHonk(),
       ),
     );
   }
@@ -63,7 +65,7 @@ export class MockProver implements ServerCircuitProver {
       makePublicInputsAndRecursiveProof(
         makeBaseOrMergeRollupPublicInputs(),
         makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
-        VerificationKeyData.makeFake(),
+        VerificationKeyData.makeFakeHonk(),
       ),
     );
   }
@@ -73,7 +75,7 @@ export class MockProver implements ServerCircuitProver {
       makePublicInputsAndRecursiveProof(
         makeBlockRootOrBlockMergeRollupPublicInputs(),
         makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
-        VerificationKeyData.makeFake(),
+        VerificationKeyData.makeFakeHonk(),
       ),
     );
   }
@@ -83,7 +85,7 @@ export class MockProver implements ServerCircuitProver {
       makePublicInputsAndRecursiveProof(
         makeBlockRootOrBlockMergeRollupPublicInputs(),
         makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
-        VerificationKeyData.makeFake(),
+        VerificationKeyData.makeFakeHonk(),
       ),
     );
   }
@@ -93,7 +95,7 @@ export class MockProver implements ServerCircuitProver {
       makePublicInputsAndRecursiveProof(
         makeBlockRootOrBlockMergeRollupPublicInputs(),
         makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
-        VerificationKeyData.makeFake(),
+        VerificationKeyData.makeFakeHonk(),
       ),
     );
   }
@@ -103,17 +105,17 @@ export class MockProver implements ServerCircuitProver {
       makePublicInputsAndRecursiveProof(
         makeKernelCircuitPublicInputs(),
         makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
-        VerificationKeyData.makeFake(),
+        VerificationKeyData.makeFakeHonk(),
       ),
     );
   }
 
-  getEmptyTubeProof(): Promise<PublicInputsAndTubeProof<KernelCircuitPublicInputs>> {
+  getEmptyTubeProof(): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeKernelCircuitPublicInputs(),
         makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
-        VerificationKeyData.makeFake(),
+        VerificationKeyData.makeFakeHonk(),
       ),
     );
   }
@@ -123,7 +125,7 @@ export class MockProver implements ServerCircuitProver {
       makePublicInputsAndRecursiveProof(
         makeVMCircuitPublicInputs(),
         makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
-        VerificationKeyData.makeFake(),
+        VerificationKeyData.makeFakeHonk(),
       ),
     );
   }
@@ -133,7 +135,7 @@ export class MockProver implements ServerCircuitProver {
       makePublicInputsAndRecursiveProof(
         makePublicKernelCircuitPublicInputs(),
         makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
-        VerificationKeyData.makeFake(),
+        VerificationKeyData.makeFakeHonk(),
       ),
     );
   }
@@ -143,7 +145,7 @@ export class MockProver implements ServerCircuitProver {
       makePublicInputsAndRecursiveProof(
         makeKernelCircuitPublicInputs(),
         makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
-        VerificationKeyData.makeFake(),
+        VerificationKeyData.makeFakeHonk(),
       ),
     );
   }
@@ -153,18 +155,14 @@ export class MockProver implements ServerCircuitProver {
       makePublicInputsAndRecursiveProof(
         makeRootRollupPublicInputs(),
         makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
-        VerificationKeyData.makeFake(),
+        VerificationKeyData.makeFakeHonk(),
       ),
     );
   }
 
-  getTubeProof(): Promise<{
-    tubeVK: VerificationKeyData;
-    tubeProof: RecursiveProof<typeof RECURSIVE_PROOF_LENGTH>;
-  }> {
-    return Promise.resolve({
-      tubeVK: VerificationKeyData.makeFake(),
-      tubeProof: makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
-    });
+  getTubeProof(): Promise<ProofAndVerificationKey<RecursiveProof<typeof TUBE_PROOF_LENGTH>>> {
+    return Promise.resolve(
+      makeProofAndVerificationKey(makeRecursiveProof(TUBE_PROOF_LENGTH), VerificationKeyData.makeFake()),
+    );
   }
 }

package/src/tx-prover/tx-prover.ts

@@ -2,13 +2,13 @@ import { BBNativeRollupProver, TestCircuitProver } from '@aztec/bb-prover';
 import {
   type EpochProver,
   type EpochProverManager,
+  type MerkleTreeWriteOperations,
   type ProvingJobSource,
   type ServerCircuitProver,
 } from '@aztec/circuit-types/interfaces';
 import { Fr } from '@aztec/circuits.js';
 import { NativeACVMSimulator } from '@aztec/simulator';
 import { type TelemetryClient } from '@aztec/telemetry-client';
-import { type MerkleTreeOperations } from '@aztec/world-state';
 
 import { type ProverClientConfig } from '../config.js';
 import { ProvingOrchestrator } from '../orchestrator/orchestrator.js';
@@ -33,7 +33,7 @@ export class TxProver implements EpochProverManager {
     this.queue = new MemoryProvingQueue(telemetry, config.proverJobTimeoutMs, config.proverJobPollIntervalMs);
   }
 
-  public createEpochProver(db: MerkleTreeOperations): EpochProver {
+  public createEpochProver(db: MerkleTreeWriteOperations): EpochProver {
     return new ProvingOrchestrator(db, this.queue, this.telemetry, this.config.proverId);
   }