@aztec/archiver 3.0.0-devnet.5 → 3.0.0-devnet.6-patch.1

package/dest/archiver/archiver_store_test_suite.js

@@ -1,13 +1,14 @@
 import { INITIAL_L2_BLOCK_NUM, 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';
 import { times, timesParallel } from '@aztec/foundation/collection';
-import { randomInt } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { randomInt } from '@aztec/foundation/crypto/random';
+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, wrapInBlock } from '@aztec/stdlib/block';
+import { CommitteeAttestation, EthAddress, L2Block, L2BlockHash, PublishedL2Block, randomBlockInfo, wrapDataInBlock } from '@aztec/stdlib/block';
 import { SerializableContractInstance, computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
 import { LogId, PrivateLog, PublicLog } from '@aztec/stdlib/logs';
 import { InboxLeaf } from '@aztec/stdlib/messaging';
@@ -73,7 +74,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
         };
         beforeEach(async ()=>{
             store = await getStore();
-            blocks = await timesParallel(10, async (i)=>makePublished(await L2Block.random(i + 1), i + 10));
+            blocks = await timesParallel(10, async (i)=>makePublished(await L2Block.random(BlockNumber(i + 1)), i + 10));
         });
         describe('addBlocks', ()=>{
             it('returns success when adding blocks', async ()=>{
@@ -84,19 +85,19 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 await expect(store.addBlocks(blocks)).resolves.toBe(true);
             });
             it('throws an error if the previous block does not exist in the store', async ()=>{
-                const block = makePublished(await L2Block.random(2), 2);
+                const block = makePublished(await L2Block.random(BlockNumber(2)), 2);
                 await expect(store.addBlocks([
                     block
                 ])).rejects.toThrow(InitialBlockNumberNotSequentialError);
-                await expect(store.getPublishedBlocks(1, 10)).resolves.toEqual([]);
+                await expect(store.getPublishedBlocks(BlockNumber(1), 10)).resolves.toEqual([]);
             });
             it('throws an error if there is a gap in the blocks being added', async ()=>{
                 const blocks = [
-                    makePublished(await L2Block.random(1), 1),
-                    makePublished(await L2Block.random(3), 3)
+                    makePublished(await L2Block.random(BlockNumber(1)), 1),
+                    makePublished(await L2Block.random(BlockNumber(3)), 3)
                 ];
                 await expect(store.addBlocks(blocks)).rejects.toThrow(BlockNumberNotSequentialError);
-                await expect(store.getPublishedBlocks(1, 10)).resolves.toEqual([]);
+                await expect(store.getPublishedBlocks(BlockNumber(1), 10)).resolves.toEqual([]);
             });
         });
         describe('unwindBlocks', ()=>{
@@ -111,12 +112,12 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 expect(await store.getPublishedBlocks(blockNumber, 1)).toEqual([]);
             });
             it('can unwind multiple empty blocks', async ()=>{
-                const emptyBlocks = await timesParallel(10, async (i)=>makePublished(await L2Block.random(i + 1, 0), i + 10));
+                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(10, 3);
+                await store.unwindBlocks(BlockNumber(10), 3);
                 expect(await store.getSynchedL2BlockNumber()).toBe(7);
-                expect((await store.getPublishedBlocks(1, 10)).map((b)=>b.block.number)).toEqual([
+                expect((await store.getPublishedBlocks(BlockNumber(1), 10)).map((b)=>b.block.number)).toEqual([
                     1,
                     2,
                     3,
@@ -128,7 +129,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             });
             it('refuses to unwind blocks if the tip is not the last block', async ()=>{
                 await store.addBlocks(blocks);
-                await expect(store.unwindBlocks(5, 1)).rejects.toThrow(/can only unwind blocks from the tip/i);
+                await expect(store.unwindBlocks(BlockNumber(5), 1)).rejects.toThrow(/can only unwind blocks from the tip/i);
             });
             it('unwound blocks and headers cannot be retrieved by hash or archive', async ()=>{
                 await store.addBlocks(blocks);
@@ -154,33 +155,33 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 await store.addBlocks(blocks);
             });
             it.each(blockTests)('retrieves previously stored blocks', async (start, limit, getExpectedBlocks)=>{
-                expectBlocksEqual(await store.getPublishedBlocks(start, limit), getExpectedBlocks());
+                expectBlocksEqual(await store.getPublishedBlocks(BlockNumber(start), limit), getExpectedBlocks());
             });
             it('returns an empty array if no blocks are found', async ()=>{
-                await expect(store.getPublishedBlocks(12, 1)).resolves.toEqual([]);
+                await expect(store.getPublishedBlocks(BlockNumber(12), 1)).resolves.toEqual([]);
             });
             it('throws an error if limit is invalid', async ()=>{
-                await expect(store.getPublishedBlocks(1, 0)).rejects.toThrow('Invalid limit: 0');
+                await expect(store.getPublishedBlocks(BlockNumber(1), 0)).rejects.toThrow('Invalid limit: 0');
             });
             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('throws an error if unexpected initial block number is found', async ()=>{
                 await store.addBlocks([
-                    makePublished(await L2Block.random(21), 31)
+                    makePublished(await L2Block.random(BlockNumber(21)), 31)
                 ], {
                     force: true
                 });
-                await expect(store.getPublishedBlocks(20, 1)).rejects.toThrow(`mismatch`);
+                await expect(store.getPublishedBlocks(BlockNumber(20), 1)).rejects.toThrow(`mismatch`);
             });
             it('throws an error if a gap is found', async ()=>{
                 await store.addBlocks([
-                    makePublished(await L2Block.random(20), 30),
-                    makePublished(await L2Block.random(22), 32)
+                    makePublished(await L2Block.random(BlockNumber(20)), 30),
+                    makePublished(await L2Block.random(BlockNumber(22)), 32)
                 ], {
                     force: true
                 });
-                await expect(store.getPublishedBlocks(20, 2)).rejects.toThrow(`mismatch`);
+                await expect(store.getPublishedBlocks(BlockNumber(20), 2)).rejects.toThrow(`mismatch`);
             });
         });
         describe('getPublishedBlockByHash', ()=>{
@@ -330,41 +331,24 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 ])).resolves.toEqual(true);
             });
         });
-        describe('deleteLogs', ()=>{
-            it('deletes private & public logs', async ()=>{
-                const block = blocks[0].block;
-                await store.addBlocks([
-                    blocks[0]
-                ]);
-                await expect(store.addLogs([
-                    block
-                ])).resolves.toEqual(true);
-                expect((await store.getPrivateLogs(1, 1)).length).toEqual(block.body.txEffects.map((txEffect)=>txEffect.privateLogs).flat().length);
-                expect((await store.getPublicLogs({
-                    fromBlock: 1
-                })).logs.length).toEqual(block.body.txEffects.map((txEffect)=>txEffect.publicLogs).flat().length);
-                // This one is a pain for memory as we would never want to just delete memory in the middle.
-                await store.deleteLogs([
-                    block
-                ]);
-                expect((await store.getPrivateLogs(1, 1)).length).toEqual(0);
-                expect((await store.getPublicLogs({
-                    fromBlock: 1
-                })).logs.length).toEqual(0);
-            });
-        });
-        describe('getPrivateLogs', ()=>{
-            it('gets added private logs', async ()=>{
-                const block = blocks[0].block;
-                await store.addBlocks([
-                    blocks[0]
-                ]);
-                await store.addLogs([
-                    block
-                ]);
-                const privateLogs = await store.getPrivateLogs(1, 1);
-                expect(privateLogs).toEqual(block.body.txEffects.map((txEffect)=>txEffect.privateLogs).flat());
-            });
+        it('deleteLogs', async ()=>{
+            const block = blocks[0].block;
+            await store.addBlocks([
+                blocks[0]
+            ]);
+            await expect(store.addLogs([
+                block
+            ])).resolves.toEqual(true);
+            expect((await store.getPublicLogs({
+                fromBlock: BlockNumber(1)
+            })).logs.length).toEqual(block.body.txEffects.map((txEffect)=>txEffect.publicLogs).flat().length);
+            // This one is a pain for memory as we would never want to just delete memory in the middle.
+            await store.deleteLogs([
+                block
+            ]);
+            expect((await store.getPublicLogs({
+                fromBlock: BlockNumber(1)
+            })).logs.length).toEqual(0);
         });
         describe('getTxEffect', ()=>{
             beforeEach(async ()=>{
@@ -412,13 +396,13 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 await expect(store.getTxEffect(TxHash.random())).resolves.toBeUndefined();
             });
             it.each([
-                ()=>wrapInBlock(blocks[0].block.body.txEffects[0], blocks[0].block),
-                ()=>wrapInBlock(blocks[9].block.body.txEffects[3], blocks[9].block),
-                ()=>wrapInBlock(blocks[3].block.body.txEffects[1], blocks[3].block),
-                ()=>wrapInBlock(blocks[5].block.body.txEffects[2], blocks[5].block),
-                ()=>wrapInBlock(blocks[1].block.body.txEffects[0], blocks[1].block)
+                ()=>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(blocks.length, blocks.length);
+                await store.unwindBlocks(BlockNumber(blocks.length), blocks.length);
                 const expectedTx = await getExpectedTx();
                 const actualTx = await store.getTxEffect(expectedTx.data.txHash);
                 expect(actualTx).toEqual(undefined);
@@ -427,7 +411,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 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 wrapInBlock(blocks[1].block.body.txEffects[0], blocks[1].block);
+                const expectedTx = await wrapDataInBlock(blocks[1].block.body.txEffects[0], blocks[1].block);
                 let done = false;
                 void (async ()=>{
                     while(!done){
@@ -435,13 +419,13 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                         await sleep(1);
                     }
                 })();
-                await store.unwindBlocks(blocks.length, blocks.length);
+                await store.unwindBlocks(BlockNumber(blocks.length), blocks.length);
                 done = true;
                 expect(await store.getTxEffect(expectedTx.data.txHash)).toEqual(undefined);
             });
         });
         describe('L1 to L2 Messages', ()=>{
-            const initialL2BlockNumber = 13;
+            const initialCheckpointNumber = CheckpointNumber(13);
             const checkMessages = async (msgs)=>{
                 expect(await store.getLastL1ToL2Message()).toEqual(msgs.at(-1));
                 expect(await toArray(store.iterateL1ToL2Messages())).toEqual(msgs);
@@ -449,11 +433,11 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             };
             const makeInboxMessagesWithFullBlocks = (blockCount, opts = {})=>makeInboxMessages(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * blockCount, {
                     overrideFn: (msg, i)=>{
-                        const l2BlockNumber = (opts.initialL2BlockNumber ?? initialL2BlockNumber) + Math.floor(i / NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-                        const index = InboxLeaf.smallestIndexFromL2Block(l2BlockNumber) + BigInt(i % NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+                        const checkpointNumber = CheckpointNumber((opts.initialCheckpointNumber ?? initialCheckpointNumber) + Math.floor(i / NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
+                        const index = InboxLeaf.smallestIndexForCheckpoint(checkpointNumber) + BigInt(i % NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
                         return {
                             ...msg,
-                            l2BlockNumber,
+                            checkpointNumber,
                             index
                         };
                     }
@@ -461,7 +445,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             it('stores first message ever', async ()=>{
                 const msg = makeInboxMessage(Buffer16.ZERO, {
                     index: 0n,
-                    l2BlockNumber: 1
+                    checkpointNumber: CheckpointNumber(1)
                 });
                 await store.addL1ToL2Messages([
                     msg
@@ -469,13 +453,13 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 await checkMessages([
                     msg
                 ]);
-                expect(await store.getL1ToL2Messages(1)).toEqual([
+                expect(await store.getL1ToL2Messages(CheckpointNumber(1))).toEqual([
                     msg.leaf
                 ]);
             });
             it('stores single message', async ()=>{
                 const msg = makeInboxMessage(Buffer16.ZERO, {
-                    l2BlockNumber: 2
+                    checkpointNumber: CheckpointNumber(2)
                 });
                 await store.addL1ToL2Messages([
                     msg
@@ -483,23 +467,23 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 await checkMessages([
                     msg
                 ]);
-                expect(await store.getL1ToL2Messages(2)).toEqual([
+                expect(await store.getL1ToL2Messages(CheckpointNumber(2))).toEqual([
                     msg.leaf
                 ]);
             });
             it('stores and returns messages across different blocks', async ()=>{
                 const msgs = makeInboxMessages(5, {
-                    initialL2BlockNumber
+                    initialCheckpointNumber
                 });
                 await store.addL1ToL2Messages(msgs);
                 await checkMessages(msgs);
-                expect(await store.getL1ToL2Messages(initialL2BlockNumber + 2)).toEqual([
+                expect(await store.getL1ToL2Messages(CheckpointNumber(initialCheckpointNumber + 2))).toEqual([
                     msgs[2]
                 ].map((m)=>m.leaf));
             });
             it('stores the same messages again', async ()=>{
                 const msgs = makeInboxMessages(5, {
-                    initialL2BlockNumber
+                    initialCheckpointNumber
                 });
                 await store.addL1ToL2Messages(msgs);
                 await store.addL1ToL2Messages(msgs.slice(2));
@@ -507,10 +491,10 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             });
             it('stores and returns messages across different blocks with gaps', async ()=>{
                 const msgs1 = makeInboxMessages(3, {
-                    initialL2BlockNumber: 1
+                    initialCheckpointNumber: CheckpointNumber(1)
                 });
                 const msgs2 = makeInboxMessages(3, {
-                    initialL2BlockNumber: 20,
+                    initialCheckpointNumber: CheckpointNumber(20),
                     initialHash: msgs1.at(-1).rollingHash
                 });
                 await store.addL1ToL2Messages(msgs1);
@@ -519,22 +503,22 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                     ...msgs1,
                     ...msgs2
                 ]);
-                expect(await store.getL1ToL2Messages(1)).toEqual([
+                expect(await store.getL1ToL2Messages(CheckpointNumber(1))).toEqual([
                     msgs1[0].leaf
                 ]);
-                expect(await store.getL1ToL2Messages(4)).toEqual([]);
-                expect(await store.getL1ToL2Messages(20)).toEqual([
+                expect(await store.getL1ToL2Messages(CheckpointNumber(4))).toEqual([]);
+                expect(await store.getL1ToL2Messages(CheckpointNumber(20))).toEqual([
                     msgs2[0].leaf
                 ]);
-                expect(await store.getL1ToL2Messages(24)).toEqual([]);
+                expect(await store.getL1ToL2Messages(CheckpointNumber(24))).toEqual([]);
             });
             it('stores and returns messages with block numbers larger than a byte', async ()=>{
                 const msgs = makeInboxMessages(5, {
-                    initialL2BlockNumber: 1000
+                    initialCheckpointNumber: CheckpointNumber(1000)
                 });
                 await store.addL1ToL2Messages(msgs);
                 await checkMessages(msgs);
-                expect(await store.getL1ToL2Messages(1002)).toEqual([
+                expect(await store.getL1ToL2Messages(CheckpointNumber(1002))).toEqual([
                     msgs[2]
                 ].map((m)=>m.leaf));
             });
@@ -542,27 +526,27 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 const msgs = makeInboxMessagesWithFullBlocks(4);
                 await store.addL1ToL2Messages(msgs);
                 await checkMessages(msgs);
-                const blockMessages = await store.getL1ToL2Messages(initialL2BlockNumber + 1);
+                const blockMessages = await store.getL1ToL2Messages(CheckpointNumber(initialCheckpointNumber + 1));
                 expect(blockMessages).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
                 expect(blockMessages).toEqual(msgs.slice(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * 2).map((m)=>m.leaf));
             });
             it('stores messages in multiple operations', async ()=>{
                 const msgs = makeInboxMessages(20, {
-                    initialL2BlockNumber
+                    initialCheckpointNumber
                 });
                 await store.addL1ToL2Messages(msgs.slice(0, 10));
                 await store.addL1ToL2Messages(msgs.slice(10, 20));
-                expect(await store.getL1ToL2Messages(initialL2BlockNumber + 2)).toEqual([
+                expect(await store.getL1ToL2Messages(CheckpointNumber(initialCheckpointNumber + 2))).toEqual([
                     msgs[2]
                 ].map((m)=>m.leaf));
-                expect(await store.getL1ToL2Messages(initialL2BlockNumber + 12)).toEqual([
+                expect(await store.getL1ToL2Messages(CheckpointNumber(initialCheckpointNumber + 12))).toEqual([
                     msgs[12]
                 ].map((m)=>m.leaf));
                 await checkMessages(msgs);
             });
             it('iterates over messages from start index', async ()=>{
                 const msgs = makeInboxMessages(10, {
-                    initialL2BlockNumber
+                    initialCheckpointNumber
                 });
                 await store.addL1ToL2Messages(msgs);
                 const iterated = await toArray(store.iterateL1ToL2Messages({
@@ -572,9 +556,10 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             });
             it('iterates over messages in reverse', async ()=>{
                 const msgs = makeInboxMessages(10, {
-                    initialL2BlockNumber
+                    initialCheckpointNumber
                 });
                 await store.addL1ToL2Messages(msgs);
+                initialCheckpointNumber;
                 const iterated = await toArray(store.iterateL1ToL2Messages({
                     reverse: true,
                     end: msgs[3].index
@@ -592,9 +577,9 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             });
             it('throws if block number for the first message is out of order', async ()=>{
                 const msgs = makeInboxMessages(4, {
-                    initialL2BlockNumber
+                    initialCheckpointNumber
                 });
-                msgs[2].l2BlockNumber = initialL2BlockNumber - 1;
+                msgs[2].checkpointNumber = CheckpointNumber(initialCheckpointNumber - 1);
                 await store.addL1ToL2Messages(msgs.slice(0, 2));
                 await expect(store.addL1ToL2Messages(msgs.slice(2, 4))).rejects.toThrow(MessageStoreError);
             });
@@ -606,29 +591,29 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             it('throws if rolling hash for first message is not correct', async ()=>{
                 const msgs = makeInboxMessages(4);
                 msgs[2].rollingHash = Buffer16.random();
-                await store.addL1ToL2Messages(msgs.slice(0, 2));
+                await store.addL1ToL2Messages(msgs.slice(0, CheckpointNumber(2)));
                 await expect(store.addL1ToL2Messages(msgs.slice(2, 4))).rejects.toThrow(MessageStoreError);
             });
             it('throws if index is not in the correct range', async ()=>{
                 const msgs = makeInboxMessages(5, {
-                    initialL2BlockNumber
+                    initialCheckpointNumber
                 });
                 msgs.at(-1).index += 100n;
                 await expect(store.addL1ToL2Messages(msgs)).rejects.toThrow(MessageStoreError);
             });
             it('throws if first index in block has gaps', async ()=>{
                 const msgs = makeInboxMessages(4, {
-                    initialL2BlockNumber
+                    initialCheckpointNumber
                 });
                 msgs[2].index++;
                 await expect(store.addL1ToL2Messages(msgs)).rejects.toThrow(MessageStoreError);
             });
             it('throws if index does not follow previous one', async ()=>{
                 const msgs = makeInboxMessages(2, {
-                    initialL2BlockNumber,
+                    initialCheckpointNumber,
                     overrideFn: (msg, i)=>({
                             ...msg,
-                            l2BlockNumber: 2,
+                            checkpointNumber: CheckpointNumber(2),
                             index: BigInt(i + NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * 2)
                         })
                 });
@@ -637,24 +622,24 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             });
             it('removes messages up to the given block number', async ()=>{
                 const msgs = makeInboxMessagesWithFullBlocks(4, {
-                    initialL2BlockNumber: 1
+                    initialCheckpointNumber: CheckpointNumber(1)
                 });
                 await store.addL1ToL2Messages(msgs);
                 await checkMessages(msgs);
-                expect(await store.getL1ToL2Messages(1)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-                expect(await store.getL1ToL2Messages(2)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-                expect(await store.getL1ToL2Messages(3)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-                expect(await store.getL1ToL2Messages(4)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-                await store.rollbackL1ToL2MessagesToL2Block(2);
-                expect(await store.getL1ToL2Messages(1)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-                expect(await store.getL1ToL2Messages(2)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-                expect(await store.getL1ToL2Messages(3)).toHaveLength(0);
-                expect(await store.getL1ToL2Messages(4)).toHaveLength(0);
+                expect(await store.getL1ToL2Messages(CheckpointNumber(1))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+                expect(await store.getL1ToL2Messages(CheckpointNumber(2))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+                expect(await store.getL1ToL2Messages(CheckpointNumber(3))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+                expect(await store.getL1ToL2Messages(CheckpointNumber(4))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+                await store.rollbackL1ToL2MessagesToCheckpoint(CheckpointNumber(2));
+                expect(await store.getL1ToL2Messages(CheckpointNumber(1))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+                expect(await store.getL1ToL2Messages(CheckpointNumber(2))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+                expect(await store.getL1ToL2Messages(CheckpointNumber(3))).toHaveLength(0);
+                expect(await store.getL1ToL2Messages(CheckpointNumber(4))).toHaveLength(0);
                 await checkMessages(msgs.slice(0, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * 2));
             });
             it('removes messages starting with the given index', async ()=>{
                 const msgs = makeInboxMessagesWithFullBlocks(4, {
-                    initialL2BlockNumber: 1
+                    initialCheckpointNumber: CheckpointNumber(1)
                 });
                 await store.addL1ToL2Messages(msgs);
                 await store.removeL1ToL2Messages(msgs[13].index);
@@ -677,7 +662,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 };
                 await store.addContractInstances([
                     contractInstance
-                ], blockNum);
+                ], BlockNumber(blockNum));
             });
             it('returns previously stored contract instances', async ()=>{
                 await expect(store.getContractInstance(contractInstance.address, timestamp)).resolves.toMatchObject(contractInstance);
@@ -688,7 +673,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             it('returns undefined if previously stored contract instances was deleted', async ()=>{
                 await store.deleteContractInstances([
                     contractInstance
-                ], blockNum);
+                ], BlockNumber(blockNum));
                 await expect(store.getContractInstance(contractInstance.address, timestamp)).resolves.toBeUndefined();
             });
         });
@@ -710,7 +695,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 };
                 await store.addContractInstances([
                     contractInstance
-                ], 1);
+                ], BlockNumber(1));
                 await store.addContractInstanceUpdates([
                     {
                         prevContractClassId: classId,
@@ -747,7 +732,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 };
                 await store.addContractInstances([
                     otherContractInstance
-                ], 1);
+                ], BlockNumber(1));
                 const fetchedInstance = await store.getContractInstance(otherContractInstance.address, timestampOfChange + 1n);
                 expect(fetchedInstance?.originalContractClassId).toEqual(otherClassId);
                 expect(fetchedInstance?.currentContractClassId).toEqual(otherClassId);
@@ -765,7 +750,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 };
                 await store.addContractInstances([
                     otherContractInstance
-                ], 1);
+                ], BlockNumber(1));
                 await store.addContractInstanceUpdates([
                     {
                         prevContractClassId: otherClassId,
@@ -788,7 +773,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                     contractClass
                 ], [
                     await computePublicBytecodeCommitment(contractClass.packedBytecode)
-                ], blockNum);
+                ], BlockNumber(blockNum));
             });
             it('returns previously stored contract class', async ()=>{
                 await expect(store.getContractClass(contractClass.id)).resolves.toMatchObject(contractClass);
@@ -796,7 +781,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             it('returns undefined if the initial deployed contract class was deleted', async ()=>{
                 await store.deleteContractClasses([
                     contractClass
-                ], blockNum);
+                ], BlockNumber(blockNum));
                 await expect(store.getContractClass(contractClass.id)).resolves.toBeUndefined();
             });
             it('returns contract class if later "deployment" class was deleted', async ()=>{
@@ -804,10 +789,10 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                     contractClass
                 ], [
                     await computePublicBytecodeCommitment(contractClass.packedBytecode)
-                ], blockNum + 1);
+                ], BlockNumber(blockNum + 1));
                 await store.deleteContractClasses([
                     contractClass
-                ], blockNum + 1);
+                ], BlockNumber(blockNum + 1));
                 await expect(store.getContractClass(contractClass.id)).resolves.toMatchObject(contractClass);
             });
             it('returns undefined if contract class is not found', async ()=>{
@@ -870,8 +855,8 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 });
             };
             const mockBlockWithLogs = async (blockNumber)=>{
-                const block = await L2Block.random(blockNumber);
-                block.header.globalVariables.blockNumber = blockNumber;
+                const block = await L2Block.random(BlockNumber(blockNumber));
+                block.header.globalVariables.blockNumber = BlockNumber(blockNumber);
                 block.body.txEffects = await timesParallel(numTxsPerBlock, async (txIndex)=>{
                     const txEffect = await TxEffect.random();
                     txEffect.privateLogs = mockPrivateLogs(blockNumber, txIndex);
@@ -995,7 +980,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             let blocks;
             beforeEach(async ()=>{
                 blocks = await timesParallel(numBlocks, async (index)=>PublishedL2Block.fromFields({
-                        block: await L2Block.random(index + 1, txsPerBlock, numPublicFunctionCalls, numPublicLogs),
+                        block: await L2Block.random(BlockNumber(index + 1), txsPerBlock, numPublicFunctionCalls, numPublicLogs),
                         l1: {
                             blockNumber: BigInt(index),
                             blockHash: makeBlockHash(index),
@@ -1012,7 +997,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 const targetTxIndex = randomInt(txsPerBlock);
                 const targetTxHash = blocks[targetBlockIndex].block.body.txEffects[targetTxIndex].txHash;
                 await Promise.all([
-                    store.unwindBlocks(blocks.length, blocks.length),
+                    store.unwindBlocks(BlockNumber(blocks.length), blocks.length),
                     store.deleteLogs(blocks.map((b)=>b.block))
                 ]);
                 const response = await store.getPublicLogs({
@@ -1077,7 +1062,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 const targetBlockIndex = randomInt(numBlocks);
                 const targetTxIndex = randomInt(txsPerBlock);
                 const targetLogIndex = randomInt(numPublicLogs);
-                const afterLog = new LogId(targetBlockIndex + INITIAL_L2_BLOCK_NUM, targetTxIndex, targetLogIndex);
+                const afterLog = new LogId(BlockNumber(targetBlockIndex + INITIAL_L2_BLOCK_NUM), targetTxIndex, targetLogIndex);
                 const response = await store.getPublicLogs({
                     afterLog
                 });
@@ -1097,7 +1082,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
             it('"txHash" filter param is ignored when "afterLog" is set', async ()=>{
                 // Get random txHash
                 const txHash = TxHash.random();
-                const afterLog = new LogId(1, 0, 0);
+                const afterLog = new LogId(BlockNumber(1), 0, 0);
                 const response = await store.getPublicLogs({
                     txHash,
                     afterLog
@@ -1113,7 +1098,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 // "fromBlock" gets correctly trimmed to range and "toBlock" is exclusive
                 logs = (await store.getPublicLogs({
                     fromBlock: -10,
-                    toBlock: 5
+                    toBlock: BlockNumber(5)
                 })).logs;
                 let blockNumbers = new Set(logs.map((log)=>log.id.blockNumber));
                 expect(blockNumbers).toEqual(new Set([
@@ -1124,13 +1109,13 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 ]));
                 // "toBlock" should be exclusive
                 logs = (await store.getPublicLogs({
-                    fromBlock: 1,
-                    toBlock: 1
+                    fromBlock: BlockNumber(1),
+                    toBlock: BlockNumber(1)
                 })).logs;
                 expect(logs.length).toBe(0);
                 logs = (await store.getPublicLogs({
-                    fromBlock: 10,
-                    toBlock: 5
+                    fromBlock: BlockNumber(10),
+                    toBlock: BlockNumber(5)
                 })).logs;
                 expect(logs.length).toBe(0);
                 // both "fromBlock" and "toBlock" get correctly capped to range and logs from all blocks are returned
@@ -1142,23 +1127,23 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 expect(blockNumbers.size).toBe(numBlocks);
                 // intersecting with "afterLog" works
                 logs = (await store.getPublicLogs({
-                    fromBlock: 2,
-                    toBlock: 5,
-                    afterLog: new LogId(4, 0, 0)
+                    fromBlock: BlockNumber(2),
+                    toBlock: BlockNumber(5),
+                    afterLog: new LogId(BlockNumber(4), 0, 0)
                 })).logs;
                 blockNumbers = new Set(logs.map((log)=>log.id.blockNumber));
                 expect(blockNumbers).toEqual(new Set([
                     4
                 ]));
                 logs = (await store.getPublicLogs({
-                    toBlock: 5,
-                    afterLog: new LogId(5, 1, 0)
+                    toBlock: BlockNumber(5),
+                    afterLog: new LogId(BlockNumber(5), 1, 0)
                 })).logs;
                 expect(logs.length).toBe(0);
                 logs = (await store.getPublicLogs({
-                    fromBlock: 2,
-                    toBlock: 5,
-                    afterLog: new LogId(100, 0, 0)
+                    fromBlock: BlockNumber(2),
+                    toBlock: BlockNumber(5),
+                    afterLog: new LogId(BlockNumber(100), 0, 0)
                 })).logs;
                 expect(logs.length).toBe(0);
             });
@@ -1167,7 +1152,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                 const targetBlockIndex = randomInt(numBlocks);
                 const targetTxIndex = randomInt(txsPerBlock);
                 const targetLogIndex = randomInt(numPublicLogs);
-                const afterLog = new LogId(targetBlockIndex + INITIAL_L2_BLOCK_NUM, targetTxIndex, targetLogIndex);
+                const afterLog = new LogId(BlockNumber(targetBlockIndex + INITIAL_L2_BLOCK_NUM), targetTxIndex, targetLogIndex);
                 const response = await store.getPublicLogs({
                     afterLog,
                     fromBlock: afterLog.blockNumber
@@ -1207,7 +1192,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                         EthAddress.random(),
                         EthAddress.random()
                     ],
-                    epoch: 123n,
+                    epoch: EpochNumber(123),
                     seed: 456n,
                     attestors: [
                         EthAddress.random()
@@ -1231,7 +1216,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                     attestors: [
                         EthAddress.random()
                     ],
-                    epoch: 789n,
+                    epoch: EpochNumber(789),
                     seed: 101n,
                     attestations: [
                         CommitteeAttestation.random()
@@ -1253,7 +1238,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                     committee: [
                         EthAddress.random()
                     ],
-                    epoch: 999n,
+                    epoch: EpochNumber(999),
                     seed: 888n,
                     attestors: [
                         EthAddress.random()
@@ -1273,7 +1258,7 @@ import { MessageStoreError } from './kv_archiver_store/message_store.js';
                     valid: false,
                     block: randomBlockInfo(4),
                     committee: [],
-                    epoch: 0n,
+                    epoch: EpochNumber(0),
                     seed: 0n,
                     attestors: [],
                     attestations: [],