@aztec/archiver 0.0.0-test.0 → 0.0.1-commit.24de95ac

package/src/archiver/instrumentation.ts

@@ -18,32 +18,43 @@ export class ArchiverInstrumentation {
 
   private blockHeight: Gauge;
   private txCount: UpDownCounter;
-  private syncDuration: Histogram;
-  private l1BlocksSynced: UpDownCounter;
   private l1BlockHeight: Gauge;
   private proofsSubmittedDelay: Histogram;
   private proofsSubmittedCount: UpDownCounter;
   private dbMetrics: LmdbMetrics;
+
+  private pruneDuration: Histogram;
   private pruneCount: UpDownCounter;
 
+  private syncDurationPerBlock: Histogram;
+  private syncBlockCount: UpDownCounter;
+  private manaPerBlock: Histogram;
+  private txsPerBlock: Histogram;
+
+  private syncDurationPerMessage: Histogram;
+  private syncMessageCount: UpDownCounter;
+
   private log = createLogger('archiver:instrumentation');
 
-  private constructor(private telemetry: TelemetryClient, lmdbStats?: LmdbStatsCallback) {
+  private constructor(
+    private telemetry: TelemetryClient,
+    lmdbStats?: LmdbStatsCallback,
+  ) {
     this.tracer = telemetry.getTracer('Archiver');
     const meter = telemetry.getMeter('Archiver');
+
     this.blockHeight = meter.createGauge(Metrics.ARCHIVER_BLOCK_HEIGHT, {
       description: 'The height of the latest block processed by the archiver',
       valueType: ValueType.INT,
     });
 
-    this.txCount = meter.createUpDownCounter(Metrics.ARCHIVER_TX_COUNT, {
-      description: 'The total number of transactions',
+    this.l1BlockHeight = meter.createGauge(Metrics.ARCHIVER_L1_BLOCK_HEIGHT, {
+      description: 'The height of the latest L1 block processed by the archiver',
       valueType: ValueType.INT,
     });
 
-    this.syncDuration = meter.createHistogram(Metrics.ARCHIVER_SYNC_DURATION, {
-      unit: 'ms',
-      description: 'Duration to sync a block',
+    this.txCount = meter.createUpDownCounter(Metrics.ARCHIVER_TOTAL_TXS, {
+      description: 'The total number of transactions',
       valueType: ValueType.INT,
     });
 
@@ -58,13 +69,48 @@ export class ArchiverInstrumentation {
       valueType: ValueType.INT,
     });
 
-    this.l1BlocksSynced = meter.createUpDownCounter(Metrics.ARCHIVER_L1_BLOCKS_SYNCED, {
+    this.syncDurationPerBlock = meter.createHistogram(Metrics.ARCHIVER_SYNC_PER_BLOCK, {
+      unit: 'ms',
+      description: 'Duration to sync a block',
+      valueType: ValueType.INT,
+    });
+
+    this.syncBlockCount = meter.createUpDownCounter(Metrics.ARCHIVER_SYNC_BLOCK_COUNT, {
       description: 'Number of blocks synced from L1',
       valueType: ValueType.INT,
     });
 
-    this.l1BlockHeight = meter.createGauge(Metrics.ARCHIVER_L1_BLOCK_HEIGHT, {
-      description: 'The height of the latest L1 block processed by the archiver',
+    this.manaPerBlock = meter.createHistogram(Metrics.ARCHIVER_MANA_PER_BLOCK, {
+      description: 'The mana consumed by blocks',
+      valueType: ValueType.DOUBLE,
+      unit: 'Mmana',
+    });
+
+    this.txsPerBlock = meter.createHistogram(Metrics.ARCHIVER_TXS_PER_BLOCK, {
+      description: 'The block tx count',
+      valueType: ValueType.INT,
+      unit: 'tx',
+    });
+
+    this.syncDurationPerMessage = meter.createHistogram(Metrics.ARCHIVER_SYNC_PER_MESSAGE, {
+      unit: 'ms',
+      description: 'Duration to sync a message',
+      valueType: ValueType.INT,
+    });
+
+    this.syncMessageCount = meter.createUpDownCounter(Metrics.ARCHIVER_SYNC_MESSAGE_COUNT, {
+      description: 'Number of L1 to L2 messages synced',
+      valueType: ValueType.INT,
+    });
+
+    this.pruneDuration = meter.createHistogram(Metrics.ARCHIVER_PRUNE_DURATION, {
+      unit: 'ms',
+      description: 'Duration to sync a message',
+      valueType: ValueType.INT,
+    });
+
+    this.pruneCount = meter.createUpDownCounter(Metrics.ARCHIVER_PRUNE_COUNT, {
+      description: 'Number of prunes detected',
       valueType: ValueType.INT,
     });
 
@@ -75,17 +121,14 @@ export class ArchiverInstrumentation {
       },
       lmdbStats,
     );
-
-    this.pruneCount = meter.createUpDownCounter(Metrics.ARCHIVER_PRUNE_COUNT, {
-      description: 'Number of prunes detected',
-      valueType: ValueType.INT,
-    });
   }
 
   public static async new(telemetry: TelemetryClient, lmdbStats?: LmdbStatsCallback) {
     const instance = new ArchiverInstrumentation(telemetry, lmdbStats);
 
-    instance.l1BlocksSynced.add(0);
+    instance.syncBlockCount.add(0);
+    instance.syncMessageCount.add(0);
+    instance.pruneCount.add(0);
 
     await instance.telemetry.flush();
 
@@ -97,16 +140,28 @@ export class ArchiverInstrumentation {
   }
 
   public processNewBlocks(syncTimePerBlock: number, blocks: L2Block[]) {
-    this.syncDuration.record(Math.ceil(syncTimePerBlock));
+    this.syncDurationPerBlock.record(Math.ceil(syncTimePerBlock));
     this.blockHeight.record(Math.max(...blocks.map(b => b.number)));
-    this.l1BlocksSynced.add(blocks.length);
+    this.syncBlockCount.add(blocks.length);
+
     for (const block of blocks) {
       this.txCount.add(block.body.txEffects.length);
+      this.txsPerBlock.record(block.body.txEffects.length);
+      this.manaPerBlock.record(block.header.totalManaUsed.toNumber() / 1e6);
+    }
+  }
+
+  public processNewMessages(count: number, syncPerMessageMs: number) {
+    if (count === 0) {
+      return;
     }
+    this.syncMessageCount.add(count);
+    this.syncDurationPerMessage.record(Math.ceil(syncPerMessageMs));
   }
 
-  public processPrune() {
+  public processPrune(duration: number) {
     this.pruneCount.add(1);
+    this.pruneDuration.record(Math.ceil(duration));
   }
 
   public updateLastProvenBlock(blockNumber: number) {

package/src/archiver/kv_archiver_store/block_store.ts

@@ -1,22 +1,44 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
 import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { bufferToHex } from '@aztec/foundation/string';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncSingleton, Range } from '@aztec/kv-store';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { Body, type InBlock, L2Block, L2BlockHash } from '@aztec/stdlib/block';
+import {
+  Body,
+  CommitteeAttestation,
+  L2Block,
+  L2BlockHash,
+  PublishedL2Block,
+  type ValidateBlockResult,
+} from '@aztec/stdlib/block';
+import { L2BlockHeader, deserializeValidateBlockResult, serializeValidateBlockResult } from '@aztec/stdlib/block';
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
-import { BlockHeader, TxEffect, TxHash, TxReceipt } from '@aztec/stdlib/tx';
+import {
+  BlockHeader,
+  type IndexedTxEffect,
+  TxEffect,
+  TxHash,
+  TxReceipt,
+  deserializeIndexedTxEffect,
+  serializeIndexedTxEffect,
+} from '@aztec/stdlib/tx';
 
-import type { L1Published, L1PublishedData } from '../structs/published.js';
+import { BlockNumberNotSequentialError, InitialBlockNumberNotSequentialError } from '../errors.js';
+import type { L1PublishedData } from '../structs/published.js';
 
-export { type TxEffect, type TxHash, TxReceipt } from '@aztec/stdlib/tx';
+export { TxReceipt, type TxEffect, type TxHash } from '@aztec/stdlib/tx';
 
 type BlockIndexValue = [blockNumber: number, index: number];
 
 type BlockStorage = {
   header: Buffer;
+  blockHash: Buffer;
   archive: Buffer;
   l1: L1PublishedData;
+  attestations: Buffer[];
 };
 
 /**
@@ -26,8 +48,11 @@ export class BlockStore {
   /** Map block number to block data */
   #blocks: AztecAsyncMap<number, BlockStorage>;
 
-  /** Map block hash to block body */
-  #blockBodies: AztecAsyncMap<string, Buffer>;
+  /** Map block hash to list of tx hashes */
+  #blockTxs: AztecAsyncMap<string, Buffer>;
+
+  /** Tx hash to serialized IndexedTxEffect */
+  #txEffects: AztecAsyncMap<string, Buffer>;
 
   /** Stores L1 block number in which the last processed L2 block was included */
   #lastSynchedL1Block: AztecAsyncSingleton<bigint>;
@@ -35,25 +60,30 @@ export class BlockStore {
   /** Stores l2 block number of the last proven block */
   #lastProvenL2Block: AztecAsyncSingleton<number>;
 
-  /** Stores l2 epoch number of the last proven epoch */
-  #lastProvenL2Epoch: AztecAsyncSingleton<number>;
-
-  /** Index mapping transaction hash (as a string) to its location in a block */
-  #txIndex: AztecAsyncMap<string, BlockIndexValue>;
+  /** Stores the pending chain validation status */
+  #pendingChainValidationStatus: AztecAsyncSingleton<Buffer>;
 
   /** Index mapping a contract's address (as a string) to its location in a block */
   #contractIndex: AztecAsyncMap<string, BlockIndexValue>;
 
+  /** Index mapping block hash to block number */
+  #blockHashIndex: AztecAsyncMap<string, number>;
+
+  /** Index mapping block archive to block number */
+  #blockArchiveIndex: AztecAsyncMap<string, number>;
+
   #log = createLogger('archiver:block_store');
 
   constructor(private db: AztecAsyncKVStore) {
     this.#blocks = db.openMap('archiver_blocks');
-    this.#blockBodies = db.openMap('archiver_block_bodies');
-    this.#txIndex = db.openMap('archiver_tx_index');
+    this.#blockTxs = db.openMap('archiver_block_txs');
+    this.#txEffects = db.openMap('archiver_tx_effects');
     this.#contractIndex = db.openMap('archiver_contract_index');
+    this.#blockHashIndex = db.openMap('archiver_block_hash_index');
+    this.#blockArchiveIndex = db.openMap('archiver_block_archive_index');
     this.#lastSynchedL1Block = db.openSingleton('archiver_last_synched_l1_block');
     this.#lastProvenL2Block = db.openSingleton('archiver_last_proven_l2_block');
-    this.#lastProvenL2Epoch = db.openSingleton('archiver_last_proven_l2_epoch');
+    this.#pendingChainValidationStatus = db.openSingleton('archiver_pending_chain_validation_status');
   }
 
   /**
@@ -61,25 +91,59 @@ export class BlockStore {
    * @param blocks - The L2 blocks to be added to the store.
    * @returns True if the operation is successful.
    */
-  async addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
+  async addBlocks(blocks: PublishedL2Block[], opts: { force?: boolean } = {}): Promise<boolean> {
     if (blocks.length === 0) {
       return true;
     }
 
     return await this.db.transactionAsync(async () => {
+      // Check that the block immediately before the first block to be added is present in the store.
+      const firstBlockNumber = blocks[0].block.number;
+      const [previousBlockNumber] = await toArray(
+        this.#blocks.keysAsync({ reverse: true, limit: 1, end: firstBlockNumber - 1 }),
+      );
+      const hasPreviousBlock =
+        firstBlockNumber === INITIAL_L2_BLOCK_NUM ||
+        (previousBlockNumber !== undefined && previousBlockNumber === firstBlockNumber - 1);
+      if (!opts.force && !hasPreviousBlock) {
+        throw new InitialBlockNumberNotSequentialError(firstBlockNumber, previousBlockNumber);
+      }
+
+      // Iterate over blocks array and insert them, checking that the block numbers are sequential.
+      let previousBlock: PublishedL2Block | undefined = undefined;
       for (const block of blocks) {
-        await this.#blocks.set(block.data.number, {
-          header: block.data.header.toBuffer(),
-          archive: block.data.archive.toBuffer(),
+        if (!opts.force && previousBlock && previousBlock.block.number + 1 !== block.block.number) {
+          throw new BlockNumberNotSequentialError(block.block.number, previousBlock.block.number);
+        }
+        previousBlock = block;
+        const blockHash = L2BlockHash.fromField(await block.block.hash());
+
+        await this.#blocks.set(block.block.number, {
+          header: block.block.header.toBuffer(),
+          blockHash: blockHash.toBuffer(),
+          archive: block.block.archive.toBuffer(),
           l1: block.l1,
+          attestations: block.attestations.map(attestation => attestation.toBuffer()),
         });
 
-        for (let i = 0; i < block.data.body.txEffects.length; i++) {
-          const txEffect = block.data.body.txEffects[i];
-          await this.#txIndex.set(txEffect.txHash.toString(), [block.data.number, i]);
+        for (let i = 0; i < block.block.body.txEffects.length; i++) {
+          const txEffect: IndexedTxEffect = {
+            data: block.block.body.txEffects[i],
+            l2BlockNumber: block.block.number,
+            l2BlockHash: blockHash,
+            txIndexInBlock: i,
+          };
+          await this.#txEffects.set(txEffect.data.txHash.toString(), serializeIndexedTxEffect(txEffect));
         }
 
-        await this.#blockBodies.set((await block.data.hash()).toString(), block.data.body.toBuffer());
+        await this.#blockTxs.set(
+          blockHash.toString(),
+          Buffer.concat(block.block.body.txEffects.map(tx => tx.txHash.toBuffer())),
+        );
+
+        // Update indices for block hash and archive
+        await this.#blockHashIndex.set(blockHash.toString(), block.block.number);
+        await this.#blockArchiveIndex.set(block.block.archive.root.toString(), block.block.number);
       }
 
       await this.#lastSynchedL1Block.set(blocks[blocks.length - 1].l1.blockNumber);
@@ -101,6 +165,11 @@ export class BlockStore {
         throw new Error(`Can only unwind blocks from the tip (requested ${from} but current tip is ${last})`);
       }
 
+      const proven = await this.getProvenL2BlockNumber();
+      if (from - blocksToUnwind < proven) {
+        await this.setProvenL2BlockNumber(from - blocksToUnwind);
+      }
+
       for (let i = 0; i < blocksToUnwind; i++) {
         const blockNumber = from - i;
         const block = await this.getBlock(blockNumber);
@@ -109,10 +178,15 @@ export class BlockStore {
           this.#log.warn(`Cannot remove block ${blockNumber} from the store since we don't have it`);
           continue;
         }
-        await this.#blocks.delete(block.data.number);
-        await Promise.all(block.data.body.txEffects.map(tx => this.#txIndex.delete(tx.txHash.toString())));
-        const blockHash = (await block.data.hash()).toString();
-        await this.#blockBodies.delete(blockHash);
+        await this.#blocks.delete(block.block.number);
+        await Promise.all(block.block.body.txEffects.map(tx => this.#txEffects.delete(tx.txHash.toString())));
+        const blockHash = (await block.block.hash()).toString();
+        await this.#blockTxs.delete(blockHash);
+
+        // Clean up indices
+        await this.#blockHashIndex.delete(blockHash);
+        await this.#blockArchiveIndex.delete(block.block.archive.root.toString());
+
         this.#log.debug(`Unwound block ${blockNumber} ${blockHash}`);
       }
 
@@ -126,10 +200,12 @@ export class BlockStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks
    */
-  async *getBlocks(start: number, limit: number): AsyncIterableIterator<L1Published<L2Block>> {
-    for await (const blockStorage of this.#blocks.valuesAsync(this.#computeBlockRange(start, limit))) {
-      const block = await this.getBlockFromBlockStorage(blockStorage);
-      yield block;
+  async *getBlocks(start: number, limit: number): AsyncIterableIterator<PublishedL2Block> {
+    for await (const [blockNumber, blockStorage] of this.getBlockStorages(start, limit)) {
+      const block = await this.getBlockFromBlockStorage(blockNumber, blockStorage);
+      if (block) {
+        yield block;
+      }
     }
   }
 
@@ -138,13 +214,72 @@ export class BlockStore {
    * @param blockNumber - The number of the block to return.
    * @returns The requested L2 block.
    */
-  async getBlock(blockNumber: number): Promise<L1Published<L2Block> | undefined> {
+  async getBlock(blockNumber: number): Promise<PublishedL2Block | undefined> {
     const blockStorage = await this.#blocks.getAsync(blockNumber);
     if (!blockStorage || !blockStorage.header) {
       return Promise.resolve(undefined);
     }
+    return this.getBlockFromBlockStorage(blockNumber, blockStorage);
+  }
+
+  /**
+   * Gets an L2 block by its hash.
+   * @param blockHash - The hash of the block to return.
+   * @returns The requested L2 block.
+   */
+  async getBlockByHash(blockHash: L2BlockHash): Promise<PublishedL2Block | undefined> {
+    const blockNumber = await this.#blockHashIndex.getAsync(blockHash.toString());
+    if (blockNumber === undefined) {
+      return undefined;
+    }
+    return this.getBlock(blockNumber);
+  }
+
+  /**
+   * Gets an L2 block by its archive root.
+   * @param archive - The archive root of the block to return.
+   * @returns The requested L2 block.
+   */
+  async getBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined> {
+    const blockNumber = await this.#blockArchiveIndex.getAsync(archive.toString());
+    if (blockNumber === undefined) {
+      return undefined;
+    }
+    return this.getBlock(blockNumber);
+  }
+
+  /**
+   * Gets a block header by its hash.
+   * @param blockHash - The hash of the block to return.
+   * @returns The requested block header.
+   */
+  async getBlockHeaderByHash(blockHash: L2BlockHash): Promise<BlockHeader | undefined> {
+    const blockNumber = await this.#blockHashIndex.getAsync(blockHash.toString());
+    if (blockNumber === undefined) {
+      return undefined;
+    }
+    const blockStorage = await this.#blocks.getAsync(blockNumber);
+    if (!blockStorage || !blockStorage.header) {
+      return undefined;
+    }
+    return L2BlockHeader.fromBuffer(blockStorage.header).toBlockHeader();
+  }
 
-    return this.getBlockFromBlockStorage(blockStorage);
+  /**
+   * Gets a block header by its archive root.
+   * @param archive - The archive root of the block to return.
+   * @returns The requested block header.
+   */
+  async getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined> {
+    const blockNumber = await this.#blockArchiveIndex.getAsync(archive.toString());
+    if (blockNumber === undefined) {
+      return undefined;
+    }
+    const blockStorage = await this.#blocks.getAsync(blockNumber);
+    if (!blockStorage || !blockStorage.header) {
+      return undefined;
+    }
+    return L2BlockHeader.fromBuffer(blockStorage.header).toBlockHeader();
   }
 
   /**
@@ -154,48 +289,80 @@ export class BlockStore {
    * @returns The requested L2 block headers
    */
   async *getBlockHeaders(start: number, limit: number): AsyncIterableIterator<BlockHeader> {
-    for await (const blockStorage of this.#blocks.valuesAsync(this.#computeBlockRange(start, limit))) {
-      yield BlockHeader.fromBuffer(blockStorage.header);
+    for await (const [blockNumber, blockStorage] of this.getBlockStorages(start, limit)) {
+      const header = L2BlockHeader.fromBuffer(blockStorage.header).toBlockHeader();
+      if (header.getBlockNumber() !== blockNumber) {
+        throw new Error(
+          `Block number mismatch when retrieving block header from archive (expected ${blockNumber} but got ${header.getBlockNumber()})`,
+        );
+      }
+      yield header;
     }
   }
 
-  private async getBlockFromBlockStorage(blockStorage: BlockStorage) {
-    const header = BlockHeader.fromBuffer(blockStorage.header);
+  private async *getBlockStorages(start: number, limit: number) {
+    let expectedBlockNumber = start;
+    for await (const [blockNumber, blockStorage] of this.#blocks.entriesAsync(this.#computeBlockRange(start, limit))) {
+      if (blockNumber !== expectedBlockNumber) {
+        throw new Error(
+          `Block number mismatch when iterating blocks from archive (expected ${expectedBlockNumber} but got ${blockNumber})`,
+        );
+      }
+      expectedBlockNumber++;
+      yield [blockNumber, blockStorage] as const;
+    }
+  }
+
+  private async getBlockFromBlockStorage(
+    blockNumber: number,
+    blockStorage: BlockStorage,
+  ): Promise<PublishedL2Block | undefined> {
+    const header = L2BlockHeader.fromBuffer(blockStorage.header);
     const archive = AppendOnlyTreeSnapshot.fromBuffer(blockStorage.archive);
-    const blockHash = (await header.hash()).toString();
-    const blockBodyBuffer = await this.#blockBodies.getAsync(blockHash);
-    if (blockBodyBuffer === undefined) {
+    const blockHash = blockStorage.blockHash;
+    const blockHashString = bufferToHex(blockHash);
+    const blockTxsBuffer = await this.#blockTxs.getAsync(blockHashString);
+    if (blockTxsBuffer === undefined) {
+      this.#log.warn(`Could not find body for block ${header.globalVariables.blockNumber} ${blockHash}`);
+      return undefined;
+    }
+
+    const txEffects: TxEffect[] = [];
+    const reader = BufferReader.asReader(blockTxsBuffer);
+    while (!reader.isEmpty()) {
+      const txHash = reader.readObject(TxHash);
+      const txEffect = await this.#txEffects.getAsync(txHash.toString());
+      if (txEffect === undefined) {
+        this.#log.warn(`Could not find tx effect for tx ${txHash} in block ${blockNumber}`);
+        return undefined;
+      }
+      txEffects.push(deserializeIndexedTxEffect(txEffect).data);
+    }
+    const body = new Body(txEffects);
+    const block = new L2Block(archive, header, body, Fr.fromBuffer(blockHash));
+
+    if (block.number !== blockNumber) {
       throw new Error(
-        `Could not retrieve body for block ${header.globalVariables.blockNumber.toNumber()} ${blockHash}`,
+        `Block number mismatch when retrieving block from archive (expected ${blockNumber} but got ${
+          block.number
+        } with hash ${blockHashString})`,
       );
     }
-    const body = Body.fromBuffer(blockBodyBuffer);
-
-    const l2Block = new L2Block(archive, header, body);
-    return { data: l2Block, l1: blockStorage.l1 };
+    const attestations = blockStorage.attestations.map(CommitteeAttestation.fromBuffer);
+    return PublishedL2Block.fromFields({ block, l1: blockStorage.l1, attestations });
   }
 
   /**
    * Gets a tx effect.
-   * @param txHash - The txHash of the tx corresponding to the tx effect.
-   * @returns The requested tx effect (or undefined if not found).
+   * @param txHash - The hash of the tx corresponding to the tx effect.
+   * @returns The requested tx effect with block info (or undefined if not found).
    */
-  async getTxEffect(txHash: TxHash): Promise<InBlock<TxEffect> | undefined> {
-    const [blockNumber, txIndex] = (await this.getTxLocation(txHash)) ?? [];
-    if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
+  async getTxEffect(txHash: TxHash): Promise<IndexedTxEffect | undefined> {
+    const buffer = await this.#txEffects.getAsync(txHash.toString());
+    if (!buffer) {
       return undefined;
     }
-
-    const block = await this.getBlock(blockNumber);
-    if (!block) {
-      return undefined;
-    }
-
-    return {
-      data: block.data.body.txEffects[txIndex],
-      l2BlockNumber: block.data.number,
-      l2BlockHash: (await block.data.hash()).toString(),
-    };
+    return deserializeIndexedTxEffect(buffer);
   }
 
   /**
@@ -204,21 +371,18 @@ export class BlockStore {
    * @returns The requested tx receipt (or undefined if not found).
    */
   async getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
-    const [blockNumber, txIndex] = (await this.getTxLocation(txHash)) ?? [];
-    if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
+    const txEffect = await this.getTxEffect(txHash);
+    if (!txEffect) {
       return undefined;
     }
 
-    const block = (await this.getBlock(blockNumber))!;
-    const tx = block.data.body.txEffects[txIndex];
-
     return new TxReceipt(
       txHash,
-      TxReceipt.statusFromRevertCode(tx.revertCode),
+      TxReceipt.statusFromRevertCode(txEffect.data.revertCode),
       '',
-      tx.transactionFee.toBigInt(),
-      L2BlockHash.fromField(await block.data.hash()),
-      block.data.number,
+      txEffect.data.transactionFee.toBigInt(),
+      txEffect.l2BlockHash,
+      txEffect.l2BlockNumber,
     );
   }
 
@@ -227,8 +391,13 @@ export class BlockStore {
    * @param txHash - The txHash of the tx.
    * @returns The block number and index of the tx.
    */
-  getTxLocation(txHash: TxHash): Promise<[blockNumber: number, txIndex: number] | undefined> {
-    return this.#txIndex.getAsync(txHash.toString());
+  public async getTxLocation(txHash: TxHash): Promise<[blockNumber: number, txIndex: number] | undefined> {
+    const txEffect = await this.#txEffects.getAsync(txHash.toString());
+    if (!txEffect) {
+      return undefined;
+    }
+    const { l2BlockNumber, txIndexInBlock } = deserializeIndexedTxEffect(txEffect);
+    return [l2BlockNumber, txIndexInBlock];
   }
 
   /**
@@ -262,7 +431,11 @@ export class BlockStore {
   }
 
   async getProvenL2BlockNumber(): Promise<number> {
-    return (await this.#lastProvenL2Block.getAsync()) ?? 0;
+    const [latestBlockNumber, provenBlockNumber] = await Promise.all([
+      this.getSynchedL2BlockNumber(),
+      this.#lastProvenL2Block.getAsync(),
+    ]);
+    return (provenBlockNumber ?? 0) > latestBlockNumber ? latestBlockNumber : (provenBlockNumber ?? 0);
   }
 
   setProvenL2BlockNumber(blockNumber: number) {
@@ -280,4 +453,29 @@ export class BlockStore {
 
     return { start, limit };
   }
+
+  /**
+   * Gets the pending chain validation status.
+   * @returns The validation status or undefined if not set.
+   */
+  async getPendingChainValidationStatus(): Promise<ValidateBlockResult | undefined> {
+    const buffer = await this.#pendingChainValidationStatus.getAsync();
+    if (!buffer) {
+      return undefined;
+    }
+    return deserializeValidateBlockResult(buffer);
+  }
+
+  /**
+   * Sets the pending chain validation status.
+   * @param status - The validation status to store.
+   */
+  async setPendingChainValidationStatus(status: ValidateBlockResult | undefined): Promise<void> {
+    if (status) {
+      const buffer = serializeValidateBlockResult(status);
+      await this.#pendingChainValidationStatus.set(buffer);
+    } else {
+      await this.#pendingChainValidationStatus.delete();
+    }
+  }
 }