@aztec/prover-client 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@aztec/prover-client",
-  "version": "0.0.0-test.1",
+  "version": "0.0.1-commit.023c3e5",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
-    "./block-builder": "./dest/block_builder/index.js",
     "./broker": "./dest/proving_broker/index.js",
+    "./broker/config": "./dest/proving_broker/config.js",
     "./orchestrator": "./dest/orchestrator/index.js",
     "./helpers": "./dest/orchestrator/block-building-helpers.js",
+    "./light": "./dest/light/index.js",
     "./config": "./dest/config.js"
   },
   "typedocOptions": {
@@ -22,15 +23,12 @@
     "./package.local.json"
   ],
   "scripts": {
-    "build": "yarn clean && tsc -b",
-    "build:dev": "tsc -b --watch",
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --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 +61,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.023c3e5",
+    "@aztec/blob-lib": "0.0.1-commit.023c3e5",
+    "@aztec/constants": "0.0.1-commit.023c3e5",
+    "@aztec/ethereum": "0.0.1-commit.023c3e5",
+    "@aztec/foundation": "0.0.1-commit.023c3e5",
+    "@aztec/kv-store": "0.0.1-commit.023c3e5",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.023c3e5",
+    "@aztec/noir-types": "0.0.1-commit.023c3e5",
+    "@aztec/protocol-contracts": "0.0.1-commit.023c3e5",
+    "@aztec/simulator": "0.0.1-commit.023c3e5",
+    "@aztec/stdlib": "0.0.1-commit.023c3e5",
+    "@aztec/telemetry-client": "0.0.1-commit.023c3e5",
+    "@aztec/world-state": "0.0.1-commit.023c3e5",
     "@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.023c3e5",
+    "@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.20260113.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 +109,6 @@
   ],
   "types": "./dest/index.d.ts",
   "engines": {
-    "node": ">=18"
+    "node": ">=20.10"
   }
 }

package/src/config.ts

@@ -1,6 +1,11 @@
 import type { ACVMConfig, BBConfig } from '@aztec/bb-prover';
-import { type ConfigMappingsType, booleanConfigHelper, getConfigFromMappings } from '@aztec/foundation/config';
-import { type ProverConfig, proverConfigMappings } from '@aztec/stdlib/interfaces/server';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getConfigFromMappings,
+  numberConfigHelper,
+} from '@aztec/foundation/config';
+import { type ProverConfig, proverConfigMappings } from '@aztec/stdlib/interfaces/prover-config';
 
 import {
   type ProverAgentConfig,
@@ -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/index.ts

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

package/src/light/lightweight_checkpoint_builder.ts

@@ -0,0 +1,289 @@
+import { SpongeBlob, computeBlobsHashFromBlobs, encodeCheckpointEndMarker, getBlobsPerL1Block } from '@aztec/blob-lib';
+import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { type CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { L2Block } from '@aztec/stdlib/block';
+import { Checkpoint } from '@aztec/stdlib/checkpoint';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import {
+  accumulateCheckpointOutHashes,
+  computeCheckpointOutHash,
+  computeInHashFromL1ToL2Messages,
+} from '@aztec/stdlib/messaging';
+import { CheckpointHeader, computeBlockHeadersHash } from '@aztec/stdlib/rollup';
+import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import {
+  type CheckpointGlobalVariables,
+  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: Logger;
+
+  private lastArchives: AppendOnlyTreeSnapshot[] = [];
+  private spongeBlob: SpongeBlob;
+  private blocks: L2Block[] = [];
+  private blobFields: Fr[] = [];
+
+  constructor(
+    public readonly checkpointNumber: CheckpointNumber,
+    public readonly constants: CheckpointGlobalVariables,
+    public readonly l1ToL2Messages: Fr[],
+    private readonly previousCheckpointOutHashes: Fr[],
+    public readonly db: MerkleTreeWriteOperations,
+    bindings?: LoggerBindings,
+  ) {
+    this.logger = createLogger('checkpoint-builder', {
+      ...bindings,
+      instanceId: `checkpoint-${checkpointNumber}`,
+    });
+    this.spongeBlob = SpongeBlob.init();
+    this.logger.debug('Starting new checkpoint', { constants, l1ToL2Messages });
+  }
+
+  static async startNewCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    constants: CheckpointGlobalVariables,
+    l1ToL2Messages: Fr[],
+    previousCheckpointOutHashes: Fr[],
+    db: MerkleTreeWriteOperations,
+    bindings?: LoggerBindings,
+  ): 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,
+      previousCheckpointOutHashes,
+      db,
+      bindings,
+    );
+  }
+
+  /**
+   * Resumes building a checkpoint from existing blocks. This is used for validator re-execution
+   * where blocks have already been built and their effects are already in the database.
+   * Unlike startNewCheckpoint, this does NOT append l1ToL2Messages to the tree since they
+   * were already added when the blocks were originally built.
+   */
+  static async resumeCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    constants: CheckpointGlobalVariables,
+    l1ToL2Messages: Fr[],
+    previousCheckpointOutHashes: Fr[],
+    db: MerkleTreeWriteOperations,
+    existingBlocks: L2Block[],
+    bindings?: LoggerBindings,
+  ): Promise<LightweightCheckpointBuilder> {
+    const builder = new LightweightCheckpointBuilder(
+      checkpointNumber,
+      constants,
+      l1ToL2Messages,
+      previousCheckpointOutHashes,
+      db,
+      bindings,
+    );
+
+    builder.logger.debug('Resuming checkpoint from existing blocks', {
+      checkpointNumber,
+      numExistingBlocks: existingBlocks.length,
+      blockNumbers: existingBlocks.map(b => b.header.getBlockNumber()),
+    });
+
+    // Validate block order and consistency
+    for (let i = 1; i < existingBlocks.length; i++) {
+      const prev = existingBlocks[i - 1];
+      const curr = existingBlocks[i];
+      if (curr.number !== prev.number + 1) {
+        throw new Error(`Non-sequential block numbers in resumeCheckpoint: ${prev.number} -> ${curr.number}`);
+      }
+      if (!prev.archive.root.equals(curr.header.lastArchive.root)) {
+        throw new Error(`Archive root mismatch between blocks ${prev.number} and ${curr.number}`);
+      }
+    }
+
+    for (let i = 0; i < existingBlocks.length; i++) {
+      const block = existingBlocks[i];
+      const isFirstBlock = i === 0;
+
+      if (isFirstBlock) {
+        builder.lastArchives.push(block.header.lastArchive);
+      }
+
+      builder.lastArchives.push(block.archive);
+
+      const blockBlobFields = block.toBlobFields();
+      await builder.spongeBlob.absorb(blockBlobFields);
+      builder.blobFields.push(...blockBlobFields);
+
+      builder.blocks.push(block);
+    }
+
+    return builder;
+  }
+
+  /** Returns how many blocks have been added to this checkpoint so far */
+  public getBlockCount() {
+    return this.blocks.length;
+  }
+
+  /**
+   * 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<L2Block> {
+    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 = IndexWithinCheckpoint(this.blocks.length);
+    const block = new L2Block(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 { slotNumber, coinbase, feeRecipient, gasFees } = this.constants;
+    const checkpointOutHash = computeCheckpointOutHash(
+      blocks.map(block => block.body.txEffects.map(tx => tx.l2ToL1Msgs)),
+    );
+    const epochOutHash = accumulateCheckpointOutHashes([...this.previousCheckpointOutHashes, checkpointOutHash]);
+
+    // 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,
+      blobsHash,
+      inHash,
+      epochOutHash,
+      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.previousCheckpointOutHashes],
+      this.db,
+      this.logger.getBindings(),
+    );
+    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 { 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);
@@ -75,7 +75,8 @@ export async function getSimulationProvider(
       logger?.info(
         `Using native ACVM at ${config.acvmBinaryPath} and working directory ${config.acvmWorkingDirectory}`,
       );
-      return new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath);
+      const acvmLogger = logger?.createChild('acvm-native');
+      return new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath, undefined, acvmLogger);
     } catch {
       logger?.warn(`Failed to access ACVM at ${config.acvmBinaryPath}, falling back to WASM`);
     }
@@ -84,34 +85,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: 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,
-    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,
+  });
 };