@aztec/archiver 0.0.1-commit.fce3e4f → 0.0.1-commit.fffb133c

package/dest/l1/data_retrieval.d.ts

@@ -0,0 +1,88 @@
+import type { BlobClientInterface } from '@aztec/blob-client/client';
+import { type CheckpointBlobData } from '@aztec/blob-lib';
+import type { InboxContract, RollupContract } from '@aztec/ethereum/contracts';
+import type { ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/types';
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { type Logger } from '@aztec/foundation/log';
+import { CommitteeAttestation } from '@aztec/stdlib/block';
+import { L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { Proof } from '@aztec/stdlib/proofs';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { type Hex } from 'viem';
+import type { ArchiverInstrumentation } from '../modules/instrumentation.js';
+import type { DataRetrieval } from '../structs/data_retrieval.js';
+import type { InboxMessage } from '../structs/inbox_message.js';
+export type RetrievedCheckpoint = {
+    checkpointNumber: CheckpointNumber;
+    archiveRoot: Fr;
+    header: CheckpointHeader;
+    checkpointBlobData: CheckpointBlobData;
+    l1: L1PublishedData;
+    chainId: Fr;
+    version: Fr;
+    attestations: CommitteeAttestation[];
+};
+export declare function retrievedToPublishedCheckpoint({ checkpointNumber, archiveRoot, header: checkpointHeader, checkpointBlobData, l1, chainId, version, attestations }: RetrievedCheckpoint): Promise<PublishedCheckpoint>;
+/**
+ * Fetches new checkpoints.
+ * @param rollup - The rollup contract wrapper.
+ * @param publicClient - The viem public client to use for transaction retrieval.
+ * @param debugClient - The viem debug client to use for trace/debug RPC methods (optional).
+ * @param blobClient - The blob client client for fetching blob data.
+ * @param searchStartBlock - The block number to use for starting the search.
+ * @param searchEndBlock - The highest block number that we should search up to.
+ * @param contractAddresses - The contract addresses (governanceProposerAddress, slashFactoryAddress, slashingProposerAddress).
+ * @param instrumentation - The archiver instrumentation instance.
+ * @param logger - The logger instance.
+ * @param isHistoricalSync - Whether this is a historical sync.
+ * @returns An array of retrieved checkpoints.
+ */
+export declare function retrieveCheckpointsFromRollup(rollup: RollupContract, publicClient: ViemPublicClient, debugClient: ViemPublicDebugClient, blobClient: BlobClientInterface, searchStartBlock: bigint, searchEndBlock: bigint, contractAddresses: {
+    governanceProposerAddress: EthAddress;
+    slashFactoryAddress?: EthAddress;
+    slashingProposerAddress: EthAddress;
+}, instrumentation: ArchiverInstrumentation, logger?: Logger, isHistoricalSync?: boolean): Promise<RetrievedCheckpoint[]>;
+export declare function getL1BlockTime(publicClient: ViemPublicClient, blockNumber: bigint): Promise<bigint>;
+export declare function getCheckpointBlobDataFromBlobs(blobClient: BlobClientInterface, blockHash: string, blobHashes: Buffer<ArrayBufferLike>[], checkpointNumber: CheckpointNumber, logger: Logger, isHistoricalSync: boolean): Promise<CheckpointBlobData>;
+/** Given an L1 to L2 message, retrieves its corresponding event from the Inbox within a specific block range. */
+export declare function retrieveL1ToL2Message(inbox: InboxContract, leaf: Fr, fromBlock: bigint, toBlock: bigint): Promise<InboxMessage | undefined>;
+/**
+ * Fetch L1 to L2 messages.
+ * @param inbox - The inbox contract wrapper.
+ * @param searchStartBlock - The block number to use for starting the search.
+ * @param searchEndBlock - The highest block number that we should search up to.
+ * @returns An array of InboxLeaf and next eth block to search from.
+ */
+export declare function retrieveL1ToL2Messages(inbox: InboxContract, searchStartBlock: bigint, searchEndBlock: bigint): Promise<InboxMessage[]>;
+/** Retrieves L2ProofVerified events from the rollup contract. */
+export declare function retrieveL2ProofVerifiedEvents(publicClient: ViemPublicClient, rollupAddress: EthAddress, searchStartBlock: bigint, searchEndBlock?: bigint): Promise<{
+    l1BlockNumber: bigint;
+    checkpointNumber: CheckpointNumber;
+    proverId: Fr;
+    txHash: Hex;
+}[]>;
+/** Retrieve submitted proofs from the rollup contract */
+export declare function retrieveL2ProofsFromRollup(publicClient: ViemPublicClient, rollupAddress: EthAddress, searchStartBlock: bigint, searchEndBlock?: bigint): Promise<DataRetrieval<{
+    proof: Proof;
+    proverId: Fr;
+    checkpointNumber: number;
+    txHash: `0x${string}`;
+}>>;
+export type SubmitEpochProof = {
+    archiveRoot: Fr;
+    proverId: Fr;
+    proof: Proof;
+};
+/**
+ * Gets epoch proof metadata (archive root and proof) from the calldata of an L1 transaction.
+ * Assumes that the block was published from an EOA.
+ * TODO: Add retries and error management.
+ * @param publicClient - The viem public client to use for transaction retrieval.
+ * @param txHash - Hash of the tx that published it.
+ * @param expectedProverId - Expected prover ID.
+ * @returns Epoch proof metadata from the calldata, deserialized.
+ */
+export declare function getProofFromSubmitProofTx(publicClient: ViemPublicClient, txHash: `0x${string}`, expectedProverId: Fr): Promise<SubmitEpochProof>;
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/dest/{archiver → l1}/data_retrieval.js

@@ -1,25 +1,26 @@
 import { BlobDeserializationError, SpongeBlob, decodeCheckpointBlobDataFromBlobs, encodeBlockBlobData } from '@aztec/blob-lib';
 import { asyncPool } from '@aztec/foundation/async-pool';
-import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
-import { Fr } from '@aztec/foundation/fields';
+import { CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { RollupAbi } from '@aztec/l1-artifacts';
-import { Body, CommitteeAttestation, L2BlockNew } from '@aztec/stdlib/block';
-import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { Body, L2Block } from '@aztec/stdlib/block';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { Proof } from '@aztec/stdlib/proofs';
-import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
 import { BlockHeader, GlobalVariables, PartialStateReference, StateReference } from '@aztec/stdlib/tx';
-import { decodeFunctionData, getAbiItem, hexToBytes, multicall3Abi } from 'viem';
-import { NoBlobBodiesFoundError } from './errors.js';
+import { decodeFunctionData, getAbiItem, hexToBytes } from 'viem';
+import { NoBlobBodiesFoundError } from '../errors.js';
+import { CalldataRetriever } from './calldata_retriever.js';
 export async function retrievedToPublishedCheckpoint({ checkpointNumber, archiveRoot, header: checkpointHeader, checkpointBlobData, l1, chainId, version, attestations }) {
     const { blocks: blocksBlobData } = checkpointBlobData;
     // The lastArchiveRoot of a block is the new archive for the previous block.
     const newArchiveRoots = blocksBlobData.map((b)=>b.lastArchiveRoot).slice(1).concat([
         archiveRoot
     ]);
-    // `blocksBlobData` is created from `decodeCheckpointBlobDataFromBlobs`. An error will be thrown if it can't read a
-    // field for the `l1ToL2MessageRoot` of the first block. So below we can safely assume it exists:
+    // An error will be thrown from `decodeCheckpointBlobDataFromBlobs` if it can't read a field for the
+    // `l1ToL2MessageRoot` of the first block. So below we can safely assume it exists:
     const l1toL2MessageTreeRoot = blocksBlobData[0].l1ToL2MessageRoot;
     const spongeBlob = SpongeBlob.init();
     const l2Blocks = [];
@@ -59,7 +60,7 @@ export async function retrievedToPublishedCheckpoint({ checkpointNumber, archive
             totalManaUsed: new Fr(blockEndStateField.totalManaUsed)
         });
         const newArchive = new AppendOnlyTreeSnapshot(newArchiveRoots[i], l2BlockNumber + 1);
-        l2Blocks.push(new L2BlockNew(newArchive, header, body));
+        l2Blocks.push(new L2Block(newArchive, header, body, checkpointNumber, IndexWithinCheckpoint(i)));
     }
     const lastBlock = l2Blocks.at(-1);
     const checkpoint = Checkpoint.from({
@@ -76,86 +77,100 @@ export async function retrievedToPublishedCheckpoint({ checkpointNumber, archive
 }
 /**
  * Fetches new checkpoints.
+ * @param rollup - The rollup contract wrapper.
  * @param publicClient - The viem public client to use for transaction retrieval.
- * @param rollupAddress - The address of the rollup contract.
+ * @param debugClient - The viem debug client to use for trace/debug RPC methods (optional).
+ * @param blobClient - The blob client client for fetching blob data.
  * @param searchStartBlock - The block number to use for starting the search.
  * @param searchEndBlock - The highest block number that we should search up to.
- * @param expectedNextL2BlockNum - The next L2 block number that we expect to find.
- * @returns An array of block; as well as the next eth block to search from.
- */ export async function retrieveCheckpointsFromRollup(rollup, publicClient, blobSinkClient, searchStartBlock, searchEndBlock, logger = createLogger('archiver')) {
+ * @param contractAddresses - The contract addresses (governanceProposerAddress, slashFactoryAddress, slashingProposerAddress).
+ * @param instrumentation - The archiver instrumentation instance.
+ * @param logger - The logger instance.
+ * @param isHistoricalSync - Whether this is a historical sync.
+ * @returns An array of retrieved checkpoints.
+ */ export async function retrieveCheckpointsFromRollup(rollup, publicClient, debugClient, blobClient, searchStartBlock, searchEndBlock, contractAddresses, instrumentation, logger = createLogger('archiver'), isHistoricalSync = false) {
     const retrievedCheckpoints = [];
     let rollupConstants;
     do {
         if (searchStartBlock > searchEndBlock) {
             break;
         }
-        const checkpointProposedLogs = (await rollup.getEvents.CheckpointProposed({}, {
-            fromBlock: searchStartBlock,
-            toBlock: searchEndBlock
-        })).filter((log)=>log.blockNumber >= searchStartBlock && log.blockNumber <= searchEndBlock);
+        const checkpointProposedLogs = await rollup.getCheckpointProposedEvents(searchStartBlock, searchEndBlock);
         if (checkpointProposedLogs.length === 0) {
             break;
         }
         const lastLog = checkpointProposedLogs.at(-1);
-        logger.debug(`Got ${checkpointProposedLogs.length} processed logs for checkpoints  ${checkpointProposedLogs[0].args.checkpointNumber}-${lastLog.args.checkpointNumber} between L1 blocks ${searchStartBlock}-${searchEndBlock}`);
+        logger.debug(`Got ${checkpointProposedLogs.length} processed logs for checkpoints ${checkpointProposedLogs[0].args.checkpointNumber}-${lastLog.args.checkpointNumber} between L1 blocks ${searchStartBlock}-${searchEndBlock}`);
         if (rollupConstants === undefined) {
             const [chainId, version, targetCommitteeSize] = await Promise.all([
                 publicClient.getChainId(),
-                rollup.read.getVersion(),
-                rollup.read.getTargetCommitteeSize()
+                rollup.getVersion(),
+                rollup.getTargetCommitteeSize()
             ]);
             rollupConstants = {
                 chainId: new Fr(chainId),
                 version: new Fr(version),
-                targetCommitteeSize: Number(targetCommitteeSize)
+                targetCommitteeSize
             };
         }
-        const newCheckpoints = await processCheckpointProposedLogs(rollup, publicClient, blobSinkClient, checkpointProposedLogs, rollupConstants, logger);
+        const newCheckpoints = await processCheckpointProposedLogs(rollup, publicClient, debugClient, blobClient, checkpointProposedLogs, rollupConstants, contractAddresses, instrumentation, logger, isHistoricalSync);
         retrievedCheckpoints.push(...newCheckpoints);
-        searchStartBlock = lastLog.blockNumber + 1n;
+        searchStartBlock = lastLog.l1BlockNumber + 1n;
     }while (searchStartBlock <= searchEndBlock)
     // The asyncPool from processCheckpointProposedLogs will not necessarily return the checkpoints in order, so we sort them before returning.
     return retrievedCheckpoints.sort((a, b)=>Number(a.l1.blockNumber - b.l1.blockNumber));
 }
 /**
  * Processes newly received CheckpointProposed logs.
- * @param rollup - The rollup contract
+ * @param rollup - The rollup contract wrapper.
  * @param publicClient - The viem public client to use for transaction retrieval.
+ * @param debugClient - The viem debug client to use for trace/debug RPC methods (optional).
+ * @param blobClient - The blob client client for fetching blob data.
  * @param logs - CheckpointProposed logs.
- * @returns - An array of checkpoints.
- */ async function processCheckpointProposedLogs(rollup, publicClient, blobSinkClient, logs, { chainId, version, targetCommitteeSize }, logger) {
+ * @param rollupConstants - The rollup constants (chainId, version, targetCommitteeSize).
+ * @param contractAddresses - The contract addresses (governanceProposerAddress, slashFactoryAddress, slashingProposerAddress).
+ * @param instrumentation - The archiver instrumentation instance.
+ * @param logger - The logger instance.
+ * @param isHistoricalSync - Whether this is a historical sync.
+ * @returns An array of retrieved checkpoints.
+ */ async function processCheckpointProposedLogs(rollup, publicClient, debugClient, blobClient, logs, { chainId, version, targetCommitteeSize }, contractAddresses, instrumentation, logger, isHistoricalSync) {
     const retrievedCheckpoints = [];
+    const calldataRetriever = new CalldataRetriever(publicClient, debugClient, targetCommitteeSize, instrumentation, logger, {
+        ...contractAddresses,
+        rollupAddress: EthAddress.fromString(rollup.address)
+    });
     await asyncPool(10, logs, async (log)=>{
-        const checkpointNumber = Number(log.args.checkpointNumber);
+        const checkpointNumber = log.args.checkpointNumber;
         const archive = log.args.archive;
-        const archiveFromChain = await rollup.read.archiveAt([
-            BigInt(checkpointNumber)
-        ]);
-        const blobHashes = log.args.versionedBlobHashes.map((blobHash)=>Buffer.from(blobHash.slice(2), 'hex'));
+        const archiveFromChain = await rollup.archiveAt(checkpointNumber);
+        const blobHashes = log.args.versionedBlobHashes;
         // The value from the event and contract will match only if the checkpoint is in the chain.
-        if (archive === archiveFromChain) {
-            const checkpoint = await getCheckpointFromRollupTx(publicClient, blobSinkClient, log.transactionHash, blobHashes, checkpointNumber, rollup.address, targetCommitteeSize, logger);
-            const l1 = {
-                blockNumber: log.blockNumber,
-                blockHash: log.blockHash,
-                timestamp: await getL1BlockTime(publicClient, log.blockNumber)
+        if (archive.equals(archiveFromChain)) {
+            // Build expected hashes object (fields may be undefined for backwards compatibility with older events)
+            const expectedHashes = {
+                attestationsHash: log.args.attestationsHash?.toString(),
+                payloadDigest: log.args.payloadDigest?.toString()
             };
+            const checkpoint = await calldataRetriever.getCheckpointFromRollupTx(log.l1TransactionHash, blobHashes, checkpointNumber, expectedHashes);
+            const checkpointBlobData = await getCheckpointBlobDataFromBlobs(blobClient, checkpoint.blockHash, blobHashes, checkpointNumber, logger, isHistoricalSync);
+            const l1 = new L1PublishedData(log.l1BlockNumber, await getL1BlockTime(publicClient, log.l1BlockNumber), log.l1BlockHash.toString());
             retrievedCheckpoints.push({
                 ...checkpoint,
+                checkpointBlobData,
                 l1,
                 chainId,
                 version
             });
-            logger.trace(`Retrieved checkpoint ${checkpointNumber} from L1 tx ${log.transactionHash}`, {
-                l1BlockNumber: log.blockNumber,
+            logger.trace(`Retrieved checkpoint ${checkpointNumber} from L1 tx ${log.l1TransactionHash}`, {
+                l1BlockNumber: log.l1BlockNumber,
                 checkpointNumber,
                 archive: archive.toString(),
                 attestations: checkpoint.attestations
             });
         } else {
             logger.warn(`Ignoring checkpoint ${checkpointNumber} due to archive root mismatch`, {
-                actual: archive,
-                expected: archiveFromChain
+                actual: archive.toString(),
+                expected: archiveFromChain.toString()
             });
         }
     });
@@ -168,149 +183,60 @@ export async function getL1BlockTime(publicClient, blockNumber) {
     });
     return block.timestamp;
 }
-/**
- * Extracts the first 'propose' method calldata from a multicall3 transaction's data.
- * @param multicall3Data - The multicall3 transaction input data
- * @param rollupAddress - The address of the rollup contract
- * @returns The calldata for the first 'propose' method call to the rollup contract
- */ function extractRollupProposeCalldata(multicall3Data, rollupAddress) {
-    const { functionName: multicall3FunctionName, args: multicall3Args } = decodeFunctionData({
-        abi: multicall3Abi,
-        data: multicall3Data
-    });
-    if (multicall3FunctionName !== 'aggregate3') {
-        throw new Error(`Unexpected multicall3 method called ${multicall3FunctionName}`);
-    }
-    if (multicall3Args.length !== 1) {
-        throw new Error(`Unexpected number of arguments for multicall3`);
-    }
-    const [calls] = multicall3Args;
-    // Find all rollup calls
-    const rollupAddressLower = rollupAddress.toLowerCase();
-    for(let i = 0; i < calls.length; i++){
-        const addr = calls[i].target;
-        if (addr.toLowerCase() !== rollupAddressLower) {
-            continue;
-        }
-        const callData = calls[i].callData;
-        try {
-            const { functionName: rollupFunctionName } = decodeFunctionData({
-                abi: RollupAbi,
-                data: callData
-            });
-            if (rollupFunctionName === 'propose') {
-                return callData;
-            }
-        } catch  {
-            continue;
-        }
-    }
-    throw new Error(`Rollup address not found in multicall3 args`);
-}
-/**
- * Gets checkpoint from the calldata of an L1 transaction.
- * Assumes that the checkpoint was published from an EOA.
- * TODO: Add retries and error management.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param txHash - Hash of the tx that published it.
- * @param checkpointNumber - Checkpoint number.
- * @returns Checkpoint from the calldata, deserialized
- */ async function getCheckpointFromRollupTx(publicClient, blobSinkClient, txHash, blobHashes, checkpointNumber, rollupAddress, targetCommitteeSize, logger) {
-    logger.trace(`Fetching checkpoint ${checkpointNumber} from rollup tx ${txHash}`);
-    const { input: forwarderData, blockHash } = await publicClient.getTransaction({
-        hash: txHash
+export async function getCheckpointBlobDataFromBlobs(blobClient, blockHash, blobHashes, checkpointNumber, logger, isHistoricalSync) {
+    const blobBodies = await blobClient.getBlobSidecar(blockHash, blobHashes, {
+        isHistoricalSync
     });
-    const rollupData = extractRollupProposeCalldata(forwarderData, rollupAddress);
-    const { functionName: rollupFunctionName, args: rollupArgs } = decodeFunctionData({
-        abi: RollupAbi,
-        data: rollupData
-    });
-    if (rollupFunctionName !== 'propose') {
-        throw new Error(`Unexpected rollup method called ${rollupFunctionName}`);
-    }
-    const [decodedArgs, packedAttestations, _signers, _blobInput] = rollupArgs;
-    const attestations = CommitteeAttestation.fromPacked(packedAttestations, targetCommitteeSize);
-    logger.trace(`Recovered propose calldata from tx ${txHash}`, {
-        checkpointNumber,
-        archive: decodedArgs.archive,
-        header: decodedArgs.header,
-        l1BlockHash: blockHash,
-        blobHashes,
-        attestations,
-        packedAttestations,
-        targetCommitteeSize
-    });
-    const header = CheckpointHeader.fromViem(decodedArgs.header);
-    const blobBodies = await blobSinkClient.getBlobSidecar(blockHash, blobHashes);
     if (blobBodies.length === 0) {
         throw new NoBlobBodiesFoundError(checkpointNumber);
     }
     let checkpointBlobData;
     try {
         // Attempt to decode the checkpoint blob data.
-        checkpointBlobData = decodeCheckpointBlobDataFromBlobs(blobBodies.map((b)=>b.blob));
+        checkpointBlobData = decodeCheckpointBlobDataFromBlobs(blobBodies);
     } catch (err) {
         if (err instanceof BlobDeserializationError) {
             logger.fatal(err.message);
         } else {
             logger.fatal('Unable to sync: failed to decode fetched blob, this blob was likely not created by us');
         }
+        // Throwing an error since this is most likely caused by a bug.
         throw err;
     }
-    const archiveRoot = new Fr(Buffer.from(hexToBytes(decodedArgs.archive)));
-    return {
-        checkpointNumber,
-        archiveRoot,
-        header,
-        checkpointBlobData,
-        attestations
-    };
+    return checkpointBlobData;
 }
 /** Given an L1 to L2 message, retrieves its corresponding event from the Inbox within a specific block range. */ export async function retrieveL1ToL2Message(inbox, leaf, fromBlock, toBlock) {
-    const logs = await inbox.getEvents.MessageSent({
-        hash: leaf.toString()
-    }, {
-        fromBlock,
-        toBlock
-    });
+    const logs = await inbox.getMessageSentEventByHash(leaf.toString(), fromBlock, toBlock);
     const messages = mapLogsInboxMessage(logs);
     return messages.length > 0 ? messages[0] : undefined;
 }
 /**
  * Fetch L1 to L2 messages.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param inboxAddress - The address of the inbox contract to fetch messages from.
- * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
+ * @param inbox - The inbox contract wrapper.
  * @param searchStartBlock - The block number to use for starting the search.
  * @param searchEndBlock - The highest block number that we should search up to.
  * @returns An array of InboxLeaf and next eth block to search from.
  */ export async function retrieveL1ToL2Messages(inbox, searchStartBlock, searchEndBlock) {
     const retrievedL1ToL2Messages = [];
     while(searchStartBlock <= searchEndBlock){
-        const messageSentLogs = (await inbox.getEvents.MessageSent({}, {
-            fromBlock: searchStartBlock,
-            toBlock: searchEndBlock
-        })).filter((log)=>log.blockNumber >= searchStartBlock && log.blockNumber <= searchEndBlock);
+        const messageSentLogs = await inbox.getMessageSentEvents(searchStartBlock, searchEndBlock);
         if (messageSentLogs.length === 0) {
             break;
         }
         retrievedL1ToL2Messages.push(...mapLogsInboxMessage(messageSentLogs));
-        searchStartBlock = messageSentLogs.at(-1).blockNumber + 1n;
+        searchStartBlock = messageSentLogs.at(-1).l1BlockNumber + 1n;
     }
     return retrievedL1ToL2Messages;
 }
 function mapLogsInboxMessage(logs) {
-    return logs.map((log)=>{
-        const { index, hash, checkpointNumber, rollingHash } = log.args;
-        return {
-            index: index,
-            leaf: Fr.fromHexString(hash),
-            l1BlockNumber: log.blockNumber,
-            l1BlockHash: Buffer32.fromString(log.blockHash),
-            l2BlockNumber: Number(checkpointNumber),
-            rollingHash: Buffer16.fromString(rollingHash)
-        };
-    });
+    return logs.map((log)=>({
+            index: log.args.index,
+            leaf: log.args.leaf,
+            l1BlockNumber: log.l1BlockNumber,
+            l1BlockHash: log.l1BlockHash,
+            checkpointNumber: log.args.checkpointNumber,
+            rollingHash: log.args.rollingHash
+        }));
 }
 /** Retrieves L2ProofVerified events from the rollup contract. */ export async function retrieveL2ProofVerifiedEvents(publicClient, rollupAddress, searchStartBlock, searchEndBlock) {
     const logs = await publicClient.getLogs({
@@ -325,7 +251,7 @@ function mapLogsInboxMessage(logs) {
     });
     return logs.map((log)=>({
             l1BlockNumber: log.blockNumber,
-            checkpointNumber: Number(log.args.checkpointNumber),
+            checkpointNumber: CheckpointNumber.fromBigInt(log.args.checkpointNumber),
             proverId: Fr.fromHexString(log.args.proverId),
             txHash: log.transactionHash
         }));

package/dest/l1/debug_tx.d.ts

@@ -0,0 +1,19 @@
+import type { DebugCallTrace, ViemPublicDebugClient } from '@aztec/ethereum/types';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { Logger } from '@aztec/foundation/log';
+import { type ZodFor } from '@aztec/foundation/schemas';
+import type { Hex } from 'viem';
+import type { CallInfo } from './types.js';
+/** Zod schema for validating call trace from debug_traceTransaction */
+export declare const callTraceSchema: ZodFor<DebugCallTrace>;
+/**
+ * Traces a transaction and extracts all CALL operations to a specific contract and function selector.
+ *
+ * @param client - The Viem public client
+ * @param txHash - The transaction hash to trace
+ * @param targetAddress - The contract address to filter for
+ * @param functionSelector - The 4-byte function selector to filter for (with or without 0x prefix)
+ * @returns Array of CallInfo objects containing from, gasUsed, input, and value for matching calls
+ */
+export declare function getSuccessfulCallsFromDebug(client: ViemPublicDebugClient, txHash: Hex, targetAddress: EthAddress, functionSelector: string, logger?: Logger): Promise<CallInfo[]>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVidWdfdHguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9sMS9kZWJ1Z190eC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxjQUFjLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRixPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDM0QsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDcEQsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFXLE1BQU0sMkJBQTJCLENBQUM7QUFHakUsT0FBTyxLQUFLLEVBQUUsR0FBRyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBR2hDLE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUUzQyx1RUFBdUU7QUFDdkUsZUFBTyxNQUFNLGVBQWUsRUFBRSxNQUFNLENBQUMsY0FBYyxDQWFsRCxDQUFDO0FBRUY7Ozs7Ozs7O0dBUUc7QUFDSCx3QkFBc0IsMkJBQTJCLENBQy9DLE1BQU0sRUFBRSxxQkFBcUIsRUFDN0IsTUFBTSxFQUFFLEdBQUcsRUFDWCxhQUFhLEVBQUUsVUFBVSxFQUN6QixnQkFBZ0IsRUFBRSxNQUFNLEVBQ3hCLE1BQU0sQ0FBQyxFQUFFLE1BQU0sR0FDZCxPQUFPLENBQUMsUUFBUSxFQUFFLENBQUMsQ0F3RHJCIn0=

package/dest/l1/debug_tx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug_tx.d.ts","sourceRoot":"","sources":["../../src/l1/debug_tx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnF,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,2BAA2B,CAAC;AAGjE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAGhC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,uEAAuE;AACvE,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,cAAc,CAalD,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,GAAG,EACX,aAAa,EAAE,UAAU,EACzB,gBAAgB,EAAE,MAAM,EACxB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,QAAQ,EAAE,CAAC,CAwDrB"}

package/dest/l1/debug_tx.js

@@ -0,0 +1,73 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { schemas } from '@aztec/foundation/schemas';
+import { withHexPrefix } from '@aztec/foundation/string';
+import { z } from 'zod';
+/** Zod schema for validating call trace from debug_traceTransaction */ export const callTraceSchema = z.lazy(()=>z.object({
+        from: schemas.HexStringWith0x,
+        to: schemas.HexStringWith0x.optional(),
+        type: z.string(),
+        input: schemas.HexStringWith0x.optional(),
+        output: schemas.HexStringWith0x.optional(),
+        gas: schemas.HexStringWith0x.optional(),
+        gasUsed: schemas.HexStringWith0x.optional(),
+        value: schemas.HexStringWith0x.optional(),
+        error: z.string().optional(),
+        calls: z.array(callTraceSchema).optional()
+    }));
+/**
+ * Traces a transaction and extracts all CALL operations to a specific contract and function selector.
+ *
+ * @param client - The Viem public client
+ * @param txHash - The transaction hash to trace
+ * @param targetAddress - The contract address to filter for
+ * @param functionSelector - The 4-byte function selector to filter for (with or without 0x prefix)
+ * @returns Array of CallInfo objects containing from, gasUsed, input, and value for matching calls
+ */ export async function getSuccessfulCallsFromDebug(client, txHash, targetAddress, functionSelector, logger) {
+    // Normalize inputs for comparison
+    const normalizedTarget = targetAddress.toString().toLowerCase();
+    const normalizedSelector = withHexPrefix(functionSelector.toLowerCase());
+    // Call debug_traceTransaction with callTracer
+    // Using 'any' here because debug_traceTransaction is not in viem's standard RPC types
+    const rawTrace = await client.request({
+        method: 'debug_traceTransaction',
+        params: [
+            txHash,
+            {
+                tracer: 'callTracer'
+            }
+        ]
+    });
+    if (rawTrace === null || rawTrace === undefined) {
+        throw new Error(`Failed to retrieve debug_traceTransaction for ${txHash}`);
+    }
+    logger?.trace(`Retrieved debug_traceTransaction for ${txHash}`, {
+        trace: rawTrace
+    });
+    // Validate the response with zod
+    const trace = callTraceSchema.parse(rawTrace);
+    const results = [];
+    /**
+   * Recursively traverse the call trace tree
+   */ function traverseCalls(callTrace) {
+        // Skip calls that have errors, and all its descendants
+        if (callTrace.error) {
+            return;
+        }
+        // Check if this is a CALL (not DELEGATECALL or STATICCALL) to the target address with matching selector
+        if (callTrace.type.toUpperCase() === 'CALL' && callTrace.to?.toLowerCase() === normalizedTarget && callTrace.input?.toLowerCase().startsWith(normalizedSelector)) {
+            results.push({
+                from: EthAddress.fromString(callTrace.from),
+                gasUsed: callTrace.gasUsed === undefined ? undefined : BigInt(callTrace.gasUsed),
+                input: callTrace.input,
+                value: callTrace.value ? BigInt(callTrace.value) : 0n
+            });
+        }
+        // Recursively process nested calls
+        for (const nestedCall of callTrace.calls ?? []){
+            traverseCalls(nestedCall);
+        }
+    }
+    // Start traversal from the root trace
+    traverseCalls(trace);
+    return results;
+}

package/dest/l1/spire_proposer.d.ts

@@ -0,0 +1,70 @@
+import type { Logger } from '@aztec/foundation/log';
+import { type Hex, type Transaction } from 'viem';
+export declare const SPIRE_PROPOSER_ADDRESS = "0x9ccc2f3ecde026230e11a5c8799ac7524f2bb294";
+export declare const SPIRE_PROPOSER_EXPECTED_IMPLEMENTATION = "0x7d38d47e7c82195e6e607d3b0f1c20c615c7bf42";
+export declare const EIP1967_IMPLEMENTATION_SLOT: "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
+export declare const SpireProposerAbi: readonly [{
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "proposer";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "target";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "data";
+            readonly type: "bytes";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "gasLimit";
+            readonly type: "uint256";
+        }];
+        readonly internalType: "struct IProposerMulticall.Call[]";
+        readonly name: "_calls";
+        readonly type: "tuple[]";
+    }];
+    readonly name: "multicall";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+/**
+ * Verifies that a proxy contract points to the expected implementation using EIP-1967.
+ * @param publicClient - The viem public client
+ * @param proxyAddress - The proxy contract address
+ * @param expectedImplementation - The expected implementation address
+ * @param logger - Logger instance
+ * @returns True if the proxy points to the expected implementation
+ */
+export declare function verifyProxyImplementation(publicClient: {
+    getStorageAt: (params: {
+        address: Hex;
+        slot: Hex;
+    }) => Promise<Hex | undefined>;
+}, proxyAddress: Hex, expectedImplementation: Hex, logger: Logger): Promise<boolean>;
+/**
+ * Attempts to decode transaction as a Spire Proposer Multicall.
+ * Spire Proposer is a proxy contract that wraps multiple calls.
+ * Returns the target address and calldata of the wrapped call if validation succeeds and there is a single call.
+ * @param tx - The transaction to decode
+ * @param publicClient - The viem public client for proxy verification
+ * @param logger - Logger instance
+ * @returns Object with 'to' and 'data' of the wrapped call, or undefined if validation fails
+ */
+export declare function getCallFromSpireProposer(tx: Transaction, publicClient: {
+    getStorageAt: (params: {
+        address: Hex;
+        slot: Hex;
+    }) => Promise<Hex | undefined>;
+}, logger: Logger): Promise<{
+    to: Hex;
+    data: Hex;
+} | undefined>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BpcmVfcHJvcG9zZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9sMS9zcGlyZV9wcm9wb3Nlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUVwRCxPQUFPLEVBQUUsS0FBSyxHQUFHLEVBQUUsS0FBSyxXQUFXLEVBQXdDLE1BQU0sTUFBTSxDQUFDO0FBR3hGLGVBQU8sTUFBTSxzQkFBc0IsK0NBQStDLENBQUM7QUFDbkYsZUFBTyxNQUFNLHNDQUFzQywrQ0FBK0MsQ0FBQztBQUluRyxlQUFPLE1BQU0sMkJBQTJCLHNFQUN1QyxDQUFDO0FBR2hGLGVBQU8sTUFBTSxnQkFBZ0I7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7RUFxQm5CLENBQUM7QUFFWDs7Ozs7OztHQU9HO0FBQ0gsd0JBQXNCLHlCQUF5QixDQUM3QyxZQUFZLEVBQUU7SUFBRSxZQUFZLEVBQUUsQ0FBQyxNQUFNLEVBQUU7UUFBRSxPQUFPLEVBQUUsR0FBRyxDQUFDO1FBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQTtLQUFFLEtBQUssT0FBTyxDQUFDLEdBQUcsR0FBRyxTQUFTLENBQUMsQ0FBQTtDQUFFLEVBQ2pHLFlBQVksRUFBRSxHQUFHLEVBQ2pCLHNCQUFzQixFQUFFLEdBQUcsRUFDM0IsTUFBTSxFQUFFLE1BQU0sR0FDYixPQUFPLENBQUMsT0FBTyxDQUFDLENBaUNsQjtBQUVEOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQXNCLHdCQUF3QixDQUM1QyxFQUFFLEVBQUUsV0FBVyxFQUNmLFlBQVksRUFBRTtJQUFFLFlBQVksRUFBRSxDQUFDLE1BQU0sRUFBRTtRQUFFLE9BQU8sRUFBRSxHQUFHLENBQUM7UUFBQyxJQUFJLEVBQUUsR0FBRyxDQUFBO0tBQUUsS0FBSyxPQUFPLENBQUMsR0FBRyxHQUFHLFNBQVMsQ0FBQyxDQUFBO0NBQUUsRUFDakcsTUFBTSxFQUFFLE1BQU0sR0FDYixPQUFPLENBQUM7SUFBRSxFQUFFLEVBQUUsR0FBRyxDQUFDO0lBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQTtDQUFFLEdBQUcsU0FBUyxDQUFDLENBNEQ3QyJ9

package/dest/l1/spire_proposer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spire_proposer.d.ts","sourceRoot":"","sources":["../../src/l1/spire_proposer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EAAE,KAAK,GAAG,EAAE,KAAK,WAAW,EAAwC,MAAM,MAAM,CAAC;AAGxF,eAAO,MAAM,sBAAsB,+CAA+C,CAAC;AACnF,eAAO,MAAM,sCAAsC,+CAA+C,CAAC;AAInG,eAAO,MAAM,2BAA2B,sEACuC,CAAC;AAGhF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBnB,CAAC;AAEX;;;;;;;GAOG;AACH,wBAAsB,yBAAyB,CAC7C,YAAY,EAAE;IAAE,YAAY,EAAE,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,KAAK,OAAO,CAAC,GAAG,GAAG,SAAS,CAAC,CAAA;CAAE,EACjG,YAAY,EAAE,GAAG,EACjB,sBAAsB,EAAE,GAAG,EAC3B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,OAAO,CAAC,CAiClB;AAED;;;;;;;;GAQG;AACH,wBAAsB,wBAAwB,CAC5C,EAAE,EAAE,WAAW,EACf,YAAY,EAAE;IAAE,YAAY,EAAE,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAC;QAAC,IAAI,EAAE,GAAG,CAAA;KAAE,KAAK,OAAO,CAAC,GAAG,GAAG,SAAS,CAAC,CAAA;CAAE,EACjG,MAAM,EAAE,MAAM,GACb,OAAO,CAAC;IAAE,EAAE,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,GAAG,CAAA;CAAE,GAAG,SAAS,CAAC,CA4D7C"}