@aztec/archiver 0.86.0 → 0.87.0

package/dest/archiver/archiver_store_test_suite.js

@@ -1,8 +1,11 @@
-import { INITIAL_L2_BLOCK_NUM, L1_TO_L2_MSG_SUBTREE_HEIGHT, PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_LOG_DATA_SIZE_IN_FIELDS } from '@aztec/constants';
+import { INITIAL_L2_BLOCK_NUM, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
 import { times, timesParallel } from '@aztec/foundation/collection';
 import { randomInt } from '@aztec/foundation/crypto';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
+import { toArray } from '@aztec/foundation/iterable';
 import { sleep } from '@aztec/foundation/sleep';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { L2Block, wrapInBlock } from '@aztec/stdlib/block';
@@ -12,6 +15,9 @@ import { InboxLeaf } from '@aztec/stdlib/messaging';
 import { makeContractClassPublic, makeExecutablePrivateFunctionWithMembershipProof, makeUtilityFunctionWithMembershipProof } from '@aztec/stdlib/testing';
 import '@aztec/stdlib/testing/jest';
 import { TxEffect, TxHash } from '@aztec/stdlib/tx';
+import { makeInboxMessage, makeInboxMessages } from '../test/mock_structs.js';
+import { BlockNumberNotSequentialError, InitialBlockNumberNotSequentialError } from './errors.js';
+import { MessageStoreError } from './kv_archiver_store/message_store.js';
 /**
  * @param testName - The name of the test suite.
  * @param getStore - Returns an instance of a store that's already been initialized.
@@ -77,17 +83,32 @@ import { TxEffect, TxHash } from '@aztec/stdlib/tx';
                 await store.addBlocks(blocks);
                 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);
+                await expect(store.addBlocks([
+                    block
+                ])).rejects.toThrow(InitialBlockNumberNotSequentialError);
+                await expect(store.getPublishedBlocks(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)
+                ];
+                await expect(store.addBlocks(blocks)).rejects.toThrow(BlockNumberNotSequentialError);
+                await expect(store.getPublishedBlocks(1, 10)).resolves.toEqual([]);
+            });
         });
         describe('unwindBlocks', ()=>{
             it('unwinding blocks will remove blocks from the chain', async ()=>{
                 await store.addBlocks(blocks);
                 const blockNumber = await store.getSynchedL2BlockNumber();
-                expectBlocksEqual(await store.getBlocks(blockNumber, 1), [
+                expectBlocksEqual(await store.getPublishedBlocks(blockNumber, 1), [
                     blocks[blocks.length - 1]
                 ]);
                 await store.unwindBlocks(blockNumber, 1);
                 expect(await store.getSynchedL2BlockNumber()).toBe(blockNumber - 1);
-                expect(await store.getBlocks(blockNumber, 1)).toEqual([]);
+                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));
@@ -95,7 +116,7 @@ import { TxEffect, TxHash } from '@aztec/stdlib/tx';
                 expect(await store.getSynchedL2BlockNumber()).toBe(10);
                 await store.unwindBlocks(10, 3);
                 expect(await store.getSynchedL2BlockNumber()).toBe(7);
-                expect((await store.getBlocks(1, 10)).map((b)=>b.block.number)).toEqual([
+                expect((await store.getPublishedBlocks(1, 10)).map((b)=>b.block.number)).toEqual([
                     1,
                     2,
                     3,
@@ -115,16 +136,33 @@ import { TxEffect, TxHash } from '@aztec/stdlib/tx';
                 await store.addBlocks(blocks);
             });
             it.each(blockTests)('retrieves previously stored blocks', async (start, limit, getExpectedBlocks)=>{
-                expectBlocksEqual(await store.getBlocks(start, limit), getExpectedBlocks());
+                expectBlocksEqual(await store.getPublishedBlocks(start, limit), getExpectedBlocks());
             });
             it('returns an empty array if no blocks are found', async ()=>{
-                await expect(store.getBlocks(12, 1)).resolves.toEqual([]);
+                await expect(store.getPublishedBlocks(12, 1)).resolves.toEqual([]);
             });
             it('throws an error if limit is invalid', async ()=>{
-                await expect(store.getBlocks(1, 0)).rejects.toThrow('Invalid limit: 0');
+                await expect(store.getPublishedBlocks(1, 0)).rejects.toThrow('Invalid limit: 0');
             });
             it('throws an error if `from` it is out of range', async ()=>{
-                await expect(store.getBlocks(INITIAL_L2_BLOCK_NUM - 100, 1)).rejects.toThrow('Invalid start: -99');
+                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)
+                ], {
+                    force: true
+                });
+                await expect(store.getPublishedBlocks(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)
+                ], {
+                    force: true
+                });
+                await expect(store.getPublishedBlocks(20, 2)).rejects.toThrow(`mismatch`);
             });
         });
         describe('getSyncedL2BlockNumber', ()=>{
@@ -151,15 +189,46 @@ import { TxEffect, TxHash } from '@aztec/stdlib/tx';
                 });
             });
             it('returns the L1 block number that most recently added messages from inbox', async ()=>{
-                await store.addL1ToL2Messages({
-                    lastProcessedL1BlockNumber: 1n,
-                    retrievedData: [
-                        new InboxLeaf(1n, Fr.ZERO)
-                    ]
+                const l1BlockHash = Buffer32.random();
+                const l1BlockNumber = 10n;
+                await store.setMessageSynchedL1Block({
+                    l1BlockNumber: 5n,
+                    l1BlockHash: Buffer32.random()
+                });
+                await store.addL1ToL2Messages([
+                    makeInboxMessage(Buffer16.ZERO, {
+                        l1BlockNumber,
+                        l1BlockHash
+                    })
+                ]);
+                await expect(store.getSynchPoint()).resolves.toEqual({
+                    blocksSynchedTo: undefined,
+                    messagesSynchedTo: {
+                        l1BlockHash,
+                        l1BlockNumber
+                    }
+                });
+            });
+            it('returns the latest syncpoint if latest message is behind', async ()=>{
+                const l1BlockHash = Buffer32.random();
+                const l1BlockNumber = 10n;
+                await store.setMessageSynchedL1Block({
+                    l1BlockNumber,
+                    l1BlockHash
+                });
+                const msg = makeInboxMessage(Buffer16.ZERO, {
+                    l1BlockNumber: 5n,
+                    l1BlockHash: Buffer32.random()
                 });
+                await store.addL1ToL2Messages([
+                    msg
+                ]);
                 await expect(store.getSynchPoint()).resolves.toEqual({
                     blocksSynchedTo: undefined,
-                    messagesSynchedTo: 1n
+                    messagesSynchedTo: {
+                        l1BlockHash,
+                        l1BlockNumber
+                    }
                 });
             });
         });
@@ -282,35 +351,224 @@ import { TxEffect, TxHash } from '@aztec/stdlib/tx';
             });
         });
         describe('L1 to L2 Messages', ()=>{
-            const l2BlockNumber = 13n;
-            const l1ToL2MessageSubtreeSize = 2 ** L1_TO_L2_MSG_SUBTREE_HEIGHT;
-            const generateBlockMessages = (blockNumber, numMessages)=>Array.from({
-                    length: numMessages
-                }, (_, i)=>new InboxLeaf(InboxLeaf.smallestIndexFromL2Block(blockNumber) + BigInt(i), Fr.random()));
-            it('returns messages in correct order', async ()=>{
-                const msgs = generateBlockMessages(l2BlockNumber, l1ToL2MessageSubtreeSize);
-                const shuffledMessages = msgs.slice().sort(()=>randomInt(1) - 0.5);
-                await store.addL1ToL2Messages({
-                    lastProcessedL1BlockNumber: 100n,
-                    retrievedData: shuffledMessages
-                });
-                const retrievedMessages = await store.getL1ToL2Messages(l2BlockNumber);
-                const expectedLeavesOrder = msgs.map((msg)=>msg.leaf);
-                expect(expectedLeavesOrder).toEqual(retrievedMessages);
-            });
-            it('throws if it is impossible to sequence messages correctly', async ()=>{
-                const msgs = generateBlockMessages(l2BlockNumber, l1ToL2MessageSubtreeSize - 1);
-                // We replace a message with index 4 with a message with index at the end of the tree
-                // --> with that there will be a gap and it will be impossible to sequence the
-                // end of tree = start of next tree/block - 1
-                msgs[4] = new InboxLeaf(InboxLeaf.smallestIndexFromL2Block(l2BlockNumber + 1n) - 1n, Fr.random());
-                await store.addL1ToL2Messages({
-                    lastProcessedL1BlockNumber: 100n,
-                    retrievedData: msgs
-                });
-                await expect(async ()=>{
-                    await store.getL1ToL2Messages(l2BlockNumber);
-                }).rejects.toThrow(`L1 to L2 message gap found in block ${l2BlockNumber}`);
+            const initialL2BlockNumber = 13n;
+            const checkMessages = async (msgs)=>{
+                expect(await store.getLastL1ToL2Message()).toEqual(msgs.at(-1));
+                expect(await toArray(store.iterateL1ToL2Messages())).toEqual(msgs);
+                expect(await store.getTotalL1ToL2MessageCount()).toEqual(BigInt(msgs.length));
+            };
+            const makeInboxMessagesWithFullBlocks = (blockCount, opts = {})=>makeInboxMessages(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * blockCount, {
+                    overrideFn: (msg, i)=>{
+                        const l2BlockNumber = (opts.initialL2BlockNumber ?? initialL2BlockNumber) + BigInt(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
+                        };
+                    }
+                });
+            it('stores first message ever', async ()=>{
+                const msg = makeInboxMessage(Buffer16.ZERO, {
+                    index: 0n,
+                    l2BlockNumber: 1n
+                });
+                await store.addL1ToL2Messages([
+                    msg
+                ]);
+                await checkMessages([
+                    msg
+                ]);
+                expect(await store.getL1ToL2Messages(1n)).toEqual([
+                    msg.leaf
+                ]);
+            });
+            it('stores single message', async ()=>{
+                const msg = makeInboxMessage(Buffer16.ZERO, {
+                    l2BlockNumber: 2n
+                });
+                await store.addL1ToL2Messages([
+                    msg
+                ]);
+                await checkMessages([
+                    msg
+                ]);
+                expect(await store.getL1ToL2Messages(2n)).toEqual([
+                    msg.leaf
+                ]);
+            });
+            it('stores and returns messages across different blocks', async ()=>{
+                const msgs = makeInboxMessages(5, {
+                    initialL2BlockNumber
+                });
+                await store.addL1ToL2Messages(msgs);
+                await checkMessages(msgs);
+                expect(await store.getL1ToL2Messages(initialL2BlockNumber + 2n)).toEqual([
+                    msgs[2]
+                ].map((m)=>m.leaf));
+            });
+            it('stores the same messages again', async ()=>{
+                const msgs = makeInboxMessages(5, {
+                    initialL2BlockNumber
+                });
+                await store.addL1ToL2Messages(msgs);
+                await store.addL1ToL2Messages(msgs.slice(2));
+                await checkMessages(msgs);
+            });
+            it('stores and returns messages across different blocks with gaps', async ()=>{
+                const msgs1 = makeInboxMessages(3, {
+                    initialL2BlockNumber: 1n
+                });
+                const msgs2 = makeInboxMessages(3, {
+                    initialL2BlockNumber: 20n,
+                    initialHash: msgs1.at(-1).rollingHash
+                });
+                await store.addL1ToL2Messages(msgs1);
+                await store.addL1ToL2Messages(msgs2);
+                await checkMessages([
+                    ...msgs1,
+                    ...msgs2
+                ]);
+                expect(await store.getL1ToL2Messages(1n)).toEqual([
+                    msgs1[0].leaf
+                ]);
+                expect(await store.getL1ToL2Messages(4n)).toEqual([]);
+                expect(await store.getL1ToL2Messages(20n)).toEqual([
+                    msgs2[0].leaf
+                ]);
+                expect(await store.getL1ToL2Messages(24n)).toEqual([]);
+            });
+            it('stores and returns messages with block numbers larger than a byte', async ()=>{
+                const msgs = makeInboxMessages(5, {
+                    initialL2BlockNumber: 1000n
+                });
+                await store.addL1ToL2Messages(msgs);
+                await checkMessages(msgs);
+                expect(await store.getL1ToL2Messages(1002n)).toEqual([
+                    msgs[2]
+                ].map((m)=>m.leaf));
+            });
+            it('stores and returns multiple messages per block', async ()=>{
+                const msgs = makeInboxMessagesWithFullBlocks(4);
+                await store.addL1ToL2Messages(msgs);
+                await checkMessages(msgs);
+                const blockMessages = await store.getL1ToL2Messages(initialL2BlockNumber + 1n);
+                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
+                });
+                await store.addL1ToL2Messages(msgs.slice(0, 10));
+                await store.addL1ToL2Messages(msgs.slice(10, 20));
+                expect(await store.getL1ToL2Messages(initialL2BlockNumber + 2n)).toEqual([
+                    msgs[2]
+                ].map((m)=>m.leaf));
+                expect(await store.getL1ToL2Messages(initialL2BlockNumber + 12n)).toEqual([
+                    msgs[12]
+                ].map((m)=>m.leaf));
+                await checkMessages(msgs);
+            });
+            it('iterates over messages from start index', async ()=>{
+                const msgs = makeInboxMessages(10, {
+                    initialL2BlockNumber
+                });
+                await store.addL1ToL2Messages(msgs);
+                const iterated = await toArray(store.iterateL1ToL2Messages({
+                    start: msgs[3].index
+                }));
+                expect(iterated).toEqual(msgs.slice(3));
+            });
+            it('iterates over messages in reverse', async ()=>{
+                const msgs = makeInboxMessages(10, {
+                    initialL2BlockNumber
+                });
+                await store.addL1ToL2Messages(msgs);
+                const iterated = await toArray(store.iterateL1ToL2Messages({
+                    reverse: true,
+                    end: msgs[3].index
+                }));
+                expect(iterated).toEqual(msgs.slice(0, 4).reverse());
+            });
+            it('throws if messages are added out of order', async ()=>{
+                const msgs = makeInboxMessages(5, {
+                    overrideFn: (msg, i)=>({
+                            ...msg,
+                            index: BigInt(10 - i)
+                        })
+                });
+                await expect(store.addL1ToL2Messages(msgs)).rejects.toThrow(MessageStoreError);
+            });
+            it('throws if block number for the first message is out of order', async ()=>{
+                const msgs = makeInboxMessages(4, {
+                    initialL2BlockNumber
+                });
+                msgs[2].l2BlockNumber = initialL2BlockNumber - 1n;
+                await store.addL1ToL2Messages(msgs.slice(0, 2));
+                await expect(store.addL1ToL2Messages(msgs.slice(2, 4))).rejects.toThrow(MessageStoreError);
+            });
+            it('throws if rolling hash is not correct', async ()=>{
+                const msgs = makeInboxMessages(5);
+                msgs[1].rollingHash = Buffer16.random();
+                await expect(store.addL1ToL2Messages(msgs)).rejects.toThrow(MessageStoreError);
+            });
+            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 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
+                });
+                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
+                });
+                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,
+                    overrideFn: (msg, i)=>({
+                            ...msg,
+                            l2BlockNumber: 2n,
+                            index: BigInt(i + NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * 2)
+                        })
+                });
+                msgs[1].index++;
+                await expect(store.addL1ToL2Messages(msgs)).rejects.toThrow(MessageStoreError);
+            });
+            it('removes messages up to the given block number', async ()=>{
+                const msgs = makeInboxMessagesWithFullBlocks(4, {
+                    initialL2BlockNumber: 1n
+                });
+                await store.addL1ToL2Messages(msgs);
+                await checkMessages(msgs);
+                expect(await store.getL1ToL2Messages(1n)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+                expect(await store.getL1ToL2Messages(2n)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+                expect(await store.getL1ToL2Messages(3n)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+                expect(await store.getL1ToL2Messages(4n)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+                await store.rollbackL1ToL2MessagesToL2Block(2n);
+                expect(await store.getL1ToL2Messages(1n)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+                expect(await store.getL1ToL2Messages(2n)).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+                expect(await store.getL1ToL2Messages(3n)).toHaveLength(0);
+                expect(await store.getL1ToL2Messages(4n)).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: 1n
+                });
+                await store.addL1ToL2Messages(msgs);
+                await store.removeL1ToL2Messages(msgs[13].index);
+                await checkMessages(msgs.slice(0, 13));
             });
         });
         describe('contractInstances', ()=>{
@@ -386,6 +644,49 @@ import { TxEffect, TxHash } from '@aztec/stdlib/tx';
                 expect(fetchedInstance?.originalContractClassId).toEqual(classId);
                 expect(fetchedInstance?.currentContractClassId).toEqual(nextClassId);
             });
+            it('ignores updates for the wrong contract', async ()=>{
+                const otherClassId = Fr.random();
+                const randomInstance = await SerializableContractInstance.random({
+                    currentContractClassId: otherClassId,
+                    originalContractClassId: otherClassId
+                });
+                const otherContractInstance = {
+                    ...randomInstance,
+                    address: await AztecAddress.random()
+                };
+                await store.addContractInstances([
+                    otherContractInstance
+                ], 1);
+                const fetchedInstance = await store.getContractInstance(otherContractInstance.address, blockOfChange + 1);
+                expect(fetchedInstance?.originalContractClassId).toEqual(otherClassId);
+                expect(fetchedInstance?.currentContractClassId).toEqual(otherClassId);
+            });
+            it('bounds its search to the right contract if more than than one update exists', async ()=>{
+                const otherClassId = Fr.random();
+                const otherNextClassId = Fr.random();
+                const randomInstance = await SerializableContractInstance.random({
+                    currentContractClassId: otherClassId,
+                    originalContractClassId: otherNextClassId
+                });
+                const otherContractInstance = {
+                    ...randomInstance,
+                    address: await AztecAddress.random()
+                };
+                await store.addContractInstances([
+                    otherContractInstance
+                ], 1);
+                await store.addContractInstanceUpdates([
+                    {
+                        prevContractClassId: otherClassId,
+                        newContractClassId: otherNextClassId,
+                        blockOfChange,
+                        address: otherContractInstance.address
+                    }
+                ], blockOfChange - 1);
+                const fetchedInstance = await store.getContractInstance(contractInstance.address, blockOfChange + 1);
+                expect(fetchedInstance?.originalContractClassId).toEqual(classId);
+                expect(fetchedInstance?.currentContractClassId).toEqual(nextClassId);
+            });
         });
         describe('contractClasses', ()=>{
             let contractClass;
@@ -454,16 +755,17 @@ import { TxEffect, TxHash } from '@aztec/stdlib/tx';
             const numPrivateLogsPerTx = 3;
             const numPublicLogsPerTx = 2;
             let blocks;
-            const makeTag = (blockNumber, txIndex, logIndex, isPublic = false)=>new Fr((blockNumber * 100 + txIndex * 10 + logIndex) * (isPublic ? 123 : 1));
-            const makePrivateLog = (tag)=>PrivateLog.fromFields([
-                    tag,
-                    ...times(PRIVATE_LOG_SIZE_IN_FIELDS - 1, (i)=>new Fr(tag.toNumber() + i))
-                ]);
-            const makePublicLog = (tag)=>PublicLog.fromFields([
-                    AztecAddress.fromNumber(1).toField(),
-                    tag,
-                    ...times(PUBLIC_LOG_DATA_SIZE_IN_FIELDS - 1, (i)=>new Fr(tag.toNumber() + i))
-                ]);
+            const makeTag = (blockNumber, txIndex, logIndex, isPublic = false)=>blockNumber === 1 && txIndex === 0 && logIndex === 0 ? Fr.ZERO // Shared tag
+                 : new Fr((blockNumber * 100 + txIndex * 10 + logIndex) * (isPublic ? 123 : 1));
+            const makePrivateLog = (tag)=>PrivateLog.from({
+                    fields: makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, (i)=>!i ? tag : new Fr(tag.toNumber() + i)),
+                    emittedLength: PRIVATE_LOG_SIZE_IN_FIELDS
+                });
+            const makePublicLog = (tag)=>PublicLog.from({
+                    contractAddress: AztecAddress.fromNumber(1),
+                    fields: makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, (i)=>!i ? tag : new Fr(tag.toNumber() + i)),
+                    emittedLength: PUBLIC_LOG_SIZE_IN_FIELDS
+                });
             const mockPrivateLogs = (blockNumber, txIndex)=>{
                 return times(numPrivateLogsPerTx, (logIndex)=>{
                     const tag = makeTag(blockNumber, txIndex, logIndex);
@@ -496,27 +798,27 @@ import { TxEffect, TxHash } from '@aztec/stdlib/tx';
                 };
             };
             beforeEach(async ()=>{
-                blocks = await timesParallel(numBlocks, (index)=>mockBlockWithLogs(index));
+                blocks = await timesParallel(numBlocks, (index)=>mockBlockWithLogs(index + 1));
                 await store.addBlocks(blocks);
                 await store.addLogs(blocks.map((b)=>b.block));
             });
             it('is possible to batch request private logs via tags', async ()=>{
                 const tags = [
-                    makeTag(1, 1, 2),
-                    makeTag(0, 2, 0)
+                    makeTag(2, 1, 2),
+                    makeTag(1, 2, 0)
                 ];
                 const logsByTags = await store.getLogsByTags(tags);
                 expect(logsByTags).toEqual([
                     [
                         expect.objectContaining({
-                            blockNumber: 1,
+                            blockNumber: 2,
                             log: makePrivateLog(tags[0]),
                             isFromPublic: false
                         })
                     ],
                     [
                         expect.objectContaining({
-                            blockNumber: 0,
+                            blockNumber: 1,
                             log: makePrivateLog(tags[1]),
                             isFromPublic: false
                         })
@@ -524,20 +826,20 @@ import { TxEffect, TxHash } from '@aztec/stdlib/tx';
                 ]);
             });
             it('is possible to batch request all logs (private and public) via tags', async ()=>{
-                // Tag(0, 0, 0) is shared with the first private log and the first public log.
+                // Tag(1, 0, 0) is shared with the first private log and the first public log.
                 const tags = [
-                    makeTag(0, 0, 0)
+                    makeTag(1, 0, 0)
                 ];
                 const logsByTags = await store.getLogsByTags(tags);
                 expect(logsByTags).toEqual([
                     [
                         expect.objectContaining({
-                            blockNumber: 0,
+                            blockNumber: 1,
                             log: makePrivateLog(tags[0]),
                             isFromPublic: false
                         }),
                         expect.objectContaining({
-                            blockNumber: 0,
+                            blockNumber: 1,
                             log: makePublicLog(tags[0]),
                             isFromPublic: true
                         })

package/dest/archiver/data_retrieval.d.ts

@@ -1,14 +1,29 @@
 import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
-import type { ViemPublicClient } from '@aztec/ethereum';
+import type { ViemClient, ViemPublicClient } from '@aztec/ethereum';
 import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger } from '@aztec/foundation/log';
 import { type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
-import { InboxLeaf } from '@aztec/stdlib/messaging';
+import { Body } from '@aztec/stdlib/block';
 import { Proof } from '@aztec/stdlib/proofs';
-import { type GetContractEventsReturnType, type GetContractReturnType, type Hex } from 'viem';
+import { ProposedBlockHeader, StateReference } from '@aztec/stdlib/tx';
+import { type GetContractReturnType, type Hex } from 'viem';
 import type { DataRetrieval } from './structs/data_retrieval.js';
-import type { PublishedL2Block } from './structs/published.js';
+import type { InboxMessage } from './structs/inbox_message.js';
+import type { L1PublishedData, PublishedL2Block } from './structs/published.js';
+export type RetrievedL2Block = {
+    l2BlockNumber: bigint;
+    archiveRoot: Fr;
+    stateReference: StateReference;
+    header: ProposedBlockHeader;
+    body: Body;
+    l1: L1PublishedData;
+    chainId: Fr;
+    version: Fr;
+    signatures: Signature[];
+};
+export declare function retrievedBlockToPublishedL2Block(retrievedBlock: RetrievedL2Block): PublishedL2Block;
 /**
  * Fetches new L2 blocks.
  * @param publicClient - The viem public client to use for transaction retrieval.
@@ -18,16 +33,10 @@ import type { PublishedL2Block } from './structs/published.js';
  * @param expectedNextL2BlockNum - The next L2 block number that we expect to find.
  * @returns An array of block; as well as the next eth block to search from.
  */
-export declare function retrieveBlocksFromRollup(rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>, publicClient: ViemPublicClient, blobSinkClient: BlobSinkClientInterface, searchStartBlock: bigint, searchEndBlock: bigint, logger?: Logger): Promise<PublishedL2Block[]>;
-/**
- * Processes newly received L2BlockProposed logs.
- * @param rollup - The rollup contract
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param logs - L2BlockProposed logs.
- * @returns - An array blocks.
- */
-export declare function processL2BlockProposedLogs(rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>, publicClient: ViemPublicClient, blobSinkClient: BlobSinkClientInterface, logs: GetContractEventsReturnType<typeof RollupAbi, 'L2BlockProposed'>, logger: Logger): Promise<PublishedL2Block[]>;
+export declare function retrieveBlocksFromRollup(rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>, publicClient: ViemPublicClient, blobSinkClient: BlobSinkClientInterface, searchStartBlock: bigint, searchEndBlock: bigint, logger?: Logger): Promise<RetrievedL2Block[]>;
 export declare function getL1BlockTime(publicClient: ViemPublicClient, blockNumber: bigint): Promise<bigint>;
+/** Given an L1 to L2 message, retrieves its corresponding event from the Inbox. */
+export declare function retrieveL1ToL2Message(inbox: GetContractReturnType<typeof InboxAbi, ViemClient>, leaf: Fr, fromBlock: bigint): Promise<InboxMessage | undefined>;
 /**
  * Fetch L1 to L2 messages.
  * @param publicClient - The viem public client to use for transaction retrieval.
@@ -37,7 +46,7 @@ export declare function getL1BlockTime(publicClient: ViemPublicClient, blockNumb
  * @param searchEndBlock - The highest block number that we should search up to.
  * @returns An array of InboxLeaf and next eth block to search from.
  */
-export declare function retrieveL1ToL2Messages(inbox: GetContractReturnType<typeof InboxAbi, ViemPublicClient>, searchStartBlock: bigint, searchEndBlock: bigint): Promise<DataRetrieval<InboxLeaf>>;
+export declare function retrieveL1ToL2Messages(inbox: GetContractReturnType<typeof InboxAbi, ViemClient>, searchStartBlock: bigint, searchEndBlock: bigint): Promise<InboxMessage[]>;
 /** Retrieves L2ProofVerified events from the rollup contract. */
 export declare function retrieveL2ProofVerifiedEvents(publicClient: ViemPublicClient, rollupAddress: EthAddress, searchStartBlock: bigint, searchEndBlock?: bigint): Promise<{
     l1BlockNumber: bigint;

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

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