@clawnch/clawtomaton 0.8.1 → 0.9.0

package/dist/skills/herd.js

@@ -0,0 +1,687 @@
+/**
+ * Skill: herd_intelligence — On-chain intelligence via Herd MCP.
+ *
+ * Multi-action skill that exposes HerdIntelligence composed methods
+ * to the Clawtomaton agent. Combines Herd's block explorer data with
+ * Clawncher's domain-specific on-chain reading.
+ *
+ * Actions (all read-only, available at normal + low_compute tiers):
+ *   investigate          — Investigate contract, tx, or wallet (auto-detects)
+ *   audit_token          — Security audit with risk score (0-100)
+ *   validate_swap        — Pre-swap route validation vs historical data
+ *   validate_claim       — Fee-claim validation vs historical claims
+ *   profile_counterparty — Trust assessment for a wallet/contract
+ *   search_code          — Regex search across on-chain contract code
+ *   track_token          — Track token transfers for a given holder+token
+ *   bookmark             — List/add/remove Herd bookmarks
+ *   simulate             — Generate HAL expressions for simulation
+ *
+ * Requires HERD_ACCESS_TOKEN env var or stored auth at ~/.clawncher/herd-auth.json.
+ */
+import { HerdIntelligence, HalBuilder } from '@clawnch/clawncher-sdk';
+import { isAddress, isHash } from 'viem';
+// ============================================================================
+// Tier permissions — all actions are read-only, no gas cost
+// ============================================================================
+const ALL_ACTIONS = new Set([
+    'investigate',
+    'audit_token',
+    'validate_swap',
+    'validate_claim',
+    'profile_counterparty',
+    'search_code',
+    'track_token',
+    'bookmark',
+    'simulate',
+]);
+const TIER_ALLOWED = {
+    normal: new Set(ALL_ACTIONS),
+    low_compute: new Set(ALL_ACTIONS),
+    critical: new Set(['investigate', 'audit_token', 'bookmark']),
+    dead: new Set(),
+};
+// ============================================================================
+// Cached HerdIntelligence singleton
+// ============================================================================
+let cachedHerd = null;
+async function getHerd(ctx) {
+    if (cachedHerd)
+        return cachedHerd;
+    const rpcUrl = process.env.BASE_RPC_URL ?? 'https://mainnet.base.org';
+    // Dynamic import to match check-price pattern
+    const { buildClients } = await import('../identity/index.js');
+    const { publicClient } = buildClients(ctx.identity, rpcUrl);
+    const config = {
+        publicClient: publicClient,
+        network: 'mainnet',
+        accessToken: process.env.HERD_ACCESS_TOKEN,
+    };
+    cachedHerd = new HerdIntelligence(config);
+    return cachedHerd;
+}
+// ============================================================================
+// Skill Definition
+// ============================================================================
+export const herdIntelligenceSkill = {
+    name: 'herd_intelligence',
+    description: 'On-chain intelligence powered by Herd MCP. ' +
+        'Actions: investigate (contract/tx/wallet auto-detect), audit_token (security risk score 0-100), ' +
+        'validate_swap (pre-swap safety check), validate_claim (fee claim validation), ' +
+        'profile_counterparty (trust assessment), search_code (regex code search), ' +
+        'track_token (token flow tracking), bookmark (list/add/remove), ' +
+        'simulate (HAL expression builder for transfer/swap/balance/allowance/approve). ' +
+        'All actions are read-only (no gas cost). Requires HERD_ACCESS_TOKEN.',
+    parameters: [
+        {
+            name: 'action',
+            type: 'string',
+            description: 'Action: investigate, audit_token, validate_swap, validate_claim, ' +
+                'profile_counterparty, search_code, track_token, bookmark, simulate',
+            required: true,
+        },
+        {
+            name: 'target',
+            type: 'string',
+            description: 'Target address or tx hash. For investigate: auto-detects contract/tx/wallet. ' +
+                'For audit_token/validate_claim/profile_counterparty: address. ' +
+                'For search_code: contract address(es), comma-separated. ' +
+                'For track_token: holder address.',
+            required: false,
+        },
+        {
+            name: 'token_in',
+            type: 'address',
+            description: 'Token-in address for validate_swap. For track_token: the token address.',
+            required: false,
+        },
+        {
+            name: 'token_out',
+            type: 'address',
+            description: 'Token-out address for validate_swap.',
+            required: false,
+        },
+        {
+            name: 'amount',
+            type: 'string',
+            description: 'Amount (human-readable) for validate_swap or simulate.',
+            required: false,
+        },
+        {
+            name: 'pattern',
+            type: 'string',
+            description: 'Regex or natural language query for search_code.',
+            required: false,
+        },
+        {
+            name: 'bookmark_action',
+            type: 'string',
+            description: 'For bookmark action: list, add, or remove.',
+            required: false,
+        },
+        {
+            name: 'label',
+            type: 'string',
+            description: 'Label/note for bookmark add.',
+            required: false,
+        },
+        {
+            name: 'bookmark_type',
+            type: 'string',
+            description: 'Bookmark type: contract, wallet, transaction.',
+            required: false,
+        },
+        {
+            name: 'simulate_type',
+            type: 'string',
+            description: 'For simulate: transfer, swap, balance, allowance, approve.',
+            required: false,
+        },
+        {
+            name: 'recipient',
+            type: 'address',
+            description: 'Recipient address for simulate transfer.',
+            required: false,
+        },
+        {
+            name: 'chain',
+            type: 'string',
+            description: 'Blockchain: base or ethereum. Defaults to base.',
+            required: false,
+        },
+    ],
+    execute: executeHerdIntelligence,
+};
+// ============================================================================
+// Executor
+// ============================================================================
+async function executeHerdIntelligence(params, ctx) {
+    const action = params.action;
+    if (!action) {
+        return fail('Missing required parameter: action');
+    }
+    // Check tier permissions
+    const allowed = TIER_ALLOWED[ctx.survival.tier];
+    if (!allowed || !allowed.has(action)) {
+        return fail(`Action "${action}" not allowed at ${ctx.survival.tier} tier. ` +
+            `Available: ${[...allowed].join(', ')}`);
+    }
+    try {
+        const herd = await getHerd(ctx);
+        switch (action) {
+            case 'investigate':
+                return await actionInvestigate(herd, params);
+            case 'audit_token':
+                return await actionAuditToken(herd, params);
+            case 'validate_swap':
+                return await actionValidateSwap(herd, params);
+            case 'validate_claim':
+                return await actionValidateClaim(herd, params);
+            case 'profile_counterparty':
+                return await actionProfileCounterparty(herd, params);
+            case 'search_code':
+                return await actionSearchCode(herd, params);
+            case 'track_token':
+                return await actionTrackToken(herd, params);
+            case 'bookmark':
+                return await actionBookmark(herd, params);
+            case 'simulate':
+                return await actionSimulate(params);
+            default:
+                return fail(`Unknown action: "${action}". Valid: investigate, audit_token, validate_swap, ` +
+                    `validate_claim, profile_counterparty, search_code, track_token, bookmark, simulate`);
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes('authentication required') || msg.includes('HERD_ACCESS_TOKEN')) {
+            return fail('Herd authentication required. Set HERD_ACCESS_TOKEN env var or run `clawncher herd auth`.');
+        }
+        return fail(msg);
+    }
+}
+// ============================================================================
+// Actions
+// ============================================================================
+async function actionInvestigate(herd, params) {
+    const target = params.target;
+    if (!target) {
+        return fail('Missing required parameter: target (address or tx hash)');
+    }
+    const blockchain = params.chain || undefined;
+    // Auto-detect target type
+    if (isHash(target)) {
+        const profile = await herd.investigateTransaction(target, { blockchain });
+        return ok(formatTransactionProfile(profile));
+    }
+    if (isAddress(target)) {
+        // Try contract first
+        const profile = await herd.investigateContract(target, { blockchain });
+        if (profile.name || profile.functions.length > 0 || profile.proxy) {
+            return ok(formatContractProfile(profile));
+        }
+        // Fall back to wallet
+        const wallet = await herd.investigateWallet(target, { blockchain });
+        return ok(formatWalletProfile(wallet));
+    }
+    return fail('Invalid target. Provide a valid address (0x..., 42 chars) or tx hash (0x..., 66 chars).');
+}
+async function actionAuditToken(herd, params) {
+    const target = params.target;
+    if (!target || !isAddress(target)) {
+        return fail('Missing or invalid target address for audit_token.');
+    }
+    const blockchain = params.chain || undefined;
+    const audit = await herd.auditTokenSafety(target, { blockchain });
+    return ok(formatAuditReport(audit), {
+        riskScore: audit.riskScore,
+        riskLevel: audit.riskLevel,
+        findingCount: audit.findings.length,
+    });
+}
+async function actionValidateSwap(herd, params) {
+    const tokenIn = (params.token_in || params.target);
+    const tokenOut = params.token_out;
+    const amount = params.amount || '1.0';
+    if (!tokenIn || !isAddress(tokenIn)) {
+        return fail('Missing or invalid token_in address for validate_swap.');
+    }
+    if (!tokenOut || !isAddress(tokenOut)) {
+        return fail('Missing or invalid token_out address for validate_swap.');
+    }
+    const blockchain = params.chain || undefined;
+    const validation = await herd.validateSwapRoute(tokenIn, tokenOut, amount, { blockchain });
+    return ok(formatSwapValidation(validation), {
+        recommendation: validation.analysis.recommendation,
+        quoteReasonable: validation.analysis.quoteReasonable,
+        warningCount: validation.analysis.warnings.length,
+    });
+}
+async function actionValidateClaim(herd, params) {
+    const target = params.target;
+    if (!target || !isAddress(target)) {
+        return fail('Missing or invalid target token address for validate_claim.');
+    }
+    const blockchain = params.chain || undefined;
+    const validation = await herd.validateFeeClaim(target, { blockchain });
+    return ok(formatFeeClaimValidation(validation), {
+        estimateReliable: validation.analysis.estimateReliable,
+        estimatedNetProfitEth: validation.analysis.estimatedNetProfitEth,
+        warningCount: validation.analysis.warnings.length,
+    });
+}
+async function actionProfileCounterparty(herd, params) {
+    const target = params.target;
+    if (!target || !isAddress(target)) {
+        return fail('Missing or invalid target address for profile_counterparty.');
+    }
+    const blockchain = params.chain || undefined;
+    const profile = await herd.profileCounterparty(target, { blockchain });
+    return ok(formatCounterpartyProfile(profile), {
+        trustLevel: profile.riskAssessment.trustLevel,
+        factorCount: profile.riskAssessment.factors.length,
+    });
+}
+async function actionSearchCode(herd, params) {
+    const target = params.target;
+    const pattern = params.pattern;
+    if (!target) {
+        return fail('Missing target address(es) for search_code.');
+    }
+    if (!pattern) {
+        return fail('Missing required parameter: pattern (regex or query)');
+    }
+    // Support comma-separated addresses
+    const addresses = target.split(',').map((a) => a.trim());
+    for (const addr of addresses) {
+        if (!isAddress(addr)) {
+            return fail(`Invalid address in target list: ${addr}`);
+        }
+    }
+    const results = await herd.searchCode(addresses, pattern);
+    if (!results || results.trim().length === 0) {
+        return ok(`No matches found for "${pattern}" in ${addresses.join(', ')}`);
+    }
+    return ok(`Code search results for "${pattern}":\n${results}`);
+}
+async function actionTrackToken(herd, params) {
+    const holder = params.target;
+    const token = params.token_in;
+    if (!holder || !isAddress(holder)) {
+        return fail('Missing or invalid target (holder address) for track_token.');
+    }
+    if (!token || !isAddress(token)) {
+        return fail('Missing or invalid token_in (token address) for track_token.');
+    }
+    const blockchain = params.chain || undefined;
+    const flow = await herd.trackTokenFlow(holder, token, { blockchain });
+    return ok(formatTokenFlow(flow));
+}
+async function actionBookmark(herd, params) {
+    const subAction = params.bookmark_action || 'list';
+    switch (subAction) {
+        case 'list': {
+            const bookmarks = await herd.getBookmarks();
+            if (bookmarks.length === 0) {
+                return ok('No bookmarks saved.');
+            }
+            const lines = bookmarks.map((b, i) => `${i + 1}. [${b.objectType}] ${b.objectId}${b.label ? ` — ${b.label}` : ''}${b.blockchain ? ` (${b.blockchain})` : ''}`);
+            return ok(`=== Herd Bookmarks (${bookmarks.length}) ===\n${lines.join('\n')}`);
+        }
+        case 'add': {
+            const target = params.target;
+            if (!target) {
+                return fail('Missing target address/hash for bookmark add.');
+            }
+            const objType = params.bookmark_type || 'contract';
+            const label = params.label || undefined;
+            const chain = params.chain || undefined;
+            await herd.bookmark(objType, target, label, chain);
+            return ok(`Bookmarked ${target} as ${objType}${label ? ` (${label})` : ''}.`);
+        }
+        case 'remove': {
+            const target = params.target;
+            if (!target) {
+                return fail('Missing target address/hash for bookmark remove.');
+            }
+            const objType = params.bookmark_type || 'contract';
+            const chain = params.chain || undefined;
+            await herd.removeBookmark(objType, target, chain);
+            return ok(`Removed bookmark for ${target}.`);
+        }
+        default:
+            return fail(`Unknown bookmark_action: "${subAction}". Valid: list, add, remove.`);
+    }
+}
+async function actionSimulate(params) {
+    const simType = params.simulate_type;
+    if (!simType) {
+        return fail('Missing required parameter: simulate_type (transfer, swap, balance, allowance, approve)');
+    }
+    const target = params.target;
+    const chain = params.chain || 'base';
+    const hal = new HalBuilder();
+    try {
+        let expression;
+        switch (simType) {
+            case 'transfer': {
+                if (!target)
+                    return fail('Missing target (token address) for transfer simulation.');
+                expression = hal.buildTransferAdapter({ token: target, blockchain: chain });
+                break;
+            }
+            case 'swap': {
+                const sellToken = (params.token_in || target);
+                const buyToken = params.token_out;
+                if (!sellToken)
+                    return fail('Missing token_in (sell token) for swap simulation.');
+                if (!buyToken)
+                    return fail('Missing token_out (buy token) for swap simulation.');
+                expression = hal.buildSwapAction({ sellToken, buyToken, blockchain: chain });
+                break;
+            }
+            case 'balance': {
+                if (!target)
+                    return fail('Missing target (token address) for balance read.');
+                expression = hal.buildBalanceReader({ token: target, blockchain: chain });
+                break;
+            }
+            case 'allowance': {
+                if (!target)
+                    return fail('Missing target (token address) for allowance read.');
+                const spender = params.recipient;
+                expression = hal.buildAllowanceReader({ token: target, blockchain: chain, spender });
+                break;
+            }
+            case 'approve': {
+                if (!target)
+                    return fail('Missing target (token address) for approve.');
+                expression = hal.buildApproveAdapter({ token: target, blockchain: chain });
+                break;
+            }
+            default:
+                return fail(`Unknown simulate_type: "${simType}". Valid: transfer, swap, balance, allowance, approve.`);
+        }
+        const exprJson = JSON.stringify(expression, null, 2);
+        return ok(`HAL Expression (${simType}):\n${exprJson}\n\nUse this expression with a HAL-compatible simulator to preview the result.`);
+    }
+    catch (err) {
+        return fail(`Failed to build HAL expression: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+// ============================================================================
+// Formatters
+// ============================================================================
+function formatContractProfile(p) {
+    const lines = [
+        `=== Contract: ${p.address} ===`,
+        p.name ? `Name: ${p.name}` : '',
+        p.compiler ? `Compiler: ${p.compiler}` : '',
+        p.protocol ? `Protocol: ${p.protocol}` : '',
+        p.verified ? 'Verified: Yes' : 'Verified: No',
+        p.proxy ? `Proxy: ${p.proxy.proxyType} → ${p.proxy.currentImplementation}` : '',
+    ];
+    if (p.token) {
+        lines.push(`\nToken: ${p.token.symbol}`);
+        lines.push(`  Decimals: ${p.token.decimals}`);
+        if (p.token.priceUsd !== null)
+            lines.push(`  Price: $${p.token.priceUsd}`);
+        if (p.token.marketCap !== null)
+            lines.push(`  Market Cap: $${formatLargeNumber(p.token.marketCap)}`);
+        if (p.token.holders !== null)
+            lines.push(`  Holders: ${p.token.holders}`);
+    }
+    if (p.clawncher) {
+        lines.push(`\nClawncher Token: Yes`);
+        lines.push(`  Fees (WETH): ${p.clawncher.feesWeth}`);
+        lines.push(`  Fees (Token): ${p.clawncher.feesToken}`);
+        lines.push(`  Vault: ${p.clawncher.vaultStatus}`);
+        lines.push(`  MEV Protection: ${p.clawncher.mevProtection ? 'Yes' : 'No'}`);
+        if (p.clawncher.agent)
+            lines.push(`  Agent: ${p.clawncher.agent}`);
+    }
+    if (p.securityFlags.length > 0) {
+        lines.push(`\nSecurity Flags (${p.securityFlags.length}):`);
+        for (const f of p.securityFlags) {
+            lines.push(`  [${f.severity}] ${f.category}: ${f.description}`);
+        }
+    }
+    if (p.functions.length > 0) {
+        const reads = p.functions.filter((f) => f.type === 'read');
+        const writes = p.functions.filter((f) => f.type === 'write');
+        lines.push(`\nFunctions: ${p.functions.length} (${reads.length} read, ${writes.length} write)`);
+        for (const fn of p.functions.slice(0, 10)) {
+            lines.push(`  [${fn.type}] ${fn.name}(${fn.inputs.map((i) => `${i.type} ${i.name}`).join(', ')})`);
+        }
+        if (p.functions.length > 10)
+            lines.push(`  ... and ${p.functions.length - 10} more`);
+    }
+    return lines.filter(Boolean).join('\n');
+}
+function formatTransactionProfile(p) {
+    const lines = [
+        `=== Transaction: ${p.hash} ===`,
+        `Status: ${p.success ? 'Success' : 'Failed'}`,
+        `Block: ${p.blockNumber}`,
+        `Timestamp: ${p.timestamp}`,
+        p.functionCalled ? `Function: ${p.functionCalled}` : '',
+        p.revertReason ? `Revert: ${p.revertReason}` : '',
+    ];
+    lines.push(`\nGas: ${p.gas.gasUsed} used, ${p.gas.costEth} ETH${p.gas.costUsd ? ` ($${p.gas.costUsd})` : ''}`);
+    if (p.balanceChanges.length > 0) {
+        lines.push(`\nBalance Changes (${p.balanceChanges.length}):`);
+        for (const bc of p.balanceChanges.slice(0, 10)) {
+            lines.push(`  ${bc.token}: ${bc.from} → ${bc.to} (${bc.amount}${bc.usdValue ? `, $${bc.usdValue}` : ''})`);
+        }
+        if (p.balanceChanges.length > 10)
+            lines.push(`  ... and ${p.balanceChanges.length - 10} more`);
+    }
+    if (p.events.length > 0) {
+        lines.push(`\nEvents (${p.events.length}):`);
+        for (const e of p.events.slice(0, 8)) {
+            lines.push(`  ${e.eventName}${e.contractName ? ` @ ${e.contractName}` : ''} (${e.contract})`);
+        }
+        if (p.events.length > 8)
+            lines.push(`  ... and ${p.events.length - 8} more`);
+    }
+    if (p.clawncher) {
+        lines.push(`\nClawncher: ${p.clawncher.operationType}`);
+        lines.push(`  ${p.clawncher.description}`);
+        if (p.clawncher.tokenAddress)
+            lines.push(`  Token: ${p.clawncher.tokenAddress}`);
+    }
+    return lines.filter(Boolean).join('\n');
+}
+function formatWalletProfile(p) {
+    const lines = [
+        `=== Wallet: ${p.address} ===`,
+        `Type: ${p.walletType}`,
+        p.totalValueUsd !== null ? `Total Value: $${formatLargeNumber(p.totalValueUsd)}` : '',
+    ];
+    if (p.activity) {
+        lines.push(`Transactions: ${p.activity.transactionCount}`);
+        lines.push(`Contracts Deployed: ${p.activity.contractsDeployed}`);
+        if (p.activity.firstTransaction)
+            lines.push(`First Active: ${p.activity.firstTransaction}`);
+    }
+    if (p.holdings.length > 0) {
+        lines.push(`\nTop Holdings (${p.holdings.length}):`);
+        for (const h of p.holdings.slice(0, 10)) {
+            lines.push(`  ${h.token}: ${h.balance}${h.usdValue !== null ? ` ($${formatLargeNumber(h.usdValue)})` : ''}`);
+        }
+        if (p.holdings.length > 10)
+            lines.push(`  ... and ${p.holdings.length - 10} more`);
+    }
+    if (p.multisig) {
+        lines.push(`\nMultisig: ${p.multisig.threshold}/${p.multisig.signers.length} signers`);
+        lines.push(`  Pending: ${p.multisig.pendingTransactions} txs`);
+    }
+    if (p.clawncher) {
+        lines.push(`\nClawncher:`);
+        lines.push(`  Registered Agent: ${p.clawncher.isRegisteredAgent ? 'Yes' : 'No'}`);
+        if (p.clawncher.tokenPositions.length > 0) {
+            lines.push(`  Token Positions (${p.clawncher.tokenPositions.length}):`);
+            for (const pos of p.clawncher.tokenPositions) {
+                lines.push(`    ${pos.symbol}: ${pos.balance}`);
+                if (pos.claimableFees) {
+                    lines.push(`      Fees: ${pos.claimableFees.weth} WETH, ${pos.claimableFees.token} token`);
+                }
+            }
+        }
+    }
+    return lines.filter(Boolean).join('\n');
+}
+function formatAuditReport(a) {
+    const lines = [
+        `=== Token Audit: ${a.contract.address} ===`,
+        `Risk Score: ${a.riskScore}/100 (${a.riskLevel})`,
+        '',
+        `Upgradeable: ${a.isUpgradeable ? 'Yes' : 'No'}`,
+        `Owner Controls: ${a.hasOwnerControls ? 'Yes' : 'No'}`,
+        `Mint Function: ${a.hasMintFunction ? 'Yes' : 'No'}`,
+        `Pause/Blacklist: ${a.hasPauseOrBlacklist ? 'Yes' : 'No'}`,
+    ];
+    if (a.findings.length > 0) {
+        lines.push(`\nFindings (${a.findings.length}):`);
+        for (const f of a.findings) {
+            lines.push(`  [${f.severity}] ${f.category}: ${f.description}`);
+        }
+    }
+    if (a.checksPerformed.length > 0) {
+        lines.push(`\nChecks Performed: ${a.checksPerformed.join(', ')}`);
+    }
+    lines.push(`\nAudited: ${a.auditedAt}`);
+    return lines.filter(Boolean).join('\n');
+}
+function formatSwapValidation(v) {
+    const lines = [
+        `=== Swap Validation ===`,
+        `${v.tokenIn} → ${v.tokenOut}`,
+        `Amount In: ${v.amountIn}`,
+        `Recommendation: ${v.analysis.recommendation.toUpperCase()}`,
+        `Quote Reasonable: ${v.analysis.quoteReasonable ? 'Yes' : 'No'}`,
+        '',
+    ];
+    if (v.ourQuote) {
+        lines.push(`Our Quote:`);
+        lines.push(`  Amount Out: ${v.ourQuote.amountOut}`);
+        lines.push(`  Price Impact: ${v.ourQuote.priceImpact}%`);
+    }
+    if (v.analysis.deviationPercent !== null) {
+        lines.push(`Deviation from Historical: ${v.analysis.deviationPercent.toFixed(2)}%`);
+    }
+    if (v.historicalSwaps.length > 0) {
+        lines.push(`\nRecent Swaps (${v.historicalSwaps.length}):`);
+        for (const s of v.historicalSwaps.slice(0, 5)) {
+            lines.push(`  ${s.timestamp}: ${s.amountIn} → ${s.amountOut} (rate: ${s.effectiveRate})`);
+        }
+    }
+    if (v.analysis.warnings.length > 0) {
+        lines.push(`\nWarnings:`);
+        for (const w of v.analysis.warnings) {
+            lines.push(`  - ${w}`);
+        }
+    }
+    return lines.filter(Boolean).join('\n');
+}
+function formatFeeClaimValidation(v) {
+    const lines = [
+        `=== Fee Claim Validation ===`,
+        `Token: ${v.tokenAddress}`,
+        `Estimate Reliable: ${v.analysis.estimateReliable ? 'Yes' : 'No'}`,
+        '',
+    ];
+    if (v.ourEstimate) {
+        lines.push(`Our Estimate:`);
+        lines.push(`  WETH Available: ${v.ourEstimate.wethAvailable}`);
+        lines.push(`  Token Available: ${v.ourEstimate.tokenAvailable}`);
+    }
+    if (v.analysis.avgGasCostEth) {
+        lines.push(`Avg Gas Cost: ${v.analysis.avgGasCostEth} ETH`);
+    }
+    if (v.analysis.estimatedNetProfitEth) {
+        lines.push(`Estimated Net Profit: ${v.analysis.estimatedNetProfitEth} ETH`);
+    }
+    if (v.historicalClaims.length > 0) {
+        lines.push(`\nRecent Claims (${v.historicalClaims.length}):`);
+        for (const c of v.historicalClaims.slice(0, 5)) {
+            lines.push(`  ${c.timestamp}: ${c.wethReceived} WETH, ${c.tokenReceived} token (gas: ${c.gasCostEth} ETH)`);
+        }
+    }
+    if (v.analysis.warnings.length > 0) {
+        lines.push(`\nWarnings:`);
+        for (const w of v.analysis.warnings) {
+            lines.push(`  - ${w}`);
+        }
+    }
+    return lines.filter(Boolean).join('\n');
+}
+function formatCounterpartyProfile(p) {
+    const lines = [
+        `=== Counterparty: ${p.wallet.address} ===`,
+        `Trust Level: ${p.riskAssessment.trustLevel}`,
+        `Wallet Type: ${p.wallet.walletType}`,
+        p.walletAge ? `Account Age: ${p.walletAge}` : '',
+        '',
+    ];
+    if (p.wallet.activity) {
+        lines.push(`Transactions: ${p.wallet.activity.transactionCount}`);
+    }
+    if (p.deployedContracts.length > 0) {
+        lines.push(`\nDeployed Contracts (${p.deployedContracts.length}):`);
+        for (const c of p.deployedContracts.slice(0, 5)) {
+            lines.push(`  ${c.address}${c.name ? ` (${c.name})` : ''} — ${c.verified ? 'verified' : 'unverified'}`);
+        }
+    }
+    if (p.riskAssessment.factors.length > 0) {
+        lines.push(`\nRisk Factors:`);
+        for (const f of p.riskAssessment.factors) {
+            lines.push(`  - ${f}`);
+        }
+    }
+    return lines.filter(Boolean).join('\n');
+}
+function formatTokenFlow(flow) {
+    const lines = [
+        `=== Token Flow: ${flow.tokenSymbol} ===`,
+        `Holder: ${flow.holder}`,
+        `Token: ${flow.token}`,
+        `Current Balance: ${flow.currentBalance}`,
+        '',
+    ];
+    if (flow.transfers.length > 0) {
+        lines.push(`Transfers (${flow.transfers.length}):`);
+        for (const t of flow.transfers.slice(0, 20)) {
+            const counterpartyLabel = t.counterpartyName || `${t.counterparty.slice(0, 10)}...`;
+            lines.push(`  ${t.timestamp} ${t.direction === 'in' ? '←' : '→'} ${counterpartyLabel}: ${t.amount}${t.usdValue ? ` ($${t.usdValue})` : ''}`);
+        }
+        if (flow.transfers.length > 20) {
+            lines.push(`  ... and ${flow.transfers.length - 20} more`);
+        }
+    }
+    if (flow.annotations.length > 0) {
+        lines.push(`\nAnnotations:`);
+        for (const a of flow.annotations) {
+            lines.push(`  ${a.label} (transfers: ${a.transferIndices.join(', ')})`);
+        }
+    }
+    return lines.filter(Boolean).join('\n');
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+function ok(result, metadata) {
+    return { callId: '', success: true, result, metadata };
+}
+function fail(error) {
+    return { callId: '', success: false, result: null, error };
+}
+function formatLargeNumber(n) {
+    if (n >= 1_000_000_000)
+        return `${(n / 1_000_000_000).toFixed(2)}B`;
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(2)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(2)}K`;
+    return n.toFixed(2);
+}
+//# sourceMappingURL=herd.js.map