opencode-froggy 0.3.0 → 0.5.0

package/dist/tools/blockchain/eth-transaction.d.ts

@@ -2,19 +2,33 @@
  * Tool to get Ethereum transaction details by hash
  */
 import { type ToolContext } from "@opencode-ai/plugin";
+import { type TransactionDetails } from "./types";
 export interface EthTransactionArgs {
     hash: string;
     chainId?: string;
+    includeInternalTxs?: boolean;
+    includeTokenTransfers?: boolean;
+    decodeLogs?: boolean;
 }
-export declare function getTransactionDetails(hash: string, chainId?: string): Promise<string>;
+export declare function getTransactionDetails(hash: string, chainId?: string, options?: {
+    includeInternalTxs?: boolean;
+    includeTokenTransfers?: boolean;
+    decodeLogs?: boolean;
+}): Promise<TransactionDetails>;
 export declare const ethTransactionTool: {
     description: string;
     args: {
         hash: import("zod").ZodString;
         chainId: import("zod").ZodOptional<import("zod").ZodString>;
+        includeInternalTxs: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        includeTokenTransfers: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        decodeLogs: import("zod").ZodOptional<import("zod").ZodBoolean>;
     };
     execute(args: {
         hash: string;
         chainId?: string | undefined;
+        includeInternalTxs?: boolean | undefined;
+        includeTokenTransfers?: boolean | undefined;
+        decodeLogs?: boolean | undefined;
     }, context: ToolContext): Promise<string>;
 };

package/dist/tools/blockchain/eth-transaction.js

@@ -2,37 +2,200 @@
  * Tool to get Ethereum transaction details by hash
  */
 import { tool } from "@opencode-ai/plugin";
-import { EtherscanClient, EtherscanClientError, validateTxHash } from "./etherscan-client";
-import { formatTransactionReceipt } from "./formatters";
-import { CHAIN_ID_DESCRIPTION } from "./types";
-export async function getTransactionDetails(hash, chainId) {
+import { EtherscanClient, EtherscanClientError, validateTxHash, weiToEth } from "./etherscan-client";
+import { getTransactionReceipt, getBlock, getTokenMetadata } from "./viem-client";
+import { CHAIN_ID_DESCRIPTION, DEFAULT_CHAIN_ID, } from "./types";
+import { decodeEvents } from "./event-decoder";
+const TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+function decodeAddress(topic) {
+    if (!topic || topic.length < 66)
+        return "0x0000000000000000000000000000000000000000";
+    return "0x" + topic.slice(26).toLowerCase();
+}
+function decodeUint256(data) {
+    if (!data)
+        return "0";
+    const hex = data.startsWith("0x") ? data.slice(2) : data;
+    if (hex === "" || !/^[0-9a-fA-F]+$/.test(hex))
+        return "0";
+    return BigInt("0x" + hex).toString();
+}
+function extractTransfersFromLogs(logs) {
+    return logs
+        .filter((log) => log.topics[0] === TRANSFER_TOPIC && log.topics.length === 3)
+        .map((log) => ({
+        contractAddress: log.address.toLowerCase(),
+        from: decodeAddress(log.topics[1]),
+        to: decodeAddress(log.topics[2]),
+        value: decodeUint256(log.data),
+    }));
+}
+function mapViemLogsToTransactionLogs(logs) {
+    return logs.map((log) => ({
+        address: log.address,
+        topics: log.topics,
+        data: log.data,
+        blockNumber: log.blockNumber?.toString() ?? "",
+        transactionHash: log.transactionHash ?? "",
+        transactionIndex: log.transactionIndex?.toString() ?? "",
+        blockHash: log.blockHash ?? "",
+        logIndex: log.logIndex?.toString() ?? "",
+        removed: log.removed ?? false,
+    }));
+}
+function formatTokenValue(value, decimals) {
+    const valueBigInt = BigInt(value);
+    const divisor = BigInt(10) ** BigInt(decimals);
+    const wholePart = valueBigInt / divisor;
+    const fractionPart = valueBigInt % divisor;
+    const fractionStr = fractionPart.toString().padStart(decimals, "0");
+    const trimmedFraction = fractionStr.replace(/0+$/, "").slice(0, 8);
+    if (trimmedFraction === "") {
+        return wholePart.toString();
+    }
+    return `${wholePart}.${trimmedFraction}`;
+}
+class ContractLabelResolver {
+    addressCache = new Map();
+    tokenCache = new Map();
+    chainId;
+    constructor(chainId) {
+        this.chainId = chainId;
+    }
+    async resolve(address) {
+        const lowerAddress = address.toLowerCase();
+        const cached = this.addressCache.get(lowerAddress);
+        if (cached) {
+            return cached;
+        }
+        const result = { address, label: null };
+        this.addressCache.set(lowerAddress, result);
+        return result;
+    }
+    async resolveToken(contractAddress) {
+        const lowerAddress = contractAddress.toLowerCase();
+        const cached = this.tokenCache.get(lowerAddress);
+        if (cached) {
+            return cached;
+        }
+        const metadata = await getTokenMetadata(contractAddress, this.chainId);
+        this.tokenCache.set(lowerAddress, metadata);
+        return metadata;
+    }
+}
+export async function getTransactionDetails(hash, chainId, options = {}) {
     validateTxHash(hash);
-    const client = new EtherscanClient(undefined, chainId);
-    const receipt = await client.getTransactionReceipt(hash);
+    const resolvedChainId = chainId ?? DEFAULT_CHAIN_ID;
+    const resolver = new ContractLabelResolver(resolvedChainId);
+    const receipt = await getTransactionReceipt(hash, resolvedChainId);
     if (!receipt) {
-        return `Transaction not found: ${hash}`;
+        throw new EtherscanClientError(`Transaction not found: ${hash}`);
+    }
+    const status = receipt.status === "success" ? "success" : "failed";
+    const gasUsed = Number(receipt.gasUsed);
+    const effectiveGasPrice = receipt.effectiveGasPrice?.toString() ?? "0";
+    const gasCostWei = (receipt.gasUsed * (receipt.effectiveGasPrice ?? 0n)).toString();
+    const blockNumber = Number(receipt.blockNumber);
+    let timestamp = null;
+    const block = await getBlock(receipt.blockNumber, resolvedChainId);
+    if (block?.timestamp) {
+        timestamp = new Date(Number(block.timestamp) * 1000).toISOString();
+    }
+    const fromAddress = await resolver.resolve(receipt.from);
+    const toAddress = receipt.to ? await resolver.resolve(receipt.to) : null;
+    const result = {
+        hash,
+        status,
+        block: blockNumber,
+        timestamp,
+        from: fromAddress,
+        to: toAddress,
+        value: "0",
+        gas: {
+            used: gasUsed,
+            price: effectiveGasPrice,
+            cost: weiToEth(gasCostWei),
+        },
+    };
+    if (options.includeInternalTxs) {
+        const client = new EtherscanClient(undefined, resolvedChainId);
+        const internalTxs = await client.getInternalTransactionsByHash(hash);
+        const internalDetails = [];
+        for (const tx of internalTxs) {
+            const from = await resolver.resolve(tx.from);
+            const to = await resolver.resolve(tx.to);
+            internalDetails.push({
+                from,
+                to,
+                value: weiToEth(tx.value),
+                type: tx.type || "call",
+            });
+        }
+        result.internalTransactions = internalDetails;
     }
-    return formatTransactionReceipt(hash, receipt);
+    const mappedLogs = Array.isArray(receipt.logs)
+        ? mapViemLogsToTransactionLogs(receipt.logs)
+        : [];
+    if (options.includeTokenTransfers && mappedLogs.length > 0) {
+        const rawTransfers = extractTransfersFromLogs(mappedLogs);
+        const tokenDetails = [];
+        for (const transfer of rawTransfers) {
+            const from = await resolver.resolve(transfer.from);
+            const to = await resolver.resolve(transfer.to);
+            const tokenMetadata = await resolver.resolveToken(transfer.contractAddress);
+            tokenDetails.push({
+                token: {
+                    address: transfer.contractAddress,
+                    name: tokenMetadata.name,
+                    symbol: tokenMetadata.symbol,
+                    decimals: tokenMetadata.decimals,
+                },
+                from,
+                to,
+                value: formatTokenValue(transfer.value, tokenMetadata.decimals),
+            });
+        }
+        result.tokenTransfers = tokenDetails;
+    }
+    if (options.decodeLogs && mappedLogs.length > 0) {
+        const { decoded, undecodedCount } = await decodeEvents(mappedLogs, resolver);
+        result.decodedEvents = decoded;
+        result.undecodedEventsCount = undecodedCount;
+    }
+    return result;
 }
 export const ethTransactionTool = tool({
     description: "Get Ethereum transaction details by transaction hash. " +
-        "Returns status, block, addresses, gas costs, and log count.",
+        "Returns status, block, addresses, gas costs in JSON format. " +
+        "Use optional parameters to include internal transactions, token transfers, and decoded event logs.",
     args: {
-        hash: tool.schema
-            .string()
-            .describe("Transaction hash (0x...)"),
-        chainId: tool.schema
-            .string()
+        hash: tool.schema.string().describe("Transaction hash (0x...)"),
+        chainId: tool.schema.string().optional().describe(CHAIN_ID_DESCRIPTION),
+        includeInternalTxs: tool.schema
+            .boolean()
+            .optional()
+            .describe("Include internal transactions (ETH transfers between contracts)"),
+        includeTokenTransfers: tool.schema
+            .boolean()
+            .optional()
+            .describe("Include ERC-20 token transfers"),
+        decodeLogs: tool.schema
+            .boolean()
             .optional()
-            .describe(CHAIN_ID_DESCRIPTION),
+            .describe("Decode event logs (Transfer, Approval, Deposit, Withdrawal)"),
     },
     async execute(args, _context) {
         try {
-            return await getTransactionDetails(args.hash, args.chainId);
+            const result = await getTransactionDetails(args.hash, args.chainId, {
+                includeInternalTxs: args.includeInternalTxs,
+                includeTokenTransfers: args.includeTokenTransfers,
+                decodeLogs: args.decodeLogs,
+            });
+            return JSON.stringify(result, null, 2);
         }
         catch (error) {
             if (error instanceof EtherscanClientError) {
-                return `Error: ${error.message}`;
+                return JSON.stringify({ error: error.message });
             }
             throw error;
         }

package/dist/tools/blockchain/etherscan-client.d.ts

@@ -1,7 +1,7 @@
 /**
  * Etherscan API client for Ethereum blockchain queries
  */
-import { type EthTransaction, type EthTokenTransfer, type EthInternalTransaction } from "./types";
+import { type EthTransaction, type EthTokenTransfer, type EthInternalTransaction, type ContractInfo } from "./types";
 export declare class EtherscanClientError extends Error {
     constructor(message: string);
 }
@@ -14,9 +14,10 @@ export declare class EtherscanClient {
     getBalance(address: string): Promise<string>;
     getTransactions(address: string, limit?: number): Promise<EthTransaction[]>;
     getInternalTransactions(address: string, limit?: number): Promise<EthInternalTransaction[]>;
+    getInternalTransactionsByHash(txhash: string): Promise<EthInternalTransaction[]>;
     getTokenTransfers(address: string, limit?: number): Promise<EthTokenTransfer[]>;
     getTransactionByHash(hash: string): Promise<EthTransaction | null>;
-    getTransactionReceipt(hash: string): Promise<Record<string, unknown> | null>;
+    getContractInfo(address: string): Promise<ContractInfo | null>;
 }
 export declare function weiToEth(wei: string): string;
 export declare function formatTimestamp(timestamp: string): string;

package/dist/tools/blockchain/etherscan-client.js

@@ -80,6 +80,17 @@ export class EtherscanClient {
         }
         return result;
     }
+    async getInternalTransactionsByHash(txhash) {
+        const result = await this.request({
+            module: "account",
+            action: "txlistinternal",
+            txhash,
+        });
+        if (typeof result === "string") {
+            return [];
+        }
+        return result;
+    }
     async getTokenTransfers(address, limit = DEFAULT_TRANSACTION_LIMIT) {
         const result = await this.request({
             module: "account",
@@ -115,13 +126,20 @@ export class EtherscanClient {
         }
         return result[0];
     }
-    async getTransactionReceipt(hash) {
+    async getContractInfo(address) {
         const result = await this.request({
-            module: "proxy",
-            action: "eth_getTransactionReceipt",
-            txhash: hash,
+            module: "contract",
+            action: "getsourcecode",
+            address,
         });
-        return result;
+        if (typeof result === "string" || result.length === 0) {
+            return null;
+        }
+        const info = result[0];
+        if (!info.ContractName || info.ContractName === "") {
+            return null;
+        }
+        return info;
     }
 }
 export function weiToEth(wei) {

package/dist/tools/blockchain/event-decoder.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Event decoder for common ERC-20 and WETH events
+ */
+import { type TransactionLog, type DecodedEvent, type LabeledAddress } from "./types";
+export interface AddressResolver {
+    resolve(address: string): Promise<LabeledAddress>;
+}
+export declare function decodeEvent(log: TransactionLog, resolver: AddressResolver): Promise<DecodedEvent | null>;
+export declare function decodeEvents(logs: TransactionLog[], resolver: AddressResolver): Promise<{
+    decoded: DecodedEvent[];
+    undecodedCount: number;
+}>;
+export declare function isKnownEvent(topic0: string): boolean;
+export declare function getEventName(topic0: string): string | null;

package/dist/tools/blockchain/event-decoder.js

@@ -0,0 +1,96 @@
+/**
+ * Event decoder for common ERC-20 and WETH events
+ */
+const EVENT_SIGNATURES = {
+    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef": "Transfer",
+    "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925": "Approval",
+    "0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c": "Deposit",
+    "0x7fcf532c15f0a6db0bd6d0e038bea71d30d808c7d98cb3bf7268a95bf5081b65": "Withdrawal",
+};
+function decodeAddress(topic) {
+    return "0x" + topic.slice(26).toLowerCase();
+}
+function decodeUint256(data) {
+    const hex = data.startsWith("0x") ? data.slice(2) : data;
+    if (hex === "")
+        return "0";
+    return BigInt("0x" + hex).toString();
+}
+export async function decodeEvent(log, resolver) {
+    const topic0 = log.topics[0];
+    const signature = EVENT_SIGNATURES[topic0];
+    if (!signature) {
+        return null;
+    }
+    const contractAddress = await resolver.resolve(log.address);
+    switch (signature) {
+        case "Transfer": {
+            if (log.topics.length < 3)
+                return null;
+            const from = decodeAddress(log.topics[1]);
+            const to = decodeAddress(log.topics[2]);
+            const value = decodeUint256(log.data);
+            return {
+                name: "Transfer",
+                address: contractAddress,
+                params: { from, to, value },
+            };
+        }
+        case "Approval": {
+            if (log.topics.length < 3)
+                return null;
+            const owner = decodeAddress(log.topics[1]);
+            const spender = decodeAddress(log.topics[2]);
+            const value = decodeUint256(log.data);
+            return {
+                name: "Approval",
+                address: contractAddress,
+                params: { owner, spender, value },
+            };
+        }
+        case "Deposit": {
+            if (log.topics.length < 2)
+                return null;
+            const dst = decodeAddress(log.topics[1]);
+            const wad = decodeUint256(log.data);
+            return {
+                name: "Deposit",
+                address: contractAddress,
+                params: { dst, wad },
+            };
+        }
+        case "Withdrawal": {
+            if (log.topics.length < 2)
+                return null;
+            const src = decodeAddress(log.topics[1]);
+            const wad = decodeUint256(log.data);
+            return {
+                name: "Withdrawal",
+                address: contractAddress,
+                params: { src, wad },
+            };
+        }
+        default:
+            return null;
+    }
+}
+export async function decodeEvents(logs, resolver) {
+    const decoded = [];
+    let undecodedCount = 0;
+    for (const log of logs) {
+        const event = await decodeEvent(log, resolver);
+        if (event) {
+            decoded.push(event);
+        }
+        else {
+            undecodedCount++;
+        }
+    }
+    return { decoded, undecodedCount };
+}
+export function isKnownEvent(topic0) {
+    return topic0 in EVENT_SIGNATURES;
+}
+export function getEventName(topic0) {
+    return EVENT_SIGNATURES[topic0] ?? null;
+}

package/dist/tools/blockchain/event-decoder.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/blockchain/event-decoder.test.js

@@ -0,0 +1,197 @@
+import { describe, it, expect } from "vitest";
+import { decodeEvent, decodeEvents, isKnownEvent, getEventName, } from "./event-decoder";
+const mockResolver = {
+    async resolve(address) {
+        return { address, label: null };
+    },
+};
+describe("Event Decoder", () => {
+    describe("isKnownEvent", () => {
+        it("should recognize Transfer event", () => {
+            const topic0 = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+            expect(isKnownEvent(topic0)).toBe(true);
+        });
+        it("should recognize Approval event", () => {
+            const topic0 = "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925";
+            expect(isKnownEvent(topic0)).toBe(true);
+        });
+        it("should recognize Deposit event", () => {
+            const topic0 = "0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c";
+            expect(isKnownEvent(topic0)).toBe(true);
+        });
+        it("should recognize Withdrawal event", () => {
+            const topic0 = "0x7fcf532c15f0a6db0bd6d0e038bea71d30d808c7d98cb3bf7268a95bf5081b65";
+            expect(isKnownEvent(topic0)).toBe(true);
+        });
+        it("should return false for unknown event", () => {
+            const topic0 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+            expect(isKnownEvent(topic0)).toBe(false);
+        });
+    });
+    describe("getEventName", () => {
+        it("should return Transfer for Transfer topic", () => {
+            const topic0 = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+            expect(getEventName(topic0)).toBe("Transfer");
+        });
+        it("should return null for unknown topic", () => {
+            const topic0 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+            expect(getEventName(topic0)).toBe(null);
+        });
+    });
+    describe("decodeEvent", () => {
+        it("should decode Transfer event", async () => {
+            const log = {
+                address: "0x6b175474e89094c44da98b954eedeac495271d0f",
+                topics: [
+                    "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                    "0x000000000000000000000000ba12222222228d8ba445958a75a0704d566bf2c8",
+                    "0x000000000000000000000000000000002b0184b12e908bf97941f2f5385c9820",
+                ],
+                data: "0x000000000000000000000000000000000000000000000278fd3c000000000000",
+                blockNumber: "0x1234",
+                transactionHash: "0xabc",
+                transactionIndex: "0x0",
+                blockHash: "0xdef",
+                logIndex: "0x0",
+                removed: false,
+            };
+            const result = await decodeEvent(log, mockResolver);
+            expect(result).not.toBeNull();
+            expect(result.name).toBe("Transfer");
+            expect(result.params.from).toBe("0xba12222222228d8ba445958a75a0704d566bf2c8");
+            expect(result.params.to).toBe("0x000000002b0184b12e908bf97941f2f5385c9820");
+            expect(result.params.value).toBe("11676589714374635028480");
+        });
+        it("should decode Approval event", async () => {
+            const log = {
+                address: "0x6b175474e89094c44da98b954eedeac495271d0f",
+                topics: [
+                    "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
+                    "0x0000000000000000000000001111111111111111111111111111111111111111",
+                    "0x0000000000000000000000002222222222222222222222222222222222222222",
+                ],
+                data: "0x0000000000000000000000000000000000000000000000000de0b6b3a7640000",
+                blockNumber: "0x1234",
+                transactionHash: "0xabc",
+                transactionIndex: "0x0",
+                blockHash: "0xdef",
+                logIndex: "0x0",
+                removed: false,
+            };
+            const result = await decodeEvent(log, mockResolver);
+            expect(result).not.toBeNull();
+            expect(result.name).toBe("Approval");
+            expect(result.params.owner).toBe("0x1111111111111111111111111111111111111111");
+            expect(result.params.spender).toBe("0x2222222222222222222222222222222222222222");
+            expect(result.params.value).toBe("1000000000000000000");
+        });
+        it("should decode Deposit event (WETH)", async () => {
+            const log = {
+                address: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                topics: [
+                    "0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c",
+                    "0x0000000000000000000000001111111111111111111111111111111111111111",
+                ],
+                data: "0x0000000000000000000000000000000000000000000000000de0b6b3a7640000",
+                blockNumber: "0x1234",
+                transactionHash: "0xabc",
+                transactionIndex: "0x0",
+                blockHash: "0xdef",
+                logIndex: "0x0",
+                removed: false,
+            };
+            const result = await decodeEvent(log, mockResolver);
+            expect(result).not.toBeNull();
+            expect(result.name).toBe("Deposit");
+            expect(result.params.dst).toBe("0x1111111111111111111111111111111111111111");
+            expect(result.params.wad).toBe("1000000000000000000");
+        });
+        it("should decode Withdrawal event (WETH)", async () => {
+            const log = {
+                address: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                topics: [
+                    "0x7fcf532c15f0a6db0bd6d0e038bea71d30d808c7d98cb3bf7268a95bf5081b65",
+                    "0x0000000000000000000000001111111111111111111111111111111111111111",
+                ],
+                data: "0x0000000000000000000000000000000000000000000000000de0b6b3a7640000",
+                blockNumber: "0x1234",
+                transactionHash: "0xabc",
+                transactionIndex: "0x0",
+                blockHash: "0xdef",
+                logIndex: "0x0",
+                removed: false,
+            };
+            const result = await decodeEvent(log, mockResolver);
+            expect(result).not.toBeNull();
+            expect(result.name).toBe("Withdrawal");
+            expect(result.params.src).toBe("0x1111111111111111111111111111111111111111");
+            expect(result.params.wad).toBe("1000000000000000000");
+        });
+        it("should return null for unknown event", async () => {
+            const log = {
+                address: "0x1234567890123456789012345678901234567890",
+                topics: ["0x0000000000000000000000000000000000000000000000000000000000000000"],
+                data: "0x",
+                blockNumber: "0x1234",
+                transactionHash: "0xabc",
+                transactionIndex: "0x0",
+                blockHash: "0xdef",
+                logIndex: "0x0",
+                removed: false,
+            };
+            const result = await decodeEvent(log, mockResolver);
+            expect(result).toBeNull();
+        });
+    });
+    describe("decodeEvents", () => {
+        it("should decode multiple events and count undecoded", async () => {
+            const logs = [
+                {
+                    address: "0x6b175474e89094c44da98b954eedeac495271d0f",
+                    topics: [
+                        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+                        "0x0000000000000000000000001111111111111111111111111111111111111111",
+                        "0x0000000000000000000000002222222222222222222222222222222222222222",
+                    ],
+                    data: "0x0000000000000000000000000000000000000000000000000de0b6b3a7640000",
+                    blockNumber: "0x1234",
+                    transactionHash: "0xabc",
+                    transactionIndex: "0x0",
+                    blockHash: "0xdef",
+                    logIndex: "0x0",
+                    removed: false,
+                },
+                {
+                    address: "0x1234567890123456789012345678901234567890",
+                    topics: ["0x0000000000000000000000000000000000000000000000000000000000000000"],
+                    data: "0x",
+                    blockNumber: "0x1234",
+                    transactionHash: "0xabc",
+                    transactionIndex: "0x0",
+                    blockHash: "0xdef",
+                    logIndex: "0x1",
+                    removed: false,
+                },
+                {
+                    address: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                    topics: [
+                        "0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c",
+                        "0x0000000000000000000000001111111111111111111111111111111111111111",
+                    ],
+                    data: "0x0000000000000000000000000000000000000000000000000de0b6b3a7640000",
+                    blockNumber: "0x1234",
+                    transactionHash: "0xabc",
+                    transactionIndex: "0x0",
+                    blockHash: "0xdef",
+                    logIndex: "0x2",
+                    removed: false,
+                },
+            ];
+            const result = await decodeEvents(logs, mockResolver);
+            expect(result.decoded.length).toBe(2);
+            expect(result.undecodedCount).toBe(1);
+            expect(result.decoded[0].name).toBe("Transfer");
+            expect(result.decoded[1].name).toBe("Deposit");
+        });
+    });
+});