@aztec/archiver 3.0.0-devnet.5 → 3.0.0-devnet.6-patch.1

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/archiver/structs/data_retrieval.d.ts

@@ -24,4 +24,4 @@ export type SingletonDataRetrieval<T> = {
      */
     retrievedData: T;
 };
-//# sourceMappingURL=data_retrieval.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YV9yZXRyaWV2YWwuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcmNoaXZlci9zdHJ1Y3RzL2RhdGFfcmV0cmlldmFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxNQUFNLGFBQWEsQ0FBQyxDQUFDLElBQUk7SUFDN0I7O09BRUc7SUFDSCwwQkFBMEIsRUFBRSxNQUFNLENBQUM7SUFDbkM7O09BRUc7SUFDSCxhQUFhLEVBQUUsQ0FBQyxFQUFFLENBQUM7Q0FDcEIsQ0FBQztBQUVGOztHQUVHO0FBQ0gsTUFBTSxNQUFNLHNCQUFzQixDQUFDLENBQUMsSUFBSTtJQUN0Qzs7T0FFRztJQUNILDBCQUEwQixFQUFFLE1BQU0sQ0FBQztJQUNuQzs7T0FFRztJQUNILGFBQWEsRUFBRSxDQUFDLENBQUM7Q0FDbEIsQ0FBQyJ9

package/dest/archiver/structs/inbox_message.d.ts

@@ -1,10 +1,10 @@
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
-import { Fr } from '@aztec/foundation/fields';
-import type { UInt32 } from '@aztec/stdlib/types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 export type InboxMessage = {
     index: bigint;
     leaf: Fr;
-    l2BlockNumber: UInt32;
+    checkpointNumber: CheckpointNumber;
     l1BlockNumber: bigint;
     l1BlockHash: Buffer32;
     rollingHash: Buffer16;
@@ -12,4 +12,4 @@ export type InboxMessage = {
 export declare function updateRollingHash(currentRollingHash: Buffer16, leaf: Fr): Buffer16;
 export declare function serializeInboxMessage(message: InboxMessage): Buffer;
 export declare function deserializeInboxMessage(buffer: Buffer): InboxMessage;
-//# sourceMappingURL=inbox_message.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5ib3hfbWVzc2FnZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FyY2hpdmVyL3N0cnVjdHMvaW5ib3hfbWVzc2FnZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNuRSxPQUFPLEVBQUUsUUFBUSxFQUFFLFFBQVEsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRTlELE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUdwRCxNQUFNLE1BQU0sWUFBWSxHQUFHO0lBQ3pCLEtBQUssRUFBRSxNQUFNLENBQUM7SUFDZCxJQUFJLEVBQUUsRUFBRSxDQUFDO0lBQ1QsZ0JBQWdCLEVBQUUsZ0JBQWdCLENBQUM7SUFDbkMsYUFBYSxFQUFFLE1BQU0sQ0FBQztJQUN0QixXQUFXLEVBQUUsUUFBUSxDQUFDO0lBQ3RCLFdBQVcsRUFBRSxRQUFRLENBQUM7Q0FDdkIsQ0FBQztBQUVGLHdCQUFnQixpQkFBaUIsQ0FBQyxrQkFBa0IsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLEVBQUUsR0FBRyxRQUFRLENBR2xGO0FBRUQsd0JBQWdCLHFCQUFxQixDQUFDLE9BQU8sRUFBRSxZQUFZLEdBQUcsTUFBTSxDQVNuRTtBQUVELHdCQUFnQix1QkFBdUIsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksQ0FTcEUifQ==

package/dest/archiver/structs/inbox_message.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inbox_message.d.ts","sourceRoot":"","sources":["../../../src/archiver/structs/inbox_message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,EAAE,CAAC;IACT,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,QAAQ,CAAC;IACtB,WAAW,EAAE,QAAQ,CAAC;CACvB,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,kBAAkB,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,GAAG,QAAQ,CAGlF;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CASnE;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CASpE"}
+{"version":3,"file":"inbox_message.d.ts","sourceRoot":"","sources":["../../../src/archiver/structs/inbox_message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAGpD,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,EAAE,CAAC;IACT,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,QAAQ,CAAC;IACtB,WAAW,EAAE,QAAQ,CAAC;CACvB,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,kBAAkB,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,GAAG,QAAQ,CAGlF;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CASnE;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CASpE"}

package/dest/archiver/structs/inbox_message.js

@@ -1,6 +1,7 @@
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256 } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { keccak256 } from '@aztec/foundation/crypto/keccak';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, bigintToUInt64BE, numToUInt32BE, serializeToBuffer } from '@aztec/foundation/serialize';
 export function updateRollingHash(currentRollingHash, leaf) {
     const input = Buffer.concat([
@@ -15,7 +16,7 @@ export function serializeInboxMessage(message) {
         message.leaf,
         message.l1BlockHash,
         numToUInt32BE(Number(message.l1BlockNumber)),
-        numToUInt32BE(message.l2BlockNumber),
+        numToUInt32BE(message.checkpointNumber),
         message.rollingHash
     ]);
 }
@@ -25,14 +26,14 @@ export function deserializeInboxMessage(buffer) {
     const leaf = reader.readObject(Fr);
     const l1BlockHash = reader.readObject(Buffer32);
     const l1BlockNumber = BigInt(reader.readNumber());
-    const l2BlockNumber = reader.readNumber();
+    const checkpointNumber = CheckpointNumber(reader.readNumber());
     const rollingHash = reader.readObject(Buffer16);
     return {
         index,
         leaf,
         l1BlockHash,
         l1BlockNumber,
-        l2BlockNumber,
+        checkpointNumber,
         rollingHash
     };
 }

package/dest/archiver/structs/published.d.ts

@@ -1,2 +1,3 @@
-export type { PublishedL2Block, L1PublishedData } from '@aztec/stdlib/block';
-//# sourceMappingURL=published.d.ts.map
+export type { PublishedL2Block } from '@aztec/stdlib/block';
+export type { L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGlzaGVkLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXJjaGl2ZXIvc3RydWN0cy9wdWJsaXNoZWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWSxFQUFFLGdCQUFnQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDNUQsWUFBWSxFQUFFLGVBQWUsRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDIn0=

package/dest/archiver/structs/published.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"published.d.ts","sourceRoot":"","sources":["../../../src/archiver/structs/published.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"published.d.ts","sourceRoot":"","sources":["../../../src/archiver/structs/published.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,YAAY,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC"}

package/dest/archiver/validation.d.ts

@@ -1,11 +1,17 @@
 import type { EpochCache } from '@aztec/epoch-cache';
 import type { Logger } from '@aztec/foundation/log';
-import { type PublishedL2Block, type ValidateBlockResult } from '@aztec/stdlib/block';
+import { type AttestationInfo, type ValidateBlockResult } from '@aztec/stdlib/block';
+import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 export type { ValidateBlockResult };
 /**
- * Validates the attestations submitted for the given block.
+ * Extracts attestation information from a published checkpoint.
+ * Returns info for each attestation, preserving array indices.
+ */
+export declare function getAttestationInfoFromPublishedCheckpoint({ checkpoint, attestations }: PublishedCheckpoint): AttestationInfo[];
+/**
+ * Validates the attestations submitted for the given checkpoint.
  * Returns true if the attestations are valid and sufficient, false otherwise.
  */
-export declare function validateBlockAttestations(publishedBlock: PublishedL2Block, epochCache: EpochCache, constants: Pick<L1RollupConstants, 'epochDuration'>, logger?: Logger): Promise<ValidateBlockResult>;
-//# sourceMappingURL=validation.d.ts.map
+export declare function validateCheckpointAttestations(publishedCheckpoint: PublishedCheckpoint, epochCache: EpochCache, constants: Pick<L1RollupConstants, 'epochDuration'>, logger?: Logger): Promise<ValidateBlockResult>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGlvbi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FyY2hpdmVyL3ZhbGlkYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFHckQsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDcEQsT0FBTyxFQUNMLEtBQUssZUFBZSxFQUVwQixLQUFLLG1CQUFtQixFQUV6QixNQUFNLHFCQUFxQixDQUFDO0FBQzdCLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDcEUsT0FBTyxFQUFFLEtBQUssaUJBQWlCLEVBQWtCLE1BQU0sNkJBQTZCLENBQUM7QUFHckYsWUFBWSxFQUFFLG1CQUFtQixFQUFFLENBQUM7QUFFcEM7OztHQUdHO0FBQ0gsd0JBQWdCLHlDQUF5QyxDQUFDLEVBQ3hELFVBQVUsRUFDVixZQUFZLEVBQ2IsRUFBRSxtQkFBbUIsR0FBRyxlQUFlLEVBQUUsQ0FHekM7QUFFRDs7O0dBR0c7QUFDSCx3QkFBc0IsOEJBQThCLENBQ2xELG1CQUFtQixFQUFFLG1CQUFtQixFQUN4QyxVQUFVLEVBQUUsVUFBVSxFQUN0QixTQUFTLEVBQUUsSUFBSSxDQUFDLGlCQUFpQixFQUFFLGVBQWUsQ0FBQyxFQUNuRCxNQUFNLENBQUMsRUFBRSxNQUFNLEdBQ2QsT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBc0Y5QiJ9

package/dest/archiver/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/archiver/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EACL,KAAK,gBAAgB,EAErB,KAAK,mBAAmB,EAEzB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,iBAAiB,EAAkB,MAAM,6BAA6B,CAAC;AAErF,YAAY,EAAE,mBAAmB,EAAE,CAAC;AAEpC;;;GAGG;AACH,wBAAsB,yBAAyB,CAC7C,cAAc,EAAE,gBAAgB,EAChC,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,EACnD,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,mBAAmB,CAAC,CA4E9B"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/archiver/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,mBAAmB,EAEzB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,KAAK,iBAAiB,EAAkB,MAAM,6BAA6B,CAAC;AAGrF,YAAY,EAAE,mBAAmB,EAAE,CAAC;AAEpC;;;GAGG;AACH,wBAAgB,yCAAyC,CAAC,EACxD,UAAU,EACV,YAAY,EACb,EAAE,mBAAmB,GAAG,eAAe,EAAE,CAGzC;AAED;;;GAGG;AACH,wBAAsB,8BAA8B,CAClD,mBAAmB,EAAE,mBAAmB,EACxC,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,EACnD,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,mBAAmB,CAAC,CAsF9B"}

package/dest/archiver/validation.js

@@ -1,48 +1,55 @@
 import { compactArray } from '@aztec/foundation/collection';
-import { getAttestationInfoFromPublishedL2Block } from '@aztec/stdlib/block';
+import { getAttestationInfoFromPayload } from '@aztec/stdlib/block';
 import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import { ConsensusPayload } from '@aztec/stdlib/p2p';
 /**
- * Validates the attestations submitted for the given block.
+ * Extracts attestation information from a published checkpoint.
+ * Returns info for each attestation, preserving array indices.
+ */ export function getAttestationInfoFromPublishedCheckpoint({ checkpoint, attestations }) {
+    const payload = ConsensusPayload.fromCheckpoint(checkpoint);
+    return getAttestationInfoFromPayload(payload, attestations);
+}
+/**
+ * Validates the attestations submitted for the given checkpoint.
  * Returns true if the attestations are valid and sufficient, false otherwise.
- */ export async function validateBlockAttestations(publishedBlock, epochCache, constants, logger) {
-    const attestorInfos = getAttestationInfoFromPublishedL2Block(publishedBlock);
+ */ export async function validateCheckpointAttestations(publishedCheckpoint, epochCache, constants, logger) {
+    const attestorInfos = getAttestationInfoFromPublishedCheckpoint(publishedCheckpoint);
     const attestors = compactArray(attestorInfos.map((info)=>'address' in info ? info.address : undefined));
-    const { block } = publishedBlock;
-    const blockHash = await block.hash().then((hash)=>hash.toString());
-    const archiveRoot = block.archive.root.toString();
-    const slot = block.header.getSlot();
+    const { checkpoint, attestations } = publishedCheckpoint;
+    const headerHash = checkpoint.header.hash();
+    const archiveRoot = checkpoint.archive.root.toString();
+    const slot = checkpoint.header.slotNumber;
     const epoch = getEpochAtSlot(slot, constants);
     const { committee, seed } = await epochCache.getCommitteeForEpoch(epoch);
     const logData = {
-        blockNumber: block.number,
+        checkpointNumber: checkpoint.number,
         slot,
         epoch,
-        blockHash,
+        headerHash,
         archiveRoot
     };
-    logger?.debug(`Validating attestations for block ${block.number} at slot ${slot} in epoch ${epoch}`, {
+    logger?.debug(`Validating attestations for checkpoint ${checkpoint.number} at slot ${slot} in epoch ${epoch}`, {
         committee: (committee ?? []).map((member)=>member.toString()),
         recoveredAttestors: attestorInfos,
-        postedAttestations: publishedBlock.attestations.map((a)=>(a.address.isZero() ? a.signature : a.address).toString()),
+        postedAttestations: attestations.map((a)=>(a.address.isZero() ? a.signature : a.address).toString()),
         ...logData
     });
     if (!committee || committee.length === 0) {
-        logger?.warn(`No committee found for epoch ${epoch} at slot ${slot}. Accepting block without validation.`, logData);
+        logger?.warn(`No committee found for epoch ${epoch} at slot ${slot}. Accepting checkpoint without validation.`, logData);
         return {
             valid: true
         };
     }
-    const committeeSet = new Set(committee.map((member)=>member.toString()));
     const requiredAttestationCount = Math.floor(committee.length * 2 / 3) + 1;
     const failedValidationResult = (reason)=>({
             valid: false,
             reason,
-            block: publishedBlock.block.toBlockInfo(),
+            block: checkpoint.blocks[0].toBlockInfo(),
             committee,
             seed,
             epoch,
             attestors,
-            attestations: publishedBlock.attestations
+            attestations
         });
     for(let i = 0; i < attestorInfos.length; i++){
         const info = attestorInfos[i];
@@ -58,11 +65,12 @@ import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
                 invalidIndex: i
             };
         }
-        // Check if the attestor is in the committee
+        // Check if the attestor at this index matches the committee member at the same index
         if (info.status === 'recovered-from-signature' || info.status === 'provided-as-address') {
             const signer = info.address.toString();
-            if (!committeeSet.has(signer)) {
-                logger?.warn(`Attestation from non-committee member ${signer} at slot ${slot}`, {
+            const expectedCommitteeMember = committee[i]?.toString();
+            if (!expectedCommitteeMember || signer !== expectedCommitteeMember) {
+                logger?.warn(`Attestation at index ${i} from ${signer} does not match expected committee member ${expectedCommitteeMember} at slot ${slot}`, {
                     committee,
                     invalidIndex: i,
                     ...logData
@@ -76,14 +84,14 @@ import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
     }
     const validAttestationCount = attestorInfos.filter((info)=>info.status === 'recovered-from-signature').length;
     if (validAttestationCount < requiredAttestationCount) {
-        logger?.warn(`Insufficient attestations for block at slot ${slot}`, {
+        logger?.warn(`Insufficient attestations for checkpoint at slot ${slot}`, {
             requiredAttestations: requiredAttestationCount,
             actualAttestations: validAttestationCount,
             ...logData
         });
         return failedValidationResult('insufficient-attestations');
     }
-    logger?.debug(`Block attestations validated successfully for block ${block.number} at slot ${slot}`, logData);
+    logger?.debug(`Checkpoint attestations validated successfully for checkpoint ${checkpoint.number} at slot ${slot}`, logData);
     return {
         valid: true
     };