@aztec/archiver 3.0.0-nightly.20251202 → 3.0.0-nightly.20251204

package/src/archiver/archiver_store_test_suite.ts

@@ -4,7 +4,7 @@ import {
   PRIVATE_LOG_SIZE_IN_FIELDS,
 } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
-import { EpochNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, 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';
@@ -90,7 +90,7 @@ export function describeArchiverDataStore(
 
     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', () => {
@@ -104,15 +104,18 @@ export function describeArchiverDataStore(
       });
 
       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)];
+        const blocks = [
+          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([]);
       });
     });
 
@@ -130,18 +133,22 @@ export function describeArchiverDataStore(
       });
 
       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([1, 2, 3, 4, 5, 6, 7]);
+        expect((await store.getPublishedBlocks(BlockNumber(1), 10)).map(b => b.block.number)).toEqual([
+          1, 2, 3, 4, 5, 6, 7,
+        ]);
       });
 
       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 () => {
@@ -173,32 +180,37 @@ export function describeArchiverDataStore(
       });
 
       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');
+        await expect(store.getPublishedBlocks((INITIAL_L2_BLOCK_NUM - 100) as BlockNumber, 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)], { force: true });
-        await expect(store.getPublishedBlocks(20, 1)).rejects.toThrow(`mismatch`);
+        await store.addBlocks([makePublished(await L2Block.random(BlockNumber(21)), 31)], { force: true });
+        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`);
       });
     });
 
@@ -346,18 +358,18 @@ export function describeArchiverDataStore(
         await store.addBlocks([blocks[0]]);
         await expect(store.addLogs([block])).resolves.toEqual(true);
 
-        expect((await store.getPrivateLogs(1, 1)).length).toEqual(
+        expect((await store.getPrivateLogs(BlockNumber(1), 1)).length).toEqual(
           block.body.txEffects.map(txEffect => txEffect.privateLogs).flat().length,
         );
-        expect((await store.getPublicLogs({ fromBlock: 1 })).logs.length).toEqual(
+        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.getPrivateLogs(1, 1)).length).toEqual(0);
-        expect((await store.getPublicLogs({ fromBlock: 1 })).logs.length).toEqual(0);
+        expect((await store.getPrivateLogs(BlockNumber(1), 1)).length).toEqual(0);
+        expect((await store.getPublicLogs({ fromBlock: BlockNumber(1) })).logs.length).toEqual(0);
       });
     });
 
@@ -367,7 +379,7 @@ export function describeArchiverDataStore(
         await store.addBlocks([blocks[0]]);
         await store.addLogs([block]);
 
-        const privateLogs = await store.getPrivateLogs(1, 1);
+        const privateLogs = await store.getPrivateLogs(BlockNumber(1), 1);
         expect(privateLogs).toEqual(block.body.txEffects.map(txEffect => txEffect.privateLogs).flat());
       });
     });
@@ -407,7 +419,7 @@ export function describeArchiverDataStore(
         () => wrapInBlock(blocks[5].block.body.txEffects[2], blocks[5].block),
         () => wrapInBlock(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);
@@ -427,7 +439,7 @@ export function describeArchiverDataStore(
             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);
       });
@@ -445,8 +457,9 @@ export function describeArchiverDataStore(
       const makeInboxMessagesWithFullBlocks = (blockCount: number, opts: { initialL2BlockNumber?: number } = {}) =>
         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 l2BlockNumber = BlockNumber(
+              (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);
             return { ...msg, l2BlockNumber, index };
@@ -454,19 +467,19 @@ export function describeArchiverDataStore(
         });
 
       it('stores first message ever', async () => {
-        const msg = makeInboxMessage(Buffer16.ZERO, { index: 0n, l2BlockNumber: 1 });
+        const msg = makeInboxMessage(Buffer16.ZERO, { index: 0n, l2BlockNumber: BlockNumber(1) });
         await store.addL1ToL2Messages([msg]);
 
         await checkMessages([msg]);
-        expect(await store.getL1ToL2Messages(1)).toEqual([msg.leaf]);
+        expect(await store.getL1ToL2Messages(BlockNumber(1))).toEqual([msg.leaf]);
       });
 
       it('stores single message', async () => {
-        const msg = makeInboxMessage(Buffer16.ZERO, { l2BlockNumber: 2 });
+        const msg = makeInboxMessage(Buffer16.ZERO, { l2BlockNumber: BlockNumber(2) });
         await store.addL1ToL2Messages([msg]);
 
         await checkMessages([msg]);
-        expect(await store.getL1ToL2Messages(2)).toEqual([msg.leaf]);
+        expect(await store.getL1ToL2Messages(BlockNumber(2))).toEqual([msg.leaf]);
       });
 
       it('stores and returns messages across different blocks', async () => {
@@ -474,7 +487,9 @@ export function describeArchiverDataStore(
         await store.addL1ToL2Messages(msgs);
 
         await checkMessages(msgs);
-        expect(await store.getL1ToL2Messages(initialL2BlockNumber + 2)).toEqual([msgs[2]].map(m => m.leaf));
+        expect(await store.getL1ToL2Messages(BlockNumber(initialL2BlockNumber + 2))).toEqual(
+          [msgs[2]].map(m => m.leaf),
+        );
       });
 
       it('stores the same messages again', async () => {
@@ -494,10 +509,10 @@ export function describeArchiverDataStore(
 
         await checkMessages([...msgs1, ...msgs2]);
 
-        expect(await store.getL1ToL2Messages(1)).toEqual([msgs1[0].leaf]);
-        expect(await store.getL1ToL2Messages(4)).toEqual([]);
-        expect(await store.getL1ToL2Messages(20)).toEqual([msgs2[0].leaf]);
-        expect(await store.getL1ToL2Messages(24)).toEqual([]);
+        expect(await store.getL1ToL2Messages(BlockNumber(1))).toEqual([msgs1[0].leaf]);
+        expect(await store.getL1ToL2Messages(BlockNumber(4))).toEqual([]);
+        expect(await store.getL1ToL2Messages(BlockNumber(20))).toEqual([msgs2[0].leaf]);
+        expect(await store.getL1ToL2Messages(BlockNumber(24))).toEqual([]);
       });
 
       it('stores and returns messages with block numbers larger than a byte', async () => {
@@ -505,7 +520,7 @@ export function describeArchiverDataStore(
         await store.addL1ToL2Messages(msgs);
 
         await checkMessages(msgs);
-        expect(await store.getL1ToL2Messages(1002)).toEqual([msgs[2]].map(m => m.leaf));
+        expect(await store.getL1ToL2Messages(BlockNumber(1002))).toEqual([msgs[2]].map(m => m.leaf));
       });
 
       it('stores and returns multiple messages per block', async () => {
@@ -513,7 +528,7 @@ export function describeArchiverDataStore(
         await store.addL1ToL2Messages(msgs);
 
         await checkMessages(msgs);
-        const blockMessages = await store.getL1ToL2Messages(initialL2BlockNumber + 1);
+        const blockMessages = await store.getL1ToL2Messages(BlockNumber(initialL2BlockNumber + 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),
@@ -525,8 +540,12 @@ export function describeArchiverDataStore(
         await store.addL1ToL2Messages(msgs.slice(0, 10));
         await store.addL1ToL2Messages(msgs.slice(10, 20));
 
-        expect(await store.getL1ToL2Messages(initialL2BlockNumber + 2)).toEqual([msgs[2]].map(m => m.leaf));
-        expect(await store.getL1ToL2Messages(initialL2BlockNumber + 12)).toEqual([msgs[12]].map(m => m.leaf));
+        expect(await store.getL1ToL2Messages(BlockNumber(initialL2BlockNumber + 2))).toEqual(
+          [msgs[2]].map(m => m.leaf),
+        );
+        expect(await store.getL1ToL2Messages(BlockNumber(initialL2BlockNumber + 12))).toEqual(
+          [msgs[12]].map(m => m.leaf),
+        );
         await checkMessages(msgs);
       });
 
@@ -553,7 +572,7 @@ export function describeArchiverDataStore(
 
       it('throws if block number for the first message is out of order', async () => {
         const msgs = makeInboxMessages(4, { initialL2BlockNumber });
-        msgs[2].l2BlockNumber = initialL2BlockNumber - 1;
+        msgs[2].l2BlockNumber = BlockNumber(initialL2BlockNumber - 1);
         await store.addL1ToL2Messages(msgs.slice(0, 2));
         await expect(store.addL1ToL2Messages(msgs.slice(2, 4))).rejects.toThrow(MessageStoreError);
       });
@@ -567,7 +586,7 @@ export function describeArchiverDataStore(
       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, BlockNumber(2)));
         await expect(store.addL1ToL2Messages(msgs.slice(2, 4))).rejects.toThrow(MessageStoreError);
       });
 
@@ -588,7 +607,7 @@ export function describeArchiverDataStore(
           initialL2BlockNumber,
           overrideFn: (msg, i) => ({
             ...msg,
-            l2BlockNumber: 2,
+            l2BlockNumber: BlockNumber(2),
             index: BigInt(i + NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * 2),
           }),
         });
@@ -602,17 +621,17 @@ export function describeArchiverDataStore(
         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);
+        expect(await store.getL1ToL2Messages(BlockNumber(1))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        expect(await store.getL1ToL2Messages(BlockNumber(2))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        expect(await store.getL1ToL2Messages(BlockNumber(3))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        expect(await store.getL1ToL2Messages(BlockNumber(4))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
 
-        await store.rollbackL1ToL2MessagesToL2Block(2);
+        await store.rollbackL1ToL2MessagesToL2Block(BlockNumber(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(BlockNumber(1))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        expect(await store.getL1ToL2Messages(BlockNumber(2))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        expect(await store.getL1ToL2Messages(BlockNumber(3))).toHaveLength(0);
+        expect(await store.getL1ToL2Messages(BlockNumber(4))).toHaveLength(0);
 
         await checkMessages(msgs.slice(0, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * 2));
       });
@@ -638,7 +657,7 @@ export function describeArchiverDataStore(
           originalContractClassId: classId,
         });
         contractInstance = { ...randomInstance, address: await AztecAddress.random() };
-        await store.addContractInstances([contractInstance], blockNum);
+        await store.addContractInstances([contractInstance], BlockNumber(blockNum));
       });
 
       it('returns previously stored contract instances', async () => {
@@ -652,7 +671,7 @@ export function describeArchiverDataStore(
       });
 
       it('returns undefined if previously stored contract instances was deleted', async () => {
-        await store.deleteContractInstances([contractInstance], blockNum);
+        await store.deleteContractInstances([contractInstance], BlockNumber(blockNum));
         await expect(store.getContractInstance(contractInstance.address, timestamp)).resolves.toBeUndefined();
       });
     });
@@ -671,7 +690,7 @@ export function describeArchiverDataStore(
           originalContractClassId: classId,
         });
         contractInstance = { ...randomInstance, address: await AztecAddress.random() };
-        await store.addContractInstances([contractInstance], 1);
+        await store.addContractInstances([contractInstance], BlockNumber(1));
         await store.addContractInstanceUpdates(
           [
             {
@@ -713,7 +732,7 @@ export function describeArchiverDataStore(
           ...randomInstance,
           address: await AztecAddress.random(),
         };
-        await store.addContractInstances([otherContractInstance], 1);
+        await store.addContractInstances([otherContractInstance], BlockNumber(1));
 
         const fetchedInstance = await store.getContractInstance(otherContractInstance.address, timestampOfChange + 1n);
         expect(fetchedInstance?.originalContractClassId).toEqual(otherClassId);
@@ -731,7 +750,7 @@ export function describeArchiverDataStore(
           ...randomInstance,
           address: await AztecAddress.random(),
         };
-        await store.addContractInstances([otherContractInstance], 1);
+        await store.addContractInstances([otherContractInstance], BlockNumber(1));
         await store.addContractInstanceUpdates(
           [
             {
@@ -759,7 +778,7 @@ export function describeArchiverDataStore(
         await store.addContractClasses(
           [contractClass],
           [await computePublicBytecodeCommitment(contractClass.packedBytecode)],
-          blockNum,
+          BlockNumber(blockNum),
         );
       });
 
@@ -768,7 +787,7 @@ export function describeArchiverDataStore(
       });
 
       it('returns undefined if the initial deployed contract class was deleted', async () => {
-        await store.deleteContractClasses([contractClass], blockNum);
+        await store.deleteContractClasses([contractClass], BlockNumber(blockNum));
         await expect(store.getContractClass(contractClass.id)).resolves.toBeUndefined();
       });
 
@@ -776,9 +795,9 @@ export function describeArchiverDataStore(
         await store.addContractClasses(
           [contractClass],
           [await computePublicBytecodeCommitment(contractClass.packedBytecode)],
-          blockNum + 1,
+          BlockNumber(blockNum + 1),
         );
-        await store.deleteContractClasses([contractClass], blockNum + 1);
+        await store.deleteContractClasses([contractClass], BlockNumber(blockNum + 1));
         await expect(store.getContractClass(contractClass.id)).resolves.toMatchObject(contractClass);
       });
 
@@ -858,8 +877,8 @@ export function describeArchiverDataStore(
       };
 
       const mockBlockWithLogs = async (blockNumber: number): Promise<PublishedL2Block> => {
-        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: number) => {
           const txEffect = await TxEffect.random();
@@ -991,7 +1010,7 @@ export function describeArchiverDataStore(
       beforeEach(async () => {
         blocks = await timesParallel(numBlocks, async (index: number) =>
           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), timestamp: BigInt(index) },
             attestations: times(3, CommitteeAttestation.random),
           }),
@@ -1008,7 +1027,7 @@ export function describeArchiverDataStore(
         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)),
         ]);
 
@@ -1083,7 +1102,7 @@ export function describeArchiverDataStore(
         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 });
         const logs = response.logs;
@@ -1105,42 +1124,54 @@ export function describeArchiverDataStore(
       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 });
         expect(response.logs.length).toBeGreaterThan(1);
       });
 
       it('intersecting works', async () => {
-        let logs = (await store.getPublicLogs({ fromBlock: -10, toBlock: -5 })).logs;
+        let logs = (await store.getPublicLogs({ fromBlock: -10 as BlockNumber, toBlock: -5 as BlockNumber })).logs;
         expect(logs.length).toBe(0);
 
         // "fromBlock" gets correctly trimmed to range and "toBlock" is exclusive
-        logs = (await store.getPublicLogs({ fromBlock: -10, toBlock: 5 })).logs;
+        logs = (await store.getPublicLogs({ fromBlock: -10 as BlockNumber, toBlock: BlockNumber(5) })).logs;
         let blockNumbers = new Set(logs.map(log => log.id.blockNumber));
         expect(blockNumbers).toEqual(new Set([1, 2, 3, 4]));
 
         // "toBlock" should be exclusive
-        logs = (await store.getPublicLogs({ fromBlock: 1, toBlock: 1 })).logs;
+        logs = (await store.getPublicLogs({ fromBlock: BlockNumber(1), toBlock: BlockNumber(1) })).logs;
         expect(logs.length).toBe(0);
 
-        logs = (await store.getPublicLogs({ fromBlock: 10, toBlock: 5 })).logs;
+        logs = (await store.getPublicLogs({ 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
-        logs = (await store.getPublicLogs({ fromBlock: -100, toBlock: +100 })).logs;
+        logs = (await store.getPublicLogs({ fromBlock: -100 as BlockNumber, toBlock: +100 })).logs;
         blockNumbers = new Set(logs.map(log => log.id.blockNumber));
         expect(blockNumbers.size).toBe(numBlocks);
 
         // intersecting with "afterLog" works
-        logs = (await store.getPublicLogs({ fromBlock: 2, toBlock: 5, afterLog: new LogId(4, 0, 0) })).logs;
+        logs = (
+          await store.getPublicLogs({
+            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) })).logs;
+        logs = (await store.getPublicLogs({ 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) })).logs;
+        logs = (
+          await store.getPublicLogs({
+            fromBlock: BlockNumber(2),
+            toBlock: BlockNumber(5),
+            afterLog: new LogId(BlockNumber(100), 0, 0),
+          })
+        ).logs;
         expect(logs.length).toBe(0);
       });
 
@@ -1150,7 +1181,7 @@ export function describeArchiverDataStore(
         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 });
         const logs = response.logs;

package/src/archiver/data_retrieval.ts

@@ -14,7 +14,7 @@ import type {
   ViemPublicClient,
 } from '@aztec/ethereum';
 import { asyncPool } from '@aztec/foundation/async-pool';
-import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { ViemSignature } from '@aztec/foundation/eth-signature';
@@ -470,7 +470,7 @@ function mapLogsInboxMessage(logs: GetContractEventsReturnType<typeof InboxAbi,
       leaf: Fr.fromHexString(hash!),
       l1BlockNumber: log.blockNumber,
       l1BlockHash: Buffer32.fromString(log.blockHash),
-      l2BlockNumber: Number(checkpointNumber!),
+      l2BlockNumber: BlockNumber(Number(checkpointNumber!)),
       rollingHash: Buffer16.fromString(rollingHash!),
     };
   });

package/src/archiver/kv_archiver_store/block_store.ts

@@ -1,4 +1,5 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/fields';
 import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
@@ -158,7 +159,7 @@ export class BlockStore {
    * @param blocksToUnwind - The number of blocks we are to unwind
    * @returns True if the operation is successful
    */
-  async unwindBlocks(from: number, blocksToUnwind: number) {
+  async unwindBlocks(from: BlockNumber, blocksToUnwind: number) {
     return await this.db.transactionAsync(async () => {
       const last = await this.getSynchedL2BlockNumber();
       if (from !== last) {
@@ -167,12 +168,12 @@ export class BlockStore {
 
       const proven = await this.getProvenL2BlockNumber();
       if (from - blocksToUnwind < proven) {
-        await this.setProvenL2BlockNumber(from - blocksToUnwind);
+        await this.setProvenL2BlockNumber(BlockNumber(from - blocksToUnwind));
       }
 
       for (let i = 0; i < blocksToUnwind; i++) {
         const blockNumber = from - i;
-        const block = await this.getBlock(blockNumber);
+        const block = await this.getBlock(BlockNumber(blockNumber));
 
         if (block === undefined) {
           this.#log.warn(`Cannot remove block ${blockNumber} from the store since we don't have it`);
@@ -200,7 +201,7 @@ export class BlockStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks
    */
-  async *getBlocks(start: number, limit: number): AsyncIterableIterator<PublishedL2Block> {
+  async *getBlocks(start: BlockNumber, limit: number): AsyncIterableIterator<PublishedL2Block> {
     for await (const [blockNumber, blockStorage] of this.getBlockStorages(start, limit)) {
       const block = await this.getBlockFromBlockStorage(blockNumber, blockStorage);
       if (block) {
@@ -214,7 +215,7 @@ export class BlockStore {
    * @param blockNumber - The number of the block to return.
    * @returns The requested L2 block.
    */
-  async getBlock(blockNumber: number): Promise<PublishedL2Block | undefined> {
+  async getBlock(blockNumber: BlockNumber): Promise<PublishedL2Block | undefined> {
     const blockStorage = await this.#blocks.getAsync(blockNumber);
     if (!blockStorage || !blockStorage.header) {
       return Promise.resolve(undefined);
@@ -232,7 +233,7 @@ export class BlockStore {
     if (blockNumber === undefined) {
       return undefined;
     }
-    return this.getBlock(blockNumber);
+    return this.getBlock(BlockNumber(blockNumber));
   }
 
   /**
@@ -245,7 +246,7 @@ export class BlockStore {
     if (blockNumber === undefined) {
       return undefined;
     }
-    return this.getBlock(blockNumber);
+    return this.getBlock(BlockNumber(blockNumber));
   }
 
   /**
@@ -288,7 +289,7 @@ export class BlockStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 block headers
    */
-  async *getBlockHeaders(start: number, limit: number): AsyncIterableIterator<BlockHeader> {
+  async *getBlockHeaders(start: BlockNumber, limit: number): AsyncIterableIterator<BlockHeader> {
     for await (const [blockNumber, blockStorage] of this.getBlockStorages(start, limit)) {
       const header = L2BlockHeader.fromBuffer(blockStorage.header).toBlockHeader();
       if (header.getBlockNumber() !== blockNumber) {
@@ -300,7 +301,7 @@ export class BlockStore {
     }
   }
 
-  private async *getBlockStorages(start: number, limit: number) {
+  private async *getBlockStorages(start: BlockNumber, limit: number) {
     let expectedBlockNumber = start;
     for await (const [blockNumber, blockStorage] of this.#blocks.entriesAsync(this.#computeBlockRange(start, limit))) {
       if (blockNumber !== expectedBlockNumber) {
@@ -382,7 +383,7 @@ export class BlockStore {
       '',
       txEffect.data.transactionFee.toBigInt(),
       txEffect.l2BlockHash,
-      txEffect.l2BlockNumber,
+      BlockNumber(txEffect.l2BlockNumber),
     );
   }
 
@@ -413,9 +414,9 @@ export class BlockStore {
    * Gets the number of the latest L2 block processed.
    * @returns The number of the latest L2 block processed.
    */
-  async getSynchedL2BlockNumber(): Promise<number> {
+  async getSynchedL2BlockNumber(): Promise<BlockNumber> {
     const [lastBlockNumber] = await toArray(this.#blocks.keysAsync({ reverse: true, limit: 1 }));
-    return typeof lastBlockNumber === 'number' ? lastBlockNumber : INITIAL_L2_BLOCK_NUM - 1;
+    return typeof lastBlockNumber === 'number' ? BlockNumber(lastBlockNumber) : BlockNumber(INITIAL_L2_BLOCK_NUM - 1);
   }
 
   /**
@@ -430,19 +431,19 @@ export class BlockStore {
     return this.#lastSynchedL1Block.set(l1BlockNumber);
   }
 
-  async getProvenL2BlockNumber(): Promise<number> {
+  async getProvenL2BlockNumber(): Promise<BlockNumber> {
     const [latestBlockNumber, provenBlockNumber] = await Promise.all([
       this.getSynchedL2BlockNumber(),
       this.#lastProvenL2Block.getAsync(),
     ]);
-    return (provenBlockNumber ?? 0) > latestBlockNumber ? latestBlockNumber : (provenBlockNumber ?? 0);
+    return (provenBlockNumber ?? 0) > latestBlockNumber ? latestBlockNumber : BlockNumber(provenBlockNumber ?? 0);
   }
 
-  setProvenL2BlockNumber(blockNumber: number) {
+  setProvenL2BlockNumber(blockNumber: BlockNumber) {
     return this.#lastProvenL2Block.set(blockNumber);
   }
 
-  #computeBlockRange(start: number, limit: number): Required<Pick<Range<number>, 'start' | 'limit'>> {
+  #computeBlockRange(start: BlockNumber, limit: number): Required<Pick<Range<number>, 'start' | 'limit'>> {
     if (limit < 1) {
       throw new Error(`Invalid limit: ${limit}`);
     }