@aztec/archiver 2.1.8 → 2.1.9

package/src/archiver/{data_retrieval.ts → l1/data_retrieval.ts}

@@ -1,17 +1,9 @@
 import { Blob, BlobDeserializationError, EMPTY_BLOB_VERSIONED_HASH } from '@aztec/blob-lib';
 import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
-import type {
-  EpochProofPublicInputArgs,
-  ViemClient,
-  ViemCommitteeAttestations,
-  ViemHeader,
-  ViemPublicClient,
-  ViemStateReference,
-} from '@aztec/ethereum';
+import type { EpochProofPublicInputArgs, ViemClient, ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum';
 import { asyncPool } from '@aztec/foundation/async-pool';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { ViemSignature } from '@aztec/foundation/eth-signature';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { bufferToHex } from '@aztec/foundation/string';
@@ -28,13 +20,14 @@ import {
   decodeFunctionData,
   getAbiItem,
   hexToBytes,
-  multicall3Abi,
 } from 'viem';
 
-import { NoBlobBodiesFoundError } from './errors.js';
-import type { DataRetrieval } from './structs/data_retrieval.js';
-import type { InboxMessage } from './structs/inbox_message.js';
-import type { L1PublishedData } from './structs/published.js';
+import { NoBlobBodiesFoundError } from '../errors.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';
+import { CalldataRetriever } from './calldata_retriever.js';
 
 export type RetrievedL2Block = {
   l2BlockNumber: number;
@@ -94,6 +87,7 @@ export function retrievedBlockToPublishedL2Block(retrievedBlock: RetrievedL2Bloc
 /**
  * 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.
@@ -103,9 +97,16 @@ export function retrievedBlockToPublishedL2Block(retrievedBlock: RetrievedL2Bloc
 export async 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 = createLogger('archiver'),
 ): Promise<RetrievedL2Block[]> {
   const retrievedBlocks: RetrievedL2Block[] = [];
@@ -151,9 +152,12 @@ export async function retrieveBlocksFromRollup(
     const newBlocks = await processL2BlockProposedLogs(
       rollup,
       publicClient,
+      debugClient,
       blobSinkClient,
       l2BlockProposedLogs,
       rollupConstants,
+      contractAddresses,
+      instrumentation,
       logger,
     );
     retrievedBlocks.push(...newBlocks);
@@ -168,18 +172,35 @@ export async function retrieveBlocksFromRollup(
  * 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: GetContractReturnType<typeof RollupAbi, ViemPublicClient>,
   publicClient: ViemPublicClient,
+  debugClient: ViemPublicDebugClient,
   blobSinkClient: BlobSinkClientInterface,
   logs: GetContractEventsReturnType<typeof RollupAbi, 'L2BlockProposed'>,
   { chainId, version, targetCommitteeSize }: { chainId: Fr; version: Fr; targetCommitteeSize: number },
+  contractAddresses: {
+    governanceProposerAddress: EthAddress;
+    slashFactoryAddress?: EthAddress;
+    slashingProposerAddress: EthAddress;
+  },
+  instrumentation: ArchiverInstrumentation,
   logger: Logger,
 ): Promise<RetrievedL2Block[]> {
   const retrievedBlocks: RetrievedL2Block[] = [];
+  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!;
@@ -188,14 +209,13 @@ async function processL2BlockProposedLogs(
 
     // 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,
+      const blockHeader = await calldataRetriever.getBlockHeaderFromRollupTx(log.transactionHash!, l2BlockNumber);
+
+      const body = await getBlockBodyFromBlobs(
         blobSinkClient,
-        log.transactionHash!,
+        blockHeader.blockHash,
         blobHashes,
         l2BlockNumber,
-        rollup.address,
-        targetCommitteeSize,
         logger,
       );
 
@@ -205,12 +225,13 @@ async function processL2BlockProposedLogs(
         timestamp: await getL1BlockTime(publicClient, log.blockNumber),
       };
 
-      retrievedBlocks.push({ ...block, l1, chainId, version });
+      const { blockHash: _blockHash, ...blockData } = blockHeader;
+      retrievedBlocks.push({ ...blockData, body, l1, chainId, version });
       logger.trace(`Retrieved L2 block ${l2BlockNumber} from L1 tx ${log.transactionHash}`, {
         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`, {
@@ -228,144 +249,13 @@ export async function getL1BlockTime(publicClient: ViemPublicClient, 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: Hex, rollupAddress: Hex): Hex {
-  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 {
-      // Skip invalid function data
-      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: ViemPublicClient,
-  blobSinkClient: BlobSinkClientInterface,
-  txHash: `0x${string}`,
-  blobHashes: Buffer[], // TODO(md): buffer32?
-  l2BlockNumber: number,
-  rollupAddress: Hex,
-  targetCommitteeSize: number,
-  logger: Logger,
-): Promise<Omit<RetrievedL2Block, 'l1' | 'chainId' | 'version'>> {
-  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! as readonly [
-    {
-      archive: Hex;
-      stateReference: ViemStateReference;
-      oracleInput: {
-        feeAssetPriceModifier: bigint;
-      };
-      header: ViemHeader;
-      txHashes: readonly Hex[];
-    },
-    ViemCommitteeAttestations,
-    Hex[],
-    ViemSignature,
-    Hex,
-  ];
-
-  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(
+export async function getBlockBodyFromBlobs(
   blobSinkClient: BlobSinkClientInterface,
   blockHash: string,
   blobHashes: Buffer<ArrayBufferLike>[],
   l2BlockNumber: number,
   logger: Logger,
-) {
+): Promise<Body> {
   const blobBodies = await blobSinkClient.getBlobSidecar(blockHash, blobHashes);
   logger.trace(`Fetched ${blobBodies.length} blob bodies for L2 block ${l2BlockNumber}`, {
     blobHashes: blobHashes.map(bufferToHex),

package/src/archiver/l1/debug_tx.ts

@@ -0,0 +1,99 @@
+import type { DebugCallTrace, ViemPublicDebugClient } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { Logger } from '@aztec/foundation/log';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import { withHexPrefix } from '@aztec/foundation/string';
+
+import type { Hex } from 'viem';
+import { z } from 'zod';
+
+import type { CallInfo } from './types.js';
+
+/** Zod schema for validating call trace from debug_traceTransaction */
+export const callTraceSchema: ZodFor<DebugCallTrace> = 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: ViemPublicDebugClient,
+  txHash: Hex,
+  targetAddress: EthAddress,
+  functionSelector: string,
+  logger?: Logger,
+): Promise<CallInfo[]> {
+  // 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: CallInfo[] = [];
+
+  /**
+   * Recursively traverse the call trace tree
+   */
+  function traverseCalls(callTrace: DebugCallTrace) {
+    // 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/src/archiver/l1/spire_proposer.ts

@@ -0,0 +1,160 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { Logger } from '@aztec/foundation/log';
+
+import { type Hex, type Transaction, 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' as const;
+
+// 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',
+  },
+] as const;
+
+/**
+ * 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: { getStorageAt: (params: { address: Hex; slot: Hex }) => Promise<Hex | undefined> },
+  proxyAddress: Hex,
+  expectedImplementation: Hex,
+  logger: Logger,
+): Promise<boolean> {
+  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: Transaction,
+  publicClient: { getStorageAt: (params: { address: Hex; slot: Hex }) => Promise<Hex | undefined> },
+  logger: Logger,
+): Promise<{ to: Hex; data: Hex } | undefined> {
+  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 as Hex,
+      SPIRE_PROPOSER_EXPECTED_IMPLEMENTATION as Hex,
+      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;
+  }
+}

package/src/archiver/l1/trace_tx.ts

@@ -0,0 +1,128 @@
+import type { ViemPublicDebugClient } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { Logger } from '@aztec/foundation/log';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import { withHexPrefix } from '@aztec/foundation/string';
+
+import type { Hex } from 'viem';
+import { z } from 'zod';
+
+import type { CallInfo } from './types.js';
+
+/** Zod schema for trace action from trace_transaction */
+const traceActionSchema = z.object({
+  from: schemas.HexStringWith0x,
+  to: schemas.HexStringWith0x.optional(),
+  callType: z.string(),
+  gas: schemas.HexStringWith0x.optional(),
+  input: schemas.HexStringWith0x.optional(),
+  value: schemas.HexStringWith0x.optional(),
+});
+
+/** Zod schema for trace result from trace_transaction */
+const traceResultSchema = z.object({
+  gasUsed: schemas.HexStringWith0x.optional(),
+  output: schemas.HexStringWith0x.optional(),
+});
+
+/** Zod schema for a single trace from trace_transaction */
+export const traceSchema = z.object({
+  action: traceActionSchema,
+  result: traceResultSchema.optional(),
+  error: z.string().optional(),
+  subtraces: z.number(),
+  traceAddress: z.array(z.number()),
+  type: z.string(),
+});
+
+/** Type for trace_transaction response */
+type TraceTransaction = z.infer<typeof traceSchema>;
+
+/** Zod schema for the full trace_transaction response (array of traces) */
+export const traceTransactionResponseSchema: ZodFor<TraceTransaction[]> = z.array(traceSchema);
+
+/**
+ * Traces a transaction and extracts all CALL operations to a specific contract and function selector.
+ * Uses the trace_transaction RPC method which returns a flat array of traces.
+ *
+ * @param client - The Viem public debug 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 getSuccessfulCallsFromTrace(
+  client: ViemPublicDebugClient,
+  txHash: Hex,
+  targetAddress: EthAddress,
+  functionSelector: string,
+  logger?: Logger,
+): Promise<CallInfo[]> {
+  // Normalize inputs for comparison
+  const normalizedTarget = targetAddress.toString().toLowerCase();
+  const normalizedSelector = withHexPrefix(functionSelector.toLowerCase());
+
+  // Call trace_transaction (no options needed)
+  const rawTrace = await client.request({
+    method: 'trace_transaction',
+    params: [txHash],
+  });
+
+  if (rawTrace === null || rawTrace === undefined) {
+    throw new Error(`Failed to retrieve trace_transaction for ${txHash}`);
+  }
+
+  logger?.trace(`Retrieved trace_transaction for ${txHash}`, { trace: rawTrace });
+
+  // Validate the response with zod
+  const traces = traceTransactionResponseSchema.parse(rawTrace);
+
+  const results: CallInfo[] = [];
+
+  // Build a set of trace addresses that errored - we should skip their descendants
+  // A trace address is the path in the trace tree, represented as an array of indices
+  const erroredTraceAddresses = new Set<string>();
+  for (const trace of traces) {
+    if (trace.error) {
+      erroredTraceAddresses.add(JSON.stringify(trace.traceAddress));
+    }
+  }
+
+  // Helper to check if a trace is a descendant of an errored trace
+  function isDescendantOfError(traceAddress: number[]): boolean {
+    // Check all possible ancestor paths
+    for (let i = 1; i < traceAddress.length; i++) {
+      const ancestorAddress = traceAddress.slice(0, i);
+      if (erroredTraceAddresses.has(JSON.stringify(ancestorAddress))) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Process each trace
+  for (const trace of traces) {
+    // Skip if this has an error or is a descendant of an errored trace
+    if (trace.error || isDescendantOfError(trace.traceAddress)) {
+      continue;
+    }
+
+    // Check if this is a CALL type trace to the target address with matching selector and result
+    if (
+      trace.type === 'call' &&
+      trace.action.callType.toLowerCase() === 'call' &&
+      trace.action.to?.toLowerCase() === normalizedTarget &&
+      trace.action.input?.toLowerCase().startsWith(normalizedSelector) &&
+      trace.result
+    ) {
+      results.push({
+        from: EthAddress.fromString(trace.action.from),
+        gasUsed: trace.result.gasUsed === undefined ? undefined : BigInt(trace.result.gasUsed),
+        input: trace.action.input,
+        value: trace.action.value ? BigInt(trace.action.value) : 0n,
+      });
+    }
+  }
+
+  return results;
+}

package/src/archiver/l1/types.ts

@@ -0,0 +1,13 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+
+import type { Hex } from 'viem';
+
+/**
+ * Information about a matching CALL
+ */
+export interface CallInfo {
+  from: EthAddress;
+  gasUsed?: bigint;
+  input: Hex;
+  value: bigint;
+}