@xgamesfun/solana 0.28.7 → 0.28.8

package/README.md

@@ -77,7 +77,7 @@ codex plugin add xsolana@xgamesfun
 
 **claude.ai, ChatGPT or Claude Desktop:** add `https://xgames.fun/mcp` as a custom connector. Nothing to install.
 
-**Cursor, Cline, opencode or any MCP client:** run `npx -y --package=@xgamesfun/solana@0.28.7 xsolana mcp`.
+**Cursor, Cline, opencode or any MCP client:** run `npx -y --package=@xgamesfun/solana@0.28.8 xsolana mcp`.
 
 **Any agent that reads skills** (Copilot, Gemini CLI, Windsurf…): `npx skills add XGamesFun/solana-kit`.
 
@@ -88,26 +88,26 @@ are in [docs/harnesses.md](docs/harnesses.md).
 
 ```bash
 # find a worked example close to your idea
-npx -y @xgamesfun/solana@0.28.7 examples shop with loot boxes
+npx -y @xgamesfun/solana@0.28.8 examples shop with loot boxes
 
 # using a coin you already launched? read it from the chain into its "tokens" entry
-npx -y @xgamesfun/solana@0.28.7 token <its mint address>
+npx -y @xgamesfun/solana@0.28.8 token <its mint address>
 
 # does it work? where does the money go? what does it cost?
-npx -y @xgamesfun/solana@0.28.7 check xsolana.json
-npx -y @xgamesfun/solana@0.28.7 simulate xsolana.json
-npx -y @xgamesfun/solana@0.28.7 cost xsolana.json
+npx -y @xgamesfun/solana@0.28.8 check xsolana.json
+npx -y @xgamesfun/solana@0.28.8 simulate xsolana.json
+npx -y @xgamesfun/solana@0.28.8 cost xsolana.json
 
 # the whole economy in plain words, and what a cheater could get
-npx -y @xgamesfun/solana@0.28.7 explain xsolana.json
-npx -y @xgamesfun/solana@0.28.7 review xsolana.json
+npx -y @xgamesfun/solana@0.28.8 explain xsolana.json
+npx -y @xgamesfun/solana@0.28.8 review xsolana.json
 
 # go live: a key file for the project (it prints the address to send SOL to, never the key)…
-npx -y @xgamesfun/solana@0.28.7 keygen ~/.config/xsolana/my-game.json
+npx -y @xgamesfun/solana@0.28.8 keygen ~/.config/xsolana/my-game.json
 # …then everything going live would send, and a code; nothing is sent
-npx -y @xgamesfun/solana@0.28.7 approve xsolana.json --keypair ~/.config/xsolana/my-game.json
+npx -y @xgamesfun/solana@0.28.8 approve xsolana.json --keypair ~/.config/xsolana/my-game.json
 # …and with that code, exactly what it listed is sent
-npx -y @xgamesfun/solana@0.28.7 approve xsolana.json --keypair ~/.config/xsolana/my-game.json --yes <code>
+npx -y @xgamesfun/solana@0.28.8 approve xsolana.json --keypair ~/.config/xsolana/my-game.json --yes <code>
 ```
 
 Each command names an exact version, so you always run the release you meant to. `xsolana help` lists them all.

package/js/economy/challenge.mjs

@@ -0,0 +1,198 @@
+// Traps the program takes as written, found by a game that went live with them (Bubble Day, 2026-11-11): a ticket
+// token bought with another token, so a cancelled round refunds the ticket token and not what was paid for it; a way
+// back from that token left open at all times; a free grant of a token that is also sold and converts back; a least
+// sale the scenario's players never reach; a ticket that needs a craft first, two wallet prompts unless both go in one
+// transaction; and a token still earned after the last draw it was good for. Each is a warning: the person decides.
+import { prizeLine, prizeToken, toSeconds, toTime } from './model.mjs';
+import { DEFAULT_PER_DAY } from './simulate.mjs';
+
+const DAY = 86_400;
+const num = x => Number(x ?? 0);
+const at = seconds =>
+  new Date(seconds * 1000)
+    .toISOString()
+    .replace('T', ' ')
+    .replace(/:\d\d\.\d+Z$/, ' UTC');
+const named = part => `“${part?.name ?? part?.key}”`;
+const words = list => (list.length < 2 ? list.join('') : `${list.slice(0, -1).join(', ')} and ${list.at(-1)}`);
+
+/** The token a token line pays in or gives, by key; null for an item, an NFT or a roll. */
+function lineToken(line, m) {
+  const prize = prizeLine(line);
+  if (prize?.gives !== 'tokens') return null;
+  return prizeToken(prize, m)?.key ?? prize.currency ?? m.currencyKey;
+}
+
+/** What a recipe takes in tokens: [{ token, amount }]. */
+const paysIn = (r, m) =>
+  (r.in ?? []).filter(l => l.takes === 'pay').map(l => ({ token: l.currency ?? m.currencyKey, amount: num(l.amount) }));
+
+/** What a recipe gives in tokens: [{ token, amount }]. */
+const givesOut = (r, m) =>
+  (r.out ?? []).map(l => ({ token: lineToken(l, m), amount: num(l.amount) })).filter(x => x.token);
+
+/** The token a lottery's tickets are paid in, or null for a free ticket or one paid with an NFT. */
+const ticketOf = (l, m) =>
+  l.ticketNft || !(num(l.price) > 0) ? null : (l.ticketCurrency ?? l.currency ?? m.currencyKey);
+
+/**
+ * Warns of the traps above. `warn(code, where, message, fix)` as check() calls it; `now` in seconds.
+ */
+export function challenge(m, warn, now) {
+  const sym = key => m.tokens.get(key)?.symbol ?? key;
+  const on = r => r.active !== false;
+  /** The recipes that sell token `t` for another token: [{ recipe, pays: [{ token, amount }], makes }]. */
+  const sellers = t =>
+    m.recipes
+      .map(r => ({
+        recipe: r,
+        pays: paysIn(r, m).filter(p => p.token !== t),
+        makes: givesOut(r, m).find(g => g.token === t)?.amount ?? 0,
+      }))
+      .filter(s => s.makes > 0 && s.pays.length);
+  /** The recipes that turn token `t` back into another token: [{ recipe, takes, gives: [{ token, amount }] }]. */
+  const backs = t =>
+    m.recipes
+      .map(r => ({
+        recipe: r,
+        takes: paysIn(r, m).find(p => p.token === t)?.amount ?? 0,
+        gives: givesOut(r, m).filter(g => g.token !== t),
+      }))
+      .filter(b => b.takes > 0 && b.gives.length);
+  const priced = list => words(list.map(p => `${p.amount} ${sym(p.token)}`));
+  const tickets = new Map();
+  for (const l of m.lotteries) {
+    const t = ticketOf(l, m);
+    if (t) tickets.set(t, [...(tickets.get(t) ?? []), l]);
+  }
+
+  // ---- W-REFUND-NOT-PAID: a cancelled round refunds what reached it, in its ticket token.
+  for (const l of m.lotteries) {
+    const t = ticketOf(l, m);
+    // Tickets in the game's currency or SOL refund what the player paid.
+    if (!t || t === m.currencyKey || m.tokens.get(t)?.source === 'sol' || !(num(l.minSold) > 0)) continue;
+    const sold = sellers(t);
+    if (!sold.length) continue;
+    const s = sold[0];
+    const ways = sold.map(x => `${named(x.recipe)} (${priced(x.pays)} for ${x.makes} ${sym(t)})`);
+    warn(
+      'W-REFUND-NOT-PAID',
+      `economy.lotteries.${l.key}.minSold`,
+      `${named(l)}’s tickets are paid in ${sym(t)}, which players buy with another token: ${words(ways)}. A round short of its ${l.minSold} tickets is cancelled, and its refund pays back ${sym(t)}, the ticket token, not the ${priced(s.pays)} a player paid for it: that stays where ${named(s.recipe)} sent it. A player who wanted their ${sym(s.pays[0].token)} back has no way to get it unless the project opens one.`,
+      `Price the tickets in ${sym(s.pays[0].token)} itself ("currency": "${s.pays[0].token}", "price": ${s.pays[0].amount / s.makes}, "rest": "burn" if they should burn), so a refund pays back what was paid; or keep a recipe that turns ${sym(t)} back into ${sym(s.pays[0].token)} switched off ("active": false) and switch it on after a cancelled round.`,
+    );
+  }
+
+  // ---- W-SWAP-BACK-OPEN: a way back from a ticket token, open at all times.
+  for (const [t, lots] of tickets) {
+    const made = sellers(t);
+    if (!made.length) continue;
+    const paidWith = new Set(made.flatMap(s => s.pays.map(p => p.token)));
+    for (const b of backs(t)) {
+      const r = b.recipe;
+      if (!on(r) || r.closes !== undefined || r.opens !== undefined) continue;
+      if (!b.gives.some(g => paidWith.has(g.token))) continue;
+      warn(
+        'W-SWAP-BACK-OPEN',
+        `economy.recipes.${r.key}`,
+        `${named(r)} turns ${sym(t)}, the ticket of ${words(lots.map(named))}, back into ${priced(b.gives)} for ${b.takes}, and it is open with no "opens" or "closes": anyone holding ${sym(t)} can undo their purchase at any time, before a draw or after losing interest, and every ${sym(t)} given free becomes ${priced(b.gives)}. A way back is for a cancelled round.`,
+        `Make it "active": false and switch it on only after a cancelled round (an edit by the project), or give it "opens" and "closes" around the time it is for.`,
+      );
+    }
+  }
+
+  // ---- W-FREE-IS-PAID: a free grant of a token that is also sold, and turns back into another token.
+  for (const g of m.grants) {
+    const prize = prizeLine(g.prize ?? g.gives);
+    const t = lineToken(prize, m);
+    // The project's own currency, or SOL, given as a reward is what a grant is for.
+    if (!t || t === m.currencyKey || m.tokens.get(t)?.source === 'sol') continue;
+    const sold = sellers(t);
+    const back = backs(t);
+    if (!sold.length || !back.length) continue;
+    const b = back.find(x => on(x.recipe)) ?? back[0];
+    const per = num(prize.amount) / b.takes;
+    const worth = b.gives.map(x => ({ token: x.token, amount: +(x.amount * per).toFixed(9) }));
+    warn(
+      'W-FREE-IS-PAID',
+      `economy.grants.${g.key}`,
+      `${named(g)} gives ${num(prize.amount)} ${sym(t)} for nothing, the token ${named(sold[0].recipe)} sells for ${priced(sold[0].pays)}, and ${named(b.recipe)} turns it back into ${priced(b.gives)}${on(b.recipe) ? '' : ' once it is switched on'}: each claim is worth ${priced(worth)}, and the grant’s limits are all that hold that back.`,
+      `Give the free one a token of its own that turns into nothing (a free-entry token a lottery also takes, or an NFT ticket), keep every way back switched off, or set the grant's "limits" to what you would pay out.`,
+    );
+  }
+
+  // ---- W-MINSOLD-VS-SCENARIO: a least sale above what the scenario's players buy in a round.
+  for (const l of m.lotteries) {
+    if (!(num(l.minSold) > 0)) continue;
+    const every = toSeconds(l.every);
+    const untilDraw = l.firstDraw ? toTime(l.firstDraw, now) - now : 0;
+    const roundDays = every ? every / DAY : untilDraw > 0 ? untilDraw / DAY : 0;
+    if (!(roundDays > 0)) continue;
+    const said = m.scenario.perDay?.[`lottery:${l.key}`];
+    const perDay = num(said ?? DEFAULT_PER_DAY);
+    let sold = perDay * roundDays;
+    const players = num(m.scenario.players);
+    const each = num(l.perWallet);
+    const capped = players > 0 && each > 0 && players * each < sold;
+    if (capped) sold = players * each;
+    sold = Math.floor(sold);
+    if (sold >= num(l.minSold)) continue;
+    const round = every ? 'a round' : `its one round, until its draw at ${at(toTime(l.firstDraw, now))}`;
+    warn(
+      'W-MINSOLD-VS-SCENARIO',
+      `economy.lotteries.${l.key}.minSold`,
+      `${named(l)} is cancelled unless ${l.minSold} tickets sell in ${round}, and the scenario sells about ${sold}${capped ? ` (${players} players, at most ${each} each)` : said === undefined ? ` (it names no tickets for it: ${DEFAULT_PER_DAY} a day assumed)` : ` (${perDay} a day)`}. A cancelled round refunds every ticket and draws nothing. Its least sale can change only before the round's first ticket: the round keeps the terms it opened with.`,
+      `Lower "minSold" to what you expect to sell (or leave it out), or set the scenario ("scenario.perDay", "scenario.players") to what you really expect and check again.`,
+    );
+  }
+
+  // ---- W-TWO-PROMPTS: a ticket the player crafts first, then buys: one wallet prompt each, unless one transaction.
+  for (const [t, lots] of tickets) {
+    const made = sellers(t).filter(s => on(s.recipe) && !(s.recipe.out ?? []).some(o => o.gives === 'roll'));
+    if (!made.length || t === m.currencyKey) continue;
+    const s = made[0];
+    for (const l of lots)
+      warn(
+        'W-TWO-PROMPTS',
+        `economy.lotteries.${l.key}`,
+        `A player buys ${named(l)}’s tickets with ${sym(t)}, which they get from ${named(s.recipe)}: a craft, then a purchase, two wallet prompts a buy (more, for each ticket crafted one at a time).`,
+        `Send both in one transaction: the play client's buyTickets(“${l.key}”, count, { listing, make: { recipe: “${s.recipe.key}”, times: ${num(l.price) / s.makes === 1 ? 'count' : `count × ${+(num(l.price) / s.makes).toFixed(9)}`}, listing } }) crafts what the tickets cost and buys them with one approval (kit 0.28.7 and later).`,
+      );
+  }
+
+  // ---- W-AFTER-THE-END: a token still given after the last draw it was good for.
+  for (const [t, lots] of tickets) {
+    if (t === m.currencyKey || m.tokens.get(t)?.source === 'sol' || lots.some(l => toSeconds(l.every))) continue;
+    if (lots.some(l => !l.firstDraw)) continue;
+    const used =
+      m.recipes.some(r => on(r) && paysIn(r, m).some(p => p.token === t)) ||
+      m.allBoxes.some(b => b.currency === t) ||
+      m.auctions.some(a => a.currency === t) ||
+      m.contests.some(c => c.currency === t) ||
+      m.payments.some(p => p.currency === t) ||
+      m.farms.some(f => f.stakes === t);
+    if (used) continue;
+    const last = Math.max(...lots.map(l => toTime(l.firstDraw, now)));
+    const lastLot = lots.find(l => toTime(l.firstDraw, now) === last);
+    const after = `${sym(t)} has no use after the last draw (${named(lastLot)}, ${at(last)})`;
+    for (const g of m.grants) {
+      if (g.active === false || lineToken(prizeLine(g.prize ?? g.gives), m) !== t) continue;
+      warn(
+        'W-AFTER-THE-END',
+        `economy.grants.${g.key}`,
+        `${named(g)} keeps giving ${sym(t)} for as long as it is switched on, and ${after}: players go on claiming a token that does nothing.`,
+        `Switch it off after the draw ("active": false, an edit by the project), make the lottery repeat ("every"), or give ${sym(t)} a use after it.`,
+      );
+    }
+    for (const r of m.recipes) {
+      if (!on(r) || !givesOut(r, m).some(x => x.token === t)) continue;
+      if (r.closes !== undefined && toTime(r.closes, now) <= last) continue;
+      warn(
+        'W-AFTER-THE-END',
+        `economy.recipes.${r.key}`,
+        `${named(r)} keeps making ${sym(t)}${r.closes === undefined ? ' with no "closes"' : ` until ${at(toTime(r.closes, now))}`}, and ${after}: a player can still pay for a token that does nothing.`,
+        `Give it "closes" at the draw (${at(last)}) or before, or switch it off after the draw.`,
+      );
+    }
+  }
+}

package/js/economy/check.mjs

@@ -62,6 +62,7 @@ import {
 } from './model.mjs';
 // plan.mjs imports check() in turn: each module only calls the other's functions, never at load time.
 import { boxArgs, boxOrderBytes, placeholderContext, recipeArgs, setupSteps, stepAloneBytes } from './plan.mjs';
+import { challenge } from './challenge.mjs';
 import { findSecrets } from './secrets.mjs';
 import { simulate } from './simulate.mjs';
 import { BUDGET, MAX_TRANSACTION_BYTES, transactionLocks, transactionSize, WALLET_ROOM } from './txsize.mjs';
@@ -5823,6 +5824,10 @@ export function check(economy, { now = Math.floor(Date.now() / 1000), project =
     }
   }
 
+  // ---- traps the program takes as written: a ticket token bought with another token, a way back left open, a free
+  // grant worth a paid one, a least sale the scenario never reaches, two wallet prompts a buy, a token after its end
+  if (!refusals.length) challenge(m, warn, now);
+
   // ---- pools that run dry at the scenario's rates (W-POOL-DRY above names a pool nothing fills): one that is filled
   // but pays out faster drains, and then skips or fails what it owes.
   if (!refusals.length) {

package/js/economy/explain.mjs

@@ -1,6 +1,7 @@
 // The economy in plain words, from the checker, the simulation, the cost and the play-time steps: what players do
 // and what it costs them, how the pools fill and drain, what runs by itself, what the authority must sign, what
 // going live costs, and what the owner must know. Deterministic. Pure.
+import { walkThrough } from './walk.mjs';
 import { check, describe } from './check.mjs';
 import { cost } from './cost.mjs';
 import {
@@ -616,6 +617,8 @@ export function explainEconomy(economy, { now = Math.floor(Date.now() / 1000) }
     '',
     `${realMoney() ? 'This economy is on mainnet: what it takes and what it pays is real money, and loot has not been independently audited.' : 'This economy is on devnet: nothing here is real money.'} Going live is signed on your own machine by the project’s key file, which is what “your wallet” means above. The command first prints everything it would send and sends nothing; it sends only when run again with the code it printed, which your agent is told to do only after your yes. No seed phrase or wallet key is ever asked for.`,
   );
+  const walk = walkThrough(m, { now });
+  if (walk.length) lines.push('', ...walk);
   return {
     ok: true,
     text: lines.join('\n').trim(),

package/js/economy/review.mjs

@@ -24,6 +24,7 @@ import {
   toSeconds,
 } from './model.mjs';
 import { TRUST_LEVELS, TRUST_WORDS } from './trust.mjs';
+import { walkThrough } from './walk.mjs';
 
 /** Severities, most serious first. */
 export const SEVERITIES = Object.freeze(['high', 'medium', 'low', 'info']);
@@ -710,6 +711,12 @@ export function review(economy, { now = Math.floor(Date.now() / 1000) } = {}) {
     ['W-LOTTERY-WEIGHT', 'R-LOTTERY-WEIGHT', 'info'],
     ['W-ZERO', 'R-ZERO', 'low'],
     ['W-ANSWER', 'R-ANSWER', 'low'],
+    ['W-REFUND-NOT-PAID', 'R-REFUND-NOT-PAID', 'medium'],
+    ['W-SWAP-BACK-OPEN', 'R-SWAP-BACK-OPEN', 'medium'],
+    ['W-FREE-IS-PAID', 'R-FREE-IS-PAID', 'medium'],
+    ['W-MINSOLD-VS-SCENARIO', 'R-MINSOLD-VS-SCENARIO', 'medium'],
+    ['W-AFTER-THE-END', 'R-AFTER-THE-END', 'low'],
+    ['W-TWO-PROMPTS', 'R-TWO-PROMPTS', 'low'],
   ])
     for (const w of warned(code)) find(id, severity, routeOf(w.where), w.message, w.fix);
 
@@ -718,7 +725,7 @@ export function review(economy, { now = Math.floor(Date.now() / 1000) } = {}) {
     ok: !findings.some(f => f.severity === 'high'),
     routes,
     findings,
-    tradeoffs: tradeoffs(routes, findings),
+    tradeoffs: [tradeoffs(routes, findings), walkThrough(m, { now }).join('\n')].filter(Boolean).join('\n\n'),
   };
 }
 

package/js/economy/simulate.mjs

@@ -52,7 +52,7 @@ import {
 } from './model.mjs';
 
 const DAY = 86_400;
-const DEFAULT_PER_DAY = 100;
+export const DEFAULT_PER_DAY = 100;
 /** How many wallets the simulation's crowd is, next to one: what a person with many wallets could take from a grant. */
 const MANY_WALLETS = 100;
 /** Bids a day on an auction the scenario doesn't name (`auction:<key>`); a grant it doesn't name is claimed by nobody. */

package/js/economy/walk.mjs

@@ -0,0 +1,313 @@
+// The walk-through at the end of `xsolana explain` and the review: each route of the spec, state by state (before it
+// opens, while it runs, cancelled or failed, won, after it ends, a change of mind), as a player, the owner and a
+// cheater see it, and what can change only before its first sale or claim. Words the program's rules back
+// (PROGRAM.md), filled with the spec's own names, prices and dates, so an agent has the trade-offs in front of it at
+// the moment it decides.
+import { boxRolls, ORACLE_FEE, prizeLine, prizeToken, prizeWords, toSeconds, toTime } from './model.mjs';
+
+const num = x => Number(x ?? 0);
+const at = seconds =>
+  new Date(seconds * 1000)
+    .toISOString()
+    .replace('T', ' ')
+    .replace(/:\d\d\.\d+Z$/, ' UTC');
+const named = part => `“${part?.name ?? part?.key}”`;
+const words = list => (list.length < 2 ? list.join('') : `${list.slice(0, -1).join(', ')} and ${list.at(-1)}`);
+const span = seconds =>
+  seconds % 86_400 === 0
+    ? `${seconds / 86_400} d`
+    : seconds % 3600 === 0
+      ? `${seconds / 3600} h`
+      : seconds % 60 === 0
+        ? `${seconds / 60} min`
+        : `${seconds} s`;
+
+/** What a draw or a roll pays the oracle, in SOL. */
+const oracleSol = Number(ORACLE_FEE) / 1e9;
+
+/** The walk-through, as lines: a title, then for each route its name and one line a state. [] for a spec with no route. */
+export function walkThrough(m, { now }) {
+  const sym = key => m.tokens.get(key)?.symbol ?? key;
+  const on = x => x.active !== false;
+  const lineToken = l => {
+    const p = prizeLine(l);
+    return p?.gives === 'tokens' ? (prizeToken(p, m)?.key ?? p.currency ?? m.currencyKey) : null;
+  };
+  const inWords = r =>
+    words(
+      (r.in ?? []).map(l =>
+        l.takes === 'pay'
+          ? `${num(l.amount)} ${sym(l.currency ?? m.currencyKey)}`
+          : l.item
+            ? `${l.count ?? 1} ${named(m.item.get(l.item) ?? { key: l.item })} (${l.takes === 'burn' ? 'burned' : l.takes === 'use' || l.takes === 'renew' ? 'used, kept' : l.takes === 'staked' ? 'staked, kept' : l.takes})`
+            : l.takes === 'show'
+              ? 'an NFT of a collection, shown and kept'
+              : l.takes === 'trade'
+                ? 'an NFT of a collection, traded in'
+                : l.takes,
+      ),
+    ) || 'nothing';
+  const outWords = r => words((r.out ?? []).map(o => prizeWords(o, m))) || 'nothing';
+  /** Recipes that make token `t` from something else, and recipes that turn it back into another token. */
+  const makers = t => m.recipes.filter(r => (r.out ?? []).some(o => lineToken(o) === t) && (r.in ?? []).length);
+  const backs = t =>
+    m.recipes.filter(
+      r =>
+        (r.in ?? []).some(l => l.takes === 'pay' && (l.currency ?? m.currencyKey) === t) &&
+        (r.out ?? []).some(o => lineToken(o) && lineToken(o) !== t),
+    );
+  const backWords = (t, how) => {
+    const b = backs(t);
+    if (!b.length) return '';
+    const open = b.filter(on);
+    return open.length
+      ? ` ${words(open.map(named))} ${how} (open now).`
+      : ` ${words(b.map(named))} ${how} once the project switches it on.`;
+  };
+  const windowWords = (x, what, none) =>
+    !on(x)
+      ? `It is switched off ("active": false): ${none} until the project switches it on.`
+      : x.opens !== undefined
+        ? `${none[0].toUpperCase()}${none.slice(1)} before ${at(toTime(x.opens, now))}.`
+        : `It ${what} from the moment it is live.`;
+  const perWalletWords = x =>
+    x.perWallet ? ` (at most ${x.perWallet} a wallet: a wallet is free, so it counts wallets, not people)` : '';
+  const routes = [];
+  const route = (title, rows) =>
+    routes.push(title, ...rows.filter(([, text]) => text).map(([s, text]) => `  - ${s}: ${text}`));
+
+  for (const l of m.lotteries) {
+    const t = l.ticketNft ? null : (l.ticketCurrency ?? l.currency ?? m.currencyKey);
+    const price = num(l.price);
+    const every = toSeconds(l.every);
+    const draw = l.firstDraw ? at(toTime(l.firstDraw, now)) : null;
+    const made = t ? makers(t) : [];
+    const closesBefore = num(toSeconds(l.closesBefore));
+    const ticket = l.ticketNft
+      ? 'an NFT that passes its rule'
+      : price > 0
+        ? `${price} ${sym(t)}`
+        : 'nothing but the player fee';
+    route(
+      `${named(l)}: a lottery, ${every ? `drawn every ${span(every)}` : `drawn once${draw ? `, at ${draw}` : ''}`}`,
+      [
+        [
+          'Before it opens',
+          `It sells from the moment it is live; its first ticket opens the round.${l.gate ? ' Only wallets its gate admits buy.' : ''}`,
+        ],
+        [
+          'While it runs',
+          `Player: pays ${ticket} a ticket${made.length ? ` (${sym(t)} comes from ${words(made.map(named))}: a craft before the purchase)` : ''}${perWalletWords(l)}, and holds an entry in the round, not a token: it can't be sold or taken back. Sales close ${closesBefore ? `${span(closesBefore)} before` : 'at'} the draw. Owner: nothing to send; an edit reaches the next round, never the one running. Cheater: many wallets buy many tickets; nobody sees or picks the result, drawn from the oracle's answer after sales close.`,
+        ],
+        [
+          'Cancelled or failed',
+          `${num(l.minSold) > 0 ? `A round short of ${l.minSold} tickets is cancelled when its draw is asked, with no draw. ` : ''}A draw the oracle hasn't answered 7 days after it was asked is cancelled at the next ask. Player: every ticket is refunded${t && price > 0 ? ` in ${sym(t)}` : ''}${l.ticketNft ? ' (the NFT back)' : ''}, the player fee not; anyone may pull a refund to its buyer.${made.length ? ` What was paid for the ${sym(t)} does not come back with it:${backWordsOr(backWords(t, 'turns it back'), ` nothing turns ${sym(t)} back.`)}` : ''} Owner: nothing to send; a round nobody asks to draw waits, with no deadline. Cheater: nothing to gain: a refund goes to the entry's own buyer.`,
+        ],
+        [
+          'Won',
+          `Once it is due anyone asks for the draw, paying the oracle ${oracleSol} SOL, and anyone pulls each winner's part to the winner: ${words((l.places ?? []).map((p, i) => `place ${i + 1} ${p.prize ? prizeWords(p.prize, m) : `${num(p.percent)}% of the pot`}`)) || 'the pot'}. An item is given while it has stock${(l.places ?? []).some(p => prizeLine(p.prize)?.gives === 'item' && m.item.get(prizeLine(p.prize).item)?.kind !== 'collectible') ? '; a normal item is an off-chain prize, yours to deliver from its receipt' : ''}.`,
+        ],
+        [
+          'After it ends',
+          every
+            ? 'The next round sells at once, on the lottery’s terms as they are then.'
+            : `It sells no more tickets.${t && price > 0 && t !== m.currencyKey ? ` ${sym(t)} left in wallets does only what something else takes it for.` : ''} The owner may close it once its round is paid out, for its rent back.`,
+        ],
+        [
+          'A change of mind',
+          `No way out: a ticket stays in the round until its draw or a cancel.${t && made.length ? backWords(t, `turns ${sym(t)} not yet spent on tickets back`) : ''}`,
+        ],
+        [
+          'Only before the first ticket',
+          `The round copies the lottery's terms (price, places, least sale, draw date) at its first ticket: an edit after it reaches only the next round${every ? '' : ', and a lottery that draws once has none'}.`,
+        ],
+      ],
+    );
+  }
+
+  for (const b of m.allBoxes) {
+    const item = b.shopOf ? m.item.get(b.shopOf) : null;
+    const source = item ?? b;
+    const rolls = boxRolls(b, m);
+    const cur = sym(b.currency ?? m.currencyKey);
+    const price = num(b.price);
+    const what = item ? `${named(item)} from the shop` : named(b);
+    route(`${what}: ${item ? 'an item for sale' : rolls ? 'a box, rolled by the oracle' : 'a box'}`, [
+      ['Before it opens', windowWords(source, 'sells', 'nothing is sold')],
+      [
+        'While it runs',
+        `Player: pays ${price > 0 ? `${price} ${cur}` : 'nothing but the player fee'}${perWalletWords(source)}; ${rolls ? `the oracle rolls what they get (paid ${oracleSol} SOL), which lands with its answer` : 'gets what it gives at once'}. Owner: nothing to send${rolls ? '; an edit of its entries or odds refunds every paid roll still waiting, at once; a price change reaches the next purchase' : ''}. Cheater: ${rolls ? "can't see or pick a roll" : 'nothing to take: it sells at its price'}${item?.supply || (!item && rolls) ? '; bots can buy limited stock first' : ''}.`,
+      ],
+      [
+        'Cancelled or failed',
+        rolls
+          ? "A roll the oracle hasn't answered is asked again once it is stale, by its player or your keys; nothing times it out. A prize out of stock is never set aside for a roll."
+          : 'A purchase that can’t give what it sells fails whole: nothing is taken.',
+      ],
+      [
+        'After it ends',
+        source.closes !== undefined
+          ? `Nothing sells after ${at(toTime(source.closes, now))}.`
+          : 'It sells until its stock runs out or the project switches it off.',
+      ],
+      ['A change of mind', 'No refund once paid.'],
+      [
+        'Only before the first sale',
+        item?.kind === 'collectible' ? 'The item’s collection can’t change once a unit is out.' : '',
+      ],
+    ]);
+  }
+
+  for (const r of m.recipes) {
+    const takes = (r.in ?? []).filter(l => l.takes === 'pay').map(l => l.currency ?? m.currencyKey);
+    const back = takes.length
+      ? m.recipes.filter(
+          x =>
+            x !== r &&
+            (x.out ?? []).some(o => takes.includes(lineToken(o))) &&
+            (x.in ?? []).some(
+              l => l.takes === 'pay' && (r.out ?? []).some(o => lineToken(o) === (l.currency ?? m.currencyKey)),
+            ),
+        )
+      : [];
+    route(`${named(r)}: a recipe`, [
+      ['Before it opens', windowWords(r, 'crafts', 'nothing is crafted')],
+      [
+        'While it runs',
+        `Player: gives ${inWords(r)}, gets ${outWords(r)}, in one transaction, all or nothing${perWalletWords(r)}. Owner: nothing to send; an edit reaches the next craft. Cheater: crafts as often as they hold what it takes.`,
+      ],
+      ['Cancelled or failed', 'A craft that can’t give every line fails whole: nothing is taken.'],
+      [
+        'After it ends',
+        r.closes !== undefined
+          ? `Nothing crafts after ${at(toTime(r.closes, now))}.`
+          : 'It crafts until the project switches it off.',
+      ],
+      [
+        'A change of mind',
+        back.length
+          ? `${words(back.map(named))} turns it back${back.some(on) ? '' : ' once the project switches it on'}.`
+          : 'No undo: what it took is spent.',
+      ],
+    ]);
+  }
+
+  for (const g of m.grants) {
+    const prize = prizeWords(g.prize ?? g.gives, m);
+    const how = g.vouchers?.length
+      ? 'a voucher from the project’s results server'
+      : g.list
+        ? 'a place on its list'
+        : 'nothing but its limits';
+    const limits = Object.entries(g.limits ?? {})
+      .map(([k, v]) => `${k} ${typeof v === 'object' ? JSON.stringify(v) : v}`)
+      .join(', ');
+    route(`${named(g)}: a grant`, [
+      [
+        'Before it opens',
+        on(g)
+          ? 'Claims work from the moment it is live.'
+          : 'It is switched off ("active": false): no claim until the project switches it on.',
+      ],
+      [
+        'While it runs',
+        `Player: claims ${prize}, proving it with ${how}; only their own wallet signs the claim. Owner: ${g.vouchers?.length ? 'the results server must be up to sign vouchers (no server, no claims), and ' : ''}its funds pay each claim's rent: keep them topped up. Cheater: ${g.vouchers?.length ? `gets whatever the server signs (${g.trust ?? 'what it checks'}): a signed result is worth what the server checks; ` : g.list ? '' : 'every wallet may claim; '}its limits are the ceiling (${limits || 'none'}).`,
+      ],
+      [
+        'Cancelled or failed',
+        'A claim whose prize can’t be given (a pool run dry, an item out of stock) is refused and keeps its round: it can be claimed later.',
+      ],
+      ['After it ends', 'It gives until its limits are reached or the project switches it off: it has no end date.'],
+    ]);
+  }
+
+  for (const a of m.auctions) {
+    route(`${named(a)}: an auction`, [
+      [
+        'Before it opens',
+        a.start !== undefined ? `No bid before ${at(toTime(a.start, now))}.` : 'Bids from the moment it opens.',
+      ],
+      [
+        'While it runs',
+        `Player: bids at least ${num(a.reserve) || 1} ${sym(a.currency ?? m.currencyKey)}; a higher bid sends theirs back in the same instruction. Owner: nothing to send; its terms are fixed when it opens. Cheater: anyone, the seller included, can bid to push the price${a.extendBy ? `; a bid in the last ${a.extendBy} moves the end` : ''}.`,
+      ],
+      [
+        'Cancelled or failed',
+        'With no bid it ends unsold and the lot goes home. The owner or authority may call off a sale whose lot has not moved: the bid back, the lot home.',
+      ],
+      ['Won', 'Anyone ends it after its end: the lot to the high bidder, the bid to the seller and the shares.'],
+      ['A change of mind', 'A bid can’t be taken back: only a higher bid returns it before the end.'],
+      ['Only before the first bid', 'Every term is fixed when it opens.'],
+    ]);
+  }
+
+  for (const c of m.contests) {
+    route(`${named(c)}: a contest`, [
+      [
+        'While it runs',
+        `Player: enters one side${c.stake ? `, a stake of ${num(c.stake)}` : ''}${c.entriesClose ? ` (entries close: ${c.entriesClose})` : ''}; a wallet backs one side, never two. Owner: ${c.decidedBy === 'authority' || !c.deciders ? 'the result is yours to decide once entries close' : 'its deciders sign the result once entries close'}. Cheater: the result is worth what its decider checks; nobody names a side before entries close.`,
+      ],
+      [
+        'Cancelled or failed',
+        `With no result by its result deadline${c.minPot ? `, or less than ${num(c.minPot)} in its sides when entries close` : ''}, or a call-off, every entry is refunded.`,
+      ],
+      ['Won', 'The winners claim their share of the pot, by what each put in.'],
+      ['A change of mind', 'An entry stays until the result or a refund.'],
+      ['Only before the first entry', 'Every term is fixed when it opens and never edited.'],
+    ]);
+  }
+
+  for (const f of m.farms) {
+    route(`${named(f)}: a farm`, [
+      [
+        'While it runs',
+        `Player: stakes ${f.stakes === 'collectibles' ? 'NFTs' : sym(f.stakes ?? m.currencyKey)} and earns while staked, by tier. Owner: ${f.rate ? 'its rate pays from its rewards' : 'its stakers share what arrives in its rewards vault: nothing arrives, nothing is paid'}. Cheater: ${f.custody === 'watch' ? 'a watched NFT sold keeps earning until someone refreshes its seat' : 'many wallets stake as one: rewards follow the stake, not the person'}.`,
+      ],
+      [
+        'After it ends',
+        f.runs
+          ? `It takes no stake after its end (${f.runs}); seats keep what they earned.`
+          : 'It has no end: it runs until it is closed.',
+      ],
+      ['A change of mind', 'A stake leaves once its tier’s lock has run (earlier only where a tier sets an exit fee).'],
+      ['Only before it opens', 'A farm is never edited once open: a change is a new farm.'],
+    ]);
+  }
+
+  for (const s of m.schedules)
+    route(`${named(s)}: a schedule`, [
+      [
+        'While it runs',
+        s.sealed
+          ? 'Its recipient sends each run when it is due; nobody can stop it.'
+          : 'Owner: you, or a key of the project’s, sends each run when it is due: nothing runs it otherwise, and a missed run lapses. Player: nothing to do. Cheater: nothing: only the project’s keys send it.',
+      ],
+    ]);
+
+  for (const p of m.payments)
+    route(`${named(p)}: a payment`, [
+      [
+        'While it runs',
+        `Player: pays ${p.any ? 'what they choose' : `${num(p.amount)} ${sym(p.currency ?? m.currencyKey)}`}. Owner: what it pays for is yours to deliver from its receipt.`,
+      ],
+      ['A change of mind', 'No refund: the program keeps no record to undo.'],
+    ]);
+
+  for (const h of m.holds)
+    route(`${named(h)}: a hold`, [
+      [
+        'While it runs',
+        'Player: hands an NFT to the project until the time they chose. Owner: until then the authority may release it, to any wallet. Cheater: whoever holds the authority’s key could release it elsewhere before its time: a hold trusts the project.',
+      ],
+      ['After it ends', 'Anyone sends it home once its time is up.'],
+    ]);
+
+  if (!routes.length) return [];
+  return [
+    'Each route, state by state (as a player, the owner and a cheater see it)',
+    'The owner’s pause stops every purchase, ticket, entry, stake and bid coming in; nothing owed waits on it: claims, refunds, unstakes, draws and payouts go on.',
+    ...routes,
+  ];
+}
+
+const backWordsOr = (text, otherwise) => text || otherwise;

package/js/mcp/server.mjs

@@ -15,9 +15,14 @@ import { withCluster } from './with-cluster.mjs';
 /** Where loot runs, for every agent that connects. */
 const WHERE = `loot ${VERSION} runs on devnet (program ${CLUSTERS.devnet.program}) and on mainnet (program ${CLUSTERS.mainnet.program}). An economy is on devnet, where nothing is real money, unless its file says "network": "mainnet", where everything is. Build and try an economy on devnet first. loot has not been independently audited.`;
 
+/** How to meet a request: the simplest version first, its trade said, before building what was asked. */
+const CHALLENGE =
+  'Challenge before you build. For every request, name the simplest version that delivers most of it. Say what it gives up and what the asked-for version costs: wallet prompts, moving parts, failure states, who must act later. Recommend one. Build the asked-for version only after the person has seen that trade and still wants it. Challenge economy, flow and irreversible choices; don’t challenge taste. Composing parts is still how you find the versions; xsolana_explain ends with each route’s states as a player, the owner and a cheater see them.';
+
 export const INSTRUCTIONS = [
   'loot is one shared Solana program for game and community economies (shops, loot boxes, lotteries, auctions, staking farms, crafting, contests, schedules, perks for holders of any NFT, capped rewards). An economy is a JSON spec, not a new smart contract: never write Anchor or Rust for what loot covers.',
   'Start with xsolana_guide, then xsolana_examples with the person’s own words; write the spec; xsolana_check after every change; xsolana_simulate and xsolana_explain before telling them what it does; xsolana_review before going live (fix its high findings, say honestly what each voucher server checks, and tell the person what a cheater gets); xsolana_save; xsolana_publish when they say to put it live. Going live is signed by a key file on their own machine (xsolana keygen makes one; never ask for, read or print a key) with xsolana approve --keypair, which prints everything it would send and sends nothing until it is run again with the code it printed: do that only after they have read the printout and said yes. That key owns the project for good: a change to an economy that is already live is signed by the key that owns it, never by a new one. A browser wallet’s signing page (approve --browser) only if they ask for one, and they run it themselves.',
+  CHALLENGE,
   WHERE,
 ].join(' ');
 
@@ -27,6 +32,7 @@ export const INSTRUCTIONS = [
  */
 export const REMOTE_INSTRUCTIONS = [
   INSTRUCTIONS.split(' Start with')[0],
+  CHALLENGE,
   'Start with xsolana_guide, then xsolana_examples with the person’s own words; write the spec and pass it whole as "spec" to every tool (this hosted server reads no files); xsolana_check after every change; xsolana_simulate and xsolana_explain before telling them what it does; xsolana_review before going live (fix its high findings, say honestly what each voucher server checks, and tell the person what a cheater gets).',
   `To go live, the spec goes in a file named xsolana.json on the person’s own computer and is signed there by a key file. In that folder: npx -y @xgamesfun/solana@${PACKAGE_VERSION} keygen ~/.config/xsolana/<name>.json makes the key file (it prints the address, never the key; the person sends that address devnet SOL), then npx -y @xgamesfun/solana@${PACKAGE_VERSION} approve xsolana.json --keypair <that file> prints everything that would be sent and sends nothing. When the person has read that and said yes, the same command with --yes <the code it printed> sends it. Run them yourself if you have a terminal there; otherwise hand them to the person. Never ask for, read or print a key. Say once what the key file is: the project’s owner for good (whoever can read it controls the project; they back it up themselves; nothing restores a lost one) and, unless the spec names a treasury, where what the economy earns lands. A change to an economy that is already live is signed by the key that owns it: never make a new key for it. A browser wallet’s signing page (the same approve command with --browser in place of --keypair), which the person runs themselves, only if they ask for one or a browser wallet owns the project. (xsolana_save and xsolana_publish, which tool texts may name, run only in the local server.)`,
   WHERE,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xgamesfun/solana",
-  "version": "0.28.7",
+  "version": "0.28.8",
   "mcpName": "io.github.XGamesFun/solana-kit",
   "description": "Loot boxes, gacha, shops, lotteries, auctions, NFT staking, crafting and rewards on Solana without writing a smart contract: one shared program, its JS client, a CLI, and an MCP server and skill so Claude Code, Codex or any AI agent can design, check, simulate and launch an economy.",
   "license": "Apache-2.0",

package/skills/xsolana-economy/SKILL.md

@@ -11,9 +11,9 @@ signed by a key file on the owner's own machine, once they have read what will b
 **devnet**, where nothing is real money, and on **mainnet**, where everything is: an economy is on devnet unless its
 file says `"network": "mainnet"`.
 
-The tools are the `xsolana_*` MCP tools. Without MCP, the same from a terminal: `npx -y @xgamesfun/solana@0.28.7 <guide|examples|check|simulate|cost|explain|review|publish|status> [xsolana.json]`,
-`npx -y @xgamesfun/solana@0.28.7 token <mint>` for a coin made elsewhere,
-or `npx -y @xgamesfun/solana@0.28.7 tool <name> '<json>'` for any tool (always with the exact version).
+The tools are the `xsolana_*` MCP tools. Without MCP, the same from a terminal: `npx -y @xgamesfun/solana@0.28.8 <guide|examples|check|simulate|cost|explain|review|publish|status> [xsolana.json]`,
+`npx -y @xgamesfun/solana@0.28.8 token <mint>` for a coin made elsewhere,
+or `npx -y @xgamesfun/solana@0.28.8 tool <name> '<json>'` for any tool (always with the exact version).
 
 ## Rules (always)
 
@@ -56,22 +56,24 @@ or `npx -y @xgamesfun/solana@0.28.7 tool <name> '<json>'` for any tool (always w
 7. **Take addresses from the tools, never from memory**: the program, its accounts, the IDL. Every answer names them.
 8. **Public data only in a spec**: names, prices, percents, public addresses. Leave out `id`, `index`, `shopBox`,
    and `live`: they are written when it goes live.
-9. **Compose before you say no.** Most ideas are several parts working together, not one part. Before calling
-   anything a limit, break the idea into its pieces (what players pay, what they get, what is random, what the chain
-   can't see, what is held and for how long, who is paid) and find the part for each (`references/sentence-to-spec.md`).
-   What the chain can't see (a match, a score, something done offline) is vouched for by a signer: a results server's voucher, a
-   decider's key, a list. The signer is not the end of the story: the program checks its signature and limits, never
-   what happened, so a signed result is worth what that server checks (it decides the result, replays it, or only
-   bounds what the page reports: rule 12). Build the combination and say which part does which piece. When the tools' words and the
-   checker disagree (a field the schema takes that a sentence somewhere calls impossible), the checker and
-   `xsolana_guide`'s parts decide: try it in a spec and run `xsolana_check`.
-   A piece is a limit only when no part or combination does it. Then:
-   - say in one line what is missing and why;
-   - offer the nearest versions (`xsolana_examples` with the words of that piece returns them), best first, each with
-     what it gives up and its "in all" cost; recommend one, and build it;
-   - if they push back, offer the next version or a change that brings back what they miss (a price, a bundle, a
-     second step). Don't withdraw a draft that checks, and don't send them elsewhere while a version on loot is on the
-     table.
+9. **Challenge before you build.** For every request, name the simplest version that delivers most of it. Say what
+   it gives up and what the asked-for version costs: wallet prompts, moving parts, failure states, who must act
+   later. Recommend one. Build the asked-for version only after the person has seen that trade and still wants it.
+   Challenge economy, flow and irreversible choices; don't challenge taste. `xsolana_explain` ends with each route's
+   states (before it opens, while it runs, cancelled or failed, won, after it ends, a change of mind) as a player, the
+   owner and a cheater see them, and what can change only before a first sale or claim; the checker's warnings name
+   the traps a game already fell into. Read both before you answer.
+   Composing parts is still how you find the versions. Most ideas are several parts working together: break the idea
+   into its pieces (what players pay, what they get, what is random, what the chain can't see, what is held and for
+   how long, who is paid) and find the part for each (`references/sentence-to-spec.md`). What the chain can't see (a
+   match, a score, something done offline) is vouched for by a signer: a results server's voucher, a decider's key, a
+   list. The program checks the signer's signature and limits, never what happened, so a signed result is worth what
+   that server checks (it decides the result, replays it, or only bounds what the page reports: rule 12). When the
+   tools' words and the checker disagree (a field the schema takes that a sentence somewhere calls impossible), the
+   checker and `xsolana_guide`'s parts decide: try it in a spec and run `xsolana_check`. A piece is a limit only when
+   no part or combination does it: say in one line what is missing and why, and offer the nearest versions
+   (`xsolana_examples` with the words of that piece returns them), best first, each with what it gives up and its "in
+   all" cost.
 
 10. **Design for many wallets and bots.** Wallets are free and bots play well: bound every reward with totals
     (`perDay`, `total`), gate open rewards on holding something or count people by vouchers (`perPerson`, with the
@@ -141,7 +143,7 @@ or `npx -y @xgamesfun/solana@0.28.7 tool <name> '<json>'` for any tool (always w
 9. **When they say "put it live"**: `xsolana_publish` lists every step and its cost and gives the commands, which you
    run in the project folder exactly as given (they name the exact version; never drop it):
    - **A new economy gets a key file**, unless the project has one:
-     `npx -y @xgamesfun/solana@0.28.7 keygen ~/.config/xsolana/<name>.json`. Give the person the address it prints. A
+     `npx -y @xgamesfun/solana@0.28.8 keygen ~/.config/xsolana/<name>.json`. Give the person the address it prints. A
      Solana key file they already have and name themselves (`~/.config/solana/id.json`) works the same; never go
      looking for one.
    - **Say what the key file is** before anything is sent: the project's owner, and, unless the spec says otherwise,
@@ -156,7 +158,7 @@ or `npx -y @xgamesfun/solana@0.28.7 tool <name> '<json>'` for any tool (always w
      devnet SOL for an economy on devnet, real SOL for one on mainnet), any seed in a coin that already exists, and every NFT a stash, a raffle or an auction names. A
      collection they already have needs the key's address as its update authority. If they would rather not move
      those, offer the browser wallet.
-   - **Show it**: `npx -y @xgamesfun/solana@0.28.7 approve xsolana.json --keypair <key file>` prints every step with
+   - **Show it**: `npx -y @xgamesfun/solana@0.28.8 approve xsolana.json --keypair <key file>` prints every step with
      what it pays and trusts, the warnings, the notice and a code, and sends nothing. Give the person that printout as
      it is, not a summary of it, and ask.
    - **On their yes**, the same command with `--yes <code>`. What lands is written back into `xsolana.json`. If it

package/types/economy/challenge.d.mts

@@ -0,0 +1,4 @@
+/**
+ * Warns of the traps above. `warn(code, where, message, fix)` as check() calls it; `now` in seconds.
+ */
+export declare function challenge(m: any, warn: any, now: any): void;

package/types/economy/simulate.d.mts

@@ -1,3 +1,4 @@
+export declare const DEFAULT_PER_DAY = 100;
 export declare const round: (x: any, digits?: number) => any;
 /** A budget of sales to walk, shared by every salePrices call of one simulation. */
 export declare const walkBudget: () => {

package/types/economy/walk.d.mts

@@ -0,0 +1,4 @@
+/** The walk-through, as lines: a title, then for each route its name and one line a state. [] for a spec with no route. */
+export declare function walkThrough(m: any, { now }: {
+    now: any;
+}): any[];

package/types/mcp/server.d.mts

@@ -299,10 +299,10 @@ export declare function runTool(name: any, input?: {}, ctx?: {}): Promise<{
     })[];
     text: string;
 } | {
+    token?: undefined;
     mint?: undefined;
     ok: boolean;
     text: string;
-    token?: undefined;
 } | {
     mint?: undefined;
     ok: boolean;

package/types/mcp/tools.d.mts

@@ -745,10 +745,10 @@ export declare const tools: ({
         additionalProperties: boolean;
     };
     handler(input: any, ctx: any): Promise<{
-        token?: undefined;
         mint?: undefined;
         ok: boolean;
         text: string;
+        token?: undefined;
     } | {
         mint?: undefined;
         ok: boolean;