@aztec-labs/prover-client 6.0.0-nightly.20260829

package/README.md

@@ -0,0 +1 @@
+# Prover Client

package/dest/config.d.ts

@@ -0,0 +1,17 @@
+import type { ACVMConfig, BBConfig } from '@aztec-labs/bb-prover';
+import { type ConfigMappingsType } from '@aztec-labs/foundation/config';
+import { type ProverConfig } from '@aztec-labs/stdlib/interfaces/prover-config';
+import { type ProverAgentConfig, type ProverBrokerConfig } from './proving_broker/config.js';
+/** The prover configuration as defined by the user. */
+export type ProverClientUserConfig = ProverConfig & ProverAgentConfig & ProverBrokerConfig & BBConfig & ACVMConfig;
+/** The prover configuration with all missing fields resolved. */
+export type ProverClientConfig = ProverClientUserConfig & Required<Pick<ProverClientUserConfig, 'proverId'>>;
+export declare const bbConfigMappings: ConfigMappingsType<BBConfig & ACVMConfig>;
+export declare const proverClientConfigMappings: ConfigMappingsType<ProverClientUserConfig>;
+/**
+ * Returns the prover configuration from the environment variables.
+ * Note: If an environment variable is not set, the default value is used.
+ * @returns The prover configuration.
+ */
+export declare function getProverEnvVars(): ProverClientUserConfig;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUNsRSxPQUFPLEVBQ0wsS0FBSyxrQkFBa0IsRUFJeEIsTUFBTSwrQkFBK0IsQ0FBQztBQUN2QyxPQUFPLEVBQUUsS0FBSyxZQUFZLEVBQXdCLE1BQU0sNkNBQTZDLENBQUM7QUFFdEcsT0FBTyxFQUNMLEtBQUssaUJBQWlCLEVBQ3RCLEtBQUssa0JBQWtCLEVBR3hCLE1BQU0sNEJBQTRCLENBQUM7QUFFcEMsdURBQXVEO0FBQ3ZELE1BQU0sTUFBTSxzQkFBc0IsR0FBRyxZQUFZLEdBQUcsaUJBQWlCLEdBQUcsa0JBQWtCLEdBQUcsUUFBUSxHQUFHLFVBQVUsQ0FBQztBQUVuSCxpRUFBaUU7QUFDakUsTUFBTSxNQUFNLGtCQUFrQixHQUFHLHNCQUFzQixHQUFHLFFBQVEsQ0FBQyxJQUFJLENBQUMsc0JBQXNCLEVBQUUsVUFBVSxDQUFDLENBQUMsQ0FBQztBQUU3RyxlQUFPLE1BQU0sZ0JBQWdCLEVBQUUsa0JBQWtCLENBQUMsUUFBUSxHQUFHLFVBQVUsQ0FnRHRFLENBQUM7QUFFRixlQUFPLE1BQU0sMEJBQTBCLEVBQUUsa0JBQWtCLENBQUMsc0JBQXNCLENBS2pGLENBQUM7QUFFRjs7OztHQUlHO0FBQ0gsd0JBQWdCLGdCQUFnQixJQUFJLHNCQUFzQixDQUV6RCJ9

package/dest/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EACL,KAAK,kBAAkB,EAIxB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,KAAK,YAAY,EAAwB,MAAM,6CAA6C,CAAC;AAEtG,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EAGxB,MAAM,4BAA4B,CAAC;AAEpC,uDAAuD;AACvD,MAAM,MAAM,sBAAsB,GAAG,YAAY,GAAG,iBAAiB,GAAG,kBAAkB,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEnH,iEAAiE;AACjE,MAAM,MAAM,kBAAkB,GAAG,sBAAsB,GAAG,QAAQ,CAAC,IAAI,CAAC,sBAAsB,EAAE,UAAU,CAAC,CAAC,CAAC;AAE7G,eAAO,MAAM,gBAAgB,EAAE,kBAAkB,CAAC,QAAQ,GAAG,UAAU,CAgDtE,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,kBAAkB,CAAC,sBAAsB,CAKjF,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,sBAAsB,CAEzD"}

package/dest/config.js

@@ -0,0 +1,63 @@
+import { booleanConfigHelper, getConfigFromMappings, numberConfigHelper } from '@aztec-labs/foundation/config';
+import { proverConfigMappings } from '@aztec-labs/stdlib/interfaces/prover-config';
+import { proverAgentConfigMappings, proverBrokerConfigMappings } from './proving_broker/config.js';
+export const bbConfigMappings = {
+    acvmWorkingDirectory: {
+        env: 'ACVM_WORKING_DIRECTORY',
+        description: 'The working directory to use for simulation/proving'
+    },
+    acvmBinaryPath: {
+        env: 'ACVM_BINARY_PATH',
+        description: 'The path to the ACVM binary'
+    },
+    bbWorkingDirectory: {
+        env: 'BB_WORKING_DIRECTORY',
+        description: 'The working directory to use for proving'
+    },
+    bbBinaryPath: {
+        env: 'BB_BINARY_PATH',
+        description: 'The path to the bb binary'
+    },
+    bbSkipCleanup: {
+        env: 'BB_SKIP_CLEANUP',
+        description: 'Whether to skip cleanup of bb temporary files',
+        ...booleanConfigHelper(false)
+    },
+    numConcurrentIVCVerifiers: {
+        env: 'BB_NUM_IVC_VERIFIERS',
+        description: 'Max concurrent verifications for the RPC verifier (QueuedIVCVerifier).',
+        ...numberConfigHelper(8)
+    },
+    bbIVCConcurrency: {
+        env: 'BB_IVC_CONCURRENCY',
+        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 = {
+    ...bbConfigMappings,
+    ...proverConfigMappings,
+    ...proverAgentConfigMappings,
+    ...proverBrokerConfigMappings
+};
+/**
+ * Returns the prover configuration from the environment variables.
+ * Note: If an environment variable is not set, the default value is used.
+ * @returns The prover configuration.
+ */ export function getProverEnvVars() {
+    return getConfigFromMappings(proverClientConfigMappings);
+}

package/dest/index.d.ts

@@ -0,0 +1,4 @@
+export type { EpochProverManager } from '@aztec-labs/stdlib/interfaces/server';
+export * from './prover-client/index.js';
+export * from './config.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUUvRSxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsYUFBYSxDQUFDIn0=

package/dest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAE/E,cAAc,0BAA0B,CAAC;AACzC,cAAc,aAAa,CAAC"}

package/dest/index.js

@@ -0,0 +1,2 @@
+export * from './prover-client/index.js';
+export * from './config.js';

package/dest/light/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lightweight_checkpoint_builder.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9saWdodC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFDQUFxQyxDQUFDIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/light/index.ts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAC"}

package/dest/light/index.js

@@ -0,0 +1 @@
+export * from './lightweight_checkpoint_builder.js';

package/dest/light/lightweight_checkpoint_builder.d.ts

@@ -0,0 +1,58 @@
+import { type CheckpointNumber } from '@aztec-labs/foundation/branded-types';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { type LoggerBindings } from '@aztec-labs/foundation/log';
+import { L2Block } from '@aztec-labs/stdlib/block';
+import { Checkpoint } from '@aztec-labs/stdlib/checkpoint';
+import type { MerkleTreeWriteOperations } from '@aztec-labs/stdlib/interfaces/server';
+import { type CheckpointGlobalVariables, type GlobalVariables, type ProcessedTx, StateReference } from '@aztec-labs/stdlib/tx';
+/**
+ * Builds a checkpoint and its header and the blocks in it from a set of processed tx without running any circuits.
+ *
+ * Each added block inserts its own L1-to-L2 message bundle into the message tree and then updates the archive tree.
+ * Finally completes the checkpoint by computing its header.
+ */
+export declare class LightweightCheckpointBuilder {
+    readonly checkpointNumber: CheckpointNumber;
+    readonly constants: CheckpointGlobalVariables;
+    feeAssetPriceModifier: bigint;
+    readonly l1ToL2Messages: Fr[];
+    private readonly previousCheckpointOutHashes;
+    private readonly previousInboxRollingHash;
+    readonly db: MerkleTreeWriteOperations;
+    private readonly logger;
+    private lastArchives;
+    private spongeBlob;
+    private blocks;
+    private blobFields;
+    constructor(checkpointNumber: CheckpointNumber, constants: CheckpointGlobalVariables, feeAssetPriceModifier: bigint, l1ToL2Messages: Fr[], previousCheckpointOutHashes: Fr[], previousInboxRollingHash: Fr, db: MerkleTreeWriteOperations, bindings?: LoggerBindings);
+    /**
+     * Starts a fresh checkpoint. The checkpoint's L1-to-L2 messages are not supplied here: every block brings its own
+     * bundle to {@link addBlock}, which inserts it into the tree and accumulates it into the checkpoint's message list.
+     */
+    static startNewCheckpoint(checkpointNumber: CheckpointNumber, constants: CheckpointGlobalVariables, previousCheckpointOutHashes: Fr[], previousInboxRollingHash: Fr, db: MerkleTreeWriteOperations, bindings?: LoggerBindings, feeAssetPriceModifier?: bigint): LightweightCheckpointBuilder;
+    /**
+     * Resumes building a checkpoint from existing blocks. This is used for validator re-execution
+     * where blocks have already been built and their effects are already in the database.
+     * `l1ToL2Messages` is the whole checkpoint's message list as consumed by the existing blocks: it seeds the
+     * checkpoint's rolling hash and is not inserted into the tree, since the blocks already inserted it.
+     */
+    static resumeCheckpoint(checkpointNumber: CheckpointNumber, constants: CheckpointGlobalVariables, feeAssetPriceModifier: bigint, l1ToL2Messages: Fr[], previousCheckpointOutHashes: Fr[], previousInboxRollingHash: Fr, db: MerkleTreeWriteOperations, existingBlocks: L2Block[], bindings?: LoggerBindings): Promise<LightweightCheckpointBuilder>;
+    /** Returns how many blocks have been added to this checkpoint so far */
+    getBlockCount(): number;
+    getBlocks(): L2Block[];
+    /**
+     * 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.
+     * @param l1ToL2Messages - The message leaves this block consumes from the Inbox, in insertion order.
+     */
+    addBlock(globalVariables: GlobalVariables, txs: ProcessedTx[], l1ToL2Messages: Fr[], opts?: {
+        insertTxsEffects?: boolean;
+        expectedEndState?: StateReference;
+    }): Promise<{
+        block: L2Block;
+        timings: Record<string, number>;
+    }>;
+    completeCheckpoint(): Promise<Checkpoint>;
+    clone(): LightweightCheckpointBuilder;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/light/lightweight_checkpoint_builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lightweight_checkpoint_builder.d.ts","sourceRoot":"","sources":["../../src/light/lightweight_checkpoint_builder.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,gBAAgB,EAAyB,MAAM,sCAAsC,CAAC;AACpG,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AACzD,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,4BAA4B,CAAC;AAE5F,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AAStF,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,cAAc,EACf,MAAM,uBAAuB,CAAC;AAQ/B;;;;;GAKG;AACH,qBAAa,4BAA4B;aASrB,gBAAgB,EAAE,gBAAgB;aAClC,SAAS,EAAE,yBAAyB;IAC7C,qBAAqB,EAAE,MAAM;aACpB,cAAc,EAAE,EAAE,EAAE;IACpC,OAAO,CAAC,QAAQ,CAAC,2BAA2B;IAE5C,OAAO,CAAC,QAAQ,CAAC,wBAAwB;aACzB,EAAE,EAAE,yBAAyB;IAf/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAEhC,OAAO,CAAC,YAAY,CAAgC;IACpD,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,UAAU,CAAY;IAE9B,YACkB,gBAAgB,EAAE,gBAAgB,EAClC,SAAS,EAAE,yBAAyB,EAC7C,qBAAqB,EAAE,MAAM,EACpB,cAAc,EAAE,EAAE,EAAE,EACnB,2BAA2B,EAAE,EAAE,EAAE,EAEjC,wBAAwB,EAAE,EAAE,EAC7B,EAAE,EAAE,yBAAyB,EAC7C,QAAQ,CAAC,EAAE,cAAc,EAQ1B;IAED;;;OAGG;IACH,MAAM,CAAC,kBAAkB,CACvB,gBAAgB,EAAE,gBAAgB,EAClC,SAAS,EAAE,yBAAyB,EACpC,2BAA2B,EAAE,EAAE,EAAE,EACjC,wBAAwB,EAAE,EAAE,EAC5B,EAAE,EAAE,yBAAyB,EAC7B,QAAQ,CAAC,EAAE,cAAc,EACzB,qBAAqB,GAAE,MAAW,GACjC,4BAA4B,CAW9B;IAED;;;;;OAKG;IACH,OAAa,gBAAgB,CAC3B,gBAAgB,EAAE,gBAAgB,EAClC,SAAS,EAAE,yBAAyB,EACpC,qBAAqB,EAAE,MAAM,EAC7B,cAAc,EAAE,EAAE,EAAE,EACpB,2BAA2B,EAAE,EAAE,EAAE,EACjC,wBAAwB,EAAE,EAAE,EAC5B,EAAE,EAAE,yBAAyB,EAC7B,cAAc,EAAE,OAAO,EAAE,EACzB,QAAQ,CAAC,EAAE,cAAc,GACxB,OAAO,CAAC,4BAA4B,CAAC,CAoDvC;IAED,wEAAwE;IACjE,aAAa,WAEnB;IAEM,SAAS,cAEf;IAED;;;;OAIG;IACU,QAAQ,CACnB,eAAe,EAAE,eAAe,EAChC,GAAG,EAAE,WAAW,EAAE,EAClB,cAAc,EAAE,EAAE,EAAE,EACpB,IAAI,GAAE;QAAE,gBAAgB,CAAC,EAAE,OAAO,CAAC;QAAC,gBAAgB,CAAC,EAAE,cAAc,CAAA;KAAO,GAC3E,OAAO,CAAC;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAC,CAoF9D;IAEK,kBAAkB,IAAI,OAAO,CAAC,UAAU,CAAC,CAuD9C;IAED,KAAK,iCAgBJ;CACF"}

package/dest/light/lightweight_checkpoint_builder.js

@@ -0,0 +1,243 @@
+import { SpongeBlob, computeBlobsHashFromBlobs, encodeCheckpointEndMarker, getBlobsPerL1Block } from '@aztec-labs/blob-lib';
+import { IndexWithinCheckpoint } from '@aztec-labs/foundation/branded-types';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { elapsed } from '@aztec-labs/foundation/timer';
+import { L2Block } from '@aztec-labs/stdlib/block';
+import { Checkpoint } from '@aztec-labs/stdlib/checkpoint';
+import { accumulateCheckpointOutHashes, accumulateInboxRollingHash, appendL1ToL2MessagesToTree, computeCheckpointOutHash } from '@aztec-labs/stdlib/messaging';
+import { CheckpointHeader, computeBlockHeadersHash } from '@aztec-labs/stdlib/rollup';
+import { MerkleTreeId } from '@aztec-labs/stdlib/trees';
+import { buildHeaderAndBodyFromTxs, getTreeSnapshot, insertSideEffects } from '../orchestrator/block-building-helpers.js';
+/**
+ * Builds a checkpoint and its header and the blocks in it from a set of processed tx without running any circuits.
+ *
+ * Each added block inserts its own L1-to-L2 message bundle into the message tree and then updates the archive tree.
+ * Finally completes the checkpoint by computing its header.
+ */ export class LightweightCheckpointBuilder {
+    checkpointNumber;
+    constants;
+    feeAssetPriceModifier;
+    l1ToL2Messages;
+    previousCheckpointOutHashes;
+    previousInboxRollingHash;
+    db;
+    logger;
+    lastArchives;
+    spongeBlob;
+    blocks;
+    blobFields;
+    constructor(checkpointNumber, constants, feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, // Inbox rolling hash of the previous checkpoint (this checkpoint's chain start); genesis is zero.
+    previousInboxRollingHash, db, bindings){
+        this.checkpointNumber = checkpointNumber;
+        this.constants = constants;
+        this.feeAssetPriceModifier = feeAssetPriceModifier;
+        this.l1ToL2Messages = l1ToL2Messages;
+        this.previousCheckpointOutHashes = previousCheckpointOutHashes;
+        this.previousInboxRollingHash = previousInboxRollingHash;
+        this.db = db;
+        this.lastArchives = [];
+        this.blocks = [];
+        this.blobFields = [];
+        this.logger = createLogger('checkpoint-builder', {
+            ...bindings,
+            instanceId: `checkpoint-${checkpointNumber}`
+        });
+        this.spongeBlob = SpongeBlob.init();
+        this.logger.debug('Starting new checkpoint', {
+            constants,
+            l1ToL2Messages,
+            feeAssetPriceModifier
+        });
+    }
+    /**
+   * Starts a fresh checkpoint. The checkpoint's L1-to-L2 messages are not supplied here: every block brings its own
+   * bundle to {@link addBlock}, which inserts it into the tree and accumulates it into the checkpoint's message list.
+   */ static startNewCheckpoint(checkpointNumber, constants, previousCheckpointOutHashes, previousInboxRollingHash, db, bindings, feeAssetPriceModifier = 0n) {
+        return new LightweightCheckpointBuilder(checkpointNumber, constants, feeAssetPriceModifier, [], previousCheckpointOutHashes, previousInboxRollingHash, db, bindings);
+    }
+    /**
+   * Resumes building a checkpoint from existing blocks. This is used for validator re-execution
+   * where blocks have already been built and their effects are already in the database.
+   * `l1ToL2Messages` is the whole checkpoint's message list as consumed by the existing blocks: it seeds the
+   * checkpoint's rolling hash and is not inserted into the tree, since the blocks already inserted it.
+   */ static async resumeCheckpoint(checkpointNumber, constants, feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, previousInboxRollingHash, db, existingBlocks, bindings) {
+        const builder = new LightweightCheckpointBuilder(checkpointNumber, constants, feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, previousInboxRollingHash, db, bindings);
+        builder.logger.debug('Resuming checkpoint from existing blocks', {
+            checkpointNumber,
+            numExistingBlocks: existingBlocks.length,
+            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];
+            const curr = existingBlocks[i];
+            if (curr.number !== prev.number + 1) {
+                throw new Error(`Non-sequential block numbers in resumeCheckpoint: ${prev.number} -> ${curr.number}`);
+            }
+            if (!prev.archive.root.equals(curr.header.lastArchive.root)) {
+                throw new Error(`Archive root mismatch between blocks ${prev.number} and ${curr.number}`);
+            }
+        }
+        for(let i = 0; i < existingBlocks.length; i++){
+            const block = existingBlocks[i];
+            const isFirstBlock = i === 0;
+            if (isFirstBlock) {
+                builder.lastArchives.push(block.header.lastArchive);
+            }
+            builder.lastArchives.push(block.archive);
+            const blockBlobFields = block.toBlobFields();
+            await builder.spongeBlob.absorb(blockBlobFields);
+            builder.blobFields.push(...blockBlobFields);
+            builder.blocks.push(block);
+        }
+        return builder;
+    }
+    /** Returns how many blocks have been added to this checkpoint so far */ getBlockCount() {
+        return this.blocks.length;
+    }
+    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.
+   * @param l1ToL2Messages - The message leaves this block consumes from the Inbox, in insertion order.
+   */ async addBlock(globalVariables, txs, l1ToL2Messages, opts = {}) {
+        const timings = {};
+        const isFirstBlock = this.blocks.length === 0;
+        if (isFirstBlock) {
+            const [msGetInitialArchive, initialArchive] = await elapsed(()=>getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db));
+            this.lastArchives.push(initialArchive);
+            timings.getInitialArchive = msGetInitialArchive;
+        }
+        const lastArchive = this.lastArchives.at(-1);
+        if (opts.insertTxsEffects) {
+            this.logger.debug(`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){
+                const [ms] = await elapsed(()=>insertSideEffects(tx, this.db));
+                msInsertSideEffects += ms;
+            }
+            timings.insertSideEffects = msInsertSideEffects;
+        }
+        // Streaming Inbox: insert this block's L1-to-L2 message bundle before reading the end state,
+        // so the block header's L1-to-L2 tree snapshot reflects it. Bundles are appended compactly (unpadded, at the
+        // tree's current next-available index). The logical messages are accumulated only once the block is fully built
+        // (below), so a mid-build failure does not pollute the checkpoint's rolling hash; the rolling hash is recomputed
+        // over them at checkpoint completion.
+        await appendL1ToL2MessagesToTree(this.db, l1ToL2Messages);
+        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(),
+                expectedEndState: opts.expectedEndState.toInspect(),
+                actualEndState: endState.toInspect()
+            });
+            throw new Error(`End state does not match expected end state when building block ${globalVariables.blockNumber}`);
+        }
+        const [msBuildHeaderAndBody, { header, body, blockBlobFields }] = await elapsed(()=>buildHeaderAndBodyFromTxs(txs, lastArchive, endState, globalVariables, this.spongeBlob));
+        timings.buildHeaderAndBody = msBuildHeaderAndBody;
+        header.state.validate();
+        await this.db.updateArchive(header);
+        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);
+        // Accumulate the streaming bundle now that the block is fully built, so a mid-build throw above leaves the
+        // checkpoint's message list (and thus its rolling hash) consistent with the blocks actually built.
+        this.l1ToL2Messages.push(...l1ToL2Messages);
+        const [msSpongeAbsorb] = await elapsed(()=>this.spongeBlob.absorb(blockBlobFields));
+        timings.spongeAbsorb = msSpongeAbsorb;
+        this.blobFields.push(...blockBlobFields);
+        this.logger.debug(`Built block ${header.getBlockNumber()}`, {
+            globalVariables: globalVariables.toInspect(),
+            archiveRoot: newArchive.root.toString(),
+            stateReference: header.state.toInspect(),
+            blockHash: (await block.hash()).toString(),
+            txs: block.body.txEffects.map((tx)=>tx.txHash.toString())
+        });
+        return {
+            block,
+            timings
+        };
+    }
+    async completeCheckpoint() {
+        if (!this.blocks.length) {
+            throw new Error('Cannot complete a checkpoint with no blocks');
+        }
+        const numBlobFields = this.blobFields.length + 1; // +1 for the checkpoint end marker.
+        const checkpointEndMarker = encodeCheckpointEndMarker({
+            numBlobFields
+        });
+        this.blobFields.push(checkpointEndMarker);
+        const blocks = this.blocks;
+        const blockHeadersHash = await computeBlockHeadersHash(blocks.map((block)=>block.header));
+        const newArchive = this.lastArchives[this.lastArchives.length - 1];
+        const blobs = await getBlobsPerL1Block(this.blobFields);
+        const blobsHash = computeBlobsHashFromBlobs(blobs);
+        const inboxRollingHash = accumulateInboxRollingHash(this.previousInboxRollingHash, this.l1ToL2Messages);
+        const { slotNumber, coinbase, feeRecipient, gasFees } = this.constants;
+        const checkpointOutHash = computeCheckpointOutHash(blocks.map((block)=>block.body.txEffects.map((tx)=>tx.l2ToL1Msgs)));
+        const epochOutHash = accumulateCheckpointOutHashes([
+            ...this.previousCheckpointOutHashes,
+            checkpointOutHash
+        ]);
+        // 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,
+            blobsHash,
+            inboxRollingHash,
+            epochOutHash,
+            blockHeadersHash,
+            slotNumber,
+            timestamp,
+            coinbase,
+            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, this.feeAssetPriceModifier);
+    }
+    clone() {
+        const clone = new LightweightCheckpointBuilder(this.checkpointNumber, this.constants, this.feeAssetPriceModifier, [
+            ...this.l1ToL2Messages
+        ], [
+            ...this.previousCheckpointOutHashes
+        ], this.previousInboxRollingHash, this.db, this.logger.getBindings());
+        clone.lastArchives = [
+            ...this.lastArchives
+        ];
+        clone.spongeBlob = this.spongeBlob.clone();
+        clone.blocks = [
+            ...this.blocks
+        ];
+        clone.blobFields = [
+            ...this.blobFields
+        ];
+        return clone;
+    }
+}

package/dest/mocks/fixtures.d.ts

@@ -0,0 +1,20 @@
+import type { Logger } from '@aztec-labs/foundation/log';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+import { type CircuitSimulator } from '@aztec-labs/simulator/server';
+import { CheckpointConstantData } from '@aztec-labs/stdlib/rollup';
+import { GlobalVariables } from '@aztec-labs/stdlib/tx';
+export declare const getEnvironmentConfig: (logger: Logger) => Promise<{
+    acvmWorkingDirectory: string;
+    bbWorkingDirectory: string;
+    expectedAcvmPath: string;
+    expectedBBPath: string;
+    directoryToCleanup: string | undefined;
+    bbSkipCleanup: boolean;
+} | undefined>;
+export declare function getSimulator(config: {
+    acvmWorkingDirectory: string | undefined;
+    acvmBinaryPath: string | undefined;
+}, logger?: Logger): Promise<CircuitSimulator>;
+export declare const makeGlobals: (blockNumber: number, slotNumber?: number, overrides?: Partial<FieldsOf<GlobalVariables> & FieldsOf<CheckpointConstantData>>) => GlobalVariables;
+export declare const makeCheckpointConstants: (slotNumber: number, overrides?: Partial<FieldsOf<CheckpointConstantData>>) => CheckpointConstantData;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZml4dHVyZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tb2Nrcy9maXh0dXJlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUk3RCxPQUFPLEVBQUUsS0FBSyxnQkFBZ0IsRUFBK0MsTUFBTSw4QkFBOEIsQ0FBQztBQUdsSCxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUNuRSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFjeEQsZUFBTyxNQUFNLG9CQUFvQjs7Ozs7OztjQWtDaEMsQ0FBQztBQUVGLHdCQUFzQixZQUFZLENBQ2hDLE1BQU0sRUFBRTtJQUFFLG9CQUFvQixFQUFFLE1BQU0sR0FBRyxTQUFTLENBQUM7SUFBQyxjQUFjLEVBQUUsTUFBTSxHQUFHLFNBQVMsQ0FBQTtDQUFFLEVBQ3hGLE1BQU0sQ0FBQyxFQUFFLE1BQU0sR0FDZCxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FnQjNCO0FBRUQsZUFBTyxNQUFNLFdBQVcsa0pBaUJ2QixDQUFDO0FBRUYsZUFBTyxNQUFNLHVCQUF1Qix1R0FnQm5DLENBQUMifQ==

package/dest/mocks/fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/mocks/fixtures.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAI7D,OAAO,EAAE,KAAK,gBAAgB,EAA+C,MAAM,8BAA8B,CAAC;AAGlH,OAAO,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAcxD,eAAO,MAAM,oBAAoB;;;;;;;cAkChC,CAAC;AAEF,wBAAsB,YAAY,CAChC,MAAM,EAAE;IAAE,oBAAoB,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,EACxF,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,gBAAgB,CAAC,CAgB3B;AAED,eAAO,MAAM,WAAW,kJAiBvB,CAAC;AAEF,eAAO,MAAM,uBAAuB,uGAgBnC,CAAC"}

package/dest/mocks/fixtures.js

@@ -0,0 +1,96 @@
+import { BlockNumber, SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { randomBytes } from '@aztec-labs/foundation/crypto/random';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { fileURLToPath } from '@aztec-labs/foundation/url';
+import { getVKTreeRoot } from '@aztec-labs/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec-labs/protocol-contracts';
+import { NativeACVMSimulator, WASMSimulatorWithBlobs } from '@aztec-labs/simulator/server';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { GasFees } from '@aztec-labs/stdlib/gas';
+import { CheckpointConstantData } from '@aztec-labs/stdlib/rollup';
+import { GlobalVariables } from '@aztec-labs/stdlib/tx';
+import { promises as fs } from 'fs';
+import path from 'path';
+const { TEMP_DIR = '/tmp', BB_BINARY_PATH = '', BB_WORKING_DIRECTORY = '', BB_SKIP_CLEANUP = '', ACVM_BINARY_PATH = '', ACVM_WORKING_DIRECTORY = '' } = process.env;
+// Determines if we have access to the bb binary and a tmp folder for temp files
+export const getEnvironmentConfig = async (logger)=>{
+    try {
+        const expectedBBPath = BB_BINARY_PATH ? BB_BINARY_PATH : `${path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../labs-aztec-toolchain/bin')}/bb-avm`;
+        await fs.access(expectedBBPath, fs.constants.R_OK);
+        const tempWorkingDirectory = `${TEMP_DIR}/${randomBytes(4).toString('hex')}`;
+        const bbWorkingDirectory = BB_WORKING_DIRECTORY ? BB_WORKING_DIRECTORY : `${tempWorkingDirectory}/bb`;
+        await fs.mkdir(bbWorkingDirectory, {
+            recursive: true
+        });
+        logger.info(`Found native BB binary at ${expectedBBPath} with working directory ${bbWorkingDirectory}`);
+        const expectedAcvmPath = ACVM_BINARY_PATH ? ACVM_BINARY_PATH : `${path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../labs-aztec-toolchain/bin')}/acvm`;
+        await fs.access(expectedAcvmPath, fs.constants.R_OK);
+        const acvmWorkingDirectory = ACVM_WORKING_DIRECTORY ? ACVM_WORKING_DIRECTORY : `${tempWorkingDirectory}/acvm`;
+        await fs.mkdir(acvmWorkingDirectory, {
+            recursive: true
+        });
+        logger.info(`Found native ACVM binary at ${expectedAcvmPath} with working directory ${acvmWorkingDirectory}`);
+        const bbSkipCleanup = [
+            '1',
+            'true'
+        ].includes(BB_SKIP_CLEANUP);
+        bbSkipCleanup && logger.verbose(`Not going to clean up BB working directory ${bbWorkingDirectory} after run`);
+        return {
+            acvmWorkingDirectory,
+            bbWorkingDirectory,
+            expectedAcvmPath,
+            expectedBBPath,
+            directoryToCleanup: ACVM_WORKING_DIRECTORY && BB_WORKING_DIRECTORY ? undefined : tempWorkingDirectory,
+            bbSkipCleanup
+        };
+    } catch (err) {
+        logger.info(`Native BB not available: ${err}`);
+        return undefined;
+    }
+};
+export async function getSimulator(config, logger) {
+    if (config.acvmBinaryPath && config.acvmWorkingDirectory) {
+        try {
+            await fs.access(config.acvmBinaryPath, fs.constants.R_OK);
+            await fs.mkdir(config.acvmWorkingDirectory, {
+                recursive: true
+            });
+            logger?.info(`Using native ACVM at ${config.acvmBinaryPath} and working directory ${config.acvmWorkingDirectory}`);
+            const acvmLogger = logger?.createChild('acvm-native');
+            return new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath, undefined, acvmLogger);
+        } catch  {
+            logger?.warn(`Failed to access ACVM at ${config.acvmBinaryPath}, falling back to WASM`);
+        }
+    }
+    logger?.info('Using WASM ACVM simulation');
+    return new WASMSimulatorWithBlobs();
+}
+export const makeGlobals = (blockNumber, slotNumber = blockNumber, overrides = {})=>{
+    const checkpointConstants = makeCheckpointConstants(slotNumber, overrides);
+    return GlobalVariables.from({
+        chainId: checkpointConstants.chainId,
+        version: checkpointConstants.version,
+        blockNumber: BlockNumber(blockNumber),
+        slotNumber: SlotNumber(slotNumber),
+        timestamp: BigInt(blockNumber * 123),
+        coinbase: checkpointConstants.coinbase,
+        feeRecipient: checkpointConstants.feeRecipient,
+        gasFees: checkpointConstants.gasFees,
+        ...overrides
+    });
+};
+export const makeCheckpointConstants = (slotNumber, overrides = {})=>{
+    return CheckpointConstantData.from({
+        chainId: Fr.ZERO,
+        version: Fr.ZERO,
+        vkTreeRoot: getVKTreeRoot(),
+        protocolContractsHash,
+        proverId: Fr.ZERO,
+        slotNumber: SlotNumber(slotNumber),
+        coinbase: EthAddress.ZERO,
+        feeRecipient: AztecAddress.ZERO,
+        gasFees: GasFees.empty(),
+        ...overrides
+    });
+};