@aztec/prover-client 0.0.0-test.1 → 0.0.1-fake-ceab37513c

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

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

package/dest/orchestrator/block-building-helpers.js

@@ -2,26 +2,25 @@ import { Blob } from '@aztec/blob-lib';
 import { ARCHIVE_HEIGHT, MAX_CONTRACT_CLASS_LOGS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NOTE_HASH_SUBTREE_HEIGHT, NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH, NULLIFIER_SUBTREE_HEIGHT, NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH, NULLIFIER_TREE_HEIGHT, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, PUBLIC_DATA_TREE_HEIGHT } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { sha256Trunc } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
-import { assertLength, serializeToBuffer, toFriendlyJSON } from '@aztec/foundation/serialize';
-import { MembershipWitness, MerkleTreeCalculator, computeUnbalancedMerkleRoot } from '@aztec/foundation/trees';
+import { sha256ToField, sha256Trunc } from '@aztec/foundation/crypto';
+import { BLS12Point, Fr } from '@aztec/foundation/fields';
+import { assertLength, toFriendlyJSON } from '@aztec/foundation/serialize';
+import { MembershipWitness, MerkleTreeCalculator, computeUnbalancedMerkleTreeRoot } from '@aztec/foundation/trees';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
 import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
 import { PublicDataHint } from '@aztec/stdlib/avm';
 import { Body } from '@aztec/stdlib/block';
-import { ContractClassLog } from '@aztec/stdlib/logs';
-import { ConstantRollupData, PrivateBaseRollupHints, PrivateBaseStateDiffHints, PublicBaseRollupHints } from '@aztec/stdlib/rollup';
+import { ContractClassLogFields } from '@aztec/stdlib/logs';
+import { BlockConstantData, PrivateBaseRollupHints, PrivateBaseStateDiffHints, PublicBaseRollupHints } from '@aztec/stdlib/rollup';
 import { AppendOnlyTreeSnapshot, MerkleTreeId, NullifierLeafPreimage, PublicDataTreeLeaf, PublicDataTreeLeafPreimage, getTreeHeight } from '@aztec/stdlib/trees';
-import { BlockHeader, ContentCommitment, PartialStateReference, StateReference, TxEffect } from '@aztec/stdlib/tx';
+import { BlockHeader, ContentCommitment, PartialStateReference, StateReference } from '@aztec/stdlib/tx';
 import { Attributes, runInSpan } from '@aztec/telemetry-client';
-import { inspect } from 'util';
 // Builds the hints for base rollup. Updating the contract, nullifier, and data trees in the process.
-export const buildBaseRollupHints = runInSpan('BlockBuilderHelpers', 'buildBaseRollupHints', async (span, tx, globalVariables, db, startSpongeBlob)=>{
+export const insertSideEffectsAndBuildBaseRollupHints = runInSpan('BlockBuilderHelpers', 'buildBaseRollupHints', async (span, tx, globalVariables, newL1ToL2MessageTreeSnapshot, db, startSpongeBlob)=>{
     span.setAttribute(Attributes.TX_HASH, tx.hash.toString());
     // Get trees info before any changes hit
-    const constants = await getConstantRollupData(globalVariables, db);
+    const lastArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
     const start = new PartialStateReference(await getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE, db), await getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE, db), await getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE, db));
     // Get the subtree sibling paths for the circuit
     const noteHashSubtreeSiblingPathArray = await getSubtreeSiblingPath(MerkleTreeId.NOTE_HASH_TREE, NOTE_HASH_SUBTREE_HEIGHT, db);
@@ -48,15 +47,15 @@ export const buildBaseRollupHints = runInSpan('BlockBuilderHelpers', 'buildBaseR
     // Append new data to startSpongeBlob
     const inputSpongeBlob = startSpongeBlob.clone();
     await startSpongeBlob.absorb(tx.txEffect.toBlobFields());
-    const contractClassLogsPreimages = makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, (i)=>tx.txEffect.contractClassLogs[i]?.toUnsiloed() || ContractClassLog.empty());
+    const contractClassLogsFields = makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, (i)=>tx.txEffect.contractClassLogs[i]?.fields || ContractClassLogFields.empty());
     if (tx.avmProvingRequest) {
-        const blockHash = await tx.constants.historicalHeader.hash();
+        const blockHash = await tx.data.constants.historicalHeader.hash();
         const archiveRootMembershipWitness = await getMembershipWitnessFor(blockHash, MerkleTreeId.ARCHIVE, ARCHIVE_HEIGHT, db);
         return PublicBaseRollupHints.from({
             startSpongeBlob: inputSpongeBlob,
+            lastArchive,
             archiveRootMembershipWitness,
-            contractClassLogsPreimages,
-            constants
+            contractClassLogsFields
         });
     } else {
         if (txPublicDataUpdateRequestInfo.lowPublicDataWritesMembershipWitnesses.length > 1 || txPublicDataUpdateRequestInfo.lowPublicDataWritesPreimages.length > 1 || txPublicDataUpdateRequestInfo.publicDataWritesSiblingPaths.length > 1) {
@@ -76,15 +75,22 @@ export const buildBaseRollupHints = runInSpan('BlockBuilderHelpers', 'buildBaseR
             feeWriteLowLeafMembershipWitness,
             feeWriteSiblingPath
         });
-        const blockHash = await tx.constants.historicalHeader.hash();
+        const blockHash = await tx.data.constants.historicalHeader.hash();
         const archiveRootMembershipWitness = await getMembershipWitnessFor(blockHash, MerkleTreeId.ARCHIVE, ARCHIVE_HEIGHT, db);
+        const constants = BlockConstantData.from({
+            lastArchive,
+            newL1ToL2: newL1ToL2MessageTreeSnapshot,
+            vkTreeRoot: getVKTreeRoot(),
+            protocolContractTreeRoot,
+            globalVariables
+        });
         return PrivateBaseRollupHints.from({
             start,
             startSpongeBlob: inputSpongeBlob,
             stateDiffHints,
             feePayerFeeJuiceBalanceReadHint,
             archiveRootMembershipWitness,
-            contractClassLogsPreimages,
+            contractClassLogsFields,
             constants
         });
     }
@@ -100,14 +106,19 @@ export async function getPublicDataHint(db, leafSlot) {
     if (!leafPreimage) {
         throw new Error(`Cannot find the leaf preimage for public data tree at index ${index}.`);
     }
-    const exists = leafPreimage.slot.toBigInt() === leafSlot;
-    const value = exists ? leafPreimage.value : Fr.ZERO;
+    const exists = leafPreimage.leaf.slot.toBigInt() === leafSlot;
+    const value = exists ? leafPreimage.leaf.value : Fr.ZERO;
     return new PublicDataHint(new Fr(leafSlot), value, membershipWitness, leafPreimage);
 }
 export const buildBlobHints = runInSpan('BlockBuilderHelpers', 'buildBlobHints', async (_span, txEffects)=>{
     const blobFields = txEffects.flatMap((tx)=>tx.toBlobFields());
-    const blobs = await Blob.getBlobs(blobFields);
-    const blobCommitments = blobs.map((b)=>b.commitmentToFields());
+    const blobs = await Blob.getBlobsPerBlock(blobFields);
+    // TODO(#13430): The blobsHash is confusingly similar to blobCommitmentsHash, calculated from below blobCommitments:
+    // - blobsHash := sha256([blobhash_0, ..., blobhash_m]) = a hash of all blob hashes in a block with m+1 blobs inserted into the header, exists so a user can cross check blobs.
+    // - blobCommitmentsHash := sha256( ...sha256(sha256(C_0), C_1) ... C_n) = iteratively calculated hash of all blob commitments in an epoch with n+1 blobs (see calculateBlobCommitmentsHash()),
+    //   exists so we can validate injected commitments to the rollup circuits correspond to the correct real blobs.
+    // We may be able to combine these values e.g. blobCommitmentsHash := sha256( ...sha256(sha256(blobshash_0), blobshash_1) ... blobshash_l) for an epoch with l+1 blocks.
+    const blobCommitments = blobs.map((b)=>BLS12Point.decompress(b.commitment));
     const blobsHash = new Fr(getBlobsHashFromBlobs(blobs));
     return {
         blobFields,
@@ -116,45 +127,37 @@ export const buildBlobHints = runInSpan('BlockBuilderHelpers', 'buildBlobHints',
         blobsHash
     };
 });
-export const buildHeaderFromCircuitOutputs = runInSpan('BlockBuilderHelpers', 'buildHeaderFromCircuitOutputs', async (_span, previousRollupData, parityPublicInputs, rootRollupOutputs, endState, logger)=>{
+export const accumulateBlobs = runInSpan('BlockBuilderHelpers', 'accumulateBlobs', async (_span, txs, startBlobAccumulator)=>{
+    const blobFields = txs.flatMap((tx)=>tx.txEffect.toBlobFields());
+    const blobs = await Blob.getBlobsPerBlock(blobFields);
+    const endBlobAccumulator = startBlobAccumulator.accumulateBlobs(blobs);
+    return endBlobAccumulator;
+});
+export const buildHeaderFromCircuitOutputs = runInSpan('BlockBuilderHelpers', 'buildHeaderFromCircuitOutputs', (_span, previousRollupData, parityPublicInputs, rootRollupOutputs, blobsHash, endState)=>{
     if (previousRollupData.length > 2) {
         throw new Error(`There can't be more than 2 previous rollups. Received ${previousRollupData.length}.`);
     }
-    const blobsHash = rootRollupOutputs.blobPublicInputs[0].getBlobsHash();
-    const numTxs = previousRollupData.reduce((sum, d)=>sum + d.numTxs, 0);
-    const outHash = previousRollupData.length === 0 ? Fr.ZERO.toBuffer() : previousRollupData.length === 1 ? previousRollupData[0].outHash.toBuffer() : sha256Trunc(Buffer.concat([
-        previousRollupData[0].outHash.toBuffer(),
-        previousRollupData[1].outHash.toBuffer()
-    ]));
-    const contentCommitment = new ContentCommitment(new Fr(numTxs), blobsHash, parityPublicInputs.shaRoot.toBuffer(), outHash);
+    const outHash = previousRollupData.length === 0 ? Fr.ZERO : previousRollupData.length === 1 ? previousRollupData[0].outHash : sha256ToField([
+        previousRollupData[0].outHash,
+        previousRollupData[1].outHash
+    ]);
+    const contentCommitment = new ContentCommitment(blobsHash, parityPublicInputs.shaRoot, outHash);
     const accumulatedFees = previousRollupData.reduce((sum, d)=>sum.add(d.accumulatedFees), Fr.ZERO);
     const accumulatedManaUsed = previousRollupData.reduce((sum, d)=>sum.add(d.accumulatedManaUsed), Fr.ZERO);
-    const header = new BlockHeader(rootRollupOutputs.previousArchive, contentCommitment, endState, rootRollupOutputs.endGlobalVariables, accumulatedFees, accumulatedManaUsed);
-    if (!(await header.hash()).equals(rootRollupOutputs.endBlockHash)) {
-        logger?.error(`Block header mismatch when building header from circuit outputs.` + `\n\nHeader: ${inspect(header)}` + `\n\nCircuit: ${toFriendlyJSON(rootRollupOutputs)}`);
-        throw new Error(`Block header mismatch when building from circuit outputs`);
-    }
-    return header;
+    return new BlockHeader(rootRollupOutputs.previousArchive, contentCommitment, endState, rootRollupOutputs.endGlobalVariables, accumulatedFees, accumulatedManaUsed);
 });
 export const buildHeaderAndBodyFromTxs = runInSpan('BlockBuilderHelpers', 'buildHeaderAndBodyFromTxs', async (span, txs, globalVariables, l1ToL2Messages, db)=>{
-    span.setAttribute(Attributes.BLOCK_NUMBER, globalVariables.blockNumber.toNumber());
+    span.setAttribute(Attributes.BLOCK_NUMBER, globalVariables.blockNumber);
     const stateReference = new StateReference(await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db), new PartialStateReference(await getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE, db), await getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE, db), await getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE, db)));
     const previousArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
     const txEffects = txs.map((tx)=>tx.txEffect);
     const body = new Body(txEffects);
-    const numTxs = body.txEffects.length;
-    const outHash = numTxs === 0 ? Fr.ZERO.toBuffer() : numTxs === 1 ? body.txEffects[0].txOutHash() : computeUnbalancedMerkleRoot(body.txEffects.map((tx)=>tx.txOutHash()), TxEffect.empty().txOutHash());
-    l1ToL2Messages = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-    const hasher = (left, right)=>Promise.resolve(sha256Trunc(Buffer.concat([
-            left,
-            right
-        ])));
-    const parityHeight = Math.ceil(Math.log2(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
-    const parityCalculator = await MerkleTreeCalculator.create(parityHeight, Fr.ZERO.toBuffer(), hasher);
-    const parityShaRoot = await parityCalculator.computeTreeRoot(l1ToL2Messages.map((msg)=>msg.toBuffer()));
-    const blobsHash = getBlobsHashFromBlobs(await Blob.getBlobs(body.toBlobFields()));
-    const contentCommitment = new ContentCommitment(new Fr(numTxs), blobsHash, parityShaRoot, outHash);
-    const fees = body.txEffects.reduce((acc, tx)=>acc.add(tx.transactionFee), Fr.ZERO);
+    const txOutHashes = txEffects.map((tx)=>tx.txOutHash());
+    const outHash = txOutHashes.length === 0 ? Fr.ZERO : new Fr(computeUnbalancedMerkleTreeRoot(txOutHashes));
+    const parityShaRoot = await computeInHashFromL1ToL2Messages(l1ToL2Messages);
+    const blobsHash = getBlobsHashFromBlobs(await Blob.getBlobsPerBlock(body.toBlobFields()));
+    const contentCommitment = new ContentCommitment(blobsHash, parityShaRoot, outHash);
+    const fees = txEffects.reduce((acc, tx)=>acc.add(tx.transactionFee), Fr.ZERO);
     const manaUsed = txs.reduce((acc, tx)=>acc.add(new Fr(tx.gasUsed.billedGas.l2Gas)), Fr.ZERO);
     const header = new BlockHeader(previousArchive, contentCommitment, stateReference, globalVariables, fees, manaUsed);
     return {
@@ -162,11 +165,28 @@ export const buildHeaderAndBodyFromTxs = runInSpan('BlockBuilderHelpers', 'build
         body
     };
 });
+/** Computes the inHash for a block's ContentCommitment given its l1 to l2 messages. */ export async function computeInHashFromL1ToL2Messages(unpaddedL1ToL2Messages) {
+    const l1ToL2Messages = padArrayEnd(unpaddedL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+    const hasher = (left, right)=>Promise.resolve(sha256Trunc(Buffer.concat([
+            left,
+            right
+        ])));
+    const parityHeight = Math.ceil(Math.log2(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
+    const parityCalculator = await MerkleTreeCalculator.create(parityHeight, Fr.ZERO.toBuffer(), hasher);
+    return new Fr(await parityCalculator.computeTreeRoot(l1ToL2Messages.map((msg)=>msg.toBuffer())));
+}
 export function getBlobsHashFromBlobs(inputs) {
-    const blobHashes = serializeToBuffer(inputs.map((b)=>b.getEthVersionedBlobHash()));
-    return sha256Trunc(serializeToBuffer(blobHashes));
+    return sha256ToField(inputs.map((b)=>b.getEthVersionedBlobHash()));
+}
+// Note: tested against the constant values in block_root/empty_block_root_rollup_inputs.nr, set by block_building_helpers.test.ts.
+// Having this separate fn hopefully makes it clear how we treat empty blocks and their blobs, and won't break if we decide to change how
+// getBlobsPerBlock() works on empty input.
+export async function getEmptyBlockBlobsHash() {
+    const blobHash = (await Blob.getBlobsPerBlock([])).map((b)=>b.getEthVersionedBlobHash());
+    return sha256ToField(blobHash);
 }
 // Validate that the roots of all local trees match the output of the root circuit simulation
+// TODO: does this get called?
 export async function validateBlockRootOutput(blockRootOutput, blockHeader, db) {
     await Promise.all([
         validateState(blockHeader.state, db),
@@ -191,19 +211,16 @@ export const validateState = runInSpan('BlockBuilderHelpers', 'validateState', a
     validatePartialState(state.partial, snapshots);
     validateSimulatedTree(await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db), state.l1ToL2MessageTree, 'L1ToL2MessageTree');
 });
+export async function getLastSiblingPath(treeId, db) {
+    const { size } = await db.getTreeInfo(treeId);
+    const path = await db.getSiblingPath(treeId, size - 1n);
+    return padArrayEnd(path.toFields(), Fr.ZERO, getTreeHeight(treeId));
+}
 export async function getRootTreeSiblingPath(treeId, db) {
     const { size } = await db.getTreeInfo(treeId);
     const path = await db.getSiblingPath(treeId, size);
     return padArrayEnd(path.toFields(), Fr.ZERO, getTreeHeight(treeId));
 }
-export const getConstantRollupData = runInSpan('BlockBuilderHelpers', 'getConstantRollupData', async (_span, globalVariables, db)=>{
-    return ConstantRollupData.from({
-        vkTreeRoot: getVKTreeRoot(),
-        protocolContractTreeRoot,
-        lastArchive: await getTreeSnapshot(MerkleTreeId.ARCHIVE, db),
-        globalVariables
-    });
-});
 export async function getTreeSnapshot(id, db) {
     const treeInfo = await db.getTreeInfo(id);
     return new AppendOnlyTreeSnapshot(Fr.fromBuffer(treeInfo.root), Number(treeInfo.size));
@@ -269,17 +286,17 @@ function validateSimulatedTree(localTree, simulatedTree, name, label) {
     }
 }
 export function validateTx(tx) {
-    const txHeader = tx.constants.historicalHeader;
-    if (txHeader.state.l1ToL2MessageTree.isZero()) {
+    const txHeader = tx.data.constants.historicalHeader;
+    if (txHeader.state.l1ToL2MessageTree.isEmpty()) {
         throw new Error(`Empty L1 to L2 messages tree in tx: ${toFriendlyJSON(tx)}`);
     }
-    if (txHeader.state.partial.noteHashTree.isZero()) {
+    if (txHeader.state.partial.noteHashTree.isEmpty()) {
         throw new Error(`Empty note hash tree in tx: ${toFriendlyJSON(tx)}`);
     }
-    if (txHeader.state.partial.nullifierTree.isZero()) {
+    if (txHeader.state.partial.nullifierTree.isEmpty()) {
         throw new Error(`Empty nullifier tree in tx: ${toFriendlyJSON(tx)}`);
     }
-    if (txHeader.state.partial.publicDataTree.isZero()) {
+    if (txHeader.state.partial.publicDataTree.isEmpty()) {
         throw new Error(`Empty public data tree in tx: ${toFriendlyJSON(tx)}`);
     }
 }

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

@@ -1,14 +1,13 @@
-import { SpongeBlob } from '@aztec/blob-lib';
+import { BatchedBlobAccumulator, SpongeBlob } from '@aztec/blob-lib';
 import { type ARCHIVE_HEIGHT, type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
-import type { Logger } from '@aztec/foundation/log';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation } from '@aztec/foundation/trees';
-import type { L2Block } from '@aztec/stdlib/block';
+import type { EthAddress, L2Block } from '@aztec/stdlib/block';
 import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
 import { type ParityPublicInputs, RootParityInputs } from '@aztec/stdlib/parity';
-import { type BaseOrMergeRollupPublicInputs, type BlockRootOrBlockMergePublicInputs, BlockRootRollupInputs, EmptyBlockRootRollupInputs, MergeRollupInputs, SingleTxBlockRootRollupInputs } from '@aztec/stdlib/rollup';
-import type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import { type BaseOrMergeRollupPublicInputs, type BlockRootOrBlockMergePublicInputs, BlockRootRollupInputs, EmptyBlockRootRollupInputs, MergeRollupInputs, PaddingBlockRootRollupInputs, SingleTxBlockRootRollupInputs } from '@aztec/stdlib/rollup';
+import { AppendOnlyTreeSnapshot, type MerkleTreeId } from '@aztec/stdlib/trees';
 import { type BlockHeader, type GlobalVariables } from '@aztec/stdlib/tx';
 import type { EpochProvingState } from './epoch-proving-state.js';
 import type { TxProvingState } from './tx-proving-state.js';
@@ -22,11 +21,14 @@ export declare class BlockProvingState {
     readonly index: number;
     readonly globalVariables: GlobalVariables;
     readonly newL1ToL2Messages: Fr[];
+    readonly l1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot;
     private readonly l1ToL2MessageSubtreeSiblingPath;
-    private readonly l1ToL2MessageTreeSnapshotAfterInsertion;
+    readonly l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot;
     private readonly lastArchiveSnapshot;
+    private readonly lastArchiveSiblingPath;
     private readonly newArchiveSiblingPath;
     private readonly previousBlockHeader;
+    private readonly proverId;
     private readonly parentEpoch;
     private baseOrMergeProvingOutputs;
     private baseParityProvingOutputs;
@@ -35,10 +37,13 @@ export declare class BlockProvingState {
     blockRootRollupStarted: boolean;
     block: L2Block | undefined;
     spongeBlobState: SpongeBlob | undefined;
+    startBlobAccumulator: BatchedBlobAccumulator | undefined;
+    endBlobAccumulator: BatchedBlobAccumulator | undefined;
+    blobsHash: Fr | undefined;
     totalNumTxs: number;
     private txs;
     error: string | undefined;
-    constructor(index: number, globalVariables: GlobalVariables, newL1ToL2Messages: Fr[], l1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>, l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot, lastArchiveSnapshot: AppendOnlyTreeSnapshot, newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, previousBlockHeader: BlockHeader, parentEpoch: EpochProvingState);
+    constructor(index: number, globalVariables: GlobalVariables, newL1ToL2Messages: Fr[], l1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, l1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>, l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot, lastArchiveSnapshot: AppendOnlyTreeSnapshot, lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, previousBlockHeader: BlockHeader, proverId: EthAddress, parentEpoch: EpochProvingState);
     get blockNumber(): number;
     startNewBlock(numTxs: number, numBlobFields: number): void;
     addNewTx(tx: TxProvingState): number;
@@ -47,12 +52,16 @@ export declare class BlockProvingState {
     setBaseParityProof(index: number, provingOutput: PublicInputsAndRecursiveProof<ParityPublicInputs>): void;
     setRootParityProof(provingOutput: PublicInputsAndRecursiveProof<ParityPublicInputs>): void;
     setBlockRootRollupProof(provingOutput: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
+    setBlock(block: L2Block): void;
+    setStartBlobAccumulator(accumulator: BatchedBlobAccumulator): void;
+    setEndBlobAccumulator(accumulator: BatchedBlobAccumulator): void;
+    accumulateBlobs(): Promise<void>;
     get allTxs(): TxProvingState[];
     /** Returns the block number as an epoch number. Used for prioritizing proof requests. */
     get epochNumber(): number;
     getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
     getMergeRollupInputs(mergeLocation: TreeNodeLocation): MergeRollupInputs;
-    getBlockRootRollupTypeAndInputs(proverId: Fr): Promise<{
+    getBlockRootRollupTypeAndInputs(): Promise<{
         rollupType: string;
         inputs: EmptyBlockRootRollupInputs;
     } | {
@@ -62,10 +71,10 @@ export declare class BlockProvingState {
         rollupType: string;
         inputs: BlockRootRollupInputs;
     }>;
-    getPaddingBlockRootInputs(proverId: Fr): Promise<EmptyBlockRootRollupInputs>;
+    getPaddingBlockRootInputs(): PaddingBlockRootRollupInputs;
     getRootParityInputs(): RootParityInputs;
     getTxProvingState(txIndex: number): TxProvingState;
-    buildHeaderFromProvingOutputs(logger?: Logger): Promise<BlockHeader>;
+    buildHeaderFromProvingOutputs(): Promise<BlockHeader>;
     isReadyForMergeRollup(location: TreeNodeLocation): boolean;
     isReadyForBlockRootRollup(): boolean;
     isReadyForRootParity(): boolean;

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,14 +1,15 @@
-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 { BatchedBlobAccumulator, BlobAccumulatorPublicInputs, SpongeBlob } from '@aztec/blob-lib';
+import { BLOBS_PER_BLOCK, FIELDS_PER_BLOB, NUM_BASE_PARITY_PER_ROOT_PARITY } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
-import { MembershipWitness, UnbalancedTreeStore } from '@aztec/foundation/trees';
+import { BLS12Point, Fr } from '@aztec/foundation/fields';
+import { 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 { BlockConstantData, BlockRootRollupBlobData, BlockRootRollupData, BlockRootRollupInputs, EmptyBlockRootRollupInputs, EpochConstantData, MergeRollupInputs, PaddingBlockRootRollupInputs, PreviousRollupData, SingleTxBlockRootRollupInputs } from '@aztec/stdlib/rollup';
 import { StateReference } from '@aztec/stdlib/tx';
-import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-helpers.js';
+import { VkData } from '@aztec/stdlib/vks';
+import { accumulateBlobs, buildBlobHints, buildHeaderFromCircuitOutputs, getEmptyBlockBlobsHash } 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.
@@ -16,11 +17,14 @@ import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-
     index;
     globalVariables;
     newL1ToL2Messages;
+    l1ToL2MessageTreeSnapshot;
     l1ToL2MessageSubtreeSiblingPath;
     l1ToL2MessageTreeSnapshotAfterInsertion;
     lastArchiveSnapshot;
+    lastArchiveSiblingPath;
     newArchiveSiblingPath;
     previousBlockHeader;
+    proverId;
     parentEpoch;
     baseOrMergeProvingOutputs;
     baseParityProvingOutputs;
@@ -29,18 +33,24 @@ import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-
     blockRootRollupStarted;
     block;
     spongeBlobState;
+    startBlobAccumulator;
+    endBlobAccumulator;
+    blobsHash;
     totalNumTxs;
     txs;
     error;
-    constructor(index, globalVariables, newL1ToL2Messages, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchiveSnapshot, newArchiveSiblingPath, previousBlockHeader, parentEpoch){
+    constructor(index, globalVariables, newL1ToL2Messages, l1ToL2MessageTreeSnapshot, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchiveSnapshot, lastArchiveSiblingPath, newArchiveSiblingPath, previousBlockHeader, proverId, parentEpoch){
         this.index = index;
         this.globalVariables = globalVariables;
         this.newL1ToL2Messages = newL1ToL2Messages;
+        this.l1ToL2MessageTreeSnapshot = l1ToL2MessageTreeSnapshot;
         this.l1ToL2MessageSubtreeSiblingPath = l1ToL2MessageSubtreeSiblingPath;
         this.l1ToL2MessageTreeSnapshotAfterInsertion = l1ToL2MessageTreeSnapshotAfterInsertion;
         this.lastArchiveSnapshot = lastArchiveSnapshot;
+        this.lastArchiveSiblingPath = lastArchiveSiblingPath;
         this.newArchiveSiblingPath = newArchiveSiblingPath;
         this.previousBlockHeader = previousBlockHeader;
+        this.proverId = proverId;
         this.parentEpoch = parentEpoch;
         this.baseOrMergeProvingOutputs = new UnbalancedTreeStore(0);
         this.blockRootRollupStarted = false;
@@ -49,16 +59,19 @@ import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-
             length: NUM_BASE_PARITY_PER_ROOT_PARITY
         }).map((_)=>undefined);
         this.totalNumTxs = 0;
+        if (this.blockNumber == parentEpoch.firstBlockNumber) {
+            this.startBlobAccumulator = BatchedBlobAccumulator.newWithChallenges(parentEpoch.finalBlobBatchingChallenges);
+        }
     }
     get blockNumber() {
-        return this.globalVariables.blockNumber.toNumber();
+        return this.globalVariables.blockNumber;
     }
     startNewBlock(numTxs, numBlobFields) {
         if (this.spongeBlobState) {
             throw new Error(`Block ${this.blockNumber} already initalised.`);
         }
         this.baseOrMergeProvingOutputs = new UnbalancedTreeStore(numTxs);
-        // Initialise the sponge which will eventually absorb all tx effects to be added to the blob.
+        // Initialize 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;
@@ -91,6 +104,23 @@ import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-
     setBlockRootRollupProof(provingOutput) {
         this.blockRootProvingOutput = provingOutput;
     }
+    setBlock(block) {
+        this.block = block;
+    }
+    setStartBlobAccumulator(accumulator) {
+        this.startBlobAccumulator = accumulator;
+    }
+    setEndBlobAccumulator(accumulator) {
+        this.endBlobAccumulator = accumulator;
+    }
+    async accumulateBlobs() {
+        if (!this.block || !this.startBlobAccumulator) {
+            // We only want to accumulate once we have all txs, so we wait until the block is set.
+            return;
+        }
+        const endBlobAccumulator = await accumulateBlobs(this.allTxs.map((t)=>t.processedTx), this.startBlobAccumulator);
+        this.setEndBlobAccumulator(endBlobAccumulator);
+    }
     // Returns the complete set of transaction proving state objects
     get allTxs() {
         return this.txs;
@@ -111,7 +141,7 @@ import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-
             this.#getPreviousRollupData(right)
         ]);
     }
-    async getBlockRootRollupTypeAndInputs(proverId) {
+    async getBlockRootRollupTypeAndInputs() {
         if (!this.rootParityProvingOutput) {
             throw new Error('Root parity is not ready.');
         }
@@ -120,25 +150,27 @@ import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-
         if (proofs.length !== nonEmptyProofs.length) {
             throw new Error('At lease one child is not ready for the block root.');
         }
-        const data = this.#getBlockRootRollupData(proverId);
+        const data = this.#getBlockRootRollupData();
         if (this.totalNumTxs === 0) {
-            const constants = ConstantRollupData.from({
+            const constants = BlockConstantData.from({
                 lastArchive: this.lastArchiveSnapshot,
+                newL1ToL2: this.l1ToL2MessageTreeSnapshotAfterInsertion,
                 globalVariables: this.globalVariables,
                 vkTreeRoot: getVKTreeRoot(),
                 protocolContractTreeRoot
             });
+            this.blobsHash = await getEmptyBlockBlobsHash();
             return {
                 rollupType: 'empty-block-root-rollup',
                 inputs: EmptyBlockRootRollupInputs.from({
                     data,
-                    constants,
-                    isPadding: false
+                    constants
                 })
             };
         }
         const previousRollupData = await Promise.all(nonEmptyProofs.map((p)=>this.#getPreviousRollupData(p)));
         const blobData = await this.#getBlockRootRollupBlobData();
+        this.blobsHash = blobData.blobsHash;
         if (previousRollupData.length === 1) {
             return {
                 rollupType: 'single-tx-block-root-rollup',
@@ -151,30 +183,14 @@ import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-
             };
         }
     }
-    async getPaddingBlockRootInputs(proverId) {
-        if (!this.rootParityProvingOutput) {
-            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,
+    getPaddingBlockRootInputs() {
+        const constants = EpochConstantData.from({
             vkTreeRoot: getVKTreeRoot(),
-            protocolContractTreeRoot
+            protocolContractTreeRoot,
+            proverId: this.proverId.toField()
         });
-        return EmptyBlockRootRollupInputs.from({
-            data,
-            constants,
-            isPadding: true
+        return PaddingBlockRootRollupInputs.from({
+            constants
         });
     }
     getRootParityInputs() {
@@ -188,7 +204,7 @@ import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-
     getTxProvingState(txIndex) {
         return this.txs[txIndex];
     }
-    async buildHeaderFromProvingOutputs(logger) {
+    async buildHeaderFromProvingOutputs() {
         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) {
@@ -200,7 +216,7 @@ import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-
             endPartialState = lastRollup.inputs.end;
         }
         const endState = new StateReference(this.l1ToL2MessageTreeSnapshotAfterInsertion, endPartialState);
-        return buildHeaderFromCircuitOutputs(previousRollupData.map((d)=>d.baseOrMergeRollupPublicInputs), this.rootParityProvingOutput.inputs, this.blockRootProvingOutput.inputs, endState, logger);
+        return buildHeaderFromCircuitOutputs(previousRollupData.map((d)=>d.baseOrMergeRollupPublicInputs), this.rootParityProvingOutput.inputs, this.blockRootProvingOutput.inputs, this.blobsHash, endState);
     }
     isReadyForMergeRollup(location) {
         return this.baseOrMergeProvingOutputs.getSibling(location) !== undefined;
@@ -208,7 +224,7 @@ import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-
     // 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);
+        return this.block !== undefined && this.rootParityProvingOutput !== undefined && this.endBlobAccumulator !== undefined && childProofs.every((p)=>!!p);
     }
     // Returns true if we have sufficient root parity inputs to execute the root parity circuit
     isReadyForRootParity() {
@@ -225,13 +241,16 @@ import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-
         this.error = reason;
         this.parentEpoch.reject(reason);
     }
-    #getBlockRootRollupData(proverId) {
+    #getBlockRootRollupData() {
         return BlockRootRollupData.from({
             l1ToL2Roots: this.#getRootParityData(this.rootParityProvingOutput),
             l1ToL2MessageSubtreeSiblingPath: this.l1ToL2MessageSubtreeSiblingPath,
+            previousArchiveSiblingPath: this.lastArchiveSiblingPath,
             newArchiveSiblingPath: this.newArchiveSiblingPath,
             previousBlockHeader: this.previousBlockHeader,
-            proverId
+            startBlobAccumulator: BlobAccumulatorPublicInputs.fromBatchedBlobAccumulator(this.startBlobAccumulator),
+            finalBlobChallenges: this.startBlobAccumulator.finalBlobChallenges,
+            proverId: this.proverId.toField()
         });
     }
     async #getBlockRootRollupBlobData() {
@@ -239,10 +258,7 @@ import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-
         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),
+            blobCommitments: padArrayEnd(blobCommitments, BLS12Point.ZERO, BLOBS_PER_BLOCK),
             blobsHash
         });
     }
@@ -261,7 +277,8 @@ import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-
     }
     #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)));
+        const vkData = new VkData(verificationKey, leafIndex, getVKSiblingPath(leafIndex));
+        return new PreviousRollupData(inputs, proof, vkData);
     }
     #getRootParityData({ inputs, proof, verificationKey }) {
         return new RootParityInput(proof, verificationKey.keyAsFields, getVKSiblingPath(getVKIndex(verificationKey)), inputs);