@aztec/prover-client 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/src/light/lightweight_checkpoint_builder.ts

@@ -0,0 +1,198 @@
+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 { CheckpointHeader, computeBlockHeadersHash } from '@aztec/stdlib/rollup';
+import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import {
+  type CheckpointGlobalVariables,
+  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, and then updates the archive tree when each block is added.
+ * Finally completes the checkpoint by computing its header.
+ */
+export class LightweightCheckpointBuilder {
+  private readonly logger = createLogger('lightweight-checkpoint-builder');
+
+  private lastArchives: AppendOnlyTreeSnapshot[] = [];
+  private spongeBlob: SpongeBlob;
+  private blocks: L2BlockNew[] = [];
+  private blobFields: Fr[] = [];
+
+  constructor(
+    public readonly checkpointNumber: CheckpointNumber,
+    public readonly constants: CheckpointGlobalVariables,
+    public readonly l1ToL2Messages: Fr[],
+    public readonly db: MerkleTreeWriteOperations,
+  ) {
+    this.spongeBlob = SpongeBlob.init();
+    this.logger.debug('Starting new checkpoint', { constants, l1ToL2Messages });
+  }
+
+  static async startNewCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    constants: CheckpointGlobalVariables,
+    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);
+  }
+
+  /**
+   * Adds a new block to the checkpoint. The tx effects must have already been inserted into the db if
+   * this is called after tx processing, if that's not the case, then set `insertTxsEffects` to true.
+   */
+  public async addBlock(
+    globalVariables: GlobalVariables,
+    txs: ProcessedTx[],
+    opts: { insertTxsEffects?: boolean; expectedEndState?: StateReference } = {},
+  ): Promise<L2BlockNew> {
+    const isFirstBlock = this.blocks.length === 0;
+
+    // Empty blocks are only allowed as the first block in a checkpoint
+    if (!isFirstBlock && txs.length === 0) {
+      throw new Error('Cannot add empty block that is not the first block in the checkpoint.');
+    }
+
+    if (isFirstBlock) {
+      this.lastArchives.push(await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db));
+    }
+
+    const lastArchive = this.lastArchives.at(-1)!;
+
+    if (opts.insertTxsEffects) {
+      this.logger.debug(
+        `Inserting side effects for ${txs.length} txs for block ${globalVariables.blockNumber} into db`,
+        { txs: txs.map(tx => tx.hash.toString()) },
+      );
+      for (const tx of txs) {
+        await insertSideEffects(tx, this.db);
+      }
+    }
+
+    const endState = await this.db.getStateReference();
+    if (opts.expectedEndState && !endState.equals(opts.expectedEndState)) {
+      this.logger.error('End state after processing txs does not match expected end state', {
+        globalVariables: globalVariables.toInspect(),
+        expectedEndState: opts.expectedEndState.toInspect(),
+        actualEndState: endState.toInspect(),
+      });
+      throw new Error(`End state does not match expected end state when building block ${globalVariables.blockNumber}`);
+    }
+
+    const { header, body, blockBlobFields } = await buildHeaderAndBodyFromTxs(
+      txs,
+      lastArchive,
+      endState,
+      globalVariables,
+      this.spongeBlob,
+      isFirstBlock,
+    );
+
+    header.state.validate();
+
+    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('Cannot complete a checkpoint with no blocks');
+    }
+
+    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 { slotNumber, coinbase, feeRecipient, gasFees } = this.constants;
+
+    // TODO(palla/mbps): Should we source this from the constants instead?
+    // 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,
+      contentCommitment: new ContentCommitment(blobsHash, inHash, outHash),
+      blockHeadersHash,
+      slotNumber,
+      timestamp,
+      coinbase,
+      feeRecipient,
+      gasFees,
+      totalManaUsed,
+    });
+
+    return new Checkpoint(newArchive, header, blocks, this.checkpointNumber);
+  }
+
+  clone() {
+    const clone = new LightweightCheckpointBuilder(
+      this.checkpointNumber,
+      this.constants,
+      [...this.l1ToL2Messages],
+      this.db,
+    );
+    clone.lastArchives = [...this.lastArchives];
+    clone.spongeBlob = this.spongeBlob.clone();
+    clone.blocks = [...this.blocks];
+    clone.blobFields = [...this.blobFields];
+    return clone;
+  }
+}

package/src/mocks/fixtures.ts

@@ -1,16 +1,16 @@
-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';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+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 { MerkleTreeId } from '@aztec/stdlib/trees';
-import type { ProcessedTx } from '@aztec/stdlib/tx';
+import { CheckpointConstantData } from '@aztec/stdlib/rollup';
 import { GlobalVariables } from '@aztec/stdlib/tx';
 
 import { promises as fs } from 'fs';
@@ -32,7 +32,7 @@ export const getEnvironmentConfig = async (logger: Logger) => {
   try {
     const expectedBBPath = BB_BINARY_PATH
       ? BB_BINARY_PATH
-      : `${path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../barretenberg/', BB_RELEASE_DIR)}/bb`;
+      : `${path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../barretenberg/', BB_RELEASE_DIR)}/bb-avm`;
     await fs.access(expectedBBPath, fs.constants.R_OK);
     const tempWorkingDirectory = `${TEMP_DIR}/${randomBytes(4).toString('hex')}`;
     const bbWorkingDirectory = BB_WORKING_DIRECTORY ? BB_WORKING_DIRECTORY : `${tempWorkingDirectory}/bb`;
@@ -84,34 +84,39 @@ 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,
+  overrides: Partial<FieldsOf<GlobalVariables> & FieldsOf<CheckpointConstantData>> = {},
+) => {
+  const checkpointConstants = makeCheckpointConstants(slotNumber, overrides);
+  return GlobalVariables.from({
+    chainId: checkpointConstants.chainId,
+    version: checkpointConstants.version,
+    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,
+    ...overrides,
+  });
 };
 
-export const makeGlobals = (blockNumber: number) => {
-  return new GlobalVariables(
-    Fr.ZERO,
-    Fr.ZERO,
-    blockNumber /** block number */,
-    new Fr(blockNumber) /** slot number */,
-    BigInt(blockNumber) /** block number as pseudo-timestamp for testing */,
-    EthAddress.ZERO,
-    AztecAddress.ZERO,
-    GasFees.empty(),
-  );
+export const makeCheckpointConstants = (
+  slotNumber: number,
+  overrides: Partial<FieldsOf<CheckpointConstantData>> = {},
+) => {
+  return CheckpointConstantData.from({
+    chainId: Fr.ZERO,
+    version: Fr.ZERO,
+    vkTreeRoot: getVKTreeRoot(),
+    protocolContractsHash,
+    proverId: Fr.ZERO,
+    slotNumber: SlotNumber(slotNumber),
+    coinbase: EthAddress.ZERO,
+    feeRecipient: AztecAddress.ZERO,
+    gasFees: GasFees.empty(),
+    ...overrides,
+  });
 };