@finchagentic/mcp 4.7.1 → 4.7.3

package/dist/tools/rh-mcp-constants.js

@@ -0,0 +1,65 @@
+"use strict";
+// Robinhood Chain (chainId 4663) constants shared across the rh-mcp-* modules.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RH_DEX_CHAIN = exports.DEXSCREENER = exports.RH_BLOCKSCOUT_V2 = exports.RH_STOCKS = exports.USDG_DECIMALS = exports.USDG_ADDRESS = exports.RH_UNIVERSAL_ROUTER = exports.RH_PERMIT2 = exports.NATIVE_ETH = exports.RH_EXPLORER = exports.RH_RPC = exports.RH_CHAIN_ID = void 0;
+exports.rhRpcDisplay = rhRpcDisplay;
+exports.RH_CHAIN_ID = 4663;
+exports.RH_RPC = process.env.ROBINHOOD_RPC_URL ??
+    process.env.RH_RPC_URL ??
+    process.env.FINCH_RH_RPC_URL ??
+    "https://rpc.mainnet.chain.robinhood.com";
+/** Host only, for display in tool output - never the full RH_RPC. An
+ *  operator can point ROBINHOOD_RPC_URL/RH_RPC_URL at a keyed provider
+ *  (same pattern app/convex just fixed for its own Alchemy-key leak risk -
+ *  a `.../v2/<key>`-style URL echoed verbatim into a tool response lands the
+ *  key in chat transcripts/client logs). Falls back to the raw value only
+ *  if it isn't a parseable URL, which should never happen in practice. */
+function rhRpcDisplay() {
+    try {
+        return new URL(exports.RH_RPC).host;
+    }
+    catch {
+        return "(configured)";
+    }
+}
+exports.RH_EXPLORER = "https://robinhoodchain.blockscout.com";
+exports.NATIVE_ETH = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+exports.RH_PERMIT2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+exports.RH_UNIVERSAL_ROUTER = "0x8876789976decbfcbbbe364623c63652db8c0904";
+/**
+ * Canonical Global Dollar (USDG) — RH chain's settlement stablecoin (same
+ * address as app/convex/_settlement.ts). Hardcoded rather than resolved via
+ * DexScreener ticker search: "USDG" is the exact symbol an imposter contract
+ * would spoof, and dexSearchByTicker ranks by pool liquidity, not authenticity
+ * — a fake pool with inflated liquidity could otherwise outrank the real token.
+ */
+exports.USDG_ADDRESS = "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168";
+exports.USDG_DECIMALS = 6;
+/** ClawHood / Finch catalog (22 tokenized stocks — official "Robinhood Token" contracts). */
+exports.RH_STOCKS = [
+    { address: "0xaf3d76f1834a1d425780943c99ea8a608f8a93f9", symbol: "AAPL", name: "Apple" },
+    { address: "0x86923f96303d656e4aa86d9d42d1e57ad2023fdc", symbol: "AMD", name: "AMD" },
+    { address: "0x12f190a9f9d7d37a250758b26824b97ce941bf54", symbol: "AMZN", name: "Amazon" },
+    { address: "0x822cc93ffd030293e9842c30bbd678f530701867", symbol: "BE", name: "Bloom Energy" },
+    { address: "0x6330d8c3178a418788df01a47479c0ce7ccf450b", symbol: "COIN", name: "Coinbase" },
+    { address: "0x5f10a1c971b69e47e059e1dc91901b59b3fb49c3", symbol: "CRWV", name: "CoreWeave" },
+    { address: "0x1b0e319c6a659f002271b69db8a7df2f911c153e", symbol: "GME", name: "GameStop" },
+    { address: "0x2e0847e8910a9732eb3fb1bb4b70a580adad4fe3", symbol: "GOOGL", name: "Alphabet" },
+    { address: "0xc72b96e0e48ecd4dc75e1e45396e26300bc39681", symbol: "INTC", name: "Intel" },
+    { address: "0xc0d6457c16cc70d6790dd43521c899c87ce02f35", symbol: "META", name: "Meta" },
+    { address: "0xe93237c50d904957cf27e7b1133b510c669c2e74", symbol: "MSFT", name: "Microsoft" },
+    { address: "0xff080c8ce2e5feadaca0da81314ae59d232d4afd", symbol: "MU", name: "Micron" },
+    { address: "0xe0444ef8bf4ed74f74fd73686e2ddf4c1c5591e8", symbol: "NFLX", name: "Netflix" },
+    { address: "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec", symbol: "NVDA", name: "NVIDIA" },
+    { address: "0xb0992820e760d836549ba69bc7598b4af75dee03", symbol: "ORCL", name: "Oracle" },
+    { address: "0x894e1ec2d74ffe5aef8dc8a9e84686accb964f2a", symbol: "PLTR", name: "Palantir" },
+    { address: "0xd5f3879160bc7c32ebb4dc785f8a4f505888de68", symbol: "QQQ", name: "Invesco QQQ" },
+    { address: "0xb90a19ff0af67f7779aff50a882a9cff42446400", symbol: "SNDK", name: "Sandisk" },
+    { address: "0x4a0e65a3eccec6dbe60ae065f2e7bb85fae35eea", symbol: "SPCX", name: "SPACEX" },
+    { address: "0x117cc2133c37b721f49de2a7a74833232b3b4c0c", symbol: "SPY", name: "SPDR S&P 500" },
+    { address: "0x322f0929c4625ed5bad873c95208d54e1c003b2d", symbol: "TSLA", name: "Tesla" },
+    { address: "0xd917b029c761d264c6a312bbbcda868658ef86a6", symbol: "USAR", name: "USA Rare Earth" },
+];
+exports.RH_BLOCKSCOUT_V2 = "https://robinhoodchain.blockscout.com/api/v2";
+exports.DEXSCREENER = "https://api.dexscreener.com";
+exports.RH_DEX_CHAIN = "robinhood";

package/dist/tools/rh-mcp-dex.js

@@ -0,0 +1,107 @@
+"use strict";
+// DexScreener (Robinhood chain) — arbitrary token resolution + market data.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dexFetch = dexFetch;
+exports.dexTokenBest = dexTokenBest;
+exports.quoteValueRatio = quoteValueRatio;
+exports.badQuoteWarning = badQuoteWarning;
+exports.dexSearchByTicker = dexSearchByTicker;
+const dex_pair_js_1 = require("../dex-pair.js");
+const rh_mcp_constants_js_1 = require("./rh-mcp-constants.js");
+async function dexFetch(path) {
+    const res = await fetch(`${rh_mcp_constants_js_1.DEXSCREENER}${path}`, {
+        headers: { accept: "application/json" },
+        signal: AbortSignal.timeout(12000),
+    });
+    if (!res.ok)
+        throw new Error(`DexScreener HTTP ${res.status}`);
+    return res.json();
+}
+function rhOnly(pairs) {
+    return (pairs ?? []).filter((p) => p.chainId === rh_mcp_constants_js_1.RH_DEX_CHAIN);
+}
+/** Highest-liquidity RH pair that contains `address`. */
+async function dexTokenBest(address) {
+    try {
+        const data = await dexFetch(`/latest/dex/tokens/${address}`);
+        // Only base-side pairs price our token; see pickTokenPair for why the
+        // deepest pair overall is the wrong answer. That price feeds TP/SL triggers.
+        return (0, dex_pair_js_1.pickTokenPair)(rhOnly(data?.pairs), address);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Sanity-check an on-chain quote against DexScreener spot value.
+ *
+ * The RH engine routes Uniswap V4 pools only. When a token's real depth lives
+ * elsewhere (e.g. a V2/V3 WETH pair) the V4 path can be empty and still return a
+ * quote — at a catastrophic rate. Returns the fraction of spot value received,
+ * or null when it can't be determined (no ETH-quoted pair → no false alarms).
+ */
+async function quoteValueRatio(from, to, amountInHuman, amountOutHuman) {
+    const tokenSide = from.kind === "token" ? from : to;
+    const amtIn = Number(amountInHuman);
+    if (!isFinite(amtIn) || amtIn <= 0 || !isFinite(amountOutHuman) || amountOutHuman <= 0) {
+        return null;
+    }
+    try {
+        const data = await dexFetch(`/latest/dex/tokens/${tokenSide.address}`);
+        const pairs = rhOnly(data?.pairs);
+        if (!pairs.length)
+            return null;
+        // Derive ETH/USD from any ETH/WETH-quoted pair: priceUsd / priceNative.
+        const ethPair = pairs.find((p) => {
+            const q = p.quoteToken?.symbol?.toUpperCase();
+            return (q === "WETH" || q === "ETH") && Number(p.priceNative) > 0 && Number(p.priceUsd) > 0;
+        });
+        if (!ethPair)
+            return null;
+        const ethUsd = Number(ethPair.priceUsd) / Number(ethPair.priceNative);
+        // Only base-side pairs price OUR token — `priceUsd` always belongs to the
+        // base. Sorting across every pair could hand back a completely different
+        // token's price, and this value decides whether a swap is blocked.
+        const want = tokenSide.address.toLowerCase();
+        const ourPairs = pairs.filter((p) => p.baseToken?.address?.toLowerCase() === want);
+        const deepest = [...ourPairs].sort((a, b) => (b.liquidity?.usd ?? 0) - (a.liquidity?.usd ?? 0))[0];
+        const tokenUsd = Number(deepest?.priceUsd);
+        if (!isFinite(ethUsd) || ethUsd <= 0 || !isFinite(tokenUsd) || tokenUsd <= 0)
+            return null;
+        const inUsd = from.kind === "eth" ? amtIn * ethUsd : amtIn * tokenUsd;
+        const outUsd = to.kind === "eth" ? amountOutHuman * ethUsd : amountOutHuman * tokenUsd;
+        if (!isFinite(inUsd) || inUsd <= 0 || !isFinite(outUsd))
+            return null;
+        const expectedOut = to.kind === "eth" ? inUsd / ethUsd : inUsd / tokenUsd;
+        return { ratio: outUsd / inUsd, expectedOut };
+    }
+    catch {
+        return null;
+    }
+}
+/** Human-readable warning when a quote is far below spot value, else null. */
+function badQuoteWarning(check, toSymbol) {
+    if (!check || check.ratio >= 0.75)
+        return null;
+    const pct = (check.ratio * 100).toFixed(1);
+    const lost = ((1 - check.ratio) * 100).toFixed(1);
+    return (`🔴 **BAD PRICE — you would receive only ${pct}% of spot value (~${lost}% instant loss).**\n` +
+        `Expected ≈ **${check.expectedOut.toLocaleString(undefined, { maximumFractionDigits: 6 })} ${toSymbol}** at DexScreener spot.\n` +
+        `Cause: this engine routes **Uniswap V4 pools only**. This token's real depth is likely in a ` +
+        `V2/V3 pair the router cannot reach, so it is quoting a near-empty V4 path. **Do not swap.**`);
+}
+/** RH tokens whose base symbol matches `ticker`, deduped by address, ranked by liquidity. */
+async function dexSearchByTicker(ticker) {
+    const data = await dexFetch(`/latest/dex/search/?q=${encodeURIComponent(ticker)}`);
+    const up = ticker.trim().toUpperCase();
+    const byToken = new Map();
+    for (const p of rhOnly(data?.pairs)) {
+        if (p.baseToken?.symbol?.toUpperCase() !== up)
+            continue;
+        const key = p.baseToken.address.toLowerCase();
+        const prev = byToken.get(key);
+        if (!prev || (p.liquidity?.usd ?? 0) > (prev.liquidity?.usd ?? 0))
+            byToken.set(key, p);
+    }
+    return [...byToken.values()].sort((a, b) => (b.liquidity?.usd ?? 0) - (a.liquidity?.usd ?? 0));
+}

package/dist/tools/rh-mcp-provider.js

@@ -0,0 +1,127 @@
+"use strict";
+// RH RPC access — provider, raw eth_call/eth_getBalance, and the wei/decimal
+// helpers everything else in rh-mcp-* builds on.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rhProviderAsync = rhProviderAsync;
+exports.rhRpc = rhRpc;
+exports.rhErc20Balance = rhErc20Balance;
+exports.rhPriceUsd = rhPriceUsd;
+exports.erc20Decimals = erc20Decimals;
+exports.parseHumanToWei = parseHumanToWei;
+exports.formatWei = formatWei;
+const ethers_1 = require("ethers");
+const convex_js_1 = require("../convex.js");
+const config_js_1 = require("../config.js");
+const rh_mcp_constants_js_1 = require("./rh-mcp-constants.js");
+const rh_mcp_dex_js_1 = require("./rh-mcp-dex.js");
+// Some networks can't reach the RH RPC at all (e.g. ISPs that DNS-block
+// robinhood.com), which would break balances, approvals and broadcasting. Probe
+// once, then transparently relay through Convex — which can reach it — instead.
+const RH_RPC_RELAY = `${convex_js_1.CONVEX_SITE}/mcp/rh/rpc`;
+let _rhRpcMode = null;
+async function rhRpcMode() {
+    if (_rhRpcMode)
+        return _rhRpcMode;
+    try {
+        const res = await fetch(rh_mcp_constants_js_1.RH_RPC, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_chainId", params: [] }),
+            signal: AbortSignal.timeout(6000),
+        });
+        if (res.ok) {
+            _rhRpcMode = "direct";
+            return _rhRpcMode;
+        }
+    }
+    catch {
+        /* blocked or unreachable → relay */
+    }
+    _rhRpcMode = "relay";
+    return _rhRpcMode;
+}
+/** Auth header for the Convex relay (session token or API key). */
+function rhRelayHeaders() {
+    const token = (0, config_js_1.getSavedToken)();
+    return {
+        "Content-Type": "application/json",
+        ...(token ? { Authorization: `Bearer ${token}` } : {}),
+    };
+}
+/** Provider that works on both paths — relays via Convex when RPC is blocked. */
+async function rhProviderAsync() {
+    if ((await rhRpcMode()) === "direct") {
+        return new ethers_1.ethers.JsonRpcProvider(rh_mcp_constants_js_1.RH_RPC, rh_mcp_constants_js_1.RH_CHAIN_ID);
+    }
+    const req = new ethers_1.ethers.FetchRequest(RH_RPC_RELAY);
+    for (const [k, v] of Object.entries(rhRelayHeaders()))
+        req.setHeader(k, v);
+    return new ethers_1.ethers.JsonRpcProvider(req, rh_mcp_constants_js_1.RH_CHAIN_ID);
+}
+async function rhRpc(method, params) {
+    const relay = (await rhRpcMode()) === "relay";
+    const url = relay ? RH_RPC_RELAY : rh_mcp_constants_js_1.RH_RPC;
+    const res = await fetch(url, {
+        method: "POST",
+        headers: relay ? rhRelayHeaders() : { "Content-Type": "application/json" },
+        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+        signal: AbortSignal.timeout(20000),
+    });
+    if (!res.ok)
+        throw new Error(`RH RPC HTTP ${res.status}${relay ? " (via relay)" : ""}`);
+    const data = (await res.json());
+    if (data.error)
+        throw new Error(data.error.message ?? "RH RPC error");
+    return data.result;
+}
+function encodeBalanceOf(addr) {
+    return "0x70a08231" + addr.toLowerCase().replace("0x", "").padStart(64, "0");
+}
+/** Raw ERC-20 balanceOf(owner) on RH chain (wei). 0n on any failure. */
+async function rhErc20Balance(token, owner) {
+    try {
+        const hex = await rhRpc("eth_call", [{ to: token, data: encodeBalanceOf(owner) }, "latest"]);
+        if (hex && hex !== "0x")
+            return BigInt(hex);
+    }
+    catch {
+        /* 0 */
+    }
+    return 0n;
+}
+/** Current USD price of a token on RH chain via DexScreener, or null. */
+async function rhPriceUsd(address) {
+    const dex = await (0, rh_mcp_dex_js_1.dexTokenBest)(address);
+    const p = dex?.priceUsd != null ? Number(dex.priceUsd) : NaN;
+    return isFinite(p) ? p : null;
+}
+/** ERC-20 decimals() via RH RPC; falls back to 18. */
+async function erc20Decimals(addr) {
+    try {
+        const hex = await rhRpc("eth_call", [{ to: addr, data: "0x313ce567" }, "latest"]);
+        if (hex && hex !== "0x") {
+            const d = Number(BigInt(hex));
+            if (d > 0 && d <= 36)
+                return d;
+        }
+    }
+    catch {
+        /* default 18 */
+    }
+    return 18;
+}
+function parseHumanToWei(amount, decimals = 18) {
+    const a = amount.trim();
+    if (!/^\d+(\.\d+)?$/.test(a))
+        throw new Error(`Invalid amount: ${amount}`);
+    return ethers_1.ethers.parseUnits(a, decimals).toString();
+}
+function formatWei(raw, decimals = 18, maxFrac = 6) {
+    try {
+        const n = Number(ethers_1.ethers.formatUnits(raw, decimals));
+        return n.toLocaleString(undefined, { maximumFractionDigits: maxFrac });
+    }
+    catch {
+        return raw;
+    }
+}

package/dist/tools/rh-mcp-resolve.js

@@ -0,0 +1,137 @@
+"use strict";
+// Resolve ETH / a catalog stock / a crypto ticker / a raw 0x address to a
+// tradeable RH-chain token, plus the Blockscout-backed wallet balance render.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAddress = isAddress;
+exports.isEth = isEth;
+exports.resolveStock = resolveStock;
+exports.resolveTokenSmart = resolveTokenSmart;
+exports.fetchRhBalances = fetchRhBalances;
+const ethers_1 = require("ethers");
+const rh_mcp_constants_js_1 = require("./rh-mcp-constants.js");
+const rh_mcp_dex_js_1 = require("./rh-mcp-dex.js");
+const rh_mcp_provider_js_1 = require("./rh-mcp-provider.js");
+function isAddress(s) {
+    return /^0x[a-fA-F0-9]{40}$/.test(s);
+}
+function isEth(sym) {
+    const s = sym.trim().toUpperCase();
+    return s === "ETH" || s === "WETH" || s === "NATIVE" || s === rh_mcp_constants_js_1.NATIVE_ETH.toUpperCase();
+}
+function resolveStock(input) {
+    const t = input.trim();
+    if (isEth(t))
+        return null;
+    if (isAddress(t)) {
+        const hit = rh_mcp_constants_js_1.RH_STOCKS.find((s) => s.address.toLowerCase() === t.toLowerCase());
+        return hit ?? { address: t, symbol: t.slice(0, 8), name: "Unknown token" };
+    }
+    const up = t.toUpperCase();
+    return rh_mcp_constants_js_1.RH_STOCKS.find((s) => s.symbol === up) ?? null;
+}
+/**
+ * Resolve ETH, a catalog stock, a crypto ticker, or a raw 0x address to a
+ * tradeable RH-chain token. Tickers resolve via DexScreener (highest liquidity
+ * wins) — callers should confirm the contract address with the user first.
+ */
+async function resolveTokenSmart(input) {
+    if (isEth(input))
+        return { kind: "eth", address: rh_mcp_constants_js_1.NATIVE_ETH, symbol: "ETH", decimals: 18 };
+    const t = input.trim();
+    if (t.toUpperCase() === "USDG") {
+        return { kind: "token", address: rh_mcp_constants_js_1.USDG_ADDRESS, symbol: "USDG", name: "Global Dollar", decimals: rh_mcp_constants_js_1.USDG_DECIMALS };
+    }
+    // 1) catalog symbol fast-path (22 tokenized stocks, all 18-decimals)
+    const cat = rh_mcp_constants_js_1.RH_STOCKS.find((s) => s.symbol === t.toUpperCase());
+    if (cat)
+        return { kind: "token", address: cat.address, symbol: cat.symbol, name: cat.name, decimals: 18 };
+    // 2) raw contract address
+    if (isAddress(t)) {
+        const dex = await (0, rh_mcp_dex_js_1.dexTokenBest)(t);
+        const decimals = await (0, rh_mcp_provider_js_1.erc20Decimals)(t);
+        const known = resolveStock(t);
+        const symbol = dex?.baseToken?.address?.toLowerCase() === t.toLowerCase()
+            ? dex.baseToken.symbol
+            : known?.symbol ?? dex?.quoteToken?.symbol ?? `${t.slice(0, 6)}…`;
+        return { kind: "token", address: t, symbol, name: dex?.baseToken?.name ?? known?.name, decimals, dex };
+    }
+    // 3) crypto ticker via DexScreener
+    const cands = await (0, rh_mcp_dex_js_1.dexSearchByTicker)(t);
+    if (cands.length === 0) {
+        throw new Error(`Unknown RH asset "${input}". Not in the stock catalog and no Robinhood-chain token matched on DexScreener. Paste the 0x contract address instead.`);
+    }
+    const best = cands[0];
+    const decimals = await (0, rh_mcp_provider_js_1.erc20Decimals)(best.baseToken.address);
+    return {
+        kind: "token",
+        address: best.baseToken.address,
+        symbol: best.baseToken.symbol,
+        name: best.baseToken.name,
+        decimals,
+        dex: best,
+    };
+}
+async function fetchRhBalances(address) {
+    if (!isAddress(address))
+        return "Invalid address.";
+    let ethStr = "?";
+    try {
+        const hex = await (0, rh_mcp_provider_js_1.rhRpc)("eth_getBalance", [address, "latest"]);
+        ethStr = (Number(BigInt(hex)) / 1e18).toFixed(6);
+    }
+    catch (e) {
+        ethStr = `error: ${e?.message ?? "rpc"}`;
+    }
+    // Blockscout lists EVERY token held, not just the 18-stock catalog — the old
+    // per-catalog RPC loop was blind to arbitrary crypto we can now trade. It's
+    // also 1 request instead of 18, and stays reachable when the RPC is blocked.
+    const holdings = [];
+    try {
+        const res = await fetch(`${rh_mcp_constants_js_1.RH_BLOCKSCOUT_V2}/addresses/${address}/token-balances`, {
+            headers: { accept: "application/json" },
+            signal: AbortSignal.timeout(15000),
+        });
+        if (res.ok) {
+            const data = await res.json();
+            const items = Array.isArray(data) ? data : (data?.items ?? []);
+            for (const it of items) {
+                const tk = it?.token ?? {};
+                if (tk.type && String(tk.type).toUpperCase() !== "ERC-20")
+                    continue;
+                const dec = Number(tk.decimals ?? 18);
+                const raw = String(it?.value ?? "0");
+                let bal = 0;
+                try {
+                    bal = Number(ethers_1.ethers.formatUnits(raw, isFinite(dec) ? dec : 18));
+                }
+                catch {
+                    continue;
+                }
+                if (bal > 1e-9) {
+                    holdings.push({
+                        symbol: tk.symbol ?? "?",
+                        bal: bal.toLocaleString(undefined, { maximumFractionDigits: 6 }),
+                        address: tk.address_hash ?? tk.address ?? "",
+                    });
+                }
+            }
+            holdings.sort((a, b) => a.symbol.localeCompare(b.symbol));
+        }
+    }
+    catch {
+        /* fall through — ETH balance still reported */
+    }
+    const lines = [
+        `**Wallet**: \`${address}\``,
+        ``,
+        `**Balances on Robinhood Chain (${rh_mcp_constants_js_1.RH_CHAIN_ID}):**`,
+        `- ETH (gas): ${ethStr}`,
+    ];
+    if (holdings.length === 0)
+        lines.push(`- (no token balances)`);
+    else
+        for (const h of holdings)
+            lines.push(`- ${h.symbol}: ${h.bal}  \`${h.address}\``);
+    lines.push(``, `_RPC: ${(0, rh_mcp_constants_js_1.rhRpcDisplay)()}_`, `_Explorer: ${rh_mcp_constants_js_1.RH_EXPLORER}/address/${address}_`);
+    return lines.join("\n");
+}

package/dist/tools/rh-mcp-risk.js

@@ -0,0 +1,230 @@
+"use strict";
+// Market risk pre-screen (heuristic, DexScreener data only) — powers
+// rh_analyze, rh_token_resolve and rh_mcp_list_stocks rendering.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fmtUsd = fmtUsd;
+exports.fmtPct = fmtPct;
+exports.assessRisk = assessRisk;
+exports.renderResolveList = renderResolveList;
+exports.renderResolveOne = renderResolveOne;
+exports.buildRhAnalysis = buildRhAnalysis;
+exports.buildRhStocksList = buildRhStocksList;
+exports.renderAnalysis = renderAnalysis;
+const rh_mcp_constants_js_1 = require("./rh-mcp-constants.js");
+function fmtUsd(n) {
+    const v = Number(n ?? 0);
+    if (!isFinite(v))
+        return "0";
+    if (v >= 1e9)
+        return (v / 1e9).toFixed(2) + "B";
+    if (v >= 1e6)
+        return (v / 1e6).toFixed(2) + "M";
+    if (v >= 1e3)
+        return (v / 1e3).toFixed(1) + "K";
+    return v.toFixed(2);
+}
+function fmtPct(n) {
+    if (n == null || !isFinite(n))
+        return "n/a";
+    return (n > 0 ? "+" : "") + Number(n).toFixed(1) + "%";
+}
+function assessRisk(dex) {
+    let score = 0;
+    const flags = [];
+    const liq = dex.liquidity?.usd ?? 0;
+    if (liq < 10000) {
+        score += 40;
+        flags.push(`🔴 Very low liquidity ($${fmtUsd(liq)}) — high slippage & rug risk`);
+    }
+    else if (liq < 25000) {
+        score += 28;
+        flags.push(`🟠 Low liquidity ($${fmtUsd(liq)})`);
+    }
+    else if (liq < 100000) {
+        score += 15;
+        flags.push(`🟡 Moderate liquidity ($${fmtUsd(liq)})`);
+    }
+    else {
+        flags.push(`🟢 Liquidity $${fmtUsd(liq)}`);
+    }
+    if (dex.pairCreatedAt) {
+        const ageH = (Date.now() - dex.pairCreatedAt) / 3600000;
+        if (ageH < 24) {
+            score += 25;
+            flags.push(`🔴 Very new pair (${ageH.toFixed(0)}h old)`);
+        }
+        else if (ageH < 24 * 7) {
+            score += 12;
+            flags.push(`🟠 New pair (${(ageH / 24).toFixed(1)}d old)`);
+        }
+        else {
+            flags.push(`🟢 Pair age ${(ageH / 24).toFixed(0)}d`);
+        }
+    }
+    else {
+        flags.push("⚪ Pair age unknown");
+    }
+    const vol = dex.volume?.h24 ?? 0;
+    const ratio = liq > 0 ? vol / liq : 0;
+    if (ratio > 20) {
+        score += 15;
+        flags.push(`🔴 24h volume ${ratio.toFixed(1)}× liquidity — possible wash/hype spike`);
+    }
+    else if (ratio > 5) {
+        score += 6;
+        flags.push(`🟠 High turnover (${ratio.toFixed(1)}× liq)`);
+    }
+    const buys = dex.txns?.h24?.buys ?? 0;
+    const sells = dex.txns?.h24?.sells ?? 0;
+    if (buys + sells < 10) {
+        score += 8;
+        flags.push(`🟠 Thin activity (${buys + sells} txns/24h)`);
+    }
+    else if (sells > buys * 2) {
+        score += 10;
+        flags.push(`🟠 Sell-heavy (${sells} sells vs ${buys} buys/24h) — distribution`);
+    }
+    const ch = dex.priceChange?.h24;
+    if (ch != null && Math.abs(ch) > 50) {
+        score += 8;
+        flags.push(`🟠 Volatile: ${fmtPct(ch)} 24h`);
+    }
+    const hasSocials = ((dex.info?.socials?.length ?? 0) + (dex.info?.websites?.length ?? 0)) > 0;
+    if (!hasSocials) {
+        score += 6;
+        flags.push("🟡 No website/socials listed on DexScreener");
+    }
+    // ── Implausibility checks ────────────────────────────────────────────────
+    // A launchpad whitelist ages badly — new platforms appear constantly. These
+    // look instead at whether the numbers are internally coherent, which a
+    // bundled or honeypot token cannot fake without giving up the illusion.
+    // Exit ratio: notional value vs the pool that would have to absorb a sale.
+    // A $35M "market cap" sitting on $17K of liquidity is not a market cap —
+    // it is a quote nobody can realise.
+    const fdv = dex.fdv ?? dex.marketCap ?? 0;
+    if (fdv > 0 && liq > 0) {
+        const exitRatio = fdv / liq;
+        if (exitRatio > 500) {
+            score += 22;
+            flags.push(`🔴 FDV is ${exitRatio.toFixed(0)}× liquidity ($${fmtUsd(fdv)} vs $${fmtUsd(liq)}) — ` +
+                `the quoted valuation cannot be exited; treat the price as notional`);
+        }
+        else if (exitRatio > 100) {
+            score += 12;
+            flags.push(`🟠 FDV ${exitRatio.toFixed(0)}× liquidity — thin float behind the headline value`);
+        }
+    }
+    // Wash pattern: heavy volume relative to the pool, with buys and sells almost
+    // perfectly matched. Organic trading is lopsided; round-tripping is not.
+    if (buys > 40 && sells > 40 && liq > 0) {
+        const symmetry = Math.abs(buys - sells) / (buys + sells); // 0 = perfectly matched
+        if (symmetry < 0.06 && ratio > 3) {
+            score += 15;
+            flags.push(`🔴 Buy/sell almost perfectly matched (${buys}/${sells}) on ${ratio.toFixed(1)}× turnover — ` +
+                `consistent with wash trading or a bundled wallet set`);
+        }
+    }
+    // Implausibly uniform trade size: many transactions, negligible average value.
+    const txCount = buys + sells;
+    if (txCount > 100 && vol > 0) {
+        const avgTrade = vol / txCount;
+        if (avgTrade < 25) {
+            score += 10;
+            flags.push(`🟠 Average trade only $${avgTrade.toFixed(2)} across ${txCount} txns — ` +
+                `bot-like churn rather than real participation`);
+        }
+    }
+    // Buys with no exits at all is the clearest honeypot tell available here.
+    if (buys > 10 && sells === 0) {
+        score += 30;
+        flags.push(`🔴 ${buys} buys and ZERO sells in 24h — nobody has exited; possible honeypot`);
+    }
+    score = Math.min(100, score);
+    const tier = score >= 70 ? "🔴 EXTREME" : score >= 45 ? "🟠 HIGH" : score >= 25 ? "🟡 MEDIUM" : "🟢 LOWER";
+    return { score, tier, flags };
+}
+function renderResolveList(query, cands) {
+    const rows = cands.slice(0, 8).map((p, i) => `| ${i === 0 ? "⭐" : " "} | \`${p.baseToken.address}\` | $${fmtUsd(p.liquidity?.usd ?? 0)} | $${fmtUsd(p.volume?.h24 ?? 0)} | ${p.priceUsd ? "$" + p.priceUsd : "?"} |`);
+    return [
+        `## 🔎 RH resolve — "${query}" (${cands.length} match${cands.length === 1 ? "" : "es"})`,
+        "",
+        "| | Contract | Liquidity | Vol 24h | Price |",
+        "|--|----------|-----------|---------|-------|",
+        ...rows,
+        "",
+        `⭐ = highest liquidity. ⚠️ **Tickers can be spoofed** — several tokens may share "${query}". Trade using the exact contract address, never the ticker alone.`,
+        "",
+        `Next: \`rh_analyze\` the contract, then \`rh_mcp_estimate\` / \`rh_mcp_swap\` with the CA.`,
+    ].join("\n");
+}
+function renderResolveOne(address, dex) {
+    const isBase = dex.baseToken.address.toLowerCase() === address.toLowerCase();
+    const tok = isBase ? dex.baseToken : dex.quoteToken;
+    return [
+        `## 🔎 RH token — ${tok.symbol}${tok.name ? ` (${tok.name})` : ""}`,
+        `\`${tok.address}\` · chain 4663`,
+        "",
+        `**Price**: ${dex.priceUsd ? "$" + dex.priceUsd : "?"} · **24h**: ${fmtPct(dex.priceChange?.h24)}`,
+        `**Liquidity**: $${fmtUsd(dex.liquidity?.usd ?? 0)} · **Vol 24h**: $${fmtUsd(dex.volume?.h24 ?? 0)}`,
+        `**Pair**: ${dex.dexId ?? "uniswap"} · ${rh_mcp_constants_js_1.RH_EXPLORER}/address/${dex.pairAddress}`,
+        "",
+        `Next: \`rh_analyze\` for a risk read, then \`rh_mcp_estimate\` / \`rh_mcp_swap\`.`,
+    ].join("\n");
+}
+// structuredContent payload for rh_analyze - mirrors buildRhSafetyStructured:
+// `tier` is the assessRisk label with its leading emoji stripped
+// ("EXTREME"/"HIGH"/"MEDIUM"/"LOWER"), single source, no thresholds duplicated.
+function buildRhAnalysis(r, dex, assessment) {
+    return {
+        address: r.address,
+        symbol: r.symbol ?? null,
+        name: r.name ?? null,
+        priceUsd: dex.priceUsd ? Number(dex.priceUsd) : null,
+        change1hPct: dex.priceChange?.h1 ?? null,
+        change24hPct: dex.priceChange?.h24 ?? null,
+        liquidityUsd: dex.liquidity?.usd ?? null,
+        volume24hUsd: dex.volume?.h24 ?? null,
+        fdvUsd: dex.fdv ?? null,
+        marketCapUsd: dex.marketCap ?? null,
+        buys24h: dex.txns?.h24?.buys ?? null,
+        sells24h: dex.txns?.h24?.sells ?? null,
+        pairAgeDays: dex.pairCreatedAt ? Math.floor((Date.now() - dex.pairCreatedAt) / 86400000) : null,
+        riskScore: assessment.score,
+        tier: assessment.tier.replace(/^\S+\s+/, ""),
+        flags: assessment.flags,
+    };
+}
+// structuredContent payload for rh_mcp_list_stocks - a machine-readable
+// mirror of the human table (already filtered by the caller's query).
+function buildRhStocksList(rows) {
+    return {
+        count: rows.length,
+        stocks: rows.map((s) => ({ symbol: s.symbol, name: s.name, address: s.address })),
+    };
+}
+function renderAnalysis(r, dex, assessment) {
+    const { score, tier, flags } = assessment;
+    const ageLine = dex.pairCreatedAt
+        ? `**Age**: ${((Date.now() - dex.pairCreatedAt) / 86400000).toFixed(1)}d`
+        : "**Age**: unknown";
+    return [
+        `## 🔬 RH Token Analysis — ${r.symbol}${r.name ? ` (${r.name})` : ""}`,
+        `\`${r.address}\` · chain 4663`,
+        "",
+        `**Price**: ${dex.priceUsd ? "$" + dex.priceUsd : "?"} · **24h**: ${fmtPct(dex.priceChange?.h24)} · **1h**: ${fmtPct(dex.priceChange?.h1)}`,
+        `**Liquidity**: $${fmtUsd(dex.liquidity?.usd ?? 0)} · **Vol 24h**: $${fmtUsd(dex.volume?.h24 ?? 0)}`,
+        `**FDV**: $${fmtUsd(dex.fdv ?? 0)} · **MCap**: $${fmtUsd(dex.marketCap ?? 0)}`,
+        `**Txns 24h**: ${dex.txns?.h24?.buys ?? 0} buys / ${dex.txns?.h24?.sells ?? 0} sells · ${ageLine}`,
+        "",
+        `### Risk: ${tier} — ${score}/100`,
+        ...flags.map((f) => `- ${f}`),
+        "",
+        `**Market data only (DexScreener).** For a full verdict also run:`,
+        `- \`audit_contract\` — honeypot / mint authority / owner privileges`,
+        `- \`deep_research\` or \`web_scrape\` — X/Twitter sentiment & narrative`,
+        "",
+        `**Pair chart**: ${rh_mcp_constants_js_1.RH_EXPLORER}/address/${dex.pairAddress}`,
+        "",
+        `_Heuristic pre-screen, not financial advice. Thin RH-chain liquidity = elevated rug risk. Verify the contract address before trading._`,
+    ].join("\n");
+}