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

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;
+    }
+}

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

@@ -0,0 +1,97 @@
+import type { 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 { z } from 'zod';
+import type { CallInfo } from './types.js';
+/** Zod schema for a single trace from trace_transaction */
+export declare const traceSchema: z.ZodObject<{
+    action: z.ZodObject<{
+        from: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, `0x${string}`, string>;
+        to: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, `0x${string}`, string>>;
+        callType: z.ZodString;
+        gas: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, `0x${string}`, string>>;
+        input: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, `0x${string}`, string>>;
+        value: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, `0x${string}`, string>>;
+    }, "strip", z.ZodTypeAny, {
+        from: `0x${string}`;
+        to?: `0x${string}` | undefined;
+        callType: string;
+        gas?: `0x${string}` | undefined;
+        input?: `0x${string}` | undefined;
+        value?: `0x${string}` | undefined;
+    }, {
+        from: string;
+        to?: string | undefined;
+        callType: string;
+        gas?: string | undefined;
+        input?: string | undefined;
+        value?: string | undefined;
+    }>;
+    result: z.ZodOptional<z.ZodObject<{
+        gasUsed: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, `0x${string}`, string>>;
+        output: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, `0x${string}`, string>>;
+    }, "strip", z.ZodTypeAny, {
+        gasUsed?: `0x${string}` | undefined;
+        output?: `0x${string}` | undefined;
+    }, {
+        gasUsed?: string | undefined;
+        output?: string | undefined;
+    }>>;
+    error: z.ZodOptional<z.ZodString>;
+    subtraces: z.ZodNumber;
+    traceAddress: z.ZodArray<z.ZodNumber, "many">;
+    type: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    action: {
+        from: `0x${string}`;
+        to?: `0x${string}` | undefined;
+        callType: string;
+        gas?: `0x${string}` | undefined;
+        input?: `0x${string}` | undefined;
+        value?: `0x${string}` | undefined;
+    };
+    result?: {
+        gasUsed?: `0x${string}` | undefined;
+        output?: `0x${string}` | undefined;
+    } | undefined;
+    error?: string | undefined;
+    subtraces: number;
+    traceAddress: number[];
+    type: string;
+}, {
+    action: {
+        from: string;
+        to?: string | undefined;
+        callType: string;
+        gas?: string | undefined;
+        input?: string | undefined;
+        value?: string | undefined;
+    };
+    result?: {
+        gasUsed?: string | undefined;
+        output?: string | undefined;
+    } | undefined;
+    error?: string | undefined;
+    subtraces: number;
+    traceAddress: number[];
+    type: string;
+}>;
+/** Type for trace_transaction response */
+type TraceTransaction = z.infer<typeof traceSchema>;
+/** Zod schema for the full trace_transaction response (array of traces) */
+export declare const traceTransactionResponseSchema: ZodFor<TraceTransaction[]>;
+/**
+ * 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 declare function getSuccessfulCallsFromTrace(client: ViemPublicDebugClient, txHash: Hex, targetAddress: EthAddress, functionSelector: string, logger?: Logger): Promise<CallInfo[]>;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhY2VfdHguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcmNoaXZlci9sMS90cmFjZV90eC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ25FLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUMzRCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUNwRCxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQVcsTUFBTSwyQkFBMkIsQ0FBQztBQUdqRSxPQUFPLEtBQUssRUFBRSxHQUFHLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDaEMsT0FBTyxFQUFFLENBQUMsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUV4QixPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFrQjNDLDJEQUEyRDtBQUMzRCxlQUFPLE1BQU0sV0FBVzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7RUFPdEIsQ0FBQztBQUVILDBDQUEwQztBQUMxQyxLQUFLLGdCQUFnQixHQUFHLENBQUMsQ0FBQyxLQUFLLENBQUMsT0FBTyxXQUFXLENBQUMsQ0FBQztBQUVwRCwyRUFBMkU7QUFDM0UsZUFBTyxNQUFNLDhCQUE4QixFQUFFLE1BQU0sQ0FBQyxnQkFBZ0IsRUFBRSxDQUF3QixDQUFDO0FBRS9GOzs7Ozs7Ozs7R0FTRztBQUNILHdCQUFzQiwyQkFBMkIsQ0FDL0MsTUFBTSxFQUFFLHFCQUFxQixFQUM3QixNQUFNLEVBQUUsR0FBRyxFQUNYLGFBQWEsRUFBRSxVQUFVLEVBQ3pCLGdCQUFnQixFQUFFLE1BQU0sRUFDeEIsTUFBTSxDQUFDLEVBQUUsTUFBTSxHQUNkLE9BQU8sQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQW9FckIifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"trace_tx.d.ts","sourceRoot":"","sources":["../../../src/archiver/l1/trace_tx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,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;AAChC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAkB3C,2DAA2D;AAC3D,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOtB,CAAC;AAEH,0CAA0C;AAC1C,KAAK,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEpD,2EAA2E;AAC3E,eAAO,MAAM,8BAA8B,EAAE,MAAM,CAAC,gBAAgB,EAAE,CAAwB,CAAC;AAE/F;;;;;;;;;GASG;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,CAoErB"}