opencode-froggy 0.3.0 → 0.4.0

package/README.md

@@ -22,6 +22,7 @@ Plugin providing Claude Code–style hooks, specialized agents (doc-writer, code
   - [prompt-session](#prompt-session)
   - [list-child-sessions](#list-child-sessions)
   - [Blockchain](#blockchain)
+    - [Configuration](#configuration)
     - [eth-transaction](#eth-transaction)
     - [eth-address-balance](#eth-address-balance)
     - [eth-address-txs](#eth-address-txs)
@@ -140,38 +141,26 @@ gitingest({
 
 ### diff-summary
 
-Generate a structured summary of git diffs. Use for reviewing branch comparisons or working tree changes. Returns stats, commits, files changed, and full diff in a structured markdown format.
+**Command** that displays a structured summary of git working tree changes (staged, unstaged, and untracked files). Injects git diff output directly into the prompt using bash commands.
 
-#### Parameters
+#### Usage
 
-| Parameter | Type | Required | Default | Description |
-|-----------|------|----------|---------|-------------|
-| `source` | `string` | No | - | Source branch to compare (e.g., `feature-branch`). If omitted, analyzes working tree changes. |
-| `target` | `string` | No | `main` | Target branch to compare against |
-| `remote` | `string` | No | `origin` | Git remote name |
+```bash
+/diff-summary
+```
 
-#### Usage Examples
+#### What it shows
 
-```typescript
-// Analyze working tree changes (staged, unstaged, and untracked files)
-diffSummary({})
+- Git status (porcelain format)
+- Staged changes (stats and full diff)
+- Unstaged changes (stats and full diff)
+- Untracked files content (first 50 lines of each file)
 
-// Compare feature branch against main
-diffSummary({ source: "feature-branch" })
+#### Implementation
 
-// Compare feature branch against develop
-diffSummary({ 
-  source: "feature-branch",
-  target: "develop"
-})
+This command uses OpenCode's `!`\`...\`` syntax to inject bash command output directly into the prompt, avoiding the 2000-line truncation limit that affects tools.
 
-// Compare branches on a different remote
-diffSummary({
-  source: "feature-branch",
-  target: "main",
-  remote: "upstream"
-})
-```
+See `command/diff-summary.md` for the full implementation.
 
 #### Output Structure
 
@@ -279,9 +268,35 @@ All blockchain tools support multiple chains via the `chainId` parameter:
 | `250` | Fantom |
 | `324` | zkSync |
 
+#### Configuration
+
+The blockchain tools use Etherscan-compatible APIs. An API key is optional but recommended.
+
+**Environment Variable:**
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `ETHERSCAN_API_KEY` | No | API key for Etherscan and compatible explorers |
+
+**Without an API key:** Requests are rate-limited (typically 1 request per 5 seconds).
+
+**With an API key:** Higher rate limits and more reliable access.
+
+**Getting an API key:**
+
+1. Create a free account at [etherscan.io](https://etherscan.io/register)
+2. Navigate to API Keys in your account settings
+3. Generate a new API key
+
+**Setting the environment variable:**
+
+```bash
+export ETHERSCAN_API_KEY="your-api-key-here"
+```
+
 #### eth-transaction
 
-Get Ethereum transaction details by transaction hash. Returns status, block, addresses, gas costs, and log count.
+Get Ethereum transaction details by transaction hash. Returns status, block, addresses, gas costs in JSON format. Use optional parameters to include internal transactions, token transfers, and decoded event logs.
 
 ##### Parameters
 
@@ -289,11 +304,14 @@ Get Ethereum transaction details by transaction hash. Returns status, block, add
 |-----------|------|----------|---------|-------------|
 | `hash` | `string` | Yes | - | Transaction hash (0x...) |
 | `chainId` | `string` | No | `"1"` | Chain ID (see table above) |
+| `includeInternalTxs` | `boolean` | No | `false` | Include internal transactions (ETH transfers between contracts) |
+| `includeTokenTransfers` | `boolean` | No | `false` | Include ERC-20 token transfers |
+| `decodeLogs` | `boolean` | No | `false` | Decode event logs (Transfer, Approval, Deposit, Withdrawal) |
 
 ##### Usage Examples
 
 ```typescript
-// Get transaction on Ethereum mainnet
+// Get basic transaction details on Ethereum mainnet
 ethTransaction({ hash: "0x123abc..." })
 
 // Get transaction on Polygon
@@ -301,8 +319,90 @@ ethTransaction({
   hash: "0x123abc...",
   chainId: "137"
 })
+
+// Get transaction with internal transactions and token transfers
+ethTransaction({ 
+  hash: "0x123abc...",
+  includeInternalTxs: true,
+  includeTokenTransfers: true
+})
+
+// Get full transaction details with decoded event logs
+ethTransaction({ 
+  hash: "0x123abc...",
+  includeInternalTxs: true,
+  includeTokenTransfers: true,
+  decodeLogs: true
+})
+```
+
+##### Output Structure
+
+The tool returns JSON with labeled addresses (contract names resolved via Etherscan):
+
+```json
+{
+  "hash": "0x123...",
+  "status": "success",
+  "block": 12345678,
+  "from": { "address": "0xabc...", "label": "Uniswap V3: Router" },
+  "to": { "address": "0xdef...", "label": "WETH" },
+  "value": "0",
+  "gas": { "used": 150000, "price": "20000000000", "cost": "0.003" }
+}
+```
+
+With `includeInternalTxs: true`:
+```json
+{
+  "internalTransactions": [
+    {
+      "from": { "address": "0x...", "label": "Uniswap V3: Router" },
+      "to": { "address": "0x...", "label": null },
+      "value": "1.5",
+      "type": "call"
+    }
+  ]
+}
 ```
 
+With `includeTokenTransfers: true`:
+```json
+{
+  "tokenTransfers": [
+    {
+      "token": { "address": "0x...", "name": "Wrapped Ether", "symbol": "WETH", "decimals": 18 },
+      "from": { "address": "0x...", "label": null },
+      "to": { "address": "0x...", "label": "Uniswap V3: Router" },
+      "value": "1.5"
+    }
+  ]
+}
+```
+
+With `decodeLogs: true`:
+```json
+{
+  "decodedEvents": [
+    {
+      "name": "Transfer",
+      "address": { "address": "0x...", "label": "WETH" },
+      "params": { "from": "0x...", "to": "0x...", "value": "1500000000000000000" }
+    }
+  ],
+  "undecodedEventsCount": 2
+}
+```
+
+##### Supported Decoded Events
+
+| Event | Description |
+|-------|-------------|
+| `Transfer` | ERC-20 token transfer |
+| `Approval` | ERC-20 approval for spending |
+| `Deposit` | WETH deposit (ETH → WETH) |
+| `Withdrawal` | WETH withdrawal (WETH → ETH) |
+
 #### eth-address-balance
 
 Get the ETH balance of an Ethereum address. Returns balance in both ETH and Wei.

package/command/commit-push.md

@@ -9,7 +9,7 @@ agent: build
 
 ## Your task
 
-1. Use the `diff-summary` tool (without parameters) to analyze all working tree changes
+1. Run `/diff-summary` to analyze all working tree changes
 2. Present a summary to the user:
    - Files modified/added/deleted with stats
    - Proposed commit message based on the changes

package/command/diff-summary.md

@@ -0,0 +1,19 @@
+---
+description: Show working tree changes (staged, unstaged, untracked)
+---
+
+# Diff Summary: Working Tree → HEAD
+
+## Status
+!`git status --porcelain`
+
+## Staged Changes
+!`git diff --cached --stat`
+!`git diff --cached`
+
+## Unstaged Changes
+!`git diff --stat`
+!`git diff`
+
+## Untracked Files Content
+!`bash -c 'git ls-files --others --exclude-standard | while read f; do [ -f "$f" ] && echo "=== $f ===" && sed -n "1,50p" "$f" && sed -n "51p" "$f" | grep -q . && echo "... (truncated)"; done'`

package/command/doc-changes.md

@@ -5,7 +5,7 @@ agent: doc-writer
 
 ## Analysis Phase
 
-Use the `diff-summary` tool (without parameters) to get the working tree changes, then:
+Run `/diff-summary` to get the working tree changes, then:
 
 1. **Identify new features** in the changes:
    - New public APIs, functions, or methods

package/command/review-changes.md

@@ -5,4 +5,18 @@ agent: code-reviewer
 
 # Review: Working Tree → HEAD
 
-Use the `diff-summary` tool (without parameters) to get the working tree changes, then review them.
+## Status
+!`git status --porcelain`
+
+## Staged Changes
+!`git diff --cached --stat`
+!`git diff --cached`
+
+## Unstaged Changes
+!`git diff --stat`
+!`git diff`
+
+## Untracked Files Content
+!`bash -c 'git ls-files --others --exclude-standard | while read f; do [ -f "$f" ] && echo "=== $f ===" && sed -n "1,50p" "$f" && sed -n "51p" "$f" | grep -q . && echo "... (truncated)"; done'`
+
+Review the above changes for quality, correctness, and adherence to project guidelines.

package/command/review-pr.md

@@ -3,6 +3,21 @@ description: Review changes from source branch into target branch
 agent: code-reviewer
 ---
 
-# Review: origin/$1 → origin/$2
+# Review: $1 → $2
 
-Use the `diff-summary` tool with `source: "$1"` and `target: "$2"` to get the diff, then review the changes.
+## Fetch latest
+!`git fetch --all --prune 2>/dev/null || true`
+
+## Stats Overview
+!`git diff --stat $2...$1`
+
+## Commits to Review
+!`git log --oneline --no-merges $2..$1`
+
+## Files Changed
+!`git diff --name-only $2...$1`
+
+## Full Diff
+!`git diff -U5 --function-context $2...$1`
+
+Review the above changes for quality, correctness, and adherence to project guidelines.

package/command/simplify-changes.md

@@ -5,4 +5,4 @@ agent: code-simplifier
 
 # Simplify: Working Tree → HEAD
 
-Use the `diff-summary` tool (without parameters) to get the working tree changes, then simplify them.
+Run `/diff-summary` to get the working tree changes, then simplify them.

package/dist/index.js

@@ -5,7 +5,7 @@ import { getGlobalHookDir, getProjectHookDir } from "./config-paths";
 import { hasCodeExtension } from "./code-files";
 import { log } from "./logger";
 import { executeBashAction, DEFAULT_BASH_TIMEOUT, } from "./bash-executor";
-import { gitingestTool, createDiffSummaryTool, createPromptSessionTool, createListChildSessionsTool, ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, } from "./tools";
+import { gitingestTool, createPromptSessionTool, createListChildSessionsTool, ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, } from "./tools";
 export { parseFrontmatter, loadAgents, loadCommands } from "./loaders";
 // ============================================================================
 // CONSTANTS
@@ -32,7 +32,6 @@ const SmartfrogPlugin = async (ctx) => {
         hooks: Array.from(hooks.keys()),
         tools: [
             "gitingest",
-            "diff-summary",
             "eth-transaction",
             "eth-address-txs",
             "eth-address-balance",
@@ -183,7 +182,6 @@ const SmartfrogPlugin = async (ctx) => {
         },
         tool: {
             gitingest: gitingestTool,
-            "diff-summary": createDiffSummaryTool(ctx.directory),
             "prompt-session": createPromptSessionTool(ctx.client),
             "list-child-sessions": createListChildSessionsTool(ctx.client),
             "eth-transaction": ethTransactionTool,

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;