@aztec/prover-client 3.0.0-devnet.5 → 3.0.0-devnet.6-patch.1

package/src/block-factory/light.ts

@@ -1,18 +1,19 @@
-import { SpongeBlob } from '@aztec/blob-lib';
+import { SpongeBlob, computeBlobsHashFromBlobs, encodeCheckpointEndMarker, getBlobsPerL1Block } from '@aztec/blob-lib';
 import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
-import { L2Block } from '@aztec/stdlib/block';
+import { L2Block, L2BlockHeader } from '@aztec/stdlib/block';
 import type { IBlockFactory, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { computeBlockOutHash, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
-import type { GlobalVariables, ProcessedTx } from '@aztec/stdlib/tx';
+import { ContentCommitment, type GlobalVariables, type ProcessedTx } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import {
   buildHeaderAndBodyFromTxs,
   getTreeSnapshot,
-  insertSideEffectsAndBuildBaseRollupHints,
+  insertSideEffects,
 } from '../orchestrator/block-building-helpers.js';
 
 /**
@@ -25,12 +26,13 @@ import {
  * PublicProcessor which will do this for you as it processes transactions.
  *
  * If you haven't already inserted the side effects, e.g. because you are in a testing context, you can use the helper
- * function `buildBlockWithCleanDB`, which calls `insertSideEffectsAndBuildBaseRollupHints` for you.
+ * function `buildBlockWithCleanDB`, which calls `insertSideEffects` for you.
+ *
+ * @deprecated Use LightweightCheckpointBuilder instead. This only works for one block per checkpoint.
  */
 export class LightweightBlockFactory implements IBlockFactory {
   private globalVariables?: GlobalVariables;
   private l1ToL2Messages?: Fr[];
-  private startSpongeBlob?: SpongeBlob;
   private txs: ProcessedTx[] | undefined;
 
   private readonly logger = createLogger('lightweight-block-factory');
@@ -40,20 +42,10 @@ export class LightweightBlockFactory implements IBlockFactory {
     private telemetry: TelemetryClient = getTelemetryClient(),
   ) {}
 
-  async startNewBlock(
-    globalVariables: GlobalVariables,
-    l1ToL2Messages: Fr[],
-    // Must be provided to generate the correct spongeBlobHash for the block header if there's more than one block in the checkpoint.
-    startSpongeBlob?: SpongeBlob,
-    // Only insert l1 to l2 messages for the first block in a checkpoint.
-    isFirstBlock = true,
-  ): Promise<void> {
+  async startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[]): Promise<void> {
     this.logger.debug('Starting new block', { globalVariables: globalVariables.toInspect(), l1ToL2Messages });
     this.globalVariables = globalVariables;
-    this.l1ToL2Messages = isFirstBlock
-      ? padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP)
-      : [];
-    this.startSpongeBlob = startSpongeBlob;
+    this.l1ToL2Messages = padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
     this.txs = undefined;
     // Update L1 to L2 tree
     await this.db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, this.l1ToL2Messages!);
@@ -75,21 +67,40 @@ export class LightweightBlockFactory implements IBlockFactory {
   }
 
   private async buildBlock(): Promise<L2Block> {
-    const { header, body } = await buildHeaderAndBodyFromTxs(
-      this.txs ?? [],
+    const lastArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db);
+    const state = await this.db.getStateReference();
+
+    const txs = this.txs ?? [];
+    const startSpongeBlob = SpongeBlob.init();
+
+    const { header, body, blockBlobFields } = await buildHeaderAndBodyFromTxs(
+      txs,
+      lastArchive,
+      state,
       this.globalVariables!,
-      this.l1ToL2Messages!,
-      this.db,
-      this.startSpongeBlob,
+      startSpongeBlob,
+      true,
     );
 
     header.state.validate();
 
-    const blockHeader = header.toBlockHeader();
-    await this.db.updateArchive(blockHeader);
+    await this.db.updateArchive(header);
     const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db);
 
-    const block = new L2Block(newArchive, header, body);
+    const outHash = computeBlockOutHash(txs.map(tx => tx.txEffect.l2ToL1Msgs));
+    const inHash = computeInHashFromL1ToL2Messages(this.l1ToL2Messages!);
+    const numBlobFields = blockBlobFields.length + 1;
+    const blobFields = blockBlobFields.concat([encodeCheckpointEndMarker({ numBlobFields })]);
+    const blobsHash = computeBlobsHashFromBlobs(getBlobsPerL1Block(blobFields));
+    const blockHeaderHash = await header.hash();
+    const contentCommitment = new ContentCommitment(blobsHash, inHash, outHash);
+    const l2BlockHeader = L2BlockHeader.from({
+      ...header,
+      blockHeadersHash: blockHeaderHash,
+      contentCommitment,
+    });
+
+    const block = new L2Block(newArchive, l2BlockHeader, body);
 
     this.logger.debug(`Built block ${block.number}`, {
       globalVariables: this.globalVariables?.toInspect(),
@@ -112,27 +123,13 @@ export async function buildBlockWithCleanDB(
   globalVariables: GlobalVariables,
   l1ToL2Messages: Fr[],
   db: MerkleTreeWriteOperations,
-  startSpongeBlob?: SpongeBlob,
-  isFirstBlock = true,
   telemetry: TelemetryClient = getTelemetryClient(),
 ) {
-  const lastArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
   const builder = new LightweightBlockFactory(db, telemetry);
-  await builder.startNewBlock(globalVariables, l1ToL2Messages, startSpongeBlob, isFirstBlock);
-  const l1ToL2MessageTree = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
+  await builder.startNewBlock(globalVariables, l1ToL2Messages);
 
   for (const tx of txs) {
-    // startSpongeBlob and proverId are only used for constructing private inputs of the base rollup.
-    // Their values don't matter here because we are not using the return private inputs to build the block.
-    const proverId = Fr.ZERO;
-    await insertSideEffectsAndBuildBaseRollupHints(
-      tx,
-      lastArchive,
-      l1ToL2MessageTree,
-      startSpongeBlob?.clone() ?? SpongeBlob.empty(),
-      proverId,
-      db,
-    );
+    await insertSideEffects(tx, db);
   }
   await builder.addTxs(txs);
 

package/src/config.ts

@@ -44,7 +44,7 @@ export const bbConfigMappings: ConfigMappingsType<BBConfig & ACVMConfig> = {
   },
   numConcurrentIVCVerifiers: {
     env: 'BB_NUM_IVC_VERIFIERS',
-    description: 'Max number of client IVC verifiers to run concurrently',
+    description: 'Max number of chonk verifiers to run concurrently',
     ...numberConfigHelper(8),
   },
   bbIVCConcurrency: {

package/src/light/lightweight_checkpoint_builder.ts

@@ -0,0 +1,144 @@
+import { SpongeBlob, computeBlobsHashFromBlobs, encodeCheckpointEndMarker, getBlobsPerL1Block } from '@aztec/blob-lib';
+import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import type { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { L2BlockNew } from '@aztec/stdlib/block';
+import { Checkpoint } from '@aztec/stdlib/checkpoint';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { computeCheckpointOutHash, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
+import { CheckpointConstantData, CheckpointHeader, computeBlockHeadersHash } from '@aztec/stdlib/rollup';
+import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import { ContentCommitment, type GlobalVariables, type ProcessedTx, StateReference } from '@aztec/stdlib/tx';
+
+import {
+  buildHeaderAndBodyFromTxs,
+  getTreeSnapshot,
+  insertSideEffects,
+} from '../orchestrator/block-building-helpers.js';
+
+/**
+ * Builds a checkpoint and its header and the blocks in it from a set of processed tx without running any circuits.
+ *
+ * It updates the l1-to-l2 message tree when starting a new checkpoint, inserts the side effects to note hash,
+ * nullifier, and public data trees, then updates the archive tree when a block is added.
+ */
+export class LightweightCheckpointBuilder {
+  private readonly logger = createLogger('lightweight-checkpoint-builder');
+  private lastArchives: AppendOnlyTreeSnapshot[] = [];
+  private spongeBlob: SpongeBlob;
+  private blocks: L2BlockNew[] = [];
+  private blobFields: Fr[] = [];
+
+  constructor(
+    private checkpointNumber: CheckpointNumber,
+    private constants: CheckpointConstantData,
+    private l1ToL2Messages: Fr[],
+    private db: MerkleTreeWriteOperations,
+  ) {
+    this.spongeBlob = SpongeBlob.init();
+    this.logger.debug('Starting new checkpoint', { constants: constants.toInspect(), l1ToL2Messages });
+  }
+
+  static async startNewCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    constants: CheckpointConstantData,
+    l1ToL2Messages: Fr[],
+    db: MerkleTreeWriteOperations,
+  ): Promise<LightweightCheckpointBuilder> {
+    // Insert l1-to-l2 messages into the tree.
+    await db.appendLeaves(
+      MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
+      padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
+    );
+
+    return new LightweightCheckpointBuilder(checkpointNumber, constants, l1ToL2Messages, db);
+  }
+
+  async addBlock(globalVariables: GlobalVariables, endState: StateReference, txs: ProcessedTx[]): Promise<L2BlockNew> {
+    const isFirstBlock = this.blocks.length === 0;
+    if (isFirstBlock) {
+      this.lastArchives.push(await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db));
+    }
+
+    const lastArchive = this.lastArchives.at(-1)!;
+
+    for (const tx of txs) {
+      await insertSideEffects(tx, this.db);
+    }
+
+    const { header, body, blockBlobFields } = await buildHeaderAndBodyFromTxs(
+      txs,
+      lastArchive,
+      endState,
+      globalVariables,
+      this.spongeBlob,
+      isFirstBlock,
+    );
+
+    await this.db.updateArchive(header);
+    const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db);
+    this.lastArchives.push(newArchive);
+
+    const indexWithinCheckpoint = this.blocks.length;
+    const block = new L2BlockNew(newArchive, header, body, this.checkpointNumber, indexWithinCheckpoint);
+    this.blocks.push(block);
+
+    await this.spongeBlob.absorb(blockBlobFields);
+    this.blobFields.push(...blockBlobFields);
+
+    this.logger.debug(`Built block ${header.getBlockNumber()}`, {
+      globalVariables: globalVariables.toInspect(),
+      archiveRoot: newArchive.root.toString(),
+      stateReference: header.state.toInspect(),
+      blockHash: (await block.hash()).toString(),
+      txs: block.body.txEffects.map(tx => tx.txHash.toString()),
+    });
+
+    return block;
+  }
+
+  async completeCheckpoint(): Promise<Checkpoint> {
+    if (!this.blocks.length) {
+      throw new Error('No blocks added to checkpoint.');
+    }
+
+    const numBlobFields = this.blobFields.length + 1; // +1 for the checkpoint end marker.
+    const checkpointEndMarker = encodeCheckpointEndMarker({ numBlobFields });
+    this.blobFields.push(checkpointEndMarker);
+
+    const blocks = this.blocks;
+    const blockHeadersHash = await computeBlockHeadersHash(blocks.map(block => block.header));
+
+    const newArchive = this.lastArchives[this.lastArchives.length - 1];
+
+    const blobs = getBlobsPerL1Block(this.blobFields);
+    const blobsHash = computeBlobsHashFromBlobs(blobs);
+
+    const inHash = computeInHashFromL1ToL2Messages(this.l1ToL2Messages);
+
+    const outHash = computeCheckpointOutHash(blocks.map(block => block.body.txEffects.map(tx => tx.l2ToL1Msgs)));
+
+    const constants = this.constants!;
+
+    // timestamp of a checkpoint is the timestamp of the last block in the checkpoint.
+    const timestamp = blocks[blocks.length - 1].timestamp;
+
+    const totalManaUsed = blocks.reduce((acc, block) => acc.add(block.header.totalManaUsed), Fr.ZERO);
+
+    const header = CheckpointHeader.from({
+      lastArchiveRoot: this.lastArchives[0].root,
+      blockHeadersHash,
+      contentCommitment: new ContentCommitment(blobsHash, inHash, outHash),
+      slotNumber: constants.slotNumber,
+      timestamp,
+      coinbase: constants.coinbase,
+      feeRecipient: constants.feeRecipient,
+      gasFees: constants.gasFees,
+      totalManaUsed,
+    });
+
+    return new Checkpoint(newArchive, header, blocks, this.checkpointNumber);
+  }
+}

package/src/mocks/fixtures.ts

@@ -1,8 +1,7 @@
-import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_TREE_HEIGHT } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { randomBytes } from '@aztec/foundation/crypto';
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { randomBytes } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import type { Logger } from '@aztec/foundation/log';
 import type { FieldsOf } from '@aztec/foundation/types';
 import { fileURLToPath } from '@aztec/foundation/url';
@@ -11,10 +10,7 @@ import { protocolContractsHash } from '@aztec/protocol-contracts';
 import { type CircuitSimulator, NativeACVMSimulator, WASMSimulatorWithBlobs } from '@aztec/simulator/server';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { GasFees } from '@aztec/stdlib/gas';
-import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
 import { CheckpointConstantData } from '@aztec/stdlib/rollup';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
-import type { ProcessedTx } from '@aztec/stdlib/tx';
 import { GlobalVariables } from '@aztec/stdlib/tx';
 
 import { promises as fs } from 'fs';
@@ -88,25 +84,6 @@ export async function getSimulator(
   return new WASMSimulatorWithBlobs();
 }
 
-// Updates the expectedDb trees based on the new note hashes, contracts, and nullifiers from these txs
-export const updateExpectedTreesFromTxs = async (db: MerkleTreeWriteOperations, txs: ProcessedTx[]) => {
-  await db.appendLeaves(
-    MerkleTreeId.NOTE_HASH_TREE,
-    txs.flatMap(tx => padArrayEnd(tx.txEffect.noteHashes, Fr.zero(), MAX_NOTE_HASHES_PER_TX)),
-  );
-  await db.batchInsert(
-    MerkleTreeId.NULLIFIER_TREE,
-    txs.flatMap(tx => padArrayEnd(tx.txEffect.nullifiers, Fr.zero(), MAX_NULLIFIERS_PER_TX).map(x => x.toBuffer())),
-    NULLIFIER_TREE_HEIGHT,
-  );
-  for (const tx of txs) {
-    await db.sequentialInsert(
-      MerkleTreeId.PUBLIC_DATA_TREE,
-      tx.txEffect.publicDataWrites.map(write => write.toBuffer()),
-    );
-  }
-};
-
 export const makeGlobals = (
   blockNumber: number,
   slotNumber = blockNumber,
@@ -116,9 +93,9 @@ export const makeGlobals = (
   return GlobalVariables.from({
     chainId: checkpointConstants.chainId,
     version: checkpointConstants.version,
-    blockNumber /** block number */,
-    slotNumber: new Fr(slotNumber) /** slot number */,
-    timestamp: BigInt(blockNumber) /** block number as pseudo-timestamp for testing */,
+    blockNumber: BlockNumber(blockNumber) /** block number */,
+    slotNumber: SlotNumber(slotNumber) /** slot number */,
+    timestamp: BigInt(blockNumber * 123) /** block number * 123 as pseudo-timestamp for testing */,
     coinbase: checkpointConstants.coinbase,
     feeRecipient: checkpointConstants.feeRecipient,
     gasFees: checkpointConstants.gasFees,
@@ -136,7 +113,7 @@ export const makeCheckpointConstants = (
     vkTreeRoot: getVKTreeRoot(),
     protocolContractsHash,
     proverId: Fr.ZERO,
-    slotNumber: new Fr(slotNumber),
+    slotNumber: SlotNumber(slotNumber),
     coinbase: EthAddress.ZERO,
     feeRecipient: AztecAddress.ZERO,
     gasFees: GasFees.empty(),