@aztec/archiver 2.1.8 → 2.1.9

package/dest/archiver/l1/calldata_retriever.js

@@ -0,0 +1,406 @@
+import { MULTI_CALL_3_ADDRESS } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { EmpireSlashingProposerAbi, GovernanceProposerAbi, RollupAbi, SlashFactoryAbi, TallySlashingProposerAbi } from '@aztec/l1-artifacts';
+import { CommitteeAttestation } from '@aztec/stdlib/block';
+import { ProposedBlockHeader, StateReference } from '@aztec/stdlib/tx';
+import { decodeFunctionData, hexToBytes, multicall3Abi, toFunctionSelector } from 'viem';
+import { getSuccessfulCallsFromDebug } from './debug_tx.js';
+import { getCallFromSpireProposer } from './spire_proposer.js';
+import { getSuccessfulCallsFromTrace } from './trace_tx.js';
+/**
+ * Extracts calldata to the `propose` method of the rollup contract from an L1 transaction
+ * in order to reconstruct an L2 block header.
+ */ export class CalldataRetriever {
+    publicClient;
+    debugClient;
+    targetCommitteeSize;
+    instrumentation;
+    logger;
+    /** Pre-computed valid contract calls for validation */ validContractCalls;
+    rollupAddress;
+    constructor(publicClient, debugClient, targetCommitteeSize, instrumentation, logger, contractAddresses){
+        this.publicClient = publicClient;
+        this.debugClient = debugClient;
+        this.targetCommitteeSize = targetCommitteeSize;
+        this.instrumentation = instrumentation;
+        this.logger = logger;
+        this.rollupAddress = contractAddresses.rollupAddress;
+        this.validContractCalls = computeValidContractCalls(contractAddresses);
+    }
+    /**
+   * Gets block header and metadata from the calldata of an L1 transaction.
+   * Tries multicall3 decoding, falls back to trace-based extraction.
+   * @param txHash - Hash of the tx that published it.
+   * @param l2BlockNumber - L2 block number.
+   * @returns L2 block header and metadata from the calldata, deserialized (without body)
+   */ async getBlockHeaderFromRollupTx(txHash, l2BlockNumber) {
+        this.logger.trace(`Fetching L2 block ${l2BlockNumber} from rollup tx ${txHash}`);
+        const tx = await this.publicClient.getTransaction({
+            hash: txHash
+        });
+        const proposeCalldata = await this.getProposeCallData(tx, l2BlockNumber);
+        return this.decodeAndBuildBlockHeader(proposeCalldata, tx.blockHash, l2BlockNumber);
+    }
+    /** Gets rollup propose calldata from a transaction */ async getProposeCallData(tx, l2BlockNumber) {
+        // Try to decode as multicall3 with validation
+        const proposeCalldata = this.tryDecodeMulticall3(tx);
+        if (proposeCalldata) {
+            this.logger.trace(`Decoded propose calldata from multicall3 for tx ${tx.hash}`);
+            this.instrumentation?.recordBlockProposalTxTarget(tx.to, false);
+            return proposeCalldata;
+        }
+        // Try to decode as direct propose call
+        const directProposeCalldata = this.tryDecodeDirectPropose(tx);
+        if (directProposeCalldata) {
+            this.logger.trace(`Decoded propose calldata from direct call for tx ${tx.hash}`);
+            this.instrumentation?.recordBlockProposalTxTarget(tx.to, false);
+            return directProposeCalldata;
+        }
+        // Try to decode as Spire Proposer multicall wrapper
+        const spireProposeCalldata = await this.tryDecodeSpireProposer(tx);
+        if (spireProposeCalldata) {
+            this.logger.trace(`Decoded propose calldata from Spire Proposer for tx ${tx.hash}`);
+            this.instrumentation?.recordBlockProposalTxTarget(tx.to, false);
+            return spireProposeCalldata;
+        }
+        // Fall back to trace-based extraction
+        this.logger.warn(`Failed to decode multicall3, direct propose, or Spire proposer for L1 tx ${tx.hash}, falling back to trace for L2 block ${l2BlockNumber}`);
+        this.instrumentation?.recordBlockProposalTxTarget(tx.to ?? EthAddress.ZERO.toString(), true);
+        return await this.extractCalldataViaTrace(tx.hash);
+    }
+    /**
+   * Attempts to decode a transaction as a Spire Proposer multicall wrapper.
+   * If successful, extracts the wrapped call and validates it as either multicall3 or direct propose.
+   * @param tx - The transaction to decode
+   * @returns The propose calldata if successfully decoded and validated, undefined otherwise
+   */ async tryDecodeSpireProposer(tx) {
+        // Try to decode as Spire Proposer multicall (extracts the wrapped call)
+        const spireWrappedCall = await getCallFromSpireProposer(tx, this.publicClient, this.logger);
+        if (!spireWrappedCall) {
+            return undefined;
+        }
+        this.logger.trace(`Decoded Spire Proposer wrapping for tx ${tx.hash}, inner call to ${spireWrappedCall.to}`);
+        // Now try to decode the wrapped call as either multicall3 or direct propose
+        const wrappedTx = {
+            to: spireWrappedCall.to,
+            input: spireWrappedCall.data,
+            hash: tx.hash
+        };
+        const multicall3Calldata = this.tryDecodeMulticall3(wrappedTx);
+        if (multicall3Calldata) {
+            this.logger.trace(`Decoded propose calldata from Spire Proposer to multicall3 for tx ${tx.hash}`);
+            return multicall3Calldata;
+        }
+        const directProposeCalldata = this.tryDecodeDirectPropose(wrappedTx);
+        if (directProposeCalldata) {
+            this.logger.trace(`Decoded propose calldata from Spire Proposer to direct propose for tx ${tx.hash}`);
+            return directProposeCalldata;
+        }
+        this.logger.warn(`Spire Proposer wrapped call could not be decoded as multicall3 or direct propose for tx ${tx.hash}`);
+        return undefined;
+    }
+    /**
+   * Attempts to decode transaction input as multicall3 and extract propose calldata.
+   * Returns undefined if validation fails.
+   * @param tx - The transaction-like object with to, input, and hash
+   * @returns The propose calldata if successfully validated, undefined otherwise
+   */ tryDecodeMulticall3(tx) {
+        const txHash = tx.hash;
+        try {
+            // Check if transaction is to Multicall3 address
+            if (!tx.to || !EthAddress.areEqual(tx.to, MULTI_CALL_3_ADDRESS)) {
+                this.logger.debug(`Transaction is not to Multicall3 address (to: ${tx.to})`, {
+                    txHash,
+                    to: tx.to
+                });
+                return undefined;
+            }
+            // Try to decode as multicall3 aggregate3 call
+            const { functionName: multicall3Fn, args: multicall3Args } = decodeFunctionData({
+                abi: multicall3Abi,
+                data: tx.input
+            });
+            // If not aggregate3, return undefined (not a multicall3 transaction)
+            if (multicall3Fn !== 'aggregate3') {
+                this.logger.warn(`Transaction is not multicall3 aggregate3 (got ${multicall3Fn})`, {
+                    txHash
+                });
+                return undefined;
+            }
+            if (multicall3Args.length !== 1) {
+                this.logger.warn(`Unexpected number of arguments for multicall3 (got ${multicall3Args.length})`, {
+                    txHash
+                });
+                return undefined;
+            }
+            const [calls] = multicall3Args;
+            // Validate all calls and find propose calls
+            const rollupAddressLower = this.rollupAddress.toString().toLowerCase();
+            const proposeCalls = [];
+            for(let i = 0; i < calls.length; i++){
+                const addr = calls[i].target.toLowerCase();
+                const callData = calls[i].callData;
+                // Extract function selector (first 4 bytes)
+                if (callData.length < 10) {
+                    // "0x" + 8 hex chars = 10 chars minimum for a valid function call
+                    this.logger.warn(`Invalid calldata length at index ${i} (${callData.length})`, {
+                        txHash
+                    });
+                    return undefined;
+                }
+                const functionSelector = callData.slice(0, 10);
+                // Validate this call is allowed by searching through valid calls
+                const validCall = this.validContractCalls.find((vc)=>vc.address === addr && vc.functionSelector === functionSelector);
+                if (!validCall) {
+                    this.logger.warn(`Invalid contract call detected in multicall3`, {
+                        index: i,
+                        targetAddress: addr,
+                        functionSelector,
+                        validCalls: this.validContractCalls.map((c)=>({
+                                address: c.address,
+                                selector: c.functionSelector
+                            })),
+                        txHash
+                    });
+                    return undefined;
+                }
+                this.logger.trace(`Valid call found to ${addr}`, {
+                    validCall
+                });
+                // Collect propose calls specifically
+                if (addr === rollupAddressLower && validCall.functionName === 'propose') {
+                    proposeCalls.push(callData);
+                }
+            }
+            // Validate exactly ONE propose call
+            if (proposeCalls.length === 0) {
+                this.logger.warn(`No propose calls found in multicall3`, {
+                    txHash
+                });
+                return undefined;
+            }
+            if (proposeCalls.length > 1) {
+                this.logger.warn(`Multiple propose calls found in multicall3 (${proposeCalls.length})`, {
+                    txHash
+                });
+                return undefined;
+            }
+            // Successfully extracted single propose call
+            return proposeCalls[0];
+        } catch (err) {
+            // Any decoding error triggers fallback to trace
+            this.logger.warn(`Failed to decode multicall3: ${err}`, {
+                txHash
+            });
+            return undefined;
+        }
+    }
+    /**
+   * Attempts to decode transaction as a direct propose call to the rollup contract.
+   * Returns undefined if validation fails.
+   * @param tx - The transaction-like object with to, input, and hash
+   * @returns The propose calldata if successfully validated, undefined otherwise
+   */ tryDecodeDirectPropose(tx) {
+        const txHash = tx.hash;
+        try {
+            // Check if transaction is to the rollup address
+            if (!tx.to || !EthAddress.areEqual(tx.to, this.rollupAddress)) {
+                this.logger.debug(`Transaction is not to rollup address (to: ${tx.to})`, {
+                    txHash
+                });
+                return undefined;
+            }
+            // Try to decode as propose call
+            const { functionName } = decodeFunctionData({
+                abi: RollupAbi,
+                data: tx.input
+            });
+            // If not propose, return undefined
+            if (functionName !== 'propose') {
+                this.logger.warn(`Transaction to rollup is not propose (got ${functionName})`, {
+                    txHash
+                });
+                return undefined;
+            }
+            // Successfully validated direct propose call
+            this.logger.trace(`Validated direct propose call to rollup`, {
+                txHash
+            });
+            return tx.input;
+        } catch (err) {
+            // Any decoding error means it's not a valid propose call
+            this.logger.warn(`Failed to decode as direct propose: ${err}`, {
+                txHash
+            });
+            return undefined;
+        }
+    }
+    /**
+   * Uses debug/trace RPC to extract the actual calldata from the successful propose call.
+   * This is the definitive fallback that works for any transaction pattern.
+   * Tries trace_transaction first, then falls back to debug_traceTransaction.
+   * @param txHash - The transaction hash to trace
+   * @returns The propose calldata from the successful call
+   */ async extractCalldataViaTrace(txHash) {
+        const rollupAddress = this.rollupAddress;
+        const selector = PROPOSE_SELECTOR;
+        let calls;
+        try {
+            // Try trace_transaction first (using Parity/OpenEthereum/Erigon RPC)
+            this.logger.debug(`Attempting to trace transaction ${txHash} using trace_transaction`);
+            calls = await getSuccessfulCallsFromTrace(this.debugClient, txHash, rollupAddress, selector, this.logger);
+            this.logger.debug(`Successfully traced using trace_transaction, found ${calls.length} calls`);
+        } catch (err) {
+            const traceError = err instanceof Error ? err : new Error(String(err));
+            this.logger.verbose(`Failed trace_transaction for ${txHash}`, {
+                traceError
+            });
+            try {
+                // Fall back to debug_traceTransaction (Geth RPC)
+                this.logger.debug(`Attempting to trace transaction ${txHash} using debug_traceTransaction`);
+                calls = await getSuccessfulCallsFromDebug(this.debugClient, txHash, rollupAddress, selector, this.logger);
+                this.logger.debug(`Successfully traced using debug_traceTransaction, found ${calls.length} calls`);
+            } catch (debugErr) {
+                const debugError = debugErr instanceof Error ? debugErr : new Error(String(debugErr));
+                this.logger.warn(`All tracing methods failed for tx ${txHash}`, {
+                    traceError,
+                    debugError,
+                    txHash
+                });
+                throw new Error(`Failed to trace transaction ${txHash} to extract propose calldata`);
+            }
+        }
+        // Validate exactly ONE successful propose call
+        if (calls.length === 0) {
+            throw new Error(`No successful propose calls found in transaction ${txHash}`);
+        }
+        if (calls.length > 1) {
+            throw new Error(`Multiple successful propose calls found in transaction ${txHash} (${calls.length})`);
+        }
+        // Return the calldata from the single successful propose call
+        return calls[0].input;
+    }
+    /**
+   * Decodes propose calldata and builds the block header structure.
+   * @param proposeCalldata - The propose function calldata
+   * @param blockHash - The L1 block hash containing this transaction
+   * @param blobHashes - The blob hashes for this block
+   * @param l2BlockNumber - The L2 block number
+   * @returns The decoded block header and metadata
+   */ decodeAndBuildBlockHeader(proposeCalldata, blockHash, l2BlockNumber) {
+        const { functionName: rollupFunctionName, args: rollupArgs } = decodeFunctionData({
+            abi: RollupAbi,
+            data: proposeCalldata
+        });
+        if (rollupFunctionName !== 'propose') {
+            throw new Error(`Unexpected rollup method called ${rollupFunctionName}`);
+        }
+        const [decodedArgs, packedAttestations, _signers, _attestationsAndSignersSignature, _blobInput] = rollupArgs;
+        const attestations = CommitteeAttestation.fromPacked(packedAttestations, this.targetCommitteeSize);
+        this.logger.trace(`Decoded propose calldata`, {
+            l2BlockNumber,
+            archive: decodedArgs.archive,
+            stateReference: decodedArgs.stateReference,
+            header: decodedArgs.header,
+            l1BlockHash: blockHash,
+            attestations,
+            packedAttestations,
+            targetCommitteeSize: this.targetCommitteeSize
+        });
+        const header = ProposedBlockHeader.fromViem(decodedArgs.header);
+        const archiveRoot = new Fr(Buffer.from(hexToBytes(decodedArgs.archive)));
+        const stateReference = StateReference.fromViem(decodedArgs.stateReference);
+        return {
+            l2BlockNumber,
+            archiveRoot,
+            stateReference,
+            header,
+            attestations,
+            blockHash
+        };
+    }
+}
+/**
+ * Pre-computed function selectors for all valid contract calls.
+ * These are computed once at module load time from the ABIs.
+ * Based on analysis of sequencer-client/src/publisher/sequencer-publisher.ts
+ */ // Rollup contract function selectors (always valid)
+const PROPOSE_SELECTOR = toFunctionSelector(RollupAbi.find((x)=>x.type === 'function' && x.name === 'propose'));
+const INVALIDATE_BAD_ATTESTATION_SELECTOR = toFunctionSelector(RollupAbi.find((x)=>x.type === 'function' && x.name === 'invalidateBadAttestation'));
+const INVALIDATE_INSUFFICIENT_ATTESTATIONS_SELECTOR = toFunctionSelector(RollupAbi.find((x)=>x.type === 'function' && x.name === 'invalidateInsufficientAttestations'));
+// Governance proposer function selectors
+const GOVERNANCE_SIGNAL_WITH_SIG_SELECTOR = toFunctionSelector(GovernanceProposerAbi.find((x)=>x.type === 'function' && x.name === 'signalWithSig'));
+// Slash factory function selectors
+const CREATE_SLASH_PAYLOAD_SELECTOR = toFunctionSelector(SlashFactoryAbi.find((x)=>x.type === 'function' && x.name === 'createSlashPayload'));
+// Empire slashing proposer function selectors
+const EMPIRE_SIGNAL_WITH_SIG_SELECTOR = toFunctionSelector(EmpireSlashingProposerAbi.find((x)=>x.type === 'function' && x.name === 'signalWithSig'));
+const EMPIRE_SUBMIT_ROUND_WINNER_SELECTOR = toFunctionSelector(EmpireSlashingProposerAbi.find((x)=>x.type === 'function' && x.name === 'submitRoundWinner'));
+// Tally slashing proposer function selectors
+const TALLY_VOTE_SELECTOR = toFunctionSelector(TallySlashingProposerAbi.find((x)=>x.type === 'function' && x.name === 'vote'));
+const TALLY_EXECUTE_ROUND_SELECTOR = toFunctionSelector(TallySlashingProposerAbi.find((x)=>x.type === 'function' && x.name === 'executeRound'));
+/**
+ * All valid contract calls that the sequencer publisher can make.
+ * Builds the list of valid (address, selector) pairs for validation.
+ *
+ * Alternatively, if we are absolutely sure that no code path from any of these
+ * contracts can eventually land on another call to `propose`, we can remove the
+ * function selectors.
+ */ function computeValidContractCalls(addresses) {
+    const { rollupAddress, governanceProposerAddress, slashFactoryAddress, slashingProposerAddress } = addresses;
+    const calls = [];
+    // Rollup contract calls (always present)
+    calls.push({
+        address: rollupAddress.toString().toLowerCase(),
+        functionSelector: PROPOSE_SELECTOR,
+        functionName: 'propose'
+    }, {
+        address: rollupAddress.toString().toLowerCase(),
+        functionSelector: INVALIDATE_BAD_ATTESTATION_SELECTOR,
+        functionName: 'invalidateBadAttestation'
+    }, {
+        address: rollupAddress.toString().toLowerCase(),
+        functionSelector: INVALIDATE_INSUFFICIENT_ATTESTATIONS_SELECTOR,
+        functionName: 'invalidateInsufficientAttestations'
+    });
+    // Governance proposer calls (optional)
+    if (governanceProposerAddress && !governanceProposerAddress.isZero()) {
+        calls.push({
+            address: governanceProposerAddress.toString().toLowerCase(),
+            functionSelector: GOVERNANCE_SIGNAL_WITH_SIG_SELECTOR,
+            functionName: 'signalWithSig'
+        });
+    }
+    // Slash factory calls (optional)
+    if (slashFactoryAddress && !slashFactoryAddress.isZero()) {
+        calls.push({
+            address: slashFactoryAddress.toString().toLowerCase(),
+            functionSelector: CREATE_SLASH_PAYLOAD_SELECTOR,
+            functionName: 'createSlashPayload'
+        });
+    }
+    // Slashing proposer calls (optional, can be either Empire or Tally)
+    if (slashingProposerAddress && !slashingProposerAddress.isZero()) {
+        // Empire calls
+        calls.push({
+            address: slashingProposerAddress.toString().toLowerCase(),
+            functionSelector: EMPIRE_SIGNAL_WITH_SIG_SELECTOR,
+            functionName: 'signalWithSig (empire)'
+        }, {
+            address: slashingProposerAddress.toString().toLowerCase(),
+            functionSelector: EMPIRE_SUBMIT_ROUND_WINNER_SELECTOR,
+            functionName: 'submitRoundWinner'
+        });
+        // Tally calls
+        calls.push({
+            address: slashingProposerAddress.toString().toLowerCase(),
+            functionSelector: TALLY_VOTE_SELECTOR,
+            functionName: 'vote'
+        }, {
+            address: slashingProposerAddress.toString().toLowerCase(),
+            functionSelector: TALLY_EXECUTE_ROUND_SELECTOR,
+            functionName: 'executeRound'
+        });
+    }
+    return calls;
+}

package/dest/archiver/{data_retrieval.d.ts → l1/data_retrieval.d.ts}

@@ -1,6 +1,6 @@
 import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
-import type { ViemClient, ViemPublicClient } from '@aztec/ethereum';
-import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { ViemClient, ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger } from '@aztec/foundation/log';
 import { type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
@@ -8,9 +8,10 @@ import { Body, CommitteeAttestation, PublishedL2Block } from '@aztec/stdlib/bloc
 import { Proof } from '@aztec/stdlib/proofs';
 import { ProposedBlockHeader, StateReference } from '@aztec/stdlib/tx';
 import { type GetContractReturnType, type Hex } from 'viem';
-import type { DataRetrieval } from './structs/data_retrieval.js';
-import type { InboxMessage } from './structs/inbox_message.js';
-import type { L1PublishedData } from './structs/published.js';
+import type { ArchiverInstrumentation } from '../instrumentation.js';
+import type { DataRetrieval } from '../structs/data_retrieval.js';
+import type { InboxMessage } from '../structs/inbox_message.js';
+import type { L1PublishedData } from '../structs/published.js';
 export type RetrievedL2Block = {
     l2BlockNumber: number;
     archiveRoot: Fr;
@@ -26,14 +27,20 @@ export declare function retrievedBlockToPublishedL2Block(retrievedBlock: Retriev
 /**
  * Fetches new L2 blocks.
  * @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 rollupAddress - The address of the rollup contract.
  * @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 declare function retrieveBlocksFromRollup(rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>, publicClient: ViemPublicClient, blobSinkClient: BlobSinkClientInterface, searchStartBlock: bigint, searchEndBlock: bigint, logger?: Logger): Promise<RetrievedL2Block[]>;
+export declare function retrieveBlocksFromRollup(rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>, publicClient: ViemPublicClient, debugClient: ViemPublicDebugClient, blobSinkClient: BlobSinkClientInterface, searchStartBlock: bigint, searchEndBlock: bigint, contractAddresses: {
+    governanceProposerAddress: EthAddress;
+    slashFactoryAddress?: EthAddress;
+    slashingProposerAddress: EthAddress;
+}, instrumentation: ArchiverInstrumentation, logger?: Logger): Promise<RetrievedL2Block[]>;
 export declare function getL1BlockTime(publicClient: ViemPublicClient, blockNumber: bigint): Promise<bigint>;
+export declare function getBlockBodyFromBlobs(blobSinkClient: BlobSinkClientInterface, blockHash: string, blobHashes: Buffer<ArrayBufferLike>[], l2BlockNumber: number, logger: Logger): Promise<Body>;
 /** Given an L1 to L2 message, retrieves its corresponding event from the Inbox within a specific block range. */
 export declare function retrieveL1ToL2Message(inbox: GetContractReturnType<typeof InboxAbi, ViemClient>, leaf: Fr, fromBlock: bigint, toBlock: bigint): Promise<InboxMessage | undefined>;
 /**

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

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

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

@@ -1,16 +1,18 @@
 import { Blob, BlobDeserializationError, EMPTY_BLOB_VERSIONED_HASH } from '@aztec/blob-lib';
 import { asyncPool } from '@aztec/foundation/async-pool';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { bufferToHex } from '@aztec/foundation/string';
 import { RollupAbi } from '@aztec/l1-artifacts';
-import { Body, CommitteeAttestation, L2Block, PublishedL2Block } from '@aztec/stdlib/block';
+import { Body, L2Block, PublishedL2Block } from '@aztec/stdlib/block';
 import { Proof } from '@aztec/stdlib/proofs';
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
-import { BlockHeader, GlobalVariables, ProposedBlockHeader, StateReference } from '@aztec/stdlib/tx';
-import { decodeFunctionData, getAbiItem, hexToBytes, multicall3Abi } from 'viem';
-import { NoBlobBodiesFoundError } from './errors.js';
+import { BlockHeader, GlobalVariables } from '@aztec/stdlib/tx';
+import { decodeFunctionData, getAbiItem, hexToBytes } from 'viem';
+import { NoBlobBodiesFoundError } from '../errors.js';
+import { CalldataRetriever } from './calldata_retriever.js';
 export function retrievedBlockToPublishedL2Block(retrievedBlock) {
     const { l2BlockNumber, archiveRoot, stateReference, header: proposedHeader, body, l1, chainId, version, attestations } = retrievedBlock;
     const archive = new AppendOnlyTreeSnapshot(archiveRoot, l2BlockNumber + 1);
@@ -42,12 +44,13 @@ export function retrievedBlockToPublishedL2Block(retrievedBlock) {
 /**
  * Fetches new L2 blocks.
  * @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 rollupAddress - The address of the rollup contract.
  * @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 retrieveBlocksFromRollup(rollup, publicClient, blobSinkClient, searchStartBlock, searchEndBlock, logger = createLogger('archiver')) {
+ */ export async function retrieveBlocksFromRollup(rollup, publicClient, debugClient, blobSinkClient, searchStartBlock, searchEndBlock, contractAddresses, instrumentation, logger = createLogger('archiver')) {
     const retrievedBlocks = [];
     let rollupConstants;
     do {
@@ -75,7 +78,7 @@ export function retrievedBlockToPublishedL2Block(retrievedBlock) {
                 targetCommitteeSize: Number(targetCommitteeSize)
             };
         }
-        const newBlocks = await processL2BlockProposedLogs(rollup, publicClient, blobSinkClient, l2BlockProposedLogs, rollupConstants, logger);
+        const newBlocks = await processL2BlockProposedLogs(rollup, publicClient, debugClient, blobSinkClient, l2BlockProposedLogs, rollupConstants, contractAddresses, instrumentation, logger);
         retrievedBlocks.push(...newBlocks);
         searchStartBlock = lastLog.blockNumber + 1n;
     }while (searchStartBlock <= searchEndBlock)
@@ -86,10 +89,15 @@ export function retrievedBlockToPublishedL2Block(retrievedBlock) {
  * Processes newly received L2BlockProposed logs.
  * @param rollup - The rollup contract
  * @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 logs - L2BlockProposed logs.
  * @returns - An array blocks.
- */ async function processL2BlockProposedLogs(rollup, publicClient, blobSinkClient, logs, { chainId, version, targetCommitteeSize }, logger) {
+ */ async function processL2BlockProposedLogs(rollup, publicClient, debugClient, blobSinkClient, logs, { chainId, version, targetCommitteeSize }, contractAddresses, instrumentation, logger) {
     const retrievedBlocks = [];
+    const calldataRetriever = new CalldataRetriever(publicClient, debugClient, targetCommitteeSize, instrumentation, logger, {
+        ...contractAddresses,
+        rollupAddress: EthAddress.fromString(rollup.address)
+    });
     await asyncPool(10, logs, async (log)=>{
         const l2BlockNumber = Number(log.args.blockNumber);
         const archive = log.args.archive;
@@ -99,14 +107,17 @@ export function retrievedBlockToPublishedL2Block(retrievedBlock) {
         const blobHashes = log.args.versionedBlobHashes.map((blobHash)=>Buffer.from(blobHash.slice(2), 'hex'));
         // The value from the event and contract will match only if the block is in the chain.
         if (archive === archiveFromChain) {
-            const block = await getBlockFromRollupTx(publicClient, blobSinkClient, log.transactionHash, blobHashes, l2BlockNumber, rollup.address, targetCommitteeSize, logger);
+            const blockHeader = await calldataRetriever.getBlockHeaderFromRollupTx(log.transactionHash, l2BlockNumber);
+            const body = await getBlockBodyFromBlobs(blobSinkClient, blockHeader.blockHash, blobHashes, l2BlockNumber, logger);
             const l1 = {
                 blockNumber: log.blockNumber,
                 blockHash: log.blockHash,
                 timestamp: await getL1BlockTime(publicClient, log.blockNumber)
             };
+            const { blockHash: _blockHash, ...blockData } = blockHeader;
             retrievedBlocks.push({
-                ...block,
+                ...blockData,
+                body,
                 l1,
                 chainId,
                 version
@@ -115,7 +126,7 @@ export function retrievedBlockToPublishedL2Block(retrievedBlock) {
                 l1BlockNumber: log.blockNumber,
                 l2BlockNumber,
                 archive: archive.toString(),
-                attestations: block.attestations
+                attestations: blockHeader.attestations
             });
         } else {
             logger.warn(`Ignoring L2 block ${l2BlockNumber} due to archive root mismatch`, {
@@ -133,95 +144,7 @@ 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 block 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 l2BlockNumber - L2 block number.
- * @returns L2 block from the calldata, deserialized
- */ async function getBlockFromRollupTx(publicClient, blobSinkClient, txHash, blobHashes, l2BlockNumber, rollupAddress, targetCommitteeSize, logger) {
-    logger.trace(`Fetching L2 block ${l2BlockNumber} from rollup tx ${txHash}`);
-    const { input: forwarderData, blockHash } = await publicClient.getTransaction({
-        hash: txHash
-    });
-    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}`, {
-        l2BlockNumber,
-        archive: decodedArgs.archive,
-        stateReference: decodedArgs.stateReference,
-        header: decodedArgs.header,
-        l1BlockHash: blockHash,
-        blobHashes,
-        attestations,
-        packedAttestations,
-        targetCommitteeSize
-    });
-    // TODO(md): why is the proposed block header different to the actual block header?
-    // This is likely going to be a footgun
-    const header = ProposedBlockHeader.fromViem(decodedArgs.header);
-    const body = await getBlockBodyFromBlobs(blobSinkClient, blockHash, blobHashes, l2BlockNumber, logger);
-    const archiveRoot = new Fr(Buffer.from(hexToBytes(decodedArgs.archive)));
-    const stateReference = StateReference.fromViem(decodedArgs.stateReference);
-    return {
-        l2BlockNumber,
-        archiveRoot,
-        stateReference,
-        header,
-        body,
-        attestations
-    };
-}
-async function getBlockBodyFromBlobs(blobSinkClient, blockHash, blobHashes, l2BlockNumber, logger) {
+export async function getBlockBodyFromBlobs(blobSinkClient, blockHash, blobHashes, l2BlockNumber, logger) {
     const blobBodies = await blobSinkClient.getBlobSidecar(blockHash, blobHashes);
     logger.trace(`Fetched ${blobBodies.length} blob bodies for L2 block ${l2BlockNumber}`, {
         blobHashes: blobHashes.map(bufferToHex),