@aztec/archiver 4.0.0-nightly.20260112 → 4.0.0-nightly.20260114

package/README.md

@@ -1,37 +1,154 @@
 # Archiver
 
-Archiver is a service which is used to fetch data onchain data and present them in a nice-to-consume form.
+The archiver fetches onchain data from L1 and stores it locally in a queryable form. It pulls:
+- **Checkpoints** (containing L2 blocks) from `CheckpointProposed` events on the Rollup contract
+- **L1-to-L2 messages** from `MessageSent` events on the Inbox contract
 
-The onchain data specifically are the following events:
+The interfaces `L2BlockSource`, `L2LogsSource`, and `ContractDataSource` define how consumers access this data. Interface `L2BlockSink` allows other subsystems, such as the validator client, to push not-yet-checkpointed blocks into the archiver.
 
-1. `L2BlockProposed` event emitted on Rollup contract,
-2. `MessageAdded` event emitted on Inbox contract,
+## Events
 
-The interfaces defining how the data can be consumed from the archiver are `L2BlockSource`, `L2LogsSource` and `ContractDataSource`.
+The archiver emits events for other subsystems to react to state changes:
 
-## Sync process
+- **`L2PruneDetected`**: Emitted before unwinding checkpoints due to epoch prune. Contains the epoch number and affected blocks. Subscribers (e.g., world-state) use this to prepare for the unwind.
+- **`L2BlockProven`**: Emitted when the proven checkpoint advances. Contains the block number, slot, and epoch.
+- **`InvalidAttestationsCheckpointDetected`**: Emitted when a checkpoint with invalid attestations is encountered during sync.
 
-The archiver sync process periodically checks its current state against the Rollup contract on L1 and updates its local state.
+Note that most subsystems handle these events not by subscribing but by polling the archiver using an `L2BlockStream`. This means that, if the node stops while a subsystem has not yet processed an event, the block stream will detect it and have the subsystem reprocess it.
 
-### Handling invalid blocks
+## Sync Process
 
-After the implementation of [delayed attestation verification](https://github.com/AztecProtocol/engineering-designs/pull/69), the Rollup contract on L1 no longer validates committee attestations. Instead, these are posted in calldata, and L2 nodes are expected to verify them as they download blocks. The archiver handles this validation during its sync process.
+The archiver runs a periodic sync loop with two phases:
 
-Whenever the archiver detects a block with invalid attestations, it skips it. These blocks are not meant to be part of the chain, so the archiver ignores them and continues processing the next blocks. It is expected that an honest proposer will eventually invalidate these blocks, removing them from the chain on L1, and then resume the sequence of valid blocks.
+1. **Process queued blocks**: External subsystems (e.g., sequencer) can push blocks directly via `addBlock()`
+2. **Sync from L1**: Pull checkpoints and messages from L1 contracts
 
-> [!WARNING]
-> If the committee for the epoch is also malicious and attests to a descendant of an invalid block, nodes should also ignore these descendants, unless they become proven. This is currently not implemented. Nodes assume that the majority of the committee is honest.
+```
+sync()
+├── processQueuedBlocks()       # Handle blocks pushed via addBlock()
+└── syncFromL1()
+    ├── handleL1ToL2Messages()  # Sync messages from Inbox contract
+    ├── handleCheckpoints()     # Sync checkpoints from Rollup contract
+    ├── handleEpochPrune()      # Proactive unwind before proof window expires
+    └── checkForNewCheckpointsBeforeL1SyncPoint()  # Handle L1 reorg edge case
+```
+
+Each sync iteration pins the current L1 block number at the start and uses it as an upper bound for all queries. This ensures consistent data retrieval even if L1 advances during the iteration.
+
+Two independent syncpoints track progress on L1:
+- `blocksSynchedTo`: L1 block number for checkpoint events
+- `messagesSynchedTo`: L1 block ID (number + hash) for messages
+
+### L1-to-L2 Messages
+
+Messages are synced from the Inbox contract via `handleL1ToL2Messages()`:
+
+1. Query Inbox state at the current L1 block (message count + rolling hash)
+2. Compare local vs remote state
+3. If they match, nothing to do
+4. If mismatch, validate the local last message still exists on L1 with the same rolling hash
+   - If not found or hash differs, an L1 reorg occurred: find the last common message, delete everything after, and rollback the syncpoint
+5. Fetch `MessageSent` events in batches and store
+
+### Checkpoints
+
+Checkpoints are synced from the Rollup contract via `handleCheckpoints()`:
+
+1. Query rollup status (proven/pending checkpoint numbers, archive roots)
+2. Update local proven checkpoint if it matches L1 (called early to update as soon as possible)
+3. **Reorg detection**: Compare the local pending checkpoint's archive root against L1
+   - If not in L1 chain, unwind checkpoints until a common ancestor is found
+4. Retrieve `CheckpointProposed` events in batches
+5. For each checkpoint:
+   - Verify archive matches (checkpoint still in chain)
+   - Validate attestations (2/3 + 1 committee signatures required)
+   - Skip invalid checkpoints (see "Invalid Checkpoints" in Edge Cases)
+   - Verify `inHash` matches expected value (see below)
+   - Store valid checkpoints with their blocks
+6. Update proven checkpoint again (may have advanced after storing new checkpoints)
+7. Handle epoch prune if applicable
+8. Check for checkpoints behind syncpoint (L1 reorg case)
+
+The `inHash` is a hash of all L1-to-L2 messages consumed by a checkpoint. The archiver computes the expected `inHash` from locally stored messages and compares it against the checkpoint header. A mismatch indicates a bug (messages out of sync with checkpoints) and causes a fatal error.
+
+The `blocksSynchedTo` syncpoint is updated:
+- When checkpoints are stored: set to the L1 block of the last stored checkpoint
+- When an invalid checkpoint is processed: advanced past it to avoid re-downloading on every iteration
+- When the L2 chain is empty and there are still no checkpoints on L1: set to current L1 block
+- When rolling back due to L1 reorg or missing checkpoints: set to the target L1 block to re-fetch from
+
+Note that the `blocksSynchedTo` pointer is NOT updated during normal sync when there are no new checkpoints. This protects against small L1 reorgs that could add a checkpoint on an L1 block we have flagged as already synced.
+
+### Block Queue
+
+The archiver implements `L2BlockSink`, allowing other subsystems to push blocks before they appear on L1:
+
+```typescript
+archiver.addBlock(block);  // Queues block for processing
+```
+
+Queued blocks are processed at the start of each sync iteration. This allows the sequencer to make blocks available locally before checkpoint publication. This is used to make the `proposed` chain (ie blocks that have been broadcasted via p2p but not checkpointed on L1) available to consumers.
+
+### Edge Cases
+
+#### L1 Reorgs
 
-When the current node is elected as proposer, the `sequencer` needs to know whether there is an invalid block in L1 that needs to be purged before posting their own block. To support this, the archiver exposes a `pendingChainValidationStatus`, which is the state of the tip of the pending chain. This status can be valid in the happy path, or invalid if the tip of the pending chain has invalid attestations. If invalid, this status also contains all the data needed for purging the block from L1 via an `invalidate` call to the Rollup contract. Note that, if the head of the chain has more than one invalid consecutive block, this status will reference the earliest one that needs to be purged, since a call to purge an invalid block will automatically purge all descendants. Refer to the [InvalidateLib.sol](`l1-contracts/src/core/libraries/rollup/InvalidateLib.sol`) for more info.
+Both message and checkpoint sync detect L1 reorgs by comparing local state against L1. When detected, they find the last common ancestor and rollback.
+
+**Messages**: Each stored message includes its rolling hash. During sync, if the local last message's rolling hash doesn't match L1, the archiver walks backwards through local messages, querying L1 for each one, until it finds a message with a matching rolling hash. Everything after that message is deleted, and the syncpoint is rolled back.
+
+**Checkpoints**: When the archiver queries the Rollup contract for the archive root at the local pending checkpoint number, and it doesn't match the local archive root, the local checkpoint is no longer in L1's chain. The archiver walks backwards through local checkpoints, querying `archiveAt()` for each, until it finds one that matches. All checkpoints after that are unwound.
+
+**Example**: The archiver has synced up to checkpoint 15. An L1 reorg replaces checkpoint 14 and 15 with different content. On the next sync:
+1. Archiver queries `archiveAt(15)` and gets a different archive root than stored locally
+2. Archiver queries `archiveAt(14)` — still different
+3. Archiver queries `archiveAt(13)` — matches
+4. Archiver unwinds checkpoints 14 and 15
+5. Next sync iteration re-fetches the new checkpoints 14 and 15
+
+#### Epoch Prune
+
+If a prune would occur on the next checkpoint submission (checked via `canPruneAtTime`), the archiver preemptively unwinds to the proven checkpoint.
+
+This handles the case where an epoch's proof submission window has passed without a valid proof being submitted. The Rollup contract will prune all unproven checkpoints on the next submission. Rather than wait for that to happen and then react, the archiver detects this condition and unwinds proactively. This keeps the local state consistent with what L1 will look like after the next checkpoint. It also means that the sequencer or validator client will build the next block with the unwind having already taken place.
+
+**Example**: The proven checkpoint is 10, and pending checkpoints 11-15 exist locally. The proof submission window for the epoch containing checkpoint 11 will expire. On sync:
+1. Archiver calls `canPruneAtTime()` with the next L1 block's timestamp — returns true
+2. Archiver unwinds checkpoints 11-15
+3. Emits `L2PruneDetected` event so subscribed subsystems can react
+4. Local state now shows checkpoint 10 as latest
+
+#### Checkpoints Behind Syncpoint
+
+If after processing all logs the local checkpoint count is less than L1's pending checkpoint count, an L1 reorg may have added checkpoints _behind_ the syncpoint. The archiver rolls back the syncpoint to re-fetch.
+
+This handles a subtle L1 reorg scenario: an L1 reorg doesn't replace existing checkpoints but adds new ones in blocks the archiver already processed. Since the archiver only queries events starting from `blocksSynchedTo`, it would miss these new checkpoints.
+
+> [!NOTE]
+> This scenario only occurs when `blocksSynchedTo` was advanced _without_ storing a checkpoint — specifically when the chain is empty or when an invalid checkpoint was processed (and skipped). In normal operation, `blocksSynchedTo` is set to the L1 block of the last stored checkpoint, so any L1 reorg that adds checkpoints would also change the archive root and be caught by the L1 Reorgs check (step 3 in checkpoint sync).
+
+**Example**: The archiver has synced to L1 block 1000 with checkpoint 10. An L1 reorg at block 950 adds a new checkpoint 11 in block 960 (which was previously empty). On sync:
+1. Archiver queries events from block 1001 onwards — finds nothing
+2. Archiver queries Rollup contract — pending checkpoint is 11
+3. Local checkpoint count (10) < L1 pending (11)
+4. Archiver rolls back `blocksSynchedTo` to the L1 block of checkpoint 10
+5. Next sync iteration re-queries from that point and finds checkpoint 11
+
+#### Invalid Checkpoints
+
+When the archiver encounters a checkpoint with invalid attestations, it skips it and continues processing subsequent checkpoints. It also advances `blocksSynchedTo` past the invalid checkpoint to avoid re-downloading it on every iteration.
+
+This handles [delayed attestation verification](https://github.com/AztecProtocol/engineering-designs/pull/69): the Rollup contract no longer validates committee attestations on L1. Instead, attestations are posted in calldata and L2 nodes verify them during sync. Checkpoints with invalid attestations (insufficient signatures, wrong signers, or invalid signatures) are skipped. An honest proposer will eventually call `invalidate` on the Rollup contract to remove these checkpoints.
+
+The archiver exposes `pendingChainValidationStatus` for the sequencer to know if there's an invalid checkpoint that needs purging before posting a new one. If invalid, this status contains the data needed for the `invalidate` call. When multiple consecutive invalid checkpoints exist, the status references the earliest one (invalidating it automatically purges descendants).
+
+> [!WARNING]
+> If a malicious committee attests to a descendant of an invalid checkpoint, nodes should ignore these descendants unless proven. This is not yet implemented — nodes assume honest committee majority.
 
-> [!TIP]
-> The archiver can be configured to `skipValidateBlockAttestations`, which will make it skip this validation. This cannot be set via environment variables, only via a call to `nodeAdmin_setConfig`. This setting is only meant for testing purposes.
+**Example**: Chain has progressed to checkpoint 10. Then:
+1. Checkpoint 11 posted with invalid attestations → archiver reports 10 as latest, `pendingChainValidationStatus` points to 11
+2. Checkpoint 11 purged, new invalid checkpoint 11 posted → status updates to new checkpoint 11
+3. Checkpoint 12 with invalid attestations posted → no change (status still points to 11)
+4. Checkpoint 11 purged and reposted with valid attestations → archiver syncs checkpoint 11, status becomes valid
 
-As an example, let's say the chain has been progressing normally up until block 10, and then:
-1. Block 11 is posted with invalid attestations. The archiver will report 10 as the latest block, but the `pendingChainValidationStatus` will point to block 11.
-2. Block 11 is purged, but another block 11 with invalid attestations is posted in its place. The archiver will still report 10 as latest, and the `pendingChainValidationStatus` will point to the new block 11 that needs to be purged.
-3. Block 12 with invalid attestations is posted. No changes in the archiver.
-4. Block 13 is posted with valid attestations, due to a malicious committee. The archiver will try to sync it and fail, since 13 does not follow 10. This scenario is not gracefully handled yet.
-5. Blocks 11 to 13 are purged. The archiver status will not yet be changed: 10 will still be the latest block, and the `pendingChainValidationStatus` will point to 11. This is because the archiver does **not** follow `BlockInvalidated` events.
-6. Block 11 with valid attestations is posted. The archiver pending chain now reports 11 as latest, and its status is valid.
 

package/dest/archiver/archive_source_base.d.ts

@@ -0,0 +1,75 @@
+import { BlockNumber, CheckpointNumber, type EpochNumber, type SlotNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type CheckpointedL2Block, L2Block, type L2BlockNew, type L2Tips, PublishedL2Block } from '@aztec/stdlib/block';
+import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
+import type { L2LogsSource } from '@aztec/stdlib/interfaces/server';
+import type { LogFilter, SiloedTag, Tag, TxScopedL2Log } from '@aztec/stdlib/logs';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { BlockHeader, IndexedTxEffect, TxHash, TxReceipt } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+import type { ArchiveSource } from './archiver.js';
+import type { KVArchiverDataStore } from './kv_archiver_store/kv_archiver_store.js';
+import type { ValidateCheckpointResult } from './validation.js';
+/**
+ * Abstract base class implementing ArchiveSource using a KVArchiverDataStore.
+ * Provides implementations for all store-delegating methods and declares abstract methods
+ * for L1-dependent functionality that subclasses must implement.
+ */
+export declare abstract class ArchiveSourceBase implements ArchiveSource, L2LogsSource, ContractDataSource, L1ToL2MessageSource {
+    protected readonly store: KVArchiverDataStore;
+    constructor(store: KVArchiverDataStore);
+    abstract getRollupAddress(): Promise<EthAddress>;
+    abstract getRegistryAddress(): Promise<EthAddress>;
+    abstract getL1Constants(): Promise<L1RollupConstants>;
+    abstract getGenesisValues(): Promise<{
+        genesisArchiveRoot: Fr;
+    }>;
+    abstract getL1Timestamp(): Promise<bigint | undefined>;
+    abstract getL2Tips(): Promise<L2Tips>;
+    abstract getL2SlotNumber(): Promise<SlotNumber | undefined>;
+    abstract getL2EpochNumber(): Promise<EpochNumber | undefined>;
+    abstract getCheckpointsForEpoch(epochNumber: EpochNumber): Promise<Checkpoint[]>;
+    abstract getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]>;
+    abstract getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]>;
+    abstract isEpochComplete(epochNumber: EpochNumber): Promise<boolean>;
+    abstract syncImmediate(): Promise<void>;
+    getBlockNumber(): Promise<BlockNumber>;
+    getProvenBlockNumber(): Promise<BlockNumber>;
+    getBlockHeader(number: BlockNumber | 'latest'): Promise<BlockHeader | undefined>;
+    getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined>;
+    getCheckpointedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<CheckpointedL2Block[]>;
+    getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined>;
+    getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined>;
+    getL2BlockNew(number: BlockNumber): Promise<L2BlockNew | undefined>;
+    getTxEffect(txHash: TxHash): Promise<IndexedTxEffect | undefined>;
+    getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined>;
+    isPendingChainInvalid(): Promise<boolean>;
+    getPendingChainValidationStatus(): Promise<ValidateCheckpointResult>;
+    getL2BlocksNew(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]>;
+    getPrivateLogsByTags(tags: SiloedTag[]): Promise<TxScopedL2Log[][]>;
+    getPublicLogsByTagsFromContract(contractAddress: AztecAddress, tags: Tag[]): Promise<TxScopedL2Log[][]>;
+    getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse>;
+    getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse>;
+    getContractClass(id: Fr): Promise<ContractClassPublic | undefined>;
+    getBytecodeCommitment(id: Fr): Promise<Fr | undefined>;
+    getContract(address: AztecAddress, maybeTimestamp?: UInt64): Promise<ContractInstanceWithAddress | undefined>;
+    getContractClassIds(): Promise<Fr[]>;
+    getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
+    registerContractFunctionSignatures(signatures: string[]): Promise<void>;
+    getL1ToL2Messages(checkpointNumber: CheckpointNumber): Promise<Fr[]>;
+    getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined>;
+    getPublishedCheckpoints(checkpointNumber: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]>;
+    getPublishedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<PublishedL2Block[]>;
+    getBlock(number: BlockNumber): Promise<L2Block | undefined>;
+    getBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<L2Block[]>;
+    getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined>;
+    getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined>;
+    private buildOldBlockFromCheckpointedBlock;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/archiver/archive_source_base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive_source_base.d.ts","sourceRoot":"","sources":["../../src/archiver/archive_source_base.ts"],"names":[],"mappings":"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"}

package/dest/archiver/archive_source_base.js

@@ -0,0 +1,202 @@
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { isDefined } from '@aztec/foundation/types';
+import { CommitteeAttestation, L2Block, PublishedL2Block } from '@aztec/stdlib/block';
+import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+/**
+ * Abstract base class implementing ArchiveSource using a KVArchiverDataStore.
+ * Provides implementations for all store-delegating methods and declares abstract methods
+ * for L1-dependent functionality that subclasses must implement.
+ */ export class ArchiveSourceBase {
+    store;
+    constructor(store){
+        this.store = store;
+    }
+    // Store-delegating methods
+    getBlockNumber() {
+        return this.store.getLatestBlockNumber();
+    }
+    getProvenBlockNumber() {
+        return this.store.getProvenBlockNumber();
+    }
+    async getBlockHeader(number) {
+        const blockNumber = number === 'latest' ? await this.store.getLatestBlockNumber() : number;
+        if (blockNumber === 0) {
+            return undefined;
+        }
+        const headers = await this.store.getBlockHeaders(blockNumber, 1);
+        return headers.length === 0 ? undefined : headers[0];
+    }
+    getCheckpointedBlock(number) {
+        return this.store.getCheckpointedBlock(number);
+    }
+    async getCheckpointedBlocks(from, limit, proven) {
+        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;
+    }
+    getBlockHeaderByHash(blockHash) {
+        return this.store.getBlockHeaderByHash(blockHash);
+    }
+    getBlockHeaderByArchive(archive) {
+        return this.store.getBlockHeaderByArchive(archive);
+    }
+    async getL2BlockNew(number) {
+        // If the number provided is -ve, then return the latest block.
+        if (number < 0) {
+            number = await this.store.getLatestBlockNumber();
+        }
+        if (number === 0) {
+            return undefined;
+        }
+        const publishedBlock = await this.store.getBlock(number);
+        return publishedBlock;
+    }
+    getTxEffect(txHash) {
+        return this.store.getTxEffect(txHash);
+    }
+    getSettledTxReceipt(txHash) {
+        return this.store.getSettledTxReceipt(txHash);
+    }
+    isPendingChainInvalid() {
+        return this.getPendingChainValidationStatus().then((status)=>!status.valid);
+    }
+    async getPendingChainValidationStatus() {
+        return await this.store.getPendingChainValidationStatus() ?? {
+            valid: true
+        };
+    }
+    async getL2BlocksNew(from, limit, proven) {
+        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;
+    }
+    // L2LogsSource methods
+    getPrivateLogsByTags(tags) {
+        return this.store.getPrivateLogsByTags(tags);
+    }
+    getPublicLogsByTagsFromContract(contractAddress, tags) {
+        return this.store.getPublicLogsByTagsFromContract(contractAddress, tags);
+    }
+    getPublicLogs(filter) {
+        return this.store.getPublicLogs(filter);
+    }
+    getContractClassLogs(filter) {
+        return this.store.getContractClassLogs(filter);
+    }
+    // ContractDataSource methods
+    getContractClass(id) {
+        return this.store.getContractClass(id);
+    }
+    getBytecodeCommitment(id) {
+        return this.store.getBytecodeCommitment(id);
+    }
+    async getContract(address, maybeTimestamp) {
+        let timestamp;
+        if (maybeTimestamp === undefined) {
+            const latestBlockHeader = await this.getBlockHeader('latest');
+            // If we get undefined block header, it means that the archiver has not yet synced any block so we default to 0.
+            timestamp = latestBlockHeader ? latestBlockHeader.globalVariables.timestamp : 0n;
+        } else {
+            timestamp = maybeTimestamp;
+        }
+        return this.store.getContractInstance(address, timestamp);
+    }
+    getContractClassIds() {
+        return this.store.getContractClassIds();
+    }
+    getDebugFunctionName(address, selector) {
+        return this.store.getDebugFunctionName(address, selector);
+    }
+    registerContractFunctionSignatures(signatures) {
+        return this.store.registerContractFunctionSignatures(signatures);
+    }
+    // L1ToL2MessageSource methods
+    getL1ToL2Messages(checkpointNumber) {
+        return this.store.getL1ToL2Messages(checkpointNumber);
+    }
+    getL1ToL2MessageIndex(l1ToL2Message) {
+        return this.store.getL1ToL2MessageIndex(l1ToL2Message);
+    }
+    // Published checkpoint methods
+    async getPublishedCheckpoints(checkpointNumber, limit) {
+        const checkpoints = await this.store.getRangeOfCheckpoints(checkpointNumber, limit);
+        const blocks = (await Promise.all(checkpoints.map((ch)=>this.store.getBlocksForCheckpoint(ch.checkpointNumber)))).filter(isDefined);
+        const fullCheckpoints = [];
+        for(let i = 0; i < checkpoints.length; i++){
+            const blocksForCheckpoint = blocks[i];
+            const checkpoint = checkpoints[i];
+            const fullCheckpoint = new Checkpoint(checkpoint.archive, checkpoint.header, blocksForCheckpoint, checkpoint.checkpointNumber);
+            const publishedCheckpoint = new PublishedCheckpoint(fullCheckpoint, checkpoint.l1, checkpoint.attestations.map((x)=>CommitteeAttestation.fromBuffer(x)));
+            fullCheckpoints.push(publishedCheckpoint);
+        }
+        return fullCheckpoints;
+    }
+    async getPublishedBlocks(from, limit, proven) {
+        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 olbBlocks = [];
+        for(let i = 0; i < checkpoints.length; i++){
+            const blockForCheckpoint = blocks[i][0];
+            const checkpoint = checkpoints[i];
+            if (checkpoint.checkpointNumber > provenCheckpointNumber && proven === true) {
+                continue;
+            }
+            const oldCheckpoint = new Checkpoint(blockForCheckpoint.archive, checkpoint.header, [
+                blockForCheckpoint
+            ], checkpoint.checkpointNumber);
+            const oldBlock = L2Block.fromCheckpoint(oldCheckpoint);
+            const publishedBlock = new PublishedL2Block(oldBlock, checkpoint.l1, checkpoint.attestations.map((x)=>CommitteeAttestation.fromBuffer(x)));
+            olbBlocks.push(publishedBlock);
+        }
+        return olbBlocks;
+    }
+    // Legacy APIs
+    async getBlock(number) {
+        // If the number provided is -ve, then return the latest block.
+        if (number < 0) {
+            number = await this.store.getLatestBlockNumber();
+        }
+        if (number === 0) {
+            return undefined;
+        }
+        const publishedBlocks = await this.getPublishedBlocks(number, 1);
+        if (publishedBlocks.length === 0) {
+            return undefined;
+        }
+        return publishedBlocks[0].block;
+    }
+    async getBlocks(from, limit, proven) {
+        const publishedBlocks = await this.getPublishedBlocks(from, limit, proven);
+        return publishedBlocks.map((x)=>x.block);
+    }
+    async getPublishedBlockByHash(blockHash) {
+        const checkpointedBlock = await this.store.getCheckpointedBlockByHash(blockHash);
+        return this.buildOldBlockFromCheckpointedBlock(checkpointedBlock);
+    }
+    async getPublishedBlockByArchive(archive) {
+        const checkpointedBlock = await this.store.getCheckpointedBlockByArchive(archive);
+        return this.buildOldBlockFromCheckpointedBlock(checkpointedBlock);
+    }
+    async buildOldBlockFromCheckpointedBlock(checkpointedBlock) {
+        if (!checkpointedBlock) {
+            return undefined;
+        }
+        const checkpoint = await this.store.getCheckpointData(checkpointedBlock.checkpointNumber);
+        if (!checkpoint) {
+            return checkpoint;
+        }
+        const fullCheckpoint = new Checkpoint(checkpointedBlock?.block.archive, checkpoint?.header, [
+            checkpointedBlock.block
+        ], checkpoint.checkpointNumber);
+        const oldBlock = L2Block.fromCheckpoint(fullCheckpoint);
+        const published = new PublishedL2Block(oldBlock, checkpoint.l1, checkpoint.attestations.map((x)=>CommitteeAttestation.fromBuffer(x)));
+        return published;
+    }
+}