@aztec/prover-client 0.0.0-test.1 → 0.0.1-commit.21caa21

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@aztec/prover-client",
-  "version": "0.0.0-test.1",
+  "version": "0.0.1-commit.21caa21",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
-    "./block-builder": "./dest/block_builder/index.js",
+    "./block-factory": "./dest/block-factory/index.js",
     "./broker": "./dest/proving_broker/index.js",
     "./orchestrator": "./dest/orchestrator/index.js",
     "./helpers": "./dest/orchestrator/block-building-helpers.js",
@@ -22,15 +22,12 @@
     "./package.local.json"
   ],
   "scripts": {
-    "build": "yarn clean && tsc -b",
-    "build:dev": "tsc -b --watch",
+    "build": "yarn clean && tsgo -b",
+    "build:dev": "tsgo -b --watch",
     "clean": "rm -rf ./dest .tsbuildinfo",
-    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
-    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
     "bb": "node --no-warnings ./dest/bb/index.js",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --testTimeout=3500000 --forceExit",
-    "test:debug": "LOG_LEVEL=debug NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --testTimeout=1500000 --forceExit --testNamePattern prover/bb_prover/parity",
-    "get-proof-inputs": "node --no-warnings ./dest/bin/get-proof-inputs.js"
+    "test:debug": "LOG_LEVEL=debug NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --testTimeout=1500000 --forceExit --testNamePattern prover/bb_prover/parity"
   },
   "jest": {
     "moduleNameMapper": {
@@ -63,42 +60,46 @@
     "testTimeout": 120000,
     "setupFiles": [
       "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "0.0.0-test.1",
-    "@aztec/blob-lib": "0.0.0-test.1",
-    "@aztec/constants": "0.0.0-test.1",
-    "@aztec/ethereum": "0.0.0-test.1",
-    "@aztec/foundation": "0.0.0-test.1",
-    "@aztec/kv-store": "0.0.0-test.1",
-    "@aztec/noir-protocol-circuits-types": "0.0.0-test.1",
-    "@aztec/protocol-contracts": "0.0.0-test.1",
-    "@aztec/simulator": "0.0.0-test.1",
-    "@aztec/stdlib": "0.0.0-test.1",
-    "@aztec/telemetry-client": "0.0.0-test.1",
-    "@aztec/world-state": "0.0.0-test.1",
+    "@aztec/bb-prover": "0.0.1-commit.21caa21",
+    "@aztec/blob-lib": "0.0.1-commit.21caa21",
+    "@aztec/constants": "0.0.1-commit.21caa21",
+    "@aztec/ethereum": "0.0.1-commit.21caa21",
+    "@aztec/foundation": "0.0.1-commit.21caa21",
+    "@aztec/kv-store": "0.0.1-commit.21caa21",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.21caa21",
+    "@aztec/noir-types": "0.0.1-commit.21caa21",
+    "@aztec/protocol-contracts": "0.0.1-commit.21caa21",
+    "@aztec/simulator": "0.0.1-commit.21caa21",
+    "@aztec/stdlib": "0.0.1-commit.21caa21",
+    "@aztec/telemetry-client": "0.0.1-commit.21caa21",
+    "@aztec/world-state": "0.0.1-commit.21caa21",
     "@google-cloud/storage": "^7.15.0",
     "@iarna/toml": "^2.2.5",
     "commander": "^12.1.0",
     "lodash.chunk": "^4.2.0",
     "source-map-support": "^0.5.21",
     "tslib": "^2.4.0",
-    "zod": "^3.23.8",
-    "@aztec/noir-types": "0.0.0-test.1"
+    "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@aztec/noir-contracts.js": "0.0.0-test.1",
-    "@jest/globals": "^29.5.0",
-    "@types/jest": "^29.5.0",
-    "@types/memdown": "^3.0.0",
-    "@types/node": "^18.7.23",
+    "@aztec/noir-contracts.js": "0.0.1-commit.21caa21",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.15.17",
     "@types/source-map-support": "^0.5.10",
+    "@typescript/native-preview": "7.0.0-dev.20251126.1",
     "get-port": "^7.1.0",
-    "jest": "^29.5.0",
-    "jest-mock-extended": "^3.0.3",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.3.3"
   },
   "files": [
     "dest",
@@ -107,6 +108,6 @@
   ],
   "types": "./dest/index.d.ts",
   "engines": {
-    "node": ">=18"
+    "node": ">=20.10"
   }
 }

package/src/block-factory/index.ts

@@ -0,0 +1 @@
+export * from './light.js';

package/src/block-factory/light.ts

@@ -0,0 +1,137 @@
+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 { createLogger } from '@aztec/foundation/log';
+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 { ContentCommitment, type GlobalVariables, type ProcessedTx } from '@aztec/stdlib/tx';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import {
+  buildHeaderAndBodyFromTxs,
+  getTreeSnapshot,
+  insertSideEffects,
+} from '../orchestrator/block-building-helpers.js';
+
+/**
+ * Builds a block and its header from a set of processed tx without running any circuits.
+ *
+ * NOTE: the onus is ON THE CALLER to update the db that is passed in with the notes hashes, nullifiers, etc
+ * PRIOR to calling `buildBlock`.
+ *
+ * Why? Because if you are, e.g. building a block in practice from TxObjects, you are using the
+ * 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 `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 txs: ProcessedTx[] | undefined;
+
+  private readonly logger = createLogger('lightweight-block-factory');
+
+  constructor(
+    private db: MerkleTreeWriteOperations,
+    private telemetry: TelemetryClient = getTelemetryClient(),
+  ) {}
+
+  async startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[]): Promise<void> {
+    this.logger.debug('Starting new block', { globalVariables: globalVariables.toInspect(), l1ToL2Messages });
+    this.globalVariables = globalVariables;
+    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!);
+  }
+
+  addTxs(txs: ProcessedTx[]): Promise<void> {
+    // Most times, `addTxs` is only called once per block.
+    // So avoid copies.
+    if (this.txs === undefined) {
+      this.txs = txs;
+    } else {
+      this.txs.push(...txs);
+    }
+    return Promise.resolve();
+  }
+
+  setBlockCompleted(): Promise<L2Block> {
+    return this.buildBlock();
+  }
+
+  private async buildBlock(): Promise<L2Block> {
+    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!,
+      startSpongeBlob,
+      true,
+    );
+
+    header.state.validate();
+
+    await this.db.updateArchive(header);
+    const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db);
+
+    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(),
+      archiveRoot: newArchive.root.toString(),
+      stateReference: header.state.toInspect(),
+      blockHash: (await block.hash()).toString(),
+      txs: block.body.txEffects.map(tx => tx.txHash.toString()),
+    });
+
+    return block;
+  }
+}
+
+/**
+ * Inserts the processed transactions into the DB, then creates a block.
+ * @param db - A db fork to use for block building which WILL BE MODIFIED.
+ */
+export async function buildBlockWithCleanDB(
+  txs: ProcessedTx[],
+  globalVariables: GlobalVariables,
+  l1ToL2Messages: Fr[],
+  db: MerkleTreeWriteOperations,
+  telemetry: TelemetryClient = getTelemetryClient(),
+) {
+  const builder = new LightweightBlockFactory(db, telemetry);
+  await builder.startNewBlock(globalVariables, l1ToL2Messages);
+
+  for (const tx of txs) {
+    await insertSideEffects(tx, db);
+  }
+  await builder.addTxs(txs);
+
+  return await builder.setBlockCompleted();
+}

package/src/config.ts

@@ -1,5 +1,10 @@
 import type { ACVMConfig, BBConfig } from '@aztec/bb-prover';
-import { type ConfigMappingsType, booleanConfigHelper, getConfigFromMappings } from '@aztec/foundation/config';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getConfigFromMappings,
+  numberConfigHelper,
+} from '@aztec/foundation/config';
 import { type ProverConfig, proverConfigMappings } from '@aztec/stdlib/interfaces/server';
 
 import {
@@ -9,10 +14,11 @@ import {
   proverBrokerConfigMappings,
 } from './proving_broker/config.js';
 
-/**
- * The prover configuration.
- */
-export type ProverClientConfig = ProverConfig & ProverAgentConfig & ProverBrokerConfig & BBConfig & ACVMConfig;
+/** The prover configuration as defined by the user. */
+export type ProverClientUserConfig = ProverConfig & ProverAgentConfig & ProverBrokerConfig & BBConfig & ACVMConfig;
+
+/** The prover configuration with all missing fields resolved. */
+export type ProverClientConfig = ProverClientUserConfig & Required<Pick<ProverClientUserConfig, 'proverId'>>;
 
 export const bbConfigMappings: ConfigMappingsType<BBConfig & ACVMConfig> = {
   acvmWorkingDirectory: {
@@ -36,9 +42,19 @@ export const bbConfigMappings: ConfigMappingsType<BBConfig & ACVMConfig> = {
     description: 'Whether to skip cleanup of bb temporary files',
     ...booleanConfigHelper(false),
   },
+  numConcurrentIVCVerifiers: {
+    env: 'BB_NUM_IVC_VERIFIERS',
+    description: 'Max number of chonk verifiers to run concurrently',
+    ...numberConfigHelper(8),
+  },
+  bbIVCConcurrency: {
+    env: 'BB_IVC_CONCURRENCY',
+    description: 'Number of threads to use for IVC verification',
+    ...numberConfigHelper(1),
+  },
 };
 
-export const proverClientConfigMappings: ConfigMappingsType<ProverClientConfig> = {
+export const proverClientConfigMappings: ConfigMappingsType<ProverClientUserConfig> = {
   ...bbConfigMappings,
   ...proverConfigMappings,
   ...proverAgentConfigMappings,
@@ -50,6 +66,6 @@ export const proverClientConfigMappings: ConfigMappingsType<ProverClientConfig>
  * Note: If an environment variable is not set, the default value is used.
  * @returns The prover configuration.
  */
-export function getProverEnvVars(): ProverClientConfig {
-  return getConfigFromMappings<ProverClientConfig>(proverClientConfigMappings);
+export function getProverEnvVars(): ProverClientUserConfig {
+  return getConfigFromMappings<ProverClientUserConfig>(proverClientConfigMappings);
 }

package/src/light/lightweight_checkpoint_builder.ts

@@ -0,0 +1,142 @@
+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 { 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: number,
+    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: number,
+    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 block = new L2BlockNew(newArchive, header, body);
+    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,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 { SlotNumber } from '@aztec/foundation/branded-types';
 import { randomBytes } from '@aztec/foundation/crypto';
 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 { NativeACVMSimulator, type SimulationProvider, WASMSimulatorWithBlobs } from '@aztec/simulator/server';
+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`;
@@ -64,10 +64,10 @@ export const getEnvironmentConfig = async (logger: Logger) => {
   }
 };
 
-export async function getSimulationProvider(
+export async function getSimulator(
   config: { acvmWorkingDirectory: string | undefined; acvmBinaryPath: string | undefined },
   logger?: Logger,
-): Promise<SimulationProvider> {
+): Promise<CircuitSimulator> {
   if (config.acvmBinaryPath && config.acvmWorkingDirectory) {
     try {
       await fs.access(config.acvmBinaryPath, fs.constants.R_OK);
@@ -84,34 +84,39 @@ export async function getSimulationProvider(
   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 /** 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,
-    new Fr(blockNumber) /** block number */,
-    new Fr(blockNumber) /** slot number */,
-    new Fr(blockNumber) /** timestamp */,
-    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,
+  });
 };