@aztec/archiver 4.0.0-nightly.20250907 → 4.0.0-nightly.20260107

package/dest/archiver/kv_archiver_store/log_store.js

@@ -1,15 +1,21 @@
-import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
-import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, PrivateLog, PublicLog, TxScopedL2Log } from '@aztec/stdlib/logs';
+import { L2BlockHash } from '@aztec/stdlib/block';
+import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, PublicLog, TxScopedL2Log } from '@aztec/stdlib/logs';
 /**
  * A store for logs
  */ export class LogStore {
     db;
     blockStore;
-    #logsByTag;
-    #logTagsByBlock;
-    #privateLogsByBlock;
+    // `tag` --> private logs
+    #privateLogsByTag;
+    // `{contractAddress}_${tag}` --> public logs
+    #publicLogsByContractAndTag;
+    #privateLogKeysByBlock;
+    #publicLogKeysByBlock;
     #publicLogsByBlock;
     #contractClassLogsByBlock;
     #logsMaxPageSize;
@@ -18,68 +24,118 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
         this.db = db;
         this.blockStore = blockStore;
         this.#log = createLogger('archiver:log_store');
-        this.#logsByTag = db.openMap('archiver_tagged_logs_by_tag');
-        this.#logTagsByBlock = db.openMap('archiver_log_tags_by_block');
-        this.#privateLogsByBlock = db.openMap('archiver_private_logs_by_block');
+        this.#privateLogsByTag = db.openMap('archiver_private_tagged_logs_by_tag');
+        this.#publicLogsByContractAndTag = db.openMap('archiver_public_tagged_logs_by_tag');
+        this.#privateLogKeysByBlock = db.openMap('archiver_private_log_keys_by_block');
+        this.#publicLogKeysByBlock = db.openMap('archiver_public_log_keys_by_block');
         this.#publicLogsByBlock = db.openMap('archiver_public_logs_by_block');
         this.#contractClassLogsByBlock = db.openMap('archiver_contract_class_logs_by_block');
         this.#logsMaxPageSize = logsMaxPageSize;
     }
-    #extractTaggedLogs(block) {
-        const taggedLogs = new Map();
-        const dataStartIndexForBlock = block.header.state.partial.noteHashTree.nextAvailableLeafIndex - block.body.txEffects.length * MAX_NOTE_HASHES_PER_TX;
-        block.body.txEffects.forEach((txEffect, txIndex)=>{
+    /**
+   * Extracts tagged logs from a single block, grouping them into private and public maps.
+   *
+   * @param block - The L2 block to extract logs from.
+   * @returns An object containing the private and public tagged logs for the block.
+   */ #extractTaggedLogsFromBlock(block) {
+        // SiloedTag (as string) -> array of log buffers.
+        const privateTaggedLogs = new Map();
+        // "{contractAddress}_{tag}" (as string) -> array of log buffers.
+        const publicTaggedLogs = new Map();
+        block.body.txEffects.forEach((txEffect)=>{
             const txHash = txEffect.txHash;
-            const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
-            txEffect.privateLogs.forEach((log, logIndex)=>{
+            txEffect.privateLogs.forEach((log)=>{
+                // Private logs use SiloedTag (already siloed by kernel)
                 const tag = log.fields[0];
                 this.#log.debug(`Found private log with tag ${tag.toString()} in block ${block.number}`);
-                const currentLogs = taggedLogs.get(tag.toString()) ?? [];
-                currentLogs.push(new TxScopedL2Log(txHash, dataStartIndexForTx, logIndex, block.number, log).toBuffer());
-                taggedLogs.set(tag.toString(), currentLogs);
+                const currentLogs = privateTaggedLogs.get(tag.toString()) ?? [];
+                currentLogs.push(new TxScopedL2Log(txHash, block.number, block.timestamp, log.getEmittedFields(), txEffect.noteHashes, txEffect.nullifiers[0]).toBuffer());
+                privateTaggedLogs.set(tag.toString(), currentLogs);
             });
-            txEffect.publicLogs.forEach((log, logIndex)=>{
+            txEffect.publicLogs.forEach((log)=>{
+                // Public logs use Tag directly (not siloed) and are stored with contract address
                 const tag = log.fields[0];
-                this.#log.debug(`Found public log with tag ${tag.toString()} in block ${block.number}`);
-                const currentLogs = taggedLogs.get(tag.toString()) ?? [];
-                currentLogs.push(new TxScopedL2Log(txHash, dataStartIndexForTx, logIndex, block.number, log).toBuffer());
-                taggedLogs.set(tag.toString(), currentLogs);
+                const contractAddress = log.contractAddress;
+                const key = `${contractAddress.toString()}_${tag.toString()}`;
+                this.#log.debug(`Found public log with tag ${tag.toString()} from contract ${contractAddress.toString()} in block ${block.number}`);
+                const currentLogs = publicTaggedLogs.get(key) ?? [];
+                currentLogs.push(new TxScopedL2Log(txHash, block.number, block.timestamp, log.getEmittedFields(), txEffect.noteHashes, txEffect.nullifiers[0]).toBuffer());
+                publicTaggedLogs.set(key, currentLogs);
             });
         });
-        return taggedLogs;
+        return {
+            privateTaggedLogs,
+            publicTaggedLogs
+        };
     }
     /**
-   * Append new logs to the store's list.
-   * @param blocks - The blocks for which to add the logs.
-   * @returns True if the operation is successful.
-   */ addLogs(blocks) {
-        const taggedLogsToAdd = blocks.map((block)=>this.#extractTaggedLogs(block)).reduce((acc, val)=>{
-            for (const [tag, logs] of val.entries()){
+   * Extracts and aggregates tagged logs from a list of blocks.
+   * @param blocks - The blocks to extract logs from.
+   * @returns A map from tag (as string) to an array of serialized private logs belonging to that tag, and a map from
+   * "{contractAddress}_{tag}" (as string) to an array of serialized public logs belonging to that key.
+   */ #extractTaggedLogs(blocks) {
+        const taggedLogsInBlocks = blocks.map((block)=>this.#extractTaggedLogsFromBlock(block));
+        // Now we merge the maps from each block into a single map.
+        const privateTaggedLogs = taggedLogsInBlocks.reduce((acc, { privateTaggedLogs })=>{
+            for (const [tag, logs] of privateTaggedLogs.entries()){
                 const currentLogs = acc.get(tag) ?? [];
                 acc.set(tag, currentLogs.concat(logs));
             }
             return acc;
         }, new Map());
-        const tagsToUpdate = Array.from(taggedLogsToAdd.keys());
+        const publicTaggedLogs = taggedLogsInBlocks.reduce((acc, { publicTaggedLogs })=>{
+            for (const [key, logs] of publicTaggedLogs.entries()){
+                const currentLogs = acc.get(key) ?? [];
+                acc.set(key, currentLogs.concat(logs));
+            }
+            return acc;
+        }, new Map());
+        return {
+            privateTaggedLogs,
+            publicTaggedLogs
+        };
+    }
+    /**
+   * Append new logs to the store's list.
+   * @param blocks - The blocks for which to add the logs.
+   * @returns True if the operation is successful.
+   */ addLogs(blocks) {
+        const { privateTaggedLogs, publicTaggedLogs } = this.#extractTaggedLogs(blocks);
+        const keysOfPrivateLogsToUpdate = Array.from(privateTaggedLogs.keys());
+        const keysOfPublicLogsToUpdate = Array.from(publicTaggedLogs.keys());
         return this.db.transactionAsync(async ()=>{
-            const currentTaggedLogs = await Promise.all(tagsToUpdate.map(async (tag)=>({
-                    tag,
-                    logBuffers: await this.#logsByTag.getAsync(tag)
+            const currentPrivateTaggedLogs = await Promise.all(keysOfPrivateLogsToUpdate.map(async (key)=>({
+                    tag: key,
+                    logBuffers: await this.#privateLogsByTag.getAsync(key)
+                })));
+            currentPrivateTaggedLogs.forEach((taggedLogBuffer)=>{
+                if (taggedLogBuffer.logBuffers && taggedLogBuffer.logBuffers.length > 0) {
+                    privateTaggedLogs.set(taggedLogBuffer.tag, taggedLogBuffer.logBuffers.concat(privateTaggedLogs.get(taggedLogBuffer.tag)));
+                }
+            });
+            const currentPublicTaggedLogs = await Promise.all(keysOfPublicLogsToUpdate.map(async (key)=>({
+                    key,
+                    logBuffers: await this.#publicLogsByContractAndTag.getAsync(key)
                 })));
-            currentTaggedLogs.forEach((taggedLogBuffer)=>{
+            currentPublicTaggedLogs.forEach((taggedLogBuffer)=>{
                 if (taggedLogBuffer.logBuffers && taggedLogBuffer.logBuffers.length > 0) {
-                    taggedLogsToAdd.set(taggedLogBuffer.tag, taggedLogBuffer.logBuffers.concat(taggedLogsToAdd.get(taggedLogBuffer.tag)));
+                    publicTaggedLogs.set(taggedLogBuffer.key, taggedLogBuffer.logBuffers.concat(publicTaggedLogs.get(taggedLogBuffer.key)));
                 }
             });
             for (const block of blocks){
-                const tagsInBlock = [];
-                for (const [tag, logs] of taggedLogsToAdd.entries()){
-                    await this.#logsByTag.set(tag, logs);
-                    tagsInBlock.push(tag);
+                const blockHash = await block.hash();
+                const privateTagsInBlock = [];
+                for (const [tag, logs] of privateTaggedLogs.entries()){
+                    await this.#privateLogsByTag.set(tag, logs);
+                    privateTagsInBlock.push(tag);
+                }
+                await this.#privateLogKeysByBlock.set(block.number, privateTagsInBlock);
+                const publicKeysInBlock = [];
+                for (const [key, logs] of publicTaggedLogs.entries()){
+                    await this.#publicLogsByContractAndTag.set(key, logs);
+                    publicKeysInBlock.push(key);
                 }
-                await this.#logTagsByBlock.set(block.number, tagsInBlock);
-                const privateLogsInBlock = block.body.txEffects.map((txEffect)=>txEffect.privateLogs).flat().map((log)=>log.toBuffer());
-                await this.#privateLogsByBlock.set(block.number, Buffer.concat(privateLogsInBlock));
+                await this.#publicLogKeysByBlock.set(block.number, publicKeysInBlock);
                 const publicLogsInBlock = block.body.txEffects.map((txEffect, txIndex)=>[
                         numToUInt32BE(txIndex),
                         numToUInt32BE(txEffect.publicLogs.length),
@@ -90,57 +146,60 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
                         numToUInt32BE(txEffect.contractClassLogs.length),
                         txEffect.contractClassLogs.map((log)=>log.toBuffer())
                     ].flat()).flat();
-                await this.#publicLogsByBlock.set(block.number, Buffer.concat(publicLogsInBlock));
-                await this.#contractClassLogsByBlock.set(block.number, Buffer.concat(contractClassLogsInBlock));
+                await this.#publicLogsByBlock.set(block.number, this.#packWithBlockHash(blockHash, publicLogsInBlock));
+                await this.#contractClassLogsByBlock.set(block.number, this.#packWithBlockHash(blockHash, contractClassLogsInBlock));
             }
             return true;
         });
     }
+    #packWithBlockHash(blockHash, data) {
+        return Buffer.concat([
+            blockHash.toBuffer(),
+            ...data
+        ]);
+    }
+    #unpackBlockHash(reader) {
+        const blockHash = reader.remainingBytes() > 0 ? reader.readObject(Fr) : undefined;
+        if (!blockHash) {
+            throw new Error('Failed to read block hash from log entry buffer');
+        }
+        return L2BlockHash.fromField(blockHash);
+    }
     deleteLogs(blocks) {
         return this.db.transactionAsync(async ()=>{
-            const tagsToDelete = (await Promise.all(blocks.map(async (block)=>{
-                const tags = await this.#logTagsByBlock.getAsync(block.number);
-                return tags ?? [];
-            }))).flat();
+            await Promise.all(blocks.map(async (block)=>{
+                // Delete private logs
+                const privateKeys = await this.#privateLogKeysByBlock.getAsync(block.number) ?? [];
+                await Promise.all(privateKeys.map((tag)=>this.#privateLogsByTag.delete(tag)));
+                // Delete public logs
+                const publicKeys = await this.#publicLogKeysByBlock.getAsync(block.number) ?? [];
+                await Promise.all(publicKeys.map((key)=>this.#publicLogsByContractAndTag.delete(key)));
+            }));
             await Promise.all(blocks.map((block)=>Promise.all([
-                    this.#privateLogsByBlock.delete(block.number),
                     this.#publicLogsByBlock.delete(block.number),
-                    this.#logTagsByBlock.delete(block.number),
+                    this.#privateLogKeysByBlock.delete(block.number),
+                    this.#publicLogKeysByBlock.delete(block.number),
                     this.#contractClassLogsByBlock.delete(block.number)
                 ])));
-            await Promise.all(tagsToDelete.map((tag)=>this.#logsByTag.delete(tag.toString())));
             return true;
         });
     }
     /**
-   * Retrieves all private logs from up to `limit` blocks, starting from the block number `start`.
-   * @param start - The block number from which to begin retrieving logs.
-   * @param limit - The maximum number of blocks to retrieve logs from.
-   * @returns An array of private logs from the specified range of blocks.
-   */ async getPrivateLogs(start, limit) {
-        const logs = [];
-        for await (const buffer of this.#privateLogsByBlock.valuesAsync({
-            start,
-            limit
-        })){
-            const reader = new BufferReader(buffer);
-            while(reader.remainingBytes() > 0){
-                logs.push(reader.readObject(PrivateLog));
-            }
-        }
-        return logs;
+   * Gets all private logs that match any of the `tags`. For each tag, an array of matching logs is returned. An empty
+   * array implies no logs match that tag.
+   */ async getPrivateLogsByTags(tags) {
+        const logs = await Promise.all(tags.map((tag)=>this.#privateLogsByTag.getAsync(tag.toString())));
+        return logs.map((logBuffers)=>logBuffers?.map((logBuffer)=>TxScopedL2Log.fromBuffer(logBuffer)) ?? []);
     }
     /**
-   * Gets all logs that match any of the received tags (i.e. logs with their first field equal to a tag).
-   * @param tags - The tags to filter the logs by.
-   * @returns For each received tag, an array of matching logs is returned. An empty array implies no logs match
-   * that tag.
-   */ async getLogsByTags(tags, limitPerTag) {
-        if (limitPerTag !== undefined && limitPerTag <= 0) {
-            throw new TypeError('limitPerTag needs to be greater than 0');
-        }
-        const logs = await Promise.all(tags.map((tag)=>this.#logsByTag.getAsync(tag.toString())));
-        return logs.map((logBuffers)=>logBuffers?.slice(0, limitPerTag).map((logBuffer)=>TxScopedL2Log.fromBuffer(logBuffer)) ?? []);
+   * Gets all public logs that match any of the `tags` from the specified contract. For each tag, an array of matching
+   * logs is returned. An empty array implies no logs match that tag.
+   */ async getPublicLogsByTagsFromContract(contractAddress, tags) {
+        const logs = await Promise.all(tags.map((tag)=>{
+            const key = `${contractAddress.toString()}_${tag.value.toString()}`;
+            return this.#publicLogsByContractAndTag.getAsync(key);
+        }));
+        return logs.map((logBuffers)=>logBuffers?.map((logBuffer)=>TxScopedL2Log.fromBuffer(logBuffer)) ?? []);
     }
     /**
    * Gets public logs based on the provided filter.
@@ -171,6 +230,7 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
             []
         ];
         const reader = new BufferReader(buffer);
+        const blockHash = this.#unpackBlockHash(reader);
         while(reader.remainingBytes() > 0){
             const indexOfTx = reader.readNumber();
             const numLogsInTx = reader.readNumber();
@@ -181,7 +241,7 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
         }
         const txLogs = publicLogsInBlock[txIndex];
         const logs = [];
-        const maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+        const maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
         return {
             logs,
             maxLogsHit
@@ -206,6 +266,7 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
                 []
             ];
             const reader = new BufferReader(logBuffer);
+            const blockHash = this.#unpackBlockHash(reader);
             while(reader.remainingBytes() > 0){
                 const indexOfTx = reader.readNumber();
                 const numLogsInTx = reader.readNumber();
@@ -216,7 +277,7 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
             }
             for(let txIndex = filter.afterLog?.txIndex ?? 0; txIndex < publicLogsInBlock.length; txIndex++){
                 const txLogs = publicLogsInBlock[txIndex];
-                maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+                maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
                 if (maxLogsHit) {
                     this.#log.debug(`Max logs hit at block ${blockNumber}`);
                     break loopOverBlocks;
@@ -257,6 +318,7 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
             []
         ];
         const reader = new BufferReader(contractClassLogsBuffer);
+        const blockHash = this.#unpackBlockHash(reader);
         while(reader.remainingBytes() > 0){
             const indexOfTx = reader.readNumber();
             const numLogsInTx = reader.readNumber();
@@ -267,7 +329,7 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
         }
         const txLogs = contractClassLogsInBlock[txIndex];
         const logs = [];
-        const maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+        const maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
         return {
             logs,
             maxLogsHit
@@ -292,6 +354,7 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
                 []
             ];
             const reader = new BufferReader(logBuffer);
+            const blockHash = this.#unpackBlockHash(reader);
             while(reader.remainingBytes() > 0){
                 const indexOfTx = reader.readNumber();
                 const numLogsInTx = reader.readNumber();
@@ -302,7 +365,7 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
             }
             for(let txIndex = filter.afterLog?.txIndex ?? 0; txIndex < contractClassLogsInBlock.length; txIndex++){
                 const txLogs = contractClassLogsInBlock[txIndex];
-                maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+                maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
                 if (maxLogsHit) {
                     this.#log.debug(`Max logs hit at block ${blockNumber}`);
                     break loopOverBlocks;
@@ -314,16 +377,18 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
             maxLogsHit
         };
     }
-    #accumulateLogs(results, blockNumber, txIndex, txLogs, filter) {
+    #accumulateLogs(results, blockNumber, blockHash, txIndex, txLogs, filter = {}) {
         let maxLogsHit = false;
         let logIndex = typeof filter.afterLog?.logIndex === 'number' ? filter.afterLog.logIndex + 1 : 0;
         for(; logIndex < txLogs.length; logIndex++){
             const log = txLogs[logIndex];
             if (!filter.contractAddress || log.contractAddress.equals(filter.contractAddress)) {
                 if (log instanceof ContractClassLog) {
-                    results.push(new ExtendedContractClassLog(new LogId(blockNumber, txIndex, logIndex), log));
+                    results.push(new ExtendedContractClassLog(new LogId(BlockNumber(blockNumber), blockHash, txIndex, logIndex), log));
+                } else if (log instanceof PublicLog) {
+                    results.push(new ExtendedPublicLog(new LogId(BlockNumber(blockNumber), blockHash, txIndex, logIndex), log));
                 } else {
-                    results.push(new ExtendedPublicLog(new LogId(blockNumber, txIndex, logIndex), log));
+                    throw new Error('Unknown log type');
                 }
                 if (results.length >= this.#logsMaxPageSize) {
                     maxLogsHit = true;

package/dest/archiver/kv_archiver_store/message_store.d.ts

@@ -1,5 +1,6 @@
-import type { L1BlockId } from '@aztec/ethereum';
-import { Fr } from '@aztec/foundation/fields';
+import type { L1BlockId } from '@aztec/ethereum/l1-types';
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type AztecAsyncKVStore, type CustomRange } from '@aztec/kv-store';
 import { type InboxMessage } from '../structs/inbox_message.js';
 export declare class MessageStoreError extends Error {
@@ -28,12 +29,12 @@ export declare class MessageStore {
      */
     getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined>;
     getLastMessage(): Promise<InboxMessage | undefined>;
-    getL1ToL2Messages(blockNumber: number): Promise<Fr[]>;
+    getL1ToL2Messages(checkpointNumber: CheckpointNumber): Promise<Fr[]>;
     iterateL1ToL2Messages(range?: CustomRange<bigint>): AsyncIterableIterator<InboxMessage>;
     removeL1ToL2Messages(startIndex: bigint): Promise<void>;
-    rollbackL1ToL2MessagesToL2Block(targetBlockNumber: number): Promise<void>;
+    rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber: CheckpointNumber): Promise<void>;
     private indexToKey;
     private leafToIndexKey;
     private increaseTotalMessageCount;
 }
-//# sourceMappingURL=message_store.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZV9zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FyY2hpdmVyL2t2X2FyY2hpdmVyX3N0b3JlL21lc3NhZ2Vfc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDMUQsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFbkUsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBSXBELE9BQU8sRUFDTCxLQUFLLGlCQUFpQixFQUd0QixLQUFLLFdBQVcsRUFFakIsTUFBTSxpQkFBaUIsQ0FBQztBQUd6QixPQUFPLEVBQ0wsS0FBSyxZQUFZLEVBSWxCLE1BQU0sNkJBQTZCLENBQUM7QUFFckMscUJBQWEsaUJBQWtCLFNBQVEsS0FBSzthQUd4QixZQUFZLEVBQUUsWUFBWTtJQUY1QyxZQUNFLE9BQU8sRUFBRSxNQUFNLEVBQ0MsWUFBWSxFQUFFLFlBQVksRUFJM0M7Q0FDRjtBQUVELHFCQUFhLFlBQVk7O0lBWVgsT0FBTyxDQUFDLEVBQUU7SUFBdEIsWUFBb0IsRUFBRSxFQUFFLGlCQUFpQixFQUt4QztJQUVZLDBCQUEwQixJQUFJLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FFekQ7SUFFRCxxQ0FBcUM7SUFDeEIsaUJBQWlCLElBQUksT0FBTyxDQUFDLFNBQVMsR0FBRyxTQUFTLENBQUMsQ0FRL0Q7SUFFRCxvQ0FBb0M7SUFDdkIsaUJBQWlCLENBQUMsT0FBTyxFQUFFLFNBQVMsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBR2hFO0lBRUQ7Ozs7T0FJRztJQUNJLGlCQUFpQixDQUFDLFFBQVEsRUFBRSxZQUFZLEVBQUUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBNkZoRTtJQUVEOzs7O09BSUc7SUFDSSxxQkFBcUIsQ0FBQyxhQUFhLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBRTNFO0lBRVksY0FBYyxJQUFJLE9BQU8sQ0FBQyxZQUFZLEdBQUcsU0FBUyxDQUFDLENBRy9EO0lBRVksaUJBQWlCLENBQUMsZ0JBQWdCLEVBQUUsZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBdUJoRjtJQUVhLHFCQUFxQixDQUFDLEtBQUssR0FBRSxXQUFXLENBQUMsTUFBTSxDQUFNLEdBQUcscUJBQXFCLENBQUMsWUFBWSxDQUFDLENBS3hHO0lBRU0sb0JBQW9CLENBQUMsVUFBVSxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBZ0I3RDtJQUVNLGtDQUFrQyxDQUFDLHNCQUFzQixFQUFFLGdCQUFnQixHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FJakc7SUFFRCxPQUFPLENBQUMsVUFBVTtJQUlsQixPQUFPLENBQUMsY0FBYztZQUlSLHlCQUF5QjtDQVN4QyJ9

package/dest/archiver/kv_archiver_store/message_store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"message_store.d.ts","sourceRoot":"","sources":["../../../src/archiver/kv_archiver_store/message_store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAI9C,OAAO,EACL,KAAK,iBAAiB,EAGtB,KAAK,WAAW,EAEjB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,KAAK,YAAY,EAIlB,MAAM,6BAA6B,CAAC;AAErC,qBAAa,iBAAkB,SAAQ,KAAK;aAGxB,YAAY,EAAE,YAAY;gBAD1C,OAAO,EAAE,MAAM,EACC,YAAY,EAAE,YAAY;CAK7C;AAED,qBAAa,YAAY;;IAYX,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,iBAAiB;IAO5B,0BAA0B,IAAI,OAAO,CAAC,MAAM,CAAC;IAI1D,qCAAqC;IACxB,iBAAiB,IAAI,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAUhE,oCAAoC;IACvB,iBAAiB,CAAC,OAAO,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAKjE;;;;OAIG;IACI,iBAAiB,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA+FjE;;;;OAIG;IACI,qBAAqB,CAAC,aAAa,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAI/D,cAAc,IAAI,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;IAKnD,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC;IAuBpD,qBAAqB,CAAC,KAAK,GAAE,WAAW,CAAC,MAAM,CAAM,GAAG,qBAAqB,CAAC,YAAY,CAAC;IAOlG,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBvD,+BAA+B,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMhF,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,cAAc;YAIR,yBAAyB;CASxC"}
+{"version":3,"file":"message_store.d.ts","sourceRoot":"","sources":["../../../src/archiver/kv_archiver_store/message_store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAEnE,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAIpD,OAAO,EACL,KAAK,iBAAiB,EAGtB,KAAK,WAAW,EAEjB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,KAAK,YAAY,EAIlB,MAAM,6BAA6B,CAAC;AAErC,qBAAa,iBAAkB,SAAQ,KAAK;aAGxB,YAAY,EAAE,YAAY;IAF5C,YACE,OAAO,EAAE,MAAM,EACC,YAAY,EAAE,YAAY,EAI3C;CACF;AAED,qBAAa,YAAY;;IAYX,OAAO,CAAC,EAAE;IAAtB,YAAoB,EAAE,EAAE,iBAAiB,EAKxC;IAEY,0BAA0B,IAAI,OAAO,CAAC,MAAM,CAAC,CAEzD;IAED,qCAAqC;IACxB,iBAAiB,IAAI,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAQ/D;IAED,oCAAoC;IACvB,iBAAiB,CAAC,OAAO,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAGhE;IAED;;;;OAIG;IACI,iBAAiB,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA6FhE;IAED;;;;OAIG;IACI,qBAAqB,CAAC,aAAa,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAE3E;IAEY,cAAc,IAAI,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAG/D;IAEY,iBAAiB,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC,CAuBhF;IAEa,qBAAqB,CAAC,KAAK,GAAE,WAAW,CAAC,MAAM,CAAM,GAAG,qBAAqB,CAAC,YAAY,CAAC,CAKxG;IAEM,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB7D;IAEM,kCAAkC,CAAC,sBAAsB,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAIjG;IAED,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,cAAc;YAIR,yBAAyB;CASxC"}

package/dest/archiver/kv_archiver_store/message_store.js

@@ -1,3 +1,4 @@
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
 import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
@@ -77,18 +78,18 @@ export class MessageStore {
                 if (!expectedRollingHash.equals(message.rollingHash)) {
                     throw new MessageStoreError(`Invalid rolling hash for incoming L1 to L2 message ${message.leaf.toString()} ` + `with index ${message.index} ` + `(expected ${expectedRollingHash.toString()} from previous hash ${previousRollingHash} but got ${message.rollingHash.toString()})`, message);
                 }
-                // 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}))`, message);
+                    throw new MessageStoreError(`Invalid index ${message.index} for incoming L1 to L2 message ${message.leaf.toString()} ` + `at checkpoint ${message.checkpointNumber} (expected value in range [${expectedStart}, ${expectedEnd}))`, message);
                 }
-                // Check there are no gaps in the indices within the same block.
-                if (lastMessage && message.l2BlockNumber === lastMessage.l2BlockNumber && message.index !== lastMessage.index + 1n) {
+                // Check there are no gaps in the indices within the same checkpoint.
+                if (lastMessage && message.checkpointNumber === lastMessage.checkpointNumber && message.index !== lastMessage.index + 1n) {
                     throw new MessageStoreError(`Missing prior message for incoming L1 to L2 message ${message.leaf.toString()} ` + `with index ${message.index}`, message);
                 }
                 // Check the first message in a block has the correct index.
-                if ((!lastMessage || message.l2BlockNumber > lastMessage.l2BlockNumber) && message.index !== InboxLeaf.smallestIndexFromL2Block(message.l2BlockNumber)) {
-                    throw new MessageStoreError(`Message ${message.leaf.toString()} for L2 block ${message.l2BlockNumber} has wrong index ` + `${message.index} (expected ${InboxLeaf.smallestIndexFromL2Block(message.l2BlockNumber)})`, message);
+                if ((!lastMessage || message.checkpointNumber > lastMessage.checkpointNumber) && message.index !== expectedStart) {
+                    throw new MessageStoreError(`Message ${message.leaf.toString()} for checkpoint ${message.checkpointNumber} has wrong index ` + `${message.index} (expected ${expectedStart})`, message);
                 }
                 // Perform the insertions.
                 await this.#l1ToL2Messages.set(this.indexToKey(message.index), serializeInboxMessage(message));
@@ -123,17 +124,17 @@ export class MessageStore {
         }));
         return msg ? deserializeInboxMessage(msg) : undefined;
     }
-    async getL1ToL2Messages(blockNumber) {
+    async getL1ToL2Messages(checkpointNumber) {
         const messages = [];
-        const [startIndex, endIndex] = InboxLeaf.indexRangeFromL2Block(blockNumber);
+        const [startIndex, endIndex] = InboxLeaf.indexRangeForCheckpoint(checkpointNumber);
         let lastIndex = startIndex - 1n;
         for await (const msgBuffer of this.#l1ToL2Messages.valuesAsync({
             start: this.indexToKey(startIndex),
             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}`);
             }
@@ -164,9 +165,9 @@ export class MessageStore {
             this.#log.warn(`Deleted ${deleteCount} L1 to L2 messages from index ${startIndex} from the store`);
         });
     }
-    rollbackL1ToL2MessagesToL2Block(targetBlockNumber) {
-        this.#log.debug(`Deleting L1 to L2 messages up to target L2 block ${targetBlockNumber}`);
-        const startIndex = InboxLeaf.smallestIndexFromL2Block(targetBlockNumber + 1);
+    rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber) {
+        this.#log.debug(`Deleting L1 to L2 messages up to target checkpoint ${targetCheckpointNumber}`);
+        const startIndex = InboxLeaf.smallestIndexForCheckpoint(CheckpointNumber(targetCheckpointNumber + 1));
         return this.removeL1ToL2Messages(startIndex);
     }
     indexToKey(index) {

package/dest/archiver/l1/bin/retrieve-calldata.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmV0cmlldmUtY2FsbGRhdGEuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hcmNoaXZlci9sMS9iaW4vcmV0cmlldmUtY2FsbGRhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dest/archiver/l1/bin/retrieve-calldata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retrieve-calldata.d.ts","sourceRoot":"","sources":["../../../../src/archiver/l1/bin/retrieve-calldata.ts"],"names":[],"mappings":""}

package/dest/archiver/l1/bin/retrieve-calldata.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { createPublicClient, http } from 'viem';
+import { mainnet } from 'viem/chains';
+import { CalldataRetriever } from '../calldata_retriever.js';
+const logger = createLogger('archiver:calldata-test');
+function parseArgs() {
+    const args = process.argv.slice(2);
+    if (args.length < 2) {
+        // eslint-disable-next-line no-console
+        console.error('Usage: node index.js <rollup-address> <tx-hash> [target-committee-size]');
+        // eslint-disable-next-line no-console
+        console.error('');
+        // eslint-disable-next-line no-console
+        console.error('Environment variables:');
+        // eslint-disable-next-line no-console
+        console.error('  ETHEREUM_HOST or RPC_URL - Ethereum RPC endpoint');
+        // eslint-disable-next-line no-console
+        console.error('');
+        // eslint-disable-next-line no-console
+        console.error('Example:');
+        // eslint-disable-next-line no-console
+        console.error('  RPC_URL=https://eth-mainnet.g.alchemy.com/v2/YOUR-API-KEY \\');
+        // eslint-disable-next-line no-console
+        console.error('  node index.js 0x1234... 0xabcd... 32');
+        process.exit(1);
+    }
+    const rollupAddress = EthAddress.fromString(args[0]);
+    const txHash = args[1];
+    const targetCommitteeSize = args[2] ? parseInt(args[2], 10) : 24;
+    const rpcUrl = process.env.ETHEREUM_HOST || process.env.RPC_URL;
+    if (!rpcUrl) {
+        // eslint-disable-next-line no-console
+        console.error('Error: ETHEREUM_HOST or RPC_URL environment variable must be set');
+        process.exit(1);
+    }
+    if (targetCommitteeSize <= 0 || targetCommitteeSize > 256) {
+        // eslint-disable-next-line no-console
+        console.error('Error: target-committee-size must be between 1 and 256');
+        process.exit(1);
+    }
+    return {
+        rollupAddress,
+        txHash,
+        rpcUrl,
+        targetCommitteeSize
+    };
+}
+async function main() {
+    const { rollupAddress, txHash, rpcUrl, targetCommitteeSize } = parseArgs();
+    logger.info('Calldata Retriever Test Script');
+    logger.info('===============================');
+    logger.info(`Rollup Address: ${rollupAddress.toString()}`);
+    logger.info(`Transaction Hash: ${txHash}`);
+    logger.info(`RPC URL: ${rpcUrl}`);
+    logger.info(`Target Committee Size: ${targetCommitteeSize}`);
+    logger.info('');
+    try {
+        // Create viem public client
+        const publicClient = createPublicClient({
+            chain: mainnet,
+            transport: http(rpcUrl, {
+                batch: false
+            })
+        });
+        logger.info('Fetching transaction...');
+        const tx = await publicClient.getTransaction({
+            hash: txHash
+        });
+        if (!tx) {
+            throw new Error(`Transaction ${txHash} not found`);
+        }
+        logger.info(`Transaction found in block ${tx.blockNumber}`);
+        // For simplicity, use zero addresses for optional contract addresses
+        // In production, these would be fetched from the rollup contract or configuration
+        const slashingProposerAddress = EthAddress.ZERO;
+        const governanceProposerAddress = EthAddress.ZERO;
+        const slashFactoryAddress = undefined;
+        logger.info('Using zero addresses for governance/slashing (can be configured if needed)');
+        // Create CalldataRetriever
+        const retriever = new CalldataRetriever(publicClient, publicClient, targetCommitteeSize, undefined, logger, {
+            rollupAddress,
+            governanceProposerAddress,
+            slashingProposerAddress,
+            slashFactoryAddress
+        });
+        // Extract L2 block number from transaction logs
+        logger.info('Decoding transaction to extract L2 block number...');
+        const receipt = await publicClient.getTransactionReceipt({
+            hash: txHash
+        });
+        const l2BlockProposedEvent = receipt.logs.find((log)=>{
+            try {
+                // Try to match the L2BlockProposed event
+                return log.address.toLowerCase() === rollupAddress.toString().toLowerCase() && log.topics[0] === '0x2f1d0e696fa5186494a2f2f89a0e0bcbb15d607f6c5eac4637e07e1e5e7d3c00' // L2BlockProposed event signature
+                ;
+            } catch  {
+                return false;
+            }
+        });
+        let l2BlockNumber;
+        if (l2BlockProposedEvent && l2BlockProposedEvent.topics[1]) {
+            // L2 block number is typically the first indexed parameter
+            l2BlockNumber = Number(BigInt(l2BlockProposedEvent.topics[1]));
+            logger.info(`L2 Block Number (from event): ${l2BlockNumber}`);
+        } else {
+            // Fallback: try to extract from transaction data or use a default
+            logger.warn('Could not extract L2 block number from event, using block number as fallback');
+            l2BlockNumber = Number(tx.blockNumber);
+        }
+        logger.info('');
+        logger.info('Retrieving block header from rollup transaction...');
+        logger.info('');
+        // For this script, we don't have blob hashes or expected hashes, so pass empty arrays/objects
+        const result = await retriever.getCheckpointFromRollupTx(txHash, [], CheckpointNumber(l2BlockNumber), {});
+        logger.info(' Successfully retrieved block header!');
+        logger.info('');
+        logger.info('Block Header Details:');
+        logger.info('====================');
+        logger.info(`Checkpoint Number: ${result.checkpointNumber}`);
+        logger.info(`Block Hash: ${result.blockHash}`);
+        logger.info(`Archive Root: ${result.archiveRoot.toString()}`);
+        logger.info('');
+        logger.info('Header:');
+        logger.info(`  Slot Number: ${result.header.slotNumber.toString()}`);
+        logger.info(`  Timestamp: ${result.header.timestamp.toString()}`);
+        logger.info(`  Coinbase: ${result.header.coinbase.toString()}`);
+        logger.info(`  Fee Recipient: ${result.header.feeRecipient.toString()}`);
+        logger.info(`  Total Mana Used: ${result.header.totalManaUsed.toString()}`);
+        logger.info('');
+        logger.info('Attestations:');
+        logger.info(`  Count: ${result.attestations.length}`);
+        logger.info(`  Non-empty attestations: ${result.attestations.filter((a)=>!a.signature.isEmpty()).length}`);
+        process.exit(0);
+    } catch (error) {
+        logger.error('Error retrieving block header:');
+        logger.error(error instanceof Error ? error.message : String(error));
+        if (error instanceof Error && error.stack) {
+            logger.debug(error.stack);
+        }
+        process.exit(1);
+    }
+}
+// Only run if this is the main module
+if (import.meta.url === `file://${process.argv[1]}`) {
+    void main();
+}