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

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

@@ -0,0 +1,87 @@
+import { type CheckpointBlobData } from '@aztec/blob-lib';
+import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
+import type { ViemClient, 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 { type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
+import { CommitteeAttestation } from '@aztec/stdlib/block';
+import { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { Proof } from '@aztec/stdlib/proofs';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { type GetContractReturnType, type Hex } from 'viem';
+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 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 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 retrieveCheckpointsFromRollup(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<RetrievedCheckpoint[]>;
+export declare function getL1BlockTime(publicClient: ViemPublicClient, blockNumber: bigint): Promise<bigint>;
+export declare function getCheckpointBlobDataFromBlobs(blobSinkClient: BlobSinkClientInterface, blockHash: string, blobHashes: Buffer<ArrayBufferLike>[], checkpointNumber: CheckpointNumber, logger: Logger): 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: GetContractReturnType<typeof InboxAbi, ViemClient>, leaf: Fr, fromBlock: bigint, toBlock: bigint): Promise<InboxMessage | 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 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: GetContractReturnType<typeof InboxAbi, ViemClient>, 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/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}

@@ -3,16 +3,17 @@ import { asyncPool } from '@aztec/foundation/async-pool';
 import { CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
 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 { Body, L2BlockNew } from '@aztec/stdlib/block';
 import { Checkpoint, 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.
@@ -78,12 +79,13 @@ export async function retrievedToPublishedCheckpoint({ checkpointNumber, archive
 /**
  * Fetches new checkpoints.
  * @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 retrieveCheckpointsFromRollup(rollup, publicClient, blobSinkClient, searchStartBlock, searchEndBlock, logger = createLogger('archiver')) {
+ */ export async function retrieveCheckpointsFromRollup(rollup, publicClient, debugClient, blobSinkClient, searchStartBlock, searchEndBlock, contractAddresses, instrumentation, logger = createLogger('archiver')) {
     const retrievedCheckpoints = [];
     let rollupConstants;
     do {
@@ -111,7 +113,7 @@ export async function retrievedToPublishedCheckpoint({ checkpointNumber, archive
                 targetCommitteeSize: Number(targetCommitteeSize)
             };
         }
-        const newCheckpoints = await processCheckpointProposedLogs(rollup, publicClient, blobSinkClient, checkpointProposedLogs, rollupConstants, logger);
+        const newCheckpoints = await processCheckpointProposedLogs(rollup, publicClient, debugClient, blobSinkClient, checkpointProposedLogs, rollupConstants, contractAddresses, instrumentation, logger);
         retrievedCheckpoints.push(...newCheckpoints);
         searchStartBlock = lastLog.blockNumber + 1n;
     }while (searchStartBlock <= searchEndBlock)
@@ -122,10 +124,15 @@ export async function retrievedToPublishedCheckpoint({ checkpointNumber, archive
  * Processes newly received CheckpointProposed 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 - CheckpointProposed logs.
  * @returns - An array of checkpoints.
- */ async function processCheckpointProposedLogs(rollup, publicClient, blobSinkClient, logs, { chainId, version, targetCommitteeSize }, logger) {
+ */ async function processCheckpointProposedLogs(rollup, publicClient, debugClient, blobSinkClient, logs, { chainId, version, targetCommitteeSize }, contractAddresses, instrumentation, logger) {
     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 = CheckpointNumber.fromBigInt(log.args.checkpointNumber);
         const archive = log.args.archive;
@@ -135,7 +142,8 @@ export async function retrievedToPublishedCheckpoint({ checkpointNumber, archive
         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 checkpoint is in the chain.
         if (archive === archiveFromChain) {
-            const checkpoint = await getCheckpointFromRollupTx(publicClient, blobSinkClient, log.transactionHash, blobHashes, checkpointNumber, rollup.address, targetCommitteeSize, logger);
+            const checkpoint = await calldataRetriever.getCheckpointFromRollupTx(log.transactionHash, blobHashes, checkpointNumber);
+            const checkpointBlobData = await getCheckpointBlobDataFromBlobs(blobSinkClient, checkpoint.blockHash, blobHashes, checkpointNumber, logger);
             const l1 = {
                 blockNumber: log.blockNumber,
                 blockHash: log.blockHash,
@@ -143,6 +151,7 @@ export async function retrievedToPublishedCheckpoint({ checkpointNumber, archive
             };
             retrievedCheckpoints.push({
                 ...checkpoint,
+                checkpointBlobData,
                 l1,
                 chainId,
                 version
@@ -169,79 +178,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 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
-    });
-    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);
+export async function getCheckpointBlobDataFromBlobs(blobSinkClient, blockHash, blobHashes, checkpointNumber, logger) {
     const blobBodies = await blobSinkClient.getBlobSidecar(blockHash, blobHashes);
     if (blobBodies.length === 0) {
         throw new NoBlobBodiesFoundError(checkpointNumber);
@@ -259,14 +196,7 @@ export async function getL1BlockTime(publicClient, blockNumber) {
         // 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({

package/dest/archiver/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVidWdfdHguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcmNoaXZlci9sMS9kZWJ1Z190eC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxjQUFjLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRixPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDM0QsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDcEQsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFXLE1BQU0sMkJBQTJCLENBQUM7QUFHakUsT0FBTyxLQUFLLEVBQUUsR0FBRyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBR2hDLE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUUzQyx1RUFBdUU7QUFDdkUsZUFBTyxNQUFNLGVBQWUsRUFBRSxNQUFNLENBQUMsY0FBYyxDQWFsRCxDQUFDO0FBRUY7Ozs7Ozs7O0dBUUc7QUFDSCx3QkFBc0IsMkJBQTJCLENBQy9DLE1BQU0sRUFBRSxxQkFBcUIsRUFDN0IsTUFBTSxFQUFFLEdBQUcsRUFDWCxhQUFhLEVBQUUsVUFBVSxFQUN6QixnQkFBZ0IsRUFBRSxNQUFNLEVBQ3hCLE1BQU0sQ0FBQyxFQUFFLE1BQU0sR0FDZCxPQUFPLENBQUMsUUFBUSxFQUFFLENBQUMsQ0F3RHJCIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"debug_tx.d.ts","sourceRoot":"","sources":["../../../src/archiver/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/archiver/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/archiver/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BpcmVfcHJvcG9zZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcmNoaXZlci9sMS9zcGlyZV9wcm9wb3Nlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUVwRCxPQUFPLEVBQUUsS0FBSyxHQUFHLEVBQUUsS0FBSyxXQUFXLEVBQXdDLE1BQU0sTUFBTSxDQUFDO0FBR3hGLGVBQU8sTUFBTSxzQkFBc0IsK0NBQStDLENBQUM7QUFDbkYsZUFBTyxNQUFNLHNDQUFzQywrQ0FBK0MsQ0FBQztBQUluRyxlQUFPLE1BQU0sMkJBQTJCLHNFQUN1QyxDQUFDO0FBR2hGLGVBQU8sTUFBTSxnQkFBZ0I7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7RUFxQm5CLENBQUM7QUFFWDs7Ozs7OztHQU9HO0FBQ0gsd0JBQXNCLHlCQUF5QixDQUM3QyxZQUFZLEVBQUU7SUFBRSxZQUFZLEVBQUUsQ0FBQyxNQUFNLEVBQUU7UUFBRSxPQUFPLEVBQUUsR0FBRyxDQUFDO1FBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQTtLQUFFLEtBQUssT0FBTyxDQUFDLEdBQUcsR0FBRyxTQUFTLENBQUMsQ0FBQTtDQUFFLEVBQ2pHLFlBQVksRUFBRSxHQUFHLEVBQ2pCLHNCQUFzQixFQUFFLEdBQUcsRUFDM0IsTUFBTSxFQUFFLE1BQU0sR0FDYixPQUFPLENBQUMsT0FBTyxDQUFDLENBaUNsQjtBQUVEOzs7Ozs7OztHQVFHO0FBQ0gsd0JBQXNCLHdCQUF3QixDQUM1QyxFQUFFLEVBQUUsV0FBVyxFQUNmLFlBQVksRUFBRTtJQUFFLFlBQVksRUFBRSxDQUFDLE1BQU0sRUFBRTtRQUFFLE9BQU8sRUFBRSxHQUFHLENBQUM7UUFBQyxJQUFJLEVBQUUsR0FBRyxDQUFBO0tBQUUsS0FBSyxPQUFPLENBQUMsR0FBRyxHQUFHLFNBQVMsQ0FBQyxDQUFBO0NBQUUsRUFDakcsTUFBTSxFQUFFLE1BQU0sR0FDYixPQUFPLENBQUM7SUFBRSxFQUFFLEVBQUUsR0FBRyxDQUFDO0lBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQTtDQUFFLEdBQUcsU0FBUyxDQUFDLENBNEQ3QyJ9

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

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

package/dest/archiver/l1/spire_proposer.js

@@ -0,0 +1,157 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { decodeFunctionData, getAddress, trim } from 'viem';
+// Spire Proposer Multicall constants
+export const SPIRE_PROPOSER_ADDRESS = '0x9ccc2f3ecde026230e11a5c8799ac7524f2bb294';
+export const SPIRE_PROPOSER_EXPECTED_IMPLEMENTATION = '0x7d38d47e7c82195e6e607d3b0f1c20c615c7bf42';
+// EIP-1967 storage slot for implementation address
+// keccak256("eip1967.proxy.implementation") - 1 = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc
+export const EIP1967_IMPLEMENTATION_SLOT = '0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc';
+// Spire Proposer Multicall ABI
+export const SpireProposerAbi = [
+    {
+        inputs: [
+            {
+                components: [
+                    {
+                        internalType: 'address',
+                        name: 'proposer',
+                        type: 'address'
+                    },
+                    {
+                        internalType: 'address',
+                        name: 'target',
+                        type: 'address'
+                    },
+                    {
+                        internalType: 'bytes',
+                        name: 'data',
+                        type: 'bytes'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'gasLimit',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct IProposerMulticall.Call[]',
+                name: '_calls',
+                type: 'tuple[]'
+            }
+        ],
+        name: 'multicall',
+        outputs: [],
+        stateMutability: 'nonpayable',
+        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 async function verifyProxyImplementation(publicClient, proxyAddress, expectedImplementation, logger) {
+    try {
+        // Read the EIP-1967 implementation slot
+        const implementationData = await publicClient.getStorageAt({
+            address: proxyAddress,
+            slot: EIP1967_IMPLEMENTATION_SLOT
+        });
+        if (!implementationData) {
+            logger.warn(`No implementation found in EIP-1967 slot for proxy ${proxyAddress}`);
+            return false;
+        }
+        // The implementation address is stored in the last 20 bytes of the slot
+        // We need to extract and normalize it for comparison
+        const implementationAddress = getAddress(trim(implementationData));
+        const expectedAddress = getAddress(expectedImplementation);
+        const matches = implementationAddress.toLowerCase() === expectedAddress.toLowerCase();
+        if (!matches) {
+            logger.warn(`Proxy implementation mismatch: expected ${expectedAddress}, got ${implementationAddress}`, {
+                proxyAddress,
+                expectedImplementation,
+                actualImplementation: implementationAddress
+            });
+        }
+        return matches;
+    } catch (err) {
+        logger.warn(`Failed to verify proxy implementation for ${proxyAddress}: ${err}`);
+        return false;
+    }
+}
+/**
+ * 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 async function getCallFromSpireProposer(tx, publicClient, logger) {
+    const txHash = tx.hash;
+    try {
+        // Check if transaction is to the Spire Proposer address
+        if (!tx.to || !EthAddress.areEqual(tx.to, SPIRE_PROPOSER_ADDRESS)) {
+            logger.debug(`Transaction is not to Spire Proposer address (to: ${tx.to})`, {
+                txHash
+            });
+            return undefined;
+        }
+        // Verify the proxy points to the expected implementation
+        const isValidProxy = await verifyProxyImplementation(publicClient, tx.to, SPIRE_PROPOSER_EXPECTED_IMPLEMENTATION, logger);
+        if (!isValidProxy) {
+            logger.warn(`Spire Proposer proxy implementation verification failed`, {
+                txHash,
+                to: tx.to
+            });
+            return undefined;
+        }
+        // Try to decode as Spire Proposer multicall
+        const { functionName: spireFunctionName, args: spireArgs } = decodeFunctionData({
+            abi: SpireProposerAbi,
+            data: tx.input
+        });
+        // If not multicall, return undefined
+        if (spireFunctionName !== 'multicall') {
+            logger.warn(`Transaction to Spire Proposer is not multicall (got ${spireFunctionName})`, {
+                txHash
+            });
+            return undefined;
+        }
+        if (spireArgs.length !== 1) {
+            logger.warn(`Unexpected number of arguments for Spire Proposer multicall (got ${spireArgs.length})`, {
+                txHash
+            });
+            return undefined;
+        }
+        const [calls] = spireArgs;
+        // Validate exactly ONE call (see ./README.md for rationale)
+        if (calls.length !== 1) {
+            logger.warn(`Spire Proposer multicall must contain exactly one call (got ${calls.length})`, {
+                txHash
+            });
+            return undefined;
+        }
+        const call = calls[0];
+        // Successfully extracted the single wrapped call
+        logger.trace(`Decoded Spire Proposer with single call to ${call.target}`, {
+            txHash
+        });
+        return {
+            to: call.target,
+            data: call.data
+        };
+    } catch (err) {
+        // Any decoding error triggers fallback to trace
+        logger.warn(`Failed to decode Spire Proposer: ${err}`, {
+            txHash
+        });
+        return undefined;
+    }
+}