@aztec/bb-prover 3.0.0-nightly.20250908 → 3.0.0-nightly.20250911

package/src/test/delay_values.ts

@@ -12,7 +12,7 @@ export const WITGEN_DELAY_MS: Record<ProvingRequestType, number> = {
   [ProvingRequestType.PUBLIC_BASE_ROLLUP]: 470_000,
   [ProvingRequestType.ROOT_PARITY]: 100,
   [ProvingRequestType.ROOT_ROLLUP]: 650,
-  [ProvingRequestType.TUBE_PROOF]: 0,
+  [ProvingRequestType.PUBLIC_TUBE]: 0,
   [ProvingRequestType.PUBLIC_VM]: 0,
 };
 
@@ -28,6 +28,6 @@ export const PROOF_DELAY_MS: Record<ProvingRequestType, number> = {
   [ProvingRequestType.PUBLIC_BASE_ROLLUP]: 160_000,
   [ProvingRequestType.ROOT_PARITY]: 30_000,
   [ProvingRequestType.ROOT_ROLLUP]: 15_000,
-  [ProvingRequestType.TUBE_PROOF]: 30_000,
+  [ProvingRequestType.PUBLIC_TUBE]: 30_000,
   [ProvingRequestType.PUBLIC_VM]: 0,
 };

package/src/test/test_circuit_prover.ts

@@ -4,7 +4,6 @@ import {
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
-  TUBE_PROOF_LENGTH,
 } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
@@ -47,6 +46,7 @@ import {
   makeProofAndVerificationKey,
   makePublicInputsAndRecursiveProof,
 } from '@aztec/stdlib/interfaces/server';
+import type { PrivateToPublicKernelCircuitPublicInputs } from '@aztec/stdlib/kernel';
 import type { BaseParityInputs, ParityPublicInputs, RootParityInputs } from '@aztec/stdlib/parity';
 import { type Proof, ProvingRequestType, makeEmptyRecursiveProof, makeRecursiveProof } from '@aztec/stdlib/proofs';
 import type {
@@ -59,10 +59,10 @@ import type {
   PaddingBlockRootRollupInputs,
   PrivateBaseRollupInputs,
   PublicBaseRollupInputs,
+  PublicTubePrivateInputs,
   RootRollupInputs,
   RootRollupPublicInputs,
   SingleTxBlockRootRollupInputs,
-  TubeInputs,
 } from '@aztec/stdlib/rollup';
 import { VerificationKeyData } from '@aztec/stdlib/vks';
 import { type TelemetryClient, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
@@ -142,9 +142,20 @@ export class TestCircuitProver implements ServerCircuitProver {
     );
   }
 
-  public getTubeProof(_tubeInput: TubeInputs): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>> {
-    return this.applyDelay(ProvingRequestType.TUBE_PROOF, () =>
-      makeProofAndVerificationKey(makeEmptyRecursiveProof(TUBE_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()),
+  public getPublicTubeProof(
+    inputs: PublicTubePrivateInputs,
+  ): Promise<
+    PublicInputsAndRecursiveProof<
+      PrivateToPublicKernelCircuitPublicInputs,
+      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+    >
+  > {
+    return this.applyDelay(ProvingRequestType.PUBLIC_TUBE, () =>
+      makePublicInputsAndRecursiveProof(
+        inputs.hidingKernelProofData.publicInputs,
+        makeEmptyRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        ProtocolCircuitVks.PublicTube,
+      ),
     );
   }
 

package/src/verifier/bb_verifier.ts

@@ -1,8 +1,12 @@
 import { runInDirectory } from '@aztec/foundation/fs';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
-import type { ClientProtocolArtifact, ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/types';
+import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
+import type {
+  ClientProtocolArtifact,
+  ProtocolArtifact,
+  ServerProtocolArtifact,
+} from '@aztec/noir-protocol-circuits-types/types';
 import type { ClientProtocolCircuitVerifier, IVCProofVerificationResult } from '@aztec/stdlib/interfaces/server';
 import type { Proof } from '@aztec/stdlib/proofs';
 import type { CircuitVerificationStats } from '@aztec/stdlib/stats';
@@ -11,7 +15,6 @@ import type { VerificationKeyData } from '@aztec/stdlib/vks';
 
 import { promises as fs } from 'fs';
 import * as path from 'path';
-import { fileURLToPath } from 'url';
 
 import {
   BB_RESULT,
@@ -23,15 +26,9 @@ import {
 } from '../bb/execute.js';
 import type { BBConfig } from '../config.js';
 import { getUltraHonkFlavorForCircuit } from '../honk.js';
-import { writeClientIVCProofToOutputDirectory } from '../prover/proof_utils.js';
+import { writeClientIVCProofToPath } from '../prover/proof_utils.js';
 import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-// Built by yarn generate
-export const PRIVATE_TAIL_CIVC_VK = path.join(__dirname, '../../artifacts/private-civc-vk');
-export const PUBLIC_TAIL_CIVC_VK = path.join(__dirname, '../../artifacts/public-civc-vk');
-
 export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
   private constructor(
     private config: BBConfig,
@@ -47,10 +44,10 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
     return new BBCircuitVerifier(config, logger);
   }
 
-  public getVerificationKeyData(circuitType: ServerProtocolArtifact): VerificationKeyData {
-    const vk = ServerCircuitVks[circuitType];
+  public getVerificationKeyData(circuit: ProtocolArtifact): VerificationKeyData {
+    const vk = ProtocolCircuitVks[circuit];
     if (vk === undefined) {
-      throw new Error('Could not find VK for server artifact ' + circuitType);
+      throw new Error(`Could not find VK for artifact ${circuit}`);
     }
     return vk;
   }
@@ -93,42 +90,43 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
   }
 
   public async verifyProof(tx: Tx): Promise<IVCProofVerificationResult> {
+    const proofType = 'ClientIVC';
     try {
       const totalTimer = new Timer();
       let verificationDuration = 0;
-      // TODO(#7370) The verification keys should be supplied separately and based on the expectedCircuit
-      // rather than read from the tx object itself. We also need the vks for the translator and ecc, which
-      // are not being saved along the other vks yet. Reuse the 'verifyProofForCircuit' method above once
-      // we have all the verification keys available.
-      const expectedCircuit: ClientProtocolArtifact = tx.data.forPublic
-        ? 'PrivateKernelTailToPublicArtifact'
-        : 'PrivateKernelTailArtifact';
-      const circuit = 'ClientIVC';
+
+      const circuit: ClientProtocolArtifact = tx.data.forPublic ? 'HidingKernelToPublic' : 'HidingKernelToRollup';
 
       // Block below is almost copy-pasted from verifyProofForCircuit
       const operation = async (bbWorkingDirectory: string) => {
         const logFunction = (message: string) => {
-          this.logger.debug(`${circuit} BB out - ${message}`);
+          this.logger.debug(`${proofType} BB out - ${message}`);
         };
 
-        await writeClientIVCProofToOutputDirectory(tx.clientIvcProof, bbWorkingDirectory);
+        const proofPath = path.join(bbWorkingDirectory, PROOF_FILENAME);
+        await writeClientIVCProofToPath(tx.clientIvcProof, proofPath);
+
+        const verificationKeyPath = path.join(bbWorkingDirectory, VK_FILENAME);
+        const verificationKey = this.getVerificationKeyData(circuit);
+        await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
+
         const timer = new Timer();
         const result = await verifyClientIvcProof(
           this.config.bbBinaryPath,
-          bbWorkingDirectory.concat('/proof'),
-          tx.data.forPublic ? PUBLIC_TAIL_CIVC_VK : PRIVATE_TAIL_CIVC_VK,
+          proofPath,
+          verificationKeyPath,
           logFunction,
           this.config.bbIVCConcurrency,
         );
         verificationDuration = timer.ms();
 
         if (result.status === BB_RESULT.FAILURE) {
-          const errorMessage = `Failed to verify ${circuit} proof for ${expectedCircuit}!`;
+          const errorMessage = `Failed to verify ${proofType} proof for ${circuit}!`;
           throw new Error(errorMessage);
         }
 
-        this.logger.debug(`${circuit} verification successful`, {
-          circuitName: mapProtocolArtifactNameToCircuitName(expectedCircuit),
+        this.logger.debug(`${proofType} verification successful`, {
+          circuitName: mapProtocolArtifactNameToCircuitName(circuit),
           duration: result.durationMs,
           eventName: 'circuit-verification',
           proofType: 'client-ivc',
@@ -137,7 +135,7 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
       await runInDirectory(this.config.bbWorkingDirectory, operation, this.config.bbSkipCleanup, this.logger);
       return { valid: true, durationMs: verificationDuration, totalDurationMs: totalTimer.ms() };
     } catch (err) {
-      this.logger.warn(`Failed to verify ClientIVC proof for tx ${tx.getTxHash().toString()}: ${String(err)}`);
+      this.logger.warn(`Failed to verify ${proofType} proof for tx ${tx.getTxHash().toString()}: ${String(err)}`);
       return { valid: false, durationMs: 0, totalDurationMs: 0 };
     }
   }