@aztec/archiver 0.0.1-commit.b655e406 → 0.0.1-commit.d3ec352c

package/src/archiver/archiver_store.ts

@@ -1,4 +1,5 @@
 import type { L1BlockId } from '@aztec/ethereum';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/fields';
 import type { CustomRange } from '@aztec/kv-store';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
@@ -53,13 +54,13 @@ export interface ArchiverDataStore {
    * @param blocksToUnwind - The number of blocks we are to unwind
    * @returns True if the operation is successful
    */
-  unwindBlocks(from: number, blocksToUnwind: number): Promise<boolean>;
+  unwindBlocks(from: BlockNumber, blocksToUnwind: number): Promise<boolean>;
 
   /**
    * Returns the block for the given number, or undefined if not exists.
    * @param number - The block number to return.
    */
-  getPublishedBlock(number: number): Promise<PublishedL2Block | undefined>;
+  getPublishedBlock(number: BlockNumber): Promise<PublishedL2Block | undefined>;
 
   /**
    * Returns the block for the given hash, or undefined if not exists.
@@ -79,7 +80,7 @@ export interface ArchiverDataStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks.
    */
-  getPublishedBlocks(from: number, limit: number): Promise<PublishedL2Block[]>;
+  getPublishedBlocks(from: BlockNumber, limit: number): Promise<PublishedL2Block[]>;
 
   /**
    * Gets up to `limit` amount of L2 block headers starting from `from`.
@@ -87,7 +88,7 @@ export interface ArchiverDataStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 block headers.
    */
-  getBlockHeaders(from: number, limit: number): Promise<BlockHeader[]>;
+  getBlockHeaders(from: BlockNumber, limit: number): Promise<BlockHeader[]>;
 
   /**
    * Returns the block header for the given hash, or undefined if not exists.
@@ -135,7 +136,7 @@ export interface ArchiverDataStore {
    * @param blockNumber - L2 block number to get messages for.
    * @returns The L1 to L2 messages/leaves of the messages subtree (throws if not found).
    */
-  getL1ToL2Messages(blockNumber: number): Promise<Fr[]>;
+  getL1ToL2Messages(blockNumber: BlockNumber): Promise<Fr[]>;
 
   /**
    * Gets the L1 to L2 message index in the L1 to L2 message tree.
@@ -156,7 +157,7 @@ export interface ArchiverDataStore {
    * @param limit - The maximum number of blocks to retrieve logs from.
    * @returns An array of private logs from the specified range of blocks.
    */
-  getPrivateLogs(from: number, limit: number): Promise<PrivateLog[]>;
+  getPrivateLogs(from: BlockNumber, limit: number): Promise<PrivateLog[]>;
 
   /**
    * Gets all logs that match any of the received tags (i.e. logs with their first field equal to a tag).
@@ -185,19 +186,19 @@ export interface ArchiverDataStore {
    * Gets the number of the latest L2 block processed.
    * @returns The number of the latest L2 block processed.
    */
-  getSynchedL2BlockNumber(): Promise<number>;
+  getSynchedL2BlockNumber(): Promise<BlockNumber>;
 
   /**
    * Gets the number of the latest proven L2 block processed.
    * @returns The number of the latest proven L2 block processed.
    */
-  getProvenL2BlockNumber(): Promise<number>;
+  getProvenL2BlockNumber(): Promise<BlockNumber>;
 
   /**
    * Stores the number of the latest proven L2 block processed.
    * @param l2BlockNumber - The number of the latest proven L2 block processed.
    */
-  setProvenL2BlockNumber(l2BlockNumber: number): Promise<void>;
+  setProvenL2BlockNumber(l2BlockNumber: BlockNumber): Promise<void>;
 
   /**
    * Stores the l1 block number that blocks have been synched until
@@ -221,9 +222,13 @@ export interface ArchiverDataStore {
    * @param blockNumber - Number of the L2 block the contracts were registered in.
    * @returns True if the operation is successful.
    */
-  addContractClasses(data: ContractClassPublic[], bytecodeCommitments: Fr[], blockNumber: number): Promise<boolean>;
+  addContractClasses(
+    data: ContractClassPublic[],
+    bytecodeCommitments: Fr[],
+    blockNumber: BlockNumber,
+  ): Promise<boolean>;
 
-  deleteContractClasses(data: ContractClassPublic[], blockNumber: number): Promise<boolean>;
+  deleteContractClasses(data: ContractClassPublic[], blockNumber: BlockNumber): Promise<boolean>;
 
   getBytecodeCommitment(contractClassId: Fr): Promise<Fr | undefined>;
 
@@ -239,8 +244,8 @@ export interface ArchiverDataStore {
    * @param blockNumber - Number of the L2 block the instances were deployed in.
    * @returns True if the operation is successful.
    */
-  addContractInstances(data: ContractInstanceWithAddress[], blockNumber: number): Promise<boolean>;
-  deleteContractInstances(data: ContractInstanceWithAddress[], blockNumber: number): Promise<boolean>;
+  addContractInstances(data: ContractInstanceWithAddress[], blockNumber: BlockNumber): Promise<boolean>;
+  deleteContractInstances(data: ContractInstanceWithAddress[], blockNumber: BlockNumber): Promise<boolean>;
 
   /**
    * Add new contract instance updates
@@ -286,7 +291,7 @@ export interface ArchiverDataStore {
   close(): Promise<void>;
 
   /** Deletes all L1 to L2 messages up until (excluding) the target L2 block number. */
-  rollbackL1ToL2MessagesToL2Block(targetBlockNumber: number): Promise<void>;
+  rollbackL1ToL2MessagesToL2Block(targetBlockNumber: BlockNumber): Promise<void>;
 
   /** Returns an async iterator to all L1 to L2 messages on the range. */
   iterateL1ToL2Messages(range?: CustomRange<bigint>): AsyncIterableIterator<InboxMessage>;

package/src/archiver/archiver_store_test_suite.ts

@@ -4,6 +4,7 @@ import {
   PRIVATE_LOG_SIZE_IN_FIELDS,
 } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
+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';
@@ -89,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', () => {
@@ -103,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([]);
       });
     });
 
@@ -129,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 () => {
@@ -172,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`);
       });
     });
 
@@ -345,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);
       });
     });
 
@@ -366,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());
       });
     });
@@ -406,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);
@@ -426,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);
       });
@@ -444,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 };
@@ -453,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 () => {
@@ -473,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 () => {
@@ -493,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 () => {
@@ -504,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 () => {
@@ -512,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),
@@ -524,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);
       });
 
@@ -552,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);
       });
@@ -566,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);
       });
 
@@ -587,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),
           }),
         });
@@ -601,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));
       });
@@ -637,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 () => {
@@ -651,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();
       });
     });
@@ -670,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(
           [
             {
@@ -712,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);
@@ -730,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(
           [
             {
@@ -758,7 +778,7 @@ export function describeArchiverDataStore(
         await store.addContractClasses(
           [contractClass],
           [await computePublicBytecodeCommitment(contractClass.packedBytecode)],
-          blockNum,
+          BlockNumber(blockNum),
         );
       });
 
@@ -767,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();
       });
 
@@ -775,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);
       });
 
@@ -857,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();
@@ -990,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),
           }),
@@ -1007,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)),
         ]);
 
@@ -1082,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;
@@ -1104,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);
       });
 
@@ -1149,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;
@@ -1189,7 +1221,7 @@ export function describeArchiverDataStore(
           valid: false,
           block: randomBlockInfo(1),
           committee: [EthAddress.random(), EthAddress.random()],
-          epoch: 123n,
+          epoch: EpochNumber(123),
           seed: 456n,
           attestors: [EthAddress.random()],
           attestations: [CommitteeAttestation.random()],
@@ -1208,7 +1240,7 @@ export function describeArchiverDataStore(
           block: randomBlockInfo(2),
           committee: [EthAddress.random()],
           attestors: [EthAddress.random()],
-          epoch: 789n,
+          epoch: EpochNumber(789),
           seed: 101n,
           attestations: [CommitteeAttestation.random()],
           reason: 'invalid-attestation',
@@ -1227,7 +1259,7 @@ export function describeArchiverDataStore(
           valid: false,
           block: randomBlockInfo(3),
           committee: [EthAddress.random()],
-          epoch: 999n,
+          epoch: EpochNumber(999),
           seed: 888n,
           attestors: [EthAddress.random()],
           attestations: [CommitteeAttestation.random()],
@@ -1246,7 +1278,7 @@ export function describeArchiverDataStore(
           valid: false,
           block: randomBlockInfo(4),
           committee: [],
-          epoch: 0n,
+          epoch: EpochNumber(0),
           seed: 0n,
           attestors: [],
           attestations: [],

package/src/archiver/config.ts

@@ -50,6 +50,11 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     description: 'Whether to skip validating block attestations (use only for testing).',
     ...booleanConfigHelper(false),
   },
+  maxAllowedEthClientDriftSeconds: {
+    env: 'MAX_ALLOWED_ETH_CLIENT_DRIFT_SECONDS',
+    description: 'Maximum allowed drift in seconds between the Ethereum client and current time.',
+    ...numberConfigHelper(300),
+  },
   ...chainConfigMappings,
   ...l1ReaderConfigMappings,
   viemPollingIntervalMS: {