@aztec/archiver 0.0.1-commit.d1f2d6c → 0.0.1-commit.d431d1c

package/src/modules/data_source_base.ts

@@ -4,7 +4,7 @@ import type { EthAddress } from '@aztec/foundation/eth-address';
 import { isDefined } from '@aztec/foundation/types';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { CheckpointedL2Block, CommitteeAttestation, L2Block, type L2Tips } from '@aztec/stdlib/block';
+import { CheckpointedL2Block, CommitteeAttestation, L2BlockNew, type L2Tips } from '@aztec/stdlib/block';
 import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { type L1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
@@ -87,14 +87,10 @@ export abstract class ArchiverDataSourceBase
     return this.store.getCheckpointedBlock(number);
   }
 
-  public getCheckpointedL2BlockNumber(): Promise<BlockNumber> {
+  public getCheckpointedBlockNumber(): Promise<BlockNumber> {
     return this.store.getCheckpointedL2BlockNumber();
   }
 
-  public getFinalizedL2BlockNumber(): Promise<BlockNumber> {
-    return this.store.getFinalizedL2BlockNumber();
-  }
-
   public async getCheckpointHeader(number: CheckpointNumber | 'latest'): Promise<CheckpointHeader | undefined> {
     if (number === 'latest') {
       number = await this.store.getSynchedCheckpointNumber();
@@ -117,8 +113,18 @@ export abstract class ArchiverDataSourceBase
     return BlockNumber(checkpointData.startBlock + checkpointData.numBlocks - 1);
   }
 
-  public getCheckpointedBlocks(from: BlockNumber, limit: number): Promise<CheckpointedL2Block[]> {
-    return this.store.getCheckpointedBlocks(from, limit);
+  public async getCheckpointedBlocks(
+    from: BlockNumber,
+    limit: number,
+    proven?: boolean,
+  ): Promise<CheckpointedL2Block[]> {
+    const blocks = await this.store.getCheckpointedBlocks(from, limit);
+
+    if (proven === true) {
+      const provenBlockNumber = await this.store.getProvenBlockNumber();
+      return blocks.filter(b => b.block.number <= provenBlockNumber);
+    }
+    return blocks;
   }
 
   public getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined> {
@@ -129,7 +135,7 @@ export abstract class ArchiverDataSourceBase
     return this.store.getBlockHeaderByArchive(archive);
   }
 
-  public async getL2Block(number: BlockNumber): Promise<L2Block | undefined> {
+  public async getL2BlockNew(number: BlockNumber): Promise<L2BlockNew | undefined> {
     // If the number provided is -ve, then return the latest block.
     if (number < 0) {
       number = await this.store.getLatestBlockNumber();
@@ -157,6 +163,16 @@ export abstract class ArchiverDataSourceBase
     return (await this.store.getPendingChainValidationStatus()) ?? { valid: true };
   }
 
+  public async getL2BlocksNew(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]> {
+    const blocks = await this.store.getBlocks(from, limit);
+
+    if (proven === true) {
+      const provenBlockNumber = await this.store.getProvenBlockNumber();
+      return blocks.filter(b => b.number <= provenBlockNumber);
+    }
+    return blocks;
+  }
+
   public getPrivateLogsByTags(tags: SiloedTag[], page?: number): Promise<TxScopedL2Log[][]> {
     return this.store.getPrivateLogsByTags(tags, page);
   }
@@ -221,7 +237,10 @@ export abstract class ArchiverDataSourceBase
     return this.store.getL1ToL2MessageIndex(l1ToL2Message);
   }
 
-  public async getCheckpoints(checkpointNumber: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]> {
+  public async getPublishedCheckpoints(
+    checkpointNumber: CheckpointNumber,
+    limit: number,
+  ): Promise<PublishedCheckpoint[]> {
     const checkpoints = await this.store.getRangeOfCheckpoints(checkpointNumber, limit);
     const blocks = (
       await Promise.all(checkpoints.map(ch => this.store.getBlocksForCheckpoint(ch.checkpointNumber)))
@@ -247,17 +266,17 @@ export abstract class ArchiverDataSourceBase
     return fullCheckpoints;
   }
 
-  public getBlocksForSlot(slotNumber: SlotNumber): Promise<L2Block[]> {
+  public getBlocksForSlot(slotNumber: SlotNumber): Promise<L2BlockNew[]> {
     return this.store.getBlocksForSlot(slotNumber);
   }
 
-  public async getCheckpointedBlocksForEpoch(epochNumber: EpochNumber): Promise<CheckpointedL2Block[]> {
+  public async getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2BlockNew[]> {
     if (!this.l1Constants) {
       throw new Error('L1 constants not set');
     }
 
     const [start, end] = getSlotRangeForEpoch(epochNumber, this.l1Constants);
-    const blocks: CheckpointedL2Block[] = [];
+    const blocks: L2BlockNew[] = [];
 
     // Walk the list of checkpoints backwards and filter by slots matching the requested epoch.
     // We'll typically ask for checkpoints for a very recent epoch, so we shouldn't need an index here.
@@ -268,9 +287,9 @@ export abstract class ArchiverDataSourceBase
         // push the blocks on backwards
         const endBlock = checkpoint.startBlock + checkpoint.numBlocks - 1;
         for (let i = endBlock; i >= checkpoint.startBlock; i--) {
-          const checkpointedBlock = await this.getCheckpointedBlock(BlockNumber(i));
-          if (checkpointedBlock) {
-            blocks.push(checkpointedBlock);
+          const block = await this.getBlock(BlockNumber(i));
+          if (block) {
+            blocks.push(block);
           }
         }
       }
@@ -280,7 +299,7 @@ export abstract class ArchiverDataSourceBase
     return blocks.reverse();
   }
 
-  public async getCheckpointedBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
+  public async getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
     if (!this.l1Constants) {
       throw new Error('L1 constants not set');
     }
@@ -323,7 +342,7 @@ export abstract class ArchiverDataSourceBase
     while (checkpointData && slot(checkpointData) >= start) {
       if (slot(checkpointData) <= end) {
         // push the checkpoints on backwards
-        const [checkpoint] = await this.getCheckpoints(checkpointData.checkpointNumber, 1);
+        const [checkpoint] = await this.getPublishedCheckpoints(checkpointData.checkpointNumber, 1);
         checkpoints.push(checkpoint.checkpoint);
       }
       checkpointData = await this.store.getCheckpointData(CheckpointNumber(checkpointData.checkpointNumber - 1));
@@ -332,7 +351,33 @@ export abstract class ArchiverDataSourceBase
     return checkpoints.reverse();
   }
 
-  public async getBlock(number: BlockNumber): Promise<L2Block | undefined> {
+  public async getPublishedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<CheckpointedL2Block[]> {
+    const checkpoints = await this.store.getRangeOfCheckpoints(CheckpointNumber(from), limit);
+    const provenCheckpointNumber = await this.store.getProvenCheckpointNumber();
+    const blocks = (
+      await Promise.all(checkpoints.map(ch => this.store.getBlocksForCheckpoint(ch.checkpointNumber)))
+    ).filter(isDefined);
+
+    const publishedBlocks: CheckpointedL2Block[] = [];
+    for (let i = 0; i < checkpoints.length; i++) {
+      const blockForCheckpoint = blocks[i][0];
+      const checkpoint = checkpoints[i];
+      if (checkpoint.checkpointNumber > provenCheckpointNumber && proven === true) {
+        // this checkpoint isn't proven and we only want proven
+        continue;
+      }
+      const publishedBlock = new CheckpointedL2Block(
+        checkpoint.checkpointNumber,
+        blockForCheckpoint,
+        checkpoint.l1,
+        checkpoint.attestations.map(x => CommitteeAttestation.fromBuffer(x)),
+      );
+      publishedBlocks.push(publishedBlock);
+    }
+    return publishedBlocks;
+  }
+
+  public async getBlock(number: BlockNumber): Promise<L2BlockNew | undefined> {
     // If the number provided is -ve, then return the latest block.
     if (number < 0) {
       number = await this.store.getLatestBlockNumber();
@@ -343,24 +388,30 @@ export abstract class ArchiverDataSourceBase
     return this.store.getBlock(number);
   }
 
-  public getBlocks(from: BlockNumber, limit: number): Promise<L2Block[]> {
-    return this.store.getBlocks(from, limit);
+  public async getBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]> {
+    const blocks = await this.store.getBlocks(from, limit);
+
+    if (proven === true) {
+      const provenBlockNumber = await this.store.getProvenBlockNumber();
+      return blocks.filter(b => b.number <= provenBlockNumber);
+    }
+    return blocks;
   }
 
-  public getCheckpointedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined> {
+  public getPublishedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined> {
     return this.store.getCheckpointedBlockByHash(blockHash);
   }
 
-  public getCheckpointedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined> {
+  public getPublishedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined> {
     return this.store.getCheckpointedBlockByArchive(archive);
   }
 
-  public async getL2BlockByHash(blockHash: Fr): Promise<L2Block | undefined> {
+  public async getL2BlockNewByHash(blockHash: Fr): Promise<L2BlockNew | undefined> {
     const checkpointedBlock = await this.store.getCheckpointedBlockByHash(blockHash);
     return checkpointedBlock?.block;
   }
 
-  public async getL2BlockByArchive(archive: Fr): Promise<L2Block | undefined> {
+  public async getL2BlockNewByArchive(archive: Fr): Promise<L2BlockNew | undefined> {
     const checkpointedBlock = await this.store.getCheckpointedBlockByArchive(archive);
     return checkpointedBlock?.block;
   }

package/src/modules/data_store_updater.ts

@@ -10,7 +10,7 @@ import {
   ContractInstancePublishedEvent,
   ContractInstanceUpdatedEvent,
 } from '@aztec/protocol-contracts/instance-registry';
-import type { L2Block, ValidateCheckpointResult } from '@aztec/stdlib/block';
+import type { L2BlockNew, ValidateCheckpointResult } from '@aztec/stdlib/block';
 import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import {
   type ExecutablePrivateFunctionWithMembershipProof,
@@ -35,7 +35,7 @@ enum Operation {
 /** Result of adding checkpoints with information about any pruned blocks. */
 type ReconcileCheckpointsResult = {
   /** Blocks that were pruned due to conflict with L1 checkpoints. */
-  prunedBlocks: L2Block[] | undefined;
+  prunedBlocks: L2BlockNew[] | undefined;
   /** Last block number that was already inserted locally, or undefined if none. */
   lastAlreadyInsertedBlockNumber: BlockNumber | undefined;
 };
@@ -55,7 +55,7 @@ export class ArchiverDataStoreUpdater {
    * @param pendingChainValidationStatus - Optional validation status to set.
    * @returns True if the operation is successful.
    */
-  public addBlocks(blocks: L2Block[], pendingChainValidationStatus?: ValidateCheckpointResult): Promise<boolean> {
+  public addBlocks(blocks: L2BlockNew[], pendingChainValidationStatus?: ValidateCheckpointResult): Promise<boolean> {
     return this.store.transactionAsync(async () => {
       await this.store.addBlocks(blocks);
 
@@ -191,7 +191,7 @@ export class ArchiverDataStoreUpdater {
    * @param blockNumber - Remove all blocks with number greater than this.
    * @returns The removed blocks.
    */
-  public removeBlocksAfter(blockNumber: BlockNumber): Promise<L2Block[]> {
+  public removeBlocksAfter(blockNumber: BlockNumber): Promise<L2BlockNew[]> {
     return this.store.transactionAsync(async () => {
       // First get the blocks to be removed so we can clean up contract data
       const removedBlocks = await this.store.removeBlocksAfter(blockNumber);
@@ -248,17 +248,17 @@ export class ArchiverDataStoreUpdater {
   }
 
   /** Extracts and stores contract data from a single block. */
-  private addBlockDataToDB(block: L2Block): Promise<boolean> {
+  private addBlockDataToDB(block: L2BlockNew): Promise<boolean> {
     return this.editContractBlockData(block, Operation.Store);
   }
 
   /** Removes contract data associated with a block. */
-  private removeBlockDataFromDB(block: L2Block): Promise<boolean> {
+  private removeBlockDataFromDB(block: L2BlockNew): Promise<boolean> {
     return this.editContractBlockData(block, Operation.Delete);
   }
 
   /** Adds or remove contract data associated with a block. */
-  private async editContractBlockData(block: L2Block, operation: Operation): Promise<boolean> {
+  private async editContractBlockData(block: L2BlockNew, operation: Operation): Promise<boolean> {
     const contractClassLogs = block.body.txEffects.flatMap(txEffect => txEffect.contractClassLogs);
     const privateLogs = block.body.txEffects.flatMap(txEffect => txEffect.privateLogs);
     const publicLogs = block.body.txEffects.flatMap(txEffect => txEffect.publicLogs);

package/src/modules/instrumentation.ts

@@ -1,5 +1,5 @@
 import { createLogger } from '@aztec/foundation/log';
-import type { L2Block } from '@aztec/stdlib/block';
+import type { L2BlockNew } from '@aztec/stdlib/block';
 import {
   Attributes,
   type Gauge,
@@ -97,7 +97,7 @@ export class ArchiverInstrumentation {
     return this.telemetry.isEnabled();
   }
 
-  public processNewBlocks(syncTimePerBlock: number, blocks: L2Block[]) {
+  public processNewBlocks(syncTimePerBlock: number, blocks: L2BlockNew[]) {
     this.syncDurationPerBlock.record(Math.ceil(syncTimePerBlock));
     this.blockHeight.record(Math.max(...blocks.map(b => b.number)));
     this.syncBlockCount.add(blocks.length);

package/src/store/block_store.ts

@@ -12,14 +12,13 @@ import {
   Body,
   CheckpointedL2Block,
   CommitteeAttestation,
-  L2Block,
   L2BlockHash,
+  L2BlockNew,
   type ValidateCheckpointResult,
   deserializeValidateCheckpointResult,
   serializeValidateCheckpointResult,
 } from '@aztec/stdlib/block';
 import { L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
-import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
 import {
@@ -28,7 +27,6 @@ import {
   TxEffect,
   TxHash,
   TxReceipt,
-  TxStatus,
   deserializeIndexedTxEffect,
   serializeIndexedTxEffect,
 } from '@aztec/stdlib/tx';
@@ -113,10 +111,7 @@ export class BlockStore {
 
   #log = createLogger('archiver:block_store');
 
-  constructor(
-    private db: AztecAsyncKVStore,
-    private l1Constants: Pick<L1RollupConstants, 'epochDuration'>,
-  ) {
+  constructor(private db: AztecAsyncKVStore) {
     this.#blocks = db.openMap('archiver_blocks');
     this.#blockTxs = db.openMap('archiver_block_txs');
     this.#txEffects = db.openMap('archiver_tx_effects');
@@ -129,24 +124,12 @@ export class BlockStore {
     this.#checkpoints = db.openMap('archiver_checkpoints');
   }
 
-  /**
-   * Computes the finalized block number based on the proven block number.
-   * A block is considered finalized when it's 2 epochs behind the proven block.
-   * TODO(#13569): Compute proper finalized block number based on L1 finalized block.
-   * TODO(palla/mbps): Even the provisional computation is wrong, since it should subtract checkpoints, not blocks
-   * @returns The finalized block number.
-   */
-  async getFinalizedL2BlockNumber(): Promise<BlockNumber> {
-    const provenBlockNumber = await this.getProvenBlockNumber();
-    return BlockNumber(Math.max(provenBlockNumber - this.l1Constants.epochDuration * 2, 0));
-  }
-
   /**
    * Append new blocks to the store's list. All blocks must be for the 'current' checkpoint
    * @param blocks - The L2 blocks to be added to the store.
    * @returns True if the operation is successful.
    */
-  async addBlocks(blocks: L2Block[], opts: { force?: boolean } = {}): Promise<boolean> {
+  async addBlocks(blocks: L2BlockNew[], opts: { force?: boolean } = {}): Promise<boolean> {
     if (blocks.length === 0) {
       return true;
     }
@@ -199,7 +182,7 @@ export class BlockStore {
       }
 
       // Iterate over blocks array and insert them, checking that the block numbers and indexes are sequential. Also check they are for the correct checkpoint.
-      let previousBlock: L2Block | undefined = undefined;
+      let previousBlock: L2BlockNew | undefined = undefined;
       for (const block of blocks) {
         if (!opts.force && previousBlock) {
           if (previousBlock.number + 1 !== block.number) {
@@ -258,7 +241,7 @@ export class BlockStore {
       }
 
       let previousBlockNumber: BlockNumber | undefined = undefined;
-      let previousBlock: L2Block | undefined = undefined;
+      let previousBlock: L2BlockNew | undefined = undefined;
 
       // If we have a previous checkpoint then we need to get the previous block number
       if (previousCheckpointData !== undefined) {
@@ -339,7 +322,7 @@ export class BlockStore {
     });
   }
 
-  private async addBlockToDatabase(block: L2Block, checkpointNumber: number, indexWithinCheckpoint: number) {
+  private async addBlockToDatabase(block: L2BlockNew, checkpointNumber: number, indexWithinCheckpoint: number) {
     const blockHash = L2BlockHash.fromField(await block.hash());
 
     await this.#blocks.set(block.number, {
@@ -368,7 +351,7 @@ export class BlockStore {
   }
 
   /** Deletes a block and all associated data (tx effects, indices). */
-  private async deleteBlock(block: L2Block): Promise<void> {
+  private async deleteBlock(block: L2BlockNew): Promise<void> {
     // Delete the block from the main blocks map
     await this.#blocks.delete(block.number);
 
@@ -466,7 +449,7 @@ export class BlockStore {
     return data;
   }
 
-  async getBlocksForCheckpoint(checkpointNumber: CheckpointNumber): Promise<L2Block[] | undefined> {
+  async getBlocksForCheckpoint(checkpointNumber: CheckpointNumber): Promise<L2BlockNew[] | undefined> {
     const checkpoint = await this.#checkpoints.getAsync(checkpointNumber);
     if (!checkpoint) {
       return undefined;
@@ -489,8 +472,8 @@ export class BlockStore {
    * @param slotNumber - The slot number to search for.
    * @returns All blocks with the given slot number, in ascending block number order.
    */
-  async getBlocksForSlot(slotNumber: SlotNumber): Promise<L2Block[]> {
-    const blocks: L2Block[] = [];
+  async getBlocksForSlot(slotNumber: SlotNumber): Promise<L2BlockNew[]> {
+    const blocks: L2BlockNew[] = [];
 
     // Iterate backwards through all blocks and filter by slot number
     // This is more efficient since we usually query for the most recent slot
@@ -513,9 +496,9 @@ export class BlockStore {
    * @param blockNumber - The block number to remove after.
    * @returns The removed blocks (for event emission).
    */
-  async unwindBlocksAfter(blockNumber: BlockNumber): Promise<L2Block[]> {
+  async unwindBlocksAfter(blockNumber: BlockNumber): Promise<L2BlockNew[]> {
     return await this.db.transactionAsync(async () => {
-      const removedBlocks: L2Block[] = [];
+      const removedBlocks: L2BlockNew[] = [];
 
       // Get the latest block number to determine the range
       const latestBlockNumber = await this.getLatestBlockNumber();
@@ -637,7 +620,7 @@ export class BlockStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks
    */
-  async *getBlocks(start: BlockNumber, limit: number): AsyncIterableIterator<L2Block> {
+  async *getBlocks(start: BlockNumber, limit: number): AsyncIterableIterator<L2BlockNew> {
     for await (const [blockNumber, blockStorage] of this.getBlockStorages(start, limit)) {
       const block = await this.getBlockFromBlockStorage(blockNumber, blockStorage);
       if (block) {
@@ -651,7 +634,7 @@ export class BlockStore {
    * @param blockNumber - The number of the block to return.
    * @returns The requested L2 block.
    */
-  async getBlock(blockNumber: BlockNumber): Promise<L2Block | undefined> {
+  async getBlock(blockNumber: BlockNumber): Promise<L2BlockNew | undefined> {
     const blockStorage = await this.#blocks.getAsync(blockNumber);
     if (!blockStorage || !blockStorage.header) {
       return Promise.resolve(undefined);
@@ -664,7 +647,7 @@ export class BlockStore {
    * @param blockHash - The hash of the block to return.
    * @returns The requested L2 block.
    */
-  async getBlockByHash(blockHash: L2BlockHash): Promise<L2Block | undefined> {
+  async getBlockByHash(blockHash: L2BlockHash): Promise<L2BlockNew | undefined> {
     const blockNumber = await this.#blockHashIndex.getAsync(blockHash.toString());
     if (blockNumber === undefined) {
       return undefined;
@@ -677,7 +660,7 @@ export class BlockStore {
    * @param archive - The archive root of the block to return.
    * @returns The requested L2 block.
    */
-  async getBlockByArchive(archive: Fr): Promise<L2Block | undefined> {
+  async getBlockByArchive(archive: Fr): Promise<L2BlockNew | undefined> {
     const blockNumber = await this.#blockArchiveIndex.getAsync(archive.toString());
     if (blockNumber === undefined) {
       return undefined;
@@ -753,7 +736,7 @@ export class BlockStore {
   private async getBlockFromBlockStorage(
     blockNumber: number,
     blockStorage: BlockStorage,
-  ): Promise<L2Block | undefined> {
+  ): Promise<L2BlockNew | undefined> {
     const header = BlockHeader.fromBuffer(blockStorage.header);
     const archive = AppendOnlyTreeSnapshot.fromBuffer(blockStorage.archive);
     const blockHash = blockStorage.blockHash;
@@ -777,7 +760,7 @@ export class BlockStore {
       txEffects.push(deserializeIndexedTxEffect(txEffect).data);
     }
     const body = new Body(txEffects);
-    const block = new L2Block(
+    const block = new L2BlockNew(
       archive,
       header,
       body,
@@ -819,34 +802,13 @@ export class BlockStore {
       return undefined;
     }
 
-    const blockNumber = BlockNumber(txEffect.l2BlockNumber);
-
-    // Use existing archiver methods to determine finalization level
-    const [provenBlockNumber, checkpointedBlockNumber, finalizedBlockNumber] = await Promise.all([
-      this.getProvenBlockNumber(),
-      this.getCheckpointedL2BlockNumber(),
-      this.getFinalizedL2BlockNumber(),
-    ]);
-
-    let status: TxStatus;
-    if (blockNumber <= finalizedBlockNumber) {
-      status = TxStatus.FINALIZED;
-    } else if (blockNumber <= provenBlockNumber) {
-      status = TxStatus.PROVEN;
-    } else if (blockNumber <= checkpointedBlockNumber) {
-      status = TxStatus.CHECKPOINTED;
-    } else {
-      status = TxStatus.PROPOSED;
-    }
-
     return new TxReceipt(
       txHash,
-      status,
-      TxReceipt.executionResultFromRevertCode(txEffect.data.revertCode),
-      undefined,
+      TxReceipt.statusFromRevertCode(txEffect.data.revertCode),
+      '',
       txEffect.data.transactionFee.toBigInt(),
       txEffect.l2BlockHash,
-      blockNumber,
+      BlockNumber(txEffect.l2BlockNumber),
     );
   }
 

package/src/store/kv_archiver_store.ts

@@ -6,7 +6,7 @@ import { createLogger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, CustomRange, StoreSize } from '@aztec/kv-store';
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { CheckpointedL2Block, L2Block, L2BlockHash, type ValidateCheckpointResult } from '@aztec/stdlib/block';
+import { CheckpointedL2Block, L2BlockHash, L2BlockNew, type ValidateCheckpointResult } from '@aztec/stdlib/block';
 import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type {
   ContractClassPublic,
@@ -16,7 +16,6 @@ import type {
   ExecutablePrivateFunctionWithMembershipProof,
   UtilityFunctionWithMembershipProof,
 } from '@aztec/stdlib/contract';
-import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
 import type { LogFilter, SiloedTag, Tag, TxScopedL2Log } from '@aztec/stdlib/logs';
 import type { BlockHeader, TxHash, TxReceipt } from '@aztec/stdlib/tx';
@@ -65,9 +64,8 @@ export class KVArchiverDataStore implements ContractDataSource {
   constructor(
     private db: AztecAsyncKVStore,
     logsMaxPageSize: number = 1000,
-    l1Constants: Pick<L1RollupConstants, 'epochDuration'>,
   ) {
-    this.#blockStore = new BlockStore(db, l1Constants);
+    this.#blockStore = new BlockStore(db);
     this.#logStore = new LogStore(db, this.#blockStore, logsMaxPageSize);
     this.#messageStore = new MessageStore(db);
     this.#contractClassStore = new ContractClassStore(db);
@@ -103,11 +101,6 @@ export class KVArchiverDataStore implements ContractDataSource {
     return this.db.close();
   }
 
-  /** Computes the finalized block number based on the proven block number. */
-  getFinalizedL2BlockNumber(): Promise<BlockNumber> {
-    return this.#blockStore.getFinalizedL2BlockNumber();
-  }
-
   /** Looks up a public function name given a selector. */
   getDebugFunctionName(_address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
     return Promise.resolve(this.functionNames.get(selector.toString()));
@@ -239,7 +232,7 @@ export class KVArchiverDataStore implements ContractDataSource {
    * @param blocks - The L2 blocks to be added to the store and the last processed L1 block.
    * @returns True if the operation is successful.
    */
-  addBlocks(blocks: L2Block[], opts: { force?: boolean; checkpointNumber?: number } = {}): Promise<boolean> {
+  addBlocks(blocks: L2BlockNew[], opts: { force?: boolean; checkpointNumber?: number } = {}): Promise<boolean> {
     return this.#blockStore.addBlocks(blocks, opts);
   }
 
@@ -305,21 +298,21 @@ export class KVArchiverDataStore implements ContractDataSource {
    * Returns the block for the given number, or undefined if not exists.
    * @param number - The block number to return.
    */
-  getBlock(number: BlockNumber): Promise<L2Block | undefined> {
+  getBlock(number: BlockNumber): Promise<L2BlockNew | undefined> {
     return this.#blockStore.getBlock(number);
   }
   /**
    * Returns the block for the given hash, or undefined if not exists.
    * @param blockHash - The block hash to return.
    */
-  getBlockByHash(blockHash: Fr): Promise<L2Block | undefined> {
+  getBlockByHash(blockHash: Fr): Promise<L2BlockNew | undefined> {
     return this.#blockStore.getBlockByHash(L2BlockHash.fromField(blockHash));
   }
   /**
    * Returns the block for the given archive root, or undefined if not exists.
    * @param archive - The archive root to return.
    */
-  getBlockByArchive(archive: Fr): Promise<L2Block | undefined> {
+  getBlockByArchive(archive: Fr): Promise<L2BlockNew | undefined> {
     return this.#blockStore.getBlockByArchive(archive);
   }
 
@@ -329,7 +322,7 @@ export class KVArchiverDataStore implements ContractDataSource {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks.
    */
-  getBlocks(from: BlockNumber, limit: number): Promise<L2Block[]> {
+  getBlocks(from: BlockNumber, limit: number): Promise<L2BlockNew[]> {
     return toArray(this.#blockStore.getBlocks(from, limit));
   }
 
@@ -392,11 +385,11 @@ export class KVArchiverDataStore implements ContractDataSource {
    * @param blocks - The blocks for which to add the logs.
    * @returns True if the operation is successful.
    */
-  addLogs(blocks: L2Block[]): Promise<boolean> {
+  addLogs(blocks: L2BlockNew[]): Promise<boolean> {
     return this.#logStore.addLogs(blocks);
   }
 
-  deleteLogs(blocks: L2Block[]): Promise<boolean> {
+  deleteLogs(blocks: L2BlockNew[]): Promise<boolean> {
     return this.#logStore.deleteLogs(blocks);
   }
 
@@ -605,7 +598,7 @@ export class KVArchiverDataStore implements ContractDataSource {
    * @param checkpointNumber Retrieves all blocks for the given checkpoint
    * @returns The collection of blocks for the requested checkpoint if available (undefined otherwise)
    */
-  getBlocksForCheckpoint(checkpointNumber: CheckpointNumber): Promise<L2Block[] | undefined> {
+  getBlocksForCheckpoint(checkpointNumber: CheckpointNumber): Promise<L2BlockNew[] | undefined> {
     return this.#blockStore.getBlocksForCheckpoint(checkpointNumber);
   }
 
@@ -623,7 +616,7 @@ export class KVArchiverDataStore implements ContractDataSource {
    * @param slotNumber - The slot number to search for.
    * @returns All blocks with the given slot number.
    */
-  getBlocksForSlot(slotNumber: SlotNumber): Promise<L2Block[]> {
+  getBlocksForSlot(slotNumber: SlotNumber): Promise<L2BlockNew[]> {
     return this.#blockStore.getBlocksForSlot(slotNumber);
   }
 
@@ -632,7 +625,7 @@ export class KVArchiverDataStore implements ContractDataSource {
    * @param blockNumber - The block number to remove after.
    * @returns The removed blocks (for event emission).
    */
-  removeBlocksAfter(blockNumber: BlockNumber): Promise<L2Block[]> {
+  removeBlocksAfter(blockNumber: BlockNumber): Promise<L2BlockNew[]> {
     return this.#blockStore.unwindBlocksAfter(blockNumber);
   }
 }