@aztec/prover-client 0.0.0-test.1 → 0.0.1-commit.001888fc

package/dest/orchestrator/block-proving-state.d.ts.map

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

package/dest/orchestrator/block-proving-state.js

@@ -1,252 +1,349 @@
-import { SpongeBlob } from '@aztec/blob-lib';
-import { BLOBS_PER_BLOCK, FIELDS_PER_BLOB, NUM_BASE_PARITY_PER_ROOT_PARITY, VK_TREE_HEIGHT } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
-import { MembershipWitness, UnbalancedTreeStore } from '@aztec/foundation/trees';
-import { getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
-import { RootParityInput, RootParityInputs } from '@aztec/stdlib/parity';
-import { BlockRootRollupBlobData, BlockRootRollupData, BlockRootRollupInputs, ConstantRollupData, EmptyBlockRootRollupInputs, MergeRollupInputs, PreviousRollupData, SingleTxBlockRootRollupInputs } from '@aztec/stdlib/rollup';
-import { StateReference } from '@aztec/stdlib/tx';
-import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-helpers.js';
+import { encodeBlockEndBlobData } from '@aztec/blob-lib';
+import { NUM_BASE_PARITY_PER_ROOT_PARITY } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { assertLength } from '@aztec/foundation/serialize';
+import { UnbalancedTreeStore } from '@aztec/foundation/trees';
+import { ParityRootPrivateInputs } from '@aztec/stdlib/parity';
+import { BlockRootEmptyTxFirstRollupPrivateInputs, BlockRootFirstRollupPrivateInputs, BlockRootRollupPrivateInputs, BlockRootSingleTxFirstRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs, TxMergeRollupPrivateInputs } from '@aztec/stdlib/rollup';
+import { BlockHeader, GlobalVariables } from '@aztec/stdlib/tx';
+import { buildHeaderFromCircuitOutputs, toProofData } from './block-building-helpers.js';
 /**
  * The current state of the proving schedule for a given block. Managed by ProvingState.
  * Contains the raw inputs and intermediate state to generate every constituent proof in the tree.
  */ export class BlockProvingState {
     index;
-    globalVariables;
-    newL1ToL2Messages;
-    l1ToL2MessageSubtreeSiblingPath;
-    l1ToL2MessageTreeSnapshotAfterInsertion;
-    lastArchiveSnapshot;
-    newArchiveSiblingPath;
-    previousBlockHeader;
-    parentEpoch;
-    baseOrMergeProvingOutputs;
-    baseParityProvingOutputs;
-    rootParityProvingOutput;
-    blockRootProvingOutput;
-    blockRootRollupStarted;
-    block;
-    spongeBlobState;
+    blockNumber;
     totalNumTxs;
+    constants;
+    timestamp;
+    lastArchiveTreeSnapshot;
+    lastArchiveSiblingPath;
+    lastL1ToL2MessageTreeSnapshot;
+    lastL1ToL2MessageSubtreeRootSiblingPath;
+    newL1ToL2MessageTreeSnapshot;
+    headerOfLastBlockInPreviousCheckpoint;
+    startSpongeBlob;
+    parentCheckpoint;
+    baseOrMergeProofs;
+    baseParityProofs;
+    rootParityProof;
+    blockRootProof;
+    builtBlockHeader;
+    builtArchive;
+    endState;
+    endSpongeBlob;
     txs;
+    isFirstBlock;
     error;
-    constructor(index, globalVariables, newL1ToL2Messages, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchiveSnapshot, newArchiveSiblingPath, previousBlockHeader, parentEpoch){
+    constructor(index, blockNumber, totalNumTxs, constants, timestamp, lastArchiveTreeSnapshot, lastArchiveSiblingPath, lastL1ToL2MessageTreeSnapshot, lastL1ToL2MessageSubtreeRootSiblingPath, newL1ToL2MessageTreeSnapshot, headerOfLastBlockInPreviousCheckpoint, startSpongeBlob, parentCheckpoint){
         this.index = index;
-        this.globalVariables = globalVariables;
-        this.newL1ToL2Messages = newL1ToL2Messages;
-        this.l1ToL2MessageSubtreeSiblingPath = l1ToL2MessageSubtreeSiblingPath;
-        this.l1ToL2MessageTreeSnapshotAfterInsertion = l1ToL2MessageTreeSnapshotAfterInsertion;
-        this.lastArchiveSnapshot = lastArchiveSnapshot;
-        this.newArchiveSiblingPath = newArchiveSiblingPath;
-        this.previousBlockHeader = previousBlockHeader;
-        this.parentEpoch = parentEpoch;
-        this.baseOrMergeProvingOutputs = new UnbalancedTreeStore(0);
-        this.blockRootRollupStarted = false;
-        this.txs = [];
-        this.baseParityProvingOutputs = Array.from({
+        this.blockNumber = blockNumber;
+        this.totalNumTxs = totalNumTxs;
+        this.constants = constants;
+        this.timestamp = timestamp;
+        this.lastArchiveTreeSnapshot = lastArchiveTreeSnapshot;
+        this.lastArchiveSiblingPath = lastArchiveSiblingPath;
+        this.lastL1ToL2MessageTreeSnapshot = lastL1ToL2MessageTreeSnapshot;
+        this.lastL1ToL2MessageSubtreeRootSiblingPath = lastL1ToL2MessageSubtreeRootSiblingPath;
+        this.newL1ToL2MessageTreeSnapshot = newL1ToL2MessageTreeSnapshot;
+        this.headerOfLastBlockInPreviousCheckpoint = headerOfLastBlockInPreviousCheckpoint;
+        this.startSpongeBlob = startSpongeBlob;
+        this.parentCheckpoint = parentCheckpoint;
+        this.baseOrMergeProofs = new UnbalancedTreeStore(0);
+        this.baseParityProofs = Array.from({
             length: NUM_BASE_PARITY_PER_ROOT_PARITY
         }).map((_)=>undefined);
-        this.totalNumTxs = 0;
-    }
-    get blockNumber() {
-        return this.globalVariables.blockNumber.toNumber();
-    }
-    startNewBlock(numTxs, numBlobFields) {
-        if (this.spongeBlobState) {
-            throw new Error(`Block ${this.blockNumber} already initalised.`);
+        this.txs = [];
+        this.isFirstBlock = index === 0;
+        if (!totalNumTxs && !this.isFirstBlock) {
+            throw new Error(`Cannot create a block with 0 txs, unless it's the first block.`);
         }
-        this.baseOrMergeProvingOutputs = new UnbalancedTreeStore(numTxs);
-        // Initialise the sponge which will eventually absorb all tx effects to be added to the blob.
-        // Like l1 to l2 messages, we need to know beforehand how many effects will be absorbed.
-        this.spongeBlobState = SpongeBlob.init(numBlobFields);
-        this.totalNumTxs = numTxs;
+        this.baseOrMergeProofs = new UnbalancedTreeStore(totalNumTxs);
+    }
+    get epochNumber() {
+        return this.parentCheckpoint.epochNumber;
     }
     // Adds a transaction to the proving state, returns it's index
     addNewTx(tx) {
-        if (!this.spongeBlobState) {
-            throw new Error(`Invalid block proving state, call startNewBlock before adding transactions.`);
+        if (!this.isAcceptingTxs()) {
+            throw new Error(`Cannot add more txs to block ${this.blockNumber}.`);
         }
         const txIndex = this.txs.length;
         this.txs[txIndex] = tx;
         return txIndex;
     }
+    isAcceptingTxs() {
+        return this.txs.length < this.totalNumTxs;
+    }
+    getProcessedTxs() {
+        return this.txs.map((t)=>t.processedTx);
+    }
+    tryStartProvingBase(txIndex) {
+        if (this.baseOrMergeProofs.getLeaf(txIndex)?.isProving) {
+            return false;
+        } else {
+            this.baseOrMergeProofs.setLeaf(txIndex, {
+                isProving: true
+            });
+            return true;
+        }
+    }
     setBaseRollupProof(txIndex, provingOutput) {
-        return this.baseOrMergeProvingOutputs.setLeaf(txIndex, provingOutput);
+        return this.baseOrMergeProofs.setLeaf(txIndex, {
+            provingOutput
+        });
+    }
+    tryStartProvingMerge(location) {
+        if (this.baseOrMergeProofs.getNode(location)?.isProving) {
+            return false;
+        } else {
+            this.baseOrMergeProofs.setNode(location, {
+                isProving: true
+            });
+            return true;
+        }
     }
     setMergeRollupProof(location, provingOutput) {
-        this.baseOrMergeProvingOutputs.setNode(location, provingOutput);
+        this.baseOrMergeProofs.setNode(location, {
+            provingOutput
+        });
+    }
+    tryStartProvingBaseParity(index) {
+        if (this.baseParityProofs[index]?.isProving) {
+            return false;
+        } else {
+            this.baseParityProofs[index] = {
+                isProving: true
+            };
+            return true;
+        }
     }
     // Stores a set of root parity inputs at the given index
     setBaseParityProof(index, provingOutput) {
         if (index >= NUM_BASE_PARITY_PER_ROOT_PARITY) {
             throw new Error(`Unable to set a base parity proofs at index ${index}. Expected at most ${NUM_BASE_PARITY_PER_ROOT_PARITY} proofs.`);
         }
-        this.baseParityProvingOutputs[index] = provingOutput;
+        this.baseParityProofs[index] = {
+            provingOutput
+        };
+    }
+    tryStartProvingRootParity() {
+        if (this.rootParityProof?.isProving) {
+            return false;
+        } else {
+            this.rootParityProof = {
+                isProving: true
+            };
+            return true;
+        }
     }
     setRootParityProof(provingOutput) {
-        this.rootParityProvingOutput = provingOutput;
+        this.rootParityProof = {
+            provingOutput
+        };
+    }
+    tryStartProvingBlockRoot() {
+        if (this.blockRootProof?.isProving) {
+            return false;
+        } else {
+            this.blockRootProof = {
+                isProving: true
+            };
+            return true;
+        }
     }
     setBlockRootRollupProof(provingOutput) {
-        this.blockRootProvingOutput = provingOutput;
+        this.blockRootProof = {
+            provingOutput
+        };
+        return this.parentCheckpoint.setBlockRootRollupProof(this.index, provingOutput);
+    }
+    getBlockRootRollupOutput() {
+        return this.blockRootProof?.provingOutput?.inputs;
+    }
+    async buildBlockHeader() {
+        if (this.isAcceptingTxs()) {
+            throw new Error('All txs must be added to the block before building the header.');
+        }
+        if (!this.endState) {
+            throw new Error('Call `setEndState` first.');
+        }
+        if (!this.endSpongeBlob) {
+            throw new Error('Call `setEndSpongeBlob` first.');
+        }
+        const endSpongeBlob = this.endSpongeBlob.clone();
+        const endSpongeBlobHash = await endSpongeBlob.squeeze();
+        this.builtBlockHeader = new BlockHeader(this.lastArchiveTreeSnapshot, this.endState, endSpongeBlobHash, this.#getGlobalVariables(), this.#getTotalFees(), new Fr(this.#getTotalManaUsed()));
+        return this.builtBlockHeader;
     }
-    // Returns the complete set of transaction proving state objects
-    get allTxs() {
-        return this.txs;
+    getBuiltBlockHeader() {
+        return this.builtBlockHeader;
     }
-    /** Returns the block number as an epoch number. Used for prioritizing proof requests. */ get epochNumber() {
-        return this.parentEpoch.epochNumber;
+    setBuiltArchive(archive) {
+        this.builtArchive = archive;
+    }
+    getBuiltArchive() {
+        return this.builtArchive;
+    }
+    getStartSpongeBlob() {
+        return this.startSpongeBlob;
+    }
+    setEndSpongeBlob(endSpongeBlob) {
+        this.endSpongeBlob = endSpongeBlob;
+    }
+    getEndSpongeBlob() {
+        return this.endSpongeBlob;
+    }
+    setEndState(endState) {
+        this.endState = endState;
+    }
+    hasEndState() {
+        return !!this.endState;
+    }
+    getBlockEndBlobFields() {
+        return encodeBlockEndBlobData(this.getBlockEndBlobData());
+    }
+    getBlockEndBlobData() {
+        if (!this.endState) {
+            throw new Error('Call `setEndState` first.');
+        }
+        const partial = this.endState.partial;
+        return {
+            blockEndMarker: {
+                numTxs: this.totalNumTxs,
+                timestamp: this.timestamp,
+                blockNumber: this.blockNumber
+            },
+            blockEndStateField: {
+                l1ToL2MessageNextAvailableLeafIndex: this.newL1ToL2MessageTreeSnapshot.nextAvailableLeafIndex,
+                noteHashNextAvailableLeafIndex: partial.noteHashTree.nextAvailableLeafIndex,
+                nullifierNextAvailableLeafIndex: partial.nullifierTree.nextAvailableLeafIndex,
+                publicDataNextAvailableLeafIndex: partial.publicDataTree.nextAvailableLeafIndex,
+                totalManaUsed: this.#getTotalManaUsed()
+            },
+            lastArchiveRoot: this.lastArchiveTreeSnapshot.root,
+            noteHashRoot: partial.noteHashTree.root,
+            nullifierRoot: partial.nullifierTree.root,
+            publicDataRoot: partial.publicDataTree.root,
+            l1ToL2MessageRoot: this.isFirstBlock ? this.newL1ToL2MessageTreeSnapshot.root : undefined
+        };
+    }
+    getBlockBlobData() {
+        return {
+            ...this.getBlockEndBlobData(),
+            txs: this.getTxEffects().map((t)=>t.toTxBlobData())
+        };
+    }
+    getTxEffects() {
+        return this.txs.map((t)=>t.processedTx.txEffect);
     }
     getParentLocation(location) {
-        return this.baseOrMergeProvingOutputs.getParentLocation(location);
+        return this.baseOrMergeProofs.getParentLocation(location);
     }
     getMergeRollupInputs(mergeLocation) {
-        const [left, right] = this.baseOrMergeProvingOutputs.getChildren(mergeLocation);
+        const [left, right] = this.baseOrMergeProofs.getChildren(mergeLocation).map((c)=>c?.provingOutput);
         if (!left || !right) {
-            throw new Error('At lease one child is not ready.');
+            throw new Error('At least one child is not ready for the merge rollup.');
         }
-        return new MergeRollupInputs([
-            this.#getPreviousRollupData(left),
-            this.#getPreviousRollupData(right)
+        return new TxMergeRollupPrivateInputs([
+            toProofData(left),
+            toProofData(right)
         ]);
     }
-    async getBlockRootRollupTypeAndInputs(proverId) {
-        if (!this.rootParityProvingOutput) {
-            throw new Error('Root parity is not ready.');
-        }
-        const proofs = this.#getChildProofsForBlockRoot();
-        const nonEmptyProofs = proofs.filter((p)=>!!p);
-        if (proofs.length !== nonEmptyProofs.length) {
-            throw new Error('At lease one child is not ready for the block root.');
+    getBlockRootRollupTypeAndInputs() {
+        const provingOutputs = this.#getChildProvingOutputsForBlockRoot();
+        if (!provingOutputs.every((p)=>!!p)) {
+            throw new Error('At least one child is not ready for the block root rollup.');
         }
-        const data = this.#getBlockRootRollupData(proverId);
-        if (this.totalNumTxs === 0) {
-            const constants = ConstantRollupData.from({
-                lastArchive: this.lastArchiveSnapshot,
-                globalVariables: this.globalVariables,
-                vkTreeRoot: getVKTreeRoot(),
-                protocolContractTreeRoot
-            });
-            return {
-                rollupType: 'empty-block-root-rollup',
-                inputs: EmptyBlockRootRollupInputs.from({
-                    data,
-                    constants,
-                    isPadding: false
-                })
-            };
+        const previousRollups = provingOutputs.map((p)=>toProofData(p));
+        if (this.isFirstBlock) {
+            return this.#getFirstBlockRootRollupTypeAndInputs(previousRollups);
         }
-        const previousRollupData = await Promise.all(nonEmptyProofs.map((p)=>this.#getPreviousRollupData(p)));
-        const blobData = await this.#getBlockRootRollupBlobData();
-        if (previousRollupData.length === 1) {
+        const [leftRollup, rightRollup] = previousRollups;
+        if (!rightRollup) {
             return {
-                rollupType: 'single-tx-block-root-rollup',
-                inputs: new SingleTxBlockRootRollupInputs(previousRollupData, data, blobData)
+                rollupType: 'rollup-block-root-single-tx',
+                inputs: new BlockRootSingleTxRollupPrivateInputs(leftRollup, this.lastArchiveSiblingPath)
             };
         } else {
             return {
-                rollupType: 'block-root-rollup',
-                inputs: new BlockRootRollupInputs(previousRollupData, data, blobData)
+                rollupType: 'rollup-block-root',
+                inputs: new BlockRootRollupPrivateInputs([
+                    leftRollup,
+                    rightRollup
+                ], this.lastArchiveSiblingPath)
             };
         }
     }
-    async getPaddingBlockRootInputs(proverId) {
-        if (!this.rootParityProvingOutput) {
+    #getFirstBlockRootRollupTypeAndInputs([leftRollup, rightRollup]) {
+        if (!this.rootParityProof?.provingOutput) {
             throw new Error('Root parity is not ready.');
         }
-        // Use the new block header and archive of the current block as the previous header and archiver of the next padding block.
-        const newBlockHeader = await this.buildHeaderFromProvingOutputs();
-        const newArchive = this.blockRootProvingOutput.inputs.newArchive;
-        const data = BlockRootRollupData.from({
-            l1ToL2Roots: this.#getRootParityData(this.rootParityProvingOutput),
-            l1ToL2MessageSubtreeSiblingPath: this.l1ToL2MessageSubtreeSiblingPath,
-            newArchiveSiblingPath: this.newArchiveSiblingPath,
-            previousBlockHeader: newBlockHeader,
-            proverId
-        });
-        const constants = ConstantRollupData.from({
-            lastArchive: newArchive,
-            globalVariables: this.globalVariables,
-            vkTreeRoot: getVKTreeRoot(),
-            protocolContractTreeRoot
-        });
-        return EmptyBlockRootRollupInputs.from({
-            data,
-            constants,
-            isPadding: true
-        });
+        const l1ToL2Roots = toProofData(this.rootParityProof.provingOutput);
+        if (!leftRollup) {
+            return {
+                rollupType: 'rollup-block-root-first-empty-tx',
+                inputs: new BlockRootEmptyTxFirstRollupPrivateInputs(l1ToL2Roots, this.lastArchiveTreeSnapshot, this.headerOfLastBlockInPreviousCheckpoint.state, this.constants, this.timestamp, this.lastL1ToL2MessageSubtreeRootSiblingPath, this.lastArchiveSiblingPath)
+            };
+        } else if (!rightRollup) {
+            return {
+                rollupType: 'rollup-block-root-first-single-tx',
+                inputs: new BlockRootSingleTxFirstRollupPrivateInputs(l1ToL2Roots, leftRollup, this.lastL1ToL2MessageTreeSnapshot, this.lastL1ToL2MessageSubtreeRootSiblingPath, this.lastArchiveSiblingPath)
+            };
+        } else {
+            return {
+                rollupType: 'rollup-block-root-first',
+                inputs: new BlockRootFirstRollupPrivateInputs(l1ToL2Roots, [
+                    leftRollup,
+                    rightRollup
+                ], this.lastL1ToL2MessageTreeSnapshot, this.lastL1ToL2MessageSubtreeRootSiblingPath, this.lastArchiveSiblingPath)
+            };
+        }
     }
-    getRootParityInputs() {
-        if (!this.baseParityProvingOutputs.every((p)=>!!p)) {
+    getParityRootInputs() {
+        const baseParityProvingOutputs = this.baseParityProofs.filter((p)=>!!p?.provingOutput).map((p)=>p.provingOutput);
+        if (baseParityProvingOutputs.length !== this.baseParityProofs.length) {
             throw new Error('At lease one base parity is not ready.');
         }
-        const children = this.baseParityProvingOutputs.map((p)=>this.#getRootParityData(p));
-        return new RootParityInputs(children);
+        const children = baseParityProvingOutputs.map((p)=>toProofData(p));
+        return new ParityRootPrivateInputs(assertLength(children, NUM_BASE_PARITY_PER_ROOT_PARITY));
     }
     // Returns a specific transaction proving state
     getTxProvingState(txIndex) {
         return this.txs[txIndex];
     }
-    async buildHeaderFromProvingOutputs(logger) {
-        const previousRollupData = this.totalNumTxs === 0 ? [] : await Promise.all(this.#getChildProofsForBlockRoot().map((p)=>this.#getPreviousRollupData(p)));
-        let endPartialState = this.previousBlockHeader.state.partial;
-        if (this.totalNumTxs !== 0) {
-            const previousRollupData = this.#getChildProofsForBlockRoot();
-            const lastRollup = previousRollupData[previousRollupData.length - 1];
-            if (!lastRollup) {
-                throw new Error('End state of the block is not available. Last rollup is not ready yet.');
-            }
-            endPartialState = lastRollup.inputs.end;
+    async buildHeaderFromProvingOutputs() {
+        if (!this.blockRootProof?.provingOutput) {
+            throw new Error('Block root rollup is not ready.');
         }
-        const endState = new StateReference(this.l1ToL2MessageTreeSnapshotAfterInsertion, endPartialState);
-        return buildHeaderFromCircuitOutputs(previousRollupData.map((d)=>d.baseOrMergeRollupPublicInputs), this.rootParityProvingOutput.inputs, this.blockRootProvingOutput.inputs, endState, logger);
+        return await buildHeaderFromCircuitOutputs(this.blockRootProof.provingOutput.inputs);
     }
     isReadyForMergeRollup(location) {
-        return this.baseOrMergeProvingOutputs.getSibling(location) !== undefined;
+        return !!this.baseOrMergeProofs.getSibling(location)?.provingOutput;
     }
     // Returns true if we have sufficient inputs to execute the block root rollup
     isReadyForBlockRootRollup() {
-        const childProofs = this.#getChildProofsForBlockRoot();
-        return this.block !== undefined && this.rootParityProvingOutput !== undefined && childProofs.every((p)=>!!p);
+        const childProofs = this.#getChildProvingOutputsForBlockRoot();
+        return (!this.isFirstBlock || !!this.rootParityProof?.provingOutput) && childProofs.every((p)=>!!p);
     }
     // Returns true if we have sufficient root parity inputs to execute the root parity circuit
     isReadyForRootParity() {
-        return this.baseParityProvingOutputs.every((p)=>!!p);
+        return this.baseParityProofs.every((p)=>!!p?.provingOutput);
     }
     isComplete() {
-        return !!this.blockRootProvingOutput;
+        return !!this.blockRootProof;
     }
-    // Returns whether the proving state is still valid
     verifyState() {
-        return this.parentEpoch.verifyState();
+        return this.parentCheckpoint.verifyState();
+    }
+    getError() {
+        return this.error;
     }
     reject(reason) {
         this.error = reason;
-        this.parentEpoch.reject(reason);
-    }
-    #getBlockRootRollupData(proverId) {
-        return BlockRootRollupData.from({
-            l1ToL2Roots: this.#getRootParityData(this.rootParityProvingOutput),
-            l1ToL2MessageSubtreeSiblingPath: this.l1ToL2MessageSubtreeSiblingPath,
-            newArchiveSiblingPath: this.newArchiveSiblingPath,
-            previousBlockHeader: this.previousBlockHeader,
-            proverId
-        });
+        this.parentCheckpoint.reject(reason);
     }
-    async #getBlockRootRollupBlobData() {
-        const txEffects = this.txs.map((txProvingState)=>txProvingState.processedTx.txEffect);
-        const { blobFields, blobCommitments, blobsHash } = await buildBlobHints(txEffects);
-        return BlockRootRollupBlobData.from({
-            blobFields: padArrayEnd(blobFields, Fr.ZERO, FIELDS_PER_BLOB * BLOBS_PER_BLOCK),
-            blobCommitments: padArrayEnd(blobCommitments, [
-                Fr.ZERO,
-                Fr.ZERO
-            ], BLOBS_PER_BLOCK),
-            blobsHash
-        });
-    }
-    #getChildProofsForBlockRoot() {
+    #getChildProvingOutputsForBlockRoot() {
         if (this.totalNumTxs === 0) {
             return [];
         }
@@ -256,14 +353,29 @@ import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-
         };
         // If there's only 1 tx, its base rollup proof will be stored at the root.
         return this.totalNumTxs === 1 ? [
-            this.baseOrMergeProvingOutputs.getNode(rootLocation)
-        ] : this.baseOrMergeProvingOutputs.getChildren(rootLocation);
+            this.baseOrMergeProofs.getNode(rootLocation)?.provingOutput
+        ] : this.baseOrMergeProofs.getChildren(rootLocation).map((c)=>c?.provingOutput);
+    }
+    #getGlobalVariables() {
+        if (this.txs.length) {
+            return this.txs[0].processedTx.globalVariables;
+        }
+        const constants = this.constants;
+        return GlobalVariables.from({
+            chainId: constants.chainId,
+            version: constants.version,
+            blockNumber: this.blockNumber,
+            slotNumber: constants.slotNumber,
+            timestamp: this.timestamp,
+            coinbase: constants.coinbase,
+            feeRecipient: constants.feeRecipient,
+            gasFees: constants.gasFees
+        });
     }
-    #getPreviousRollupData({ inputs, proof, verificationKey }) {
-        const leafIndex = getVKIndex(verificationKey.keyAsFields);
-        return new PreviousRollupData(inputs, proof, verificationKey.keyAsFields, new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), getVKSiblingPath(leafIndex)));
+    #getTotalFees() {
+        return this.txs.reduce((acc, tx)=>acc.add(tx.processedTx.txEffect.transactionFee), Fr.ZERO);
     }
-    #getRootParityData({ inputs, proof, verificationKey }) {
-        return new RootParityInput(proof, verificationKey.keyAsFields, getVKSiblingPath(getVKIndex(verificationKey)), inputs);
+    #getTotalManaUsed() {
+        return this.txs.reduce((acc, tx)=>acc + BigInt(tx.processedTx.gasUsed.billedGas.l2Gas), 0n);
     }
 }