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

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

@@ -1,3 +1,4 @@
+import type { BlobClientInterface } from '@aztec/blob-client/client';
 import {
   BlobDeserializationError,
   type CheckpointBlobData,
@@ -5,45 +6,37 @@ import {
   decodeCheckpointBlobDataFromBlobs,
   encodeBlockBlobData,
 } from '@aztec/blob-lib';
-import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
 import type {
+  CheckpointProposedLog,
   EpochProofPublicInputArgs,
-  ViemClient,
-  ViemCommitteeAttestations,
-  ViemHeader,
-  ViemPublicClient,
-} from '@aztec/ethereum';
+  InboxContract,
+  MessageSentLog,
+  RollupContract,
+} from '@aztec/ethereum/contracts';
+import type { ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/types';
 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 { Fr } from '@aztec/foundation/fields';
+import { CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
-import { Body, CommitteeAttestation, L2BlockNew } from '@aztec/stdlib/block';
-import { Checkpoint, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { RollupAbi } from '@aztec/l1-artifacts';
+import { Body, CommitteeAttestation, L2Block } from '@aztec/stdlib/block';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { Proof } from '@aztec/stdlib/proofs';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
 import { BlockHeader, GlobalVariables, PartialStateReference, StateReference } from '@aztec/stdlib/tx';
 
-import {
-  type GetContractEventsReturnType,
-  type GetContractReturnType,
-  type Hex,
-  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 { type Hex, decodeFunctionData, getAbiItem, hexToBytes } from 'viem';
+
+import { NoBlobBodiesFoundError } from '../errors.js';
+import type { ArchiverInstrumentation } from '../modules/instrumentation.js';
+import type { DataRetrieval } from '../structs/data_retrieval.js';
+import type { InboxMessage } from '../structs/inbox_message.js';
+import { CalldataRetriever } from './calldata_retriever.js';
 
 export type RetrievedCheckpoint = {
-  checkpointNumber: number;
+  checkpointNumber: CheckpointNumber;
   archiveRoot: Fr;
   header: CheckpointHeader;
   checkpointBlobData: CheckpointBlobData;
@@ -71,12 +64,12 @@ export async function retrievedToPublishedCheckpoint({
     .slice(1)
     .concat([archiveRoot]);
 
-  // `blocksBlobData` is created from `decodeCheckpointBlobDataFromBlobs`. An error will be thrown if it can't read a
-  // field for the `l1ToL2MessageRoot` of the first block. So below we can safely assume it exists:
+  // An error will be thrown from `decodeCheckpointBlobDataFromBlobs` if it can't read a field for the
+  // `l1ToL2MessageRoot` of the first block. So below we can safely assume it exists:
   const l1toL2MessageTreeRoot = blocksBlobData[0].l1ToL2MessageRoot!;
 
   const spongeBlob = SpongeBlob.init();
-  const l2Blocks: L2BlockNew[] = [];
+  const l2Blocks: L2Block[] = [];
   for (let i = 0; i < blocksBlobData.length; i++) {
     const blockBlobData = blocksBlobData[i];
     const { blockEndMarker, blockEndStateField, lastArchiveRoot, noteHashRoot, nullifierRoot, publicDataRoot } =
@@ -126,7 +119,7 @@ export async function retrievedToPublishedCheckpoint({
 
     const newArchive = new AppendOnlyTreeSnapshot(newArchiveRoots[i], l2BlockNumber + 1);
 
-    l2Blocks.push(new L2BlockNew(newArchive, header, body));
+    l2Blocks.push(new L2Block(newArchive, header, body, checkpointNumber, IndexWithinCheckpoint(i)));
   }
 
   const lastBlock = l2Blocks.at(-1)!;
@@ -142,20 +135,33 @@ export async function retrievedToPublishedCheckpoint({
 
 /**
  * Fetches new checkpoints.
+ * @param rollup - The rollup contract wrapper.
  * @param publicClient - The viem public client to use for transaction retrieval.
- * @param rollupAddress - The address of the rollup contract.
+ * @param debugClient - The viem debug client to use for trace/debug RPC methods (optional).
+ * @param blobClient - The blob client client for fetching blob data.
  * @param searchStartBlock - The block number to use for starting the search.
  * @param searchEndBlock - The highest block number that we should search up to.
- * @param expectedNextL2BlockNum - The next L2 block number that we expect to find.
- * @returns An array of block; as well as the next eth block to search from.
+ * @param contractAddresses - The contract addresses (governanceProposerAddress, slashFactoryAddress, slashingProposerAddress).
+ * @param instrumentation - The archiver instrumentation instance.
+ * @param logger - The logger instance.
+ * @param isHistoricalSync - Whether this is a historical sync.
+ * @returns An array of retrieved checkpoints.
  */
 export async function retrieveCheckpointsFromRollup(
-  rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>,
+  rollup: RollupContract,
   publicClient: ViemPublicClient,
-  blobSinkClient: BlobSinkClientInterface,
+  debugClient: ViemPublicDebugClient,
+  blobClient: BlobClientInterface,
   searchStartBlock: bigint,
   searchEndBlock: bigint,
+  contractAddresses: {
+    governanceProposerAddress: EthAddress;
+    slashFactoryAddress?: EthAddress;
+    slashingProposerAddress: EthAddress;
+  },
+  instrumentation: ArchiverInstrumentation,
   logger: Logger = createLogger('archiver'),
+  isHistoricalSync: boolean = false,
 ): Promise<RetrievedCheckpoint[]> {
   const retrievedCheckpoints: RetrievedCheckpoint[] = [];
 
@@ -165,15 +171,7 @@ export async function retrieveCheckpointsFromRollup(
     if (searchStartBlock > searchEndBlock) {
       break;
     }
-    const checkpointProposedLogs = (
-      await rollup.getEvents.CheckpointProposed(
-        {},
-        {
-          fromBlock: searchStartBlock,
-          toBlock: searchEndBlock,
-        },
-      )
-    ).filter(log => log.blockNumber! >= searchStartBlock && log.blockNumber! <= searchEndBlock);
+    const checkpointProposedLogs = await rollup.getCheckpointProposedEvents(searchStartBlock, searchEndBlock);
 
     if (checkpointProposedLogs.length === 0) {
       break;
@@ -181,32 +179,36 @@ export async function retrieveCheckpointsFromRollup(
 
     const lastLog = checkpointProposedLogs.at(-1)!;
     logger.debug(
-      `Got ${checkpointProposedLogs.length} processed logs for checkpoints  ${checkpointProposedLogs[0].args.checkpointNumber}-${lastLog.args.checkpointNumber} between L1 blocks ${searchStartBlock}-${searchEndBlock}`,
+      `Got ${checkpointProposedLogs.length} processed logs for checkpoints ${checkpointProposedLogs[0].args.checkpointNumber}-${lastLog.args.checkpointNumber} between L1 blocks ${searchStartBlock}-${searchEndBlock}`,
     );
 
     if (rollupConstants === undefined) {
       const [chainId, version, targetCommitteeSize] = await Promise.all([
         publicClient.getChainId(),
-        rollup.read.getVersion(),
-        rollup.read.getTargetCommitteeSize(),
+        rollup.getVersion(),
+        rollup.getTargetCommitteeSize(),
       ]);
       rollupConstants = {
         chainId: new Fr(chainId),
         version: new Fr(version),
-        targetCommitteeSize: Number(targetCommitteeSize),
+        targetCommitteeSize,
       };
     }
 
     const newCheckpoints = await processCheckpointProposedLogs(
       rollup,
       publicClient,
-      blobSinkClient,
+      debugClient,
+      blobClient,
       checkpointProposedLogs,
       rollupConstants,
+      contractAddresses,
+      instrumentation,
       logger,
+      isHistoricalSync,
     );
     retrievedCheckpoints.push(...newCheckpoints);
-    searchStartBlock = lastLog.blockNumber! + 1n;
+    searchStartBlock = lastLog.l1BlockNumber + 1n;
   } while (searchStartBlock <= searchEndBlock);
 
   // The asyncPool from processCheckpointProposedLogs will not necessarily return the checkpoints in order, so we sort them before returning.
@@ -215,56 +217,90 @@ export async function retrieveCheckpointsFromRollup(
 
 /**
  * Processes newly received CheckpointProposed logs.
- * @param rollup - The rollup contract
+ * @param rollup - The rollup contract wrapper.
  * @param publicClient - The viem public client to use for transaction retrieval.
+ * @param debugClient - The viem debug client to use for trace/debug RPC methods (optional).
+ * @param blobClient - The blob client client for fetching blob data.
  * @param logs - CheckpointProposed logs.
- * @returns - An array of checkpoints.
+ * @param rollupConstants - The rollup constants (chainId, version, targetCommitteeSize).
+ * @param contractAddresses - The contract addresses (governanceProposerAddress, slashFactoryAddress, slashingProposerAddress).
+ * @param instrumentation - The archiver instrumentation instance.
+ * @param logger - The logger instance.
+ * @param isHistoricalSync - Whether this is a historical sync.
+ * @returns An array of retrieved checkpoints.
  */
 async function processCheckpointProposedLogs(
-  rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>,
+  rollup: RollupContract,
   publicClient: ViemPublicClient,
-  blobSinkClient: BlobSinkClientInterface,
-  logs: GetContractEventsReturnType<typeof RollupAbi, 'CheckpointProposed'>,
+  debugClient: ViemPublicDebugClient,
+  blobClient: BlobClientInterface,
+  logs: CheckpointProposedLog[],
   { chainId, version, targetCommitteeSize }: { chainId: Fr; version: Fr; targetCommitteeSize: number },
+  contractAddresses: {
+    governanceProposerAddress: EthAddress;
+    slashFactoryAddress?: EthAddress;
+    slashingProposerAddress: EthAddress;
+  },
+  instrumentation: ArchiverInstrumentation,
   logger: Logger,
+  isHistoricalSync: boolean,
 ): Promise<RetrievedCheckpoint[]> {
   const retrievedCheckpoints: RetrievedCheckpoint[] = [];
+  const calldataRetriever = new CalldataRetriever(
+    publicClient,
+    debugClient,
+    targetCommitteeSize,
+    instrumentation,
+    logger,
+    { ...contractAddresses, rollupAddress: EthAddress.fromString(rollup.address) },
+  );
+
   await asyncPool(10, logs, async log => {
-    const checkpointNumber = Number(log.args.checkpointNumber!);
-    const archive = log.args.archive!;
-    const archiveFromChain = await rollup.read.archiveAt([BigInt(checkpointNumber)]);
-    const blobHashes = log.args.versionedBlobHashes!.map(blobHash => Buffer.from(blobHash.slice(2), 'hex'));
+    const checkpointNumber = log.args.checkpointNumber;
+    const archive = log.args.archive;
+    const archiveFromChain = await rollup.archiveAt(checkpointNumber);
+    const blobHashes = log.args.versionedBlobHashes;
 
     // The value from the event and contract will match only if the checkpoint is in the chain.
-    if (archive === archiveFromChain) {
-      const checkpoint = await getCheckpointFromRollupTx(
-        publicClient,
-        blobSinkClient,
-        log.transactionHash!,
+    if (archive.equals(archiveFromChain)) {
+      // Build expected hashes object (fields may be undefined for backwards compatibility with older events)
+      const expectedHashes = {
+        attestationsHash: log.args.attestationsHash?.toString(),
+        payloadDigest: log.args.payloadDigest?.toString(),
+      };
+
+      const checkpoint = await calldataRetriever.getCheckpointFromRollupTx(
+        log.l1TransactionHash,
+        blobHashes,
+        checkpointNumber,
+        expectedHashes,
+      );
+      const checkpointBlobData = await getCheckpointBlobDataFromBlobs(
+        blobClient,
+        checkpoint.blockHash,
         blobHashes,
         checkpointNumber,
-        rollup.address,
-        targetCommitteeSize,
         logger,
+        isHistoricalSync,
       );
 
-      const l1: L1PublishedData = {
-        blockNumber: log.blockNumber,
-        blockHash: log.blockHash,
-        timestamp: await getL1BlockTime(publicClient, log.blockNumber),
-      };
+      const l1 = new L1PublishedData(
+        log.l1BlockNumber,
+        await getL1BlockTime(publicClient, log.l1BlockNumber),
+        log.l1BlockHash.toString(),
+      );
 
-      retrievedCheckpoints.push({ ...checkpoint, l1, chainId, version });
-      logger.trace(`Retrieved checkpoint ${checkpointNumber} from L1 tx ${log.transactionHash}`, {
-        l1BlockNumber: log.blockNumber,
+      retrievedCheckpoints.push({ ...checkpoint, checkpointBlobData, l1, chainId, version });
+      logger.trace(`Retrieved checkpoint ${checkpointNumber} from L1 tx ${log.l1TransactionHash}`, {
+        l1BlockNumber: log.l1BlockNumber,
         checkpointNumber,
         archive: archive.toString(),
         attestations: checkpoint.attestations,
       });
     } else {
       logger.warn(`Ignoring checkpoint ${checkpointNumber} due to archive root mismatch`, {
-        actual: archive,
-        expected: archiveFromChain,
+        actual: archive.toString(),
+        expected: archiveFromChain.toString(),
       });
     }
   });
@@ -277,118 +313,15 @@ 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 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: ViemPublicClient,
-  blobSinkClient: BlobSinkClientInterface,
-  txHash: `0x${string}`,
-  blobHashes: Buffer[], // TODO(md): buffer32?
-  checkpointNumber: number,
-  rollupAddress: Hex,
-  targetCommitteeSize: number,
+export async function getCheckpointBlobDataFromBlobs(
+  blobClient: BlobClientInterface,
+  blockHash: string,
+  blobHashes: Buffer<ArrayBufferLike>[],
+  checkpointNumber: CheckpointNumber,
   logger: Logger,
-): Promise<Omit<RetrievedCheckpoint, 'l1' | 'chainId' | 'version'>> {
-  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! as readonly [
-    {
-      archive: Hex;
-      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}`, {
-    checkpointNumber,
-    archive: decodedArgs.archive,
-    header: decodedArgs.header,
-    l1BlockHash: blockHash,
-    blobHashes,
-    attestations,
-    packedAttestations,
-    targetCommitteeSize,
-  });
-
-  const header = CheckpointHeader.fromViem(decodedArgs.header);
-  const blobBodies = await blobSinkClient.getBlobSidecar(blockHash, blobHashes);
+  isHistoricalSync: boolean,
+): Promise<CheckpointBlobData> {
+  const blobBodies = await blobClient.getBlobSidecar(blockHash, blobHashes, { isHistoricalSync });
   if (blobBodies.length === 0) {
     throw new NoBlobBodiesFoundError(checkpointNumber);
   }
@@ -396,35 +329,28 @@ async function getCheckpointFromRollupTx(
   let checkpointBlobData: CheckpointBlobData;
   try {
     // Attempt to decode the checkpoint blob data.
-    checkpointBlobData = decodeCheckpointBlobDataFromBlobs(blobBodies.map(b => b.blob));
+    checkpointBlobData = decodeCheckpointBlobDataFromBlobs(blobBodies);
   } catch (err: any) {
     if (err instanceof BlobDeserializationError) {
       logger.fatal(err.message);
     } else {
       logger.fatal('Unable to sync: failed to decode fetched blob, this blob was likely not created by us');
     }
+    // Throwing an error since this is most likely caused by a bug.
     throw err;
   }
 
-  const archiveRoot = new Fr(Buffer.from(hexToBytes(decodedArgs.archive)));
-
-  return {
-    checkpointNumber,
-    archiveRoot,
-    header,
-    checkpointBlobData,
-    attestations,
-  };
+  return checkpointBlobData;
 }
 
 /** Given an L1 to L2 message, retrieves its corresponding event from the Inbox within a specific block range. */
 export async function retrieveL1ToL2Message(
-  inbox: GetContractReturnType<typeof InboxAbi, ViemClient>,
+  inbox: InboxContract,
   leaf: Fr,
   fromBlock: bigint,
   toBlock: bigint,
 ): Promise<InboxMessage | undefined> {
-  const logs = await inbox.getEvents.MessageSent({ hash: leaf.toString() }, { fromBlock, toBlock });
+  const logs = await inbox.getMessageSentEventByHash(leaf.toString(), fromBlock, toBlock);
 
   const messages = mapLogsInboxMessage(logs);
   return messages.length > 0 ? messages[0] : undefined;
@@ -432,47 +358,40 @@ export async function retrieveL1ToL2Message(
 
 /**
  * Fetch L1 to L2 messages.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param inboxAddress - The address of the inbox contract to fetch messages from.
- * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
+ * @param inbox - The inbox contract wrapper.
  * @param searchStartBlock - The block number to use for starting the search.
  * @param searchEndBlock - The highest block number that we should search up to.
  * @returns An array of InboxLeaf and next eth block to search from.
  */
 export async function retrieveL1ToL2Messages(
-  inbox: GetContractReturnType<typeof InboxAbi, ViemClient>,
+  inbox: InboxContract,
   searchStartBlock: bigint,
   searchEndBlock: bigint,
 ): Promise<InboxMessage[]> {
   const retrievedL1ToL2Messages: InboxMessage[] = [];
   while (searchStartBlock <= searchEndBlock) {
-    const messageSentLogs = (
-      await inbox.getEvents.MessageSent({}, { fromBlock: searchStartBlock, toBlock: searchEndBlock })
-    ).filter(log => log.blockNumber! >= searchStartBlock && log.blockNumber! <= searchEndBlock);
+    const messageSentLogs = await inbox.getMessageSentEvents(searchStartBlock, searchEndBlock);
 
     if (messageSentLogs.length === 0) {
       break;
     }
 
     retrievedL1ToL2Messages.push(...mapLogsInboxMessage(messageSentLogs));
-    searchStartBlock = messageSentLogs.at(-1)!.blockNumber + 1n;
+    searchStartBlock = messageSentLogs.at(-1)!.l1BlockNumber + 1n;
   }
 
   return retrievedL1ToL2Messages;
 }
 
-function mapLogsInboxMessage(logs: GetContractEventsReturnType<typeof InboxAbi, 'MessageSent'>): InboxMessage[] {
-  return logs.map(log => {
-    const { index, hash, checkpointNumber, rollingHash } = log.args;
-    return {
-      index: index!,
-      leaf: Fr.fromHexString(hash!),
-      l1BlockNumber: log.blockNumber,
-      l1BlockHash: Buffer32.fromString(log.blockHash),
-      l2BlockNumber: Number(checkpointNumber!),
-      rollingHash: Buffer16.fromString(rollingHash!),
-    };
-  });
+function mapLogsInboxMessage(logs: MessageSentLog[]): InboxMessage[] {
+  return logs.map(log => ({
+    index: log.args.index,
+    leaf: log.args.leaf,
+    l1BlockNumber: log.l1BlockNumber,
+    l1BlockHash: log.l1BlockHash,
+    checkpointNumber: log.args.checkpointNumber,
+    rollingHash: log.args.rollingHash,
+  }));
 }
 
 /** Retrieves L2ProofVerified events from the rollup contract. */
@@ -481,7 +400,7 @@ export async function retrieveL2ProofVerifiedEvents(
   rollupAddress: EthAddress,
   searchStartBlock: bigint,
   searchEndBlock?: bigint,
-): Promise<{ l1BlockNumber: bigint; checkpointNumber: number; proverId: Fr; txHash: Hex }[]> {
+): Promise<{ l1BlockNumber: bigint; checkpointNumber: CheckpointNumber; proverId: Fr; txHash: Hex }[]> {
   const logs = await publicClient.getLogs({
     address: rollupAddress.toString(),
     fromBlock: searchStartBlock,
@@ -492,7 +411,7 @@ export async function retrieveL2ProofVerifiedEvents(
 
   return logs.map(log => ({
     l1BlockNumber: log.blockNumber,
-    checkpointNumber: Number(log.args.checkpointNumber),
+    checkpointNumber: CheckpointNumber.fromBigInt(log.args.checkpointNumber),
     proverId: Fr.fromHexString(log.args.proverId),
     txHash: log.transactionHash,
   }));

package/src/l1/debug_tx.ts

@@ -0,0 +1,99 @@
+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, 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;
+}