@aztec/archiver 0.0.1-commit.9b94fc1 → 0.0.1-commit.9badcec54

package/dest/l1/calldata_retriever.js

@@ -0,0 +1,403 @@
+import { MULTI_CALL_3_ADDRESS } from '@aztec/ethereum/contracts';
+import { LruSet } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { RollupAbi } from '@aztec/l1-artifacts';
+import { CommitteeAttestation } from '@aztec/stdlib/block';
+import { ConsensusPayload, SignatureDomainSeparator } from '@aztec/stdlib/p2p';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { decodeFunctionData, encodeAbiParameters, hexToBytes, keccak256, multicall3Abi, toFunctionSelector } from 'viem';
+import { getSuccessfulCallsFromDebug } from './debug_tx.js';
+import { getCallsFromSpireProposer } 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. Uses hash matching against expected hashes
+ * from the CheckpointProposed event to verify the correct propose calldata.
+ */ export class CalldataRetriever {
+    publicClient;
+    debugClient;
+    targetCommitteeSize;
+    instrumentation;
+    logger;
+    rollupAddress;
+    /** Tx hashes we've already logged for trace+debug failure (log once per tx per process). */ static traceFailureWarnedTxHashes = new LruSet(1000);
+    /** Clears the trace-failure warned set. For testing only. */ static resetTraceFailureWarnedForTesting() {
+        CalldataRetriever.traceFailureWarnedTxHashes.clear();
+    }
+    constructor(publicClient, debugClient, targetCommitteeSize, instrumentation, logger, rollupAddress){
+        this.publicClient = publicClient;
+        this.debugClient = debugClient;
+        this.targetCommitteeSize = targetCommitteeSize;
+        this.instrumentation = instrumentation;
+        this.logger = logger;
+        this.rollupAddress = rollupAddress;
+    }
+    /**
+   * Gets checkpoint 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 blobHashes - Blob hashes for the checkpoint.
+   * @param checkpointNumber - Checkpoint number.
+   * @param expectedHashes - Expected hashes from the CheckpointProposed event for validation
+   * @returns Checkpoint header and metadata from the calldata, deserialized
+   */ async getCheckpointFromRollupTx(txHash, _blobHashes, checkpointNumber, expectedHashes) {
+        this.logger.trace(`Fetching checkpoint ${checkpointNumber} from rollup tx ${txHash}`);
+        const tx = await this.publicClient.getTransaction({
+            hash: txHash
+        });
+        return this.getCheckpointFromTx(tx, checkpointNumber, expectedHashes);
+    }
+    /** Gets checkpoint data from a transaction by trying decode strategies then falling back to trace. */ async getCheckpointFromTx(tx, checkpointNumber, expectedHashes) {
+        // Try to decode as multicall3 with hash-verified matching
+        const multicall3Result = this.tryDecodeMulticall3(tx, expectedHashes, checkpointNumber, tx.blockHash);
+        if (multicall3Result) {
+            this.logger.trace(`Decoded propose calldata from multicall3 for tx ${tx.hash}`);
+            this.instrumentation?.recordBlockProposalTxTarget(tx.to, false);
+            return multicall3Result;
+        }
+        // Try to decode as direct propose call
+        const directResult = this.tryDecodeDirectPropose(tx, expectedHashes, checkpointNumber, tx.blockHash);
+        if (directResult) {
+            this.logger.trace(`Decoded propose calldata from direct call for tx ${tx.hash}`);
+            this.instrumentation?.recordBlockProposalTxTarget(tx.to, false);
+            return directResult;
+        }
+        // Try to decode as Spire Proposer multicall wrapper
+        const spireResult = await this.tryDecodeSpireProposer(tx, expectedHashes, checkpointNumber, tx.blockHash);
+        if (spireResult) {
+            this.logger.trace(`Decoded propose calldata from Spire Proposer for tx ${tx.hash}`);
+            this.instrumentation?.recordBlockProposalTxTarget(tx.to, false);
+            return spireResult;
+        }
+        // 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 checkpoint ${checkpointNumber}`);
+        this.instrumentation?.recordBlockProposalTxTarget(tx.to ?? EthAddress.ZERO.toString(), true);
+        const tracedCalldata = await this.extractCalldataViaTrace(tx.hash);
+        const tracedResult = this.tryDecodeAndVerifyPropose(tracedCalldata, expectedHashes, checkpointNumber, tx.blockHash);
+        if (!tracedResult) {
+            throw new Error(`Hash mismatch for traced propose calldata in tx ${tx.hash} for checkpoint ${checkpointNumber}`);
+        }
+        return tracedResult;
+    }
+    /**
+   * Attempts to decode a transaction as a Spire Proposer multicall wrapper.
+   * If successful, iterates all wrapped calls and validates each as either multicall3
+   * or direct propose, verifying against expected hashes.
+   * @param tx - The transaction to decode
+   * @param expectedHashes - Expected hashes for hash-verified matching
+   * @param checkpointNumber - The checkpoint number
+   * @param blockHash - The L1 block hash
+   * @returns The checkpoint data if successfully decoded and validated, undefined otherwise
+   */ async tryDecodeSpireProposer(tx, expectedHashes, checkpointNumber, blockHash) {
+        // Try to decode as Spire Proposer multicall (extracts all wrapped calls)
+        const spireWrappedCalls = await getCallsFromSpireProposer(tx, this.publicClient, this.logger);
+        if (!spireWrappedCalls) {
+            return undefined;
+        }
+        this.logger.trace(`Decoded Spire Proposer wrapping for tx ${tx.hash}, ${spireWrappedCalls.length} inner call(s)`);
+        // Try each wrapped call as either multicall3 or direct propose
+        for (const spireWrappedCall of spireWrappedCalls){
+            const wrappedTx = {
+                to: spireWrappedCall.to,
+                input: spireWrappedCall.data,
+                hash: tx.hash
+            };
+            const multicall3Result = this.tryDecodeMulticall3(wrappedTx, expectedHashes, checkpointNumber, blockHash);
+            if (multicall3Result) {
+                this.logger.trace(`Decoded propose calldata from Spire Proposer to multicall3 for tx ${tx.hash}`);
+                return multicall3Result;
+            }
+            const directResult = this.tryDecodeDirectPropose(wrappedTx, expectedHashes, checkpointNumber, blockHash);
+            if (directResult) {
+                this.logger.trace(`Decoded propose calldata from Spire Proposer to direct propose for tx ${tx.hash}`);
+                return directResult;
+            }
+        }
+        this.logger.warn(`Spire Proposer wrapped calls 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.
+   * Finds all calls matching the rollup address and propose selector, then decodes
+   * and verifies each candidate against expected hashes from the CheckpointProposed event.
+   * @param tx - The transaction-like object with to, input, and hash
+   * @param expectedHashes - Expected hashes from CheckpointProposed event
+   * @param checkpointNumber - The checkpoint number
+   * @param blockHash - The L1 block hash
+   * @returns The checkpoint data if successfully validated, undefined otherwise
+   */ tryDecodeMulticall3(tx, expectedHashes, checkpointNumber, blockHash) {
+        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;
+            // Find all calls matching rollup address + propose selector
+            const rollupAddressLower = this.rollupAddress.toString().toLowerCase();
+            const proposeSelectorLower = PROPOSE_SELECTOR.toLowerCase();
+            const candidates = [];
+            for (const call of calls){
+                const addr = call.target.toLowerCase();
+                const callData = call.callData;
+                if (callData.length < 10) {
+                    continue;
+                }
+                const selector = callData.slice(0, 10).toLowerCase();
+                if (addr === rollupAddressLower && selector === proposeSelectorLower) {
+                    candidates.push(callData);
+                }
+            }
+            if (candidates.length === 0) {
+                this.logger.debug(`No propose candidates found in multicall3`, {
+                    txHash
+                });
+                return undefined;
+            }
+            // Decode, verify, and build for each candidate
+            const verified = [];
+            for (const candidate of candidates){
+                const result = this.tryDecodeAndVerifyPropose(candidate, expectedHashes, checkpointNumber, blockHash);
+                if (result) {
+                    verified.push(result);
+                }
+            }
+            if (verified.length === 1) {
+                this.logger.trace(`Verified single propose candidate via hash matching`, {
+                    txHash
+                });
+                return verified[0];
+            }
+            if (verified.length > 1) {
+                this.logger.warn(`Multiple propose candidates verified (${verified.length}), returning first (identical data)`, {
+                    txHash
+                });
+                return verified[0];
+            }
+            this.logger.debug(`No candidates verified against expected hashes`, {
+                txHash
+            });
+            return undefined;
+        } 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.
+   * Decodes, verifies hashes, and builds checkpoint data in a single pass.
+   * @param tx - The transaction-like object with to, input, and hash
+   * @param expectedHashes - Expected hashes from CheckpointProposed event
+   * @param checkpointNumber - The checkpoint number
+   * @param blockHash - The L1 block hash
+   * @returns The checkpoint data if successfully validated, undefined otherwise
+   */ tryDecodeDirectPropose(tx, expectedHashes, checkpointNumber, blockHash) {
+        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;
+            }
+            // Validate it's a propose call before full decode+verify
+            const { functionName } = decodeFunctionData({
+                abi: RollupAbi,
+                data: tx.input
+            });
+            if (functionName !== 'propose') {
+                this.logger.warn(`Transaction to rollup is not propose (got ${functionName})`, {
+                    txHash
+                });
+                return undefined;
+            }
+            // Decode, verify hashes, and build checkpoint data
+            this.logger.trace(`Validated direct propose call to rollup`, {
+                txHash
+            });
+            return this.tryDecodeAndVerifyPropose(tx.input, expectedHashes, checkpointNumber, blockHash);
+        } 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.message}`);
+            this.logger.debug(`Trace failure details 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));
+                // Log once per tx so we don't spam on every sync cycle when sync point doesn't advance
+                if (!CalldataRetriever.traceFailureWarnedTxHashes.has(txHash)) {
+                    CalldataRetriever.traceFailureWarnedTxHashes.add(txHash);
+                    this.logger.warn(`Cannot decode L1 tx ${txHash}: trace and debug RPC failed or unavailable. ` + `trace_transaction: ${traceError.message}; debug_traceTransaction: ${debugError.message}`);
+                }
+                // Full error objects can be very long; keep at debug only
+                this.logger.debug(`Trace/debug failure details 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, verifies against expected hashes, and builds checkpoint data.
+   * Returns undefined on decode errors or hash mismatches (soft failure for try-based callers).
+   * @param proposeCalldata - The propose function calldata
+   * @param expectedHashes - Expected hashes from the CheckpointProposed event
+   * @param checkpointNumber - The checkpoint number
+   * @param blockHash - The L1 block hash
+   * @returns The decoded checkpoint data, or undefined on failure
+   */ tryDecodeAndVerifyPropose(proposeCalldata, expectedHashes, checkpointNumber, blockHash) {
+        try {
+            const { functionName, args } = decodeFunctionData({
+                abi: RollupAbi,
+                data: proposeCalldata
+            });
+            if (functionName !== 'propose') {
+                return undefined;
+            }
+            const [decodedArgs, packedAttestations] = args;
+            // Verify attestationsHash
+            const computedAttestationsHash = this.computeAttestationsHash(packedAttestations);
+            if (!Buffer.from(hexToBytes(computedAttestationsHash)).equals(Buffer.from(hexToBytes(expectedHashes.attestationsHash)))) {
+                this.logger.warn(`Attestations hash mismatch during verification`, {
+                    computed: computedAttestationsHash,
+                    expected: expectedHashes.attestationsHash
+                });
+                return undefined;
+            }
+            // Verify payloadDigest
+            const header = CheckpointHeader.fromViem(decodedArgs.header);
+            const archiveRoot = new Fr(Buffer.from(hexToBytes(decodedArgs.archive)));
+            const feeAssetPriceModifier = decodedArgs.oracleInput.feeAssetPriceModifier;
+            const computedPayloadDigest = this.computePayloadDigest(header, archiveRoot, feeAssetPriceModifier);
+            if (!Buffer.from(hexToBytes(computedPayloadDigest)).equals(Buffer.from(hexToBytes(expectedHashes.payloadDigest)))) {
+                this.logger.warn(`Payload digest mismatch during verification`, {
+                    computed: computedPayloadDigest,
+                    expected: expectedHashes.payloadDigest
+                });
+                return undefined;
+            }
+            const attestations = CommitteeAttestation.fromPacked(packedAttestations, this.targetCommitteeSize);
+            this.logger.trace(`Validated and decoded propose calldata for checkpoint ${checkpointNumber}`, {
+                checkpointNumber,
+                archive: decodedArgs.archive,
+                header: decodedArgs.header,
+                l1BlockHash: blockHash,
+                attestations,
+                packedAttestations,
+                targetCommitteeSize: this.targetCommitteeSize
+            });
+            return {
+                checkpointNumber,
+                archiveRoot,
+                header,
+                attestations,
+                blockHash,
+                feeAssetPriceModifier
+            };
+        } catch  {
+            return undefined;
+        }
+    }
+    /** Computes the keccak256 hash of ABI-encoded CommitteeAttestations. */ computeAttestationsHash(packedAttestations) {
+        return keccak256(encodeAbiParameters([
+            this.getCommitteeAttestationsStructDef()
+        ], [
+            packedAttestations
+        ]));
+    }
+    /** Computes the keccak256 payload digest from the checkpoint header, archive root, and fee asset price modifier. */ computePayloadDigest(header, archiveRoot, feeAssetPriceModifier) {
+        const consensusPayload = new ConsensusPayload(header, archiveRoot, feeAssetPriceModifier);
+        const payloadToSign = consensusPayload.getPayloadToSign(SignatureDomainSeparator.checkpointAttestation);
+        return keccak256(payloadToSign);
+    }
+    /**
+   * Extracts the CommitteeAttestations struct definition from RollupAbi.
+   * Finds the _attestations parameter by name in the propose function.
+   */ getCommitteeAttestationsStructDef() {
+        const proposeFunction = RollupAbi.find((item)=>item.type === 'function' && item.name === 'propose');
+        if (!proposeFunction) {
+            throw new Error('propose function not found in RollupAbi');
+        }
+        // Find the _attestations parameter by name, not by index
+        const attestationsParam = proposeFunction.inputs.find((param)=>param.name === '_attestations');
+        if (!attestationsParam) {
+            throw new Error('_attestations parameter not found in propose function');
+        }
+        if (attestationsParam.type !== 'tuple') {
+            throw new Error(`Expected _attestations parameter to be a tuple, got ${attestationsParam.type}`);
+        }
+        // Extract the tuple components (struct fields)
+        const tupleParam = attestationsParam;
+        return {
+            type: 'tuple',
+            components: tupleParam.components || []
+        };
+    }
+}
+/** Function selector for the `propose` method of the rollup contract. */ const PROPOSE_SELECTOR = toFunctionSelector(RollupAbi.find((x)=>x.type === 'function' && x.name === 'propose'));

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;
+    feeAssetPriceModifier: bigint;
+    header: CheckpointHeader;
+    checkpointBlobData: CheckpointBlobData;
+    l1: L1PublishedData;
+    chainId: Fr;
+    version: Fr;
+    attestations: CommitteeAttestation[];
+};
+export declare function retrievedToPublishedCheckpoint({ checkpointNumber, archiveRoot, feeAssetPriceModifier, 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, 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, instrumentation: ArchiverInstrumentation, logger?: Logger, isHistoricalSync?: boolean): Promise<RetrievedCheckpoint[]>;
+export declare function getL1Block(publicClient: ViemPublicClient, blockNumber: bigint): Promise<{
+    timestamp: bigint;
+    parentBeaconBlockRoot: string | undefined;
+}>;
+export declare function getCheckpointBlobDataFromBlobs(blobClient: BlobClientInterface, blockHash: string, blobHashes: Buffer<ArrayBufferLike>[], checkpointNumber: CheckpointNumber, logger: Logger, isHistoricalSync: boolean, parentBeaconBlockRoot?: string, l1BlockTimestamp?: bigint): 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, message: InboxMessage): 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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"}