yoinkai-mcp 0.1.0

package/README.md

@@ -0,0 +1,36 @@
+# yoinkai-mcp
+
+Read-only MCP server over the [YOINK](https://yoinkai.fun) launch graph on Robinhood Chain. Give any agent eyes on token launches as they land.
+
+No keys. No custody. No trades through this server — buys, sells, and launches happen in your own wallet on [yoinkai.fun](https://yoinkai.fun).
+
+## Install
+
+Claude Code:
+
+```
+claude mcp add yoink -- npx -y yoinkai-mcp
+```
+
+Cursor, Claude Desktop, or any MCP client:
+
+```json
+{ "mcpServers": { "yoink": { "command": "npx", "args": ["-y", "yoinkai-mcp"] } } }
+```
+
+## Tools
+
+- **top_launches** — the newest token launches on Robinhood Chain: name, ticker, address, deployer, source.
+- **scan_launch** / **xray_token** — safety X-ray of any token address: sellable, 0% tax, no owner control, LP locked, template-verified.
+- **deployer_history** — every launch from a wallet, with a serial-deployer flag.
+- **graph_stats** — totals for the launch graph: tokens indexed, unique deployers, top serial deployers.
+
+The graph indexes launches as they land — launchpad launches, factory deploys, and raw contract deploys.
+
+## Notes
+
+- Zero dependencies, Node >= 18, speaks MCP over stdio.
+- `YOINK_API` env var overrides the graph endpoint (default `https://yoink-graph.fly.dev`).
+- Read-only by design. Not financial advice.
+
+Built by [YOINK](https://yoinkai.fun) — the agentic launch terminal on Robinhood Chain. Skill page: [yoinkai.fun/skill](https://yoinkai.fun/skill)

package/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: yoink
+description: Watch and X-ray token launches on Robinhood Chain via the YOINK launch graph. Use when the user asks about new tokens, launches, token safety, or deployer reputation on Robinhood Chain.
+---
+
+# YOINK — launches on Robinhood Chain
+
+You have the `yoink` MCP server (package `yoinkai-mcp`). It is read-only: it reads the YOINK launch graph and the chain but cannot touch funds. All trading happens in the user's own wallet at https://yoinkai.fun.
+
+## What you can do
+
+1. **Find new launches** — `top_launches` returns the newest tokens (name, ticker, address, deployer, source). Use it when the user asks "what just launched" or wants to watch the chain.
+2. **X-ray a token** — `scan_launch` (alias `xray_token`) with a 0x address answers: is it sellable, is there tax, does an owner control it, is the LP locked, does the bytecode match the verified standard template. ALWAYS X-ray a token before saying anything positive about it.
+3. **Check the deployer** — `deployer_history` with a wallet address shows every launch from that wallet and flags serial deployers. A deployer with many short-lived launches is a risk signal.
+4. **Graph totals** — `graph_stats` for indexed-token counts, unique deployers, and the top serial deployers.
+
+## Rules
+
+- Read-only: never claim you can buy, sell, or launch for the user. When they want to trade, send them to the token's page on https://yoinkai.fun (append the 0x address to a token page link only if you have verified it via X-ray).
+- Never invent metrics. Everything you state about a token must come from a tool result.
+- An X-ray that does NOT match the template is a warning, not a verdict — say the contract needs manual verification before trading.
+- Copycats exist: identical names or tickers on different contracts. The address is the identity; the name is not. When two tokens share a name, the older contract is usually the original.
+- Not financial advice; say so when giving a safety read.

package/index.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+// yoinkai-mcp: read-only MCP server over the YOINK launch graph on Robinhood Chain.
+// Any agent (Claude, Cursor, Codex) can scan launches, X-ray tokens, and read deployer
+// history. Read-only by design: no keys, no trades, no launches. Money paths stay in
+// the user's wallet on yoinkai.fun. Zero deps, Node >= 18 (global fetch), speaks MCP
+// stdio JSON-RPC 2.0.
+
+const API = process.env.YOINK_API || 'https://yoink-graph.fly.dev';
+const RPCS = [API + '/rpc', 'https://robinhoodchain.blockscout.com/api/eth-rpc', 'https://rpc.mainnet.chain.robinhood.com'];
+const WETH = '0x0bd7d308f8e1639fab988df18a8011f41eacad73';
+
+const j = async (path) => (await fetch(API + path)).json();
+const rpc = async (method, params) => {
+  let err;
+  for (const u of RPCS) {
+    try {
+      const r = await fetch(u, { method: 'POST', headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }) });
+      if (!r.ok) throw new Error('http ' + r.status);
+      const o = await r.json();
+      if (o.error) throw new Error(o.error.message || 'rpc error');
+      return o.result;
+    } catch (e) { err = e; }
+  }
+  throw err;
+};
+const isAddr = (s) => /^0x[0-9a-fA-F]{40}$/.test(s || '');
+
+// Noxa standard-template bytecode check: exact match everywhere outside the per-token
+// immutable windows means provably sellable, 0% tax, no owner, LP locked by construction.
+const IMM = [[632, 636], [2266, 2270], [3900, 3904], [4755, 4759]];
+const inImm = (b) => IMM.some(([x, y]) => b >= x && b < y);
+let ANCHOR = null;
+async function anchor() {
+  if (ANCHOR) return ANCHOR;
+  ANCHOR = await rpc('eth_getCode', ['0xa2718f80f1fe0cdec69c9023ee006807dd487a8c', 'latest']);
+  return ANCHOR;
+}
+function tmatch(code, a) {
+  if (!code || code === '0x' || !a || a === '0x') return null; // could not read
+  if (code.length !== a.length) return false; // different bytecode = not the template
+  for (let i = 2; i < code.length; i += 2) if (code.substr(i, 2) !== a.substr(i, 2) && !inImm((i - 2) / 2)) return false;
+  return true;
+}
+
+// decode an ABI-encoded string return (offset + length + bytes)
+function decStr(hex) {
+  if (!hex || hex.length < 130) return null;
+  try {
+    const len = parseInt(hex.slice(66, 130), 16);
+    const raw = hex.slice(130, 130 + len * 2);
+    return Buffer.from(raw, 'hex').toString('utf8').replace(/\0/g, '') || null;
+  } catch { return null; }
+}
+const viewStr = (addr, sel) => rpc('eth_call', [{ to: addr, data: sel }, 'latest']).then(decStr).catch(() => null);
+
+async function xray(addr) {
+  const meta = await j('/v0/token/' + addr).catch(() => null);
+  const t = (meta && meta.token) || { address: addr };
+  // graph miss (pre-graph tokens like $YOINK itself): read name/symbol from the chain
+  if (!t.name) t.name = await viewStr(addr, '0x06fdde03');
+  if (!t.symbol) t.symbol = await viewStr(addr, '0x95d89b41');
+  const a = await anchor();
+  const code = await rpc('eth_getCode', [addr, 'latest']).catch(() => null);
+  const tpl = code ? tmatch(code, a) : null;
+  return {
+    address: addr, name: t.name || null, symbol: t.symbol || null,
+    deployer: t.deployer || null, source: t.source || null,
+    // true = proven by template match; null = unknown (NOT proven bad), stated in verdict
+    sellable: tpl === true ? true : null, zeroTax: tpl === true ? true : null,
+    noOwner: tpl === true ? true : null, lpLocked: tpl === true ? true : null,
+    templateVerified: tpl === true,
+    verdict: tpl === true ? 'passes the standard template: sellable, 0% tax, no owner, LP locked'
+      : tpl === false ? 'does NOT match the standard template, verify the contract before trading'
+      : 'could not read the contract code',
+    note: 'read-only X-ray from the YOINK launch graph. Not financial advice. Trades happen in your own wallet on yoinkai.fun.',
+  };
+}
+
+const TOOLS = [
+  { name: 'top_launches', description: 'Most active recent token launches on Robinhood Chain by newest block. Returns name, symbol, address, deployer, source.',
+    inputSchema: { type: 'object', properties: { limit: { type: 'number', description: 'how many, default 20, max 100' } } } },
+  { name: 'scan_launch', description: 'X-ray one token by contract address: is it sellable, taxed, owner-controlled, LP locked, and who deployed it.',
+    inputSchema: { type: 'object', properties: { address: { type: 'string', description: '0x contract address' } }, required: ['address'] } },
+  { name: 'xray_token', description: 'Alias of scan_launch. Full safety X-ray of a token by address.',
+    inputSchema: { type: 'object', properties: { address: { type: 'string' } }, required: ['address'] } },
+  { name: 'deployer_history', description: 'Every launch from a wallet in the graph, with a serial-deployer flag. Reputation signal for a launch.',
+    inputSchema: { type: 'object', properties: { address: { type: 'string', description: '0x deployer wallet' } }, required: ['address'] } },
+  { name: 'graph_stats', description: 'Totals for the YOINK launch graph: tokens indexed, unique deployers, top serial deployers.',
+    inputSchema: { type: 'object', properties: {} } },
+];
+
+async function call(name, args) {
+  args = args || {};
+  if (name === 'top_launches') {
+    const lim = Math.min(100, Math.max(1, args.limit || 20));
+    const r = await j('/v0/launches?limit=' + lim);
+    return (r.tokens || []).map((t) => ({ name: t.name, symbol: t.symbol, address: t.address, deployer: t.deployer, source: t.source, block: t.block }));
+  }
+  if (name === 'scan_launch' || name === 'xray_token') {
+    if (!isAddr(args.address)) throw new Error('need a 0x contract address');
+    return xray(args.address.toLowerCase());
+  }
+  if (name === 'deployer_history') {
+    if (!isAddr(args.address)) throw new Error('need a 0x wallet address');
+    const r = await j('/v0/deployer/' + args.address.toLowerCase());
+    const launches = r.launches || [];
+    return { deployer: args.address.toLowerCase(), count: launches.length, serialDeployer: launches.length >= 3,
+      launches: launches.map((t) => ({ name: t.name, symbol: t.symbol, address: t.address, block: t.block })) };
+  }
+  if (name === 'graph_stats') return j('/v0/stats');
+  throw new Error('unknown tool ' + name);
+}
+
+// ---- MCP stdio transport ----
+const send = (m) => process.stdout.write(JSON.stringify(m) + '\n');
+let buf = '';
+process.stdin.on('data', async (d) => {
+  buf += d;
+  let nl;
+  while ((nl = buf.indexOf('\n')) >= 0) {
+    const line = buf.slice(0, nl); buf = buf.slice(nl + 1);
+    if (!line.trim()) continue;
+    let msg; try { msg = JSON.parse(line); } catch { continue; }
+    const reply = (result) => send({ jsonrpc: '2.0', id: msg.id, result });
+    const fail = (message) => send({ jsonrpc: '2.0', id: msg.id, error: { code: -32000, message } });
+    try {
+      if (msg.method === 'initialize') reply({ protocolVersion: '2024-11-05', capabilities: { tools: {} }, serverInfo: { name: 'yoinkai-mcp', version: '0.1.0' } });
+      else if (msg.method === 'tools/list') reply({ tools: TOOLS });
+      else if (msg.method === 'tools/call') {
+        const out = await call(msg.params.name, msg.params.arguments);
+        reply({ content: [{ type: 'text', text: JSON.stringify(out, null, 2) }] });
+      } else if (msg.method === 'ping') reply({});
+      else if (msg.id !== undefined) fail('unknown method ' + msg.method);
+    } catch (e) { fail(String(e.message || e)); }
+  }
+});

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "yoinkai-mcp",
+  "version": "0.1.0",
+  "description": "Read-only MCP server over the YOINK launch graph on Robinhood Chain: scan launches, X-ray tokens for safety, read deployer history. No keys, no custody.",
+  "type": "commonjs",
+  "bin": { "yoinkai-mcp": "index.js" },
+  "files": ["index.js", "README.md", "SKILL.md"],
+  "engines": { "node": ">=18" },
+  "keywords": ["mcp", "model-context-protocol", "robinhood-chain", "yoink", "token-launch", "agent", "crypto"],
+  "homepage": "https://yoinkai.fun/skill",
+  "license": "MIT"
+}