@aztec/prover-client 0.0.1-commit.a072138 → 0.0.1-commit.a5db02d

package/dest/proving_broker/rpc.js

@@ -1,3 +1,4 @@
+import { EpochNumberSchema } from '@aztec/foundation/branded-types';
 import { createSafeJsonRpcClient } from '@aztec/foundation/json-rpc/client';
 import { ProofUri, ProvingJob, ProvingJobId, ProvingJobStatus } from '@aztec/stdlib/interfaces/server';
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
@@ -5,6 +6,19 @@ import { optional } from '@aztec/stdlib/schemas';
 import { getVersioningResponseHandler } from '@aztec/stdlib/versioning';
 import { makeTracedFetch } from '@aztec/telemetry-client';
 import { z } from 'zod';
+/** Indefinite backoff for broker communication: 1, 1, 1, 2, 4, 4, 4, ... seconds. */ export function* proverBrokerBackoff() {
+    const v = [
+        1,
+        1,
+        1,
+        2,
+        4
+    ];
+    let i = 0;
+    while(true){
+        yield v[Math.min(i++, v.length - 1)];
+    }
+}
 const ProvingJobFilterSchema = z.object({
     allowList: z.array(z.nativeEnum(ProvingRequestType))
 });
@@ -13,48 +27,98 @@ const GetProvingJobResponse = z.object({
     time: z.number()
 });
 export const ProvingJobProducerSchema = {
-    enqueueProvingJob: z.function().args(ProvingJob).returns(ProvingJobStatus),
-    getProvingJobStatus: z.function().args(ProvingJobId).returns(ProvingJobStatus),
-    cancelProvingJob: z.function().args(ProvingJobId).returns(z.void()),
-    getCompletedJobs: z.function().args(z.array(ProvingJobId)).returns(z.array(ProvingJobId))
+    enqueueProvingJob: z.function({
+        input: z.tuple([
+            ProvingJob
+        ]),
+        output: ProvingJobStatus
+    }),
+    getProvingJobStatus: z.function({
+        input: z.tuple([
+            ProvingJobId
+        ]),
+        output: ProvingJobStatus
+    }),
+    cancelProvingJob: z.function({
+        input: z.tuple([
+            ProvingJobId
+        ]),
+        output: z.void()
+    }),
+    getCompletedJobs: z.function({
+        input: z.tuple([
+            z.array(ProvingJobId)
+        ]),
+        output: z.array(ProvingJobId)
+    })
 };
 export const ProvingJobConsumerSchema = {
-    getProvingJob: z.function().args(optional(ProvingJobFilterSchema)).returns(GetProvingJobResponse.optional()),
-    reportProvingJobError: z.function().args(ProvingJobId, z.string(), optional(z.boolean()), optional(ProvingJobFilterSchema)).returns(GetProvingJobResponse.optional()),
-    reportProvingJobProgress: z.function().args(ProvingJobId, z.number(), optional(ProvingJobFilterSchema)).returns(GetProvingJobResponse.optional()),
-    reportProvingJobSuccess: z.function().args(ProvingJobId, ProofUri, optional(ProvingJobFilterSchema)).returns(GetProvingJobResponse.optional())
+    getProvingJob: z.function({
+        input: z.tuple([
+            optional(ProvingJobFilterSchema)
+        ]),
+        output: GetProvingJobResponse.optional()
+    }),
+    reportProvingJobError: z.function({
+        input: z.tuple([
+            ProvingJobId,
+            z.string(),
+            optional(z.boolean()),
+            optional(ProvingJobFilterSchema)
+        ]),
+        output: GetProvingJobResponse.optional()
+    }),
+    reportProvingJobProgress: z.function({
+        input: z.tuple([
+            ProvingJobId,
+            z.number(),
+            optional(ProvingJobFilterSchema)
+        ]),
+        output: GetProvingJobResponse.optional()
+    }),
+    reportProvingJobSuccess: z.function({
+        input: z.tuple([
+            ProvingJobId,
+            ProofUri,
+            optional(ProvingJobFilterSchema)
+        ]),
+        output: GetProvingJobResponse.optional()
+    })
 };
 export const ProvingJobBrokerSchema = {
     ...ProvingJobConsumerSchema,
     ...ProvingJobProducerSchema
 };
-export function createProvingJobBrokerClient(url, versions, fetch = makeTracedFetch([
-    1,
-    2,
-    3
-], false)) {
+export const ProvingJobBrokerDebugSchema = {
+    replayProvingJob: z.function({
+        input: z.tuple([
+            ProvingJobId,
+            z.nativeEnum(ProvingRequestType),
+            EpochNumberSchema,
+            ProofUri
+        ]),
+        output: ProvingJobStatus
+    })
+};
+export const ProvingJobBrokerSchemaWithDebug = {
+    ...ProvingJobBrokerSchema,
+    ...ProvingJobBrokerDebugSchema
+};
+export function createProvingJobBrokerClient(url, versions, fetch = makeTracedFetch(proverBrokerBackoff, false)) {
     return createSafeJsonRpcClient(url, ProvingJobBrokerSchema, {
         namespaceMethods: 'proverBroker',
         fetch,
         onResponse: getVersioningResponseHandler(versions)
     });
 }
-export function createProvingJobProducerClient(url, versions, fetch = makeTracedFetch([
-    1,
-    2,
-    3
-], false)) {
+export function createProvingJobProducerClient(url, versions, fetch = makeTracedFetch(proverBrokerBackoff, false)) {
     return createSafeJsonRpcClient(url, ProvingJobProducerSchema, {
         namespaceMethods: 'provingJobProducer',
         fetch,
         onResponse: getVersioningResponseHandler(versions)
     });
 }
-export function createProvingJobConsumerClient(url, versions, fetch = makeTracedFetch([
-    1,
-    2,
-    3
-], false)) {
+export function createProvingJobConsumerClient(url, versions, fetch = makeTracedFetch(proverBrokerBackoff, false)) {
     return createSafeJsonRpcClient(url, ProvingJobConsumerSchema, {
         namespaceMethods: 'provingJobConsumer',
         fetch,

package/dest/test/epoch_settlement.d.ts

@@ -0,0 +1,36 @@
+import type { RollupCheatCodes } from '@aztec/ethereum/test';
+import type { CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
+import type { Logger } from '@aztec/foundation/log';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+/** Arguments for {@link settleEpochOutbox}. */
+export type SettleEpochOutboxArgs = {
+    /** Cheat codes used to write the computed out hash directly into the L1 Outbox storage. */
+    rollupCheatCodes: RollupCheatCodes;
+    /** Source of checkpointed L2 blocks for the epoch being settled. */
+    l2BlockSource: L2BlockSource;
+    /** Epoch to settle. */
+    epoch: EpochNumber;
+    /**
+     * When set, only checkpoints up to and including this number are covered. Used to settle a partial
+     * epoch (the AZIP-14 Outbox keeps one root per `numCheckpointsInEpoch`, so a prefix of an epoch can
+     * be settled and consumed before the epoch completes). When omitted, every checkpointed block in the
+     * epoch is covered.
+     */
+    maxCheckpoint?: CheckpointNumber;
+    log: Logger;
+};
+/**
+ * Computes the epoch out hash over the checkpointed blocks of an epoch (optionally only up to
+ * `maxCheckpoint`) and writes it into the L1 Outbox via cheat codes. This is the synthetic,
+ * no-prover equivalent of an epoch root proof landing on L1: it makes the L2-to-L1 messages in the
+ * covered checkpoints consumable. It does NOT advance the rollup's proven tip — callers
+ * `markAsProven` separately so a single prove call can settle multiple epochs before marking proven.
+ *
+ * Used by the test-only proving drivers: the `AutomineSequencer`'s auto-settle loop and the standalone
+ * `EpochTestSettler`. Lives here (rather than in either consumer) so both share one implementation.
+ *
+ * @returns The last checkpoint number covered by the settled range, or `undefined` if the epoch has
+ * no checkpointed blocks (within the `maxCheckpoint` bound).
+ */
+export declare function settleEpochOutbox({ rollupCheatCodes, l2BlockSource, epoch, maxCheckpoint, log }: SettleEpochOutboxArgs): Promise<CheckpointNumber | undefined>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXBvY2hfc2V0dGxlbWVudC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Rlc3QvZXBvY2hfc2V0dGxlbWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQzdELE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLFdBQVcsRUFBYyxNQUFNLGlDQUFpQyxDQUFDO0FBRWpHLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3BELE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBR3pELCtDQUErQztBQUMvQyxNQUFNLE1BQU0scUJBQXFCLEdBQUc7SUFDbEMsMkZBQTJGO0lBQzNGLGdCQUFnQixFQUFFLGdCQUFnQixDQUFDO0lBQ25DLG9FQUFvRTtJQUNwRSxhQUFhLEVBQUUsYUFBYSxDQUFDO0lBQzdCLHVCQUF1QjtJQUN2QixLQUFLLEVBQUUsV0FBVyxDQUFDO0lBQ25COzs7OztPQUtHO0lBQ0gsYUFBYSxDQUFDLEVBQUUsZ0JBQWdCLENBQUM7SUFDakMsR0FBRyxFQUFFLE1BQU0sQ0FBQztDQUNiLENBQUM7QUFFRjs7Ozs7Ozs7Ozs7O0dBWUc7QUFDSCx3QkFBc0IsaUJBQWlCLENBQUMsRUFDdEMsZ0JBQWdCLEVBQ2hCLGFBQWEsRUFDYixLQUFLLEVBQ0wsYUFBYSxFQUNiLEdBQUcsRUFDSixFQUFFLHFCQUFxQixHQUFHLE9BQU8sQ0FBQyxnQkFBZ0IsR0FBRyxTQUFTLENBQUMsQ0FxQy9EIn0=

package/dest/test/epoch_settlement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"epoch_settlement.d.ts","sourceRoot":"","sources":["../../src/test/epoch_settlement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAc,MAAM,iCAAiC,CAAC;AAEjG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGzD,+CAA+C;AAC/C,MAAM,MAAM,qBAAqB,GAAG;IAClC,2FAA2F;IAC3F,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,oEAAoE;IACpE,aAAa,EAAE,aAAa,CAAC;IAC7B,uBAAuB;IACvB,KAAK,EAAE,WAAW,CAAC;IACnB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,gBAAgB,CAAC;IACjC,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAsB,iBAAiB,CAAC,EACtC,gBAAgB,EAChB,aAAa,EACb,KAAK,EACL,aAAa,EACb,GAAG,EACJ,EAAE,qBAAqB,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAqC/D"}

package/dest/test/epoch_settlement.js

@@ -0,0 +1,52 @@
+import { computeEpochOutHash } from '@aztec/stdlib/messaging';
+/**
+ * Computes the epoch out hash over the checkpointed blocks of an epoch (optionally only up to
+ * `maxCheckpoint`) and writes it into the L1 Outbox via cheat codes. This is the synthetic,
+ * no-prover equivalent of an epoch root proof landing on L1: it makes the L2-to-L1 messages in the
+ * covered checkpoints consumable. It does NOT advance the rollup's proven tip — callers
+ * `markAsProven` separately so a single prove call can settle multiple epochs before marking proven.
+ *
+ * Used by the test-only proving drivers: the `AutomineSequencer`'s auto-settle loop and the standalone
+ * `EpochTestSettler`. Lives here (rather than in either consumer) so both share one implementation.
+ *
+ * @returns The last checkpoint number covered by the settled range, or `undefined` if the epoch has
+ * no checkpointed blocks (within the `maxCheckpoint` bound).
+ */ export async function settleEpochOutbox({ rollupCheatCodes, l2BlockSource, epoch, maxCheckpoint, log }) {
+    let blocks = await l2BlockSource.getBlocks({
+        epoch,
+        onlyCheckpointed: true
+    });
+    if (maxCheckpoint !== undefined) {
+        blocks = blocks.filter((block)=>block.checkpointNumber <= maxCheckpoint);
+    }
+    if (blocks.length === 0) {
+        return undefined;
+    }
+    log.info(`Settling epoch ${epoch}${maxCheckpoint !== undefined ? ` up to checkpoint ${maxCheckpoint}` : ''} with blocks ${blocks[0]?.header.getBlockNumber()} to ${blocks.at(-1)?.header.getBlockNumber()}`, {
+        epoch,
+        maxCheckpoint,
+        blocks: blocks.map((block)=>block.toBlockInfo())
+    });
+    const messagesInEpoch = [];
+    // Undefined (not SlotNumber.ZERO) so a first checkpointed block at slot 0 still opens checkpoint 0.
+    let previousSlotNumber;
+    let checkpointIndex = -1;
+    for (const block of blocks){
+        const slotNumber = block.header.globalVariables.slotNumber;
+        if (slotNumber !== previousSlotNumber) {
+            checkpointIndex++;
+            messagesInEpoch[checkpointIndex] = [];
+            previousSlotNumber = slotNumber;
+        }
+        messagesInEpoch[checkpointIndex].push(block.body.txEffects.map((txEffect)=>txEffect.l2ToL1Msgs));
+    }
+    const outHash = computeEpochOutHash(messagesInEpoch);
+    if (!outHash.isZero()) {
+        await rollupCheatCodes.insertOutbox(epoch, messagesInEpoch.length, outHash.toBigInt());
+    } else {
+        log.info(`No L2 to L1 messages in epoch ${epoch}`, {
+            epoch
+        });
+    }
+    return blocks.at(-1)?.checkpointNumber;
+}

package/dest/test/index.d.ts

@@ -0,0 +1,2 @@
+export { settleEpochOutbox, type SettleEpochOutboxArgs } from './epoch_settlement.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxLQUFLLHFCQUFxQixFQUFFLE1BQU0sdUJBQXVCLENBQUMifQ==

package/dest/test/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,KAAK,qBAAqB,EAAE,MAAM,uBAAuB,CAAC"}

package/dest/test/index.js

@@ -0,0 +1 @@
+export { settleEpochOutbox } from './epoch_settlement.js';

package/dest/test/mock_prover.d.ts

@@ -19,9 +19,9 @@ export declare class TestBroker implements ProvingJobProducer {
 }
 export declare class MockProver implements ServerCircuitProver {
     constructor();
-    getAvmProof(_inputs: AvmCircuitInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<import("@aztec/stdlib/proofs").RecursiveProof<16200>>;
-    getBaseParityProof(_inputs: ParityBasePrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<import("@aztec/stdlib/parity").ParityPublicInputs, 457>>;
-    getRootParityProof(_inputs: ParityRootPrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<import("@aztec/stdlib/parity").ParityPublicInputs, 457>>;
+    getAvmProof(_inputs: AvmCircuitInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<import("@aztec/stdlib/proofs").RecursiveProof<15516>>;
+    getBaseParityProof(_inputs: ParityBasePrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<import("@aztec/stdlib/parity").ParityPublicInputs, 410>>;
+    getRootParityProof(_inputs: ParityRootPrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<import("@aztec/stdlib/parity").ParityPublicInputs, 410>>;
     getPublicChonkVerifierProof(_inputs: PublicChonkVerifierPrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
     getPrivateTxBaseRollupProof(_baseRollupInput: PrivateTxBaseRollupPrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
     getPublicTxBaseRollupProof(_inputs: PublicTxBaseRollupPrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
@@ -31,7 +31,7 @@ export declare class MockProver implements ServerCircuitProver {
     getBlockRootEmptyTxFirstRollupProof(_input: BlockRootEmptyTxFirstRollupPrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
     getBlockRootRollupProof(_input: BlockRootRollupPrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
     getBlockRootSingleTxRollupProof(_input: BlockRootSingleTxRollupPrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
-    getBlockMergeRollupProof(_input: BlockMergeRollupPrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, 531>>;
+    getBlockMergeRollupProof(_input: BlockMergeRollupPrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, 480>>;
     getCheckpointRootRollupProof(_input: CheckpointRootRollupPrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
     getCheckpointRootSingleBlockRollupProof(_input: CheckpointRootSingleBlockRollupPrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
     getCheckpointMergeRollupProof(_input: CheckpointMergeRollupPrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;

package/dest/test/mock_prover.js

@@ -1,4 +1,4 @@
-import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH } from '@aztec/constants';
+import { AVM_V2_PROOF_LENGTH_IN_FIELDS, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH } from '@aztec/constants';
 import { times } from '@aztec/foundation/collection';
 import { makePublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
 import { makeEmptyRecursiveProof, makeRecursiveProof } from '@aztec/stdlib/proofs';
@@ -44,7 +44,7 @@ export class TestBroker {
 export class MockProver {
     constructor(){}
     getAvmProof(_inputs, _signal, _epochNumber) {
-        return Promise.resolve(makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED));
+        return Promise.resolve(makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS));
     }
     getBaseParityProof(_inputs, _signal, _epochNumber) {
         return Promise.resolve(makePublicInputsAndRecursiveProof(makeParityPublicInputs(), makeRecursiveProof(RECURSIVE_PROOF_LENGTH), VerificationKeyData.makeFakeHonk()));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/prover-client",
-  "version": "0.0.1-commit.a072138",
+  "version": "0.0.1-commit.a5db02d",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -9,7 +9,8 @@
     "./orchestrator": "./dest/orchestrator/index.js",
     "./helpers": "./dest/orchestrator/block-building-helpers.js",
     "./light": "./dest/light/index.js",
-    "./config": "./dest/config.js"
+    "./config": "./dest/config.js",
+    "./test": "./dest/test/index.js"
   },
   "typedocOptions": {
     "entryPoints": [
@@ -27,8 +28,8 @@
     "build:dev": "../scripts/tsc.sh --watch",
     "clean": "rm -rf ./dest .tsbuildinfo",
     "bb": "node --no-warnings ./dest/bb/index.js",
-    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --testTimeout=3500000 --forceExit",
-    "test:debug": "LOG_LEVEL=debug NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --testTimeout=1500000 --forceExit --testNamePattern prover/bb_prover/parity"
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --testTimeout=3500000",
+    "test:debug": "LOG_LEVEL=\"debug; info: json-rpc, simulator\" NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --testTimeout=1500000 --testNamePattern prover/bb_prover/parity"
   },
   "jest": {
     "moduleNameMapper": {
@@ -68,29 +69,28 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "0.0.1-commit.a072138",
-    "@aztec/blob-lib": "0.0.1-commit.a072138",
-    "@aztec/constants": "0.0.1-commit.a072138",
-    "@aztec/ethereum": "0.0.1-commit.a072138",
-    "@aztec/foundation": "0.0.1-commit.a072138",
-    "@aztec/kv-store": "0.0.1-commit.a072138",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.a072138",
-    "@aztec/noir-types": "0.0.1-commit.a072138",
-    "@aztec/protocol-contracts": "0.0.1-commit.a072138",
-    "@aztec/simulator": "0.0.1-commit.a072138",
-    "@aztec/stdlib": "0.0.1-commit.a072138",
-    "@aztec/telemetry-client": "0.0.1-commit.a072138",
-    "@aztec/world-state": "0.0.1-commit.a072138",
-    "@google-cloud/storage": "^7.15.0",
+    "@aztec/bb-prover": "0.0.1-commit.a5db02d",
+    "@aztec/blob-lib": "0.0.1-commit.a5db02d",
+    "@aztec/constants": "0.0.1-commit.a5db02d",
+    "@aztec/ethereum": "0.0.1-commit.a5db02d",
+    "@aztec/foundation": "0.0.1-commit.a5db02d",
+    "@aztec/kv-store": "0.0.1-commit.a5db02d",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.a5db02d",
+    "@aztec/noir-types": "0.0.1-commit.a5db02d",
+    "@aztec/protocol-contracts": "0.0.1-commit.a5db02d",
+    "@aztec/simulator": "0.0.1-commit.a5db02d",
+    "@aztec/stdlib": "0.0.1-commit.a5db02d",
+    "@aztec/telemetry-client": "0.0.1-commit.a5db02d",
+    "@aztec/world-state": "0.0.1-commit.a5db02d",
     "@iarna/toml": "^2.2.5",
     "commander": "^12.1.0",
     "lodash.chunk": "^4.2.0",
     "source-map-support": "^0.5.21",
     "tslib": "^2.4.0",
-    "zod": "^3.23.8"
+    "zod": "^4"
   },
   "devDependencies": {
-    "@aztec/noir-contracts.js": "0.0.1-commit.a072138",
+    "@aztec/noir-contracts.js": "0.0.1-commit.a5db02d",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",

package/src/config.ts

@@ -44,14 +44,30 @@ export const bbConfigMappings: ConfigMappingsType<BBConfig & ACVMConfig> = {
   },
   numConcurrentIVCVerifiers: {
     env: 'BB_NUM_IVC_VERIFIERS',
-    description: 'Max number of chonk verifiers to run concurrently',
+    description: 'Max concurrent verifications for the RPC verifier (QueuedIVCVerifier).',
     ...numberConfigHelper(8),
   },
   bbIVCConcurrency: {
     env: 'BB_IVC_CONCURRENCY',
-    description: 'Number of threads to use for IVC verification',
+    description: 'Thread count for the RPC IVC verifier.',
     ...numberConfigHelper(1),
   },
+  bbChonkVerifyMaxBatch: {
+    env: 'BB_CHONK_VERIFY_MAX_BATCH',
+    description:
+      'Upper bound on proofs per batch for the peer chonk batch verifier. Proofs are verified immediately as they arrive; this only caps how many can accumulate while a batch is already being processed.',
+    ...numberConfigHelper(16),
+  },
+  bbChonkVerifyConcurrency: {
+    env: 'BB_CHONK_VERIFY_BATCH_CONCURRENCY',
+    description: 'Thread count for the peer batch verifier parallel reduce. 0 = auto.',
+    ...numberConfigHelper(6),
+  },
+  bbDebugOutputDir: {
+    env: 'BB_DEBUG_OUTPUT_DIR',
+    description:
+      'When set, bb.js operations write input/output files and log equivalent CLI commands to this directory',
+  },
 };
 
 export const proverClientConfigMappings: ConfigMappingsType<ProverClientUserConfig> = {

package/src/light/lightweight_checkpoint_builder.ts

@@ -1,14 +1,14 @@
 import { SpongeBlob, computeBlobsHashFromBlobs, encodeCheckpointEndMarker, getBlobsPerL1Block } from '@aztec/blob-lib';
-import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
 import { type CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
-import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { elapsed } from '@aztec/foundation/timer';
 import { L2Block } from '@aztec/stdlib/block';
 import { Checkpoint } from '@aztec/stdlib/checkpoint';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
 import {
   accumulateCheckpointOutHashes,
+  appendL1ToL2MessagesToTree,
   computeCheckpointOutHash,
   computeInHashFromL1ToL2Messages,
 } from '@aztec/stdlib/messaging';
@@ -44,6 +44,7 @@ export class LightweightCheckpointBuilder {
   constructor(
     public readonly checkpointNumber: CheckpointNumber,
     public readonly constants: CheckpointGlobalVariables,
+    public feeAssetPriceModifier: bigint,
     public readonly l1ToL2Messages: Fr[],
     private readonly previousCheckpointOutHashes: Fr[],
     public readonly db: MerkleTreeWriteOperations,
@@ -54,7 +55,7 @@ export class LightweightCheckpointBuilder {
       instanceId: `checkpoint-${checkpointNumber}`,
     });
     this.spongeBlob = SpongeBlob.init();
-    this.logger.debug('Starting new checkpoint', { constants, l1ToL2Messages });
+    this.logger.debug('Starting new checkpoint', { constants, l1ToL2Messages, feeAssetPriceModifier });
   }
 
   static async startNewCheckpoint(
@@ -64,16 +65,15 @@ export class LightweightCheckpointBuilder {
     previousCheckpointOutHashes: Fr[],
     db: MerkleTreeWriteOperations,
     bindings?: LoggerBindings,
+    feeAssetPriceModifier: bigint = 0n,
   ): Promise<LightweightCheckpointBuilder> {
     // Insert l1-to-l2 messages into the tree.
-    await db.appendLeaves(
-      MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
-      padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
-    );
+    await appendL1ToL2MessagesToTree(db, l1ToL2Messages);
 
     return new LightweightCheckpointBuilder(
       checkpointNumber,
       constants,
+      feeAssetPriceModifier,
       l1ToL2Messages,
       previousCheckpointOutHashes,
       db,
@@ -90,6 +90,7 @@ export class LightweightCheckpointBuilder {
   static async resumeCheckpoint(
     checkpointNumber: CheckpointNumber,
     constants: CheckpointGlobalVariables,
+    feeAssetPriceModifier: bigint,
     l1ToL2Messages: Fr[],
     previousCheckpointOutHashes: Fr[],
     db: MerkleTreeWriteOperations,
@@ -99,6 +100,7 @@ export class LightweightCheckpointBuilder {
     const builder = new LightweightCheckpointBuilder(
       checkpointNumber,
       constants,
+      feeAssetPriceModifier,
       l1ToL2Messages,
       previousCheckpointOutHashes,
       db,
@@ -111,6 +113,10 @@ export class LightweightCheckpointBuilder {
       blockNumbers: existingBlocks.map(b => b.header.getBlockNumber()),
     });
 
+    if (existingBlocks.length === 0) {
+      throw new Error(`Cannot resume checkpoint ${checkpointNumber} with no existing blocks`);
+    }
+
     // Validate block order and consistency
     for (let i = 1; i < existingBlocks.length; i++) {
       const prev = existingBlocks[i - 1];
@@ -148,6 +154,10 @@ export class LightweightCheckpointBuilder {
     return this.blocks.length;
   }
 
+  public getBlocks() {
+    return this.blocks;
+  }
+
   /**
    * Adds a new block to the checkpoint. The tx effects must have already been inserted into the db if
    * this is called after tx processing, if that's not the case, then set `insertTxsEffects` to true.
@@ -156,7 +166,8 @@ export class LightweightCheckpointBuilder {
     globalVariables: GlobalVariables,
     txs: ProcessedTx[],
     opts: { insertTxsEffects?: boolean; expectedEndState?: StateReference } = {},
-  ): Promise<L2Block> {
+  ): Promise<{ block: L2Block; timings: Record<string, number> }> {
+    const timings: Record<string, number> = {};
     const isFirstBlock = this.blocks.length === 0;
 
     // Empty blocks are only allowed as the first block in a checkpoint
@@ -165,7 +176,9 @@ export class LightweightCheckpointBuilder {
     }
 
     if (isFirstBlock) {
-      this.lastArchives.push(await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db));
+      const [msGetInitialArchive, initialArchive] = await elapsed(() => getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db));
+      this.lastArchives.push(initialArchive);
+      timings.getInitialArchive = msGetInitialArchive;
     }
 
     const lastArchive = this.lastArchives.at(-1)!;
@@ -175,12 +188,17 @@ export class LightweightCheckpointBuilder {
         `Inserting side effects for ${txs.length} txs for block ${globalVariables.blockNumber} into db`,
         { txs: txs.map(tx => tx.hash.toString()) },
       );
+      let msInsertSideEffects = 0;
       for (const tx of txs) {
-        await insertSideEffects(tx, this.db);
+        const [ms] = await elapsed(() => insertSideEffects(tx, this.db));
+        msInsertSideEffects += ms;
       }
+      timings.insertSideEffects = msInsertSideEffects;
     }
 
-    const endState = await this.db.getStateReference();
+    const [msGetEndState, endState] = await elapsed(() => this.db.getStateReference());
+    timings.getEndState = msGetEndState;
+
     if (opts.expectedEndState && !endState.equals(opts.expectedEndState)) {
       this.logger.error('End state after processing txs does not match expected end state', {
         globalVariables: globalVariables.toInspect(),
@@ -190,26 +208,31 @@ export class LightweightCheckpointBuilder {
       throw new Error(`End state does not match expected end state when building block ${globalVariables.blockNumber}`);
     }
 
-    const { header, body, blockBlobFields } = await buildHeaderAndBodyFromTxs(
-      txs,
-      lastArchive,
-      endState,
-      globalVariables,
-      this.spongeBlob,
-      isFirstBlock,
+    const [msBuildHeaderAndBody, { header, body, blockBlobFields }] = await elapsed(() =>
+      buildHeaderAndBodyFromTxs(txs, lastArchive, endState, globalVariables, this.spongeBlob, isFirstBlock),
     );
+    timings.buildHeaderAndBody = msBuildHeaderAndBody;
 
     header.state.validate();
 
     await this.db.updateArchive(header);
-    const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db);
+    const [msUpdateArchive, newArchive] = await elapsed(() => getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db));
+    timings.updateArchive = msUpdateArchive;
     this.lastArchives.push(newArchive);
 
+    const expectedNextLeafIndex = Number(globalVariables.blockNumber) + 1;
+    if (newArchive.nextAvailableLeafIndex !== expectedNextLeafIndex) {
+      throw new Error(
+        `Archive tree next leaf index mismatch after building block ${globalVariables.blockNumber} (expected ${expectedNextLeafIndex} but got ${newArchive.nextAvailableLeafIndex})`,
+      );
+    }
+
     const indexWithinCheckpoint = IndexWithinCheckpoint(this.blocks.length);
     const block = new L2Block(newArchive, header, body, this.checkpointNumber, indexWithinCheckpoint);
     this.blocks.push(block);
 
-    await this.spongeBlob.absorb(blockBlobFields);
+    const [msSpongeAbsorb] = await elapsed(() => this.spongeBlob.absorb(blockBlobFields));
+    timings.spongeAbsorb = msSpongeAbsorb;
     this.blobFields.push(...blockBlobFields);
 
     this.logger.debug(`Built block ${header.getBlockNumber()}`, {
@@ -220,7 +243,7 @@ export class LightweightCheckpointBuilder {
       txs: block.body.txEffects.map(tx => tx.txHash.toString()),
     });
 
-    return block;
+    return { block, timings };
   }
 
   async completeCheckpoint(): Promise<Checkpoint> {
@@ -237,7 +260,7 @@ export class LightweightCheckpointBuilder {
 
     const newArchive = this.lastArchives[this.lastArchives.length - 1];
 
-    const blobs = getBlobsPerL1Block(this.blobFields);
+    const blobs = await getBlobsPerL1Block(this.blobFields);
     const blobsHash = computeBlobsHashFromBlobs(blobs);
 
     const inHash = computeInHashFromL1ToL2Messages(this.l1ToL2Messages);
@@ -248,11 +271,11 @@ export class LightweightCheckpointBuilder {
     );
     const epochOutHash = accumulateCheckpointOutHashes([...this.previousCheckpointOutHashes, checkpointOutHash]);
 
-    // TODO(palla/mbps): Should we source this from the constants instead?
-    // timestamp of a checkpoint is the timestamp of the last block in the checkpoint.
+    // All blocks in the checkpoint have the same timestamp
     const timestamp = blocks[blocks.length - 1].timestamp;
 
     const totalManaUsed = blocks.reduce((acc, block) => acc.add(block.header.totalManaUsed), Fr.ZERO);
+    const accumulatedFees = blocks.reduce((acc, block) => acc.add(block.header.totalFees), Fr.ZERO);
 
     const header = CheckpointHeader.from({
       lastArchiveRoot: this.lastArchives[0].root,
@@ -266,15 +289,25 @@ export class LightweightCheckpointBuilder {
       feeRecipient,
       gasFees,
       totalManaUsed,
+      accumulatedFees,
+    });
+
+    this.logger.debug(`Completed checkpoint ${this.checkpointNumber}`, {
+      checkpointNumber: this.checkpointNumber,
+      headerHash: header.hash().toString(),
+      checkpointOutHash: checkpointOutHash.toString(),
+      numPreviousCheckpointOutHashes: this.previousCheckpointOutHashes.length,
+      ...header.toInspect(),
     });
 
-    return new Checkpoint(newArchive, header, blocks, this.checkpointNumber);
+    return new Checkpoint(newArchive, header, blocks, this.checkpointNumber, this.feeAssetPriceModifier);
   }
 
   clone() {
     const clone = new LightweightCheckpointBuilder(
       this.checkpointNumber,
       this.constants,
+      this.feeAssetPriceModifier,
       [...this.l1ToL2Messages],
       [...this.previousCheckpointOutHashes],
       this.db,