@aztec/archiver 0.80.0 → 0.82.0

package/src/archiver/archiver_store_test_suite.ts

@@ -1,12 +1,12 @@
 import {
   INITIAL_L2_BLOCK_NUM,
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
-  MAX_NULLIFIERS_PER_TX,
   PRIVATE_LOG_SIZE_IN_FIELDS,
   PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
 } from '@aztec/constants';
 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 { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { L2Block, wrapInBlock } from '@aztec/stdlib/block';
@@ -27,7 +27,7 @@ import '@aztec/stdlib/testing/jest';
 import { TxEffect, TxHash } from '@aztec/stdlib/tx';
 
 import type { ArchiverDataStore, ArchiverL1SynchPoint } from './archiver_store.js';
-import type { L1Published } from './structs/published.js';
+import type { PublishedL2Block } from './structs/published.js';
 
 /**
  * @param testName - The name of the test suite.
@@ -39,8 +39,9 @@ export function describeArchiverDataStore(
 ) {
   describe(testName, () => {
     let store: ArchiverDataStore;
-    let blocks: L1Published<L2Block>[];
-    const blockTests: [number, number, () => L1Published<L2Block>[]][] = [
+    let blocks: PublishedL2Block[];
+
+    const blockTests: [number, number, () => PublishedL2Block[]][] = [
       [1, 1, () => blocks.slice(0, 1)],
       [10, 1, () => blocks.slice(9, 10)],
       [1, 10, () => blocks.slice(0, 10)],
@@ -48,18 +49,30 @@ export function describeArchiverDataStore(
       [5, 2, () => blocks.slice(4, 6)],
     ];
 
-    const makeL1Published = (block: L2Block, l1BlockNumber: number): L1Published<L2Block> => ({
-      data: block,
+    const makePublished = (block: L2Block, l1BlockNumber: number): PublishedL2Block => ({
+      block: block,
       l1: {
         blockNumber: BigInt(l1BlockNumber),
         blockHash: `0x${l1BlockNumber}`,
         timestamp: BigInt(l1BlockNumber * 1000),
       },
+      signatures: times(3, Signature.random),
     });
 
+    const expectBlocksEqual = (actual: PublishedL2Block[], expected: PublishedL2Block[]) => {
+      expect(actual.length).toEqual(expected.length);
+      for (let i = 0; i < expected.length; i++) {
+        const expectedBlock = expected[i];
+        const actualBlock = actual[i];
+        expect(actualBlock.l1).toEqual(expectedBlock.l1);
+        expect(actualBlock.block.equals(expectedBlock.block)).toBe(true);
+        expect(actualBlock.signatures.every((s, i) => s.equals(expectedBlock.signatures[i]))).toBe(true);
+      }
+    };
+
     beforeEach(async () => {
       store = await getStore();
-      blocks = await timesParallel(10, async i => makeL1Published(await L2Block.random(i + 1), i + 10));
+      blocks = await timesParallel(10, async i => makePublished(await L2Block.random(i + 1), i + 10));
     });
 
     describe('addBlocks', () => {
@@ -78,7 +91,7 @@ export function describeArchiverDataStore(
         await store.addBlocks(blocks);
         const blockNumber = await store.getSynchedL2BlockNumber();
 
-        expect(await store.getBlocks(blockNumber, 1)).toEqual([blocks[blocks.length - 1]]);
+        expectBlocksEqual(await store.getBlocks(blockNumber, 1), [blocks[blocks.length - 1]]);
 
         await store.unwindBlocks(blockNumber, 1);
 
@@ -87,13 +100,13 @@ export function describeArchiverDataStore(
       });
 
       it('can unwind multiple empty blocks', async () => {
-        const emptyBlocks = await timesParallel(10, async i => makeL1Published(await L2Block.random(i + 1, 0), i + 10));
+        const emptyBlocks = await timesParallel(10, async i => makePublished(await L2Block.random(i + 1, 0), i + 10));
         await store.addBlocks(emptyBlocks);
         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.data.number)).toEqual([1, 2, 3, 4, 5, 6, 7]);
+        expect((await store.getBlocks(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 () => {
@@ -108,7 +121,7 @@ export function describeArchiverDataStore(
       });
 
       it.each(blockTests)('retrieves previously stored blocks', async (start, limit, getExpectedBlocks) => {
-        await expect(store.getBlocks(start, limit)).resolves.toEqual(getExpectedBlocks());
+        expectBlocksEqual(await store.getBlocks(start, limit), getExpectedBlocks());
       });
 
       it('returns an empty array if no blocks are found', async () => {
@@ -131,7 +144,7 @@ export function describeArchiverDataStore(
 
       it("returns the most recently added block's number", async () => {
         await store.addBlocks(blocks);
-        await expect(store.getSynchedL2BlockNumber()).resolves.toEqual(blocks.at(-1)!.data.number);
+        await expect(store.getSynchedL2BlockNumber()).resolves.toEqual(blocks.at(-1)!.block.number);
       });
     });
 
@@ -165,14 +178,14 @@ export function describeArchiverDataStore(
 
     describe('addLogs', () => {
       it('adds private & public logs', async () => {
-        const block = blocks[0].data;
+        const block = blocks[0].block;
         await expect(store.addLogs([block])).resolves.toEqual(true);
       });
     });
 
     describe('deleteLogs', () => {
       it('deletes private & public logs', async () => {
-        const block = blocks[0].data;
+        const block = blocks[0].block;
         await store.addBlocks([blocks[0]]);
         await expect(store.addLogs([block])).resolves.toEqual(true);
 
@@ -193,7 +206,7 @@ export function describeArchiverDataStore(
 
     describe('getPrivateLogs', () => {
       it('gets added private logs', async () => {
-        const block = blocks[0].data;
+        const block = blocks[0].block;
         await store.addBlocks([blocks[0]]);
         await store.addLogs([block]);
 
@@ -204,16 +217,16 @@ export function describeArchiverDataStore(
 
     describe('getTxEffect', () => {
       beforeEach(async () => {
-        await store.addLogs(blocks.map(b => b.data));
+        await store.addLogs(blocks.map(b => b.block));
         await store.addBlocks(blocks);
       });
 
       it.each([
-        () => wrapInBlock(blocks[0].data.body.txEffects[0], blocks[0].data),
-        () => wrapInBlock(blocks[9].data.body.txEffects[3], blocks[9].data),
-        () => wrapInBlock(blocks[3].data.body.txEffects[1], blocks[3].data),
-        () => wrapInBlock(blocks[5].data.body.txEffects[2], blocks[5].data),
-        () => wrapInBlock(blocks[1].data.body.txEffects[0], blocks[1].data),
+        () => wrapInBlock(blocks[0].block.body.txEffects[0], blocks[0].block),
+        () => wrapInBlock(blocks[9].block.body.txEffects[3], blocks[9].block),
+        () => wrapInBlock(blocks[3].block.body.txEffects[1], blocks[3].block),
+        () => wrapInBlock(blocks[5].block.body.txEffects[2], blocks[5].block),
+        () => wrapInBlock(blocks[1].block.body.txEffects[0], blocks[1].block),
       ])('retrieves a previously stored transaction', async getExpectedTx => {
         const expectedTx = await getExpectedTx();
         const actualTx = await store.getTxEffect(expectedTx.data.txHash);
@@ -225,11 +238,11 @@ export function describeArchiverDataStore(
       });
 
       it.each([
-        () => wrapInBlock(blocks[0].data.body.txEffects[0], blocks[0].data),
-        () => wrapInBlock(blocks[9].data.body.txEffects[3], blocks[9].data),
-        () => wrapInBlock(blocks[3].data.body.txEffects[1], blocks[3].data),
-        () => wrapInBlock(blocks[5].data.body.txEffects[2], blocks[5].data),
-        () => wrapInBlock(blocks[1].data.body.txEffects[0], blocks[1].data),
+        () => wrapInBlock(blocks[0].block.body.txEffects[0], blocks[0].block),
+        () => wrapInBlock(blocks[9].block.body.txEffects[3], blocks[9].block),
+        () => wrapInBlock(blocks[3].block.body.txEffects[1], blocks[3].block),
+        () => wrapInBlock(blocks[5].block.body.txEffects[2], blocks[5].block),
+        () => wrapInBlock(blocks[1].block.body.txEffects[0], blocks[1].block),
       ])('tries to retrieves a previously stored transaction after deleted', async getExpectedTx => {
         await store.unwindBlocks(blocks.length, blocks.length);
 
@@ -292,16 +305,65 @@ export function describeArchiverDataStore(
       });
 
       it('returns previously stored contract instances', async () => {
-        await expect(store.getContractInstance(contractInstance.address)).resolves.toMatchObject(contractInstance);
+        await expect(store.getContractInstance(contractInstance.address, blockNum)).resolves.toMatchObject(
+          contractInstance,
+        );
       });
 
       it('returns undefined if contract instance is not found', async () => {
-        await expect(store.getContractInstance(await AztecAddress.random())).resolves.toBeUndefined();
+        await expect(store.getContractInstance(await AztecAddress.random(), blockNum)).resolves.toBeUndefined();
       });
 
       it('returns undefined if previously stored contract instances was deleted', async () => {
         await store.deleteContractInstances([contractInstance], blockNum);
-        await expect(store.getContractInstance(contractInstance.address)).resolves.toBeUndefined();
+        await expect(store.getContractInstance(contractInstance.address, blockNum)).resolves.toBeUndefined();
+      });
+    });
+
+    describe('contractInstanceUpdates', () => {
+      let contractInstance: ContractInstanceWithAddress;
+      let classId: Fr;
+      let nextClassId: Fr;
+      const blockOfChange = 10;
+
+      beforeEach(async () => {
+        classId = Fr.random();
+        nextClassId = Fr.random();
+        const randomInstance = await SerializableContractInstance.random({
+          currentContractClassId: classId,
+          originalContractClassId: classId,
+        });
+        contractInstance = { ...randomInstance, address: await AztecAddress.random() };
+        await store.addContractInstances([contractInstance], 1);
+        await store.addContractInstanceUpdates(
+          [
+            {
+              prevContractClassId: classId,
+              newContractClassId: nextClassId,
+              blockOfChange,
+              address: contractInstance.address,
+            },
+          ],
+          blockOfChange - 1,
+        );
+      });
+
+      it('gets the correct current class id for a contract not updated yet', async () => {
+        const fetchedInstance = await store.getContractInstance(contractInstance.address, blockOfChange - 1);
+        expect(fetchedInstance?.originalContractClassId).toEqual(classId);
+        expect(fetchedInstance?.currentContractClassId).toEqual(classId);
+      });
+
+      it('gets the correct current class id for a contract that has just been updated', async () => {
+        const fetchedInstance = await store.getContractInstance(contractInstance.address, blockOfChange);
+        expect(fetchedInstance?.originalContractClassId).toEqual(classId);
+        expect(fetchedInstance?.currentContractClassId).toEqual(nextClassId);
+      });
+
+      it('gets the correct current class id for a contract that was updated in the past', async () => {
+        const fetchedInstance = await store.getContractInstance(contractInstance.address, blockOfChange + 1);
+        expect(fetchedInstance?.originalContractClassId).toEqual(classId);
+        expect(fetchedInstance?.currentContractClassId).toEqual(nextClassId);
       });
     });
 
@@ -378,31 +440,19 @@ export function describeArchiverDataStore(
       const numPrivateLogsPerTx = 3;
       const numPublicLogsPerTx = 2;
 
-      let blocks: L1Published<L2Block>[];
+      let blocks: PublishedL2Block[];
 
       const makeTag = (blockNumber: number, txIndex: number, logIndex: number, isPublic = false) =>
         new Fr((blockNumber * 100 + txIndex * 10 + logIndex) * (isPublic ? 123 : 1));
 
-      // See parseLogFromPublic
-      // Search the codebase for "disgusting encoding" to see other hardcoded instances of this encoding, that you might need to change if you ever find yourself here.
-      const makeLengthsField = (publicValuesLen: number, privateValuesLen: number) => {
-        const buf = Buffer.alloc(32);
-        buf.writeUint16BE(publicValuesLen, 27);
-        buf.writeUint16BE(privateValuesLen, 30);
-        return Fr.fromBuffer(buf);
-      };
-
       const makePrivateLog = (tag: Fr) =>
         PrivateLog.fromFields([tag, ...times(PRIVATE_LOG_SIZE_IN_FIELDS - 1, i => new Fr(tag.toNumber() + i))]);
 
-      // The tag lives in field 1, not 0, of a public log
-      // See extractTaggedLogsFromPublic and noir-projects/aztec-nr/aztec/src/macros/notes/mod.nr -> emit_log
       const makePublicLog = (tag: Fr) =>
         PublicLog.fromFields([
           AztecAddress.fromNumber(1).toField(), // log address
-          makeLengthsField(2, PUBLIC_LOG_DATA_SIZE_IN_FIELDS - 3), // field 0
-          tag, // field 1
-          ...times(PUBLIC_LOG_DATA_SIZE_IN_FIELDS - 1, i => new Fr(tag.toNumber() + i)), // fields 2 to end
+          tag, // field 0
+          ...times(PUBLIC_LOG_DATA_SIZE_IN_FIELDS - 1, i => new Fr(tag.toNumber() + i)), // fields 1 to end
         ]);
 
       const mockPrivateLogs = (blockNumber: number, txIndex: number) => {
@@ -419,7 +469,7 @@ export function describeArchiverDataStore(
         });
       };
 
-      const mockBlockWithLogs = async (blockNumber: number): Promise<L1Published<L2Block>> => {
+      const mockBlockWithLogs = async (blockNumber: number): Promise<PublishedL2Block> => {
         const block = await L2Block.random(blockNumber);
         block.header.globalVariables.blockNumber = new Fr(blockNumber);
 
@@ -431,7 +481,8 @@ export function describeArchiverDataStore(
         });
 
         return {
-          data: block,
+          block: block,
+          signatures: times(3, Signature.random),
           l1: { blockNumber: BigInt(blockNumber), blockHash: `0x${blockNumber}`, timestamp: BigInt(blockNumber) },
         };
       };
@@ -440,7 +491,7 @@ export function describeArchiverDataStore(
         blocks = await timesParallel(numBlocks, (index: number) => mockBlockWithLogs(index));
 
         await store.addBlocks(blocks);
-        await store.addLogs(blocks.map(b => b.data));
+        await store.addLogs(blocks.map(b => b.block));
       });
 
       it('is possible to batch request private logs via tags', async () => {
@@ -452,14 +503,14 @@ export function describeArchiverDataStore(
           [
             expect.objectContaining({
               blockNumber: 1,
-              logData: makePrivateLog(tags[0]).toBuffer(),
+              log: makePrivateLog(tags[0]),
               isFromPublic: false,
             }),
           ],
           [
             expect.objectContaining({
               blockNumber: 0,
-              logData: makePrivateLog(tags[1]).toBuffer(),
+              log: makePrivateLog(tags[1]),
               isFromPublic: false,
             }),
           ],
@@ -476,12 +527,12 @@ export function describeArchiverDataStore(
           [
             expect.objectContaining({
               blockNumber: 0,
-              logData: makePrivateLog(tags[0]).toBuffer(),
+              log: makePrivateLog(tags[0]),
               isFromPublic: false,
             }),
             expect.objectContaining({
               blockNumber: 0,
-              logData: makePublicLog(tags[0]).toBuffer(),
+              log: makePublicLog(tags[0]),
               isFromPublic: true,
             }),
           ],
@@ -494,11 +545,11 @@ export function describeArchiverDataStore(
         // Create a block containing logs that have the same tag as the blocks before.
         const newBlockNumber = numBlocks;
         const newBlock = await mockBlockWithLogs(newBlockNumber);
-        const newLog = newBlock.data.body.txEffects[1].privateLogs[1];
+        const newLog = newBlock.block.body.txEffects[1].privateLogs[1];
         newLog.fields[0] = tags[0];
-        newBlock.data.body.txEffects[1].privateLogs[1] = newLog;
+        newBlock.block.body.txEffects[1].privateLogs[1] = newLog;
         await store.addBlocks([newBlock]);
-        await store.addLogs([newBlock.data]);
+        await store.addLogs([newBlock.block]);
 
         const logsByTags = await store.getLogsByTags(tags);
 
@@ -506,12 +557,12 @@ export function describeArchiverDataStore(
           [
             expect.objectContaining({
               blockNumber: 1,
-              logData: makePrivateLog(tags[0]).toBuffer(),
+              log: makePrivateLog(tags[0]),
               isFromPublic: false,
             }),
             expect.objectContaining({
               blockNumber: newBlockNumber,
-              logData: newLog.toBuffer(),
+              log: newLog,
               isFromPublic: false,
             }),
           ],
@@ -530,42 +581,12 @@ export function describeArchiverDataStore(
           [
             expect.objectContaining({
               blockNumber: 1,
-              logData: makePrivateLog(tags[1]).toBuffer(),
+              log: makePrivateLog(tags[1]),
               isFromPublic: false,
             }),
           ],
         ]);
       });
-
-      it('is not possible to add public logs by tag if they are invalid', async () => {
-        const tag = makeTag(99, 88, 77);
-        const invalidLogs = [
-          PublicLog.fromFields([
-            AztecAddress.fromNumber(1).toField(),
-            makeLengthsField(2, 3), // This field claims we have 5 items, but we actually have more
-            tag,
-            ...times(PUBLIC_LOG_DATA_SIZE_IN_FIELDS - 1, i => new Fr(tag.toNumber() + i)),
-          ]),
-          PublicLog.fromFields([
-            AztecAddress.fromNumber(1).toField(),
-            makeLengthsField(2, PUBLIC_LOG_DATA_SIZE_IN_FIELDS), // This field claims we have more than the max items
-            tag,
-            ...times(PUBLIC_LOG_DATA_SIZE_IN_FIELDS - 1, i => new Fr(tag.toNumber() + i)),
-          ]),
-        ];
-
-        // Create a block containing these invalid logs
-        const newBlockNumber = numBlocks;
-        const newBlock = await mockBlockWithLogs(newBlockNumber);
-        newBlock.data.body.txEffects[0].publicLogs = invalidLogs;
-        await store.addBlocks([newBlock]);
-        await store.addLogs([newBlock.data]);
-
-        const logsByTags = await store.getLogsByTags([tag]);
-
-        // Neither of the logs should have been added:
-        expect(logsByTags).toEqual([[]]);
-      });
     });
 
     describe('getPublicLogs', () => {
@@ -573,27 +594,28 @@ export function describeArchiverDataStore(
       const numPublicFunctionCalls = 3;
       const numPublicLogs = 2;
       const numBlocks = 10;
-      let blocks: L1Published<L2Block>[];
+      let blocks: PublishedL2Block[];
 
       beforeEach(async () => {
         blocks = await timesParallel(numBlocks, async (index: number) => ({
-          data: await L2Block.random(index + 1, txsPerBlock, numPublicFunctionCalls, numPublicLogs),
+          block: await L2Block.random(index + 1, txsPerBlock, numPublicFunctionCalls, numPublicLogs),
           l1: { blockNumber: BigInt(index), blockHash: `0x${index}`, timestamp: BigInt(index) },
+          signatures: times(3, Signature.random),
         }));
 
         await store.addBlocks(blocks);
-        await store.addLogs(blocks.map(b => b.data));
+        await store.addLogs(blocks.map(b => b.block));
       });
 
       it('no logs returned if deleted ("txHash" filter param is respected variant)', async () => {
         // get random tx
         const targetBlockIndex = randomInt(numBlocks);
         const targetTxIndex = randomInt(txsPerBlock);
-        const targetTxHash = blocks[targetBlockIndex].data.body.txEffects[targetTxIndex].txHash;
+        const targetTxHash = blocks[targetBlockIndex].block.body.txEffects[targetTxIndex].txHash;
 
         await Promise.all([
           store.unwindBlocks(blocks.length, blocks.length),
-          store.deleteLogs(blocks.map(b => b.data)),
+          store.deleteLogs(blocks.map(b => b.block)),
         ]);
 
         const response = await store.getPublicLogs({ txHash: targetTxHash });
@@ -607,7 +629,7 @@ export function describeArchiverDataStore(
         // get random tx
         const targetBlockIndex = randomInt(numBlocks);
         const targetTxIndex = randomInt(txsPerBlock);
-        const targetTxHash = blocks[targetBlockIndex].data.body.txEffects[targetTxIndex].txHash;
+        const targetTxHash = blocks[targetBlockIndex].block.body.txEffects[targetTxIndex].txHash;
 
         const response = await store.getPublicLogs({ txHash: targetTxHash });
         const logs = response.logs;
@@ -650,7 +672,7 @@ export function describeArchiverDataStore(
         const targetTxIndex = randomInt(txsPerBlock);
         const targetLogIndex = randomInt(numPublicLogs * numPublicFunctionCalls);
         const targetContractAddress =
-          blocks[targetBlockIndex].data.body.txEffects[targetTxIndex].publicLogs[targetLogIndex].contractAddress;
+          blocks[targetBlockIndex].block.body.txEffects[targetTxIndex].publicLogs[targetLogIndex].contractAddress;
 
         const response = await store.getPublicLogs({ contractAddress: targetContractAddress });
 
@@ -753,58 +775,5 @@ export function describeArchiverDataStore(
         }
       });
     });
-
-    describe('findNullifiersIndexesWithBlock', () => {
-      let blocks: L2Block[];
-      const numBlocks = 10;
-      const nullifiersPerBlock = new Map<number, Fr[]>();
-
-      beforeEach(async () => {
-        blocks = await timesParallel(numBlocks, (index: number) => L2Block.random(index + 1, 1));
-
-        blocks.forEach((block, blockIndex) => {
-          nullifiersPerBlock.set(
-            blockIndex,
-            block.body.txEffects.flatMap(txEffect => txEffect.nullifiers),
-          );
-        });
-      });
-
-      it('returns wrapped nullifiers with blocks if they exist', async () => {
-        await store.addNullifiers(blocks);
-        const nullifiersToRetrieve = [...nullifiersPerBlock.get(0)!, ...nullifiersPerBlock.get(5)!, Fr.random()];
-        const blockScopedNullifiers = await store.findNullifiersIndexesWithBlock(10, nullifiersToRetrieve);
-
-        expect(blockScopedNullifiers).toHaveLength(nullifiersToRetrieve.length);
-        const [undefinedNullifier] = blockScopedNullifiers.slice(-1);
-        const realNullifiers = blockScopedNullifiers.slice(0, -1);
-        realNullifiers.forEach((blockScopedNullifier, index) => {
-          expect(blockScopedNullifier).not.toBeUndefined();
-          const { data, l2BlockNumber } = blockScopedNullifier!;
-          expect(data).toEqual(expect.any(BigInt));
-          expect(l2BlockNumber).toEqual(index < MAX_NULLIFIERS_PER_TX ? 1 : 6);
-        });
-        expect(undefinedNullifier).toBeUndefined();
-      });
-
-      it('returns wrapped nullifiers filtering by blockNumber', async () => {
-        await store.addNullifiers(blocks);
-        const nullifiersToRetrieve = [...nullifiersPerBlock.get(0)!, ...nullifiersPerBlock.get(5)!];
-        const blockScopedNullifiers = await store.findNullifiersIndexesWithBlock(5, nullifiersToRetrieve);
-
-        expect(blockScopedNullifiers).toHaveLength(nullifiersToRetrieve.length);
-        const undefinedNullifiers = blockScopedNullifiers.slice(-MAX_NULLIFIERS_PER_TX);
-        const realNullifiers = blockScopedNullifiers.slice(0, -MAX_NULLIFIERS_PER_TX);
-        realNullifiers.forEach(blockScopedNullifier => {
-          expect(blockScopedNullifier).not.toBeUndefined();
-          const { data, l2BlockNumber } = blockScopedNullifier!;
-          expect(data).toEqual(expect.any(BigInt));
-          expect(l2BlockNumber).toEqual(1);
-        });
-        undefinedNullifiers.forEach(undefinedNullifier => {
-          expect(undefinedNullifier).toBeUndefined();
-        });
-      });
-    });
   });
 }

package/src/archiver/config.ts

@@ -40,6 +40,9 @@ export type ArchiverConfig = {
 
   /** The max number of logs that can be obtained in 1 "getPublicLogs" call. */
   maxLogs?: number;
+
+  /** The maximum possible size of the archiver DB in KB. Overwrites the general dataStoreMapSizeKB. */
+  archiverStoreMapSizeKb?: number;
 } & L1ReaderConfig &
   L1ContractsConfig &
   BlobSinkConfig &
@@ -72,6 +75,11 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     description: 'The max number of logs that can be obtained in 1 "getPublicLogs" call.',
     ...numberConfigHelper(1_000),
   },
+  archiverStoreMapSizeKb: {
+    env: 'ARCHIVER_STORE_MAP_SIZE_KB',
+    parseEnv: (val: string | undefined) => (val ? +val : undefined),
+    description: 'The maximum possible size of the archiver DB in KB. Overwrites the general dataStoreMapSizeKB.',
+  },
   ...chainConfigMappings,
   ...l1ReaderConfigMappings,
   viemPollingIntervalMS: {

package/src/archiver/data_retrieval.ts

@@ -3,7 +3,7 @@ import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
 import type { EpochProofPublicInputArgs, ViemPublicClient } from '@aztec/ethereum';
 import { asyncPool } from '@aztec/foundation/async-pool';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { ViemSignature } from '@aztec/foundation/eth-signature';
+import { Signature, type ViemSignature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { numToUInt32BE } from '@aztec/foundation/serialize';
@@ -25,7 +25,7 @@ import {
 
 import { NoBlobBodiesFoundError } from './errors.js';
 import type { DataRetrieval } from './structs/data_retrieval.js';
-import type { L1Published, L1PublishedData } from './structs/published.js';
+import type { L1PublishedData, PublishedL2Block } from './structs/published.js';
 
 /**
  * Fetches new L2 blocks.
@@ -43,8 +43,8 @@ export async function retrieveBlocksFromRollup(
   searchStartBlock: bigint,
   searchEndBlock: bigint,
   logger: Logger = createLogger('archiver'),
-): Promise<L1Published<L2Block>[]> {
-  const retrievedBlocks: L1Published<L2Block>[] = [];
+): Promise<PublishedL2Block[]> {
+  const retrievedBlocks: PublishedL2Block[] = [];
   do {
     if (searchStartBlock > searchEndBlock) {
       break;
@@ -96,8 +96,8 @@ export async function processL2BlockProposedLogs(
   blobSinkClient: BlobSinkClientInterface,
   logs: GetContractEventsReturnType<typeof RollupAbi, 'L2BlockProposed'>,
   logger: Logger,
-): Promise<L1Published<L2Block>[]> {
-  const retrievedBlocks: L1Published<L2Block>[] = [];
+): Promise<PublishedL2Block[]> {
+  const retrievedBlocks: PublishedL2Block[] = [];
   await asyncPool(10, logs, async log => {
     const l2BlockNumber = log.args.blockNumber!;
     const archive = log.args.archive!;
@@ -122,7 +122,7 @@ export async function processL2BlockProposedLogs(
         timestamp: await getL1BlockTime(publicClient, log.blockNumber),
       };
 
-      retrievedBlocks.push({ data: block, l1 });
+      retrievedBlocks.push({ ...block, l1 });
     } else {
       logger.warn(`Ignoring L2 block ${l2BlockNumber} due to archive root mismatch`, {
         actual: archive,
@@ -203,11 +203,11 @@ async function getBlockFromRollupTx(
   publicClient: ViemPublicClient,
   blobSinkClient: BlobSinkClientInterface,
   txHash: `0x${string}`,
-  blobHashes: Buffer[], // WORKTODO(md): buffer32?
+  blobHashes: Buffer[], // TODO(md): buffer32?
   l2BlockNum: bigint,
   rollupAddress: Hex,
   logger: Logger,
-): Promise<L2Block> {
+): Promise<Omit<PublishedL2Block, 'l1'>> {
   const { input: forwarderData, blockHash } = await publicClient.getTransaction({ hash: txHash });
 
   const rollupData = extractRollupProposeCalldata(forwarderData, rollupAddress);
@@ -220,7 +220,7 @@ async function getBlockFromRollupTx(
     throw new Error(`Unexpected rollup method called ${rollupFunctionName}`);
   }
 
-  const [decodedArgs, ,] = rollupArgs! as readonly [
+  const [decodedArgs, signatures] = rollupArgs! as readonly [
     {
       header: Hex;
       archive: Hex;
@@ -268,7 +268,8 @@ async function getBlockFromRollupTx(
     ]),
   );
 
-  return new L2Block(archive, header, blockBody);
+  const block = new L2Block(archive, header, blockBody);
+  return { block, signatures: signatures.map(Signature.fromViemSignature) };
 }
 
 /**

package/src/archiver/index.ts

@@ -1,7 +1,6 @@
 export * from './archiver.js';
 export * from './config.js';
-export { type L1Published, type L1PublishedData } from './structs/published.js';
-export { MemoryArchiverStore } from './memory_archiver_store/memory_archiver_store.js';
+export { type PublishedL2Block, type L1PublishedData } from './structs/published.js';
 export type { ArchiverDataStore } from './archiver_store.js';
 export { KVArchiverDataStore } from './kv_archiver_store/kv_archiver_store.js';
 export { ContractInstanceStore } from './kv_archiver_store/contract_instance_store.js';