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

package/src/orchestrator/block-proving-state.ts

@@ -1,4 +1,4 @@
-import { SpongeBlob } from '@aztec/blob-lib';
+import { BatchedBlobAccumulator, BlobAccumulatorPublicInputs, SpongeBlob } from '@aztec/blob-lib';
 import {
   type ARCHIVE_HEIGHT,
   BLOBS_PER_BLOCK,
@@ -7,35 +7,41 @@ import {
   type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   NUM_BASE_PARITY_PER_ROOT_PARITY,
   type RECURSIVE_PROOF_LENGTH,
-  VK_TREE_HEIGHT,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
-import type { Logger } from '@aztec/foundation/log';
+import { BLS12Point, Fr } from '@aztec/foundation/fields';
 import type { Tuple } from '@aztec/foundation/serialize';
-import { MembershipWitness, type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
+import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
 import { getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
-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, RootParityInput, RootParityInputs } from '@aztec/stdlib/parity';
 import {
   type BaseOrMergeRollupPublicInputs,
+  BlockConstantData,
   type BlockRootOrBlockMergePublicInputs,
   BlockRootRollupBlobData,
   BlockRootRollupData,
   BlockRootRollupInputs,
-  ConstantRollupData,
   EmptyBlockRootRollupInputs,
+  EpochConstantData,
   MergeRollupInputs,
+  PaddingBlockRootRollupInputs,
   PreviousRollupData,
   SingleTxBlockRootRollupInputs,
 } from '@aztec/stdlib/rollup';
 import type { CircuitName } from '@aztec/stdlib/stats';
-import type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import { AppendOnlyTreeSnapshot, type MerkleTreeId } from '@aztec/stdlib/trees';
 import { type BlockHeader, type GlobalVariables, StateReference } from '@aztec/stdlib/tx';
+import { VkData } from '@aztec/stdlib/vks';
 
-import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-helpers.js';
+import {
+  accumulateBlobs,
+  buildBlobHints,
+  buildHeaderFromCircuitOutputs,
+  getEmptyBlockBlobsHash,
+} from './block-building-helpers.js';
 import type { EpochProvingState } from './epoch-proving-state.js';
 import type { TxProvingState } from './tx-proving-state.js';
 
@@ -57,6 +63,9 @@ export class BlockProvingState {
   public blockRootRollupStarted: boolean = false;
   public block: L2Block | undefined;
   public spongeBlobState: SpongeBlob | undefined;
+  public startBlobAccumulator: BatchedBlobAccumulator | undefined;
+  public endBlobAccumulator: BatchedBlobAccumulator | undefined;
+  public blobsHash: Fr | undefined;
   public totalNumTxs: number;
   private txs: TxProvingState[] = [];
   public error: string | undefined;
@@ -65,19 +74,25 @@ export class BlockProvingState {
     public readonly index: number,
     public readonly globalVariables: GlobalVariables,
     public readonly newL1ToL2Messages: Fr[],
+    public readonly l1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
     private readonly l1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>,
-    private readonly l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot,
+    public readonly l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot,
     private readonly lastArchiveSnapshot: AppendOnlyTreeSnapshot,
+    private readonly lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
     private readonly newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
     private readonly previousBlockHeader: BlockHeader,
+    private readonly proverId: EthAddress,
     private readonly parentEpoch: EpochProvingState,
   ) {
     this.baseParityProvingOutputs = Array.from({ length: NUM_BASE_PARITY_PER_ROOT_PARITY }).map(_ => undefined);
     this.totalNumTxs = 0;
+    if (this.blockNumber == parentEpoch.firstBlockNumber) {
+      this.startBlobAccumulator = BatchedBlobAccumulator.newWithChallenges(parentEpoch.finalBlobBatchingChallenges);
+    }
   }
 
   public get blockNumber() {
-    return this.globalVariables.blockNumber.toNumber();
+    return this.globalVariables.blockNumber;
   }
 
   public startNewBlock(numTxs: number, numBlobFields: number) {
@@ -86,7 +101,7 @@ export class BlockProvingState {
     }
 
     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;
@@ -97,7 +112,6 @@ export class BlockProvingState {
     if (!this.spongeBlobState) {
       throw new Error(`Invalid block proving state, call startNewBlock before adding transactions.`);
     }
-
     const txIndex = this.txs.length;
     this.txs[txIndex] = tx;
     return txIndex;
@@ -146,6 +160,30 @@ export class BlockProvingState {
     this.blockRootProvingOutput = provingOutput;
   }
 
+  public setBlock(block: L2Block) {
+    this.block = block;
+  }
+
+  public setStartBlobAccumulator(accumulator: BatchedBlobAccumulator) {
+    this.startBlobAccumulator = accumulator;
+  }
+
+  public setEndBlobAccumulator(accumulator: BatchedBlobAccumulator) {
+    this.endBlobAccumulator = accumulator;
+  }
+
+  public 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
   public get allTxs() {
     return this.txs;
@@ -169,7 +207,7 @@ export class BlockProvingState {
     return new MergeRollupInputs([this.#getPreviousRollupData(left), this.#getPreviousRollupData(right)]);
   }
 
-  public async getBlockRootRollupTypeAndInputs(proverId: Fr) {
+  public async getBlockRootRollupTypeAndInputs() {
     if (!this.rootParityProvingOutput) {
       throw new Error('Root parity is not ready.');
     }
@@ -180,28 +218,31 @@ export class BlockProvingState {
       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' satisfies CircuitName,
         inputs: EmptyBlockRootRollupInputs.from({
           data,
           constants,
-          isPadding: false,
         }),
       };
     }
 
     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 {
@@ -220,34 +261,15 @@ export class BlockProvingState {
     }
   }
 
-  public async getPaddingBlockRootInputs(proverId: Fr) {
-    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,
+  public getPaddingBlockRootInputs() {
+    const constants = EpochConstantData.from({
       vkTreeRoot: getVKTreeRoot(),
       protocolContractTreeRoot,
+      proverId: this.proverId.toField(),
     });
 
-    return EmptyBlockRootRollupInputs.from({
-      data,
+    return PaddingBlockRootRollupInputs.from({
       constants,
-      isPadding: true,
     });
   }
 
@@ -267,7 +289,7 @@ export class BlockProvingState {
     return this.txs[txIndex];
   }
 
-  public async buildHeaderFromProvingOutputs(logger?: Logger) {
+  public async buildHeaderFromProvingOutputs() {
     const previousRollupData =
       this.totalNumTxs === 0
         ? []
@@ -288,8 +310,8 @@ export class BlockProvingState {
       previousRollupData.map(d => d.baseOrMergeRollupPublicInputs),
       this.rootParityProvingOutput!.inputs,
       this.blockRootProvingOutput!.inputs,
+      this.blobsHash!,
       endState,
-      logger,
     );
   }
 
@@ -300,7 +322,12 @@ export class BlockProvingState {
   // Returns true if we have sufficient inputs to execute the block root rollup
   public 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
@@ -322,13 +349,16 @@ export class BlockProvingState {
     this.parentEpoch.reject(reason);
   }
 
-  #getBlockRootRollupData(proverId: Fr) {
+  #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(),
     });
   }
 
@@ -337,7 +367,7 @@ export class BlockProvingState {
     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,
     });
   }
@@ -360,12 +390,8 @@ export class BlockProvingState {
     verificationKey,
   }: PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>) {
     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 }: PublicInputsAndRecursiveProof<ParityPublicInputs>) {

package/src/orchestrator/epoch-proving-state.ts

@@ -1,13 +1,14 @@
-import {
-  type ARCHIVE_HEIGHT,
-  type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
-  type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-  type TUBE_PROOF_LENGTH,
-  VK_TREE_HEIGHT,
+import { BatchedBlob, type FinalBlobBatchingChallenges } from '@aztec/blob-lib';
+import type {
+  ARCHIVE_HEIGHT,
+  L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
+  NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+  TUBE_PROOF_LENGTH,
 } from '@aztec/constants';
+import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { Fr } from '@aztec/foundation/fields';
 import type { Tuple } from '@aztec/foundation/serialize';
-import { MembershipWitness, type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
+import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
 import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import type { ProofAndVerificationKey, PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
 import type { Proof } from '@aztec/stdlib/proofs';
@@ -20,6 +21,7 @@ import {
 } from '@aztec/stdlib/rollup';
 import type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
 import type { BlockHeader, GlobalVariables } from '@aztec/stdlib/tx';
+import { VkData } from '@aztec/stdlib/vks';
 
 import { BlockProvingState } from './block-proving-state.js';
 
@@ -48,6 +50,7 @@ export class EpochProvingState {
     | PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
     | undefined;
   private rootRollupProvingOutput: PublicInputsAndRecursiveProof<RootRollupPublicInputs> | undefined;
+  private finalBatchedBlob: BatchedBlob | undefined;
   private provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED;
 
   // Map from tx hash to tube proof promise. Used when kickstarting tube proofs before tx processing.
@@ -59,6 +62,7 @@ export class EpochProvingState {
     public readonly epochNumber: number,
     public readonly firstBlockNumber: number,
     public readonly totalNumBlocks: number,
+    public readonly finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
     private completionCallback: (result: ProvingResult) => void,
     private rejectionCallback: (reason: string) => void,
   ) {
@@ -70,22 +74,28 @@ export class EpochProvingState {
   public startNewBlock(
     globalVariables: GlobalVariables,
     l1ToL2Messages: 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,
   ): BlockProvingState {
-    const index = globalVariables.blockNumber.toNumber() - this.firstBlockNumber;
+    const index = globalVariables.blockNumber - this.firstBlockNumber;
     const block = new BlockProvingState(
       index,
       globalVariables,
       l1ToL2Messages,
+      l1ToL2MessageTreeSnapshot,
       l1ToL2MessageSubtreeSiblingPath,
       l1ToL2MessageTreeSnapshotAfterInsertion,
       lastArchiveSnapshot,
+      lastArchiveSiblingPath,
       newArchiveSiblingPath,
       previousBlockHeader,
+      proverId,
       this,
     );
     this.blocks[index] = block;
@@ -141,6 +151,31 @@ export class EpochProvingState {
     this.paddingBlockRootProvingOutput = proof;
   }
 
+  public setFinalBatchedBlob(batchedBlob: BatchedBlob) {
+    this.finalBatchedBlob = batchedBlob;
+  }
+
+  public async setBlobAccumulators(toBlock?: number) {
+    let previousAccumulator;
+    const end = toBlock ? toBlock - this.firstBlockNumber : this.blocks.length;
+    // Accumulate blobs as far as we can for this epoch.
+    for (let i = 0; i <= end; i++) {
+      const block = this.blocks[i];
+      if (!block || !block.block) {
+        // If the block proving state does not have a .block property, it may be awaiting more txs.
+        break;
+      }
+      if (!block.startBlobAccumulator) {
+        // startBlobAccumulator always exists for firstBlockNumber, so the below should never assign an undefined:
+        block.setStartBlobAccumulator(previousAccumulator!);
+      }
+      if (block.startBlobAccumulator && !block.endBlobAccumulator) {
+        await block.accumulateBlobs();
+      }
+      previousAccumulator = block.endBlobAccumulator;
+    }
+  }
+
   public getParentLocation(location: TreeNodeLocation) {
     return this.blockRootOrMergeProvingOutputs.getParentLocation(location);
   }
@@ -154,7 +189,7 @@ export class EpochProvingState {
     return new BlockMergeRollupInputs([this.#getPreviousRollupData(left), this.#getPreviousRollupData(right)]);
   }
 
-  public getRootRollupInputs(proverId: Fr) {
+  public getRootRollupInputs() {
     const [left, right] = this.#getChildProofsForRoot();
     if (!left || !right) {
       throw new Error('At lease one child is not ready.');
@@ -162,16 +197,15 @@ export class EpochProvingState {
 
     return RootRollupInputs.from({
       previousRollupData: [this.#getPreviousRollupData(left), this.#getPreviousRollupData(right)],
-      proverId,
     });
   }
 
-  public getPaddingBlockRootInputs(proverId: Fr) {
+  public getPaddingBlockRootInputs() {
     if (!this.blocks[0]?.isComplete()) {
       throw new Error('Epoch needs one completed block in order to be padded.');
     }
 
-    return this.blocks[0].getPaddingBlockRootInputs(proverId);
+    return this.blocks[0].getPaddingBlockRootInputs();
   }
 
   // Returns a specific transaction proving state
@@ -179,14 +213,15 @@ export class EpochProvingState {
     return this.blocks.find(block => block?.blockNumber === blockNumber);
   }
 
-  public getEpochProofResult(): { proof: Proof; publicInputs: RootRollupPublicInputs } {
-    if (!this.rootRollupProvingOutput) {
+  public getEpochProofResult(): { proof: Proof; publicInputs: RootRollupPublicInputs; batchedBlobInputs: BatchedBlob } {
+    if (!this.rootRollupProvingOutput || !this.finalBatchedBlob) {
       throw new Error('Unable to get epoch proof result. Root rollup is not ready.');
     }
 
     return {
       proof: this.rootRollupProvingOutput.proof.binaryProof,
       publicInputs: this.rootRollupProvingOutput.inputs,
+      batchedBlobInputs: this.finalBatchedBlob,
     };
   }
 
@@ -242,11 +277,7 @@ export class EpochProvingState {
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >) {
     const leafIndex = getVKIndex(verificationKey.keyAsFields);
-    return new PreviousRollupBlockData(
-      inputs,
-      proof,
-      verificationKey.keyAsFields,
-      new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), getVKSiblingPath(leafIndex)),
-    );
+    const vkData = new VkData(verificationKey, leafIndex, getVKSiblingPath(leafIndex));
+    return new PreviousRollupBlockData(inputs, proof, vkData);
   }
 }