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

package/dest/mocks/test_context.d.ts

@@ -0,0 +1,93 @@
+import type { BBProverConfig } from '@aztec-labs/bb-prover';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { Logger } from '@aztec-labs/foundation/log';
+import { SerialQueue } from '@aztec-labs/foundation/queue';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { Checkpoint } from '@aztec-labs/stdlib/checkpoint';
+import type { MerkleTreeWriteOperations, ServerCircuitProver } from '@aztec-labs/stdlib/interfaces/server';
+import type { CheckpointConstantData } from '@aztec-labs/stdlib/rollup';
+import { mockProcessedTx } from '@aztec-labs/stdlib/testing';
+import { type BlockHeader, type GlobalVariables, type ProcessedTx } from '@aztec-labs/stdlib/tx';
+import type { MerkleTreeAdminDatabase } from '@aztec-labs/world-state';
+import { BrokerCircuitProverFacade } from '../proving_broker/broker_prover_facade.js';
+import { TestBroker } from '../test/mock_prover.js';
+/**
+ * Builds a started `SerialQueue` for use as an orchestrator's deferred-job queue in
+ * tests. Production wires a single shared queue via `ProverClient`; tests that construct
+ * orchestrators directly use one of these per orchestrator (or share one).
+ */
+export declare function makeTestDeferredJobQueue(concurrency?: number): SerialQueue;
+export declare class TestContext {
+    worldState: MerkleTreeAdminDatabase;
+    prover: ServerCircuitProver;
+    broker: TestBroker;
+    brokerProverFacade: BrokerCircuitProverFacade;
+    private feePayer;
+    private directoriesToCleanup;
+    private logger;
+    private headers;
+    private checkpoints;
+    private checkpointOutHashes;
+    private nextCheckpointIndex;
+    private nextCheckpointNumber;
+    private nextBlockNumber;
+    private epochNumber;
+    private feePayerBalance;
+    private currentInboxRollingHash;
+    constructor(worldState: MerkleTreeAdminDatabase, prover: ServerCircuitProver, broker: TestBroker, brokerProverFacade: BrokerCircuitProverFacade, feePayer: AztecAddress, initialFeePayerBalance: Fr, directoriesToCleanup: string[], logger: Logger);
+    static new(logger: Logger, { proverCount, createProver }?: {
+        proverCount?: number;
+        createProver?: (bbConfig: BBProverConfig) => Promise<ServerCircuitProver>;
+    }): Promise<TestContext>;
+    getFork(): Promise<MerkleTreeWriteOperations>;
+    cleanup(): Promise<void>;
+    startNewEpoch(): void;
+    getBlobFields(): Fr[][];
+    getFinalBlobChallenges(): Promise<import("@aztec-labs/blob-lib").FinalBlobBatchingChallenges>;
+    makeCheckpoint(numBlocks: number, { numTxsPerBlock, numL1ToL2Messages, makeProcessedTxOpts, ...constantOpts }?: {
+        numTxsPerBlock?: number | number[];
+        numL1ToL2Messages?: number;
+        makeProcessedTxOpts?: (blockGlobalVariables: GlobalVariables, txIndex: number) => Partial<Parameters<typeof mockProcessedTx>[0]>;
+    } & Partial<FieldsOf<CheckpointConstantData>>): Promise<{
+        constants: CheckpointConstantData;
+        checkpoint: Checkpoint;
+        header: import("@aztec-labs/stdlib/rollup").CheckpointHeader;
+        blocks: {
+            header: BlockHeader;
+            txs: ProcessedTx[];
+        }[];
+        l1ToL2Messages: Fr[];
+        previousBlockHeader: BlockHeader;
+        startInboxRollingHash: Fr;
+    }>;
+    /**
+     * Like {@link makeCheckpoint} but distributes the L1-to-L2 message bundle across the checkpoint's blocks
+     * (streaming Inbox): `l1ToL2MessagesPerBlock[i]` is block `i`'s own message slice,
+     * appended at compact indices in insertion order. Lets tests exercise checkpoints whose messages span more
+     * than one block, including a non-first block carrying a bundle — the single-block-per-checkpoint
+     * `makeCheckpoint` puts every message in the first block. `numTxsPerBlock` defaults to 1 because the builder
+     * rejects a non-first block with neither txs nor messages; a zero-tx entry whose slice is non-empty is valid
+     * and produces a message-only block.
+     */
+    makeCheckpointWithMessagesPerBlock(l1ToL2MessagesPerBlock: Fr[][], { numTxsPerBlock, makeProcessedTxOpts, ...constantOpts }?: {
+        numTxsPerBlock?: number | number[];
+        makeProcessedTxOpts?: (blockGlobalVariables: GlobalVariables, txIndex: number) => Partial<Parameters<typeof mockProcessedTx>[0]>;
+    } & Partial<FieldsOf<CheckpointConstantData>>): Promise<{
+        constants: CheckpointConstantData;
+        checkpoint: Checkpoint;
+        header: import("@aztec-labs/stdlib/rollup").CheckpointHeader;
+        blocks: {
+            header: BlockHeader;
+            txs: ProcessedTx[];
+        }[];
+        l1ToL2Messages: Fr[];
+        l1ToL2MessagesPerBlock: Fr[][];
+        previousBlockHeader: BlockHeader;
+        startInboxRollingHash: Fr;
+    }>;
+    private makeProcessedTx;
+    private getBlockHeader;
+    private updateTrees;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"test_context.d.ts","sourceRoot":"","sources":["../../src/mocks/test_context.ts"],"names":[],"mappings":"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"}

package/dest/mocks/test_context.js

@@ -0,0 +1,354 @@
+import { TestCircuitProver } from '@aztec-labs/bb-prover';
+import { BlockNumber, CheckpointNumber } from '@aztec-labs/foundation/branded-types';
+import { times, timesAsync } from '@aztec-labs/foundation/collection';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { SerialQueue } from '@aztec-labs/foundation/queue';
+import { getVKTreeRoot } from '@aztec-labs/noir-protocol-circuits-types/vk-tree';
+import { ProtocolContractsList } from '@aztec-labs/protocol-contracts';
+import { computeFeePayerBalanceLeafSlot } from '@aztec-labs/protocol-contracts/fee-juice';
+import { PublicDataWrite } from '@aztec-labs/stdlib/avm';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { mockProcessedTx } from '@aztec-labs/stdlib/testing';
+import { MerkleTreeId, PublicDataTreeLeaf } from '@aztec-labs/stdlib/trees';
+import { TreeSnapshots } from '@aztec-labs/stdlib/tx';
+import { NativeWorldStateService } from '@aztec-labs/world-state/native';
+import { promises as fs } from 'fs';
+import { LightweightCheckpointBuilder } from '../light/lightweight_checkpoint_builder.js';
+import { buildFinalBlobChallenges, getTreeSnapshot, insertSideEffects } from '../orchestrator/block-building-helpers.js';
+import { BrokerCircuitProverFacade } from '../proving_broker/broker_prover_facade.js';
+import { TestBroker } from '../test/mock_prover.js';
+import { getEnvironmentConfig, getSimulator, makeCheckpointConstants, makeGlobals } from './fixtures.js';
+/**
+ * Builds a started `SerialQueue` for use as an orchestrator's deferred-job queue in
+ * tests. Production wires a single shared queue via `ProverClient`; tests that construct
+ * orchestrators directly use one of these per orchestrator (or share one).
+ */ export function makeTestDeferredJobQueue(concurrency = 10) {
+    const queue = new SerialQueue();
+    queue.start(concurrency);
+    return queue;
+}
+export class TestContext {
+    worldState;
+    prover;
+    broker;
+    brokerProverFacade;
+    feePayer;
+    directoriesToCleanup;
+    logger;
+    headers;
+    checkpoints;
+    checkpointOutHashes;
+    nextCheckpointIndex;
+    nextCheckpointNumber;
+    nextBlockNumber;
+    epochNumber;
+    feePayerBalance;
+    // Running inbox rolling hash across the checkpoints built by this context (never resets: the protocol threads it
+    // from genesis). Each checkpoint's builder starts from it, and it advances by the checkpoint's messages, so a
+    // checkpoint built after a message-carrying one commits the correct continuation in its header.
+    currentInboxRollingHash;
+    constructor(worldState, prover, broker, brokerProverFacade, feePayer, initialFeePayerBalance, directoriesToCleanup, logger){
+        this.worldState = worldState;
+        this.prover = prover;
+        this.broker = broker;
+        this.brokerProverFacade = brokerProverFacade;
+        this.feePayer = feePayer;
+        this.directoriesToCleanup = directoriesToCleanup;
+        this.logger = logger;
+        this.headers = new Map();
+        this.checkpoints = [];
+        this.checkpointOutHashes = [];
+        this.nextCheckpointIndex = 0;
+        this.nextCheckpointNumber = CheckpointNumber(1);
+        this.nextBlockNumber = 1;
+        this.epochNumber = 1;
+        this.currentInboxRollingHash = Fr.ZERO;
+        this.feePayerBalance = initialFeePayerBalance;
+    }
+    static async new(logger, { proverCount = 4, createProver = async (bbConfig)=>new TestCircuitProver(await getSimulator(bbConfig, logger)) } = {}) {
+        const directoriesToCleanup = [];
+        const feePayer = AztecAddress.fromNumberUnsafe(42222);
+        const initialFeePayerBalance = new Fr(10n ** 20n);
+        const feePayerSlot = await computeFeePayerBalanceLeafSlot(feePayer);
+        const genesis = {
+            prefilledPublicData: [
+                new PublicDataTreeLeaf(feePayerSlot, initialFeePayerBalance)
+            ],
+            genesisTimestamp: 0n
+        };
+        // Separated dbs for public processor and prover - see public_processor for context
+        const ws = await NativeWorldStateService.tmp(/*cleanupTmpDir=*/ true, genesis);
+        let localProver;
+        const config = await getEnvironmentConfig(logger);
+        if (!config) {
+            localProver = new TestCircuitProver();
+        } else {
+            const bbConfig = {
+                acvmBinaryPath: config.expectedAcvmPath,
+                acvmWorkingDirectory: config.acvmWorkingDirectory,
+                bbBinaryPath: config.expectedBBPath,
+                bbWorkingDirectory: config.bbWorkingDirectory,
+                bbSkipCleanup: config.bbSkipCleanup,
+                numConcurrentIVCVerifiers: 8,
+                bbIVCConcurrency: 1,
+                bbChonkVerifyMaxBatch: 16,
+                bbChonkVerifyConcurrency: 6
+            };
+            localProver = await createProver(bbConfig);
+        }
+        if (config?.directoryToCleanup && !config.bbSkipCleanup) {
+            directoriesToCleanup.push(config.directoryToCleanup);
+        }
+        const broker = new TestBroker(proverCount, localProver);
+        const facade = new BrokerCircuitProverFacade(broker);
+        await broker.start();
+        facade.start();
+        return new this(ws, localProver, broker, facade, feePayer, initialFeePayerBalance, directoriesToCleanup, logger);
+    }
+    getFork() {
+        return this.worldState.fork();
+    }
+    async cleanup() {
+        await this.brokerProverFacade.stop();
+        await this.broker.stop();
+        await this.worldState.close();
+        for (const dir of this.directoriesToCleanup.filter((x)=>x !== '')){
+            try {
+                await fs.rm(dir, {
+                    recursive: true,
+                    force: true,
+                    maxRetries: 3
+                });
+            } catch (err) {
+                this.logger.warn(`Failed to delete tmp directory $dir}: ${err}`);
+            }
+        }
+    }
+    startNewEpoch() {
+        this.checkpoints = [];
+        this.checkpointOutHashes = [];
+        this.nextCheckpointIndex = 0;
+        this.epochNumber++;
+    }
+    // Return blob fields of all checkpoints in the epoch.
+    getBlobFields() {
+        return this.checkpoints.map((checkpoint)=>checkpoint.toBlobFields());
+    }
+    async getFinalBlobChallenges() {
+        const blobFields = this.getBlobFields();
+        return await buildFinalBlobChallenges(blobFields);
+    }
+    async makeCheckpoint(numBlocks, { numTxsPerBlock = 0, numL1ToL2Messages = 0, makeProcessedTxOpts = ()=>({}), ...constantOpts } = {}) {
+        if (numBlocks === 0) {
+            throw new Error('Cannot make a checkpoint with 0 blocks. Crate an empty block (numTxsPerBlock = 0) if there are no txs.');
+        }
+        const checkpointIndex = this.nextCheckpointIndex++;
+        const checkpointNumber = this.nextCheckpointNumber;
+        this.nextCheckpointNumber++;
+        const slotNumber = checkpointNumber * 15; // times an arbitrary number to make it different to the checkpoint number
+        const constants = makeCheckpointConstants(slotNumber, constantOpts);
+        const fork = await this.worldState.fork();
+        // Build l1 to l2 messages. Appended unpadded at compact indices; the mock assigns them all to
+        // the checkpoint's first block, matching how the per-block driver slices them.
+        const l1ToL2Messages = times(numL1ToL2Messages, (i)=>new Fr(slotNumber * 100 + i));
+        await fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2Messages);
+        const newL1ToL2Snapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, fork);
+        const startBlockNumber = this.nextBlockNumber;
+        const previousBlockHeader = this.getBlockHeader(BlockNumber(startBlockNumber - 1));
+        // All blocks in the same slot/checkpoint share the same timestamp.
+        const timestamp = BigInt(slotNumber * 26);
+        // Build global variables.
+        const blockGlobalVariables = times(numBlocks, (i)=>makeGlobals(startBlockNumber + i, slotNumber, {
+                coinbase: constants.coinbase,
+                feeRecipient: constants.feeRecipient,
+                gasFees: constants.gasFees,
+                timestamp
+            }));
+        this.nextBlockNumber += numBlocks;
+        // Build txs.
+        let totalTxs = 0;
+        const blockEndStates = [];
+        const blockTxs = await timesAsync(numBlocks, async (blockIndex)=>{
+            const txIndexOffset = totalTxs;
+            const numTxs = typeof numTxsPerBlock === 'number' ? numTxsPerBlock : numTxsPerBlock[blockIndex];
+            totalTxs += numTxs;
+            const txs = await timesAsync(numTxs, (txIndex)=>this.makeProcessedTx({
+                    seed: (txIndexOffset + txIndex + 1) * 321 + (checkpointIndex + 1) * 123456 + this.epochNumber * 0x99999,
+                    globalVariables: blockGlobalVariables[blockIndex],
+                    anchorBlockHeader: previousBlockHeader,
+                    newL1ToL2Snapshot,
+                    ...makeProcessedTxOpts(blockGlobalVariables[blockIndex], txIndexOffset + txIndex)
+                }));
+            // Insert side effects into the trees.
+            const endState = await this.updateTrees(txs, fork);
+            blockEndStates.push(endState);
+            return txs;
+        });
+        const cleanFork = await this.worldState.fork();
+        const previousCheckpointOutHashes = this.checkpointOutHashes;
+        const startInboxRollingHash = this.currentInboxRollingHash;
+        const builder = LightweightCheckpointBuilder.startNewCheckpoint(checkpointNumber, {
+            ...constants,
+            timestamp
+        }, previousCheckpointOutHashes, startInboxRollingHash, cleanFork);
+        // Add tx effects to db and build block headers.
+        const blocks = [];
+        for(let i = 0; i < numBlocks; i++){
+            const txs = blockTxs[i];
+            const state = blockEndStates[i];
+            const { block } = await builder.addBlock(blockGlobalVariables[i], txs, i === 0 ? l1ToL2Messages : [], {
+                expectedEndState: state,
+                insertTxsEffects: true
+            });
+            const header = block.header;
+            this.headers.set(block.number, header);
+            const blockMsgs = block.indexWithinCheckpoint === 0 ? l1ToL2Messages : [];
+            await this.worldState.handleL2BlockAndMessages(block, blockMsgs);
+            blocks.push({
+                header,
+                txs
+            });
+        }
+        const checkpoint = await builder.completeCheckpoint();
+        this.checkpoints.push(checkpoint);
+        this.checkpointOutHashes.push(checkpoint.getCheckpointOutHash());
+        this.currentInboxRollingHash = checkpoint.header.inboxRollingHash;
+        return {
+            constants,
+            checkpoint,
+            header: checkpoint.header,
+            blocks,
+            l1ToL2Messages,
+            previousBlockHeader,
+            startInboxRollingHash
+        };
+    }
+    /**
+   * Like {@link makeCheckpoint} but distributes the L1-to-L2 message bundle across the checkpoint's blocks
+   * (streaming Inbox): `l1ToL2MessagesPerBlock[i]` is block `i`'s own message slice,
+   * appended at compact indices in insertion order. Lets tests exercise checkpoints whose messages span more
+   * than one block, including a non-first block carrying a bundle — the single-block-per-checkpoint
+   * `makeCheckpoint` puts every message in the first block. `numTxsPerBlock` defaults to 1 because the builder
+   * rejects a non-first block with neither txs nor messages; a zero-tx entry whose slice is non-empty is valid
+   * and produces a message-only block.
+   */ async makeCheckpointWithMessagesPerBlock(l1ToL2MessagesPerBlock, { numTxsPerBlock = 1, makeProcessedTxOpts = ()=>({}), ...constantOpts } = {}) {
+        const numBlocks = l1ToL2MessagesPerBlock.length;
+        if (numBlocks === 0) {
+            throw new Error('Cannot make a checkpoint with 0 blocks.');
+        }
+        const checkpointIndex = this.nextCheckpointIndex++;
+        const checkpointNumber = this.nextCheckpointNumber;
+        this.nextCheckpointNumber++;
+        const slotNumber = checkpointNumber * 15;
+        const constants = makeCheckpointConstants(slotNumber, constantOpts);
+        const l1ToL2Messages = l1ToL2MessagesPerBlock.flat();
+        const fork = await this.worldState.fork();
+        const startBlockNumber = this.nextBlockNumber;
+        const previousBlockHeader = this.getBlockHeader(BlockNumber(startBlockNumber - 1));
+        const timestamp = BigInt(slotNumber * 26);
+        const blockGlobalVariables = times(numBlocks, (i)=>makeGlobals(startBlockNumber + i, slotNumber, {
+                coinbase: constants.coinbase,
+                feeRecipient: constants.feeRecipient,
+                gasFees: constants.gasFees,
+                timestamp
+            }));
+        this.nextBlockNumber += numBlocks;
+        // Build txs per block. Append the block's message slice to the fork before its txs so the per-block end
+        // state matches the builder's (message-tree and tx-effect trees are independent, so append order does not
+        // matter, but the cumulative message tree must reflect the slices already inserted).
+        let totalTxs = 0;
+        const blockEndStates = [];
+        const blockTxs = await timesAsync(numBlocks, async (blockIndex)=>{
+            await fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPerBlock[blockIndex]);
+            const newL1ToL2Snapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, fork);
+            const txIndexOffset = totalTxs;
+            const numTxs = typeof numTxsPerBlock === 'number' ? numTxsPerBlock : numTxsPerBlock[blockIndex];
+            totalTxs += numTxs;
+            const txs = await timesAsync(numTxs, (txIndex)=>this.makeProcessedTx({
+                    seed: (txIndexOffset + txIndex + 1) * 321 + (checkpointIndex + 1) * 123456 + this.epochNumber * 0x99999,
+                    globalVariables: blockGlobalVariables[blockIndex],
+                    anchorBlockHeader: previousBlockHeader,
+                    newL1ToL2Snapshot,
+                    ...makeProcessedTxOpts(blockGlobalVariables[blockIndex], txIndexOffset + txIndex)
+                }));
+            const endState = await this.updateTrees(txs, fork);
+            blockEndStates.push(endState);
+            return txs;
+        });
+        const cleanFork = await this.worldState.fork();
+        const previousCheckpointOutHashes = this.checkpointOutHashes;
+        const startInboxRollingHash = this.currentInboxRollingHash;
+        const builder = LightweightCheckpointBuilder.startNewCheckpoint(checkpointNumber, {
+            ...constants,
+            timestamp
+        }, previousCheckpointOutHashes, startInboxRollingHash, cleanFork);
+        const blocks = [];
+        for(let i = 0; i < numBlocks; i++){
+            const txs = blockTxs[i];
+            const state = blockEndStates[i];
+            const { block } = await builder.addBlock(blockGlobalVariables[i], txs, l1ToL2MessagesPerBlock[i], {
+                expectedEndState: state,
+                insertTxsEffects: true
+            });
+            const header = block.header;
+            this.headers.set(block.number, header);
+            await this.worldState.handleL2BlockAndMessages(block, l1ToL2MessagesPerBlock[i]);
+            blocks.push({
+                header,
+                txs
+            });
+        }
+        const checkpoint = await builder.completeCheckpoint();
+        this.checkpoints.push(checkpoint);
+        this.checkpointOutHashes.push(checkpoint.getCheckpointOutHash());
+        this.currentInboxRollingHash = checkpoint.header.inboxRollingHash;
+        return {
+            constants,
+            checkpoint,
+            header: checkpoint.header,
+            blocks,
+            l1ToL2Messages,
+            l1ToL2MessagesPerBlock,
+            previousBlockHeader,
+            startInboxRollingHash
+        };
+    }
+    async makeProcessedTx(opts = {}) {
+        const tx = await mockProcessedTx({
+            vkTreeRoot: getVKTreeRoot(),
+            protocolContracts: ProtocolContractsList,
+            feePayer: this.feePayer,
+            ...opts
+        });
+        this.feePayerBalance = new Fr(this.feePayerBalance.toBigInt() - tx.txEffect.transactionFee.toBigInt());
+        const feePayerSlot = await computeFeePayerBalanceLeafSlot(this.feePayer);
+        const feePaymentPublicDataWrite = new PublicDataWrite(feePayerSlot, this.feePayerBalance);
+        tx.txEffect.publicDataWrites[0] = feePaymentPublicDataWrite;
+        if (tx.avmProvingRequest) {
+            tx.avmProvingRequest.inputs.publicInputs.accumulatedData.publicDataWrites[0] = feePaymentPublicDataWrite;
+        }
+        return tx;
+    }
+    getBlockHeader(blockNumber) {
+        if (Number(blockNumber) > 0 && Number(blockNumber) >= this.nextBlockNumber) {
+            throw new Error(`Block header not built for block number ${blockNumber}.`);
+        }
+        return Number(blockNumber) === 0 ? this.worldState.getCommitted().getInitialHeader() : this.headers.get(Number(blockNumber));
+    }
+    async updateTrees(txs, fork) {
+        let startStateReference = await fork.getStateReference();
+        let endStateReference = startStateReference;
+        for (const tx of txs){
+            await insertSideEffects(tx, fork);
+            endStateReference = await fork.getStateReference();
+            if (tx.avmProvingRequest) {
+                // Update the trees in the avm public inputs so that the proof won't fail.
+                const l1ToL2MessageTree = tx.avmProvingRequest.inputs.publicInputs.startTreeSnapshots.l1ToL2MessageTree;
+                tx.avmProvingRequest.inputs.publicInputs.startTreeSnapshots = new TreeSnapshots(l1ToL2MessageTree, startStateReference.partial.noteHashTree, startStateReference.partial.nullifierTree, startStateReference.partial.publicDataTree);
+                tx.avmProvingRequest.inputs.publicInputs.endTreeSnapshots = new TreeSnapshots(l1ToL2MessageTree, endStateReference.partial.noteHashTree, endStateReference.partial.nullifierTree, endStateReference.partial.publicDataTree);
+            }
+            startStateReference = endStateReference;
+        }
+        return endStateReference;
+    }
+}

package/dest/orchestrator/block-building-helpers.d.ts

@@ -0,0 +1,67 @@
+import { BatchedBlobAccumulator, SpongeBlob } from '@aztec-labs/blob-lib';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { type Bufferable } from '@aztec-labs/foundation/serialize';
+import { MembershipWitness } from '@aztec-labs/foundation/trees';
+import { Body } from '@aztec-labs/stdlib/block';
+import type { MerkleTreeWriteOperations, PublicInputsAndRecursiveProof } from '@aztec-labs/stdlib/interfaces/server';
+import { ProofData, RecursiveProof } from '@aztec-labs/stdlib/proofs';
+import { BlockRollupPublicInputs, PrivateBaseRollupHints, PublicBaseRollupHints, PublicChonkVerifierPrivateInputs } from '@aztec-labs/stdlib/rollup';
+import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec-labs/stdlib/trees';
+import { BlockHeader, GlobalVariables, PartialStateReference, type ProcessedTx, StateReference, Tx } from '@aztec-labs/stdlib/tx';
+import type { MerkleTreeReadOperations } from '@aztec-labs/world-state';
+/**
+ * Type representing the names of the trees for the base rollup.
+ */
+type BaseTreeNames = 'NoteHashTree' | 'ContractTree' | 'NullifierTree' | 'PublicDataTree';
+/**
+ * Type representing the names of the trees.
+ */
+export type TreeNames = BaseTreeNames | 'L1ToL2MessageTree' | 'Archive';
+export declare const insertSideEffectsAndBuildBaseRollupHints: (tx: ProcessedTx, lastArchive: AppendOnlyTreeSnapshot, newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, startSpongeBlob: SpongeBlob, proverId: Fr, db: MerkleTreeWriteOperations) => Promise<PrivateBaseRollupHints | PublicBaseRollupHints>;
+export declare const insertSideEffects: (tx: ProcessedTx, db: MerkleTreeWriteOperations) => Promise<{
+    nullifierInsertionResult: import("@aztec-labs/stdlib/trees").BatchInsertionResult<number, number>;
+    publicDataInsertionResult: import("@aztec-labs/stdlib/trees").SequentialInsertionResult<number>;
+}>;
+export declare function getChonkProofFromTx(tx: Tx | ProcessedTx): RecursiveProof<1221>;
+export declare function getPublicChonkVerifierPrivateInputsFromTx(tx: Tx | ProcessedTx, proverId: Fr): PublicChonkVerifierPrivateInputs;
+export declare const buildBlobHints: (blobFields: Fr[]) => Promise<{
+    blobCommitments: import("@aztec-labs/foundation/curves/bls12").BLS12Point[];
+    blobs: import("@aztec-labs/blob-lib").Blob[];
+    blobsHash: Fr;
+}>;
+export declare const buildFinalBlobChallenges: (blobFieldsPerCheckpoint: Fr[][]) => Promise<import("@aztec-labs/blob-lib").FinalBlobBatchingChallenges>;
+export declare const accumulateBlobs: (blobFields: Fr[], startBlobAccumulator: BatchedBlobAccumulator) => Promise<BatchedBlobAccumulator>;
+export declare const buildHeaderFromCircuitOutputs: (blockRootRollupOutput: BlockRollupPublicInputs) => Promise<BlockHeader>;
+export declare const buildHeaderAndBodyFromTxs: (txs: ProcessedTx[], lastArchive: AppendOnlyTreeSnapshot, endState: StateReference, globalVariables: GlobalVariables, startSpongeBlob: SpongeBlob) => Promise<{
+    header: BlockHeader;
+    body: Body;
+    blockBlobFields: Fr[];
+}>;
+export declare function getLastSiblingPath<TID extends MerkleTreeId>(treeId: TID, db: MerkleTreeReadOperations): Promise<import("@aztec-labs/foundation/serialize").Tuple<Fr, {
+    readonly 1: 42;
+    readonly 4: 30;
+    readonly 3: 36;
+    readonly 0: 42;
+    readonly 2: 40;
+}[TID]>>;
+export declare function getRootTreeSiblingPath<TID extends MerkleTreeId>(treeId: TID, db: MerkleTreeReadOperations): Promise<import("@aztec-labs/foundation/serialize").Tuple<Fr, {
+    readonly 1: 42;
+    readonly 4: 30;
+    readonly 3: 36;
+    readonly 0: 42;
+    readonly 2: 40;
+}[TID]>>;
+export declare function getTreeSnapshot(id: MerkleTreeId, db: MerkleTreeReadOperations): Promise<AppendOnlyTreeSnapshot>;
+export declare function makeEmptyMembershipWitness<N extends number>(height: N): MembershipWitness<N>;
+export declare function getSubtreeSiblingPath(treeId: MerkleTreeId, subtreeHeight: number, db: MerkleTreeReadOperations): Promise<Fr[]>;
+/**
+ * Returns the full-height frontier (left-sibling path) at a tree's next-available leaf index — the hint the append
+ * circuits re-hash against the snapshot root when appending leaves at a compact (unaligned) index.
+ */
+export declare function getFrontierSiblingPath(treeId: MerkleTreeId, db: MerkleTreeReadOperations): Promise<Fr[]>;
+export declare function getMembershipWitnessFor<N extends number>(value: Fr, treeId: MerkleTreeId, height: N, db: MerkleTreeReadOperations): Promise<MembershipWitness<N>>;
+export declare function validatePartialState(partialState: PartialStateReference, treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>): void;
+export declare function validateTx(tx: ProcessedTx): void;
+export declare function toProofData<T extends Bufferable, PROOF_LENGTH extends number>({ inputs, proof, verificationKey }: PublicInputsAndRecursiveProof<T, PROOF_LENGTH>, vkIndex?: number): ProofData<T, PROOF_LENGTH>;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvY2stYnVpbGRpbmctaGVscGVycy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL29yY2hlc3RyYXRvci9ibG9jay1idWlsZGluZy1oZWxwZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxzQkFBc0IsRUFDdEIsVUFBVSxFQUtYLE1BQU0sc0JBQXNCLENBQUM7QUFpQjlCLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUN6RCxPQUFPLEVBQUUsS0FBSyxVQUFVLEVBQWdDLE1BQU0sa0NBQWtDLENBQUM7QUFDakcsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFJakUsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ2hELE9BQU8sS0FBSyxFQUFFLHlCQUF5QixFQUFFLDZCQUE2QixFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFFckgsT0FBTyxFQUFTLFNBQVMsRUFBRSxjQUFjLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUM3RSxPQUFPLEVBRUwsdUJBQXVCLEVBQ3ZCLHNCQUFzQixFQUN0QixxQkFBcUIsRUFDckIsZ0NBQWdDLEVBRWpDLE1BQU0sMkJBQTJCLENBQUM7QUFDbkMsT0FBTyxFQUNMLHNCQUFzQixFQUN0QixZQUFZLEVBSWIsTUFBTSwwQkFBMEIsQ0FBQztBQUNsQyxPQUFPLEVBQ0wsV0FBVyxFQUNYLGVBQWUsRUFDZixxQkFBcUIsRUFDckIsS0FBSyxXQUFXLEVBQ2hCLGNBQWMsRUFDZCxFQUFFLEVBQ0gsTUFBTSx1QkFBdUIsQ0FBQztBQUcvQixPQUFPLEtBQUssRUFBRSx3QkFBd0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRXhFOztHQUVHO0FBQ0gsS0FBSyxhQUFhLEdBQUcsY0FBYyxHQUFHLGNBQWMsR0FBRyxlQUFlLEdBQUcsZ0JBQWdCLENBQUM7QUFDMUY7O0dBRUc7QUFDSCxNQUFNLE1BQU0sU0FBUyxHQUFHLGFBQWEsR0FBRyxtQkFBbUIsR0FBRyxTQUFTLENBQUM7QUFHeEUsZUFBTyxNQUFNLHdDQUF3QyxtUEEwSHBELENBQUM7QUFFRixlQUFPLE1BQU0saUJBQWlCOzs7RUFvQzdCLENBQUM7QUFFRix3QkFBZ0IsbUJBQW1CLENBQUMsRUFBRSxFQUFFLEVBQUUsR0FBRyxXQUFXLHdCQVF2RDtBQUVELHdCQUFnQix5Q0FBeUMsQ0FBQyxFQUFFLEVBQUUsRUFBRSxHQUFHLFdBQVcsRUFBRSxRQUFRLEVBQUUsRUFBRSxvQ0FPM0Y7QUFLRCxlQUFPLE1BQU0sY0FBYzs7OztFQUsxQixDQUFDO0FBRUYsZUFBTyxNQUFNLHdCQUF3QiwwR0FFcEMsQ0FBQztBQUVGLGVBQU8sTUFBTSxlQUFlLHFHQU8zQixDQUFDO0FBRUYsZUFBTyxNQUFNLDZCQUE2QiwwRUEyQnpDLENBQUM7QUFFRixlQUFPLE1BQU0seUJBQXlCOzs7O0VBMERyQyxDQUFDO0FBRUYsd0JBQXNCLGtCQUFrQixDQUFDLEdBQUcsU0FBUyxZQUFZLEVBQUUsTUFBTSxFQUFFLEdBQUcsRUFBRSxFQUFFLEVBQUUsd0JBQXdCOzs7Ozs7U0FJM0c7QUFFRCx3QkFBc0Isc0JBQXNCLENBQUMsR0FBRyxTQUFTLFlBQVksRUFBRSxNQUFNLEVBQUUsR0FBRyxFQUFFLEVBQUUsRUFBRSx3QkFBd0I7Ozs7OztTQUkvRztBQUVELHdCQUFzQixlQUFlLENBQUMsRUFBRSxFQUFFLFlBQVksRUFBRSxFQUFFLEVBQUUsd0JBQXdCLEdBQUcsT0FBTyxDQUFDLHNCQUFzQixDQUFDLENBR3JIO0FBRUQsd0JBQWdCLDBCQUEwQixDQUFDLENBQUMsU0FBUyxNQUFNLEVBQUUsTUFBTSxFQUFFLENBQUMsd0JBTXJFO0FBRUQsd0JBQXNCLHFCQUFxQixDQUN6QyxNQUFNLEVBQUUsWUFBWSxFQUNwQixhQUFhLEVBQUUsTUFBTSxFQUNyQixFQUFFLEVBQUUsd0JBQXdCLEdBQzNCLE9BQU8sQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQU1mO0FBRUQ7OztHQUdHO0FBQ0gsd0JBQXNCLHNCQUFzQixDQUFDLE1BQU0sRUFBRSxZQUFZLEVBQUUsRUFBRSxFQUFFLHdCQUF3QixHQUFHLE9BQU8sQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUc5RztBQUdELHdCQUFzQix1QkFBdUIsQ0FBQyxDQUFDLFNBQVMsTUFBTSxFQUM1RCxLQUFLLEVBQUUsRUFBRSxFQUNULE1BQU0sRUFBRSxZQUFZLEVBQ3BCLE1BQU0sRUFBRSxDQUFDLEVBQ1QsRUFBRSxFQUFFLHdCQUF3QixHQUMzQixPQUFPLENBQUMsaUJBQWlCLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FZL0I7QUFFRCx3QkFBZ0Isb0JBQW9CLENBQ2xDLFlBQVksRUFBRSxxQkFBcUIsRUFDbkMsYUFBYSxFQUFFLEdBQUcsQ0FBQyxZQUFZLEVBQUUsc0JBQXNCLENBQUMsUUFTekQ7QUFxQkQsd0JBQWdCLFVBQVUsQ0FBQyxFQUFFLEVBQUUsV0FBVyxRQWN6QztBQUVELHdCQUFnQixXQUFXLENBQUMsQ0FBQyxTQUFTLFVBQVUsRUFBRSxZQUFZLFNBQVMsTUFBTSxFQUMzRSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsZUFBZSxFQUFFLEVBQUUsNkJBQTZCLENBQUMsQ0FBQyxFQUFFLFlBQVksQ0FBQyxFQUNsRixPQUFPLENBQUMsRUFBRSxNQUFNLDhCQUtqQiJ9

package/dest/orchestrator/block-building-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-building-helpers.d.ts","sourceRoot":"","sources":["../../src/orchestrator/block-building-helpers.ts"],"names":[],"mappings":"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"}