@aztec/prover-client 0.56.0 → 0.58.0

package/src/mocks/fixtures.ts

@@ -1,5 +1,7 @@
 import {
   MerkleTreeId,
+  type MerkleTreeReadOperations,
+  type MerkleTreeWriteOperations,
   type ProcessedTx,
   makeEmptyProcessedTx as makeEmptyProcessedTxFromHistoricalTreeRoots,
 } from '@aztec/circuit-types';
@@ -21,8 +23,8 @@ import { randomBytes } from '@aztec/foundation/crypto';
 import { type DebugLogger } from '@aztec/foundation/log';
 import { fileURLToPath } from '@aztec/foundation/url';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
 import { NativeACVMSimulator, type SimulationProvider, WASMSimulator } from '@aztec/simulator';
-import { type MerkleTreeOperations } from '@aztec/world-state';
 
 import * as fs from 'fs/promises';
 import path from 'path';
@@ -32,6 +34,7 @@ const {
   TEMP_DIR = '/tmp',
   BB_BINARY_PATH = '',
   BB_WORKING_DIRECTORY = '',
+  BB_SKIP_CLEANUP = '',
   NOIR_RELEASE_DIR = 'noir-repo/target/release',
   ACVM_BINARY_PATH = '',
   ACVM_WORKING_DIRECTORY = '',
@@ -56,12 +59,17 @@ export const getEnvironmentConfig = async (logger: DebugLogger) => {
     const acvmWorkingDirectory = ACVM_WORKING_DIRECTORY ? ACVM_WORKING_DIRECTORY : `${tempWorkingDirectory}/acvm`;
     await fs.mkdir(acvmWorkingDirectory, { recursive: true });
     logger.verbose(`Using native ACVM binary at ${expectedAcvmPath} with working directory ${acvmWorkingDirectory}`);
+
+    const bbSkipCleanup = ['1', 'true'].includes(BB_SKIP_CLEANUP);
+    bbSkipCleanup && logger.verbose(`Not going to clean up BB working directory ${bbWorkingDirectory} after run`);
+
     return {
       acvmWorkingDirectory,
       bbWorkingDirectory,
       expectedAcvmPath,
       expectedBBPath,
       directoryToCleanup: ACVM_WORKING_DIRECTORY && BB_WORKING_DIRECTORY ? undefined : tempWorkingDirectory,
+      bbSkipCleanup,
     };
   } catch (err) {
     logger.verbose(`Native BB not available, error: ${err}`);
@@ -89,16 +97,22 @@ export async function getSimulationProvider(
   return new WASMSimulator();
 }
 
-export const makeBloatedProcessedTx = (builderDb: MerkleTreeOperations, seed = 0x1) =>
-  makeBloatedProcessedTxWithVKRoot(builderDb, getVKTreeRoot(), seed);
+export const makeBloatedProcessedTx = (builderDb: MerkleTreeReadOperations, seed = 0x1) =>
+  makeBloatedProcessedTxWithVKRoot(builderDb, getVKTreeRoot(), protocolContractTreeRoot, seed);
 
-export const makeEmptyProcessedTx = (builderDb: MerkleTreeOperations, chainId: Fr, version: Fr) => {
+export const makeEmptyProcessedTx = (builderDb: MerkleTreeReadOperations, chainId: Fr, version: Fr) => {
   const header = builderDb.getInitialHeader();
-  return makeEmptyProcessedTxFromHistoricalTreeRoots(header, chainId, version, getVKTreeRoot());
+  return makeEmptyProcessedTxFromHistoricalTreeRoots(
+    header,
+    chainId,
+    version,
+    getVKTreeRoot(),
+    protocolContractTreeRoot,
+  );
 };
 
 // Updates the expectedDb trees based on the new note hashes, contracts, and nullifiers from these txs
-export const updateExpectedTreesFromTxs = async (db: MerkleTreeOperations, txs: ProcessedTx[]) => {
+export const updateExpectedTreesFromTxs = async (db: MerkleTreeWriteOperations, txs: ProcessedTx[]) => {
   await db.appendLeaves(
     MerkleTreeId.NOTE_HASH_TREE,
     txs.flatMap(tx =>
@@ -144,5 +158,5 @@ export const makeGlobals = (blockNumber: number) => {
   );
 };
 
-export const makeEmptyProcessedTestTx = (builderDb: MerkleTreeOperations): ProcessedTx =>
+export const makeEmptyProcessedTestTx = (builderDb: MerkleTreeReadOperations): ProcessedTx =>
   makeEmptyProcessedTx(builderDb, Fr.ZERO, Fr.ZERO);

package/src/mocks/test_context.ts

@@ -1,14 +1,21 @@
 import { type BBProverConfig } from '@aztec/bb-prover';
 import {
-  type BlockProver,
-  type MerkleTreeAdminOperations,
+  type MerkleTreeWriteOperations,
   type ProcessedTx,
+  type ProcessedTxHandler,
   type PublicExecutionRequest,
   type ServerCircuitProver,
   type Tx,
   type TxValidator,
 } from '@aztec/circuit-types';
-import { type Gas, GlobalVariables, Header, type Nullifier, type TxContext } from '@aztec/circuits.js';
+import {
+  type CombinedConstantData,
+  type Gas,
+  type GlobalVariables,
+  Header,
+  type Nullifier,
+  type TxContext,
+} from '@aztec/circuits.js';
 import { type Fr } from '@aztec/foundation/fields';
 import { type DebugLogger } from '@aztec/foundation/log';
 import { openTmpStore } from '@aztec/kv-store/utils';
@@ -28,8 +35,6 @@ import { NativeWorldStateService } from '@aztec/world-state/native';
 
 import * as fs from 'fs/promises';
 import { type MockProxy, mock } from 'jest-mock-extended';
-import { tmpdir } from 'os';
-import { join } from 'path';
 
 import { TestCircuitProver } from '../../../bb-prover/src/test/test_circuit_prover.js';
 import { ProvingOrchestrator } from '../orchestrator/index.js';
@@ -44,7 +49,7 @@ export class TestContext {
     public publicProcessor: PublicProcessor,
     public simulationProvider: SimulationProvider,
     public globalVariables: GlobalVariables,
-    public actualDb: MerkleTreeAdminOperations,
+    public actualDb: MerkleTreeWriteOperations,
     public prover: ServerCircuitProver,
     public proverAgent: ProverAgent,
     public orchestrator: ProvingOrchestrator,
@@ -53,13 +58,13 @@ export class TestContext {
     public logger: DebugLogger,
   ) {}
 
-  public get blockProver() {
+  public get epochProver() {
     return this.orchestrator;
   }
 
   static async new(
     logger: DebugLogger,
-    worldState: 'native' | 'legacy' = 'legacy',
+    worldState: 'native' | 'legacy' = 'native',
     proverCount = 4,
     createProver: (bbConfig: BBProverConfig) => Promise<ServerCircuitProver> = _ =>
       Promise.resolve(new TestCircuitProver(new NoopTelemetryClient(), new WASMSimulator())),
@@ -73,23 +78,21 @@ export class TestContext {
     const publicKernel = new RealPublicKernelCircuitSimulator(new WASMSimulator());
     const telemetry = new NoopTelemetryClient();
 
-    let actualDb: MerkleTreeAdminOperations;
+    let actualDb: MerkleTreeWriteOperations;
 
     if (worldState === 'native') {
-      const dir = await fs.mkdtemp(join(tmpdir(), 'prover-client-world-state-'));
-      directoriesToCleanup.push(dir);
-      const ws = await NativeWorldStateService.create(dir);
-      actualDb = ws.asLatest();
+      const ws = await NativeWorldStateService.tmp();
+      actualDb = await ws.fork();
     } else {
       const ws = await MerkleTrees.new(openTmpStore(), telemetry);
-      actualDb = ws.asLatest();
+      actualDb = await ws.getLatest();
     }
 
     const processor = PublicProcessor.create(
       actualDb,
       publicExecutor,
       publicKernel,
-      GlobalVariables.empty(),
+      globalVariables,
       Header.empty(),
       worldStateDB,
       telemetry,
@@ -109,11 +112,12 @@ export class TestContext {
         acvmWorkingDirectory: config.acvmWorkingDirectory,
         bbBinaryPath: config.expectedBBPath,
         bbWorkingDirectory: config.bbWorkingDirectory,
+        bbSkipCleanup: config.bbSkipCleanup,
       };
       localProver = await createProver(bbConfig);
     }
 
-    if (config?.directoryToCleanup) {
+    if (config?.directoryToCleanup && !config.bbSkipCleanup) {
       directoriesToCleanup.push(config.directoryToCleanup);
     }
 
@@ -150,12 +154,12 @@ export class TestContext {
   public async processPublicFunctions(
     txs: Tx[],
     maxTransactions: number,
-    blockProver?: BlockProver,
+    txHandler?: ProcessedTxHandler,
     txValidator?: TxValidator<ProcessedTx>,
   ) {
     const defaultExecutorImplementation = (
       execution: PublicExecutionRequest,
-      _globalVariables: GlobalVariables,
+      _constants: CombinedConstantData,
       availableGas: Gas,
       _txContext: TxContext,
       _pendingNullifiers: Nullifier[],
@@ -182,7 +186,7 @@ export class TestContext {
     return await this.processPublicFunctionsWithMockExecutorImplementation(
       txs,
       maxTransactions,
-      blockProver,
+      txHandler,
       txValidator,
       defaultExecutorImplementation,
     );
@@ -191,11 +195,11 @@ export class TestContext {
   public async processPublicFunctionsWithMockExecutorImplementation(
     txs: Tx[],
     maxTransactions: number,
-    blockProver?: BlockProver,
+    txHandler?: ProcessedTxHandler,
     txValidator?: TxValidator<ProcessedTx>,
     executorMock?: (
       execution: PublicExecutionRequest,
-      globalVariables: GlobalVariables,
+      constants: CombinedConstantData,
       availableGas: Gas,
       txContext: TxContext,
       pendingNullifiers: Nullifier[],
@@ -206,6 +210,6 @@ export class TestContext {
     if (executorMock) {
       this.publicExecutor.simulate.mockImplementation(executorMock);
     }
-    return await this.publicProcessor.process(txs, maxTransactions, blockProver, txValidator);
+    return await this.publicProcessor.process(txs, maxTransactions, txHandler, txValidator);
   }
 }

package/src/orchestrator/block-building-helpers.ts

@@ -1,4 +1,11 @@
-import { type Body, MerkleTreeId, type ProcessedTx, TxEffect, getTreeHeight } from '@aztec/circuit-types';
+import {
+  type Body,
+  MerkleTreeId,
+  type MerkleTreeWriteOperations,
+  type ProcessedTx,
+  TxEffect,
+  getTreeHeight,
+} from '@aztec/circuit-types';
 import {
   ARCHIVE_HEIGHT,
   AppendOnlyTreeSnapshot,
@@ -52,8 +59,9 @@ import { type DebugLogger } from '@aztec/foundation/log';
 import { type Tuple, assertLength, toFriendlyJSON } from '@aztec/foundation/serialize';
 import { computeUnbalancedMerkleRoot } from '@aztec/foundation/trees';
 import { getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
 import { HintsBuilder, computeFeePayerBalanceLeafSlot } from '@aztec/simulator';
-import { type MerkleTreeOperations } from '@aztec/world-state';
+import { type MerkleTreeReadOperations } from '@aztec/world-state';
 
 import { inspect } from 'util';
 
@@ -71,7 +79,7 @@ export async function buildBaseRollupInput(
   tx: ProcessedTx,
   proof: RecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>,
   globalVariables: GlobalVariables,
-  db: MerkleTreeOperations,
+  db: MerkleTreeWriteOperations,
   kernelVk: VerificationKeyData,
 ) {
   // Get trees info before any changes hit
@@ -251,7 +259,7 @@ export async function buildHeaderFromTxEffects(
   body: Body,
   globalVariables: GlobalVariables,
   l1ToL2Messages: Fr[],
-  db: MerkleTreeOperations,
+  db: MerkleTreeReadOperations,
 ) {
   const stateReference = new StateReference(
     await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db),
@@ -291,7 +299,7 @@ export async function buildHeaderFromTxEffects(
 export async function validateBlockRootOutput(
   blockRootOutput: BlockRootOrBlockMergePublicInputs,
   blockHeader: Header,
-  db: MerkleTreeOperations,
+  db: MerkleTreeReadOperations,
 ) {
   await Promise.all([
     validateState(blockHeader.state, db),
@@ -299,7 +307,7 @@ export async function validateBlockRootOutput(
   ]);
 }
 
-export async function validateState(state: StateReference, db: MerkleTreeOperations) {
+export async function validateState(state: StateReference, db: MerkleTreeReadOperations) {
   const promises = [MerkleTreeId.NOTE_HASH_TREE, MerkleTreeId.NULLIFIER_TREE, MerkleTreeId.PUBLIC_DATA_TREE].map(
     async (id: MerkleTreeId) => {
       return { key: id, value: await getTreeSnapshot(id, db) };
@@ -316,7 +324,7 @@ export async function validateState(state: StateReference, db: MerkleTreeOperati
   );
 }
 
-export async function getRootTreeSiblingPath<TID extends MerkleTreeId>(treeId: TID, db: MerkleTreeOperations) {
+export async function getRootTreeSiblingPath<TID extends MerkleTreeId>(treeId: TID, db: MerkleTreeReadOperations) {
   const { size } = await db.getTreeInfo(treeId);
   const path = await db.getSiblingPath(treeId, size);
   return padArrayEnd(path.toFields(), Fr.ZERO, getTreeHeight(treeId));
@@ -375,16 +383,17 @@ export function getPreviousRollupBlockDataFromPublicInputs(
 
 export async function getConstantRollupData(
   globalVariables: GlobalVariables,
-  db: MerkleTreeOperations,
+  db: MerkleTreeReadOperations,
 ): Promise<ConstantRollupData> {
   return ConstantRollupData.from({
     vkTreeRoot: getVKTreeRoot(),
+    protocolContractTreeRoot,
     lastArchive: await getTreeSnapshot(MerkleTreeId.ARCHIVE, db),
     globalVariables,
   });
 }
 
-export async function getTreeSnapshot(id: MerkleTreeId, db: MerkleTreeOperations): Promise<AppendOnlyTreeSnapshot> {
+export async function getTreeSnapshot(id: MerkleTreeId, db: MerkleTreeReadOperations): Promise<AppendOnlyTreeSnapshot> {
   const treeInfo = await db.getTreeInfo(id);
   return new AppendOnlyTreeSnapshot(Fr.fromBuffer(treeInfo.root), Number(treeInfo.size));
 }
@@ -414,7 +423,7 @@ export function makeEmptyMembershipWitness<N extends number>(height: N) {
   );
 }
 
-export async function processPublicDataUpdateRequests(tx: ProcessedTx, db: MerkleTreeOperations) {
+export async function processPublicDataUpdateRequests(tx: ProcessedTx, db: MerkleTreeWriteOperations) {
   const allPublicDataUpdateRequests = padArrayEnd(
     tx.finalPublicDataUpdateRequests,
     PublicDataUpdateRequest.empty(),
@@ -482,7 +491,7 @@ export async function processPublicDataUpdateRequests(tx: ProcessedTx, db: Merkl
 export async function getSubtreeSiblingPath(
   treeId: MerkleTreeId,
   subtreeHeight: number,
-  db: MerkleTreeOperations,
+  db: MerkleTreeReadOperations,
 ): Promise<Fr[]> {
   const nextAvailableLeafIndex = await db.getTreeInfo(treeId).then(t => t.size);
   const fullSiblingPath = await db.getSiblingPath(treeId, nextAvailableLeafIndex);
@@ -496,7 +505,7 @@ export async function getMembershipWitnessFor<N extends number>(
   value: Fr,
   treeId: MerkleTreeId,
   height: N,
-  db: MerkleTreeOperations,
+  db: MerkleTreeReadOperations,
 ): Promise<MembershipWitness<N>> {
   // If this is an empty tx, then just return zeroes
   if (value.isZero()) {

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

@@ -1,4 +1,4 @@
-import { type L2Block, type MerkleTreeId, type ProvingResult } from '@aztec/circuit-types';
+import { type L2Block, type MerkleTreeId } from '@aztec/circuit-types';
 import {
   type ARCHIVE_HEIGHT,
   type AppendOnlyTreeSnapshot,
@@ -18,14 +18,9 @@ import {
 } from '@aztec/circuits.js';
 import { type Tuple } from '@aztec/foundation/serialize';
 
+import { type EpochProvingState } from './epoch-proving-state.js';
 import { type TxProvingState } from './tx-proving-state.js';
 
-enum PROVING_STATE_LIFECYCLE {
-  PROVING_STATE_CREATED,
-  PROVING_STATE_RESOLVED,
-  PROVING_STATE_REJECTED,
-}
-
 export type MergeRollupInputData = {
   inputs: [BaseOrMergeRollupPublicInputs | undefined, BaseOrMergeRollupPublicInputs | undefined];
   proofs: [
@@ -46,11 +41,11 @@ export class BlockProvingState {
   private rootParityInputs: Array<RootParityInput<typeof RECURSIVE_PROOF_LENGTH> | undefined> = [];
   private finalRootParityInputs: RootParityInput<typeof NESTED_RECURSIVE_PROOF_LENGTH> | undefined;
   public blockRootRollupPublicInputs: BlockRootOrBlockMergePublicInputs | undefined;
+  public blockRootRollupStarted: boolean = false;
   public finalProof: Proof | undefined;
   public block: L2Block | undefined;
   private txs: TxProvingState[] = [];
-
-  private provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED;
+  public error: string | undefined;
 
   constructor(
     public readonly index: number,
@@ -63,8 +58,7 @@ export class BlockProvingState {
     public readonly archiveTreeSnapshot: AppendOnlyTreeSnapshot,
     public readonly archiveTreeRootSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
     public readonly previousBlockHash: Fr,
-    private completionCallback?: (result: ProvingResult) => void,
-    private rejectionCallback?: (reason: string) => void,
+    private readonly parentEpoch: EpochProvingState,
   ) {
     this.rootParityInputs = Array.from({ length: NUM_BASE_PARITY_PER_ROOT_PARITY }).map(_ => undefined);
   }
@@ -188,6 +182,7 @@ export class BlockProvingState {
   // Returns true if we have sufficient inputs to execute the block root rollup
   public isReadyForBlockRootRollup() {
     return !(
+      this.block === undefined ||
       this.mergeRollupInputs[0] === undefined ||
       this.finalRootParityInput === undefined ||
       this.mergeRollupInputs[0].inputs.findIndex(p => !p) !== -1
@@ -206,35 +201,16 @@ export class BlockProvingState {
 
   // Returns true if we are still able to accept transactions, false otherwise
   public isAcceptingTransactions() {
-    return (
-      this.provingStateLifecycle === PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED && this.totalNumTxs > this.txs.length
-    );
+    return this.totalNumTxs > this.txs.length;
   }
 
-  // Returns true if this proving state is still valid, false otherwise
+  // Returns whether the proving state is still valid
   public verifyState() {
-    return this.provingStateLifecycle === PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED;
+    return this.parentEpoch.verifyState();
   }
 
-  // Attempts to reject the proving state promise with the given reason
   public reject(reason: string) {
-    if (!this.verifyState()) {
-      return;
-    }
-    this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_REJECTED;
-    if (this.rejectionCallback) {
-      this.rejectionCallback(reason);
-    }
-  }
-
-  // Attempts to resolve the proving state promise with the given result
-  public resolve(result: ProvingResult) {
-    if (!this.verifyState()) {
-      return;
-    }
-    this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_RESOLVED;
-    if (this.completionCallback) {
-      this.completionCallback(result);
-    }
+    this.error = reason;
+    this.parentEpoch.reject(reason);
   }
 }

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

@@ -1,4 +1,4 @@
-import { type MerkleTreeId, type ProvingResult } from '@aztec/circuit-types';
+import { type MerkleTreeId } from '@aztec/circuit-types';
 import {
   type ARCHIVE_HEIGHT,
   type AppendOnlyTreeSnapshot,
@@ -36,6 +36,8 @@ export type BlockMergeRollupInputData = {
   verificationKeys: [VerificationKeyAsFields | undefined, VerificationKeyAsFields | undefined];
 };
 
+export type ProvingResult = { status: 'success' } | { status: 'failure'; reason: string };
+
 /**
  * The current state of the proving schedule for an epoch.
  * Contains the raw inputs and intermediate state to generate every constituent proof in the tree.
@@ -59,18 +61,20 @@ export class EpochProvingState {
 
   /** Returns the current block proving state */
   public get currentBlock(): BlockProvingState | undefined {
-    return this.blocks[this.blocks.length - 1];
+    return this.blocks.at(-1);
   }
 
   // Returns the number of levels of merge rollups
   public get numMergeLevels() {
-    return BigInt(Math.ceil(Math.log2(this.totalNumBlocks)) - 1);
+    const totalLeaves = Math.max(2, this.totalNumBlocks);
+    return BigInt(Math.ceil(Math.log2(totalLeaves)) - 1);
   }
 
   // Calculates the index and level of the parent rollup circuit
   // Based on tree implementation in unbalanced_tree.ts -> batchInsert()
   // REFACTOR: This is repeated from the block orchestrator
   public findMergeLevel(currentLevel: bigint, currentIndex: bigint) {
+    const totalLeaves = Math.max(2, this.totalNumBlocks);
     const moveUpMergeLevel = (levelSize: number, index: bigint, nodeToShift: boolean) => {
       levelSize /= 2;
       if (levelSize & 1) {
@@ -79,8 +83,7 @@ export class EpochProvingState {
       index >>= 1n;
       return { thisLevelSize: levelSize, thisIndex: index, shiftUp: nodeToShift };
     };
-    let [thisLevelSize, shiftUp] =
-      this.totalNumBlocks & 1 ? [this.totalNumBlocks - 1, true] : [this.totalNumBlocks, false];
+    let [thisLevelSize, shiftUp] = totalLeaves & 1 ? [totalLeaves - 1, true] : [totalLeaves, false];
     const maxLevel = this.numMergeLevels + 1n;
     let placeholder = currentIndex;
     for (let i = 0; i < maxLevel - currentLevel; i++) {
@@ -107,8 +110,6 @@ export class EpochProvingState {
     archiveTreeSnapshot: AppendOnlyTreeSnapshot,
     archiveTreeRootSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
     previousBlockHash: Fr,
-    completionCallback?: (result: ProvingResult) => void,
-    rejectionCallback?: (reason: string) => void,
   ) {
     const block = new BlockProvingState(
       this.blocks.length,
@@ -121,15 +122,7 @@ export class EpochProvingState {
       archiveTreeSnapshot,
       archiveTreeRootSiblingPath,
       previousBlockHash,
-      completionCallback,
-      reason => {
-        // Reject the block
-        if (rejectionCallback) {
-          rejectionCallback(reason);
-        }
-        // An error on any block rejects this whole epoch
-        this.reject(reason);
-      },
+      this,
     );
     this.blocks.push(block);
     if (this.blocks.length === this.totalNumBlocks) {
@@ -214,10 +207,6 @@ export class EpochProvingState {
     }
     this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_REJECTED;
     this.rejectionCallback(reason);
-
-    for (const block of this.blocks) {
-      block.reject('Proving cancelled');
-    }
   }
 
   // Attempts to resolve the proving state promise with the given result