@aztec/prover-client 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/src/mocks/test_context.ts

@@ -3,15 +3,15 @@ import { TestCircuitProver } from '@aztec/bb-prover';
 import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { padArrayEnd, times, timesAsync } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Logger } from '@aztec/foundation/log';
+import { SerialQueue } from '@aztec/foundation/queue';
 import type { FieldsOf } from '@aztec/foundation/types';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { ProtocolContractsList } from '@aztec/protocol-contracts';
 import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { EthAddress } from '@aztec/stdlib/block';
 import type { Checkpoint } from '@aztec/stdlib/checkpoint';
 import type { MerkleTreeWriteOperations, ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
 import type { CheckpointConstantData } from '@aztec/stdlib/rollup';
@@ -24,6 +24,7 @@ import {
   StateReference,
   TreeSnapshots,
 } from '@aztec/stdlib/tx';
+import type { GenesisData } from '@aztec/stdlib/world-state';
 import type { MerkleTreeAdminDatabase } from '@aztec/world-state';
 import { NativeWorldStateService } from '@aztec/world-state/native';
 
@@ -35,16 +36,27 @@ import {
   getTreeSnapshot,
   insertSideEffects,
 } from '../orchestrator/block-building-helpers.js';
-import type { BlockProvingState } from '../orchestrator/block-proving-state.js';
-import { ProvingOrchestrator } from '../orchestrator/index.js';
 import { BrokerCircuitProverFacade } from '../proving_broker/broker_prover_facade.js';
 import { TestBroker } from '../test/mock_prover.js';
 import { getEnvironmentConfig, getSimulator, makeCheckpointConstants, makeGlobals } from './fixtures.js';
 
+/**
+ * Builds a started `SerialQueue` for use as an orchestrator's deferred-job queue in
+ * tests. Production wires a single shared queue via `ProverClient`; tests that construct
+ * orchestrators directly use one of these per orchestrator (or share one).
+ */
+export function makeTestDeferredJobQueue(concurrency = 10): SerialQueue {
+  const queue = new SerialQueue();
+  queue.start(concurrency);
+  return queue;
+}
+
 export class TestContext {
   private headers: Map<number, BlockHeader> = new Map();
   private checkpoints: Checkpoint[] = [];
+  private checkpointOutHashes: Fr[] = [];
   private nextCheckpointIndex = 0;
+  private nextCheckpointNumber = CheckpointNumber(1);
   private nextBlockNumber = 1;
   private epochNumber = 1;
   private feePayerBalance: Fr;
@@ -54,7 +66,6 @@ export class TestContext {
     public prover: ServerCircuitProver,
     public broker: TestBroker,
     public brokerProverFacade: BrokerCircuitProverFacade,
-    public orchestrator: TestProvingOrchestrator,
     private feePayer: AztecAddress,
     initialFeePayerBalance: Fr,
     private directoriesToCleanup: string[],
@@ -63,10 +74,6 @@ export class TestContext {
     this.feePayerBalance = initialFeePayerBalance;
   }
 
-  public get epochProver() {
-    return this.orchestrator;
-  }
-
   static async new(
     logger: Logger,
     {
@@ -79,17 +86,16 @@ export class TestContext {
   ) {
     const directoriesToCleanup: string[] = [];
 
-    const feePayer = AztecAddress.fromNumber(42222);
+    const feePayer = AztecAddress.fromNumberUnsafe(42222);
     const initialFeePayerBalance = new Fr(10n ** 20n);
     const feePayerSlot = await computeFeePayerBalanceLeafSlot(feePayer);
-    const prefilledPublicData = [new PublicDataTreeLeaf(feePayerSlot, initialFeePayerBalance)];
+    const genesis: GenesisData = {
+      prefilledPublicData: [new PublicDataTreeLeaf(feePayerSlot, initialFeePayerBalance)],
+      genesisTimestamp: 0n,
+    };
 
     // Separated dbs for public processor and prover - see public_processor for context
-    const ws = await NativeWorldStateService.tmp(
-      /*rollupAddress=*/ undefined,
-      /*cleanupTmpDir=*/ true,
-      prefilledPublicData,
-    );
+    const ws = await NativeWorldStateService.tmp(/*cleanupTmpDir=*/ true, genesis);
 
     let localProver: ServerCircuitProver;
     const config = await getEnvironmentConfig(logger);
@@ -102,8 +108,10 @@ export class TestContext {
         bbBinaryPath: config.expectedBBPath,
         bbWorkingDirectory: config.bbWorkingDirectory,
         bbSkipCleanup: config.bbSkipCleanup,
-        numConcurrentIVCVerifiers: 2,
+        numConcurrentIVCVerifiers: 8,
         bbIVCConcurrency: 1,
+        bbChonkVerifyMaxBatch: 16,
+        bbChonkVerifyConcurrency: 6,
       };
       localProver = await createProver(bbConfig);
     }
@@ -114,22 +122,11 @@ export class TestContext {
 
     const broker = new TestBroker(proverCount, localProver);
     const facade = new BrokerCircuitProverFacade(broker);
-    const orchestrator = new TestProvingOrchestrator(ws, facade, EthAddress.ZERO);
 
     await broker.start();
     facade.start();
 
-    return new this(
-      ws,
-      localProver,
-      broker,
-      facade,
-      orchestrator,
-      feePayer,
-      initialFeePayerBalance,
-      directoriesToCleanup,
-      logger,
-    );
+    return new this(ws, localProver, broker, facade, feePayer, initialFeePayerBalance, directoriesToCleanup, logger);
   }
 
   public getFork() {
@@ -139,6 +136,7 @@ export class TestContext {
   async cleanup() {
     await this.brokerProverFacade.stop();
     await this.broker.stop();
+    await this.worldState.close();
     for (const dir of this.directoriesToCleanup.filter(x => x !== '')) {
       try {
         await fs.rm(dir, { recursive: true, force: true, maxRetries: 3 });
@@ -150,6 +148,7 @@ export class TestContext {
 
   public startNewEpoch() {
     this.checkpoints = [];
+    this.checkpointOutHashes = [];
     this.nextCheckpointIndex = 0;
     this.epochNumber++;
   }
@@ -187,7 +186,8 @@ export class TestContext {
     }
 
     const checkpointIndex = this.nextCheckpointIndex++;
-    const checkpointNumber = CheckpointNumber(checkpointIndex + 1);
+    const checkpointNumber = this.nextCheckpointNumber;
+    this.nextCheckpointNumber++;
     const slotNumber = checkpointNumber * 15; // times an arbitrary number to make it different to the checkpoint number
 
     const constants = makeCheckpointConstants(slotNumber, constantOpts);
@@ -204,6 +204,8 @@ export class TestContext {
 
     const startBlockNumber = this.nextBlockNumber;
     const previousBlockHeader = this.getBlockHeader(BlockNumber(startBlockNumber - 1));
+    // All blocks in the same slot/checkpoint share the same timestamp.
+    const timestamp = BigInt(slotNumber * 26);
 
     // Build global variables.
     const blockGlobalVariables = times(numBlocks, i =>
@@ -211,6 +213,7 @@ export class TestContext {
         coinbase: constants.coinbase,
         feeRecipient: constants.feeRecipient,
         gasFees: constants.gasFees,
+        timestamp,
       }),
     );
     this.nextBlockNumber += numBlocks;
@@ -240,36 +243,42 @@ export class TestContext {
     });
 
     const cleanFork = await this.worldState.fork();
+    const previousCheckpointOutHashes = this.checkpointOutHashes;
     const builder = await LightweightCheckpointBuilder.startNewCheckpoint(
       checkpointNumber,
-      constants,
+      { ...constants, timestamp },
       l1ToL2Messages,
+      previousCheckpointOutHashes,
       cleanFork,
     );
 
     // Add tx effects to db and build block headers.
     const blocks = [];
     for (let i = 0; i < numBlocks; i++) {
-      const isFirstBlock = i === 0;
       const txs = blockTxs[i];
       const state = blockEndStates[i];
 
-      const block = await builder.addBlock(blockGlobalVariables[i], state, txs);
+      const { block } = await builder.addBlock(blockGlobalVariables[i], txs, {
+        expectedEndState: state,
+        insertTxsEffects: true,
+      });
 
       const header = block.header;
       this.headers.set(block.number, header);
 
-      const blockMsgs = isFirstBlock ? l1ToL2Messages : [];
-      await this.worldState.handleL2BlockAndMessages(block, blockMsgs, isFirstBlock);
+      const blockMsgs = block.indexWithinCheckpoint === 0 ? l1ToL2Messages : [];
+      await this.worldState.handleL2BlockAndMessages(block, blockMsgs);
 
       blocks.push({ header, txs });
     }
 
     const checkpoint = await builder.completeCheckpoint();
     this.checkpoints.push(checkpoint);
+    this.checkpointOutHashes.push(checkpoint.getCheckpointOutHash());
 
     return {
       constants,
+      checkpoint,
       header: checkpoint.header,
       blocks,
       l1ToL2Messages,
@@ -337,16 +346,3 @@ export class TestContext {
     return endStateReference;
   }
 }
-
-class TestProvingOrchestrator extends ProvingOrchestrator {
-  public isVerifyBuiltBlockAgainstSyncedStateEnabled = false;
-
-  // Disable this check by default, since it requires seeding world state with the block being built
-  // This is only enabled in some tests with multiple blocks that populate the pending chain via makePendingBlock
-  protected override verifyBuiltBlockAgainstSyncedState(provingState: BlockProvingState): Promise<void> {
-    if (this.isVerifyBuiltBlockAgainstSyncedStateEnabled) {
-      return super.verifyBuiltBlockAgainstSyncedState(provingState);
-    }
-    return Promise.resolve();
-  }
-}

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

@@ -22,7 +22,7 @@ import {
 import { makeTuple } from '@aztec/foundation/array';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Bufferable, assertLength, toFriendlyJSON } from '@aztec/foundation/serialize';
 import { MembershipWitness } from '@aztec/foundation/trees';
 import { getVkData } from '@aztec/noir-protocol-circuits-types/server/vks';
@@ -99,7 +99,7 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan(
 
     const blockHash = await tx.data.constants.anchorBlockHeader.hash();
     const anchorBlockArchiveSiblingPath = (
-      await getMembershipWitnessFor(blockHash, MerkleTreeId.ARCHIVE, ARCHIVE_HEIGHT, db)
+      await getMembershipWitnessFor(blockHash.toFr(), MerkleTreeId.ARCHIVE, ARCHIVE_HEIGHT, db)
     ).siblingPath;
 
     const contractClassLogsFields = makeTuple(
@@ -253,8 +253,8 @@ export function getPublicChonkVerifierPrivateInputsFromTx(tx: Tx | ProcessedTx,
 // Build "hints" as the private inputs for the checkpoint root rollup circuit.
 // The `blobCommitments` will be accumulated and checked in the root rollup against the `finalBlobChallenges`.
 // The `blobsHash` will be validated on L1 against the submitted blob data.
-export const buildBlobHints = (blobFields: Fr[]) => {
-  const blobs = getBlobsPerL1Block(blobFields);
+export const buildBlobHints = async (blobFields: Fr[]) => {
+  const blobs = await getBlobsPerL1Block(blobFields);
   const blobCommitments = getBlobCommitmentsFromBlobs(blobs);
   const blobsHash = computeBlobsHashFromBlobs(blobs);
   return { blobCommitments, blobs, blobsHash };
@@ -282,7 +282,7 @@ export const buildHeaderFromCircuitOutputs = runInSpan(
       chainId: constants.chainId,
       version: constants.version,
       blockNumber: BlockNumber(blockRootRollupOutput.previousArchive.nextAvailableLeafIndex),
-      timestamp: blockRootRollupOutput.endTimestamp,
+      timestamp: blockRootRollupOutput.timestamp,
       slotNumber: constants.slotNumber,
       coinbase: constants.coinbase,
       feeRecipient: constants.feeRecipient,

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

@@ -7,7 +7,7 @@ import {
   NUM_BASE_PARITY_PER_ROOT_PARITY,
 } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Tuple, assertLength } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
 import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
@@ -55,6 +55,7 @@ export class BlockProvingState {
     | ProofState<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
     | undefined;
   private builtBlockHeader: BlockHeader | undefined;
+  private builtArchive: AppendOnlyTreeSnapshot | undefined;
   private endState: StateReference | undefined;
   private endSpongeBlob: SpongeBlob | undefined;
   private txs: TxProvingState[] = [];
@@ -232,6 +233,14 @@ export class BlockProvingState {
     return this.builtBlockHeader;
   }
 
+  public setBuiltArchive(archive: AppendOnlyTreeSnapshot) {
+    this.builtArchive = archive;
+  }
+
+  public getBuiltArchive() {
+    return this.builtArchive;
+  }
+
   public getStartSpongeBlob() {
     return this.startSpongeBlob;
   }

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

@@ -1,53 +1,30 @@
-import {
-  BatchedBlobAccumulator,
-  type FinalBlobBatchingChallenges,
-  SpongeBlob,
-  encodeCheckpointBlobDataFromBlocks,
-} from '@aztec/blob-lib';
+import { SpongeBlob } from '@aztec/blob-lib';
 import {
   type ARCHIVE_HEIGHT,
-  BLOBS_PER_CHECKPOINT,
-  FIELDS_PER_BLOB,
   type L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
   type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   NUM_MSGS_PER_BASE_PARITY,
 } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { BLS12Point, Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
 import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
 import { ParityBasePrivateInputs } from '@aztec/stdlib/parity';
-import {
-  BlockMergeRollupPrivateInputs,
-  BlockRollupPublicInputs,
-  CheckpointConstantData,
-  CheckpointRollupPublicInputs,
-  CheckpointRootRollupHints,
-  CheckpointRootRollupPrivateInputs,
-  CheckpointRootSingleBlockRollupPrivateInputs,
-} from '@aztec/stdlib/rollup';
-import type { CircuitName } from '@aztec/stdlib/stats';
+import { BlockMergeRollupPrivateInputs, BlockRollupPublicInputs, CheckpointConstantData } from '@aztec/stdlib/rollup';
 import type { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 
-import { accumulateBlobs, buildBlobHints, toProofData } from './block-building-helpers.js';
+import { toProofData } from './block-building-helpers.js';
 import { BlockProvingState, type ProofState } from './block-proving-state.js';
-import type { EpochProvingState } from './epoch-proving-state.js';
 
 export class CheckpointProvingState {
   private blockProofs: UnbalancedTreeStore<
     ProofState<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   >;
-  private checkpointRootProof:
-    | ProofState<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-    | undefined;
   private blocks: (BlockProvingState | undefined)[] = [];
-  private startBlobAccumulator: BatchedBlobAccumulator | undefined;
-  private endBlobAccumulator: BatchedBlobAccumulator | undefined;
-  private blobFields: Fr[] | undefined;
   private error: string | undefined;
   public readonly firstBlockNumber: BlockNumber;
 
@@ -55,7 +32,6 @@ export class CheckpointProvingState {
     public readonly index: number,
     public readonly constants: CheckpointConstantData,
     public readonly totalNumBlocks: number,
-    private readonly finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
     private readonly headerOfLastBlockInPreviousCheckpoint: BlockHeader,
     private readonly lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
     private readonly l1ToL2Messages: Fr[],
@@ -71,17 +47,16 @@ export class CheckpointProvingState {
       Fr,
       typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH
     >,
-    public parentEpoch: EpochProvingState,
-    private onBlobAccumulatorSet: (checkpoint: CheckpointProvingState) => void,
+    public readonly epochNumber: number,
+    /** Owner's liveness check. `verifyState()` returns false once this returns false. */
+    private readonly isAlive: () => boolean,
+    /** Owner's failure callback. Invoked from `reject` to surface the error upward. */
+    private readonly onReject: (reason: string) => void,
   ) {
     this.blockProofs = new UnbalancedTreeStore(totalNumBlocks);
     this.firstBlockNumber = BlockNumber(headerOfLastBlockInPreviousCheckpoint.globalVariables.blockNumber + 1);
   }
 
-  public get epochNumber(): number {
-    return this.parentEpoch.epochNumber;
-  }
-
   public startNewBlock(
     blockNumber: BlockNumber,
     timestamp: UInt64,
@@ -163,25 +138,6 @@ export class CheckpointProvingState {
     this.blockProofs.setNode(location, { provingOutput });
   }
 
-  public tryStartProvingCheckpointRoot() {
-    if (this.checkpointRootProof?.isProving) {
-      return false;
-    } else {
-      this.checkpointRootProof = { isProving: true };
-      return true;
-    }
-  }
-
-  public setCheckpointRootRollupProof(
-    provingOutput: PublicInputsAndRecursiveProof<
-      CheckpointRollupPublicInputs,
-      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
-    >,
-  ): TreeNodeLocation {
-    this.checkpointRootProof = { provingOutput };
-    return this.parentEpoch.setCheckpointRootRollupProof(this.index, provingOutput);
-  }
-
   public getBaseParityInputs(baseParityIndex: number) {
     const messages = padArrayEnd(
       this.l1ToL2Messages.slice(
@@ -191,25 +147,7 @@ export class CheckpointProvingState {
       Fr.ZERO,
       NUM_MSGS_PER_BASE_PARITY,
     );
-    return new ParityBasePrivateInputs(messages, this.constants.vkTreeRoot);
-  }
-
-  public async accumulateBlobs(startBlobAccumulator: BatchedBlobAccumulator) {
-    if (this.isAcceptingBlocks() || this.blocks.some(b => !b?.hasEndState())) {
-      return;
-    }
-
-    this.blobFields = encodeCheckpointBlobDataFromBlocks(this.blocks.map(b => b!.getBlockBlobData()));
-    this.endBlobAccumulator = await accumulateBlobs(this.blobFields!, startBlobAccumulator);
-    this.startBlobAccumulator = startBlobAccumulator;
-
-    this.onBlobAccumulatorSet(this);
-
-    return this.endBlobAccumulator;
-  }
-
-  public getEndBlobAccumulator() {
-    return this.endBlobAccumulator;
+    return new ParityBasePrivateInputs(messages, this.constants.vkTreeRoot, this.constants.proverId);
   }
 
   public getParentLocation(location: TreeNodeLocation) {
@@ -225,42 +163,6 @@ export class CheckpointProvingState {
     return new BlockMergeRollupPrivateInputs([toProofData(left), toProofData(right)]);
   }
 
-  public getCheckpointRootRollupType(): CircuitName {
-    return this.totalNumBlocks === 1 ? 'rollup-checkpoint-root-single-block' : 'rollup-checkpoint-root';
-  }
-
-  public getCheckpointRootRollupInputs() {
-    const proofs = this.#getChildProofsForRoot();
-    const nonEmptyProofs = proofs.filter(p => !!p);
-    if (proofs.length !== nonEmptyProofs.length) {
-      throw new Error('At least one child is not ready for the checkpoint root rollup.');
-    }
-    if (!this.startBlobAccumulator) {
-      throw new Error('Start blob accumulator is not set.');
-    }
-
-    // `blobFields` must've been set if `startBlobAccumulator` is set (in `accumulateBlobs`).
-    const blobFields = this.blobFields!;
-
-    const { blobCommitments, blobsHash } = buildBlobHints(blobFields);
-
-    const hints = CheckpointRootRollupHints.from({
-      previousBlockHeader: this.headerOfLastBlockInPreviousCheckpoint,
-      previousArchiveSiblingPath: this.lastArchiveSiblingPath,
-      startBlobAccumulator: this.startBlobAccumulator.toBlobAccumulator(),
-      finalBlobChallenges: this.finalBlobBatchingChallenges,
-      blobFields: padArrayEnd(blobFields, Fr.ZERO, FIELDS_PER_BLOB * BLOBS_PER_CHECKPOINT),
-      blobCommitments: padArrayEnd(blobCommitments, BLS12Point.ZERO, BLOBS_PER_CHECKPOINT),
-      blobsHash,
-    });
-
-    const [left, right] = nonEmptyProofs.map(p => toProofData(p));
-
-    return !right
-      ? new CheckpointRootSingleBlockRollupPrivateInputs(left, hints)
-      : new CheckpointRootRollupPrivateInputs([left, right], hints);
-  }
-
   public getBlockProvingStateByBlockNumber(blockNumber: BlockNumber) {
     const index = Number(blockNumber) - Number(this.firstBlockNumber);
     return this.blocks[index];
@@ -270,13 +172,8 @@ export class CheckpointProvingState {
     return !!this.blockProofs.getSibling(location)?.provingOutput;
   }
 
-  public isReadyForCheckpointRoot() {
-    const allChildProofsReady = this.#getChildProofsForRoot().every(p => !!p);
-    return allChildProofsReady && !!this.startBlobAccumulator;
-  }
-
   public verifyState() {
-    return this.parentEpoch.verifyState();
+    return this.isAlive();
   }
 
   public getError() {
@@ -290,13 +187,22 @@ export class CheckpointProvingState {
 
   public reject(reason: string) {
     this.error = reason;
-    this.parentEpoch.reject(reason);
+    this.onReject(reason);
   }
 
-  #getChildProofsForRoot() {
+  /**
+   * Returns the block-level proof outputs that feed into the checkpoint root rollup.
+   * Used by `CheckpointSubTreeOrchestrator` to surface its sub-tree result.
+   */
+  public getSubTreeOutputProofs() {
     const rootLocation = { level: 0, index: 0 };
     return this.totalNumBlocks === 1
       ? [this.blockProofs.getNode(rootLocation)?.provingOutput] // If there's only 1 block, its proof will be stored at the root.
       : this.blockProofs.getChildren(rootLocation).map(c => c?.provingOutput);
   }
+
+  /** Sibling path of the archive tree captured before any block in this checkpoint landed. */
+  public getLastArchiveSiblingPath() {
+    return this.lastArchiveSiblingPath;
+  }
 }