@aztec/archiver 3.0.0-nightly.20251209 → 3.0.0-nightly.20251211

package/src/archiver/archiver_store_test_suite.ts

@@ -4,11 +4,11 @@ import {
   PRIVATE_LOG_SIZE_IN_FIELDS,
 } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
-import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
 import { times, timesParallel } from '@aztec/foundation/collection';
-import { randomInt } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { randomInt } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
 import { sleep } from '@aztec/foundation/sleep';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -446,7 +446,7 @@ export function describeArchiverDataStore(
     });
 
     describe('L1 to L2 Messages', () => {
-      const initialL2BlockNumber = 13;
+      const initialCheckpointNumber = CheckpointNumber(13);
 
       const checkMessages = async (msgs: InboxMessage[]) => {
         expect(await store.getLastL1ToL2Message()).toEqual(msgs.at(-1));
@@ -454,46 +454,50 @@ export function describeArchiverDataStore(
         expect(await store.getTotalL1ToL2MessageCount()).toEqual(BigInt(msgs.length));
       };
 
-      const makeInboxMessagesWithFullBlocks = (blockCount: number, opts: { initialL2BlockNumber?: number } = {}) =>
+      const makeInboxMessagesWithFullBlocks = (
+        blockCount: number,
+        opts: { initialCheckpointNumber?: CheckpointNumber } = {},
+      ) =>
         makeInboxMessages(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * blockCount, {
           overrideFn: (msg, i) => {
-            const l2BlockNumber = BlockNumber(
-              (opts.initialL2BlockNumber ?? initialL2BlockNumber) + Math.floor(i / NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
+            const checkpointNumber = CheckpointNumber(
+              (opts.initialCheckpointNumber ?? initialCheckpointNumber) +
+                Math.floor(i / NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
             );
             const index =
-              InboxLeaf.smallestIndexFromL2Block(l2BlockNumber) + BigInt(i % NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-            return { ...msg, l2BlockNumber, index };
+              InboxLeaf.smallestIndexForCheckpoint(checkpointNumber) + BigInt(i % NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+            return { ...msg, checkpointNumber, index };
           },
         });
 
       it('stores first message ever', async () => {
-        const msg = makeInboxMessage(Buffer16.ZERO, { index: 0n, l2BlockNumber: BlockNumber(1) });
+        const msg = makeInboxMessage(Buffer16.ZERO, { index: 0n, checkpointNumber: CheckpointNumber(1) });
         await store.addL1ToL2Messages([msg]);
 
         await checkMessages([msg]);
-        expect(await store.getL1ToL2Messages(BlockNumber(1))).toEqual([msg.leaf]);
+        expect(await store.getL1ToL2Messages(CheckpointNumber(1))).toEqual([msg.leaf]);
       });
 
       it('stores single message', async () => {
-        const msg = makeInboxMessage(Buffer16.ZERO, { l2BlockNumber: BlockNumber(2) });
+        const msg = makeInboxMessage(Buffer16.ZERO, { checkpointNumber: CheckpointNumber(2) });
         await store.addL1ToL2Messages([msg]);
 
         await checkMessages([msg]);
-        expect(await store.getL1ToL2Messages(BlockNumber(2))).toEqual([msg.leaf]);
+        expect(await store.getL1ToL2Messages(CheckpointNumber(2))).toEqual([msg.leaf]);
       });
 
       it('stores and returns messages across different blocks', async () => {
-        const msgs = makeInboxMessages(5, { initialL2BlockNumber });
+        const msgs = makeInboxMessages(5, { initialCheckpointNumber });
         await store.addL1ToL2Messages(msgs);
 
         await checkMessages(msgs);
-        expect(await store.getL1ToL2Messages(BlockNumber(initialL2BlockNumber + 2))).toEqual(
+        expect(await store.getL1ToL2Messages(CheckpointNumber(initialCheckpointNumber + 2))).toEqual(
           [msgs[2]].map(m => m.leaf),
         );
       });
 
       it('stores the same messages again', async () => {
-        const msgs = makeInboxMessages(5, { initialL2BlockNumber });
+        const msgs = makeInboxMessages(5, { initialCheckpointNumber });
         await store.addL1ToL2Messages(msgs);
         await store.addL1ToL2Messages(msgs.slice(2));
 
@@ -501,26 +505,29 @@ export function describeArchiverDataStore(
       });
 
       it('stores and returns messages across different blocks with gaps', async () => {
-        const msgs1 = makeInboxMessages(3, { initialL2BlockNumber: 1 });
-        const msgs2 = makeInboxMessages(3, { initialL2BlockNumber: 20, initialHash: msgs1.at(-1)!.rollingHash });
+        const msgs1 = makeInboxMessages(3, { initialCheckpointNumber: CheckpointNumber(1) });
+        const msgs2 = makeInboxMessages(3, {
+          initialCheckpointNumber: CheckpointNumber(20),
+          initialHash: msgs1.at(-1)!.rollingHash,
+        });
 
         await store.addL1ToL2Messages(msgs1);
         await store.addL1ToL2Messages(msgs2);
 
         await checkMessages([...msgs1, ...msgs2]);
 
-        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([]);
+        expect(await store.getL1ToL2Messages(CheckpointNumber(1))).toEqual([msgs1[0].leaf]);
+        expect(await store.getL1ToL2Messages(CheckpointNumber(4))).toEqual([]);
+        expect(await store.getL1ToL2Messages(CheckpointNumber(20))).toEqual([msgs2[0].leaf]);
+        expect(await store.getL1ToL2Messages(CheckpointNumber(24))).toEqual([]);
       });
 
       it('stores and returns messages with block numbers larger than a byte', async () => {
-        const msgs = makeInboxMessages(5, { initialL2BlockNumber: 1000 });
+        const msgs = makeInboxMessages(5, { initialCheckpointNumber: CheckpointNumber(1000) });
         await store.addL1ToL2Messages(msgs);
 
         await checkMessages(msgs);
-        expect(await store.getL1ToL2Messages(BlockNumber(1002))).toEqual([msgs[2]].map(m => m.leaf));
+        expect(await store.getL1ToL2Messages(CheckpointNumber(1002))).toEqual([msgs[2]].map(m => m.leaf));
       });
 
       it('stores and returns multiple messages per block', async () => {
@@ -528,7 +535,7 @@ export function describeArchiverDataStore(
         await store.addL1ToL2Messages(msgs);
 
         await checkMessages(msgs);
-        const blockMessages = await store.getL1ToL2Messages(BlockNumber(initialL2BlockNumber + 1));
+        const blockMessages = await store.getL1ToL2Messages(CheckpointNumber(initialCheckpointNumber + 1));
         expect(blockMessages).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
         expect(blockMessages).toEqual(
           msgs.slice(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * 2).map(m => m.leaf),
@@ -536,21 +543,21 @@ export function describeArchiverDataStore(
       });
 
       it('stores messages in multiple operations', async () => {
-        const msgs = makeInboxMessages(20, { initialL2BlockNumber });
+        const msgs = makeInboxMessages(20, { initialCheckpointNumber });
         await store.addL1ToL2Messages(msgs.slice(0, 10));
         await store.addL1ToL2Messages(msgs.slice(10, 20));
 
-        expect(await store.getL1ToL2Messages(BlockNumber(initialL2BlockNumber + 2))).toEqual(
+        expect(await store.getL1ToL2Messages(CheckpointNumber(initialCheckpointNumber + 2))).toEqual(
           [msgs[2]].map(m => m.leaf),
         );
-        expect(await store.getL1ToL2Messages(BlockNumber(initialL2BlockNumber + 12))).toEqual(
+        expect(await store.getL1ToL2Messages(CheckpointNumber(initialCheckpointNumber + 12))).toEqual(
           [msgs[12]].map(m => m.leaf),
         );
         await checkMessages(msgs);
       });
 
       it('iterates over messages from start index', async () => {
-        const msgs = makeInboxMessages(10, { initialL2BlockNumber });
+        const msgs = makeInboxMessages(10, { initialCheckpointNumber });
         await store.addL1ToL2Messages(msgs);
 
         const iterated = await toArray(store.iterateL1ToL2Messages({ start: msgs[3].index }));
@@ -558,8 +565,9 @@ export function describeArchiverDataStore(
       });
 
       it('iterates over messages in reverse', async () => {
-        const msgs = makeInboxMessages(10, { initialL2BlockNumber });
+        const msgs = makeInboxMessages(10, { initialCheckpointNumber });
         await store.addL1ToL2Messages(msgs);
+        initialCheckpointNumber;
 
         const iterated = await toArray(store.iterateL1ToL2Messages({ reverse: true, end: msgs[3].index }));
         expect(iterated).toEqual(msgs.slice(0, 4).reverse());
@@ -571,8 +579,8 @@ 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 = BlockNumber(initialL2BlockNumber - 1);
+        const msgs = makeInboxMessages(4, { initialCheckpointNumber });
+        msgs[2].checkpointNumber = CheckpointNumber(initialCheckpointNumber - 1);
         await store.addL1ToL2Messages(msgs.slice(0, 2));
         await expect(store.addL1ToL2Messages(msgs.slice(2, 4))).rejects.toThrow(MessageStoreError);
       });
@@ -586,28 +594,28 @@ 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, BlockNumber(2)));
+        await store.addL1ToL2Messages(msgs.slice(0, CheckpointNumber(2)));
         await expect(store.addL1ToL2Messages(msgs.slice(2, 4))).rejects.toThrow(MessageStoreError);
       });
 
       it('throws if index is not in the correct range', async () => {
-        const msgs = makeInboxMessages(5, { initialL2BlockNumber });
+        const msgs = makeInboxMessages(5, { initialCheckpointNumber });
         msgs.at(-1)!.index += 100n;
         await expect(store.addL1ToL2Messages(msgs)).rejects.toThrow(MessageStoreError);
       });
 
       it('throws if first index in block has gaps', async () => {
-        const msgs = makeInboxMessages(4, { initialL2BlockNumber });
+        const msgs = makeInboxMessages(4, { initialCheckpointNumber });
         msgs[2].index++;
         await expect(store.addL1ToL2Messages(msgs)).rejects.toThrow(MessageStoreError);
       });
 
       it('throws if index does not follow previous one', async () => {
         const msgs = makeInboxMessages(2, {
-          initialL2BlockNumber,
+          initialCheckpointNumber,
           overrideFn: (msg, i) => ({
             ...msg,
-            l2BlockNumber: BlockNumber(2),
+            checkpointNumber: CheckpointNumber(2),
             index: BigInt(i + NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * 2),
           }),
         });
@@ -616,28 +624,28 @@ export function describeArchiverDataStore(
       });
 
       it('removes messages up to the given block number', async () => {
-        const msgs = makeInboxMessagesWithFullBlocks(4, { initialL2BlockNumber: 1 });
+        const msgs = makeInboxMessagesWithFullBlocks(4, { initialCheckpointNumber: CheckpointNumber(1) });
 
         await store.addL1ToL2Messages(msgs);
         await checkMessages(msgs);
 
-        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);
+        expect(await store.getL1ToL2Messages(CheckpointNumber(1))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        expect(await store.getL1ToL2Messages(CheckpointNumber(2))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        expect(await store.getL1ToL2Messages(CheckpointNumber(3))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        expect(await store.getL1ToL2Messages(CheckpointNumber(4))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
 
-        await store.rollbackL1ToL2MessagesToL2Block(BlockNumber(2));
+        await store.rollbackL1ToL2MessagesToCheckpoint(CheckpointNumber(2));
 
-        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);
+        expect(await store.getL1ToL2Messages(CheckpointNumber(1))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        expect(await store.getL1ToL2Messages(CheckpointNumber(2))).toHaveLength(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+        expect(await store.getL1ToL2Messages(CheckpointNumber(3))).toHaveLength(0);
+        expect(await store.getL1ToL2Messages(CheckpointNumber(4))).toHaveLength(0);
 
         await checkMessages(msgs.slice(0, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * 2));
       });
 
       it('removes messages starting with the given index', async () => {
-        const msgs = makeInboxMessagesWithFullBlocks(4, { initialL2BlockNumber: 1 });
+        const msgs = makeInboxMessagesWithFullBlocks(4, { initialCheckpointNumber: CheckpointNumber(1) });
         await store.addL1ToL2Messages(msgs);
 
         await store.removeL1ToL2Messages(msgs[13].index);

package/src/archiver/config.ts

@@ -1,11 +1,7 @@
 import { type BlobSinkConfig, blobSinkConfigMapping } from '@aztec/blob-sink/client';
-import {
-  type L1ContractsConfig,
-  type L1ReaderConfig,
-  l1ContractAddressesMapping,
-  l1ContractsConfigMappings,
-  l1ReaderConfigMappings,
-} from '@aztec/ethereum';
+import { type L1ContractsConfig, l1ContractsConfigMappings } from '@aztec/ethereum/config';
+import { l1ContractAddressesMapping } from '@aztec/ethereum/l1-contract-addresses';
+import { type L1ReaderConfig, l1ReaderConfigMappings } from '@aztec/ethereum/l1-reader';
 import {
   type ConfigMappingsType,
   booleanConfigHelper,
@@ -55,6 +51,11 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     description: 'Maximum allowed drift in seconds between the Ethereum client and current time.',
     ...numberConfigHelper(300),
   },
+  ethereumAllowNoDebugHosts: {
+    env: 'ETHEREUM_ALLOW_NO_DEBUG_HOSTS',
+    description: 'Whether to allow starting the archiver without debug/trace method support on Ethereum hosts',
+    ...booleanConfigHelper(true),
+  },
   ...chainConfigMappings,
   ...l1ReaderConfigMappings,
   viemPollingIntervalMS: {

package/src/archiver/instrumentation.ts

@@ -34,6 +34,8 @@ export class ArchiverInstrumentation {
   private syncDurationPerMessage: Histogram;
   private syncMessageCount: UpDownCounter;
 
+  private blockProposalTxTargetCount: UpDownCounter;
+
   private log = createLogger('archiver:instrumentation');
 
   private constructor(
@@ -114,6 +116,11 @@ export class ArchiverInstrumentation {
       valueType: ValueType.INT,
     });
 
+    this.blockProposalTxTargetCount = meter.createUpDownCounter(Metrics.ARCHIVER_BLOCK_PROPOSAL_TX_TARGET_COUNT, {
+      description: 'Number of block proposals by tx target',
+      valueType: ValueType.INT,
+    });
+
     this.dbMetrics = new LmdbMetrics(
       meter,
       {
@@ -184,4 +191,11 @@ export class ArchiverInstrumentation {
   public updateL1BlockHeight(blockNumber: bigint) {
     this.l1BlockHeight.record(Number(blockNumber));
   }
+
+  public recordBlockProposalTxTarget(target: string, usedTrace: boolean) {
+    this.blockProposalTxTargetCount.add(1, {
+      [Attributes.L1_BLOCK_PROPOSAL_TX_TARGET]: target.toLowerCase(),
+      [Attributes.L1_BLOCK_PROPOSAL_USED_TRACE]: usedTrace,
+    });
+  }
 }

package/src/archiver/kv_archiver_store/block_store.ts

@@ -1,6 +1,6 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader } from '@aztec/foundation/serialize';

package/src/archiver/kv_archiver_store/contract_class_store.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
 import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';

package/src/archiver/kv_archiver_store/contract_instance_store.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -1,6 +1,6 @@
-import type { L1BlockId } from '@aztec/ethereum';
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import type { Fr } from '@aztec/foundation/fields';
+import type { L1BlockId } from '@aztec/ethereum/l1-types';
+import type { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, CustomRange, StoreSize } from '@aztec/kv-store';
@@ -300,12 +300,12 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
   }
 
   /**
-   * Gets L1 to L2 message (to be) included in a given block.
-   * @param blockNumber - L2 block number to get messages for.
+   * Gets L1 to L2 message (to be) included in a given checkpoint.
+   * @param checkpointNumber - Checkpoint number to get messages for.
    * @returns The L1 to L2 messages/leaves of the messages subtree (throws if not found).
    */
-  getL1ToL2Messages(blockNumber: BlockNumber): Promise<Fr[]> {
-    return this.#messageStore.getL1ToL2Messages(blockNumber);
+  getL1ToL2Messages(checkpointNumber: CheckpointNumber): Promise<Fr[]> {
+    return this.#messageStore.getL1ToL2Messages(checkpointNumber);
   }
 
   /**
@@ -401,8 +401,8 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return this.db.estimateSize();
   }
 
-  public rollbackL1ToL2MessagesToL2Block(targetBlockNumber: BlockNumber): Promise<void> {
-    return this.#messageStore.rollbackL1ToL2MessagesToL2Block(targetBlockNumber);
+  public rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber: CheckpointNumber): Promise<void> {
+    return this.#messageStore.rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber);
   }
 
   public iterateL1ToL2Messages(range: CustomRange<bigint> = {}): AsyncIterableIterator<InboxMessage> {

package/src/archiver/kv_archiver_store/log_store.ts

@@ -1,6 +1,6 @@
 import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';

package/src/archiver/kv_archiver_store/message_store.ts

@@ -1,6 +1,7 @@
-import type { L1BlockId } from '@aztec/ethereum';
+import type { L1BlockId } from '@aztec/ethereum/l1-types';
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
@@ -113,20 +114,20 @@ export class MessageStore {
           );
         }
 
-        // Check index corresponds to the L2 block number.
-        const [expectedStart, expectedEnd] = InboxLeaf.indexRangeFromL2Block(message.l2BlockNumber);
+        // Check index corresponds to the checkpoint number.
+        const [expectedStart, expectedEnd] = InboxLeaf.indexRangeForCheckpoint(message.checkpointNumber);
         if (message.index < expectedStart || message.index >= expectedEnd) {
           throw new MessageStoreError(
             `Invalid index ${message.index} for incoming L1 to L2 message ${message.leaf.toString()} ` +
-              `at block ${message.l2BlockNumber} (expected value in range [${expectedStart}, ${expectedEnd}))`,
+              `at checkpoint ${message.checkpointNumber} (expected value in range [${expectedStart}, ${expectedEnd}))`,
             message,
           );
         }
 
-        // Check there are no gaps in the indices within the same block.
+        // Check there are no gaps in the indices within the same checkpoint.
         if (
           lastMessage &&
-          message.l2BlockNumber === lastMessage.l2BlockNumber &&
+          message.checkpointNumber === lastMessage.checkpointNumber &&
           message.index !== lastMessage.index + 1n
         ) {
           throw new MessageStoreError(
@@ -138,12 +139,12 @@ export class MessageStore {
 
         // Check the first message in a block has the correct index.
         if (
-          (!lastMessage || message.l2BlockNumber > lastMessage.l2BlockNumber) &&
-          message.index !== InboxLeaf.smallestIndexFromL2Block(message.l2BlockNumber)
+          (!lastMessage || message.checkpointNumber > lastMessage.checkpointNumber) &&
+          message.index !== expectedStart
         ) {
           throw new MessageStoreError(
-            `Message ${message.leaf.toString()} for L2 block ${message.l2BlockNumber} has wrong index ` +
-              `${message.index} (expected ${InboxLeaf.smallestIndexFromL2Block(message.l2BlockNumber)})`,
+            `Message ${message.leaf.toString()} for checkpoint ${message.checkpointNumber} has wrong index ` +
+              `${message.index} (expected ${expectedStart})`,
             message,
           );
         }
@@ -184,10 +185,10 @@ export class MessageStore {
     return msg ? deserializeInboxMessage(msg) : undefined;
   }
 
-  public async getL1ToL2Messages(blockNumber: number): Promise<Fr[]> {
+  public async getL1ToL2Messages(checkpointNumber: CheckpointNumber): Promise<Fr[]> {
     const messages: Fr[] = [];
 
-    const [startIndex, endIndex] = InboxLeaf.indexRangeFromL2Block(blockNumber);
+    const [startIndex, endIndex] = InboxLeaf.indexRangeForCheckpoint(checkpointNumber);
     let lastIndex = startIndex - 1n;
 
     for await (const msgBuffer of this.#l1ToL2Messages.valuesAsync({
@@ -195,8 +196,10 @@ export class MessageStore {
       end: this.indexToKey(endIndex),
     })) {
       const msg = deserializeInboxMessage(msgBuffer);
-      if (msg.l2BlockNumber !== blockNumber) {
-        throw new Error(`L1 to L2 message with index ${msg.index} has invalid block number ${msg.l2BlockNumber}`);
+      if (msg.checkpointNumber !== checkpointNumber) {
+        throw new Error(
+          `L1 to L2 message with index ${msg.index} has invalid checkpoint number ${msg.checkpointNumber}`,
+        );
       } else if (msg.index !== lastIndex + 1n) {
         throw new Error(`Expected L1 to L2 message with index ${lastIndex + 1n} but got ${msg.index}`);
       }
@@ -232,9 +235,9 @@ export class MessageStore {
     });
   }
 
-  public rollbackL1ToL2MessagesToL2Block(targetBlockNumber: number): Promise<void> {
-    this.#log.debug(`Deleting L1 to L2 messages up to target L2 block ${targetBlockNumber}`);
-    const startIndex = InboxLeaf.smallestIndexFromL2Block(targetBlockNumber + 1);
+  public rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber: CheckpointNumber): Promise<void> {
+    this.#log.debug(`Deleting L1 to L2 messages up to target checkpoint ${targetCheckpointNumber}`);
+    const startIndex = InboxLeaf.smallestIndexForCheckpoint(CheckpointNumber(targetCheckpointNumber + 1));
     return this.removeL1ToL2Messages(startIndex);
   }
 

package/src/archiver/l1/README.md

@@ -0,0 +1,98 @@
+# Archiver L1 Data Retrieval
+
+Modules and classes to handle data retrieval from L1 for the archiver.
+
+## Calldata Retriever
+
+The sequencer publisher bundles multiple operations into a single multicall3 transaction for gas
+efficiency. A typical transaction includes:
+
+1. Attestation invalidations (if needed): `invalidateBadAttestation`, `invalidateInsufficientAttestations`
+2. Block proposal: `propose` (exactly one per transaction to the rollup contract)
+3. Governance and slashing (if needed): votes, payload creation/execution
+
+The archiver needs to extract the `propose` calldata from these bundled transactions to reconstruct
+L2 blocks. This class needs to handle scenarios where the transaction was submitted via multicall3,
+as well as alternative ways for submitting the `propose` call that other clients might use.
+
+### Multicall3 Validation and Decoding
+
+First attempt to decode the transaction as a multicall3 `aggregate3` call with validation:
+
+- Check if transaction is to multicall3 address (`0xcA11bde05977b3631167028862bE2a173976CA11`)
+- Decode as `aggregate3(Call3[] calldata calls)`
+- Allow calls to known addresses and methods (rollup, governance, slashing contracts, etc.)
+- Find the single `propose` call to the rollup contract
+- Verify exactly one `propose` call exists
+- Extract and return the propose calldata
+
+This step handles the common case efficiently without requiring expensive trace or debug RPC calls.
+Any validation failure triggers fallback to the next step.
+
+### Direct Propose Call
+
+Second attempt to decode the transaction as a direct `propose` call to the rollup contract:
+
+- Check if transaction is to the rollup address
+- Decode as `propose` function call
+- Verify the function is indeed `propose`
+- Return the transaction input as the propose calldata
+
+This handles scenarios where clients submit transactions directly to the rollup contract without
+using multicall3 for bundling. Any validation failure triggers fallback to the next step.
+
+### Spire Proposer Call
+
+Given existing attempts to route the call via the Spire proposer, we also check if the tx is `to` the 
+proposer known address, and if so, we try decoding it as either a multicall3 or a direct call to the
+rollup contract.
+
+Similar as with the multicall3 check, we check that there are no other calls in the Spire proposer, so
+we are absolutely sure that the only call is the successful one to the rollup. Any extraneous call would
+imply an unexpected path to calling `propose` in the rollup contract, and since we cannot verify if the
+calldata arguments we extracted are the correct ones (see the section below), we cannot know for sure which
+one is the call that succeeded, so we don't know which calldata to process.
+
+Furthermore, since the Spire proposer is upgradeable, we check if the implementation has not changed in
+order to decode. As usual, any validation failure triggers fallback to the next step.
+
+### Verifying Multicall3 Arguments
+
+**This is NOT implemented for simplicity's sake**
+
+If the checks above don't hold, such as when there are multiple calls to `propose`, then we cannot
+reliably extract the `propose` calldata from the multicall3 arguments alone. We can try a best-effort
+where we try all `propose` calls we see and validate them against on-chain data. Note that we can use these
+same strategies if we were to obtain the calldata from another source.
+
+#### TempBlockLog Verification
+
+Read the stored `TempBlockLog` for the L2 block number from L1 and verify it matches our decoded header hash,
+since the `TempBlockLog` stores the hash of the proposed block header, the payload commitment, and the attestations.
+
+However, `TempBlockLog` is only stored temporarily and deleted after proven, so this method only works for recent
+blocks, not for historical data syncing.
+
+#### Archive Verification
+
+Verify that the archive root in the decoded propose is correct with regard to the block header. This requires
+hashing the block header we have retrieved, inserting it into the archive tree, and checking the resulting root
+against the one we got from L1.
+
+However, this requires that the archive keeps a reference to world-state, which is not the case in the current
+system.
+
+#### Emit Commitments in Rollup Contract
+
+Modify rollup contract to emit commitments to the block header in the `L2BlockProposed` event, allowing us to easily
+verify the calldata we obtained vs the emitted event.
+
+However, modifying the rollup contract is out of scope for this change. But we can implement this approach in `v2`.
+
+### Debug and Trace Transaction Fallback
+
+Last, we use L1 node's trace/debug RPC methods to definitively identify the one successful `propose` call within the tx.
+We can then extract the exact calldata that hit the `propose` function in the rollup contract.
+
+This approach requires access to a debug-enabled L1 node, which may be more resource-intensive, so we only
+use it as a fallback when the first step fails, which should be rare in practice.