@candledottv/mcp 0.9.0 → 0.10.0

package/README.md

@@ -85,7 +85,7 @@ tools, getting a key, funding the embedded wallet, and idempotent retries, see
 | `candle_launch_token` | Launch a token on Candle | `POST /api/v1/launch/headless` (or `/dry-run` when `dryRun: true`) | `CANDLE_AGENT_API_KEY` |
 | `candle_get_market` | Get market state | `GET /api/v1/markets/:chain/:mint` | none |
 | `candle_get_feed` | Get a token feed | `GET /api/v1/markets/feed?bucket=...` | none |
-| `candle_token_forensics` | Deployer history, deploy-window buyers, holder concentration, risk tier | `GET /api/v1/markets/:chain/:mint/forensics` | none |
+| `candle_token_forensics` | Deployer history, deploy-window buyers, sourced token safety flags | `GET /api/v1/markets/:chain/:mint/forensics` | none |
 | `candle_report_activity` | Report on-chain activity | `POST /api/v1/activity/report` | `CANDLE_AGENT_API_KEY` |
 | `candle_get_agent_profile` | Get an agent profile | `GET /api/v1/users/:idOrWallet/agent` | none |
 | `candle_trade` | Buy or sell a token | Reads the market for its decimals (or wallet balance, for a percent sell) then `POST /api/v1/trade/agent/build` | `CANDLE_AGENT_API_KEY` (`swap:write`) |

package/dist/index.js

@@ -106,7 +106,7 @@ function percentOfBalance(balanceRaw, percent) {
 import { randomUUID } from "node:crypto";
 
 // src/version.ts
-var SERVER_VERSION = "0.9.0";
+var SERVER_VERSION = "0.10.0";
 
 // src/update-notice.ts
 var PLAIN_VERSION = /^\d+\.\d+\.\d+$/;
@@ -220,10 +220,36 @@ async function readMarket(mint, cfg, doFetch, extra) {
     headers: headers()
   });
   const text = await res.text();
-  if (!res.ok)
-    return { status: res.status, err: relayRead(text, extra) };
+  if (!res.ok) {
+    let reason;
+    try {
+      reason = JSON.parse(text)?.error?.routing?.reason;
+    } catch {}
+    return { status: res.status, err: relayRead(text, extra), reason };
+  }
   return { market: JSON.parse(text).market ?? {} };
 }
+function isPaperFlag(value) {
+  return value === true || value === "true" || value === 1 || value === "1";
+}
+function heldPaperPosition(positions, mint) {
+  const key = (value) => {
+    const trimmed = value.trim();
+    return /^0x[0-9a-fA-F]{40}$/.test(trimmed) ? trimmed.toLowerCase() : trimmed;
+  };
+  return positions.find((p) => key(p.mint) === key(mint) && p.amountRaw !== "0");
+}
+async function readPaperInventory(cfg, doFetch, extra) {
+  const res = await doFetch(`${base(cfg)}/api/v1/trade/agent/paper/inventory`, {
+    method: "GET",
+    headers: headers(cfg.apiKey)
+  });
+  const text = await res.text();
+  if (!res.ok)
+    return { err: relayRead(text, extra) };
+  const body = JSON.parse(text);
+  return { positions: body.positions ?? [] };
+}
 async function executeTrade(args, cfg, doFetch) {
   const apiKey = requireApiKey(cfg);
   const clientTradeId = args.clientTradeId ?? randomUUID();
@@ -237,19 +263,25 @@ async function executeTrade(args, cfg, doFetch) {
     return errText("percent is only valid on sells; buys take a quote-asset amount", { clientTradeId });
   }
   let amountRaw;
-  let resolved;
+  let resolved = {};
+  let paper = isPaperFlag(args.paper);
   try {
     if (args.side === "buy") {
       const amount = args.amount;
       const read = await readMarket(args.mint, cfg, doFetch, { clientTradeId });
       let decimals;
-      if ("market" in read) {
+      if ("market" in read && (read.market.external === true || read.market.candleLaunched === false)) {
+        const q = quoteIdDecimals(args.quoteAsset, chainForMint(args.mint), { clientTradeId });
+        if ("err" in q)
+          return q.err;
+        decimals = q.decimals;
+      } else if ("market" in read) {
         const quoteDecimals = read.market.quoteDecimals;
         if (typeof quoteDecimals !== "number") {
           return errText(`could not resolve the quote decimals for mint ${args.mint}; a buy is denominated in that token's own quote asset and this market does not report its scale. Read the market with candle_get_market, then trade a raw amount via the SDK instead`, { clientTradeId });
         }
         decimals = quoteDecimals;
-      } else if (read.status === 404) {
+      } else if (read.status === 404 && read.reason !== "chain_mismatch") {
         const q = quoteIdDecimals(args.quoteAsset, chainForMint(args.mint), { clientTradeId });
         if ("err" in q)
           return q.err;
@@ -264,17 +296,36 @@ async function executeTrade(args, cfg, doFetch) {
       resolved = { amountDecimal: amount, decimals, amountRaw };
     } else if (args.amount !== undefined) {
       const read = await readMarket(args.mint, cfg, doFetch, { clientTradeId });
-      if (!("market" in read))
+      let decimals;
+      if ("market" in read) {
+        if (typeof read.market.decimals !== "number") {
+          return errText(`could not resolve decimals for mint ${args.mint}; pass a raw-ready amount via the SDK instead`, { clientTradeId });
+        }
+        decimals = read.market.decimals;
+      } else if (read.status === 404 && read.reason !== "chain_mismatch") {
+        const inventory = await readPaperInventory(cfg, doFetch, { clientTradeId });
+        if ("err" in inventory) {
+          return paper ? inventory.err : read.err;
+        }
+        const held = heldPaperPosition(inventory.positions, args.mint);
+        if (typeof held?.tokenDecimals !== "number") {
+          if (paper) {
+            return errText(`could not resolve decimals for mint ${args.mint}; no Candle market and no paper position with a known scale. Buy it in paper first, or pass a raw amount via the SDK`, { clientTradeId });
+          }
+          return read.err;
+        }
+        decimals = held.tokenDecimals;
+        paper = true;
+      } else {
         return read.err;
-      const decimals = read.market.decimals;
-      if (typeof decimals !== "number") {
-        return errText(`could not resolve decimals for mint ${args.mint}; pass a raw-ready amount via the SDK instead`, { clientTradeId });
       }
       const converted = rawOrError(args.amount, decimals, { clientTradeId });
       if ("err" in converted)
         return converted.err;
       amountRaw = converted.raw;
       resolved = { amountDecimal: args.amount, decimals, amountRaw };
+    } else if (paper) {
+      resolved = { percent: args.percent };
     } else {
       const percent = args.percent;
       const walletsRes = await doFetch(`${base(cfg)}/api/v1/agent/wallets/embedded`, {
@@ -287,23 +338,37 @@ async function executeTrade(args, cfg, doFetch) {
       const walletsBody = JSON.parse(walletsText);
       const chain = chainForMint(args.mint);
       const address = chain === "hood" ? walletsBody.wallets?.evm?.address : walletsBody.wallets?.solana?.address;
+      let walletEmpty;
       if (!address) {
-        return errText(`percent sells need an embedded ${chain === "hood" ? "EVM" : "Solana"} wallet, and this account has none`, { clientTradeId });
+        walletEmpty = errText(`percent sells need an embedded ${chain === "hood" ? "EVM" : "Solana"} wallet, and this account has none`, { clientTradeId });
+      } else {
+        const balRes = await doFetch(`${base(cfg)}/api/v1/tokens/${encodeURIComponent(args.mint)}/balance/${encodeURIComponent(address)}`, {
+          method: "GET",
+          headers: headers()
+        });
+        const balText = await balRes.text();
+        if (!balRes.ok)
+          return relayRead(balText, { clientTradeId });
+        const balBody = JSON.parse(balText);
+        const balance = balBody.payload?.balance;
+        if (balance) {
+          amountRaw = percentOfBalance(balance, percent);
+          resolved = { percent, balanceRaw: balance, amountRaw };
+        } else {
+          walletEmpty = errText(`the embedded wallet ${address} holds no ${args.mint}; nothing to sell`, {
+            clientTradeId
+          });
+        }
       }
-      const balRes = await doFetch(`${base(cfg)}/api/v1/tokens/${encodeURIComponent(args.mint)}/balance/${encodeURIComponent(address)}`, {
-        method: "GET",
-        headers: headers()
-      });
-      const balText = await balRes.text();
-      if (!balRes.ok)
-        return relayRead(balText, { clientTradeId });
-      const balBody = JSON.parse(balText);
-      const balance = balBody.payload?.balance;
-      if (!balance) {
-        return errText(`the embedded wallet ${address} holds no ${args.mint}; nothing to sell`, { clientTradeId });
+      if (walletEmpty) {
+        const inventory = await readPaperInventory(cfg, doFetch, { clientTradeId });
+        if (!("err" in inventory) && heldPaperPosition(inventory.positions, args.mint)) {
+          paper = true;
+          resolved = { percent };
+        } else {
+          return walletEmpty;
+        }
       }
-      amountRaw = percentOfBalance(balance, percent);
-      resolved = { percent, balanceRaw: balance, amountRaw };
     }
   } catch (err) {
     return errText(err instanceof Error ? err.message : String(err), { clientTradeId });
@@ -312,11 +377,11 @@ async function executeTrade(args, cfg, doFetch) {
     clientTradeId,
     mint: args.mint,
     side: args.side,
-    amountRaw,
+    ...amountRaw !== undefined ? { amountRaw } : { percent: args.percent },
     payer: { type: "main" },
     ...args.quoteAsset !== undefined ? { quoteAsset: args.quoteAsset } : {},
     ...args.maxSlippageBps !== undefined ? { maxSlippageBps: args.maxSlippageBps } : {},
-    ...args.paper === true ? { paper: true } : {}
+    ...paper ? { paper: true } : {}
   }, doFetch);
   if ("thrown" in posted)
     return transportError("clientTradeId", clientTradeId, posted.thrown);
@@ -750,11 +815,11 @@ var tradeShape = {
   mint: z.string().describe("Token mint (solana) or contract address (hood)"),
   side: z.enum(["buy", "sell"]),
   amount: z.string().optional().describe("Decimal amount. Buys: how much of THIS TOKEN'S OWN quote asset to spend (SOL for a " + 'SOL-launched token, USDC for a USDC-quoted one, and so on: e.g. "0.5"). Sells: how many ' + "TOKENS to sell. Pass exactly one of amount or percent."),
-  percent: z.number().optional().describe("Sells only: sell this percent (integer 1-100) of the wallet's holding, on either chain."),
+  percent: z.number().optional().describe("Sells only: sell this percent (integer 1-100) of the holding. Live trades size against the " + "embedded wallet. Paper trades (`paper: true`) size against this key's paper inventory -- " + "the position a previous paper buy credited -- because paper never moves the live wallet."),
   quoteAsset: z.string().optional().describe('What the wallet spends on a buy or receives on a sell: "sol", "usdc" or "cndl" on Solana, ' + '"eth" or "usdg" on Hood. Safe to pass through from candle_quote. On Solana it applies only ' + "to an arbitrary mint Candle never launched (Pro/Max) and is ignored for a Candle token, " + "whose quote comes from the token itself. On Hood it is the settlement asset of a DEX " + "trade; a USDG buy adds an approval transaction an ETH buy does not. It is not the route: " + "the cheapest path to the asset is chosen separately. Defaults to sol / ETH settlement."),
   maxSlippageBps: z.number().optional().describe("Max slippage in basis points; API default applies when omitted"),
   clientTradeId: z.string().optional().describe("Idempotency key. Auto-generated when omitted and echoed in the result. Retrying with the " + "SAME id is safe (idempotent replay); a new id is a SECOND trade."),
-  paper: z.boolean().optional().describe("Rehearse instead of trading. The request passes every admission rule a live trade passes " + "-- the same planner, spend gate, key cap and loss limits -- and records the quote, but " + "nothing is ever broadcast and no funds move. Use it to check that a strategy is admitted " + "before risking anything on it. A paper fill is optimistic by construction: it books the " + "quoted price, so the gap between a paper arm and a live one IS the execution cost.")
+  paper: z.preprocess((value) => value === "true" || value === 1 || value === "1" ? true : value === "false" || value === 0 || value === "0" ? false : value, z.boolean().optional().describe("Rehearse instead of trading. The request passes every admission rule a live trade passes " + "-- the same planner, spend gate, key cap and loss limits -- and records the quote, but " + "nothing is ever broadcast and no funds move. Use it to check that a strategy is admitted " + "before risking anything on it. A paper fill is optimistic by construction: it books the " + "quoted price, so the gap between a paper arm and a live one IS the execution cost. " + "A sell of a mint this key already paper-bought also closes that paper book when the " + "live wallet is empty, even if this flag is omitted."))
 };
 var { buyAmount: _rawBuyAmount, ...seedableLaunchShape } = launchTokenShape;
 var launchAndSeedShape = {
@@ -790,23 +855,21 @@ function registerTools(server, env = process.env) {
   }, async (args) => callAndRelay("candle_launch_token", args, cfg));
   register("candle_get_market", {
     title: "Get market state",
-    description: "Read the current market state for a token: lifecycle, pool address, whether buys are " + `open. Reads only; moves nothing. No key needed.
-
-` + "COVERAGE: this answers for tokens that have a CANDLE market. candle_get_feed indexes " + "the wider market too (pump.fun, pons.family), so a mint that feed just returned can " + "still come back MARKET_NOT_FOUND here. That is a coverage boundary, not a fault and " + "not a reason to retry or re-authenticate -- say Candle has no market for it and move on.",
+    description: "Read Candle and indexed external markets, including indexed-but-not-routable tokens. No key needed. " + "Read candleLaunched, launchpad, venue and trade.routable; jupiterOk and discovery flags are distinct. " + "Routability is stored eligibility, not a quote or permission. General quotes use POST /api/v1/trade/agent/quote. " + "Curve quotes and lifecycle describe Candle launches. MARKET_NOT_FOUND is a legacy code: read " + "error.routing.reason, error.discovery and sibling error.retryable. A curve-only 404 does not mean untradeable.",
     inputSchema: getMarketShape
   }, async (args) => callAndRelay("candle_get_market", args, cfg));
   register("candle_token_forensics", {
     title: "Token forensics",
-    description: `Gate a buy before making it: deployer history, who bought in the deploy window (the creator's own wallets are marked disclosed; strangers in the same slot are the bundle signal), holder concentration, and a risk tier (LOW/MODERATE/HIGH/CRITICAL) with per-factor reasons. Every measurement carries a coverage note -- 'unavailable' is not 'clean'. No key needed.
+    description: `Gate a buy before making it: who launched it (resolved on-chain; pump.fun's shared updateAuthority is never the developer), their went-to-zero rate and last coins, who bought in the deploy window (the creator's own wallets are marked disclosed; strangers in the same slot are the bundle signal), same-funder insider share, same-funder deployer cluster, and safety.summary with six sourced flags (mintAuthority, freezeAuthority, tokenExtensions, lpLock, sellability, liquidityDrain). Refuse an unprompted buy when flagged; incomplete or unknown is not clearance. launch.deployerLaunches is an inclusive informational count, never a warning. Every measurement carries a coverage note -- 'unavailable' is not 'clean'. No key needed.
 
-MARKET_NOT_FOUND means Candle has no market for that token and this could not run. That is also not 'clean': report that you could not check it, rather than reporting the token as safe. That refusal now carries error.coverage -- covered:false, a reason ('external_launchpad' when the token launched somewhere else, 'unknown_mint' when nobody has indexed it), the launchpad when known, and every check that consequently did not run. Read it instead of guessing. Most of the feed answers this way.`,
+MARKET_NOT_FOUND means Candle has no market for that token and this could not run. That is also not 'clean': report that you could not check it, rather than reporting the token as safe. That refusal now carries error.coverage -- covered:false, a reason ('external_launchpad' when the token launched somewhere else, 'unknown_mint' when nobody has indexed it), the launchpad when known, and every check that consequently did not run. Read it instead of guessing. Most of the feed now answers with a partial report instead.`,
     inputSchema: tokenForensicsShape
   }, async (args) => callAndRelay("candle_token_forensics", args, cfg));
   register("candle_get_feed", {
     title: "Get a token feed",
     description: "Read one of the trade page's public feeds: new, graduated, onfire, or bluechip. Reads " + `only; moves nothing. No key needed. Start here when nobody has named a token.
 
-` + "This indexes the WIDER market, not just Candle's own launches, so rows carry a " + "`launchpad` (pump.fun, pons.family, ...). A row appearing here does NOT mean Candle " + "has a market for it: candle_get_market and candle_token_forensics can legitimately " + `answer MARKET_NOT_FOUND for a mint this returned.
+` + "This indexes the WIDER market, not just Candle's own launches. Rows carry launchpad and " + "discovery flags (jupiterOk, externalTradeable, paperDiscoveryOk, organic0LiveOk). " + "candle_get_market resolves Jupiter-indexed rows; do not hard-skip organicScore=0 on live " + "when organic0LiveOk is true. liquidityDrawdownBps is a signal only — nothing here blocks " + `resolve or trade on drain; filter with where if you want to avoid draining pools.
 
 ` + "Filter, sort and pick fields SERVER-SIDE rather than reading the whole feed: an " + "unfiltered response is around 135KB and will not fit in a tool result. See `where`, " + "`sort` and `fields`.\n\n" + "One rule to know before screening on safety: a missing field is NOT a false one. " + "mintAuthorityDisabled and freezeAuthorityDisabled are absent on a real share of rows, " + "and absent means nobody checked, not that the authority is disabled. `where` never lets " + 'an absent field satisfy a comparison, so {"mintAuthorityDisabled":{"eq":true}} returns ' + "only tokens that actually say so.",
     inputSchema: getFeedShape
@@ -909,11 +972,11 @@ MARKET_NOT_FOUND means Candle has no market for that token and this could not ru
 ` + `Before the first trade of a run, once:
 ` + "1. candle_execution_status  -- confirms the wallets, the tier and this key's spend " + "limits. Call it at the start, or after an auth error; do not infer readiness from a " + `failed trade.
 ` + "2. candle_resolve_token  -- if a human handed you a bare address. It returns the chain, " + `so you never have to guess it.
-` + "3. candle_token_forensics  -- before you quote or buy anything. It returns a risk tier " + "and per-factor reasons. MARKET_NOT_FOUND there means Candle has no market for the " + `token, NOT that the token is clean.
+` + "3. candle_token_forensics  -- before you quote or buy anything. It returns safety.summary and sourced flags " + "with timestamps and details. Unknown is not clean. MARKET_NOT_FOUND there means Candle has no market for the " + `token, NOT that the token is clean.
 
 ` + "Arguments: `mint` and `side` are required. Amounts are DECIMAL, never raw base units " + '(amount: "0.5", not lamports). Omitting the amount on a sell sells the whole ' + `position.
 
-` + "Pass `paper: true` to rehearse: every admission rule runs and the quote is recorded, but " + "nothing broadcasts and no funds move. Do this before the first live trade of a new " + `strategy, and whenever you are unsure a trade would be admitted at all.
+` + "Pass `paper: true` to rehearse: every admission rule runs and the quote is recorded, but " + "nothing broadcasts and no funds move. A paper buy credits this key's paper inventory, " + "including for external Solana mints routed through Jupiter. A later sell by amount or " + "percent closes that book without reading the live wallet and without MARKET_NOT_FOUND " + "-- including when `paper` is omitted on the exit, as long as the paper position exists. " + "Do this before the first live trade of a new strategy, and whenever you are unsure a " + `trade would be admitted at all.
 
 ` + `After the call:
 ` + "- A timeout is not a failure. Retry with the SAME clientTradeId from the result -- it " + `coalesces the duplicate. A NEW id is a SECOND trade, and that is how you double-spend.
@@ -940,16 +1003,30 @@ START HERE — five tools need NO credential. Call these first to confirm the se
   candle_get_market       price, market cap, volume, curve state for one token
   candle_get_feed         the roster: hot streak, new pairs, graduated, blue chip
   candle_resolve_token    a ticker or partial name -> mint address + chain
-  candle_token_forensics  call this before quoting or buying, whenever the token has a Candle market. Returns deployer history, who bought in the deploy window (strangers in the same slot are the bundle signal), holder concentration, and a risk tier LOW/MODERATE/HIGH/CRITICAL with per-factor reasons
+  candle_token_forensics  call this before quoting or buying. Returns the on-chain developer (never a launchpad shared authority), their went-to-zero rate and last coins, who bought in the deploy window (strangers in the same slot are the bundle signal), same-funder insider share, same-funder cluster, and safety.summary with six sourced flags. Refuse an unprompted buy when flagged; incomplete or unknown is not clearance. launch.deployerLaunches is an inclusive informational count, never a warning
   candle_get_agent_profile  your own tier, caps and verified activity
 
 COVERAGE — read this before you treat an error as a broken server.
 candle_get_feed indexes the wider market (pump.fun, pons.family and other external launchpads).
-candle_get_market and candle_token_forensics answer for tokens that have a CANDLE market. So a
-mint that candle_get_feed just returned can still come back MARKET_NOT_FOUND from those two, and
-that is a coverage boundary, not a fault and not a reason to retry, re-auth, or tell the human the
-integration is down. Report it as "Candle has no market for this token, so I could not run
-forensics on it" and let the human decide.
+Feed rows carry jupiterOk / externalTradeable / paperDiscoveryOk / organic0LiveOk on external
+Solana mints. Use discovery=paper on candle_get_feed when rehearsing; on live screens do NOT
+hard-skip organicScore=0 when organic0LiveOk is true (visible m5 momentum). Hard-skip organic0
+only when organic0LiveOk is false.
+candle_get_market and candle_resolve_token answer for same-chain indexed external mints even
+when trade.routable is false. Read candleLaunched, launchpad, venue and trade; jupiterOk and
+paperDiscoveryOk are separate signals. Identity-only Solana reads have route_unverified.
+General quotes use POST /api/v1/trade/agent/quote; curve quotes/lifecycle describe Candle launches.
+Stored eligibility is not a successful quote or permission. MARKET_NOT_FOUND remains a legacy
+code: read error.routing.reason, error.discovery and sibling error.retryable. A curve-only
+404 is endpoint guidance, not a verdict that Candle cannot trade external tokens.
+candle_token_forensics also answers for Solana tokens the feed already knows, with a partial
+report: on-chain developer (never a launchpad shared authority), went-to-zero record, token
+safety flags, same-funder insiders and cluster. Deploy-window stays unavailable without a
+Candle launch record. Indexed external Hood tokens also answer, with unknown hacc flags.
+Unknown mints can still come back MARKET_NOT_FOUND. That remaining gap is a coverage boundary,
+not a fault and not a reason to retry, re-auth, or tell the human the integration is down.
+Report MARKET_NOT_FOUND as "Candle has no market for this token, so I could not run forensics
+on it" and let the human decide.
 
 Never let a MARKET_NOT_FOUND stand in for a clean bill of health. The same rule governs the
 coverage note on every forensics measurement: "unavailable" is NOT "clean" — say so rather than

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@candledottv/mcp",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "MCP server for the Candle agent rail: launch tokens, read markets, report activity",
   "type": "module",
   "license": "MIT",