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

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"}

package/dest/archiver/l1/trace_tx.js

@@ -0,0 +1,91 @@
+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 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()
+});
+/** Zod schema for the full trace_transaction response (array of traces) */ export const traceTransactionResponseSchema = 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, txHash, targetAddress, functionSelector, logger) {
+    // 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 = [];
+    // 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();
+    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) {
+        // 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/dest/archiver/l1/types.d.ts

@@ -0,0 +1,12 @@
+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;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcmNoaXZlci9sMS90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFFM0QsT0FBTyxLQUFLLEVBQUUsR0FBRyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBRWhDOztHQUVHO0FBQ0gsTUFBTSxXQUFXLFFBQVE7SUFDdkIsSUFBSSxFQUFFLFVBQVUsQ0FBQztJQUNqQixPQUFPLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDakIsS0FBSyxFQUFFLEdBQUcsQ0FBQztJQUNYLEtBQUssRUFBRSxNQUFNLENBQUM7Q0FDZiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/archiver/l1/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAEhC;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,GAAG,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf"}

package/dest/archiver/l1/types.js

@@ -0,0 +1,3 @@
+/**
+ * Information about a matching CALL
+ */ export { };

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

@@ -0,0 +1,29 @@
+import type { ViemPublicDebugClient } from '@aztec/ethereum/types';
+/** Result of trace availability checks */
+export interface TraceAvailability {
+    /** Whether debug_traceTransaction works for recent blocks */
+    debugTraceRecent: boolean;
+    /** Whether trace_transaction works for recent blocks */
+    traceTransactionRecent: boolean;
+    /** Whether debug_traceTransaction works for old blocks (512 blocks ago) */
+    debugTraceOld: boolean;
+    /** Whether trace_transaction works for old blocks (512 blocks ago) */
+    traceTransactionOld: boolean;
+}
+/**
+ * Validates the availability of debug/trace methods on the Ethereum client.
+ *
+ * @param client - The Viem public debug client
+ * @returns Object indicating which trace methods are available for recent and old blocks
+ */
+export declare function validateTraceAvailability(client: ViemPublicDebugClient): Promise<TraceAvailability>;
+/**
+ * Validates trace availability and logs appropriate messages based on the results.
+ * Optionally throws an error if no trace methods are available and ethereumAllowNoDebugHosts is false.
+ *
+ * @param client - The Viem public debug client
+ * @param ethereumAllowNoDebugHosts - If false, throws an error when no trace methods are available
+ * @throws Error if ethereumAllowNoDebugHosts is false and no trace methods are available
+ */
+export declare function validateAndLogTraceAvailability(client: ViemPublicDebugClient, ethereumAllowNoDebugHosts: boolean): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGVfdHJhY2UuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcmNoaXZlci9sMS92YWxpZGF0ZV90cmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBNkNuRSwwQ0FBMEM7QUFDMUMsTUFBTSxXQUFXLGlCQUFpQjtJQUNoQyw2REFBNkQ7SUFDN0QsZ0JBQWdCLEVBQUUsT0FBTyxDQUFDO0lBQzFCLHdEQUF3RDtJQUN4RCxzQkFBc0IsRUFBRSxPQUFPLENBQUM7SUFDaEMsMkVBQTJFO0lBQzNFLGFBQWEsRUFBRSxPQUFPLENBQUM7SUFDdkIsc0VBQXNFO0lBQ3RFLG1CQUFtQixFQUFFLE9BQU8sQ0FBQztDQUM5QjtBQUVEOzs7OztHQUtHO0FBQ0gsd0JBQXNCLHlCQUF5QixDQUFDLE1BQU0sRUFBRSxxQkFBcUIsR0FBRyxPQUFPLENBQUMsaUJBQWlCLENBQUMsQ0FzRnpHO0FBTUQ7Ozs7Ozs7R0FPRztBQUNILHdCQUFzQiwrQkFBK0IsQ0FDbkQsTUFBTSxFQUFFLHFCQUFxQixFQUM3Qix5QkFBeUIsRUFBRSxPQUFPLEdBQ2pDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0E0Q2YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"validate_trace.d.ts","sourceRoot":"","sources":["../../../src/archiver/l1/validate_trace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AA6CnE,0CAA0C;AAC1C,MAAM,WAAW,iBAAiB;IAChC,6DAA6D;IAC7D,gBAAgB,EAAE,OAAO,CAAC;IAC1B,wDAAwD;IACxD,sBAAsB,EAAE,OAAO,CAAC;IAChC,2EAA2E;IAC3E,aAAa,EAAE,OAAO,CAAC;IACvB,sEAAsE;IACtE,mBAAmB,EAAE,OAAO,CAAC;CAC9B;AAED;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAsFzG;AAMD;;;;;;;GAOG;AACH,wBAAsB,+BAA+B,CACnD,MAAM,EAAE,qBAAqB,EAC7B,yBAAyB,EAAE,OAAO,GACjC,OAAO,CAAC,IAAI,CAAC,CA4Cf"}

package/dest/archiver/l1/validate_trace.js

@@ -0,0 +1,150 @@
+import { createLogger } from '@aztec/foundation/log';
+import { callTraceSchema } from './debug_tx.js';
+import { traceTransactionResponseSchema } from './trace_tx.js';
+const logger = createLogger('aztec:archiver:validate_trace');
+/**
+ * Helper function to test a trace method with validation
+ *
+ * @param client - The Viem public debug client
+ * @param txHash - Transaction hash to trace
+ * @param schema - Zod schema to validate the response
+ * @param method - Name of the RPC method ('debug_traceTransaction' or 'trace_transaction')
+ * @param blockType - Type of block being tested ('recent' or 'old')
+ * @returns true if the method works and validation passes, false otherwise
+ */ async function testTraceMethod(client, txHash, schema, method, blockType) {
+    try {
+        // Make request with appropriate params based on method name
+        const result = await client.request(method === 'debug_traceTransaction' ? {
+            method,
+            params: [
+                txHash,
+                {
+                    tracer: 'callTracer'
+                }
+            ]
+        } : {
+            method,
+            params: [
+                txHash
+            ]
+        });
+        schema.parse(result);
+        logger.debug(`${method} works for ${blockType} blocks`);
+        return true;
+    } catch (error) {
+        logger.warn(`${method} failed for ${blockType} blocks: ${error}`);
+        return false;
+    }
+}
+/**
+ * Validates the availability of debug/trace methods on the Ethereum client.
+ *
+ * @param client - The Viem public debug client
+ * @returns Object indicating which trace methods are available for recent and old blocks
+ */ export async function validateTraceAvailability(client) {
+    const result = {
+        debugTraceRecent: false,
+        traceTransactionRecent: false,
+        debugTraceOld: false,
+        traceTransactionOld: false
+    };
+    try {
+        // Get the latest block
+        let latestBlock = await client.getBlock({
+            blockTag: 'latest'
+        });
+        let attempts = 10;
+        // Loop back to find a block with transactions (handles dev/test scenarios)
+        while(!hasTxs(latestBlock) && latestBlock.number && latestBlock.number > 0n && --attempts > 0){
+            logger.debug(`Block ${latestBlock.number} has no transactions, checking previous block`);
+            latestBlock = await client.getBlock({
+                blockNumber: latestBlock.number - 1n
+            });
+        }
+        if (!hasTxs(latestBlock)) {
+            logger.warn('No blocks with transactions found from latest back to genesis, cannot validate trace availability');
+            return result;
+        }
+        // Get a transaction from the found block
+        const recentTxHash = latestBlock.transactions[0];
+        // Test debug_traceTransaction with recent block
+        result.debugTraceRecent = await testTraceMethod(client, recentTxHash, callTraceSchema, 'debug_traceTransaction', 'recent');
+        // Test trace_transaction with recent block
+        result.traceTransactionRecent = await testTraceMethod(client, recentTxHash, traceTransactionResponseSchema, 'trace_transaction', 'recent');
+        // Get a block from 512 blocks ago
+        const oldBlockNumber = latestBlock.number ? latestBlock.number - 512n : null;
+        if (!oldBlockNumber || oldBlockNumber < 0n) {
+            logger.debug('Cannot test old blocks, blockchain too short');
+            return result;
+        }
+        let oldBlock = await client.getBlock({
+            blockNumber: oldBlockNumber
+        });
+        attempts = 10;
+        // Loop back to find a block with transactions (handles dev/test scenarios)
+        while(!hasTxs(oldBlock) && oldBlock.number && oldBlock.number > 0n && --attempts > 0){
+            logger.debug(`Block ${oldBlock.number} has no transactions, checking previous block`);
+            oldBlock = await client.getBlock({
+                blockNumber: oldBlock.number - 1n
+            });
+        }
+        if (!hasTxs(oldBlock)) {
+            logger.debug('No blocks with transactions found from old block back to genesis, cannot validate trace availability for old blocks');
+            return result;
+        }
+        const oldTxHash = oldBlock.transactions[0];
+        // Test debug_traceTransaction with old block
+        result.debugTraceOld = await testTraceMethod(client, oldTxHash, callTraceSchema, 'debug_traceTransaction', 'old');
+        // Test trace_transaction with old block
+        result.traceTransactionOld = await testTraceMethod(client, oldTxHash, traceTransactionResponseSchema, 'trace_transaction', 'old');
+    } catch (error) {
+        logger.warn(`Error validating debug_traceTransaction and trace_transaction availability: ${error}`);
+    }
+    return result;
+}
+function hasTxs(block) {
+    return Array.isArray(block.transactions) && block.transactions.length > 0;
+}
+/**
+ * Validates trace availability and logs appropriate messages based on the results.
+ * Optionally throws an error if no trace methods are available and ethereumAllowNoDebugHosts is false.
+ *
+ * @param client - The Viem public debug client
+ * @param ethereumAllowNoDebugHosts - If false, throws an error when no trace methods are available
+ * @throws Error if ethereumAllowNoDebugHosts is false and no trace methods are available
+ */ export async function validateAndLogTraceAvailability(client, ethereumAllowNoDebugHosts) {
+    logger.info('Validating trace/debug method availability...');
+    const availability = await validateTraceAvailability(client);
+    // Check if we have support for old blocks (either debug or trace)
+    const hasOldBlockSupport = availability.debugTraceOld || availability.traceTransactionOld;
+    if (hasOldBlockSupport) {
+        // Ideal case: we have trace support for old blocks
+        const methods = [];
+        if (availability.debugTraceOld) {
+            methods.push('debug_traceTransaction');
+        }
+        if (availability.traceTransactionOld) {
+            methods.push('trace_transaction');
+        }
+        logger.info(`Ethereum client supports trace methods for old blocks (${methods.join(', ')}). Archiver can retrieve historical transaction traces.`);
+    } else if (availability.debugTraceRecent || availability.traceTransactionRecent) {
+        // Warning case: only recent block support
+        const methods = [];
+        if (availability.debugTraceRecent) {
+            methods.push('debug_traceTransaction');
+        }
+        if (availability.traceTransactionRecent) {
+            methods.push('trace_transaction');
+        }
+        logger.warn(`Ethereum client only supports trace methods for recent blocks (${methods.join(', ')}). Historical transaction traces may not be available.`);
+    } else {
+        // Error case: no support at all
+        const errorMessage = 'Ethereum debug client does not support debug_traceTransaction or trace_transaction methods. Transaction tracing will not be available. This may impact archiver syncing.';
+        if (ethereumAllowNoDebugHosts) {
+            logger.warn(`${errorMessage} Continuing because ETHEREUM_ALLOW_NO_DEBUG_HOSTS is set to true.`);
+        } else {
+            logger.error(errorMessage);
+            throw new Error(`${errorMessage} Set ETHEREUM_ALLOW_NO_DEBUG_HOSTS=true to bypass this check.`);
+        }
+    }
+}

package/dest/index.d.ts

@@ -1,5 +1,5 @@
 export * from './archiver/index.js';
 export * from './factory.js';
 export * from './rpc/index.js';
-export { retrieveL2ProofVerifiedEvents } from './archiver/data_retrieval.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsZ0JBQWdCLENBQUM7QUFFL0IsT0FBTyxFQUFFLDZCQUE2QixFQUFFLE1BQU0sOEJBQThCLENBQUMifQ==
+export { retrieveCheckpointsFromRollup, retrieveL2ProofVerifiedEvents } from './archiver/l1/data_retrieval.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsZ0JBQWdCLENBQUM7QUFFL0IsT0FBTyxFQUFFLDZCQUE2QixFQUFFLDZCQUE2QixFQUFFLE1BQU0saUNBQWlDLENBQUMifQ==

package/dest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAE/B,OAAO,EAAE,6BAA6B,EAAE,MAAM,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAE/B,OAAO,EAAE,6BAA6B,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC"}

package/dest/index.js

@@ -1,4 +1,4 @@
 export * from './archiver/index.js';
 export * from './factory.js';
 export * from './rpc/index.js';
-export { retrieveL2ProofVerifiedEvents } from './archiver/data_retrieval.js';
+export { retrieveCheckpointsFromRollup, retrieveL2ProofVerifiedEvents } from './archiver/l1/data_retrieval.js';

package/dest/test/mock_l2_block_source.js

@@ -1,5 +1,5 @@
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
-import { DefaultL1ContractsConfig } from '@aztec/ethereum';
+import { DefaultL1ContractsConfig } from '@aztec/ethereum/config';
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { Fr } from '@aztec/foundation/curves/bn254';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/archiver",
-  "version": "3.0.0-nightly.20251210",
+  "version": "3.0.0-nightly.20251211",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -66,22 +66,23 @@
     ]
   },
   "dependencies": {
-    "@aztec/blob-lib": "3.0.0-nightly.20251210",
-    "@aztec/blob-sink": "3.0.0-nightly.20251210",
-    "@aztec/constants": "3.0.0-nightly.20251210",
-    "@aztec/epoch-cache": "3.0.0-nightly.20251210",
-    "@aztec/ethereum": "3.0.0-nightly.20251210",
-    "@aztec/foundation": "3.0.0-nightly.20251210",
-    "@aztec/kv-store": "3.0.0-nightly.20251210",
-    "@aztec/l1-artifacts": "3.0.0-nightly.20251210",
-    "@aztec/noir-protocol-circuits-types": "3.0.0-nightly.20251210",
-    "@aztec/protocol-contracts": "3.0.0-nightly.20251210",
-    "@aztec/stdlib": "3.0.0-nightly.20251210",
-    "@aztec/telemetry-client": "3.0.0-nightly.20251210",
+    "@aztec/blob-lib": "3.0.0-nightly.20251211",
+    "@aztec/blob-sink": "3.0.0-nightly.20251211",
+    "@aztec/constants": "3.0.0-nightly.20251211",
+    "@aztec/epoch-cache": "3.0.0-nightly.20251211",
+    "@aztec/ethereum": "3.0.0-nightly.20251211",
+    "@aztec/foundation": "3.0.0-nightly.20251211",
+    "@aztec/kv-store": "3.0.0-nightly.20251211",
+    "@aztec/l1-artifacts": "3.0.0-nightly.20251211",
+    "@aztec/noir-protocol-circuits-types": "3.0.0-nightly.20251211",
+    "@aztec/protocol-contracts": "3.0.0-nightly.20251211",
+    "@aztec/stdlib": "3.0.0-nightly.20251211",
+    "@aztec/telemetry-client": "3.0.0-nightly.20251211",
     "lodash.groupby": "^4.6.0",
     "lodash.omit": "^4.5.0",
     "tslib": "^2.5.0",
-    "viem": "npm:@aztec/viem@2.38.2"
+    "viem": "npm:@aztec/viem@2.38.2",
+    "zod": "^3.23.8"
   },
   "devDependencies": {
     "@jest/globals": "^30.0.0",

package/src/archiver/archiver.ts

@@ -1,14 +1,11 @@
 import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
 import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
 import { EpochCache } from '@aztec/epoch-cache';
-import {
-  BlockTagTooOldError,
-  InboxContract,
-  type L1BlockId,
-  RollupContract,
-  type ViemPublicClient,
-  createEthereumChain,
-} from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { BlockTagTooOldError, InboxContract, RollupContract } from '@aztec/ethereum/contracts';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import type { L1BlockId } from '@aztec/ethereum/l1-types';
+import type { ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/types';
 import { maxBigint } from '@aztec/foundation/bigint';
 import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
@@ -81,14 +78,15 @@ import { type GetContractReturnType, type Hex, createPublicClient, fallback, htt
 
 import type { ArchiverDataStore, ArchiverL1SynchPoint } from './archiver_store.js';
 import type { ArchiverConfig } from './config.js';
+import { InitialBlockNumberNotSequentialError, NoBlobBodiesFoundError } from './errors.js';
+import { ArchiverInstrumentation } from './instrumentation.js';
 import {
   retrieveCheckpointsFromRollup,
   retrieveL1ToL2Message,
   retrieveL1ToL2Messages,
   retrievedToPublishedCheckpoint,
-} from './data_retrieval.js';
-import { InitialBlockNumberNotSequentialError, NoBlobBodiesFoundError } from './errors.js';
-import { ArchiverInstrumentation } from './instrumentation.js';
+} from './l1/data_retrieval.js';
+import { validateAndLogTraceAvailability } from './l1/validate_trace.js';
 import type { InboxMessage } from './structs/inbox_message.js';
 import { type ValidateBlockResult, validateCheckpointAttestations } from './validation.js';
 
@@ -110,6 +108,7 @@ function mapArchiverConfig(config: Partial<ArchiverConfig>) {
     batchSize: config.archiverBatchSize,
     skipValidateBlockAttestations: config.skipValidateBlockAttestations,
     maxAllowedEthClientDriftSeconds: config.maxAllowedEthClientDriftSeconds,
+    ethereumAllowNoDebugHosts: config.ethereumAllowNoDebugHosts,
   };
 }
 
@@ -147,6 +146,7 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
   /**
    * Creates a new instance of the Archiver.
    * @param publicClient - A client for interacting with the Ethereum node.
+   * @param debugClient - A client for interacting with the Ethereum node for debug/trace methods.
    * @param rollupAddress - Ethereum address of the rollup contract.
    * @param inboxAddress - Ethereum address of the inbox contract.
    * @param registryAddress - Ethereum address of the registry contract.
@@ -156,13 +156,18 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
    */
   constructor(
     private readonly publicClient: ViemPublicClient,
-    private readonly l1Addresses: { rollupAddress: EthAddress; inboxAddress: EthAddress; registryAddress: EthAddress },
+    private readonly debugClient: ViemPublicDebugClient,
+    private readonly l1Addresses: Pick<
+      L1ContractAddresses,
+      'rollupAddress' | 'inboxAddress' | 'registryAddress' | 'governanceProposerAddress' | 'slashFactoryAddress'
+    > & { slashingProposerAddress: EthAddress },
     readonly dataStore: ArchiverDataStore,
     private config: {
       pollingIntervalMs: number;
       batchSize: number;
       skipValidateBlockAttestations?: boolean;
       maxAllowedEthClientDriftSeconds: number;
+      ethereumAllowNoDebugHosts?: boolean;
     },
     private readonly blobSinkClient: BlobSinkClientInterface,
     private readonly epochCache: EpochCache,
@@ -210,14 +215,24 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
       pollingInterval: config.viemPollingIntervalMS,
     });
 
+    // Create debug client using debug RPC URLs if available, otherwise fall back to regular RPC URLs
+    const debugRpcUrls = config.l1DebugRpcUrls.length > 0 ? config.l1DebugRpcUrls : config.l1RpcUrls;
+    const debugClient = createPublicClient({
+      chain: chain.chainInfo,
+      transport: fallback(debugRpcUrls.map(url => http(url))),
+      pollingInterval: config.viemPollingIntervalMS,
+    }) as ViemPublicDebugClient;
+
     const rollup = new RollupContract(publicClient, config.l1Contracts.rollupAddress);
 
-    const [l1StartBlock, l1GenesisTime, proofSubmissionEpochs, genesisArchiveRoot] = await Promise.all([
-      rollup.getL1StartBlock(),
-      rollup.getL1GenesisTime(),
-      rollup.getProofSubmissionEpochs(),
-      rollup.getGenesisArchiveTreeRoot(),
-    ] as const);
+    const [l1StartBlock, l1GenesisTime, proofSubmissionEpochs, genesisArchiveRoot, slashingProposerAddress] =
+      await Promise.all([
+        rollup.getL1StartBlock(),
+        rollup.getL1GenesisTime(),
+        rollup.getProofSubmissionEpochs(),
+        rollup.getGenesisArchiveTreeRoot(),
+        rollup.getSlashingProposerAddress(),
+      ] as const);
 
     const l1StartBlockHash = await publicClient
       .getBlock({ blockNumber: l1StartBlock, includeTransactions: false })
@@ -237,7 +252,12 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
     };
 
     const opts = merge(
-      { pollingIntervalMs: 10_000, batchSize: 100, maxAllowedEthClientDriftSeconds: 300 },
+      {
+        pollingIntervalMs: 10_000,
+        batchSize: 100,
+        maxAllowedEthClientDriftSeconds: 300,
+        ethereumAllowNoDebugHosts: false,
+      },
       mapArchiverConfig(config),
     );
 
@@ -246,7 +266,8 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
 
     const archiver = new Archiver(
       publicClient,
-      config.l1Contracts,
+      debugClient,
+      { ...config.l1Contracts, slashingProposerAddress },
       archiverStore,
       opts,
       deps.blobSinkClient,
@@ -275,6 +296,7 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
 
     await this.blobSinkClient.testSources();
     await this.testEthereumNodeSynced();
+    await validateAndLogTraceAvailability(this.debugClient, this.config.ethereumAllowNoDebugHosts ?? false);
 
     // Log initial state for the archiver
     const { l1StartBlock } = this.l1constants;
@@ -853,9 +875,12 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
       const retrievedCheckpoints = await retrieveCheckpointsFromRollup(
         this.rollup.getContract() as GetContractReturnType<typeof RollupAbi, ViemPublicClient>,
         this.publicClient,
+        this.debugClient,
         this.blobSinkClient,
         searchStartBlock, // TODO(palla/reorg): If the L2 reorg was due to an L1 reorg, we need to start search earlier
         searchEndBlock,
+        this.l1Addresses,
+        this.instrumentation,
         this.log,
       );
 

package/src/archiver/archiver_store.ts

@@ -1,5 +1,5 @@
-import type { L1BlockId } from '@aztec/ethereum';
-import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { L1BlockId } from '@aztec/ethereum/l1-types';
+import type { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { CustomRange } from '@aztec/kv-store';
 import type { FunctionSelector } from '@aztec/stdlib/abi';