@gangfun/cli 0.11.0 → 0.13.0

package/src/buyback.js

@@ -0,0 +1,183 @@
+import { createPublicClient, http, parseAbi, encodeFunctionData, formatUnits, hexToString, isAddress, zeroAddress } from 'viem'
+import { padNets, NOT_ON_MAINNET } from './gangpad.js'
+import { walletFor } from './fair.js'
+import { parseNum, revertOf as revertIn, step } from './steps.js'
+
+/**
+ * `gang buyback …` and `gang create … --buyback <pct>` — GangBuybackSplitter (dev 税按比例回购销毁): a V3 token's tax
+ * recipient that splits each payment between a buy-back in the token's PancakeSwap pool, sent to 0xdead, and the dev.
+ * GangBuybackSplitterFactory clones one per token for the dev (`create(bps, salt)`, at `predict(dev, salt)`) and has
+ * GangHandlerAdmin list it, so the dev names it as the recipient at create (launch.js does the three steps: clone →
+ * create → bind). A dev who doesn't
+ * want it leaves --buyback out: the tax goes to their own address as before.
+ * The ratio: a raise applies at once, a cut 3 days after it is asked for (then anyone applies it within 7 days, or it
+ * lapses). The keeper buys back in chunks (≤ 0.5% of the pool's quote side, never > 2% above the 10-minute average).
+ * Env: GANG_SPLITTER_FACTORY / GANG_TESTNET_SPLITTER_FACTORY override the built-in factory addresses.
+ */
+
+// BSC 56, 2026-10-28 (docs/MAINNET-BUYBACK-SPLITTER-2026-10-28.md); lists clones once the Safe ran its batch
+export const MAINNET_SPLITTER_FACTORY = '0x6bcd79206da85Aa0643Db2164Ab887b468618546'
+export const TESTNET_SPLITTER_FACTORY = '0x0Ff5C8801BdeaDac374fC14fEd6e7B31977c9DA1'
+export const BUYBACK_TYPE = 'buyback-burn-v1'
+
+export const FACTORY_ABI = parseAbi([
+  'function create(uint16 buybackBps, bytes32 salt) returns (address splitter)',
+  'function predict(address dev, bytes32 salt) view returns (address)',
+  'function pad() view returns (address)',
+  'error NotAgent()',
+  'error NotFactory()',
+  'error BadBps()',
+])
+
+export const SPLITTER_ABI = parseAbi([
+  'function moduleType() view returns (bytes32)',
+  'function dev() view returns (address)',
+  'function token() view returns (address)',
+  'function quote() view returns (address)',
+  'function buybackBps() view returns (uint16)',
+  'function pendingCut() view returns (bool live, uint16 bps, uint64 at)',
+  'function buybackLeft() view returns (uint256)',
+  'function unsplit() view returns (uint256)',
+  'function devOwed() view returns (uint256)',
+  'function previewBurn() view returns (bool ready, uint256 quoteIn, uint256 tokensOut)',
+  'function bind(address token)',
+  'function setBuybackBps(uint16 newBps)',
+  'function applyBuybackBps()',
+  'function releaseDev() returns (uint256)',
+  'error NotDev()',
+  'error BadBps()',
+  'error AlreadyBound()',
+  'error NotCurve()',
+  'error NotCreator()',
+  'error NotRecipient()',
+  'error NoProposal()',
+  'error NotDue()',
+  'error CutLapsed()',
+  'error NothingOwed()',
+])
+
+const PAD_ABI = parseAbi([
+  'function taxConfigOf(address token) view returns (uint16 buyTaxBps, uint16 sellTaxBps, uint16 dividendBps, address recipient)',
+])
+
+const HINTS = {
+  NotAgent: 'only an Agent can create a V3 token, so only an Agent gets a buy-back splitter',
+  NotFactory: 'this factory is not allowed on the platform\'s GangHandlerAdmin (any more): it cannot list a splitter',
+  NotDev: 'only the dev this splitter was made for can change its ratio',
+  NotCreator: 'the token was not created by this splitter\'s dev',
+  NotRecipient: 'the token does not pay its tax to this splitter',
+  AlreadyBound: 'the splitter is bound to a token already',
+  NotDue: 'the 3-day notice of this cut has not run yet',
+  CutLapsed: 'the cut was not applied within 7 days after its notice and has lapsed: ask for it again',
+  NoProposal: 'no cut asked for',
+  NothingOwed: 'nothing is owed to the dev',
+}
+const revertOf = (e) => revertIn(e, [SPLITTER_ABI, FACTORY_ABI], HINTS)
+
+export function splitterFactoryAddress(testnet) {
+  return (testnet ? process.env.GANG_TESTNET_SPLITTER_FACTORY || TESTNET_SPLITTER_FACTORY
+    : process.env.GANG_SPLITTER_FACTORY || MAINNET_SPLITTER_FACTORY) || null
+}
+
+export const notDeployed = (testnet) =>
+  `GangBuybackSplitterFactory is not deployed on ${testnet ? 'the BSC testnet' : 'BSC mainnet'} in this CLI version: set ${testnet ? 'GANG_TESTNET_SPLITTER_FACTORY' : 'GANG_SPLITTER_FACTORY'} to its address`
+
+/** --buyback <pct> (0–100, the share of the recipient's part bought back) in bps. */
+export const buybackBpsOf = (fail, raw) => Math.round(parseNum(fail, 'buyback', raw, 0, 100) * 100)
+
+const pct = (bps) => Number(bps) / 100
+const iso = (s) => new Date(Number(s) * 1000).toISOString()
+
+/** The splitter's state when `addr` is a GangBuybackSplitter; null when it is not (an EOA, a partner, another module). */
+export async function splitterOf(read, addr) {
+  if (!addr || addr === zeroAddress) return null
+  let type
+  try { type = await read(addr, SPLITTER_ABI, 'moduleType') } catch { return null }
+  if (hexToString(type, { size: 32 }) !== BUYBACK_TYPE) return null
+  const [dev, token, bps, cut, left, unsplit, owed, burn] = await Promise.all(
+    ['dev', 'token', 'buybackBps', 'pendingCut', 'buybackLeft', 'unsplit', 'devOwed', 'previewBurn'].map((f) => read(addr, SPLITTER_ABI, f)))
+  // the pad takes 18-decimal quotes only
+  const q = (x) => formatUnits(x, 18)
+  return {
+    splitter: addr, moduleType: BUYBACK_TYPE, dev, token: token === zeroAddress ? null : token, buybackPct: pct(bps), buybackBps: Number(bps),
+    pendingCut: cut[0] ? { toPct: pct(cut[1]), appliesFrom: iso(cut[2]), lapsesAfter: iso(Number(cut[2]) + 7 * 86400) } : null,
+    buybackLeft: q(left), unsplit: q(unsplit), devOwed: q(owed),
+    nextChunk: burn[0] ? { quoteIn: q(burn[1]), tokensBurned: formatUnits(burn[2], 18) } : null,
+    note: `${pct(bps)}% of each tax payment to this recipient is bought back in the pool and burned (0xdead), the rest goes to the dev; a raise applies at once, a cut only 3 days after it is asked for`,
+  }
+}
+
+function buybackCtx(testnet) {
+  const net = padNets('v3')[testnet ? 'testnet' : 'mainnet']
+  if (!net.pad) throw new Error(NOT_ON_MAINNET)
+  const client = createPublicClient({ chain: net.chain, transport: http(net.rpc) })
+  return { ...net, client, read: (address, abi, functionName, args = []) => client.readContract({ address, abi, functionName, args }) }
+}
+
+/** Dry-run a call; { failed } with the revert when it would not pass. */
+export async function simulateCall(client, from, address, abi, functionName, args = []) {
+  try {
+    const { result } = await client.simulateContract({ account: from, address, abi, functionName, args })
+    return { result }
+  } catch (e) {
+    const r = revertOf(e)
+    return { failed: r ? { reverted: true, ...r } : { reverted: false, error: e.shortMessage || e.message.split('\n')[0] } }
+  }
+}
+
+const SUBS = ['status', 'set', 'apply', 'bind', 'release']
+const USAGE = 'usage: gang buyback <status|set|apply|bind|release> --token <addr> [--pct <0-100>] [--testnet] — see gang help'
+
+/** `gang buyback <sub>`: the splitter of a V3 token (its tax recipient), found from --token. */
+export async function runBuyback(sub, { opt, flag, out, fail, summarize }) {
+  if (!SUBS.includes(sub)) return fail(USAGE, { got: sub ?? null })
+  const testnet = flag('testnet')
+  const rawOnly = flag('calldata')
+  let ctx
+  try { ctx = buybackCtx(testnet) } catch (e) { return fail(e.message) }
+  const token = opt('token')
+  if (!isAddress(token ?? '')) fail('--token must be a V3 token address (0x…)', { got: token ?? null })
+  let recipient
+  try { recipient = (await ctx.read(ctx.pad, PAD_ABI, 'taxConfigOf', [token]))[3] } catch {
+    return fail('not a V3 token on this pad', { token, chainId: Number(ctx.chainId) })
+  }
+  const s = await splitterOf(ctx.read, recipient)
+  if (!s) return fail('this token\'s tax recipient is not a buy-back splitter', { token, recipient: recipient === zeroAddress ? null : recipient })
+  const chainId = Number(ctx.chainId)
+  const me = () => walletFor(ctx, opt('from'))
+  const send = async (functionName, args, extra) => {
+    const sim = await simulateCall(ctx.client, me(), s.splitter, SPLITTER_ABI, functionName, args)
+    if (sim.failed) return out({ success: false, step: functionName, ...sim.failed })
+    const data = encodeFunctionData({ abi: SPLITTER_ABI, functionName, args })
+    return out(step(ctx, { from: me(), to: s.splitter, data }, { chainId, token, splitter: s.splitter, ...extra }, rawOnly, summarize))
+  }
+
+  if (sub === 'status') return out({ success: true, chainId, ...s, ...(s.token === null && { bound: false }) })
+
+  if (sub === 'bind') {
+    if (s.token) return fail('already bound', { boundTo: s.token })
+    return send('bind', [token], { step: 'bind', note: 'anyone may bind; the token must be the dev\'s and pay its tax to this splitter' })
+  }
+
+  if (sub === 'set') {
+    if (me().toLowerCase() !== s.dev.toLowerCase()) return fail(HINTS.NotDev, { wallet: me(), dev: s.dev })
+    if (!flag('pct')) fail('--pct <0-100> required: the new buy-back share')
+    const bps = Math.round(parseNum(fail, 'pct', opt('pct'), 0, 100) * 100)
+    return send('setBuybackBps', [bps], bps >= s.buybackBps
+      ? { step: 'set-buyback', fromPct: s.buybackPct, toPct: bps / 100, note: `applies at once${s.pendingCut ? ' and cancels the pending cut' : ''}` }
+      : {
+          step: 'ask-cut', fromPct: s.buybackPct, toPct: bps / 100, appliesFromAbout: new Date(Date.now() + 3 * 86400_000).toISOString(),
+          note: `a cut waits 3 days (holders see it coming), then anyone runs gang buyback apply --token ${token}${testnet ? ' --testnet' : ''} within 7 days or it lapses${s.pendingCut ? '; this replaces the cut already asked for' : ''}`,
+        })
+  }
+
+  if (sub === 'apply') {
+    if (!s.pendingCut) return fail(HINTS.NoProposal, { buybackPct: s.buybackPct })
+    if (Date.parse(s.pendingCut.appliesFrom) > Date.now()) return fail(HINTS.NotDue, { appliesFrom: s.pendingCut.appliesFrom })
+    return send('applyBuybackBps', [], { step: 'apply-cut', fromPct: s.buybackPct, toPct: s.pendingCut.toPct, note: 'anyone may apply a cut once its notice ran' })
+  }
+
+  // release
+  if (!(Number(s.devOwed) > 0)) return fail(HINTS.NothingOwed)
+  return send('releaseDev', [], { step: 'release', amount: s.devOwed, note: 'anyone may; the dev gets what a failed push left owed' })
+}

package/src/chain.js

@@ -32,8 +32,8 @@ const PADS = [
 ]
 
 const GANG_POINTER = {
-  v3: (t) => `a GangLaunchpad V3 (bonding-curve) token: use gang v3 (gang v3 info|buy|sell|status --token ${t})`,
-  fair: (t) => `a GangLaunchpad 打新 (fair-mint) token: use gang fair (gang fair info|status --token ${t}; before launch mint / withdraw, after it buy / sell)`,
+  v3: (t) => `a GangLaunchpad V3 (bonding-curve) token: gang info|buy|sell|status --token ${t} trade it (re-run if this was an RPC hiccup)`,
+  fair: (t) => `a GangLaunchpad 打新 (fair-mint) token: gang info|status --token ${t}; before launch gang mint / withdraw, after it gang buy / sell (re-run if this was an RPC hiccup)`,
 }
 
 /** Resolve which pad hosts `token` by probing curves(token).creator != 0; a GangLaunchpad token is pointed at its command. */
@@ -261,13 +261,36 @@ export const calldata = {
   wrap: () => encodeFunctionData({ abi: WBNB_ABI, functionName: 'deposit' }),
 }
 
-export async function decodeTx(hash) {
+/**
+ * Events of the logs that decode with one of `abis`, each with the emitting contract: GangLaunchpad logs, which `gang tx`
+ * reads beside the V2 / Soft / U / S pads'. Integers stay as on chain (strings), marked `units: 'raw'`: amounts are in wei
+ * (18 decimals), bps / shares / counts as they are; the V2 / Soft events are formatted (no `units`).
+ */
+export function decodeLogs(logs, abis) {
+  const events = []
+  for (const log of logs) {
+    for (const abi of abis) {
+      try {
+        const ev = decodeEventLog({ abi, data: log.data, topics: log.topics })
+        events.push({ event: ev.eventName, contract: log.address, units: 'raw', ...Object.fromEntries(Object.entries(ev.args).map(([k, v]) => [k, typeof v === 'bigint' ? v.toString() : v])) })
+        break
+      } catch { /* other contract / event */ }
+    }
+  }
+  return events
+}
+
+/** `extraAbis`: decoders for logs not from the V2 / Soft / U / S pads (see decodeLogs). */
+export async function decodeTx(hash, extraAbis = []) {
   const r = await client.waitForTransactionReceipt({ hash, timeout: 120_000 })
   const events = []
   const known = new Map(PADS.map((p) => [p.address.toLowerCase(), p]))
   for (const log of r.logs) {
     const pad = known.get(log.address.toLowerCase())
-    if (!pad) continue
+    if (!pad) {
+      events.push(...decodeLogs([log], extraAbis))
+      continue
+    }
     try {
       const ev = decodeEventLog({ abi: pad.abi, data: log.data, topics: log.topics })
       const a = Object.fromEntries(Object.entries(ev.args).map(([k, v]) => {

package/src/fair.js

@@ -5,6 +5,7 @@ import { API } from './discover.js'
 import { UA } from './version.js'
 import { MERGED_ERRORS_ABI, MERGED_HINTS, NOT_ON_MAINNET, notThisKind, padNets } from './gangpad.js'
 import { poolPayBnb, poolTrade } from './pool.js'
+import { bondAddress, bondGuard } from './bond.js'
 
 /**
  * `gang fair …` — 打新 (fair mint): one fixed price per share both ways (mint buys at it, withdraw sells back at it);
@@ -81,7 +82,7 @@ const STATUS = ['none', 'minting', 'launched']
 const HINTS = {
   BadConfig: 'a rule is out of bounds: see reason',
   NotAgent: 'this wallet holds no Agent ID; fair mint is Agent-only',
-  NotMinting: 'the sale already launched: trade the token in the pool with gang fair buy / gang fair sell',
+  NotMinting: 'the sale already launched: trade the token in the pool with gang buy / gang sell',
   WalletCapReached: 'this wallet already holds the per-wallet cap of shares',
   Slippage: 'fewer shares are left than --min-shares (someone filled first)',
   BadAmount: '--shares is more than this wallet holds in the sale',
@@ -104,6 +105,9 @@ const HINTS = {
   VaultFloorTooHigh: 'the platform\'s dividend vault requires a larger holding than fair-mint rewards allow, so no sale can be created right now; ask gang to fix the vault setting',
 }
 
+/** What `gang tx` decodes a 打新 trade's logs with (the pad, the holder-reward vault). */
+export const FAIR_EVENT_ABIS = [PAD_ABI, VAULT_ABI]
+
 export function fairCtx(testnet) {
   const net = FAIR_NETS[testnet ? 'testnet' : 'mainnet']
   if (!net.pad) throw new Error(NOT_ON_MAINNET)
@@ -244,7 +248,7 @@ export async function runFair(sub, { opt, flag, out, fail, summarize, resolveLog
     if (!['minting', 'launched', 'all'].includes(status)) fail('--status must be minting, launched or all')
     const r = await fetch(`${API}/fair/sales?status=${status}&limit=30`, { headers: { 'user-agent': UA }, signal: AbortSignal.timeout(10_000) })
       .then((x) => (x.ok ? x.json() : { error: x.status })).catch((e) => ({ error: e.message }))
-    if (r.error) return out({ success: false, error: `gang.fun fair list unavailable (${r.error})`, hint: `use gang fair info --token <addr>${testnet ? ' --testnet' : ''} for one sale` })
+    if (r.error) return out({ success: false, error: `gang.fun fair list unavailable (${r.error})`, hint: `use gang info --token <addr>${testnet ? ' --testnet' : ''} for one sale` })
     return out({ success: true, status, items: (r.items || []).map((x) => ({
       token: x.address, symbol: x.symbol, status: x.status, sold: x.sold, participants: x.participants,
       sharePrice: x.sharePrice && formatUnits(BigInt(x.sharePrice), 18), quote: x.quoteSymbol, chainId: x.chainId,
@@ -336,7 +340,7 @@ export async function runFair(sub, { opt, flag, out, fail, summarize, resolveLog
     const sale = await saleOf(ctx, token)
     if (!sale) return notFair(token)
     if (sale.status !== 'minting') {
-      return fail(`sale is ${sale.status}, not minting`, { hint: `it launched: buy in the pool with gang fair buy --token ${token} --amount <quote>${testnet ? ' --testnet' : ''}` })
+      return fail(`sale is ${sale.status}, not minting`, { hint: `it launched: buy in the pool with gang buy --token ${token} --amount <quote>${testnet ? ' --testnet' : ''}` })
     }
     const me = walletFor(ctx, opt('from'))
     if (sale.gate !== zeroAddress && (await ctx.read(sale.gate, ERC721_ABI, 'balanceOf', [me])) === 0n) {
@@ -382,7 +386,7 @@ export async function runFair(sub, { opt, flag, out, fail, summarize, resolveLog
     if (sale.status !== 'minting') {
       return fail(`sale is ${sale.status}: withdraw only while minting`, sale.launched ? {
         pair: sale.pair,
-        hint: `it launched: sell in the pool with \`gang fair sell --token ${token} (--amount <tokens> | --all)${testnet ? ' --testnet' : ''}${opt('from') ? ` --from ${opt('from')}` : ''} [--slippage 1] [--to-bnb]\``
+        hint: `it launched: sell in the pool with \`gang sell --token ${token} (--amount <tokens> | --all)${testnet ? ' --testnet' : ''}${opt('from') ? ` --from ${opt('from')}` : ''} [--slippage 1] [--to-bnb]\``
           + ' (through GangRouter; minOut from the tax handler\'s previewSellNextBlock)',
       } : {})
     }
@@ -390,6 +394,11 @@ export async function runFair(sub, { opt, flag, out, fail, summarize, resolveLog
     const held = await ctx.read(ctx.pad, PAD_ABI, 'positions', [token, me])
     if (!held) return fail('this wallet has no shares in this sale')
     const shares = flag('all') ? Number(held) : parseIntIn(fail, 'shares', opt('shares'), 1, Number(held))
+    // a bond posted during the sale already binds: selling shares back takes their tokens out of the creator's wallet
+    const guard = bondAddress(testnet) && await bondGuard(ctx, {
+      token, me, amount: BigInt(shares) * (await ctx.read(ctx.pad, PAD_ABI, 'TOKENS_PER_SHARE')), testnet, breakBond: flag('break-bond'), settleFirst: flag('settle-first'),
+    }, rawOnly, summarize)
+    if (guard?.refuse) return out({ success: false, step: 'withdraw', wallet: me, ...guard.refuse })
     const [payout, fee] = await ctx.read(ctx.pad, PAD_ABI, 'previewWithdraw', [token, me, BigInt(shares)])
     // the price is fixed, so only the exit fee can move the payout: a mint landing first can restart the 7-day clock
     // and bring a 1–2% fee back. 0.1% below the preview refuses that and nothing else.
@@ -401,7 +410,7 @@ export async function runFair(sub, { opt, flag, out, fail, summarize, resolveLog
       step: 'withdraw', chainId: Number(ctx.chainId), token, shares,
       receive: await units(ctx, sale.quote, payout), minReceive: await units(ctx, sale.quote, minPayout),
       exitFee: await units(ctx, sale.quote, fee), quote: sale.quoteSymbol,
-      exitFeePct: sale.exitFeeNowPct,
+      exitFeePct: sale.exitFeeNowPct, ...guard?.info,
       note: sale.stale
         ? `no progress for 7 days: no exit fee, the full mint price back; the ${sale.mintFeePct}% paid at mint is not returned`
         : `mint price − ${sale.exitFeeNowPct}% exit fee (none after 7 days without 10 new shares); the ${sale.mintFeePct}% paid at mint is not returned`,
@@ -414,8 +423,8 @@ export async function runFair(sub, { opt, flag, out, fail, summarize, resolveLog
     const sale = await saleOf(ctx, token)
     if (!sale) return notFair(token)
     if (!sale.launched || !sale.pair) {
-      return fail(`sale is ${sale.status}: gang fair ${sub} trades the token in its pool after launch`, {
-        hint: sub === 'buy' ? 'while minting, buy shares with gang fair mint --shares <n>' : 'while minting, sell shares back with gang fair withdraw (--shares <n> | --all)',
+      return fail(`sale is ${sale.status}: gang ${sub} trades the token in its pool after launch`, {
+        hint: sub === 'buy' ? `while minting, buy shares with gang mint --token ${token} --shares <n>` : `while minting, sell shares back with gang withdraw --token ${token} (--shares <n> | --all)`,
       })
     }
     const slippage = parseNum(fail, 'slippage', opt('slippage', '1'), 0, 50)
@@ -459,6 +468,7 @@ export async function runFair(sub, { opt, flag, out, fail, summarize, resolveLog
       amount: sub === 'sell' && flag('all') ? null : parseAmount(fail, 'amount', opt('amount')), all: sub === 'sell' && flag('all'),
       swapBackGas: Number(sellTaxBps) > 0, payBnb: sub === 'buy' && poolPayBnb(ctx, sale.quote, flag), toBnb: flag('to-bnb'),
       base: { kind: 'fair', pair: sale.pair, ...notes.pool, ...(outWarning && { ...outWarning, confirmedOut: true }) },
+      ...(sub === 'sell' && { bond: { testnet, breakBond: flag('break-bond'), settleFirst: flag('settle-first') } }),
     }, { rawOnly, summarize, revertOf }))
   }
 
@@ -473,7 +483,7 @@ export async function runFair(sub, { opt, flag, out, fail, summarize, resolveLog
     if (r.claimableRaw === 0n) {
       return fail('nothing to claim yet', {
         ...(unsold && { creditedUnsoldEstimate: r.creditedUnsoldEstimate, note: r.note }),
-        hint: `gang fair status --token ${token}${testnet ? ' --testnet' : ''}`,
+        hint: `gang status --token ${token}${testnet ? ' --testnet' : ''}`,
       })
     }
     const data = encodeFunctionData({ abi: VAULT_ABI, functionName: 'claim', args: [token] })

package/src/gangpad.js

@@ -69,7 +69,7 @@ export const MERGED_ERRORS_ABI = parseAbi([
 ])
 export const MERGED_HINTS = {
   Untaxed: 'this token is untaxed (0% / 0%): it never gets a pool tax, a tax route or dividends; nothing to release or claim on it',
-  NotReclaimable: 'only a 打新 (fair-mint) token can be sold back to the pad; a V3 token is sold on its curve (gang v3 sell)',
+  NotReclaimable: 'only a 打新 (fair-mint) token can be sold back to the pad; a V3 token is sold on its curve (gang sell)',
   NotLocked: 'the sale already launched (the token is unlocked): sell-back is over, trade the token on PancakeSwap',
   WrongKind: 'this token is the other kind on the merged pad: V3 tokens use `gang v3 …`, 打新 tokens use `gang fair …`',
   BadKind: 'the tax handler refused the token kind (a pad / handler wiring problem): report it to gang',
@@ -99,10 +99,10 @@ export async function notThisKind(ctx, token, want, net = '') {
   const kind = await kindOf(ctx, token)
   const ask = want === 'v3' ? 'a LaunchpadV3 (tax) token' : 'a 打新 (fair-mint) sale'
   if (kind === 'fair' && want === 'v3') {
-    return { error: `this is a 打新 (fair-mint) token, not a V3 token: use gang fair (e.g. gang fair info --token ${token}${net})`, kind }
+    return { error: `this is a 打新 (fair-mint) token, not a V3 token: gang info / buy / sell / mint / withdraw --token ${token}${net} pick the right pad code`, kind }
   }
   if (kind === 'v3' && want === 'fair') {
-    return { error: `this is a V3 (bonding-curve) token, not a 打新 sale: use gang v3 (e.g. gang v3 info --token ${token}${net})`, kind }
+    return { error: `this is a V3 (bonding-curve) token, not a 打新 sale: gang info / buy / sell --token ${token}${net} pick the right pad code`, kind }
   }
   return { error: `not ${ask} on this pad`, kind }
 }