@aztec/archiver 3.0.0-nightly.20251216 → 3.0.0-nightly.20251218

package/dest/archiver/archiver_store_test_suite.js

@@ -1,4 +1,4 @@
-import { INITIAL_L2_BLOCK_NUM, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { INITIAL_CHECKPOINT_NUMBER, INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { BlockNumber, CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
@@ -8,15 +8,18 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
 import { sleep } from '@aztec/foundation/sleep';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { CommitteeAttestation, EthAddress, L2Block, L2BlockHash, PublishedL2Block, randomBlockInfo, wrapDataInBlock } from '@aztec/stdlib/block';
+import { CommitteeAttestation, EthAddress, L2BlockHash, L2BlockNew, randomBlockInfo } from '@aztec/stdlib/block';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { SerializableContractInstance, computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
 import { ContractClassLog, LogId, PrivateLog, PublicLog } from '@aztec/stdlib/logs';
 import { InboxLeaf } from '@aztec/stdlib/messaging';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { makeContractClassPublic, makeExecutablePrivateFunctionWithMembershipProof, makeUtilityFunctionWithMembershipProof } from '@aztec/stdlib/testing';
 import '@aztec/stdlib/testing/jest';
-import { TxEffect, TxHash } from '@aztec/stdlib/tx';
+import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { PartialStateReference, StateReference, TxEffect, TxHash } from '@aztec/stdlib/tx';
 import { makeInboxMessage, makeInboxMessages } from '../test/mock_structs.js';
-import { BlockNumberNotSequentialError, InitialBlockNumberNotSequentialError } from './errors.js';
+import { BlockArchiveNotConsistentError, BlockIndexNotSequentialError, BlockNumberNotSequentialError, CheckpointNumberNotConsistentError, CheckpointNumberNotSequentialError, InitialBlockNumberNotSequentialError, InitialCheckpointNumberNotSequentialError } from './errors.js';
 import { MessageStoreError } from './kv_archiver_store/message_store.js';
 /**
  * @param testName - The name of the test suite.
@@ -24,100 +27,256 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
  */ export function describeArchiverDataStore(testName, getStore) {
     describe(testName, ()=>{
         let store;
-        let blocks;
-        const blockTests = [
+        let publishedCheckpoints;
+        const blockNumberTests = [
             [
                 1,
-                1,
-                ()=>blocks.slice(0, 1)
+                ()=>publishedCheckpoints[0].checkpoint.blocks[0]
             ],
             [
                 10,
-                1,
-                ()=>blocks.slice(9, 10)
-            ],
-            [
-                1,
-                10,
-                ()=>blocks.slice(0, 10)
-            ],
-            [
-                2,
-                5,
-                ()=>blocks.slice(1, 6)
+                ()=>publishedCheckpoints[9].checkpoint.blocks[0]
             ],
             [
                 5,
-                2,
-                ()=>blocks.slice(4, 6)
+                ()=>publishedCheckpoints[4].checkpoint.blocks[0]
             ]
         ];
         const makeBlockHash = (blockNumber)=>`0x${blockNumber.toString(16).padStart(64, '0')}`;
-        const makePublished = (block, l1BlockNumber)=>PublishedL2Block.fromFields({
-                block: block,
-                l1: {
-                    blockNumber: BigInt(l1BlockNumber),
-                    blockHash: makeBlockHash(l1BlockNumber),
-                    timestamp: BigInt(l1BlockNumber * 1000)
-                },
-                attestations: times(3, CommitteeAttestation.random)
-            });
-        const expectBlocksEqual = (actual, expected)=>{
-            expect(actual.length).toEqual(expected.length);
-            for(let i = 0; i < expected.length; i++){
-                const expectedBlock = expected[i];
-                const actualBlock = actual[i];
-                expect(actualBlock.l1).toEqual(expectedBlock.l1);
-                expect(actualBlock.block.equals(expectedBlock.block)).toBe(true);
-                expect(actualBlock.attestations.every((a, i)=>a.equals(expectedBlock.attestations[i]))).toBe(true);
-            }
+        // Create a state reference with properly calculated noteHashTree.nextAvailableLeafIndex
+        // This is needed because the log store calculates dataStartIndexForBlock as:
+        //   noteHashTree.nextAvailableLeafIndex - txEffects.length * MAX_NOTE_HASHES_PER_TX
+        // If nextAvailableLeafIndex is too small (random values 0-1000), this becomes negative
+        const makeStateForBlock = (blockNumber, txsPerBlock)=>{
+            // Ensure nextAvailableLeafIndex is large enough for all blocks up to this point
+            const noteHashIndex = blockNumber * txsPerBlock * MAX_NOTE_HASHES_PER_TX;
+            return new StateReference(AppendOnlyTreeSnapshot.random(), new PartialStateReference(new AppendOnlyTreeSnapshot(Fr.random(), noteHashIndex), AppendOnlyTreeSnapshot.random(), AppendOnlyTreeSnapshot.random()));
+        };
+        const makePublishedCheckpoint = (checkpoint, l1BlockNumber)=>{
+            return new PublishedCheckpoint(checkpoint, new L1PublishedData(BigInt(l1BlockNumber), BigInt(l1BlockNumber * 1000), makeBlockHash(l1BlockNumber)), times(3, CommitteeAttestation.random));
+        };
+        const expectCheckpointedBlockEquals = (actual, expectedBlock, expectedCheckpoint)=>{
+            expect(actual.l1).toEqual(expectedCheckpoint.l1);
+            expect(actual.block.header.equals(expectedBlock.header)).toBe(true);
+            expect(actual.checkpointNumber).toEqual(expectedCheckpoint.checkpoint.number);
+            expect(actual.attestations.every((a, i)=>a.equals(expectedCheckpoint.attestations[i]))).toBe(true);
         };
         beforeEach(async ()=>{
             store = await getStore();
-            blocks = await timesParallel(10, async (i)=>makePublished(await L2Block.random(BlockNumber(i + 1)), i + 10));
+            // Create checkpoints sequentially to ensure archive roots are chained properly.
+            // Each block's header.lastArchive must equal the previous block's archive.
+            publishedCheckpoints = [];
+            const txsPerBlock = 4;
+            for(let i = 0; i < 10; i++){
+                const blockNumber = i + 1;
+                const previousArchive = i > 0 ? publishedCheckpoints[i - 1].checkpoint.blocks[0].archive : undefined;
+                const checkpoint = await Checkpoint.random(CheckpointNumber(i + 1), {
+                    numBlocks: 1,
+                    startBlockNumber: blockNumber,
+                    previousArchive,
+                    txsPerBlock,
+                    state: makeStateForBlock(blockNumber, txsPerBlock),
+                    // Ensure each tx has public logs for getPublicLogs tests
+                    txOptions: {
+                        numPublicCallsPerTx: 2,
+                        numPublicLogsPerCall: 2
+                    }
+                });
+                publishedCheckpoints.push(makePublishedCheckpoint(checkpoint, i + 10));
+            }
         });
-        describe('addBlocks', ()=>{
-            it('returns success when adding blocks', async ()=>{
-                await expect(store.addBlocks(blocks)).resolves.toBe(true);
+        describe('addCheckpoints', ()=>{
+            it('returns success when adding checkpoints', async ()=>{
+                await expect(store.addCheckpoints(publishedCheckpoints)).resolves.toBe(true);
             });
-            it('allows duplicate blocks', async ()=>{
-                await store.addBlocks(blocks);
-                await expect(store.addBlocks(blocks)).resolves.toBe(true);
+            it('throws on duplicate checkpoints', async ()=>{
+                await store.addCheckpoints(publishedCheckpoints);
+                await expect(store.addCheckpoints(publishedCheckpoints)).rejects.toThrow(InitialCheckpointNumberNotSequentialError);
             });
             it('throws an error if the previous block does not exist in the store', async ()=>{
-                const block = makePublished(await L2Block.random(BlockNumber(2)), 2);
-                await expect(store.addBlocks([
+                const checkpoint = await Checkpoint.random(CheckpointNumber(2), {
+                    numBlocks: 1,
+                    startBlockNumber: 2
+                });
+                const block = makePublishedCheckpoint(checkpoint, 2);
+                await expect(store.addCheckpoints([
                     block
-                ])).rejects.toThrow(InitialBlockNumberNotSequentialError);
-                await expect(store.getPublishedBlocks(BlockNumber(1), 10)).resolves.toEqual([]);
+                ])).rejects.toThrow(InitialCheckpointNumberNotSequentialError);
+                await expect(store.getCheckpointedBlock(1)).resolves.toBeUndefined();
             });
             it('throws an error if there is a gap in the blocks being added', async ()=>{
-                const blocks = [
-                    makePublished(await L2Block.random(BlockNumber(1)), 1),
-                    makePublished(await L2Block.random(BlockNumber(3)), 3)
+                const checkpoint1 = await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 1,
+                    startBlockNumber: 1
+                });
+                const checkpoint3 = await Checkpoint.random(CheckpointNumber(3), {
+                    numBlocks: 1,
+                    startBlockNumber: 3
+                });
+                const checkpoints = [
+                    makePublishedCheckpoint(checkpoint1, 1),
+                    makePublishedCheckpoint(checkpoint3, 3)
                 ];
-                await expect(store.addBlocks(blocks)).rejects.toThrow(BlockNumberNotSequentialError);
-                await expect(store.getPublishedBlocks(BlockNumber(1), 10)).resolves.toEqual([]);
+                await expect(store.addCheckpoints(checkpoints)).rejects.toThrow(CheckpointNumberNotSequentialError);
+                await expect(store.getCheckpointedBlock(1)).resolves.toBeUndefined();
+            });
+            it('throws an error if blocks within a checkpoint are not sequential', async ()=>{
+                // Create a checkpoint with non-sequential block numbers (block 1 and block 3, skipping block 2)
+                const block1 = await L2BlockNew.random(BlockNumber(1), {
+                    checkpointNumber: CheckpointNumber(1)
+                });
+                const block3 = await L2BlockNew.random(BlockNumber(3), {
+                    checkpointNumber: CheckpointNumber(1)
+                });
+                const checkpoint = new Checkpoint(AppendOnlyTreeSnapshot.random(), CheckpointHeader.random(), [
+                    block1,
+                    block3
+                ], CheckpointNumber(1));
+                const publishedCheckpoint = makePublishedCheckpoint(checkpoint, 10);
+                await expect(store.addCheckpoints([
+                    publishedCheckpoint
+                ])).rejects.toThrow(BlockNumberNotSequentialError);
+                await expect(store.getCheckpointedBlock(1)).resolves.toBeUndefined();
+            });
+            it('throws an error if blocks within a checkpoint do not have sequential indexes', async ()=>{
+                // Create a checkpoint with non-sequential indexes
+                const block1 = await L2BlockNew.random(BlockNumber(1), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 0
+                });
+                const block3 = await L2BlockNew.random(BlockNumber(2), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 2
+                });
+                const checkpoint = new Checkpoint(AppendOnlyTreeSnapshot.random(), CheckpointHeader.random(), [
+                    block1,
+                    block3
+                ], CheckpointNumber(1));
+                const publishedCheckpoint = makePublishedCheckpoint(checkpoint, 10);
+                await expect(store.addCheckpoints([
+                    publishedCheckpoint
+                ])).rejects.toThrow(BlockIndexNotSequentialError);
+                await expect(store.getCheckpointedBlock(1)).resolves.toBeUndefined();
+            });
+            it('throws an error if blocks within a checkpoint do not start from index 0', async ()=>{
+                // Create a checkpoint with non-sequential indexes
+                const block1 = await L2BlockNew.random(BlockNumber(1), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 1
+                });
+                const block3 = await L2BlockNew.random(BlockNumber(2), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 2
+                });
+                const checkpoint = new Checkpoint(AppendOnlyTreeSnapshot.random(), CheckpointHeader.random(), [
+                    block1,
+                    block3
+                ], CheckpointNumber(1));
+                const publishedCheckpoint = makePublishedCheckpoint(checkpoint, 10);
+                await expect(store.addCheckpoints([
+                    publishedCheckpoint
+                ])).rejects.toThrow(BlockIndexNotSequentialError);
+                await expect(store.getCheckpointedBlock(1)).resolves.toBeUndefined();
+            });
+            it('throws an error if block has invalid checkpoint index', async ()=>{
+                // Create a block wit an invalid checkpoint index
+                const block1 = await L2BlockNew.random(BlockNumber(1), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: -1
+                });
+                const checkpoint = new Checkpoint(AppendOnlyTreeSnapshot.random(), CheckpointHeader.random(), [
+                    block1
+                ], CheckpointNumber(1));
+                const publishedCheckpoint = makePublishedCheckpoint(checkpoint, 10);
+                await expect(store.addCheckpoints([
+                    publishedCheckpoint
+                ])).rejects.toThrow(BlockIndexNotSequentialError);
+                await expect(store.getCheckpointedBlock(1)).resolves.toBeUndefined();
+            });
+            it('throws an error if checkpoint has invalid initial number', async ()=>{
+                const block1 = await L2BlockNew.random(BlockNumber(1), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 0
+                });
+                const checkpoint = new Checkpoint(AppendOnlyTreeSnapshot.random(), CheckpointHeader.random(), [
+                    block1
+                ], CheckpointNumber(2));
+                const publishedCheckpoint = makePublishedCheckpoint(checkpoint, 10);
+                await expect(store.addCheckpoints([
+                    publishedCheckpoint
+                ])).rejects.toThrow(InitialCheckpointNumberNotSequentialError);
+            });
+            it('allows the correct initial checkpoint', async ()=>{
+                const block1 = await L2BlockNew.random(BlockNumber(1), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 0
+                });
+                const checkpoint = new Checkpoint(AppendOnlyTreeSnapshot.random(), CheckpointHeader.random(), [
+                    block1
+                ], CheckpointNumber(1));
+                const publishedCheckpoint = makePublishedCheckpoint(checkpoint, 10);
+                await expect(store.addCheckpoints([
+                    publishedCheckpoint
+                ])).resolves.toBe(true);
+            });
+            it('throws on duplicate initial checkpoint', async ()=>{
+                const block1 = await L2BlockNew.random(BlockNumber(1), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 0
+                });
+                const block2 = await L2BlockNew.random(BlockNumber(1), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 0
+                });
+                const checkpoint = new Checkpoint(AppendOnlyTreeSnapshot.random(), CheckpointHeader.random(), [
+                    block1
+                ], CheckpointNumber(1));
+                const publishedCheckpoint = makePublishedCheckpoint(checkpoint, 10);
+                const checkpoint2 = new Checkpoint(AppendOnlyTreeSnapshot.random(), CheckpointHeader.random(), [
+                    block2
+                ], CheckpointNumber(1));
+                const publishedCheckpoint2 = makePublishedCheckpoint(checkpoint2, 10);
+                await expect(store.addCheckpoints([
+                    publishedCheckpoint
+                ])).resolves.toBe(true);
+                await expect(store.addCheckpoints([
+                    publishedCheckpoint2
+                ])).rejects.toThrow(InitialCheckpointNumberNotSequentialError);
             });
         });
-        describe('unwindBlocks', ()=>{
-            it('unwinding blocks will remove blocks from the chain', async ()=>{
-                await store.addBlocks(blocks);
-                const blockNumber = await store.getSynchedL2BlockNumber();
-                expectBlocksEqual(await store.getPublishedBlocks(blockNumber, 1), [
-                    blocks[blocks.length - 1]
-                ]);
-                await store.unwindBlocks(blockNumber, 1);
-                expect(await store.getSynchedL2BlockNumber()).toBe(blockNumber - 1);
-                expect(await store.getPublishedBlocks(blockNumber, 1)).toEqual([]);
+        describe('unwindcheckpoints', ()=>{
+            it('unwinding checkpoints will remove checkpoints from the chain', async ()=>{
+                await store.addCheckpoints(publishedCheckpoints);
+                const checkpointNumber = await store.getSynchedCheckpointNumber();
+                const lastCheckpoint = publishedCheckpoints.at(-1);
+                const lastBlockNumber = lastCheckpoint.checkpoint.blocks[0].number;
+                // Verify block exists before unwinding
+                const retrievedBlock = await store.getCheckpointedBlock(lastBlockNumber);
+                expect(retrievedBlock).toBeDefined();
+                expect(retrievedBlock.block.header.equals(lastCheckpoint.checkpoint.blocks[0].header)).toBe(true);
+                expect(retrievedBlock.checkpointNumber).toEqual(checkpointNumber);
+                await store.unwindCheckpoints(checkpointNumber, 1);
+                expect(await store.getSynchedCheckpointNumber()).toBe(checkpointNumber - 1);
+                await expect(store.getCheckpointedBlock(lastBlockNumber)).resolves.toBeUndefined();
             });
             it('can unwind multiple empty blocks', async ()=>{
-                const emptyBlocks = await timesParallel(10, async (i)=>makePublished(await L2Block.random(BlockNumber(i + 1), 0), i + 10));
-                await store.addBlocks(emptyBlocks);
-                expect(await store.getSynchedL2BlockNumber()).toBe(10);
-                await store.unwindBlocks(BlockNumber(10), 3);
-                expect(await store.getSynchedL2BlockNumber()).toBe(7);
-                expect((await store.getPublishedBlocks(BlockNumber(1), 10)).map((b)=>b.block.number)).toEqual([
+                // Create checkpoints sequentially to chain archive roots
+                const emptyCheckpoints = [];
+                for(let i = 0; i < 10; i++){
+                    const previousArchive = i > 0 ? emptyCheckpoints[i - 1].checkpoint.blocks[0].archive : undefined;
+                    const checkpoint = await Checkpoint.random(CheckpointNumber(i + 1), {
+                        numBlocks: 1,
+                        startBlockNumber: i + 1,
+                        txsPerBlock: 0,
+                        previousArchive
+                    });
+                    emptyCheckpoints.push(makePublishedCheckpoint(checkpoint, i + 10));
+                }
+                await store.addCheckpoints(emptyCheckpoints);
+                expect(await store.getSynchedCheckpointNumber()).toBe(10);
+                await store.unwindCheckpoints(CheckpointNumber(10), 3);
+                expect(await store.getSynchedCheckpointNumber()).toBe(7);
+                expect((await store.getRangeOfCheckpoints(CheckpointNumber(1), 10)).map((b)=>b.checkpointNumber)).toEqual([
                     1,
                     2,
                     3,
@@ -127,113 +286,1308 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                     7
                 ]);
             });
-            it('refuses to unwind blocks if the tip is not the last block', async ()=>{
-                await store.addBlocks(blocks);
-                await expect(store.unwindBlocks(BlockNumber(5), 1)).rejects.toThrow(/can only unwind blocks from the tip/i);
+            it('refuses to unwind checkpoints if the tip is not the last checkpoint', async ()=>{
+                await store.addCheckpoints(publishedCheckpoints);
+                await expect(store.unwindCheckpoints(CheckpointNumber(5), 1)).rejects.toThrow(/can only unwind checkpoints from the tip/i);
             });
             it('unwound blocks and headers cannot be retrieved by hash or archive', async ()=>{
-                await store.addBlocks(blocks);
-                const lastBlock = blocks[blocks.length - 1];
-                const blockHash = await lastBlock.block.hash();
-                const archive = lastBlock.block.archive.root;
+                await store.addCheckpoints(publishedCheckpoints);
+                const lastCheckpoint = publishedCheckpoints[publishedCheckpoints.length - 1];
+                const lastBlock = lastCheckpoint.checkpoint.blocks[0];
+                const blockHash = await lastBlock.header.hash();
+                const archive = lastBlock.archive.root;
                 // Verify block and header exist before unwinding
-                expect(await store.getPublishedBlockByHash(blockHash)).toBeDefined();
-                expect(await store.getPublishedBlockByArchive(archive)).toBeDefined();
-                expect(await store.getBlockHeaderByHash(blockHash)).toBeDefined();
-                expect(await store.getBlockHeaderByArchive(archive)).toBeDefined();
-                // Unwind the block
-                await store.unwindBlocks(lastBlock.block.number, 1);
+                const retrievedByHash = await store.getCheckpointedBlockByHash(blockHash);
+                expect(retrievedByHash).toBeDefined();
+                expect(retrievedByHash.block.header.equals(lastBlock.header)).toBe(true);
+                const retrievedByArchive = await store.getCheckpointedBlockByArchive(archive);
+                expect(retrievedByArchive).toBeDefined();
+                expect(retrievedByArchive.block.header.equals(lastBlock.header)).toBe(true);
+                const headerByHash = await store.getBlockHeaderByHash(blockHash);
+                expect(headerByHash).toBeDefined();
+                expect(headerByHash.equals(lastBlock.header)).toBe(true);
+                const headerByArchive = await store.getBlockHeaderByArchive(archive);
+                expect(headerByArchive).toBeDefined();
+                expect(headerByArchive.equals(lastBlock.header)).toBe(true);
+                // Unwind the checkpoint
+                await store.unwindCheckpoints(lastCheckpoint.checkpoint.number, 1);
                 // Verify neither block nor header can be retrieved after unwinding
-                expect(await store.getPublishedBlockByHash(blockHash)).toBeUndefined();
-                expect(await store.getPublishedBlockByArchive(archive)).toBeUndefined();
+                expect(await store.getCheckpointedBlockByHash(blockHash)).toBeUndefined();
+                expect(await store.getCheckpointedBlockByArchive(archive)).toBeUndefined();
                 expect(await store.getBlockHeaderByHash(blockHash)).toBeUndefined();
                 expect(await store.getBlockHeaderByArchive(archive)).toBeUndefined();
             });
         });
-        describe('getBlocks', ()=>{
-            beforeEach(async ()=>{
-                await store.addBlocks(blocks);
+        describe('multi-block checkpoints', ()=>{
+            it('block number increases correctly when adding checkpoints with multiple blocks', async ()=>{
+                // Create 3 checkpoints: first with 2 blocks, second with 3 blocks, third with 1 block
+                // Total blocks: 6, spanning block numbers 1-6
+                // Chain archive roots across checkpoints
+                const checkpoint1Cp = await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                });
+                const checkpoint1 = makePublishedCheckpoint(checkpoint1Cp, 10);
+                const previousArchive1 = checkpoint1Cp.blocks.at(-1).archive;
+                const checkpoint2Cp = await Checkpoint.random(CheckpointNumber(2), {
+                    numBlocks: 3,
+                    startBlockNumber: 3,
+                    previousArchive: previousArchive1
+                });
+                const checkpoint2 = makePublishedCheckpoint(checkpoint2Cp, 11);
+                const previousArchive2 = checkpoint2Cp.blocks.at(-1).archive;
+                const checkpoint3Cp = await Checkpoint.random(CheckpointNumber(3), {
+                    numBlocks: 1,
+                    startBlockNumber: 6,
+                    previousArchive: previousArchive2
+                });
+                const checkpoint3 = makePublishedCheckpoint(checkpoint3Cp, 12);
+                await store.addCheckpoints([
+                    checkpoint1,
+                    checkpoint2,
+                    checkpoint3
+                ]);
+                // Checkpoint number should be 3 (the last checkpoint number)
+                expect(await store.getSynchedCheckpointNumber()).toBe(3);
+                // Block number should be 6 (the last block number across all checkpoints)
+                expect(await store.getLatestBlockNumber()).toBe(6);
+            });
+            it('block number decreases correctly when unwinding checkpoints with multiple blocks', async ()=>{
+                // Create 3 checkpoints with varying block counts, chaining archive roots
+                const checkpoint1Cp = await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                });
+                const checkpoint1 = makePublishedCheckpoint(checkpoint1Cp, 10);
+                const previousArchive1 = checkpoint1Cp.blocks.at(-1).archive;
+                const checkpoint2Cp = await Checkpoint.random(CheckpointNumber(2), {
+                    numBlocks: 3,
+                    startBlockNumber: 3,
+                    previousArchive: previousArchive1
+                });
+                const checkpoint2 = makePublishedCheckpoint(checkpoint2Cp, 11);
+                const previousArchive2 = checkpoint2Cp.blocks.at(-1).archive;
+                const checkpoint3Cp = await Checkpoint.random(CheckpointNumber(3), {
+                    numBlocks: 2,
+                    startBlockNumber: 6,
+                    previousArchive: previousArchive2
+                });
+                const checkpoint3 = makePublishedCheckpoint(checkpoint3Cp, 12);
+                await store.addCheckpoints([
+                    checkpoint1,
+                    checkpoint2,
+                    checkpoint3
+                ]);
+                expect(await store.getSynchedCheckpointNumber()).toBe(3);
+                expect(await store.getLatestBlockNumber()).toBe(7);
+                // Unwind the last checkpoint (which has 2 blocks)
+                await store.unwindCheckpoints(CheckpointNumber(3), 1);
+                expect(await store.getSynchedCheckpointNumber()).toBe(2);
+                expect(await store.getLatestBlockNumber()).toBe(5);
+                // Unwind another checkpoint (which has 3 blocks)
+                await store.unwindCheckpoints(CheckpointNumber(2), 1);
+                expect(await store.getSynchedCheckpointNumber()).toBe(1);
+                expect(await store.getLatestBlockNumber()).toBe(2);
+            });
+            it('unwinding multiple checkpoints with multiple blocks in one go', async ()=>{
+                // Create 4 checkpoints with varying block counts, chaining archive roots
+                // Checkpoint 1: blocks 1-2 (2 blocks)
+                // Checkpoint 2: blocks 3-5 (3 blocks)
+                // Checkpoint 3: blocks 6-7 (2 blocks)
+                // Checkpoint 4: blocks 8-10 (3 blocks)
+                // Total: 10 blocks across 4 checkpoints
+                const checkpoint1Cp = await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                });
+                const checkpoint1 = makePublishedCheckpoint(checkpoint1Cp, 10);
+                const previousArchive1 = checkpoint1Cp.blocks.at(-1).archive;
+                const checkpoint2Cp = await Checkpoint.random(CheckpointNumber(2), {
+                    numBlocks: 3,
+                    startBlockNumber: 3,
+                    previousArchive: previousArchive1
+                });
+                const checkpoint2 = makePublishedCheckpoint(checkpoint2Cp, 11);
+                const previousArchive2 = checkpoint2Cp.blocks.at(-1).archive;
+                const checkpoint3Cp = await Checkpoint.random(CheckpointNumber(3), {
+                    numBlocks: 2,
+                    startBlockNumber: 6,
+                    previousArchive: previousArchive2
+                });
+                const checkpoint3 = makePublishedCheckpoint(checkpoint3Cp, 12);
+                const previousArchive3 = checkpoint3Cp.blocks.at(-1).archive;
+                const checkpoint4Cp = await Checkpoint.random(CheckpointNumber(4), {
+                    numBlocks: 3,
+                    startBlockNumber: 8,
+                    previousArchive: previousArchive3
+                });
+                const checkpoint4 = makePublishedCheckpoint(checkpoint4Cp, 13);
+                await store.addCheckpoints([
+                    checkpoint1,
+                    checkpoint2,
+                    checkpoint3,
+                    checkpoint4
+                ]);
+                expect(await store.getSynchedCheckpointNumber()).toBe(4);
+                expect(await store.getLatestBlockNumber()).toBe(10);
+                // Unwind 2 checkpoints at once (checkpoints 3 and 4, which together have 5 blocks)
+                await store.unwindCheckpoints(CheckpointNumber(4), 2);
+                expect(await store.getSynchedCheckpointNumber()).toBe(2);
+                expect(await store.getLatestBlockNumber()).toBe(5);
+                // Verify blocks 1-5 still exist (from checkpoints 1 and 2)
+                for(let blockNumber = 1; blockNumber <= 5; blockNumber++){
+                    expect(await store.getCheckpointedBlock(blockNumber)).toBeDefined();
+                }
+                // Verify blocks 6-10 are gone (from checkpoints 3 and 4)
+                for(let blockNumber = 6; blockNumber <= 10; blockNumber++){
+                    expect(await store.getCheckpointedBlock(blockNumber)).toBeUndefined();
+                }
+                // Unwind remaining 2 checkpoints at once (checkpoints 1 and 2, which together have 5 blocks)
+                await store.unwindCheckpoints(CheckpointNumber(2), 2);
+                expect(await store.getSynchedCheckpointNumber()).toBe(0);
+                expect(await store.getLatestBlockNumber()).toBe(0);
+                // Verify all blocks are gone
+                for(let blockNumber = 1; blockNumber <= 10; blockNumber++){
+                    expect(await store.getCheckpointedBlock(blockNumber)).toBeUndefined();
+                }
             });
-            it.each(blockTests)('retrieves previously stored blocks', async (start, limit, getExpectedBlocks)=>{
-                expectBlocksEqual(await store.getPublishedBlocks(BlockNumber(start), limit), getExpectedBlocks());
+            it('getCheckpointedBlock returns correct checkpoint info for blocks within multi-block checkpoints', async ()=>{
+                // Create checkpoints with chained archive roots
+                // Create a checkpoint with 3 blocks
+                const checkpoint1Cp = await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 3,
+                    startBlockNumber: 1
+                });
+                const checkpoint1 = makePublishedCheckpoint(checkpoint1Cp, 10);
+                // Create another checkpoint with 2 blocks
+                const previousArchive1 = checkpoint1Cp.blocks.at(-1).archive;
+                const checkpoint2Cp = await Checkpoint.random(CheckpointNumber(2), {
+                    numBlocks: 2,
+                    startBlockNumber: 4,
+                    previousArchive: previousArchive1
+                });
+                const checkpoint2 = makePublishedCheckpoint(checkpoint2Cp, 11);
+                await store.addCheckpoints([
+                    checkpoint1,
+                    checkpoint2
+                ]);
+                // Check blocks from the first checkpoint (blocks 1, 2, 3)
+                for(let i = 0; i < 3; i++){
+                    const blockNumber = i + 1;
+                    const retrievedBlock = await store.getCheckpointedBlock(blockNumber);
+                    expect(retrievedBlock).toBeDefined();
+                    expect(retrievedBlock.checkpointNumber).toBe(1);
+                    expect(retrievedBlock.block.number).toBe(blockNumber);
+                    expect(retrievedBlock.l1).toEqual(checkpoint1.l1);
+                    expect(retrievedBlock.attestations.every((a, j)=>a.equals(checkpoint1.attestations[j]))).toBe(true);
+                }
+                // Check blocks from the second checkpoint (blocks 4, 5)
+                for(let i = 0; i < 2; i++){
+                    const blockNumber = i + 4;
+                    const retrievedBlock = await store.getCheckpointedBlock(blockNumber);
+                    expect(retrievedBlock).toBeDefined();
+                    expect(retrievedBlock.checkpointNumber).toBe(2);
+                    expect(retrievedBlock.block.number).toBe(blockNumber);
+                    expect(retrievedBlock.l1).toEqual(checkpoint2.l1);
+                    expect(retrievedBlock.attestations.every((a, j)=>a.equals(checkpoint2.attestations[j]))).toBe(true);
+                }
             });
-            it('returns an empty array if no blocks are found', async ()=>{
-                await expect(store.getPublishedBlocks(BlockNumber(12), 1)).resolves.toEqual([]);
+            it('getCheckpointedBlockByHash returns correct checkpoint info for blocks within multi-block checkpoints', async ()=>{
+                const checkpoint = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 3,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint
+                ]);
+                // Check each block by its hash
+                for(let i = 0; i < checkpoint.checkpoint.blocks.length; i++){
+                    const block = checkpoint.checkpoint.blocks[i];
+                    const blockHash = await block.header.hash();
+                    const retrievedBlock = await store.getCheckpointedBlockByHash(blockHash);
+                    expect(retrievedBlock).toBeDefined();
+                    expect(retrievedBlock.checkpointNumber).toBe(1);
+                    expect(retrievedBlock.block.number).toBe(i + 1);
+                    expect(retrievedBlock.l1).toEqual(checkpoint.l1);
+                }
             });
-            it('throws an error if limit is invalid', async ()=>{
-                await expect(store.getPublishedBlocks(BlockNumber(1), 0)).rejects.toThrow('Invalid limit: 0');
+            it('getCheckpointedBlockByArchive returns correct checkpoint info for blocks within multi-block checkpoints', async ()=>{
+                const checkpoint = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 3,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint
+                ]);
+                // Check each block by its archive root
+                for(let i = 0; i < checkpoint.checkpoint.blocks.length; i++){
+                    const block = checkpoint.checkpoint.blocks[i];
+                    const archive = block.archive.root;
+                    const retrievedBlock = await store.getCheckpointedBlockByArchive(archive);
+                    expect(retrievedBlock).toBeDefined();
+                    expect(retrievedBlock.checkpointNumber).toBe(1);
+                    expect(retrievedBlock.block.number).toBe(i + 1);
+                    expect(retrievedBlock.l1).toEqual(checkpoint.l1);
+                }
             });
-            it('throws an error if `from` it is out of range', async ()=>{
-                await expect(store.getPublishedBlocks(INITIAL_L2_BLOCK_NUM - 100, 1)).rejects.toThrow('Invalid start: -99');
+            it('unwinding a multi-block checkpoint removes all its blocks', async ()=>{
+                const checkpoint = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 3,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint
+                ]);
+                // Verify all 3 blocks exist
+                for(let blockNumber = 1; blockNumber <= 3; blockNumber++){
+                    expect(await store.getCheckpointedBlock(blockNumber)).toBeDefined();
+                }
+                // Unwind the checkpoint
+                await store.unwindCheckpoints(CheckpointNumber(1), 1);
+                // Verify all 3 blocks are removed
+                for(let blockNumber = 1; blockNumber <= 3; blockNumber++){
+                    expect(await store.getCheckpointedBlock(blockNumber)).toBeUndefined();
+                }
+                expect(await store.getSynchedCheckpointNumber()).toBe(0);
+                expect(await store.getLatestBlockNumber()).toBe(0);
             });
-            it('throws an error if unexpected initial block number is found', async ()=>{
+        });
+        describe('uncheckpointed blocks', ()=>{
+            it('can add blocks independently before a checkpoint arrives', async ()=>{
+                // First, establish some checkpointed blocks (checkpoint 1 with blocks 1-3)
+                const checkpoint1 = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 3,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint1
+                ]);
+                expect(await store.getSynchedCheckpointNumber()).toBe(1);
+                expect(await store.getLatestBlockNumber()).toBe(3);
+                // Now add blocks 4, 5, 6 independently (without a checkpoint) for upcoming checkpoint 2
+                // Chain archive roots from the last block of checkpoint 1
+                const lastBlockArchive = checkpoint1.checkpoint.blocks.at(-1).archive;
+                const block4 = await L2BlockNew.random(BlockNumber(4), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 0,
+                    lastArchive: lastBlockArchive
+                });
+                const block5 = await L2BlockNew.random(BlockNumber(5), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 1,
+                    lastArchive: block4.archive
+                });
+                const block6 = await L2BlockNew.random(BlockNumber(6), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 2,
+                    lastArchive: block5.archive
+                });
                 await store.addBlocks([
-                    makePublished(await L2Block.random(BlockNumber(21)), 31)
-                ], {
-                    force: true
+                    block4,
+                    block5,
+                    block6
+                ]);
+                // Checkpoint number should still be 1 (no new checkpoint added)
+                expect(await store.getSynchedCheckpointNumber()).toBe(1);
+                // But latest block number should be 6
+                expect(await store.getLatestBlockNumber()).toBe(6);
+            });
+            it('getBlock retrieves uncheckpointed blocks', async ()=>{
+                // First, establish some checkpointed blocks
+                const checkpoint1 = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint1
+                ]);
+                // Add uncheckpointed blocks for upcoming checkpoint 2, chaining archive roots
+                const lastBlockArchive = checkpoint1.checkpoint.blocks.at(-1).archive;
+                const block3 = await L2BlockNew.random(BlockNumber(3), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 0,
+                    lastArchive: lastBlockArchive
+                });
+                const block4 = await L2BlockNew.random(BlockNumber(4), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 1,
+                    lastArchive: block3.archive
+                });
+                await store.addBlocks([
+                    block3,
+                    block4
+                ]);
+                // getBlock should work for both checkpointed and uncheckpointed blocks
+                expect((await store.getBlock(1))?.number).toBe(1);
+                expect((await store.getBlock(2))?.number).toBe(2);
+                expect(await store.getBlock(3)).toEqual(block3);
+                expect(await store.getBlock(4)).toEqual(block4);
+                expect(await store.getBlock(5)).toBeUndefined();
+                const block5 = await L2BlockNew.random(BlockNumber(5), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 2,
+                    lastArchive: block4.archive
+                });
+                await store.addBlocks([
+                    block5
+                ]);
+                // Verify the uncheckpointed blocks have correct data
+                const retrieved3 = await store.getBlock(3);
+                expect(retrieved3.number).toBe(3);
+                expect(retrieved3).toEqual(block3);
+                const retrieved4 = await store.getBlock(4);
+                expect(retrieved4.number).toBe(4);
+                expect(retrieved4).toEqual(block4);
+                const retrieved5 = await store.getBlock(5);
+                expect(retrieved5.number).toBe(5);
+                expect(retrieved5).toEqual(block5);
+            });
+            it('getBlockByHash retrieves uncheckpointed blocks', async ()=>{
+                // Add uncheckpointed blocks (no checkpoints at all) for initial checkpoint 1, chaining archive roots
+                const block1 = await L2BlockNew.random(BlockNumber(1), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 0
+                });
+                const block2 = await L2BlockNew.random(BlockNumber(2), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 1,
+                    lastArchive: block1.archive
+                });
+                await store.addBlocks([
+                    block1,
+                    block2
+                ]);
+                // getBlockByHash should work for uncheckpointed blocks
+                const hash1 = await block1.header.hash();
+                const hash2 = await block2.header.hash();
+                const retrieved1 = await store.getBlockByHash(hash1);
+                expect(retrieved1).toEqual(block1);
+                const retrieved2 = await store.getBlockByHash(hash2);
+                expect(retrieved2).toEqual(block2);
+            });
+            it('getBlockByArchive retrieves uncheckpointed blocks', async ()=>{
+                // Add uncheckpointed blocks for initial checkpoint 1, chaining archive roots
+                const block1 = await L2BlockNew.random(BlockNumber(1), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 0
+                });
+                const block2 = await L2BlockNew.random(BlockNumber(2), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 1,
+                    lastArchive: block1.archive
+                });
+                await store.addBlocks([
+                    block1,
+                    block2
+                ]);
+                // getBlockByArchive should work for uncheckpointed blocks
+                const archive1 = block1.archive.root;
+                const archive2 = block2.archive.root;
+                const retrieved1 = await store.getBlockByArchive(archive1);
+                expect(retrieved1).toEqual(block1);
+                const retrieved2 = await store.getBlockByArchive(archive2);
+                expect(retrieved2).toEqual(block2);
+            });
+            it('getCheckpointedBlock returns undefined for uncheckpointed blocks', async ()=>{
+                // Add a checkpoint with blocks 1-2
+                const checkpoint1 = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint1
+                ]);
+                // Add uncheckpointed blocks 3-4 for upcoming checkpoint 2, chaining archive roots
+                const lastBlockArchive = checkpoint1.checkpoint.blocks.at(-1).archive;
+                const block3 = await L2BlockNew.random(BlockNumber(3), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 0,
+                    lastArchive: lastBlockArchive
+                });
+                const block4 = await L2BlockNew.random(BlockNumber(4), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 1,
+                    lastArchive: block3.archive
+                });
+                await store.addBlocks([
+                    block3,
+                    block4
+                ]);
+                // getCheckpointedBlock should work for checkpointed blocks
+                expect((await store.getCheckpointedBlock(1))?.block.number).toBe(1);
+                expect((await store.getCheckpointedBlock(2))?.block.number).toBe(2);
+                // getCheckpointedBlock should return undefined for uncheckpointed blocks
+                expect(await store.getCheckpointedBlock(3)).toBeUndefined();
+                expect(await store.getCheckpointedBlock(4)).toBeUndefined();
+                // But getBlock should work for all blocks
+                expect(await store.getBlock(3)).toEqual(block3);
+                expect(await store.getBlock(4)).toEqual(block4);
+            });
+            it('getCheckpointedBlockByHash returns undefined for uncheckpointed blocks', async ()=>{
+                // Add uncheckpointed blocks for initial checkpoint 1
+                const block1 = await L2BlockNew.random(BlockNumber(1), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 0
+                });
+                await store.addBlocks([
+                    block1
+                ]);
+                const hash = await block1.header.hash();
+                // getCheckpointedBlockByHash should return undefined
+                expect(await store.getCheckpointedBlockByHash(hash)).toBeUndefined();
+                // But getBlockByHash should work
+                expect(await store.getBlockByHash(hash)).toEqual(block1);
+            });
+            it('getCheckpointedBlockByArchive returns undefined for uncheckpointed blocks', async ()=>{
+                // Add uncheckpointed blocks for initial checkpoint 1
+                const block1 = await L2BlockNew.random(BlockNumber(1), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 0
+                });
+                await store.addBlocks([
+                    block1
+                ]);
+                const archive = block1.archive.root;
+                // getCheckpointedBlockByArchive should return undefined
+                expect(await store.getCheckpointedBlockByArchive(archive)).toBeUndefined();
+                // But getBlockByArchive should work
+                expect(await store.getBlockByArchive(archive)).toEqual(block1);
+            });
+            it('checkpoint adopts previously added uncheckpointed blocks', async ()=>{
+                // Add blocks 1-3 without a checkpoint (for initial checkpoint 1), chaining archive roots
+                const block1 = await L2BlockNew.random(BlockNumber(1), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 0
                 });
-                await expect(store.getPublishedBlocks(BlockNumber(20), 1)).rejects.toThrow(`mismatch`);
+                const block2 = await L2BlockNew.random(BlockNumber(2), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 1,
+                    lastArchive: block1.archive
+                });
+                const block3 = await L2BlockNew.random(BlockNumber(3), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 2,
+                    lastArchive: block2.archive
+                });
+                await store.addBlocks([
+                    block1,
+                    block2,
+                    block3
+                ]);
+                expect(await store.getSynchedCheckpointNumber()).toBe(0);
+                expect(await store.getLatestBlockNumber()).toBe(3);
+                // getCheckpointedBlock should return undefined for all
+                expect(await store.getCheckpointedBlock(1)).toBeUndefined();
+                expect(await store.getCheckpointedBlock(2)).toBeUndefined();
+                expect(await store.getCheckpointedBlock(3)).toBeUndefined();
+                // Now add a checkpoint that covers blocks 1-3
+                const checkpoint1 = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 3,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint1
+                ]);
+                expect(await store.getSynchedCheckpointNumber()).toBe(1);
+                expect(await store.getLatestBlockNumber()).toBe(3);
+                // Now getCheckpointedBlock should work for all blocks
+                const checkpointed1 = await store.getCheckpointedBlock(1);
+                expect(checkpointed1).toBeDefined();
+                expect(checkpointed1.checkpointNumber).toBe(1);
+                expect(checkpointed1.l1).toEqual(checkpoint1.l1);
+                const checkpointed2 = await store.getCheckpointedBlock(2);
+                expect(checkpointed2).toBeDefined();
+                expect(checkpointed2.checkpointNumber).toBe(1);
+                const checkpointed3 = await store.getCheckpointedBlock(3);
+                expect(checkpointed3).toBeDefined();
+                expect(checkpointed3.checkpointNumber).toBe(1);
+            });
+            it('can add more uncheckpointed blocks after a checkpoint and then checkpoint them', async ()=>{
+                // Start with checkpoint 1 covering blocks 1-2
+                const checkpoint1 = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint1
+                ]);
+                // Add uncheckpointed blocks 3-5 for the upcoming checkpoint 2, chaining archive roots
+                const lastBlockArchive = checkpoint1.checkpoint.blocks.at(-1).archive;
+                const block3 = await L2BlockNew.random(BlockNumber(3), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 0,
+                    lastArchive: lastBlockArchive
+                });
+                const block4 = await L2BlockNew.random(BlockNumber(4), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 1,
+                    lastArchive: block3.archive
+                });
+                const block5 = await L2BlockNew.random(BlockNumber(5), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 2,
+                    lastArchive: block4.archive
+                });
+                await store.addBlocks([
+                    block3,
+                    block4,
+                    block5
+                ]);
+                expect(await store.getSynchedCheckpointNumber()).toBe(1);
+                expect(await store.getLatestBlockNumber()).toBe(5);
+                // Blocks 3-5 are not checkpointed yet
+                expect(await store.getCheckpointedBlock(3)).toBeUndefined();
+                expect(await store.getCheckpointedBlock(4)).toBeUndefined();
+                expect(await store.getCheckpointedBlock(5)).toBeUndefined();
+                // Add checkpoint 2 covering blocks 3-5, chaining from checkpoint1
+                const checkpoint2 = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(2), {
+                    numBlocks: 3,
+                    startBlockNumber: 3,
+                    previousArchive: lastBlockArchive
+                }), 11);
+                await store.addCheckpoints([
+                    checkpoint2
+                ]);
+                expect(await store.getSynchedCheckpointNumber()).toBe(2);
+                expect(await store.getLatestBlockNumber()).toBe(5);
+                // Now blocks 3-5 should be checkpointed with checkpoint 2's info
+                const checkpointed3 = await store.getCheckpointedBlock(3);
+                expect(checkpointed3).toBeDefined();
+                expect(checkpointed3.checkpointNumber).toBe(2);
+                expect(checkpointed3.l1).toEqual(checkpoint2.l1);
+                const checkpointed4 = await store.getCheckpointedBlock(4);
+                expect(checkpointed4).toBeDefined();
+                expect(checkpointed4.checkpointNumber).toBe(2);
+                const checkpointed5 = await store.getCheckpointedBlock(5);
+                expect(checkpointed5).toBeDefined();
+                expect(checkpointed5.checkpointNumber).toBe(2);
+            });
+            it('getBlocks retrieves both checkpointed and uncheckpointed blocks', async ()=>{
+                // Add checkpoint with blocks 1-2
+                const checkpoint1 = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint1
+                ]);
+                // Add uncheckpointed blocks 3-4 for the upcoming checkpoint 2, chaining archive roots
+                const lastBlockArchive = checkpoint1.checkpoint.blocks.at(-1).archive;
+                const block3 = await L2BlockNew.random(BlockNumber(3), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 0,
+                    lastArchive: lastBlockArchive
+                });
+                const block4 = await L2BlockNew.random(BlockNumber(4), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 1,
+                    lastArchive: block3.archive
+                });
+                await store.addBlocks([
+                    block3,
+                    block4
+                ]);
+                // getBlocks should retrieve all blocks
+                const allBlocks = await store.getBlocks(1, 10);
+                expect(allBlocks.length).toBe(4);
+                expect(allBlocks.map((b)=>b.number)).toEqual([
+                    1,
+                    2,
+                    3,
+                    4
+                ]);
             });
-            it('throws an error if a gap is found', async ()=>{
+        });
+        describe('addBlocks validation', ()=>{
+            it('throws if blocks have different checkpoint numbers', async ()=>{
+                // First, establish checkpoint 1 with blocks 1-2
+                const checkpoint1 = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint1
+                ]);
+                // Try to add blocks 3 and 4 with different checkpoint numbers
+                // Chain archives correctly to test the checkpoint number validation
+                const lastBlockArchive = checkpoint1.checkpoint.blocks.at(-1).archive;
+                const block3 = await L2BlockNew.random(BlockNumber(3), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 0,
+                    lastArchive: lastBlockArchive
+                });
+                const block4 = await L2BlockNew.random(BlockNumber(4), {
+                    checkpointNumber: CheckpointNumber(3),
+                    indexWithinCheckpoint: 1,
+                    lastArchive: block3.archive
+                });
+                await expect(store.addBlocks([
+                    block3,
+                    block4
+                ])).rejects.toThrow(CheckpointNumberNotConsistentError);
+            });
+            it('throws if checkpoint number is not the current checkpoint', async ()=>{
+                // First, establish checkpoint 1 with blocks 1-2
+                const checkpoint1 = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint1
+                ]);
+                // Try to add blocks for checkpoint 3 (skipping checkpoint 2)
+                const block3 = await L2BlockNew.random(BlockNumber(3), {
+                    checkpointNumber: CheckpointNumber(3),
+                    indexWithinCheckpoint: 0
+                });
+                const block4 = await L2BlockNew.random(BlockNumber(4), {
+                    checkpointNumber: CheckpointNumber(3),
+                    indexWithinCheckpoint: 1
+                });
+                await expect(store.addBlocks([
+                    block3,
+                    block4
+                ])).rejects.toThrow(InitialCheckpointNumberNotSequentialError);
+            });
+            it('allows blocks with the same checkpoint number for the current checkpoint', async ()=>{
+                // First, establish checkpoint 1 with blocks 1-2
+                const checkpoint1 = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint1
+                ]);
+                // Add blocks 3 and 4 with consistent checkpoint number (2), chaining archive roots
+                const lastBlockArchive = checkpoint1.checkpoint.blocks.at(-1).archive;
+                const block3 = await L2BlockNew.random(BlockNumber(3), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 0,
+                    lastArchive: lastBlockArchive
+                });
+                const block4 = await L2BlockNew.random(BlockNumber(4), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 1,
+                    lastArchive: block3.archive
+                });
+                await expect(store.addBlocks([
+                    block3,
+                    block4
+                ])).resolves.toBe(true);
+                // Verify blocks were added
+                expect(await store.getBlock(3)).toEqual(block3);
+                expect(await store.getBlock(4)).toEqual(block4);
+            });
+            it('allows blocks for the initial checkpoint when store is empty', async ()=>{
+                // Add blocks for the initial checkpoint (1), chaining archive roots
+                const block1 = await L2BlockNew.random(BlockNumber(1), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 0
+                });
+                const block2 = await L2BlockNew.random(BlockNumber(2), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 1,
+                    lastArchive: block1.archive
+                });
+                await expect(store.addBlocks([
+                    block1,
+                    block2
+                ])).resolves.toBe(true);
+                // Verify blocks were added
+                expect(await store.getBlock(1)).toEqual(block1);
+                expect(await store.getBlock(2)).toEqual(block2);
+                expect(await store.getLatestBlockNumber()).toBe(2);
+            });
+            it('throws if initial block is duplicated across calls', async ()=>{
+                // Add blocks for the initial checkpoint (1)
+                const block1 = await L2BlockNew.random(BlockNumber(1), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 0
+                });
+                const block2 = await L2BlockNew.random(BlockNumber(1), {
+                    checkpointNumber: CheckpointNumber(1),
+                    indexWithinCheckpoint: 0
+                });
+                await expect(store.addBlocks([
+                    block1
+                ])).resolves.toBe(true);
+                await expect(store.addBlocks([
+                    block2
+                ])).rejects.toThrow(InitialBlockNumberNotSequentialError);
+            });
+            it('throws if first block has wrong checkpoint number when store is empty', async ()=>{
+                // Try to add blocks for checkpoint 2 when store is empty (should start at 1)
+                const block1 = await L2BlockNew.random(BlockNumber(1), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 0
+                });
+                const block2 = await L2BlockNew.random(BlockNumber(2), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 1
+                });
+                await expect(store.addBlocks([
+                    block1,
+                    block2
+                ])).rejects.toThrow(InitialCheckpointNumberNotSequentialError);
+            });
+            it('allows adding more blocks to the same checkpoint in separate calls', async ()=>{
+                // First, establish checkpoint 1 with blocks 1-2
+                const checkpoint1 = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint1
+                ]);
+                // Add block 3 for checkpoint 2, chaining archive roots
+                const lastBlockArchive = checkpoint1.checkpoint.blocks.at(-1).archive;
+                const block3 = await L2BlockNew.random(BlockNumber(3), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 0,
+                    lastArchive: lastBlockArchive
+                });
+                await expect(store.addBlocks([
+                    block3
+                ])).resolves.toBe(true);
+                // Add block 4 for the same checkpoint 2 in a separate call
+                const block4 = await L2BlockNew.random(BlockNumber(4), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 1,
+                    lastArchive: block3.archive
+                });
+                await expect(store.addBlocks([
+                    block4
+                ])).resolves.toBe(true);
+                expect(await store.getLatestBlockNumber()).toBe(4);
+            });
+            it('throws if adding blocks in separate calls with non-consecutive indexes', async ()=>{
+                // First, establish checkpoint 1 with blocks 1-2
+                const checkpoint1 = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint1
+                ]);
+                // Add block 3 for checkpoint 2, chaining archive roots
+                const lastBlockArchive = checkpoint1.checkpoint.blocks.at(-1).archive;
+                const block3 = await L2BlockNew.random(BlockNumber(3), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 0,
+                    lastArchive: lastBlockArchive
+                });
+                await expect(store.addBlocks([
+                    block3
+                ])).resolves.toBe(true);
+                // Add block 4 for the same checkpoint 2 in a separate call but with a missing index
+                const block4 = await L2BlockNew.random(BlockNumber(4), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 2,
+                    lastArchive: block3.archive
+                });
+                await expect(store.addBlocks([
+                    block4
+                ])).rejects.toThrow(BlockIndexNotSequentialError);
+                expect(await store.getLatestBlockNumber()).toBe(3);
+            });
+            it('throws if second batch of blocks has different checkpoint number than first batch', async ()=>{
+                // First, establish checkpoint 1 with blocks 1-2
+                const checkpoint1 = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint1
+                ]);
+                // Add block 3 for checkpoint 2, chaining archive roots
+                const lastBlockArchive = checkpoint1.checkpoint.blocks.at(-1).archive;
+                const block3 = await L2BlockNew.random(BlockNumber(3), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 0,
+                    lastArchive: lastBlockArchive
+                });
                 await store.addBlocks([
-                    makePublished(await L2Block.random(BlockNumber(20)), 30),
-                    makePublished(await L2Block.random(BlockNumber(22)), 32)
+                    block3
+                ]);
+                // Try to add block 4 for checkpoint 3 (should fail because current checkpoint is still 2)
+                const block4 = await L2BlockNew.random(BlockNumber(4), {
+                    checkpointNumber: CheckpointNumber(3),
+                    indexWithinCheckpoint: 0,
+                    lastArchive: block3.archive
+                });
+                await expect(store.addBlocks([
+                    block4
+                ])).rejects.toThrow(InitialCheckpointNumberNotSequentialError);
+            });
+            it('force option bypasses checkpoint number validation', async ()=>{
+                // First, establish checkpoint 1 with blocks 1-2
+                const checkpoint1 = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint1
+                ]);
+                // Add blocks with different checkpoint numbers using force option, chaining archive roots
+                const lastBlockArchive = checkpoint1.checkpoint.blocks.at(-1).archive;
+                const block3 = await L2BlockNew.random(BlockNumber(3), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 0,
+                    lastArchive: lastBlockArchive
+                });
+                const block4 = await L2BlockNew.random(BlockNumber(4), {
+                    checkpointNumber: CheckpointNumber(5),
+                    indexWithinCheckpoint: 0,
+                    lastArchive: block3.archive
+                });
+                await expect(store.addBlocks([
+                    block3,
+                    block4
                 ], {
                     force: true
+                })).resolves.toBe(true);
+            });
+            it('force option bypasses blockindex number validation', async ()=>{
+                // First, establish checkpoint 1 with blocks 1-2
+                const checkpoint1 = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint1
+                ]);
+                // Add blocks with different checkpoint numbers using force option, chaining archive roots
+                const lastBlockArchive = checkpoint1.checkpoint.blocks.at(-1).archive;
+                const block3 = await L2BlockNew.random(BlockNumber(3), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 0,
+                    lastArchive: lastBlockArchive
+                });
+                const block4 = await L2BlockNew.random(BlockNumber(4), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 2,
+                    lastArchive: block3.archive
+                });
+                await expect(store.addBlocks([
+                    block3,
+                    block4
+                ], {
+                    force: true
+                })).resolves.toBe(true);
+            });
+            it('throws if adding blocks with non-consecutive archives', async ()=>{
+                // First, establish checkpoint 1 with blocks 1-2
+                const checkpoint1 = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint1
+                ]);
+                // Add block 3 for checkpoint 2 with incorrect archive
+                const block3 = await L2BlockNew.random(BlockNumber(3), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 0
+                });
+                await expect(store.addBlocks([
+                    block3
+                ])).rejects.toThrow(BlockArchiveNotConsistentError);
+                expect(await store.getLatestBlockNumber()).toBe(2);
+            });
+            it('throws if adding blocks with non-consecutive archives across calls', async ()=>{
+                // First, establish checkpoint 1 with blocks 1-2
+                const checkpoint1 = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint1
+                ]);
+                // Add block 3 for checkpoint 2 with correct archive
+                const lastBlockArchive = checkpoint1.checkpoint.blocks.at(-1).archive;
+                const block3 = await L2BlockNew.random(BlockNumber(3), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 0,
+                    lastArchive: lastBlockArchive
+                });
+                await expect(store.addBlocks([
+                    block3
+                ])).resolves.toBe(true);
+                // Add block 4 with incorrect archive (should fail)
+                const block4 = await L2BlockNew.random(BlockNumber(4), {
+                    checkpointNumber: CheckpointNumber(2),
+                    indexWithinCheckpoint: 1,
+                    lastArchive: AppendOnlyTreeSnapshot.random()
+                });
+                await expect(store.addBlocks([
+                    block4
+                ])).rejects.toThrow(BlockArchiveNotConsistentError);
+                expect(await store.getLatestBlockNumber()).toBe(3);
+            });
+        });
+        describe('getBlocksForCheckpoint', ()=>{
+            it('returns blocks for a single-block checkpoint', async ()=>{
+                const checkpoint = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 1,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint
+                ]);
+                const blocks = await store.getBlocksForCheckpoint(CheckpointNumber(1));
+                expect(blocks).toBeDefined();
+                expect(blocks.length).toBe(1);
+                expect(blocks[0].number).toBe(1);
+            });
+            it('returns all blocks for a multi-block checkpoint', async ()=>{
+                const checkpoint = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 4,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint
+                ]);
+                const blocks = await store.getBlocksForCheckpoint(CheckpointNumber(1));
+                expect(blocks).toBeDefined();
+                expect(blocks.length).toBe(4);
+                expect(blocks.map((b)=>b.number)).toEqual([
+                    1,
+                    2,
+                    3,
+                    4
+                ]);
+            });
+            it('returns correct blocks for different checkpoints', async ()=>{
+                // Create checkpoints with chained archive roots
+                // Checkpoint 1: blocks 1-2
+                const checkpoint1Cp = await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                });
+                const checkpoint1 = makePublishedCheckpoint(checkpoint1Cp, 10);
+                // Checkpoint 2: blocks 3-5
+                const previousArchive1 = checkpoint1Cp.blocks.at(-1).archive;
+                const checkpoint2Cp = await Checkpoint.random(CheckpointNumber(2), {
+                    numBlocks: 3,
+                    startBlockNumber: 3,
+                    previousArchive: previousArchive1
+                });
+                const checkpoint2 = makePublishedCheckpoint(checkpoint2Cp, 11);
+                // Checkpoint 3: blocks 6-7
+                const previousArchive2 = checkpoint2Cp.blocks.at(-1).archive;
+                const checkpoint3Cp = await Checkpoint.random(CheckpointNumber(3), {
+                    numBlocks: 2,
+                    startBlockNumber: 6,
+                    previousArchive: previousArchive2
+                });
+                const checkpoint3 = makePublishedCheckpoint(checkpoint3Cp, 12);
+                await store.addCheckpoints([
+                    checkpoint1,
+                    checkpoint2,
+                    checkpoint3
+                ]);
+                const blocks1 = await store.getBlocksForCheckpoint(CheckpointNumber(1));
+                expect(blocks1).toBeDefined();
+                expect(blocks1.map((b)=>b.number)).toEqual([
+                    1,
+                    2
+                ]);
+                const blocks2 = await store.getBlocksForCheckpoint(CheckpointNumber(2));
+                expect(blocks2).toBeDefined();
+                expect(blocks2.map((b)=>b.number)).toEqual([
+                    3,
+                    4,
+                    5
+                ]);
+                const blocks3 = await store.getBlocksForCheckpoint(CheckpointNumber(3));
+                expect(blocks3).toBeDefined();
+                expect(blocks3.map((b)=>b.number)).toEqual([
+                    6,
+                    7
+                ]);
+            });
+            it('returns undefined for non-existent checkpoint', async ()=>{
+                const checkpoint = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint
+                ]);
+                const blocks = await store.getBlocksForCheckpoint(CheckpointNumber(5));
+                expect(blocks).toBeUndefined();
+            });
+            it('returns undefined when no checkpoints exist', async ()=>{
+                const blocks = await store.getBlocksForCheckpoint(CheckpointNumber(1));
+                expect(blocks).toBeUndefined();
+            });
+        });
+        describe('getRangeOfCheckpoints', ()=>{
+            it('returns empty array when no checkpoints exist', async ()=>{
+                const checkpoints = await store.getRangeOfCheckpoints(CheckpointNumber(1), 10);
+                expect(checkpoints).toEqual([]);
+            });
+            it('returns single checkpoint', async ()=>{
+                const checkpoint = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint
+                ]);
+                const checkpoints = await store.getRangeOfCheckpoints(CheckpointNumber(1), 10);
+                expect(checkpoints.length).toBe(1);
+                expect(checkpoints[0].checkpointNumber).toBe(1);
+                expect(checkpoints[0].startBlock).toBe(1);
+                expect(checkpoints[0].numBlocks).toBe(2);
+            });
+            it('returns multiple checkpoints in order', async ()=>{
+                // Create checkpoints with chained archive roots
+                const checkpoint1Cp = await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                });
+                const checkpoint1 = makePublishedCheckpoint(checkpoint1Cp, 10);
+                const previousArchive1 = checkpoint1Cp.blocks.at(-1).archive;
+                const checkpoint2Cp = await Checkpoint.random(CheckpointNumber(2), {
+                    numBlocks: 3,
+                    startBlockNumber: 3,
+                    previousArchive: previousArchive1
+                });
+                const checkpoint2 = makePublishedCheckpoint(checkpoint2Cp, 11);
+                const previousArchive2 = checkpoint2Cp.blocks.at(-1).archive;
+                const checkpoint3Cp = await Checkpoint.random(CheckpointNumber(3), {
+                    numBlocks: 1,
+                    startBlockNumber: 6,
+                    previousArchive: previousArchive2
+                });
+                const checkpoint3 = makePublishedCheckpoint(checkpoint3Cp, 12);
+                await store.addCheckpoints([
+                    checkpoint1,
+                    checkpoint2,
+                    checkpoint3
+                ]);
+                const checkpoints = await store.getRangeOfCheckpoints(CheckpointNumber(1), 10);
+                expect(checkpoints.length).toBe(3);
+                expect(checkpoints.map((c)=>c.checkpointNumber)).toEqual([
+                    1,
+                    2,
+                    3
+                ]);
+                expect(checkpoints.map((c)=>c.startBlock)).toEqual([
+                    1,
+                    3,
+                    6
+                ]);
+                expect(checkpoints.map((c)=>c.numBlocks)).toEqual([
+                    2,
+                    3,
+                    1
+                ]);
+            });
+            it('respects the from parameter', async ()=>{
+                // Create checkpoints with chained archive roots
+                const checkpoint1Cp = await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
                 });
-                await expect(store.getPublishedBlocks(BlockNumber(20), 2)).rejects.toThrow(`mismatch`);
+                const checkpoint1 = makePublishedCheckpoint(checkpoint1Cp, 10);
+                const previousArchive1 = checkpoint1Cp.blocks.at(-1).archive;
+                const checkpoint2Cp = await Checkpoint.random(CheckpointNumber(2), {
+                    numBlocks: 2,
+                    startBlockNumber: 3,
+                    previousArchive: previousArchive1
+                });
+                const checkpoint2 = makePublishedCheckpoint(checkpoint2Cp, 11);
+                const previousArchive2 = checkpoint2Cp.blocks.at(-1).archive;
+                const checkpoint3Cp = await Checkpoint.random(CheckpointNumber(3), {
+                    numBlocks: 2,
+                    startBlockNumber: 5,
+                    previousArchive: previousArchive2
+                });
+                const checkpoint3 = makePublishedCheckpoint(checkpoint3Cp, 12);
+                await store.addCheckpoints([
+                    checkpoint1,
+                    checkpoint2,
+                    checkpoint3
+                ]);
+                // Start from checkpoint 2
+                const checkpoints = await store.getRangeOfCheckpoints(CheckpointNumber(2), 10);
+                expect(checkpoints.length).toBe(2);
+                expect(checkpoints.map((c)=>c.checkpointNumber)).toEqual([
+                    2,
+                    3
+                ]);
+            });
+            it('respects the limit parameter', async ()=>{
+                // Create checkpoints with chained archive roots
+                const checkpoint1Cp = await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 1,
+                    startBlockNumber: 1
+                });
+                const checkpoint1 = makePublishedCheckpoint(checkpoint1Cp, 10);
+                const previousArchive1 = checkpoint1Cp.blocks.at(-1).archive;
+                const checkpoint2Cp = await Checkpoint.random(CheckpointNumber(2), {
+                    numBlocks: 1,
+                    startBlockNumber: 2,
+                    previousArchive: previousArchive1
+                });
+                const checkpoint2 = makePublishedCheckpoint(checkpoint2Cp, 11);
+                const previousArchive2 = checkpoint2Cp.blocks.at(-1).archive;
+                const checkpoint3Cp = await Checkpoint.random(CheckpointNumber(3), {
+                    numBlocks: 1,
+                    startBlockNumber: 3,
+                    previousArchive: previousArchive2
+                });
+                const checkpoint3 = makePublishedCheckpoint(checkpoint3Cp, 12);
+                const previousArchive3 = checkpoint3Cp.blocks.at(-1).archive;
+                const checkpoint4Cp = await Checkpoint.random(CheckpointNumber(4), {
+                    numBlocks: 1,
+                    startBlockNumber: 4,
+                    previousArchive: previousArchive3
+                });
+                const checkpoint4 = makePublishedCheckpoint(checkpoint4Cp, 13);
+                await store.addCheckpoints([
+                    checkpoint1,
+                    checkpoint2,
+                    checkpoint3,
+                    checkpoint4
+                ]);
+                // Only get 2 checkpoints
+                const checkpoints = await store.getRangeOfCheckpoints(CheckpointNumber(1), 2);
+                expect(checkpoints.length).toBe(2);
+                expect(checkpoints.map((c)=>c.checkpointNumber)).toEqual([
+                    1,
+                    2
+                ]);
+            });
+            it('returns correct checkpoint data including L1 info', async ()=>{
+                const checkpoint = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 3,
+                    startBlockNumber: 1
+                }), 42);
+                await store.addCheckpoints([
+                    checkpoint
+                ]);
+                const checkpoints = await store.getRangeOfCheckpoints(CheckpointNumber(1), 1);
+                expect(checkpoints.length).toBe(1);
+                const data = checkpoints[0];
+                expect(data.checkpointNumber).toBe(1);
+                expect(data.startBlock).toBe(1);
+                expect(data.numBlocks).toBe(3);
+                expect(data.l1.blockNumber).toBe(42n);
+                expect(data.header.equals(checkpoint.checkpoint.header)).toBe(true);
+                expect(data.archive.equals(checkpoint.checkpoint.archive)).toBe(true);
+            });
+            it('returns empty array when from is beyond available checkpoints', async ()=>{
+                const checkpoint = makePublishedCheckpoint(await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                }), 10);
+                await store.addCheckpoints([
+                    checkpoint
+                ]);
+                const checkpoints = await store.getRangeOfCheckpoints(CheckpointNumber(5), 10);
+                expect(checkpoints).toEqual([]);
+            });
+            it('works correctly after unwinding checkpoints', async ()=>{
+                // Create checkpoints with chained archive roots
+                const checkpoint1Cp = await Checkpoint.random(CheckpointNumber(1), {
+                    numBlocks: 2,
+                    startBlockNumber: 1
+                });
+                const checkpoint1 = makePublishedCheckpoint(checkpoint1Cp, 10);
+                const previousArchive1 = checkpoint1Cp.blocks.at(-1).archive;
+                const checkpoint2Cp = await Checkpoint.random(CheckpointNumber(2), {
+                    numBlocks: 2,
+                    startBlockNumber: 3,
+                    previousArchive: previousArchive1
+                });
+                const checkpoint2 = makePublishedCheckpoint(checkpoint2Cp, 11);
+                const previousArchive2 = checkpoint2Cp.blocks.at(-1).archive;
+                const checkpoint3Cp = await Checkpoint.random(CheckpointNumber(3), {
+                    numBlocks: 2,
+                    startBlockNumber: 5,
+                    previousArchive: previousArchive2
+                });
+                const checkpoint3 = makePublishedCheckpoint(checkpoint3Cp, 12);
+                await store.addCheckpoints([
+                    checkpoint1,
+                    checkpoint2,
+                    checkpoint3
+                ]);
+                // Unwind checkpoint 3
+                await store.unwindCheckpoints(CheckpointNumber(3), 1);
+                const checkpoints = await store.getRangeOfCheckpoints(CheckpointNumber(1), 10);
+                expect(checkpoints.length).toBe(2);
+                expect(checkpoints.map((c)=>c.checkpointNumber)).toEqual([
+                    1,
+                    2
+                ]);
+            });
+        });
+        describe('getCheckpointedBlock', ()=>{
+            beforeEach(async ()=>{
+                await store.addCheckpoints(publishedCheckpoints);
+            });
+            it.each(blockNumberTests)('retrieves previously stored block %i', async (blockNumber, getExpectedBlock)=>{
+                const retrievedBlock = await store.getCheckpointedBlock(blockNumber);
+                const expectedBlock = getExpectedBlock();
+                const expectedCheckpoint = publishedCheckpoints[blockNumber - 1];
+                expect(retrievedBlock).toBeDefined();
+                expectCheckpointedBlockEquals(retrievedBlock, expectedBlock, expectedCheckpoint);
+            });
+            it('returns undefined if block is not found', async ()=>{
+                await expect(store.getCheckpointedBlock(12)).resolves.toBeUndefined();
+            });
+            it('returns undefined for block number 0', async ()=>{
+                await expect(store.getCheckpointedBlock(0)).resolves.toBeUndefined();
             });
         });
-        describe('getPublishedBlockByHash', ()=>{
+        describe('getCheckpointedBlockByHash', ()=>{
             beforeEach(async ()=>{
-                await store.addBlocks(blocks);
+                await store.addCheckpoints(publishedCheckpoints);
             });
             it('retrieves a block by its hash', async ()=>{
-                const expectedBlock = blocks[5];
-                const blockHash = await expectedBlock.block.hash();
-                const retrievedBlock = await store.getPublishedBlockByHash(blockHash);
+                const expectedCheckpoint = publishedCheckpoints[5];
+                const expectedBlock = expectedCheckpoint.checkpoint.blocks[0];
+                const blockHash = await expectedBlock.header.hash();
+                const retrievedBlock = await store.getCheckpointedBlockByHash(blockHash);
                 expect(retrievedBlock).toBeDefined();
-                expectBlocksEqual([
-                    retrievedBlock
-                ], [
-                    expectedBlock
-                ]);
+                expectCheckpointedBlockEquals(retrievedBlock, expectedBlock, expectedCheckpoint);
             });
             it('returns undefined for non-existent block hash', async ()=>{
                 const nonExistentHash = Fr.random();
-                await expect(store.getPublishedBlockByHash(nonExistentHash)).resolves.toBeUndefined();
+                await expect(store.getCheckpointedBlockByHash(nonExistentHash)).resolves.toBeUndefined();
             });
         });
-        describe('getPublishedBlockByArchive', ()=>{
+        describe('getCheckpointedBlockByArchive', ()=>{
             beforeEach(async ()=>{
-                await store.addBlocks(blocks);
+                await store.addCheckpoints(publishedCheckpoints);
             });
             it('retrieves a block by its archive root', async ()=>{
-                const expectedBlock = blocks[3];
-                const archive = expectedBlock.block.archive.root;
-                const retrievedBlock = await store.getPublishedBlockByArchive(archive);
+                const expectedCheckpoint = publishedCheckpoints[3];
+                const expectedBlock = expectedCheckpoint.checkpoint.blocks[0];
+                const archive = expectedBlock.archive.root;
+                const retrievedBlock = await store.getCheckpointedBlockByArchive(archive);
                 expect(retrievedBlock).toBeDefined();
-                expectBlocksEqual([
-                    retrievedBlock
-                ], [
-                    expectedBlock
-                ]);
+                expectCheckpointedBlockEquals(retrievedBlock, expectedBlock, expectedCheckpoint);
             });
             it('returns undefined for non-existent archive root', async ()=>{
                 const nonExistentArchive = Fr.random();
-                await expect(store.getPublishedBlockByArchive(nonExistentArchive)).resolves.toBeUndefined();
+                await expect(store.getCheckpointedBlockByArchive(nonExistentArchive)).resolves.toBeUndefined();
             });
         });
         describe('getBlockHeaderByHash', ()=>{
             beforeEach(async ()=>{
-                await store.addBlocks(blocks);
+                await store.addCheckpoints(publishedCheckpoints);
             });
             it('retrieves a block header by its hash', async ()=>{
-                const expectedBlock = blocks[7];
-                const blockHash = await expectedBlock.block.hash();
+                const expectedBlock = publishedCheckpoints[7].checkpoint.blocks[0];
+                const blockHash = await expectedBlock.header.hash();
                 const retrievedHeader = await store.getBlockHeaderByHash(blockHash);
                 expect(retrievedHeader).toBeDefined();
-                expect(retrievedHeader.equals(expectedBlock.block.getBlockHeader())).toBe(true);
+                expect(retrievedHeader.equals(expectedBlock.header)).toBe(true);
             });
             it('returns undefined for non-existent block hash', async ()=>{
                 const nonExistentHash = Fr.random();
@@ -242,27 +1596,27 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
         });
         describe('getBlockHeaderByArchive', ()=>{
             beforeEach(async ()=>{
-                await store.addBlocks(blocks);
+                await store.addCheckpoints(publishedCheckpoints);
             });
             it('retrieves a block header by its archive root', async ()=>{
-                const expectedBlock = blocks[2];
-                const archive = expectedBlock.block.archive.root;
+                const expectedBlock = publishedCheckpoints[2].checkpoint.blocks[0];
+                const archive = expectedBlock.archive.root;
                 const retrievedHeader = await store.getBlockHeaderByArchive(archive);
                 expect(retrievedHeader).toBeDefined();
-                expect(retrievedHeader.equals(expectedBlock.block.getBlockHeader())).toBe(true);
+                expect(retrievedHeader.equals(expectedBlock.header)).toBe(true);
             });
             it('returns undefined for non-existent archive root', async ()=>{
                 const nonExistentArchive = Fr.random();
                 await expect(store.getBlockHeaderByArchive(nonExistentArchive)).resolves.toBeUndefined();
             });
         });
-        describe('getSyncedL2BlockNumber', ()=>{
-            it('returns the block number before INITIAL_L2_BLOCK_NUM if no blocks have been added', async ()=>{
-                await expect(store.getSynchedL2BlockNumber()).resolves.toEqual(INITIAL_L2_BLOCK_NUM - 1);
+        describe('getSynchedCheckpointNumber', ()=>{
+            it('returns the checkpoint number before INITIAL_CHECKPOINT_NUMBER if no checkpoints have been added', async ()=>{
+                await expect(store.getSynchedCheckpointNumber()).resolves.toEqual(INITIAL_CHECKPOINT_NUMBER - 1);
             });
-            it("returns the most recently added block's number", async ()=>{
-                await store.addBlocks(blocks);
-                await expect(store.getSynchedL2BlockNumber()).resolves.toEqual(blocks.at(-1).block.number);
+            it('returns the most recently added checkpoint number', async ()=>{
+                await store.addCheckpoints(publishedCheckpoints);
+                await expect(store.getSynchedCheckpointNumber()).resolves.toEqual(publishedCheckpoints.at(-1).checkpoint.number);
             });
         });
         describe('getSynchPoint', ()=>{
@@ -273,7 +1627,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 });
             });
             it('returns the L1 block number in which the most recent L2 block was published', async ()=>{
-                await store.addBlocks(blocks);
+                await store.addCheckpoints(publishedCheckpoints);
                 await expect(store.getSynchPoint()).resolves.toEqual({
                     blocksSynchedTo: 19n,
                     messagesSynchedTo: undefined
@@ -325,16 +1679,17 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
         });
         describe('addLogs', ()=>{
             it('adds private & public logs', async ()=>{
-                const block = blocks[0].block;
-                await expect(store.addLogs([
-                    block
-                ])).resolves.toEqual(true);
+                const checkpoint = publishedCheckpoints[0];
+                await store.addCheckpoints([
+                    checkpoint
+                ]);
+                await expect(store.addLogs(checkpoint.checkpoint.blocks)).resolves.toEqual(true);
             });
         });
         it('deleteLogs', async ()=>{
-            const block = blocks[0].block;
+            const block = publishedCheckpoints[0].checkpoint.blocks[0];
             await store.addBlocks([
-                blocks[0]
+                block
             ]);
             await expect(store.addLogs([
                 block
@@ -351,34 +1706,35 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             })).logs.length).toEqual(0);
         });
         describe('getTxEffect', ()=>{
+            const getBlock = (i)=>publishedCheckpoints[i].checkpoint.blocks[0];
             beforeEach(async ()=>{
-                await store.addLogs(blocks.map((b)=>b.block));
-                await store.addBlocks(blocks);
+                await store.addLogs(publishedCheckpoints.flatMap((x)=>x.checkpoint.blocks));
+                await store.addCheckpoints(publishedCheckpoints);
             });
             it.each([
                 ()=>({
-                        data: blocks[0].block.body.txEffects[0],
-                        block: blocks[0].block,
+                        data: getBlock(0).body.txEffects[0],
+                        block: getBlock(0),
                         txIndexInBlock: 0
                     }),
                 ()=>({
-                        data: blocks[9].block.body.txEffects[3],
-                        block: blocks[9].block,
+                        data: getBlock(9).body.txEffects[3],
+                        block: getBlock(9),
                         txIndexInBlock: 3
                     }),
                 ()=>({
-                        data: blocks[3].block.body.txEffects[1],
-                        block: blocks[3].block,
+                        data: getBlock(3).body.txEffects[1],
+                        block: getBlock(3),
                         txIndexInBlock: 1
                     }),
                 ()=>({
-                        data: blocks[5].block.body.txEffects[2],
-                        block: blocks[5].block,
+                        data: getBlock(5).body.txEffects[2],
+                        block: getBlock(5),
                         txIndexInBlock: 2
                     }),
                 ()=>({
-                        data: blocks[1].block.body.txEffects[0],
-                        block: blocks[1].block,
+                        data: getBlock(1).body.txEffects[0],
+                        block: getBlock(1),
                         txIndexInBlock: 0
                     })
             ])('retrieves a previously stored transaction', async (getExpectedTx)=>{
@@ -386,7 +1742,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 const expectedTx = {
                     data,
                     l2BlockNumber: block.number,
-                    l2BlockHash: L2BlockHash.fromField(await block.hash()),
+                    l2BlockHash: L2BlockHash.fromField(await block.header.hash()),
                     txIndexInBlock
                 };
                 const actualTx = await store.getTxEffect(data.txHash);
@@ -396,32 +1752,32 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 await expect(store.getTxEffect(TxHash.random())).resolves.toBeUndefined();
             });
             it.each([
-                ()=>wrapDataInBlock(blocks[0].block.body.txEffects[0], blocks[0].block),
-                ()=>wrapDataInBlock(blocks[9].block.body.txEffects[3], blocks[9].block),
-                ()=>wrapDataInBlock(blocks[3].block.body.txEffects[1], blocks[3].block),
-                ()=>wrapDataInBlock(blocks[5].block.body.txEffects[2], blocks[5].block),
-                ()=>wrapDataInBlock(blocks[1].block.body.txEffects[0], blocks[1].block)
-            ])('tries to retrieves a previously stored transaction after deleted', async (getExpectedTx)=>{
-                await store.unwindBlocks(BlockNumber(blocks.length), blocks.length);
-                const expectedTx = await getExpectedTx();
-                const actualTx = await store.getTxEffect(expectedTx.data.txHash);
+                ()=>getBlock(0).body.txEffects[0],
+                ()=>getBlock(9).body.txEffects[3],
+                ()=>getBlock(3).body.txEffects[1],
+                ()=>getBlock(5).body.txEffects[2],
+                ()=>getBlock(1).body.txEffects[0]
+            ])('tries to retrieves a previously stored transaction after deleted', async (getTxEffect)=>{
+                await store.unwindCheckpoints(CheckpointNumber(publishedCheckpoints.length), publishedCheckpoints.length);
+                const txEffect = getTxEffect();
+                const actualTx = await store.getTxEffect(txEffect.txHash);
                 expect(actualTx).toEqual(undefined);
             });
             it('returns undefined if tx is not found', async ()=>{
                 await expect(store.getTxEffect(TxHash.random())).resolves.toBeUndefined();
             });
             it('does not fail if the block is unwound while requesting a tx', async ()=>{
-                const expectedTx = await wrapDataInBlock(blocks[1].block.body.txEffects[0], blocks[1].block);
+                const txEffect = getBlock(1).body.txEffects[0];
                 let done = false;
                 void (async ()=>{
                     while(!done){
-                        void store.getTxEffect(expectedTx.data.txHash);
+                        void store.getTxEffect(txEffect.txHash);
                         await sleep(1);
                     }
                 })();
-                await store.unwindBlocks(BlockNumber(blocks.length), blocks.length);
+                await store.unwindCheckpoints(CheckpointNumber(publishedCheckpoints.length), publishedCheckpoints.length);
                 done = true;
-                expect(await store.getTxEffect(expectedTx.data.txHash)).toEqual(undefined);
+                expect(await store.getTxEffect(txEffect.txHash)).toEqual(undefined);
             });
         });
         describe('L1 to L2 Messages', ()=>{
@@ -826,11 +2182,11 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             });
         });
         describe('getLogsByTags', ()=>{
-            const numBlocks = 3;
+            const numBlocksForLogs = 3;
             const numTxsPerBlock = 4;
             const numPrivateLogsPerTx = 3;
             const numPublicLogsPerTx = 2;
-            let blocks;
+            let logsCheckpoints;
             const makeTag = (blockNumber, txIndex, logIndex, isPublic = false)=>blockNumber === 1 && txIndex === 0 && logIndex === 0 ? Fr.ZERO // Shared tag
                  : new Fr((blockNumber * 100 + txIndex * 10 + logIndex) * (isPublic ? 123 : 1));
             const makePrivateLog = (tag)=>PrivateLog.from({
@@ -854,8 +2210,15 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                     return makePublicLog(tag);
                 });
             };
-            const mockBlockWithLogs = async (blockNumber)=>{
-                const block = await L2Block.random(BlockNumber(blockNumber));
+            const mockCheckpointWithLogs = async (blockNumber, previousArchive)=>{
+                const block = await L2BlockNew.random(BlockNumber(blockNumber), {
+                    checkpointNumber: CheckpointNumber(blockNumber),
+                    indexWithinCheckpoint: 0,
+                    state: makeStateForBlock(blockNumber, numTxsPerBlock),
+                    ...previousArchive ? {
+                        lastArchive: previousArchive
+                    } : {}
+                });
                 block.header.globalVariables.blockNumber = BlockNumber(blockNumber);
                 block.body.txEffects = await timesParallel(numTxsPerBlock, async (txIndex)=>{
                     const txEffect = await TxEffect.random();
@@ -863,20 +2226,20 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                     txEffect.publicLogs = mockPublicLogs(blockNumber, txIndex);
                     return txEffect;
                 });
-                return PublishedL2Block.fromFields({
-                    block: block,
-                    attestations: times(3, CommitteeAttestation.random),
-                    l1: {
-                        blockNumber: BigInt(blockNumber),
-                        blockHash: makeBlockHash(blockNumber),
-                        timestamp: BigInt(blockNumber)
-                    }
-                });
+                const checkpoint = new Checkpoint(AppendOnlyTreeSnapshot.random(), CheckpointHeader.random(), [
+                    block
+                ], CheckpointNumber(blockNumber));
+                return makePublishedCheckpoint(checkpoint, blockNumber);
             };
             beforeEach(async ()=>{
-                blocks = await timesParallel(numBlocks, (index)=>mockBlockWithLogs(index + 1));
-                await store.addBlocks(blocks);
-                await store.addLogs(blocks.map((b)=>b.block));
+                // Create checkpoints sequentially to chain archive roots
+                logsCheckpoints = [];
+                for(let i = 0; i < numBlocksForLogs; i++){
+                    const previousArchive = i > 0 ? logsCheckpoints[i - 1].checkpoint.blocks[0].archive : undefined;
+                    logsCheckpoints.push(await mockCheckpointWithLogs(i + 1, previousArchive));
+                }
+                await store.addCheckpoints(logsCheckpoints);
+                await store.addLogs(logsCheckpoints.flatMap((p)=>p.checkpoint.blocks));
             });
             it('is possible to batch request private logs via tags', async ()=>{
                 const tags = [
@@ -888,7 +2251,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                     [
                         expect.objectContaining({
                             blockNumber: 2,
-                            blockHash: L2BlockHash.fromField(await blocks[2 - 1].block.hash()),
+                            blockHash: L2BlockHash.fromField(await logsCheckpoints[2 - 1].checkpoint.blocks[0].header.hash()),
                             log: makePrivateLog(tags[0]),
                             isFromPublic: false
                         })
@@ -896,7 +2259,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                     [
                         expect.objectContaining({
                             blockNumber: 1,
-                            blockHash: L2BlockHash.fromField(await blocks[1 - 1].block.hash()),
+                            blockHash: L2BlockHash.fromField(await logsCheckpoints[1 - 1].checkpoint.blocks[0].header.hash()),
                             log: makePrivateLog(tags[1]),
                             isFromPublic: false
                         })
@@ -913,13 +2276,13 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                     [
                         expect.objectContaining({
                             blockNumber: 1,
-                            blockHash: L2BlockHash.fromField(await blocks[1 - 1].block.hash()),
+                            blockHash: L2BlockHash.fromField(await logsCheckpoints[1 - 1].checkpoint.blocks[0].header.hash()),
                             log: makePrivateLog(tags[0]),
                             isFromPublic: false
                         }),
                         expect.objectContaining({
                             blockNumber: 1,
-                            blockHash: L2BlockHash.fromField(await blocks[1 - 1].block.hash()),
+                            blockHash: L2BlockHash.fromField(await logsCheckpoints[1 - 1].checkpoint.blocks[0].header.hash()),
                             log: makePublicLog(tags[0]),
                             isFromPublic: true
                         })
@@ -930,30 +2293,32 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 const tags = [
                     makeTag(1, 2, 1)
                 ];
-                // Create a block containing logs that have the same tag as the blocks before.
-                const newBlockNumber = numBlocks;
-                const newBlock = await mockBlockWithLogs(newBlockNumber);
-                const newLog = newBlock.block.body.txEffects[1].privateLogs[1];
+                // Create a checkpoint containing logs that have the same tag as the checkpoints before.
+                // Chain from the last checkpoint's archive
+                const newBlockNumber = numBlocksForLogs + 1;
+                const previousArchive = logsCheckpoints[logsCheckpoints.length - 1].checkpoint.blocks[0].archive;
+                const newCheckpoint = await mockCheckpointWithLogs(newBlockNumber, previousArchive);
+                const newLog = newCheckpoint.checkpoint.blocks[0].body.txEffects[1].privateLogs[1];
                 newLog.fields[0] = tags[0];
-                newBlock.block.body.txEffects[1].privateLogs[1] = newLog;
-                await store.addBlocks([
-                    newBlock
+                newCheckpoint.checkpoint.blocks[0].body.txEffects[1].privateLogs[1] = newLog;
+                await store.addCheckpoints([
+                    newCheckpoint
                 ]);
                 await store.addLogs([
-                    newBlock.block
+                    newCheckpoint.checkpoint.blocks[0]
                 ]);
                 const logsByTags = await store.getLogsByTags(tags);
                 expect(logsByTags).toEqual([
                     [
                         expect.objectContaining({
                             blockNumber: 1,
-                            blockHash: L2BlockHash.fromField(await blocks[1 - 1].block.hash()),
+                            blockHash: L2BlockHash.fromField(await logsCheckpoints[1 - 1].checkpoint.blocks[0].header.hash()),
                             log: makePrivateLog(tags[0]),
                             isFromPublic: false
                         }),
                         expect.objectContaining({
                             blockNumber: newBlockNumber,
-                            blockHash: L2BlockHash.fromField(await blocks[newBlockNumber - 1].block.hash()),
+                            blockHash: L2BlockHash.fromField(await newCheckpoint.checkpoint.blocks[0].header.hash()),
                             log: newLog,
                             isFromPublic: false
                         })
@@ -971,7 +2336,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                     [
                         expect.objectContaining({
                             blockNumber: 1,
-                            blockHash: L2BlockHash.fromField(await blocks[1 - 1].block.hash()),
+                            blockHash: L2BlockHash.fromField(await logsCheckpoints[1 - 1].checkpoint.blocks[0].header.hash()),
                             log: makePrivateLog(tags[1]),
                             isFromPublic: false
                         })
@@ -980,32 +2345,29 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             });
         });
         describe('getPublicLogs', ()=>{
-            const txsPerBlock = 4;
-            const numPublicFunctionCalls = 3;
-            const numPublicLogs = 2;
-            const numBlocks = 10;
-            let blocks;
+            const numBlocksForPublicLogs = 10;
+            // Helper to get total public logs per tx from a block
+            const getPublicLogsPerTx = (block, txIndex)=>block.body.txEffects[txIndex].publicLogs.length;
+            // Helper to get number of txs in a block
+            const getTxsPerBlock = (block)=>block.body.txEffects.length;
             beforeEach(async ()=>{
-                blocks = await timesParallel(numBlocks, async (index)=>PublishedL2Block.fromFields({
-                        block: await L2Block.random(BlockNumber(index + 1), txsPerBlock, numPublicFunctionCalls, numPublicLogs),
-                        l1: {
-                            blockNumber: BigInt(index),
-                            blockHash: makeBlockHash(index),
-                            timestamp: BigInt(index)
-                        },
-                        attestations: times(3, CommitteeAttestation.random)
-                    }));
-                await store.addBlocks(blocks);
-                await store.addLogs(blocks.map((b)=>b.block));
+                // Use the outer publishedCheckpoints for log tests
+                for(let i = 0; i < numBlocksForPublicLogs; i++){
+                    await store.addCheckpoints([
+                        publishedCheckpoints[i]
+                    ]);
+                    await store.addLogs(publishedCheckpoints[i].checkpoint.blocks);
+                }
             });
             it('no logs returned if deleted ("txHash" filter param is respected variant)', async ()=>{
                 // get random tx
-                const targetBlockIndex = randomInt(numBlocks);
-                const targetTxIndex = randomInt(txsPerBlock);
-                const targetTxHash = blocks[targetBlockIndex].block.body.txEffects[targetTxIndex].txHash;
+                const targetBlockIndex = randomInt(numBlocksForPublicLogs);
+                const targetBlock = publishedCheckpoints[targetBlockIndex].checkpoint.blocks[0];
+                const targetTxIndex = randomInt(getTxsPerBlock(targetBlock));
+                const targetTxHash = targetBlock.body.txEffects[targetTxIndex].txHash;
                 await Promise.all([
-                    store.unwindBlocks(BlockNumber(blocks.length), blocks.length),
-                    store.deleteLogs(blocks.map((b)=>b.block))
+                    store.unwindCheckpoints(CheckpointNumber(numBlocksForPublicLogs), numBlocksForPublicLogs),
+                    store.deleteLogs(publishedCheckpoints.slice(0, numBlocksForPublicLogs).flatMap((b)=>b.checkpoint.blocks))
                 ]);
                 const response = await store.getPublicLogs({
                     txHash: targetTxHash
@@ -1016,15 +2378,16 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             });
             it('"txHash" filter param is respected', async ()=>{
                 // get random tx
-                const targetBlockIndex = randomInt(numBlocks);
-                const targetTxIndex = randomInt(txsPerBlock);
-                const targetTxHash = blocks[targetBlockIndex].block.body.txEffects[targetTxIndex].txHash;
+                const targetBlockIndex = randomInt(numBlocksForPublicLogs);
+                const targetBlock = publishedCheckpoints[targetBlockIndex].checkpoint.blocks[0];
+                const targetTxIndex = randomInt(getTxsPerBlock(targetBlock));
+                const targetTxHash = targetBlock.body.txEffects[targetTxIndex].txHash;
                 const response = await store.getPublicLogs({
                     txHash: targetTxHash
                 });
                 const logs = response.logs;
                 expect(response.maxLogsHit).toBeFalsy();
-                const expectedNumLogs = numPublicFunctionCalls * numPublicLogs;
+                const expectedNumLogs = getPublicLogsPerTx(targetBlock, targetTxIndex);
                 expect(logs.length).toEqual(expectedNumLogs);
                 const targeBlockNumber = targetBlockIndex + INITIAL_L2_BLOCK_NUM;
                 for (const log of logs){
@@ -1033,8 +2396,8 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 }
             });
             it('returns block hash on public log ids', async ()=>{
-                const targetBlock = blocks[0].block;
-                const expectedBlockHash = L2BlockHash.fromField(await targetBlock.hash());
+                const targetBlock = publishedCheckpoints[0].checkpoint.blocks[0];
+                const expectedBlockHash = L2BlockHash.fromField(await targetBlock.header.hash());
                 const logs = (await store.getPublicLogs({
                     fromBlock: targetBlock.number,
                     toBlock: targetBlock.number + 1
@@ -1052,7 +2415,12 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 });
                 const logs = response.logs;
                 expect(response.maxLogsHit).toBeFalsy();
-                const expectedNumLogs = txsPerBlock * numPublicFunctionCalls * numPublicLogs * (toBlock - fromBlock);
+                // Compute expected logs from the blocks in range
+                let expectedNumLogs = 0;
+                for(let i = fromBlock - 1; i < toBlock - 1; i++){
+                    const block = publishedCheckpoints[i].checkpoint.blocks[0];
+                    expectedNumLogs += block.body.txEffects.reduce((sum, tx)=>sum + tx.publicLogs.length, 0);
+                }
                 expect(logs.length).toEqual(expectedNumLogs);
                 for (const log of logs){
                     const blockNumber = log.id.blockNumber;
@@ -1062,10 +2430,11 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             });
             it('"contractAddress" filter param is respected', async ()=>{
                 // Get a random contract address from the logs
-                const targetBlockIndex = randomInt(numBlocks);
-                const targetTxIndex = randomInt(txsPerBlock);
-                const targetLogIndex = randomInt(numPublicLogs * numPublicFunctionCalls);
-                const targetContractAddress = blocks[targetBlockIndex].block.body.txEffects[targetTxIndex].publicLogs[targetLogIndex].contractAddress;
+                const targetBlockIndex = randomInt(numBlocksForPublicLogs);
+                const targetBlock = publishedCheckpoints[targetBlockIndex].checkpoint.blocks[0];
+                const targetTxIndex = randomInt(getTxsPerBlock(targetBlock));
+                const targetLogIndex = randomInt(getPublicLogsPerTx(targetBlock, targetTxIndex));
+                const targetContractAddress = targetBlock.body.txEffects[targetTxIndex].publicLogs[targetLogIndex].contractAddress;
                 const response = await store.getPublicLogs({
                     contractAddress: targetContractAddress
                 });
@@ -1076,10 +2445,12 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             });
             it('"afterLog" filter param is respected', async ()=>{
                 // Get a random log as reference
-                const targetBlockIndex = randomInt(numBlocks);
-                const targetTxIndex = randomInt(txsPerBlock);
-                const targetLogIndex = randomInt(numPublicLogs);
-                const targetBlockHash = L2BlockHash.fromField(await blocks[targetBlockIndex].block.hash());
+                const targetBlockIndex = randomInt(numBlocksForPublicLogs);
+                const targetBlock = publishedCheckpoints[targetBlockIndex].checkpoint.blocks[0];
+                const targetTxIndex = randomInt(getTxsPerBlock(targetBlock));
+                const numLogsInTx = targetBlock.body.txEffects[targetTxIndex].publicLogs.length;
+                const targetLogIndex = numLogsInTx > 0 ? randomInt(numLogsInTx) : 0;
+                const targetBlockHash = L2BlockHash.fromField(await targetBlock.header.hash());
                 const afterLog = new LogId(BlockNumber(targetBlockIndex + INITIAL_L2_BLOCK_NUM), targetBlockHash, targetTxIndex, targetLogIndex);
                 const response = await store.getPublicLogs({
                     afterLog
@@ -1142,7 +2513,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                     toBlock: +100
                 })).logs;
                 blockNumbers = new Set(logs.map((log)=>log.id.blockNumber));
-                expect(blockNumbers.size).toBe(numBlocks);
+                expect(blockNumbers.size).toBe(numBlocksForPublicLogs);
                 // intersecting with "afterLog" works
                 logs = (await store.getPublicLogs({
                     fromBlock: BlockNumber(2),
@@ -1167,10 +2538,12 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             });
             it('"txIndex" and "logIndex" are respected when "afterLog.blockNumber" is equal to "fromBlock"', async ()=>{
                 // Get a random log as reference
-                const targetBlockIndex = randomInt(numBlocks);
-                const targetTxIndex = randomInt(txsPerBlock);
-                const targetLogIndex = randomInt(numPublicLogs);
-                const targetBlockHash = L2BlockHash.fromField(await blocks[targetBlockIndex].block.hash());
+                const targetBlockIndex = randomInt(numBlocksForPublicLogs);
+                const targetBlock = publishedCheckpoints[targetBlockIndex].checkpoint.blocks[0];
+                const targetTxIndex = randomInt(getTxsPerBlock(targetBlock));
+                const numLogsInTx = targetBlock.body.txEffects[targetTxIndex].publicLogs.length;
+                const targetLogIndex = numLogsInTx > 0 ? randomInt(numLogsInTx) : 0;
+                const targetBlockHash = L2BlockHash.fromField(await targetBlock.header.hash());
                 const afterLog = new LogId(BlockNumber(targetBlockIndex + INITIAL_L2_BLOCK_NUM), targetBlockHash, targetTxIndex, targetLogIndex);
                 const response = await store.getPublicLogs({
                     afterLog,
@@ -1194,8 +2567,8 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             let targetBlock;
             let expectedContractClassLog;
             beforeEach(async ()=>{
-                await store.addBlocks(blocks);
-                targetBlock = blocks[0].block;
+                await store.addCheckpoints(publishedCheckpoints);
+                targetBlock = publishedCheckpoints[0].checkpoint.blocks[0];
                 expectedContractClassLog = await ContractClassLog.random();
                 targetBlock.body.txEffects.forEach((txEffect, index)=>{
                     txEffect.contractClassLogs = index === 0 ? [
@@ -1214,7 +2587,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 expect(result.maxLogsHit).toBeFalsy();
                 expect(result.logs).toHaveLength(1);
                 const [{ id, log }] = result.logs;
-                const expectedBlockHash = L2BlockHash.fromField(await targetBlock.hash());
+                const expectedBlockHash = L2BlockHash.fromField(await targetBlock.header.hash());
                 expect(id.blockHash.equals(expectedBlockHash)).toBe(true);
                 expect(id.blockNumber).toEqual(targetBlock.number);
                 expect(log).toEqual(expectedContractClassLog);