@finchagentic/mcp 4.7.1 → 4.7.3

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

@@ -0,0 +1,234 @@
+"use strict";
+// Onchain safety scan (Blockscout + DexScreener; free, no LLM) — powers
+// rh_safety_check.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blockscoutSafety = blockscoutSafety;
+exports.assessSafety = assessSafety;
+exports.buildRhSafetyStructured = buildRhSafetyStructured;
+exports.renderSafety = renderSafety;
+const rh_mcp_constants_js_1 = require("./rh-mcp-constants.js");
+// Factory address → launchpad. Keyed lowercase. Only put an entry here once the
+// factory has been read off-chain on 4663 — a wrong mapping silently mislabels
+// every token a factory ever deployed.
+// Observed empirically by sampling recent deployments, not taken from docs.
+// Add an entry only after seeing the factory actually deploy a live token.
+const LAUNCHPAD_FACTORIES = {
+    "0xa5aab3f0c6eeadf30ef1d3eb997108e976351feb": {
+        label: "Pons",
+        note: "PonsLaunchFactory — the dominant launchpad on this chain",
+    },
+    "0x1b37d3a72082029c44b35b604ea473617580b69a": {
+        label: "Doppler (Whetstone)",
+        note: "Bankr routes launches through Doppler — a Doppler factory alone does not prove a Bankr launch",
+    },
+    "0x120caef934797423479fcd0c5d71d36b0282736e": {
+        label: "Unverified factory (MemeSoft tokens)",
+        note: "Deploys contracts named MemeSoft; operator not yet identified — treat as unbranded",
+    },
+};
+// Fallback when the factory address is unknown but its contract is verified and named.
+const LAUNCHPAD_NAME_HINTS = [
+    [/pons/i, "Pons"],
+    [/doppler/i, "Doppler (Whetstone)"],
+    [/bankr/i, "Bankr"],
+    [/\bnox\b|noxa/i, "Noxa"],
+    [/clanker/i, "Clanker"],
+    [/virtuals?/i, "Virtuals"],
+    [/flap/i, "Flap"],
+    [/memesoft/i, "MemeSoft"],
+];
+async function detectLaunchpad(creator) {
+    if (!creator)
+        return null;
+    const known = LAUNCHPAD_FACTORIES[creator.toLowerCase()];
+    if (known) {
+        return { label: known.label, factory: creator, factoryName: null, confidence: "confirmed", note: known.note };
+    }
+    let isContract = false;
+    let factoryName = null;
+    try {
+        const r = await fetch(`${rh_mcp_constants_js_1.RH_BLOCKSCOUT_V2}/addresses/${creator}`, {
+            headers: { accept: "application/json" },
+            signal: AbortSignal.timeout(12000),
+        });
+        if (r.ok) {
+            const c = await r.json();
+            isContract = c?.is_contract === true;
+            factoryName = c?.name ?? null;
+        }
+    }
+    catch {
+        /* fall through to unknown */
+    }
+    if (!isContract) {
+        return { label: "None — self-deployed", factory: creator, factoryName: null, confidence: "self-deployed" };
+    }
+    const hit = factoryName ? LAUNCHPAD_NAME_HINTS.find(([re]) => re.test(factoryName)) : undefined;
+    if (hit)
+        return { label: hit[1], factory: creator, factoryName, confidence: "likely" };
+    return { label: "Unrecognized factory", factory: creator, factoryName, confidence: "unknown" };
+}
+async function blockscoutSafety(address) {
+    const out = {
+        verified: null,
+        contractName: null,
+        reputation: null,
+        holdersCount: null,
+        creator: null,
+        launchpad: null,
+    };
+    try {
+        const r = await fetch(`${rh_mcp_constants_js_1.RH_BLOCKSCOUT_V2}/tokens/${address}`, {
+            headers: { accept: "application/json" },
+            signal: AbortSignal.timeout(12000),
+        });
+        if (r.ok) {
+            const t = await r.json();
+            out.reputation = t?.reputation ?? null;
+            out.holdersCount = t?.holders_count != null ? Number(t.holders_count) : null;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    // Use /addresses/{ca} (~1KB) NOT /smart-contracts/{ca} — the latter ships the
+    // entire Solidity source and intermittently returns a truncated body on HTTP 200,
+    // which silently nulled contractName and skipped the launchpad/privilege flags.
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            const r = await fetch(`${rh_mcp_constants_js_1.RH_BLOCKSCOUT_V2}/addresses/${address}`, {
+                headers: { accept: "application/json" },
+                signal: AbortSignal.timeout(12000),
+            });
+            if (r.ok) {
+                const c = await r.json();
+                out.verified = c?.is_verified ?? null;
+                out.contractName = c?.name ?? null;
+                out.creator = c?.creator_address_hash ?? null;
+                break;
+            }
+            if (r.status === 404) {
+                out.verified = false; // address has no contract record
+                break;
+            }
+        }
+        catch {
+            /* retry once */
+        }
+    }
+    out.launchpad = await detectLaunchpad(out.creator);
+    return out;
+}
+function assessSafety(safety, dex) {
+    let score = 0;
+    const flags = [];
+    if (safety.verified === false) {
+        score += 20;
+        flags.push("🔴 Contract NOT verified on explorer");
+    }
+    else if (safety.verified === true) {
+        flags.push("🟢 Contract verified");
+    }
+    else {
+        flags.push("⚪ Verification unknown");
+    }
+    const rep = (safety.reputation ?? "").toLowerCase();
+    if (rep && rep !== "ok" && rep !== "neutral") {
+        score += 30;
+        flags.push(`🔴 Explorer reputation: "${safety.reputation}"`);
+    }
+    else if (rep) {
+        flags.push(`🟢 Explorer reputation: ${safety.reputation}`);
+    }
+    if (safety.holdersCount != null) {
+        if (safety.holdersCount < 25) {
+            score += 25;
+            flags.push(`🔴 Very few holders (${safety.holdersCount}) — high concentration / rug risk`);
+        }
+        else if (safety.holdersCount < 200) {
+            score += 12;
+            flags.push(`🟠 Few holders (${safety.holdersCount})`);
+        }
+        else {
+            flags.push(`🟢 Holders: ${safety.holdersCount.toLocaleString()}`);
+        }
+    }
+    else {
+        flags.push("⚪ Holder count unavailable");
+    }
+    const nm = (safety.contractName ?? "").toLowerCase();
+    if (/mint|burn|blacklist|pausable|pause|ownable|\btax\b|\bfee\b/.test(nm)) {
+        score += 14;
+        flags.push(`🟠 Contract name implies owner privileges ("${safety.contractName}") — possible mint/burn/blacklist/tax; verify source before trusting`);
+    }
+    // On Robinhood Chain essentially every token ships through a launchpad
+    // (Pons, Bankr/Doppler, Flap, Virtuals…), so a launchpad deploy is the NORM,
+    // not a red flag — scoring it as risk penalised every normal token and made
+    // the number stop discriminating. The anomaly here is the opposite: a token
+    // deployed straight from an EOA answers to no launchpad rules, and the
+    // deployer keeps full control of supply and liquidity.
+    const lp = safety.launchpad;
+    if (lp?.confidence === "confirmed" || lp?.confidence === "likely") {
+        flags.push(`🟢 Launched via ${lp.label}${lp.confidence === "likely" ? " (probable)" : ""} — standard for this chain` +
+            (lp.note ? ` · ${lp.note}` : ""));
+    }
+    else if (lp?.confidence === "unknown") {
+        score += 10;
+        flags.push(`🟠 Deployed by an unrecognized factory (\`${lp.factory}\`) — not a known launchpad on this chain; verify who runs it`);
+    }
+    else if (lp?.confidence === "self-deployed") {
+        score += 18;
+        flags.push(`🔴 Self-deployed from an EOA (\`${lp.factory}\`) — no launchpad rules apply. ` +
+            `Unusual on this chain: the deployer retains full control over supply and liquidity`);
+    }
+    if (dex) {
+        const buys = dex.txns?.h24?.buys ?? 0;
+        const sells = dex.txns?.h24?.sells ?? 0;
+        if (buys > 5 && sells === 0) {
+            score += 30;
+            flags.push(`🔴 Honeypot suspicion: ${buys} buys but 0 sells in 24h — may be unsellable`);
+        }
+        else if (sells > 0) {
+            flags.push(`🟢 Sellable: ${sells} sell(s) in 24h — holders can exit`);
+        }
+    }
+    score = Math.min(100, score);
+    const tier = score >= 60 ? "🔴 DANGER" : score >= 35 ? "🟠 CAUTION" : score >= 15 ? "🟡 SOME RISK" : "🟢 LOOKS OK";
+    return { score, tier, flags };
+}
+// structuredContent payload for rh_safety_check. `tier` is the assessSafety
+// label with its leading emoji stripped so consumers get a clean enum
+// ("DANGER"/"CAUTION"/"SOME RISK"/"LOOKS OK") - single source, no threshold
+// logic duplicated here.
+function buildRhSafetyStructured(r, safety, assessment) {
+    return {
+        address: r.address,
+        symbol: r.symbol ?? null,
+        name: r.name ?? null,
+        riskScore: assessment.score,
+        tier: assessment.tier.replace(/^\S+\s+/, ""),
+        verified: safety.verified,
+        contractName: safety.contractName,
+        reputation: safety.reputation,
+        holdersCount: safety.holdersCount,
+        creator: safety.creator,
+        launchpad: safety.launchpad,
+        flags: assessment.flags,
+    };
+}
+function renderSafety(r, safety, assessment) {
+    const { score, tier, flags } = assessment;
+    return [
+        `## 🛡️ RH Safety Check — ${r.symbol}${r.name ? ` (${r.name})` : ""}`,
+        `\`${r.address}\` · chain 4663${safety.contractName ? ` · contract \`${safety.contractName}\`` : ""}`,
+        "",
+        `### Safety: ${tier} — ${score}/100 risk`,
+        ...flags.map((f) => `- ${f}`),
+        "",
+        `**Onchain data only (Blockscout + DexScreener) — no LLM, no paid API.**`,
+        `For market/liquidity read run \`rh_analyze\`; for X/narrative add \`web_search\` or \`deep_research\`.`,
+        `**Explorer**: ${rh_mcp_constants_js_1.RH_EXPLORER}/token/${r.address}`,
+        "",
+        `_Heuristic — not a full audit. A verified, high-holder, sellable token can still dump. Verify the CA._`,
+    ].join("\n");
+}

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

@@ -0,0 +1,181 @@
+"use strict";
+// Swap execution engine: quote, approvals (direct + Permit2), broadcast,
+// and receipt confirmation. Real funds move through this file.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quoteRh = quoteRh;
+exports.ensureDirectApproval = ensureDirectApproval;
+exports.ensureSellApprovals = ensureSellApprovals;
+exports.confirmRhSwap = confirmRhSwap;
+exports.broadcastRhSwap = broadcastRhSwap;
+const ethers_1 = require("ethers");
+const convex_js_1 = require("../convex.js");
+const rh_mcp_constants_js_1 = require("./rh-mcp-constants.js");
+const rh_mcp_provider_js_1 = require("./rh-mcp-provider.js");
+const rh_mcp_resolve_js_1 = require("./rh-mcp-resolve.js");
+async function quoteRh(args) {
+    const from = await (0, rh_mcp_resolve_js_1.resolveTokenSmart)(args.fromToken);
+    const to = await (0, rh_mcp_resolve_js_1.resolveTokenSmart)(args.toToken);
+    if (from.kind === to.kind) {
+        throw new Error("RH swaps route ETH ↔ token. Buy a token with ETH, or sell a token for ETH.");
+    }
+    const sellAmount = (0, rh_mcp_provider_js_1.parseHumanToWei)(args.amount, from.decimals);
+    const slippagePct = args.maxSlippagePct ?? 2.0;
+    // Same bound defi.ts's SwapSchema already enforces for Base swaps
+    // (.positive().max(50)) - this file had no equivalent check anywhere, so a
+    // negative or absurd value flowed straight through to the backend as
+    // slippageBps, both for direct rh_mcp_swap calls and for every unattended
+    // rh_orders_tick execution of a DCA/bracket order created with a bad value.
+    if (!(slippagePct > 0) || slippagePct > 50) {
+        throw new Error(`maxSlippagePct must be greater than 0 and at most 50 (got ${args.maxSlippagePct}).`);
+    }
+    const slippageBps = Math.round(slippagePct * 100);
+    const result = await (0, convex_js_1.callConvex)("/mcp/rh/quote", "POST", {
+        sellToken: from.address,
+        buyToken: to.address,
+        sellAmount,
+        taker: args.taker,
+        slippageBps,
+        fromSymbol: from.symbol,
+        toSymbol: to.symbol,
+    }, args.toolName ?? "rh_mcp_estimate");
+    if (result.error)
+        throw new Error(result.error);
+    return { ...result, from, to, sellAmount, slippageBps };
+}
+/** Plain ERC-20 approval for routers that pull via transferFrom (SwapRouter02). */
+async function ensureDirectApproval(wallet, token, spender, amountWei) {
+    const provider = await (0, rh_mcp_provider_js_1.rhProviderAsync)();
+    const signer = wallet.connect(provider);
+    const erc20 = new ethers_1.ethers.Contract(token, [
+        "function allowance(address,address) view returns (uint256)",
+        "function approve(address,uint256) returns (bool)",
+    ], signer);
+    const allowance = await erc20.allowance(wallet.address, spender);
+    if (allowance >= amountWei)
+        return [];
+    const tx = await erc20.approve(spender, ethers_1.ethers.MaxUint256);
+    await tx.wait();
+    return [tx.hash];
+}
+async function ensureSellApprovals(wallet, token, amountWei) {
+    const provider = await (0, rh_mcp_provider_js_1.rhProviderAsync)();
+    const signer = wallet.connect(provider);
+    const hashes = [];
+    const erc20 = new ethers_1.ethers.Contract(token, [
+        "function allowance(address,address) view returns (uint256)",
+        "function approve(address,uint256) returns (bool)",
+    ], signer);
+    const allowance = await erc20.allowance(wallet.address, rh_mcp_constants_js_1.RH_PERMIT2);
+    if (allowance < amountWei) {
+        const tx = await erc20.approve(rh_mcp_constants_js_1.RH_PERMIT2, ethers_1.ethers.MaxUint256);
+        await tx.wait();
+        hashes.push(tx.hash);
+    }
+    // Permit2.approve(token, spender, amount, expiration) selector 0x87517c45
+    const permit2 = new ethers_1.ethers.Contract(rh_mcp_constants_js_1.RH_PERMIT2, [
+        "function approve(address token, address spender, uint160 amount, uint48 expiration)",
+        "function allowance(address user, address token, address spender) view returns (uint160 amount, uint48 expiration, uint48 nonce)",
+    ], signer);
+    try {
+        const al = await permit2.allowance(wallet.address, token, rh_mcp_constants_js_1.RH_UNIVERSAL_ROUTER);
+        const amt = BigInt(al.amount ?? al[0] ?? 0);
+        const exp = Number(al.expiration ?? al[1] ?? 0);
+        const now = Math.floor(Date.now() / 1000);
+        if (amt >= amountWei && exp > now + 60)
+            return hashes;
+    }
+    catch {
+        /* re-approve */
+    }
+    const expiration = Math.floor(Date.now() / 1000) + 30 * 24 * 3600; // 30d
+    // uint160 max for amount
+    const max160 = (1n << 160n) - 1n;
+    const tx2 = await permit2.approve(token, rh_mcp_constants_js_1.RH_UNIVERSAL_ROUTER, max160, expiration);
+    await tx2.wait();
+    hashes.push(tx2.hash);
+    return hashes;
+}
+/**
+ * Wait for the swap receipt and read back what actually happened on-chain.
+ *
+ * A quote is a prediction; a receipt is proof. Reporting only the quoted amount
+ * leaves the user unable to tell a real fill from a fabricated one, so we
+ * surface the mined status, block, gas, and the ACTUAL amount credited —
+ * parsed from the token's Transfer logs (buys) or the ETH balance delta (sells).
+ */
+async function confirmRhSwap(txHash, walletAddress, to, ethBefore) {
+    try {
+        const provider = await (0, rh_mcp_provider_js_1.rhProviderAsync)();
+        const receipt = await provider.waitForTransaction(txHash, 1, 90000);
+        if (!receipt)
+            return { mined: false };
+        let received;
+        if (to.kind === "token") {
+            // Sum Transfer(_, me, value) emitted by the bought token.
+            const TRANSFER_TOPIC = ethers_1.ethers.id("Transfer(address,address,uint256)");
+            const me = walletAddress.toLowerCase();
+            let total = 0n;
+            for (const log of receipt.logs ?? []) {
+                if (log.address?.toLowerCase() !== to.address.toLowerCase())
+                    continue;
+                if (log.topics?.[0] !== TRANSFER_TOPIC || log.topics.length < 3)
+                    continue;
+                const dest = "0x" + log.topics[2].slice(-40);
+                if (dest.toLowerCase() !== me)
+                    continue;
+                try {
+                    total += BigInt(log.data);
+                }
+                catch {
+                    /* skip malformed */
+                }
+            }
+            if (total > 0n)
+                received = ethers_1.ethers.formatUnits(total, to.decimals);
+        }
+        else if (ethBefore != null) {
+            // Selling for native ETH: credited amount = delta + gas actually burned.
+            try {
+                const after = BigInt(await (0, rh_mcp_provider_js_1.rhRpc)("eth_getBalance", [walletAddress, "latest"]));
+                const fee = BigInt(receipt.gasUsed ?? 0n) * BigInt(receipt.gasPrice ?? 0n);
+                const delta = after - ethBefore + fee;
+                if (delta > 0n)
+                    received = ethers_1.ethers.formatEther(delta);
+            }
+            catch {
+                /* balance read optional */
+            }
+        }
+        return {
+            mined: true,
+            ok: receipt.status === 1,
+            block: receipt.blockNumber,
+            gasUsed: receipt.gasUsed?.toString(),
+            received,
+        };
+    }
+    catch {
+        return { mined: false };
+    }
+}
+async function broadcastRhSwap(wallet, tx) {
+    const provider = await (0, rh_mcp_provider_js_1.rhProviderAsync)();
+    const signer = wallet.connect(provider);
+    // "pending" (not "latest") so sequential swaps in one orders-tick get
+    // incrementing nonces instead of colliding on the same unmined nonce.
+    const nonce = await provider.getTransactionCount(wallet.address, "pending");
+    const fee = await provider.getFeeData();
+    const signed = await signer.signTransaction({
+        to: tx.to,
+        data: tx.data,
+        value: BigInt(tx.value || "0"),
+        gasLimit: BigInt(tx.gas || "650000"),
+        maxFeePerGas: fee.maxFeePerGas ?? fee.gasPrice ?? 1000000000n,
+        maxPriorityFeePerGas: fee.maxPriorityFeePerGas ?? 100000000n,
+        nonce,
+        chainId: rh_mcp_constants_js_1.RH_CHAIN_ID,
+        type: 2,
+    });
+    const resp = await (0, rh_mcp_provider_js_1.rhRpc)("eth_sendRawTransaction", [signed]);
+    return resp;
+}

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

@@ -0,0 +1,137 @@
+"use strict";
+// Tool definitions for the rh_mcp_* / rh_* namespace. Pure data — no logic.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RH_MCP_TOOLS = void 0;
+exports.RH_MCP_TOOLS = [
+    {
+        name: "rh_mcp_status",
+        description: "Robinhood Chain MCP - status of RH rail (chainId 4663): wallet address, RPC, " +
+            "ETH gas balance on RH, explorer. Use at the start of any tokenized-stock session. " +
+            "NOT Robinhood Agentic brokerage (agent.robinhood.com).",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "rh_mcp_list_stocks",
+        description: "Robinhood Chain MCP - list the 22 Finch/ClawHood tokenized stock tickers " +
+            "(symbol, name, contract address) tradeable via Uniswap V4 on chain 4663.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Optional filter: symbol or name substring (e.g. 'NVDA', 'Apple')",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "rh_mcp_balance",
+        description: "Robinhood Chain MCP - ETH + tokenized stock balances on RH (chain 4663) for your " +
+            "Finch MCP wallet (same address as Base). Reads RH RPC directly (not Alchemy Base).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                address: {
+                    type: "string",
+                    description: "Optional 0x address (default: local Finch MCP wallet)",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "rh_mcp_estimate",
+        description: "Robinhood Chain MCP - preview ETH↔token swap quote via Uniswap V4 (direct or " +
+            "multi-hop via USDG). Does NOT execute. Always call before rh_mcp_swap. " +
+            "fromToken/toToken: 'ETH' or ANY RH-chain asset — a catalog stock symbol " +
+            "(NVDA, AAPL…), a crypto ticker, or a 0x contract address. Non-catalog tickers/CAs " +
+            "resolve via DexScreener. Route is always ETH↔token (buy with ETH or sell for ETH).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                fromToken: { type: "string", description: "Sell asset: ETH, ticker, or 0x contract address" },
+                toToken: { type: "string", description: "Buy asset: ETH, ticker, or 0x contract address" },
+                amount: { type: "string", description: "Human amount, e.g. '0.01' ETH or '1000' TOKEN" },
+                maxSlippagePct: {
+                    type: "number",
+                    description: "Slippage tolerance % (default 2.0; raise for thin crypto pairs)",
+                },
+            },
+            required: ["fromToken", "toToken", "amount"],
+        },
+    },
+    {
+        name: "rh_mcp_swap",
+        description: "Robinhood Chain MCP - execute ETH↔token swap on chain 4663. Quotes Uniswap V2, V3 and V4 " +
+            "and routes through whichever returns the most output. Works for catalog stocks AND " +
+            "arbitrary RH-chain crypto (by ticker or 0x address; resolved via DexScreener). Use " +
+            "rh_mcp_estimate first — and rh_analyze / rh_safety_check for unknown crypto. " +
+            "Buys (ETH→token) are 1 tx. Sells approve automatically, and the approval differs by route: " +
+            "V4 uses the 2-step Permit2 flow, V2/V3 use a single ERC-20 approve to SwapRouter02. " +
+            "Refuses to broadcast when the quote is far below DexScreener spot (override: acceptBadPrice). " +
+            "Reports the mined receipt — status, block, gas and the ACTUAL amount received. " +
+            "Gas paid in ETH on RH. NOT brokerage orders — for Robinhood Agentic brokerage use official MCP separately.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                fromToken: { type: "string", description: "Sell asset: ETH, ticker, or 0x contract address" },
+                toToken: { type: "string", description: "Buy asset: ETH, ticker, or 0x contract address" },
+                amount: { type: "string", description: "Human amount" },
+                maxSlippagePct: { type: "number", description: "Slippage % (default 2.0)" },
+                confirm: {
+                    type: "boolean",
+                    description: "Must be true to broadcast. Prevents accidental live swaps.",
+                },
+                acceptBadPrice: {
+                    type: "boolean",
+                    description: "Override the spot-price safety stop. Only set if you deliberately accept " +
+                        "receiving far less than DexScreener spot value (near-empty V4 pool).",
+                },
+            },
+            required: ["fromToken", "toToken", "amount", "confirm"],
+        },
+    },
+    {
+        name: "rh_token_resolve",
+        description: "Robinhood Chain MCP - resolve a crypto ticker OR 0x contract address to a tradeable " +
+            "token on chain 4663 via DexScreener. Ticker search returns candidates ranked by " +
+            "liquidity (tickers can be spoofed — always trade by the confirmed contract address). " +
+            "Use before rh_mcp_estimate/rh_mcp_swap for non-catalog crypto.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Crypto ticker (e.g. 'PEPE') or 0x contract address" },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "rh_analyze",
+        description: "Robinhood Chain MCP - market + risk pre-screen for any RH-chain token (ticker or 0x " +
+            "address). Pulls DexScreener data (price, liquidity, 24h volume, buy/sell txns, pair age, " +
+            "FDV/MCap) and returns a 0-100 risk score with reasoning flags. Combine with rh_safety_check " +
+            "(onchain) and deep_research (X sentiment) for a full verdict. Not financial advice.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                token: { type: "string", description: "Crypto ticker or 0x contract address on RH chain 4663" },
+            },
+            required: ["token"],
+        },
+    },
+    {
+        name: "rh_safety_check",
+        description: "Robinhood Chain MCP - free onchain safety scan for a token (ticker or 0x address). Reads " +
+            "Blockscout (contract verified?, explorer reputation, holder count, launchpad-style contract " +
+            "name) + DexScreener (sellable? honeypot signal from buys-with-0-sells). No LLM, no paid API. " +
+            "Returns red/yellow/green safety flags + a risk score. Pair with rh_analyze (market/liquidity).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                token: { type: "string", description: "Crypto ticker or 0x contract address on RH chain 4663" },
+            },
+            required: ["token"],
+        },
+    },
+];