@aztec/bb-prover 0.0.1-commit.2f68f620 → 0.0.1-commit.3100065

package/dest/verifier/batch_chonk_verifier.js

@@ -6,21 +6,19 @@ import { Timer } from '@aztec/foundation/timer';
 import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks';
 import { Unpackr } from 'msgpackr';
 import { execFile } from 'node:child_process';
-import { rmSync } from 'node:fs';
-import { mkdtemp, rm } from 'node:fs/promises';
+import { unlinkSync } from 'node:fs';
+import { unlink } from 'node:fs/promises';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { promisify } from 'node:util';
 const execFileAsync = promisify(execFile);
-const RESULT_TIMEOUT_MS = 5 * 60 * 1000;
-const STOP_DRAIN_TIMEOUT_MS = 5_000;
 /** Maps client protocol artifacts used for chonk verification to VK indices. */ const CHONK_VK_ARTIFACTS = [
     'HidingKernelToRollup',
     'HidingKernelToPublic'
 ];
 /**
  * Batch verifier for Chonk IVC proofs. Uses the bb batch verifier service
- * which batches IPA verification into a constant number of SRS MSMs for better throughput.
+ * which batches IPA verification into a single SRS MSM for better throughput.
  *
  * Architecture:
  * - Spawns a persistent `bb msgpack run` process via Barretenberg (native backend)
@@ -33,7 +31,6 @@ const STOP_DRAIN_TIMEOUT_MS = 5_000;
     batchSize;
     label;
     bb;
-    fifoDir;
     fifoPath;
     nextRequestId;
     pendingRequests;
@@ -42,22 +39,17 @@ const STOP_DRAIN_TIMEOUT_MS = 5_000;
     logger;
     /** Maps artifact name to VK index in the batch verifier. */ vkIndexMap;
     /** Bound cleanup handler for process exit signals. */ exitCleanup;
-    stopped;
-    fatalError;
-    pendingDrainedResolvers;
     constructor(config, vkBuffers, batchSize, label){
         this.config = config;
         this.vkBuffers = vkBuffers;
         this.batchSize = batchSize;
         this.label = label;
-        this.fifoPath = '';
         this.nextRequestId = 0;
         this.pendingRequests = new Map();
         this.logger = createLogger('bb-prover:batch_chonk_verifier');
         this.vkIndexMap = new Map();
         this.exitCleanup = null;
-        this.stopped = false;
-        this.pendingDrainedResolvers = new Set();
+        this.fifoPath = path.join(os.tmpdir(), `bb-batch-${label}-${process.pid}-${Date.now()}.fifo`);
         this.fifoReader = new FifoFrameReader();
         this.sendQueue = new SerialQueue();
         this.sendQueue.start(1);
@@ -88,91 +80,47 @@ const STOP_DRAIN_TIMEOUT_MS = 5_000;
     }
     async start() {
         this.logger.info('Starting BatchChonkVerifier');
-        try {
-            this.bb = await Barretenberg.new({
-                bbPath: this.config.bbBinaryPath,
-                backend: BackendType.NativeUnixSocket
-            });
-            await this.bb.initSRSChonk();
-            // Keep the FIFO in a private directory so cleanup has a single owner.
-            this.fifoDir = await mkdtemp(path.join(os.tmpdir(), `bb-batch-${this.label}-${process.pid}-`));
-            this.fifoPath = path.join(this.fifoDir, 'results.fifo');
-            await execFileAsync('mkfifo', [
-                this.fifoPath
-            ]);
-            this.registerExitCleanup();
-            this.startFifoReader();
-            await this.bb.chonkBatchVerifierStart({
-                vks: this.vkBuffers,
-                numCores: this.config.bbChonkVerifyConcurrency || 0,
-                batchSize: this.batchSize,
-                fifoPath: this.fifoPath
-            });
-        } catch (err) {
-            this.fifoReader.stop();
-            this.deregisterExitCleanup();
-            await this.cleanupFifo();
-            await this.bb?.destroy().catch(()=>{});
-            throw err;
-        }
+        this.bb = await Barretenberg.new({
+            bbPath: this.config.bbBinaryPath,
+            backend: BackendType.NativeUnixSocket
+        });
+        await this.bb.initSRSChonk();
+        await execFileAsync('mkfifo', [
+            this.fifoPath
+        ]);
+        this.registerExitCleanup();
+        await this.bb.chonkBatchVerifierStart({
+            vks: this.vkBuffers,
+            numCores: this.config.bbChonkVerifyConcurrency || 0,
+            batchSize: this.batchSize,
+            fifoPath: this.fifoPath
+        });
+        this.startFifoReader();
         this.logger.info('BatchChonkVerifier started', {
             fifoPath: this.fifoPath
         });
     }
     verifyProof(tx) {
-        const totalTimer = new Timer();
-        return (async ()=>{
-            const circuit = tx.data.forPublic ? 'HidingKernelToPublic' : 'HidingKernelToRollup';
-            const vkIndex = this.vkIndexMap.get(circuit);
-            if (vkIndex === undefined) {
-                throw new Error(`No VK index for circuit ${circuit}`);
-            }
-            const proofWithPubInputs = tx.chonkProof.attachPublicInputs(tx.data.publicInputs().toFields());
-            const proofFields = proofWithPubInputs.fieldsWithPublicInputs.map((f)=>f.toBuffer());
-            return await this.enqueueProof(vkIndex, proofFields);
-        })().catch((err)=>{
-            this.logger.warn(`Failed to verify Chonk proof for tx ${tx.getTxHash().toString()}: ${String(err)}`);
-            return {
-                valid: false,
-                durationMs: 0,
-                totalDurationMs: totalTimer.ms()
-            };
-        });
+        const circuit = tx.data.forPublic ? 'HidingKernelToPublic' : 'HidingKernelToRollup';
+        const vkIndex = this.vkIndexMap.get(circuit);
+        if (vkIndex === undefined) {
+            throw new Error(`No VK index for circuit ${circuit}`);
+        }
+        const proofWithPubInputs = tx.chonkProof.attachPublicInputs(tx.data.publicInputs().toFields());
+        const proofFields = proofWithPubInputs.fieldsWithPublicInputs.map((f)=>f.toBuffer());
+        return this.enqueueProof(vkIndex, proofFields);
     }
     /** Enqueue raw proof fields for verification. Used directly by tests with custom VKs. */ enqueueProof(vkIndex, proofFields) {
-        if (this.stopped) {
-            return Promise.reject(new Error('BatchChonkVerifier stopped'));
-        }
-        if (this.fatalError) {
-            return Promise.reject(this.fatalError);
-        }
         const totalTimer = new Timer();
         const requestId = this.nextRequestId++;
         const resultPromise = new Promise((resolve, reject)=>{
-            const timeout = setTimeout(()=>{
-                const pending = this.pendingRequests.get(requestId);
-                if (!pending) {
-                    return;
-                }
-                this.pendingRequests.delete(requestId);
-                pending.reject(new Error(`BatchChonkVerifier result timed out for request_id=${requestId}`));
-                this.notifyPendingDrained();
-            }, RESULT_TIMEOUT_MS);
-            // A pending result timer must never keep the host process alive on its own (e.g. an
-            // orphaned request at process exit); the FIFO reader keeps the loop alive while results
-            // are genuinely awaited.
-            timeout.unref();
             this.pendingRequests.set(requestId, {
                 resolve,
                 reject,
-                totalTimer,
-                timeout
+                totalTimer
             });
         });
         void this.sendQueue.put(async ()=>{
-            if (this.fatalError) {
-                throw this.fatalError;
-            }
             await this.bb.chonkBatchVerifierQueue({
                 requestId,
                 vkIndex,
@@ -182,62 +130,35 @@ const STOP_DRAIN_TIMEOUT_MS = 5_000;
             const pending = this.pendingRequests.get(requestId);
             if (pending) {
                 this.pendingRequests.delete(requestId);
-                clearTimeout(pending.timeout);
                 pending.reject(err instanceof Error ? err : new Error(String(err)));
-                this.notifyPendingDrained();
             }
         });
         return resultPromise;
     }
     async stop() {
         this.logger.info('Stopping BatchChonkVerifier');
-        this.stopped = true;
+        // Stop accepting new proofs
+        await this.sendQueue.end();
+        // Stop the bb service (flushes remaining proofs)
         try {
-            // Stop accepting new proofs and flush the send queue. Bound it so an unresponsive
-            // native process can't block teardown of our own event-loop handles indefinitely.
-            await this.withTimeout(this.sendQueue.end(), STOP_DRAIN_TIMEOUT_MS, 'send queue flush');
-            // Stop the bb service (flushes remaining proofs).
-            await this.withTimeout(this.bb.chonkBatchVerifierStop({}), STOP_DRAIN_TIMEOUT_MS, 'chonkBatchVerifierStop');
-            // Native stop flushes callbacks; keep the FIFO open until those frames are observed.
-            const drained = await this.waitForPendingRequestsToDrain(STOP_DRAIN_TIMEOUT_MS);
-            if (!drained) {
-                this.rejectPendingRequests(new Error('Timed out waiting for BatchChonkVerifier results during stop'));
-            }
+            await this.bb.chonkBatchVerifierStop({});
         } catch (err) {
-            this.logger.warn(`Error during BatchChonkVerifier graceful stop: ${err}`);
-            this.rejectPendingRequests(err instanceof Error ? err : new Error(String(err)));
-        } finally{
-            // Always release our own event-loop handles — the FIFO read stream (a blocking
-            // threadpool read that can't be unref'd), the unix socket, the native process, and the
-            // exit handler — so the host process exits cleanly even if the native backend is wedged.
-            this.fifoReader.stop();
-            this.deregisterExitCleanup();
-            await this.cleanupFifo();
-            await this.bb.destroy().catch((err)=>this.logger.warn(`Error destroying bb backend during stop: ${err}`));
+            this.logger.warn(`Error stopping batch verifier service: ${err}`);
+        }
+        // Stop FIFO reader
+        this.fifoReader.stop();
+        // Clean up FIFO file and deregister exit handler
+        await unlink(this.fifoPath).catch(()=>{});
+        this.deregisterExitCleanup();
+        // Reject any remaining pending requests
+        for (const [id, pending] of this.pendingRequests){
+            pending.reject(new Error('BatchChonkVerifier stopped'));
+            this.pendingRequests.delete(id);
         }
+        // Destroy bb process
+        await this.bb.destroy();
         this.logger.info('BatchChonkVerifier stopped');
     }
-    /**
-   * Races a promise against a timeout so a wedged native backend can't block teardown. The
-   * timer is unref'd so it never keeps the process alive; the underlying promise stays handled
-   * by the race even if the timeout wins, so it cannot surface as an unhandled rejection.
-   */ async withTimeout(promise, timeoutMs, label) {
-        let timer;
-        const timeout = new Promise((_, reject)=>{
-            timer = setTimeout(()=>reject(new Error(`BatchChonkVerifier ${label} timed out after ${timeoutMs}ms`)), timeoutMs);
-            timer.unref();
-        });
-        try {
-            return await Promise.race([
-                promise,
-                timeout
-            ]);
-        } finally{
-            if (timer) {
-                clearTimeout(timer);
-            }
-        }
-    }
     startFifoReader() {
         const unpackr = new Unpackr({
             useRecords: false
@@ -248,18 +169,16 @@ const STOP_DRAIN_TIMEOUT_MS = 5_000;
                 this.handleResult(result);
             } catch (err) {
                 this.logger.error(`FIFO: failed to decode msgpack result: ${err}`);
-                // A corrupt result stream cannot safely be matched to outstanding requests.
-                this.failVerifier(err instanceof Error ? err : new Error(String(err)));
             }
         });
         this.fifoReader.on('error', (err)=>{
             this.logger.error(`FIFO reader error: ${err}`);
-            this.failVerifier(err);
         });
         this.fifoReader.on('end', ()=>{
             this.logger.debug('FIFO reader: stream ended');
-            if (!this.stopped) {
-                this.failVerifier(new Error('FIFO stream ended unexpectedly'));
+            for (const [id, pending] of this.pendingRequests){
+                pending.reject(new Error('FIFO stream ended unexpectedly'));
+                this.pendingRequests.delete(id);
             }
         });
         this.fifoReader.start(this.fifoPath);
@@ -271,7 +190,6 @@ const STOP_DRAIN_TIMEOUT_MS = 5_000;
             return;
         }
         this.pendingRequests.delete(result.request_id);
-        clearTimeout(pending.timeout);
         const valid = result.status === 0; // VerifyStatus::OK
         const durationMs = result.time_in_verify_ms;
         const totalDurationMs = pending.totalTimer.ms();
@@ -290,95 +208,25 @@ const STOP_DRAIN_TIMEOUT_MS = 5_000;
             });
         }
         pending.resolve(ivcResult);
-        this.notifyPendingDrained();
     }
     registerExitCleanup() {
+        // Signal handlers must be synchronous — unlinkSync is intentional here
         this.exitCleanup = ()=>{
-            this.cleanupFifoSync();
+            try {
+                unlinkSync(this.fifoPath);
+            } catch  {
+            /* ignore */ }
         };
         process.on('exit', this.exitCleanup);
+        process.on('SIGINT', this.exitCleanup);
+        process.on('SIGTERM', this.exitCleanup);
     }
     deregisterExitCleanup() {
         if (this.exitCleanup) {
             process.removeListener('exit', this.exitCleanup);
+            process.removeListener('SIGINT', this.exitCleanup);
+            process.removeListener('SIGTERM', this.exitCleanup);
             this.exitCleanup = null;
         }
     }
-    rejectPendingRequests(error) {
-        for (const [id, pending] of Array.from(this.pendingRequests)){
-            pending.reject(error);
-            clearTimeout(pending.timeout);
-            this.pendingRequests.delete(id);
-        }
-        this.notifyPendingDrained();
-    }
-    failVerifier(error) {
-        if (!this.fatalError) {
-            this.fatalError = error;
-        }
-        this.rejectPendingRequests(error);
-    }
-    waitForPendingRequestsToDrain(timeoutMs) {
-        if (this.pendingRequests.size === 0) {
-            return Promise.resolve(true);
-        }
-        let timeout;
-        let onDrain;
-        const drained = new Promise((resolve)=>{
-            onDrain = ()=>resolve(true);
-            this.pendingDrainedResolvers.add(onDrain);
-        });
-        const timedOut = new Promise((resolve)=>{
-            timeout = setTimeout(()=>resolve(false), timeoutMs);
-            timeout.unref();
-        });
-        return Promise.race([
-            drained,
-            timedOut
-        ]).finally(()=>{
-            if (timeout) {
-                clearTimeout(timeout);
-            }
-            if (onDrain) {
-                this.pendingDrainedResolvers.delete(onDrain);
-            }
-        });
-    }
-    notifyPendingDrained() {
-        if (this.pendingRequests.size > 0) {
-            return;
-        }
-        for (const resolve of Array.from(this.pendingDrainedResolvers)){
-            resolve();
-        }
-    }
-    async cleanupFifo() {
-        if (this.fifoDir) {
-            await rm(this.fifoDir, {
-                recursive: true,
-                force: true
-            }).catch(()=>{});
-        } else if (this.fifoPath) {
-            await rm(this.fifoPath, {
-                force: true
-            }).catch(()=>{});
-        }
-        this.fifoDir = undefined;
-        this.fifoPath = '';
-    }
-    cleanupFifoSync() {
-        try {
-            if (this.fifoDir) {
-                rmSync(this.fifoDir, {
-                    recursive: true,
-                    force: true
-                });
-            } else if (this.fifoPath) {
-                rmSync(this.fifoPath, {
-                    force: true
-                });
-            }
-        } catch  {
-        /* ignore */ }
-    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/bb-prover",
-  "version": "0.0.1-commit.2f68f620",
+  "version": "0.0.1-commit.3100065",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -70,16 +70,16 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb.js": "0.0.1-commit.2f68f620",
-    "@aztec/constants": "0.0.1-commit.2f68f620",
-    "@aztec/foundation": "0.0.1-commit.2f68f620",
-    "@aztec/noir-noirc_abi": "0.0.1-commit.2f68f620",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.2f68f620",
-    "@aztec/noir-types": "0.0.1-commit.2f68f620",
-    "@aztec/simulator": "0.0.1-commit.2f68f620",
-    "@aztec/stdlib": "0.0.1-commit.2f68f620",
-    "@aztec/telemetry-client": "0.0.1-commit.2f68f620",
-    "@aztec/world-state": "0.0.1-commit.2f68f620",
+    "@aztec/bb.js": "0.0.1-commit.3100065",
+    "@aztec/constants": "0.0.1-commit.3100065",
+    "@aztec/foundation": "0.0.1-commit.3100065",
+    "@aztec/noir-noirc_abi": "0.0.1-commit.3100065",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.3100065",
+    "@aztec/noir-types": "0.0.1-commit.3100065",
+    "@aztec/simulator": "0.0.1-commit.3100065",
+    "@aztec/stdlib": "0.0.1-commit.3100065",
+    "@aztec/telemetry-client": "0.0.1-commit.3100065",
+    "@aztec/world-state": "0.0.1-commit.3100065",
     "commander": "^12.1.0",
     "msgpackr": "^1.11.2",
     "pako": "^2.1.0",
@@ -87,11 +87,11 @@
     "tslib": "^2.4.0"
   },
   "devDependencies": {
-    "@aztec/ethereum": "0.0.1-commit.2f68f620",
-    "@aztec/kv-store": "0.0.1-commit.2f68f620",
-    "@aztec/noir-contracts.js": "0.0.1-commit.2f68f620",
-    "@aztec/noir-test-contracts.js": "0.0.1-commit.2f68f620",
-    "@aztec/protocol-contracts": "0.0.1-commit.2f68f620",
+    "@aztec/ethereum": "0.0.1-commit.3100065",
+    "@aztec/kv-store": "0.0.1-commit.3100065",
+    "@aztec/noir-contracts.js": "0.0.1-commit.3100065",
+    "@aztec/noir-test-contracts.js": "0.0.1-commit.3100065",
+    "@aztec/protocol-contracts": "0.0.1-commit.3100065",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",

package/src/avm_proving_tests/avm_proving_tester.ts

@@ -192,7 +192,7 @@ export class AvmProvingTester extends PublicTxSimulationTester {
     gasLimits?: Gas,
   ) {
     await this.simProveVerify(
-      /*sender=*/ AztecAddress.fromNumber(42),
+      /*sender=*/ AztecAddress.fromNumberUnsafe(42),
       /*setupCalls=*/ [],
       [appCall],
       undefined,

package/src/prover/client/bb_private_kernel_prover.ts

@@ -19,12 +19,13 @@ import {
   convertPrivateKernelInnerOutputsFromWitnessMapWithAbi,
   convertPrivateKernelResetInputsToWitnessMapWithAbi,
   convertPrivateKernelResetOutputsFromWitnessMapWithAbi,
+  convertPrivateKernelResetTailInputsToWitnessMapWithAbi,
+  convertPrivateKernelResetTailToPublicInputsToWitnessMapWithAbi,
   convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi,
-  convertPrivateKernelTailInputsToWitnessMapWithAbi,
   convertPrivateKernelTailOutputsFromWitnessMapWithAbi,
-  convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi,
   foreignCallHandler,
   getPrivateKernelResetArtifactName,
+  getPrivateKernelResetTailArtifactName,
   updateResetCircuitSampleInputs,
 } from '@aztec/noir-protocol-circuits-types/client';
 import {
@@ -47,8 +48,8 @@ import type {
   PrivateKernelInner3CircuitPrivateInputs,
   PrivateKernelInnerCircuitPrivateInputs,
   PrivateKernelResetCircuitPrivateInputs,
+  PrivateKernelResetTailCircuitPrivateInputs,
   PrivateKernelSimulateOutput,
-  PrivateKernelTailCircuitPrivateInputs,
   PrivateKernelTailCircuitPublicInputs,
 } from '@aztec/stdlib/kernel';
 import type { NoirCompiledCircuitWithName } from '@aztec/stdlib/noir';
@@ -228,40 +229,42 @@ export abstract class BBPrivateKernelProver implements PrivateKernelProver {
     );
   }
 
-  public async generateTailOutput(
-    inputs: PrivateKernelTailCircuitPrivateInputs,
+  public async generateResetTailOutput(
+    inputs: PrivateKernelResetTailCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    const artifactName = getPrivateKernelResetTailArtifactName(inputs.dimensions, inputs.isForPublic());
     if (!inputs.isForPublic()) {
       return await this.generateCircuitOutput(
         inputs,
-        'PrivateKernelTailArtifact',
-        convertPrivateKernelTailInputsToWitnessMapWithAbi,
+        artifactName,
+        convertPrivateKernelResetTailInputsToWitnessMapWithAbi,
         convertPrivateKernelTailOutputsFromWitnessMapWithAbi,
       );
     }
     return await this.generateCircuitOutput(
       inputs,
-      'PrivateKernelTailToPublicArtifact',
-      convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi,
+      artifactName,
+      convertPrivateKernelResetTailToPublicInputsToWitnessMapWithAbi,
       convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi,
     );
   }
 
-  public async simulateTail(
-    inputs: PrivateKernelTailCircuitPrivateInputs,
+  public async simulateResetTail(
+    inputs: PrivateKernelResetTailCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    const artifactName = getPrivateKernelResetTailArtifactName(inputs.dimensions, inputs.isForPublic());
     if (!inputs.isForPublic()) {
       return await this.simulateCircuitOutput(
         inputs,
-        'PrivateKernelTailArtifact',
-        convertPrivateKernelTailInputsToWitnessMapWithAbi,
+        artifactName,
+        convertPrivateKernelResetTailInputsToWitnessMapWithAbi,
         convertPrivateKernelTailOutputsFromWitnessMapWithAbi,
       );
     }
     return await this.simulateCircuitOutput(
       inputs,
-      'PrivateKernelTailToPublicArtifact',
-      convertPrivateKernelTailToPublicInputsToWitnessMapWithAbi,
+      artifactName,
+      convertPrivateKernelResetTailToPublicInputsToWitnessMapWithAbi,
       convertPrivateKernelTailForPublicOutputsFromWitnessMapWithAbi,
     );
   }

package/src/prover/server/bb_prover.ts

@@ -1,5 +1,5 @@
 import {
-  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
+  AVM_V2_PROOF_LENGTH_IN_FIELDS,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   PAIRING_POINTS_SIZE,
@@ -177,9 +177,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   @trackSpan('BBNativeRollupProver.getAvmProof', inputs => ({
     [Attributes.APP_CIRCUIT_NAME]: inputs.hints.tx.hash,
   }))
-  public async getAvmProof(
-    inputs: AvmCircuitInputs,
-  ): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
+  public async getAvmProof(inputs: AvmCircuitInputs): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS>> {
     const proof = await this.createAvmProof(inputs);
     await this.verifyAvmProof(proof.binaryProof, inputs.publicInputs);
     return proof;
@@ -508,9 +506,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     };
   }
 
-  private async createAvmProof(
-    input: AvmCircuitInputs,
-  ): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
+  private async createAvmProof(input: AvmCircuitInputs): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS>> {
     logger.info(`Proving avm-circuit for TX ${input.hints.tx.hash}...`);
 
     const inputsBuffer = input.serializeWithMessagePack();
@@ -520,20 +516,14 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     // Convert Uint8Array[] (32-byte field elements) to Fr[]
     const proofFields = proofFieldArrays.map(f => Fr.fromBuffer(Buffer.from(f)));
 
-    // Pad to fixed size (during development the proof length may vary)
-    if (proofFields.length > AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED) {
-      throw new Error(
-        `Proof has ${proofFields.length} fields, expected no more than ${AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED}.`,
-      );
+    if (proofFields.length !== AVM_V2_PROOF_LENGTH_IN_FIELDS) {
+      throw new Error(`Proof has ${proofFields.length} fields, expected exactly ${AVM_V2_PROOF_LENGTH_IN_FIELDS}.`);
     }
-    const proofFieldsPadded = proofFields.concat(
-      Array(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED - proofFields.length).fill(new Fr(0)),
-    );
 
     // Build the binary proof from the raw field data
     const rawProofBuffer = Buffer.concat(proofFieldArrays.map(f => Buffer.from(f)));
     const binaryProof = new Proof(rawProofBuffer, /*numPublicInputs=*/ 0);
-    const avmProof = new RecursiveProof(proofFieldsPadded, binaryProof, true, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED);
+    const avmProof = new RecursiveProof(proofFields, binaryProof, true, AVM_V2_PROOF_LENGTH_IN_FIELDS);
 
     const circuitType = 'avm-circuit' as const;
     const appCircuitName = 'unknown' as const;

package/src/test/test_circuit_prover.ts

@@ -1,5 +1,5 @@
 import {
-  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
+  AVM_V2_PROOF_LENGTH_IN_FIELDS,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
@@ -402,13 +402,11 @@ export class TestCircuitProver implements ServerCircuitProver {
     );
   }
 
-  public getAvmProof(_inputs: AvmCircuitInputs): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>> {
+  public getAvmProof(_inputs: AvmCircuitInputs): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS>> {
     // We can't simulate the AVM because we don't have enough context to do so (e.g., DBs).
     // We just return an empty proof.
     this.logger.debug('Skipping AVM simulation in TestCircuitProver.');
-    return this.applyDelay(ProvingRequestType.PUBLIC_VM, () =>
-      makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
-    );
+    return this.applyDelay(ProvingRequestType.PUBLIC_VM, () => makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS));
   }
 
   private async applyDelay<F extends () => any>(type: ProvingRequestType, fn: F): Promise<Awaited<ReturnType<F>>> {