@aztec/prover-client 0.55.1 → 0.56.0

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@aztec/prover-client",
-  "version": "0.55.1",
+  "version": "0.56.0",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
     "./prover-agent": "./dest/prover-agent/index.js",
-    "./orchestrator": "./dest/orchestrator/index.js"
+    "./orchestrator": "./dest/orchestrator/index.js",
+    "./helpers": "./dest/orchestrator/block-building-helpers.js"
   },
   "typedocOptions": {
     "entryPoints": [
@@ -59,15 +60,15 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "0.55.1",
-    "@aztec/circuit-types": "0.55.1",
-    "@aztec/circuits.js": "0.55.1",
-    "@aztec/foundation": "0.55.1",
-    "@aztec/kv-store": "0.55.1",
-    "@aztec/noir-protocol-circuits-types": "0.55.1",
-    "@aztec/simulator": "0.55.1",
-    "@aztec/telemetry-client": "0.55.1",
-    "@aztec/world-state": "0.55.1",
+    "@aztec/bb-prover": "0.56.0",
+    "@aztec/circuit-types": "0.56.0",
+    "@aztec/circuits.js": "0.56.0",
+    "@aztec/foundation": "0.56.0",
+    "@aztec/kv-store": "0.56.0",
+    "@aztec/noir-protocol-circuits-types": "0.56.0",
+    "@aztec/simulator": "0.56.0",
+    "@aztec/telemetry-client": "0.56.0",
+    "@aztec/world-state": "0.56.0",
     "@noir-lang/types": "portal:../../noir/packages/types",
     "commander": "^12.1.0",
     "lodash.chunk": "^4.2.0",

package/src/mocks/fixtures.ts

@@ -2,29 +2,20 @@ import {
   MerkleTreeId,
   type ProcessedTx,
   makeEmptyProcessedTx as makeEmptyProcessedTxFromHistoricalTreeRoots,
-  makeProcessedTx,
-  mockTx,
 } from '@aztec/circuit-types';
+import { makeBloatedProcessedTx as makeBloatedProcessedTxWithVKRoot } from '@aztec/circuit-types/test';
 import {
   AztecAddress,
   EthAddress,
   Fr,
   GasFees,
   GlobalVariables,
-  KernelCircuitPublicInputs,
-  LogHash,
-  MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
-  MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   NULLIFIER_TREE_HEIGHT,
   PUBLIC_DATA_SUBTREE_HEIGHT,
   PublicDataTreeLeaf,
-  PublicDataUpdateRequest,
-  ScopedLogHash,
 } from '@aztec/circuits.js';
-import { fr, makeScopedL2ToL1Message } from '@aztec/circuits.js/testing';
-import { makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { type DebugLogger } from '@aztec/foundation/log';
@@ -98,43 +89,8 @@ export async function getSimulationProvider(
   return new WASMSimulator();
 }
 
-export const makeBloatedProcessedTx = (builderDb: MerkleTreeOperations, seed = 0x1) => {
-  seed *= MAX_NULLIFIERS_PER_TX; // Ensure no clashing given incremental seeds
-  const tx = mockTx(seed);
-  const kernelOutput = KernelCircuitPublicInputs.empty();
-  kernelOutput.constants.vkTreeRoot = getVKTreeRoot();
-  kernelOutput.constants.historicalHeader = builderDb.getInitialHeader();
-  kernelOutput.end.publicDataUpdateRequests = makeTuple(
-    MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-    i => new PublicDataUpdateRequest(fr(i), fr(i + 10), i + 20),
-    seed + 0x500,
-  );
-  kernelOutput.end.publicDataUpdateRequests = makeTuple(
-    MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-    i => new PublicDataUpdateRequest(fr(i), fr(i + 10), i + 20),
-    seed + 0x600,
-  );
-
-  const processedTx = makeProcessedTx(tx, kernelOutput, []);
-
-  processedTx.data.end.noteHashes = makeTuple(MAX_NOTE_HASHES_PER_TX, fr, seed + 0x100);
-  processedTx.data.end.nullifiers = makeTuple(MAX_NULLIFIERS_PER_TX, fr, seed + 0x100000);
-
-  processedTx.data.end.nullifiers[tx.data.forPublic!.end.nullifiers.length - 1] = Fr.zero();
-
-  processedTx.data.end.l2ToL1Msgs = makeTuple(MAX_L2_TO_L1_MSGS_PER_TX, makeScopedL2ToL1Message, seed + 0x300);
-  processedTx.noteEncryptedLogs.unrollLogs().forEach((log, i) => {
-    processedTx.data.end.noteEncryptedLogsHashes[i] = new LogHash(Fr.fromBuffer(log.hash()), 0, new Fr(log.length));
-  });
-  processedTx.encryptedLogs.unrollLogs().forEach((log, i) => {
-    processedTx.data.end.encryptedLogsHashes[i] = new ScopedLogHash(
-      new LogHash(Fr.fromBuffer(log.hash()), 0, new Fr(log.length)),
-      log.maskedContractAddress,
-    );
-  });
-
-  return processedTx;
-};
+export const makeBloatedProcessedTx = (builderDb: MerkleTreeOperations, seed = 0x1) =>
+  makeBloatedProcessedTxWithVKRoot(builderDb, getVKTreeRoot(), seed);
 
 export const makeEmptyProcessedTx = (builderDb: MerkleTreeOperations, chainId: Fr, version: Fr) => {
   const header = builderDb.getInitialHeader();
@@ -179,9 +135,9 @@ export const makeGlobals = (blockNumber: number) => {
   return new GlobalVariables(
     Fr.ZERO,
     Fr.ZERO,
-    new Fr(blockNumber),
+    new Fr(blockNumber) /** block number */,
     new Fr(blockNumber) /** slot number */,
-    Fr.ZERO,
+    new Fr(blockNumber) /** timestamp */,
     EthAddress.ZERO,
     AztecAddress.ZERO,
     GasFees.empty(),

package/src/mocks/test_context.ts

@@ -13,7 +13,6 @@ import { type Fr } from '@aztec/foundation/fields';
 import { type DebugLogger } from '@aztec/foundation/log';
 import { openTmpStore } from '@aztec/kv-store/utils';
 import {
-  type ContractsDataSourcePublicDB,
   type PublicExecutionResult,
   PublicExecutionResultBuilder,
   type PublicExecutor,
@@ -21,7 +20,7 @@ import {
   RealPublicKernelCircuitSimulator,
   type SimulationProvider,
   WASMSimulator,
-  type WorldStatePublicDB,
+  type WorldStateDB,
 } from '@aztec/simulator';
 import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 import { MerkleTrees } from '@aztec/world-state';
@@ -33,7 +32,7 @@ import { tmpdir } from 'os';
 import { join } from 'path';
 
 import { TestCircuitProver } from '../../../bb-prover/src/test/test_circuit_prover.js';
-import { ProvingOrchestrator } from '../orchestrator/orchestrator.js';
+import { ProvingOrchestrator } from '../orchestrator/index.js';
 import { MemoryProvingQueue } from '../prover-agent/memory-proving-queue.js';
 import { ProverAgent } from '../prover-agent/prover-agent.js';
 import { getEnvironmentConfig, getSimulationProvider, makeGlobals } from './fixtures.js';
@@ -41,8 +40,7 @@ import { getEnvironmentConfig, getSimulationProvider, makeGlobals } from './fixt
 export class TestContext {
   constructor(
     public publicExecutor: MockProxy<PublicExecutor>,
-    public publicContractsDB: MockProxy<ContractsDataSourcePublicDB>,
-    public publicWorldStateDB: MockProxy<WorldStatePublicDB>,
+    public worldStateDB: MockProxy<WorldStateDB>,
     public publicProcessor: PublicProcessor,
     public simulationProvider: SimulationProvider,
     public globalVariables: GlobalVariables,
@@ -71,8 +69,7 @@ export class TestContext {
     const globalVariables = makeGlobals(blockNumber);
 
     const publicExecutor = mock<PublicExecutor>();
-    const publicContractsDB = mock<ContractsDataSourcePublicDB>();
-    const publicWorldStateDB = mock<WorldStatePublicDB>();
+    const worldStateDB = mock<WorldStateDB>();
     const publicKernel = new RealPublicKernelCircuitSimulator(new WASMSimulator());
     const telemetry = new NoopTelemetryClient();
 
@@ -88,14 +85,13 @@ export class TestContext {
       actualDb = ws.asLatest();
     }
 
-    const processor = new PublicProcessor(
+    const processor = PublicProcessor.create(
       actualDb,
       publicExecutor,
       publicKernel,
       GlobalVariables.empty(),
       Header.empty(),
-      publicContractsDB,
-      publicWorldStateDB,
+      worldStateDB,
       telemetry,
     );
 
@@ -130,8 +126,7 @@ export class TestContext {
 
     return new this(
       publicExecutor,
-      publicContractsDB,
-      publicWorldStateDB,
+      worldStateDB,
       processor,
       simulationProvider,
       globalVariables,

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

@@ -1,4 +1,4 @@
-import { MerkleTreeId, type ProcessedTx } from '@aztec/circuit-types';
+import { type Body, MerkleTreeId, type ProcessedTx, TxEffect, getTreeHeight } from '@aztec/circuit-types';
 import {
   ARCHIVE_HEIGHT,
   AppendOnlyTreeSnapshot,
@@ -6,28 +6,29 @@ import {
   BaseRollupInputs,
   BlockMergeRollupInputs,
   type BlockRootOrBlockMergePublicInputs,
-  BlockRootRollupInputs,
   ConstantRollupData,
+  ContentCommitment,
   Fr,
   type GlobalVariables,
-  type Header,
+  Header,
   KernelData,
-  type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
   MAX_NULLIFIERS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   MembershipWitness,
   MergeRollupInputs,
+  MerkleTreeCalculator,
   type NESTED_RECURSIVE_PROOF_LENGTH,
   NOTE_HASH_SUBTREE_HEIGHT,
   NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH,
   NULLIFIER_SUBTREE_HEIGHT,
   NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH,
   NULLIFIER_TREE_HEIGHT,
-  type NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   NullifierLeafPreimage,
   PUBLIC_DATA_SUBTREE_HEIGHT,
   PUBLIC_DATA_SUBTREE_SIBLING_PATH_LENGTH,
   PUBLIC_DATA_TREE_HEIGHT,
+  type ParityPublicInputs,
   PartialStateReference,
   PreviousRollupBlockData,
   PreviousRollupData,
@@ -37,21 +38,25 @@ import {
   PublicDataUpdateRequest,
   type RECURSIVE_PROOF_LENGTH,
   type RecursiveProof,
-  type RootParityInput,
   RootRollupInputs,
   StateDiffHints,
-  type StateReference,
+  StateReference,
   VK_TREE_HEIGHT,
   type VerificationKeyAsFields,
   type VerificationKeyData,
 } from '@aztec/circuits.js';
 import { assertPermutation, makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
+import { sha256Trunc } from '@aztec/foundation/crypto';
+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 { HintsBuilder, computeFeePayerBalanceLeafSlot } from '@aztec/simulator';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
+import { inspect } from 'util';
+
 /**
  * Type representing the names of the trees for the base rollup.
  */
@@ -189,7 +194,6 @@ export function createMergeRollupInputs(
   return mergeInputs;
 }
 
-// TODO(#7346): Integrate batch rollup circuits and test below
 export function createBlockMergeRollupInputs(
   left: [
     BlockRootOrBlockMergePublicInputs,
@@ -209,6 +213,80 @@ export function createBlockMergeRollupInputs(
   return mergeInputs;
 }
 
+export function buildHeaderFromCircuitOutputs(
+  previousMergeData: [BaseOrMergeRollupPublicInputs, BaseOrMergeRollupPublicInputs],
+  parityPublicInputs: ParityPublicInputs,
+  rootRollupOutputs: BlockRootOrBlockMergePublicInputs,
+  updatedL1ToL2TreeSnapshot: AppendOnlyTreeSnapshot,
+  logger?: DebugLogger,
+) {
+  const contentCommitment = new ContentCommitment(
+    new Fr(previousMergeData[0].numTxs + previousMergeData[1].numTxs),
+    sha256Trunc(
+      Buffer.concat([previousMergeData[0].txsEffectsHash.toBuffer(), previousMergeData[1].txsEffectsHash.toBuffer()]),
+    ),
+    parityPublicInputs.shaRoot.toBuffer(),
+    sha256Trunc(Buffer.concat([previousMergeData[0].outHash.toBuffer(), previousMergeData[1].outHash.toBuffer()])),
+  );
+  const state = new StateReference(updatedL1ToL2TreeSnapshot, previousMergeData[1].end);
+  const header = new Header(
+    rootRollupOutputs.previousArchive,
+    contentCommitment,
+    state,
+    previousMergeData[0].constants.globalVariables,
+    previousMergeData[0].accumulatedFees.add(previousMergeData[1].accumulatedFees),
+  );
+  if (!header.hash().equals(rootRollupOutputs.endBlockHash)) {
+    logger?.error(
+      `Block header mismatch when building header from circuit outputs.` +
+        `\n\nHeader: ${inspect(header)}` +
+        `\n\nCircuit: ${toFriendlyJSON(rootRollupOutputs)}`,
+    );
+    throw new Error(`Block header mismatch when building from circuit outputs`);
+  }
+  return header;
+}
+
+export async function buildHeaderFromTxEffects(
+  body: Body,
+  globalVariables: GlobalVariables,
+  l1ToL2Messages: Fr[],
+  db: MerkleTreeOperations,
+) {
+  const stateReference = new StateReference(
+    await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db),
+    new PartialStateReference(
+      await getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE, db),
+      await getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE, db),
+      await getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE, db),
+    ),
+  );
+
+  const previousArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
+
+  const outHash = computeUnbalancedMerkleRoot(
+    body.txEffects.map(tx => tx.txOutHash()),
+    TxEffect.empty().txOutHash(),
+  );
+
+  l1ToL2Messages = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+  const hasher = (left: Buffer, right: Buffer) => sha256Trunc(Buffer.concat([left, right]));
+  const parityHeight = Math.ceil(Math.log2(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
+  const parityShaRoot = new MerkleTreeCalculator(parityHeight, Fr.ZERO.toBuffer(), hasher).computeTreeRoot(
+    l1ToL2Messages.map(msg => msg.toBuffer()),
+  );
+
+  const contentCommitment = new ContentCommitment(
+    new Fr(body.numberOfTxsIncludingPadded),
+    body.getTxsEffectsHash(),
+    parityShaRoot,
+    outHash,
+  );
+
+  const fees = body.txEffects.reduce((acc, tx) => acc.add(tx.transactionFee), Fr.ZERO);
+  return new Header(previousArchive, contentCommitment, stateReference, globalVariables, fees);
+}
+
 // Validate that the roots of all local trees match the output of the root circuit simulation
 export async function validateBlockRootOutput(
   blockRootOutput: BlockRootOrBlockMergePublicInputs,
@@ -238,58 +316,13 @@ export async function validateState(state: StateReference, db: MerkleTreeOperati
   );
 }
 
-// Builds the inputs for the block root rollup circuit, without making any changes to trees
-export async function getBlockRootRollupInput(
-  rollupOutputLeft: BaseOrMergeRollupPublicInputs,
-  rollupProofLeft: RecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>,
-  verificationKeyLeft: VerificationKeyAsFields,
-  rollupOutputRight: BaseOrMergeRollupPublicInputs,
-  rollupProofRight: RecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>,
-  verificationKeyRight: VerificationKeyAsFields,
-  l1ToL2Roots: RootParityInput<typeof NESTED_RECURSIVE_PROOF_LENGTH>,
-  newL1ToL2Messages: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>,
-  messageTreeSnapshot: AppendOnlyTreeSnapshot,
-  messageTreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>,
-  db: MerkleTreeOperations,
-  proverId: Fr,
-) {
-  const previousRollupData: BlockRootRollupInputs['previousRollupData'] = [
-    getPreviousRollupDataFromPublicInputs(rollupOutputLeft, rollupProofLeft, verificationKeyLeft),
-    getPreviousRollupDataFromPublicInputs(rollupOutputRight, rollupProofRight, verificationKeyRight),
-  ];
-
-  const getRootTreeSiblingPath = async (treeId: MerkleTreeId) => {
-    const { size } = await db.getTreeInfo(treeId);
-    const path = await db.getSiblingPath(treeId, size);
-    return path.toFields();
-  };
-
-  // Get blocks tree
-  const startArchiveSnapshot = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
-  const newArchiveSiblingPathArray = await getRootTreeSiblingPath(MerkleTreeId.ARCHIVE);
-
-  const newArchiveSiblingPath = makeTuple(
-    ARCHIVE_HEIGHT,
-    i => (i < newArchiveSiblingPathArray.length ? newArchiveSiblingPathArray[i] : Fr.ZERO),
-    0,
-  );
-
-  return BlockRootRollupInputs.from({
-    previousRollupData,
-    l1ToL2Roots,
-    newL1ToL2Messages,
-    newL1ToL2MessageTreeRootSiblingPath: messageTreeRootSiblingPath,
-    startL1ToL2MessageTreeSnapshot: messageTreeSnapshot,
-    startArchiveSnapshot,
-    newArchiveSiblingPath,
-    // TODO(#7346): Inject previous block hash (required when integrating batch rollup circuits)
-    previousBlockHash: Fr.ZERO,
-    proverId,
-  });
+export async function getRootTreeSiblingPath<TID extends MerkleTreeId>(treeId: TID, db: MerkleTreeOperations) {
+  const { size } = await db.getTreeInfo(treeId);
+  const path = await db.getSiblingPath(treeId, size);
+  return padArrayEnd(path.toFields(), Fr.ZERO, getTreeHeight(treeId));
 }
 
 // Builds the inputs for the final root rollup circuit, without making any changes to trees
-// TODO(#7346): Integrate batch rollup circuits and test below
 export function getRootRollupInput(
   rollupOutputLeft: BlockRootOrBlockMergePublicInputs,
   rollupProofLeft: RecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>,

package/src/orchestrator/{proving-state.ts → block-proving-state.ts}

@@ -1,5 +1,6 @@
 import { type L2Block, type MerkleTreeId, type ProvingResult } from '@aztec/circuit-types';
 import {
+  type ARCHIVE_HEIGHT,
   type AppendOnlyTreeSnapshot,
   type BaseOrMergeRollupPublicInputs,
   type BlockRootOrBlockMergePublicInputs,
@@ -8,6 +9,7 @@ import {
   type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
   type NESTED_RECURSIVE_PROOF_LENGTH,
   type NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+  NUM_BASE_PARITY_PER_ROOT_PARITY,
   type Proof,
   type RECURSIVE_PROOF_LENGTH,
   type RecursiveProof,
@@ -18,6 +20,12 @@ import { type Tuple } from '@aztec/foundation/serialize';
 
 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: [
@@ -29,20 +37,11 @@ export type MergeRollupInputData = {
 
 export type TreeSnapshots = Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
 
-enum PROVING_STATE_LIFECYCLE {
-  PROVING_STATE_CREATED,
-  PROVING_STATE_FULL,
-  PROVING_STATE_RESOLVED,
-  PROVING_STATE_REJECTED,
-}
-
 /**
- * The current state of the proving schedule. Contains the raw inputs (txs) and intermediate state to generate every constituent proof in the tree.
- * Carries an identifier so we can identify if the proving state is discarded and a new one started.
- * Captures resolve and reject callbacks to provide a promise base interface to the consumer of our proving.
+ * The current state of the proving schedule for a given block. Managed by ProvingState.
+ * Contains the raw inputs and intermediate state to generate every constituent proof in the tree.
  */
-export class ProvingState {
-  private provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED;
+export class BlockProvingState {
   private mergeRollupInputs: MergeRollupInputData[] = [];
   private rootParityInputs: Array<RootParityInput<typeof RECURSIVE_PROOF_LENGTH> | undefined> = [];
   private finalRootParityInputs: RootParityInput<typeof NESTED_RECURSIVE_PROOF_LENGTH> | undefined;
@@ -50,17 +49,28 @@ export class ProvingState {
   public finalProof: Proof | undefined;
   public block: L2Block | undefined;
   private txs: TxProvingState[] = [];
+
+  private provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED;
+
   constructor(
+    public readonly index: number,
     public readonly totalNumTxs: number,
-    private completionCallback: (result: ProvingResult) => void,
-    private rejectionCallback: (reason: string) => void,
     public readonly globalVariables: GlobalVariables,
     public readonly newL1ToL2Messages: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>,
-    numRootParityInputs: number,
     public readonly messageTreeSnapshot: AppendOnlyTreeSnapshot,
     public readonly messageTreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>,
+    public readonly messageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot,
+    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,
   ) {
-    this.rootParityInputs = Array.from({ length: numRootParityInputs }).map(_ => undefined);
+    this.rootParityInputs = Array.from({ length: NUM_BASE_PARITY_PER_ROOT_PARITY }).map(_ => undefined);
+  }
+
+  public get blockNumber() {
+    return this.globalVariables.blockNumber.toNumber();
   }
 
   // Returns the number of levels of merge rollups
@@ -95,12 +105,8 @@ export class ProvingState {
   }
 
   // Adds a transaction to the proving state, returns it's index
-  // Will update the proving life cycle if this is the last transaction
   public addNewTx(tx: TxProvingState) {
     this.txs.push(tx);
-    if (this.txs.length === this.totalNumTxs) {
-      this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_FULL;
-    }
     return this.txs.length - 1;
   }
 
@@ -124,19 +130,6 @@ export class ProvingState {
     return this.rootParityInputs;
   }
 
-  // Returns true if this proving state is still valid, false otherwise
-  public verifyState() {
-    return (
-      this.provingStateLifecycle === PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED ||
-      this.provingStateLifecycle === PROVING_STATE_LIFECYCLE.PROVING_STATE_FULL
-    );
-  }
-
-  // Returns true if we are still able to accept transactions, false otherwise
-  public isAcceptingTransactions() {
-    return this.provingStateLifecycle === PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED;
-  }
-
   // Returns the complete set of transaction proving state objects
   public get allTxs() {
     return this.txs;
@@ -211,28 +204,37 @@ export class ProvingState {
     return this.rootParityInputs.findIndex(p => !p) === -1;
   }
 
-  // Attempts to reject the proving state promise with a reason of 'cancelled'
-  public cancel() {
-    this.reject('Proving cancelled');
+  // 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
+    );
+  }
+
+  // Returns true if this proving state is still valid, false otherwise
+  public verifyState() {
+    return this.provingStateLifecycle === PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED;
   }
 
   // Attempts to reject the proving state promise with the given reason
-  // Does nothing if not in a valid state
   public reject(reason: string) {
     if (!this.verifyState()) {
       return;
     }
     this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_REJECTED;
-    this.rejectionCallback(reason);
+    if (this.rejectionCallback) {
+      this.rejectionCallback(reason);
+    }
   }
 
   // Attempts to resolve the proving state promise with the given result
-  // Does nothing if not in a valid state
   public resolve(result: ProvingResult) {
     if (!this.verifyState()) {
       return;
     }
     this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_RESOLVED;
-    this.completionCallback(result);
+    if (this.completionCallback) {
+      this.completionCallback(result);
+    }
   }
 }