@gangfun/cli 0.12.0 → 0.14.0

package/src/buyback.js

@@ -0,0 +1,205 @@
+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> [--buyback-to <addr>]` — 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's payee (the dev unless it names another address; v2 splitters only, `gang buyback set-payee`).
+ * GangBuybackSplitterFactory clones one per token for the dev (`create(bps, salt, payee)`, 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, factory v2 (payee; docs/MAINNET-BUYBACK-SPLITTER-2026-10-28.md). v1 was 0x6bcd…8546 (2-argument create)
+export const MAINNET_SPLITTER_FACTORY = '0x93467Cb38B9Cb7f6EF3b67d2226Eb8b77ca58F2f'
+export const TESTNET_SPLITTER_FACTORY = '0x08b9E2Cf5F666b55F262239b19e25de25b8ba87D'
+/** The factory's clones; v1 (mainnet's first factory, 0x6bcd…8546) pays the dev, v2 its payee. */
+export const BUYBACK_TYPE = 'buyback-burn-v2'
+const BUYBACK_TYPES = ['buyback-burn-v1', BUYBACK_TYPE]
+
+export const FACTORY_ABI = parseAbi([
+  'function create(uint16 buybackBps, bytes32 salt, address payee) 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)',
+  'function payee() view returns (address)',
+  'function setPayee(address newPayee)',
+  '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 }
+  const moduleType = hexToString(type, { size: 32 }).replace(/\0+$/, '')
+  if (!BUYBACK_TYPES.includes(moduleType)) 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)))
+  // v1 has no payee: it pays the dev
+  const hasPayee = moduleType !== 'buyback-burn-v1'
+  const payee = hasPayee ? await read(addr, SPLITTER_ABI, 'payee') : dev
+  const toDev = payee.toLowerCase() === dev.toLowerCase()
+  // the pad takes 18-decimal quotes only
+  const q = (x) => formatUnits(x, 18)
+  return {
+    splitter: addr, moduleType, dev, payee, payeeChangeable: hasPayee, 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 ${toDev ? 'the dev' : `the payee ${payee}`}; a raise applies at once, a cut only 3 days after it is asked for${hasPayee ? '; the dev can change the payee at once (gang buyback set-payee)' : ''}`,
+  }
+}
+
+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', 'set-payee', 'apply', 'bind', 'release']
+const USAGE = 'usage: gang buyback <status|set|set-payee|apply|bind|release> --token <addr> [--pct <0-100>] [--to <addr>] [--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 === 'set-payee') {
+    if (!s.payeeChangeable) return fail('this splitter (buyback-burn-v1) has no payee: it pays the dev; only splitters from the current factory (v2) can name another address')
+    if (me().toLowerCase() !== s.dev.toLowerCase()) return fail('only the dev this splitter was made for can change its payee', { wallet: me(), dev: s.dev })
+    const to = opt('to')
+    if (!isAddress(to ?? '') || to === zeroAddress) fail('--to <0x…> required (checksummed or all lowercase): the address the dev\'s part goes to from now on', { got: to ?? null })
+    if (to.toLowerCase() === s.payee.toLowerCase()) return fail('that is the payee already', { payee: s.payee })
+    return send('setPayee', [to], {
+      step: 'set-payee', fromPayee: s.payee, toPayee: to,
+      note: 'applies at once (the dev\'s own share; holders are not affected). Quote that arrived before is split to the current payee first; what is owed goes to the new one',
+    })
+  }
+
+  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, payee: s.payee, note: 'anyone may; the payee gets what a failed push left owed' })
+}

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);
@@ -393,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.
@@ -404,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`,
@@ -462,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 }))
   }
 

package/src/index.js

@@ -17,6 +17,9 @@ import { rememberPreview, previewFor } from './previews.js'
 import { UA, checkUpdate } from './version.js'
 import { runFair, FAIR_EVENT_ABIS } from './fair.js'
 import { runV3, v3Ctx, V3_EVENT_ABIS } from './v3.js'
+import { runBond } from './bond.js'
+import { runBuyback } from './buyback.js'
+import { FAIR_DEV_BUY, isLaunch, LAUNCH_FLAGS, runLaunch } from './launch.js'
 import { poolPayBnb, poolTrade } from './pool.js'
 import { parseAmount, ROUTER_ABI, ROUTER_HINTS, revertOf as revertIn, step as writeStep } from './steps.js'
 import { MERGED_ERRORS_ABI, kindOf, padNets } from './gangpad.js'
@@ -277,6 +280,22 @@ graduated tokens only).
                                          gang.fun; the token's contractURI / metaURI, permanent). --logo-uri images are copied
                                          to gang.fun first (other hosts expire); --keep-logo-uri puts a permanent URL (e.g.
                                          ipfs://) on-chain as is; gang.fun files always go on as ipfs://<cid>
+  LAUNCH in one command (one tx per run: execute it, then run the very same command again until launch.stage = done):
+  gang create … --dev-buy <quote> [--bond <quote> [--bond-hold <tokens|N%|all>] --bond-days <7-90>]
+                                         V3: create → the dev buys on the curve (--dev-buy, as gang buy) → bonds what it
+                                         holds (--bond-hold, default all; gang bond post). Wrap / approve steps come in between
+  gang create … --buy-tax <1-5> --sell-tax <1-5> --buyback <0-100> [--buyback-to <addr>] [--dev-buy … [--bond …]]
+                                         V3, taxed: the recipient's part of the tax is split, --buyback % bought back in the
+                                         pool and burned (0xdead), the rest to you (or --buyback-to <addr>; changeable later
+                                         with gang buyback set-payee). Steps: clone your buy-back splitter
+                                         (GangBuybackSplitterFactory; listed as a recipient in the same tx) → create with it as
+                                         the recipient → bind → the rest of the launch. Without --buyback the tax goes to you
+  gang create --fair … [--shares <n>] --bond <quote> [--bond-hold …] --bond-days <7-90>
+                                         打新: create (the dev's --shares are bought in it) → bond. Progress is read from the
+                                         chain (a token this wallet created with this symbol since the plan); a run that finds
+                                         none never creates again by itself (the first may still be landing): --restart does.
+                                         Done stays done: running it again only reports. --note goes on the create only;
+                                         --bond needs GangBond on the network (testnet only for now), checked before the create
   NOTES: gang create / buy / sell, and gang mint / withdraw on a 打新 sale, take [--note "<why>" [--conf 0-100]
                                          [--reveal-after 1-72h]] (a create's note is its launch manifesto); gang buy also
                                          --follow <note tx>. Mainnet only; pool trades (graduated / launched) carry no note
@@ -295,6 +314,51 @@ graduated tokens only).
                                          The router is checked first (a GangRouter with pool trades, not Pancake / an old one);
                                          a reverted simulation with --calldata is doNotSend: true, no tx. V2 / Soft / U / S:
                                          --from only on graduated tokens, mainnet only
+                                         A creator selling below its bonded X (gang bond) is refused unless --break-bond;
+                                         past the deadline, --settle-first settles the bond before the sell.
+
+BOND (押金承诺, GangBond; any GangLaunchpad token, from create on; GANG_BOND / GANG_TESTNET_BOND = its address):
+  gang bond post --token <addr> --hold <tokens|N%> --days <7-90> (--amount <quote> | --cover <coverage %>) [--use-wbnb]
+                                         creator only, any time after create (V3: buy on the curve first): bond in the token's
+                                         quote (WBNB: paid in BNB, --use-wbnb pays WBNB; also on topup) promising the creator
+                                         keeps at least --hold tokens (N% = of the 1B supply) from now on. The --days clock
+                                         starts when the token graduates / launches (at once if it already has). --cover 100 =
+                                         exactly what dumping X fetches now (only once on the pair). No early withdrawal;
+                                         below X anyone reports it, on the curve too
+  gang bond topup --token <addr> (--amount <quote> | --cover <target %>) | gang bond raise-hold --token <addr> --hold <tokens|N%>
+  gang bond extend --token <addr> --days <n>
+                                         creator only: the bond only grows, X only rises, the commitment only gets longer (90
+                                         days in all before the pair; a deadline ≤ 90 days from now after it)
+  gang bond status --token <addr>        state, phase (pending: waiting for the pair / running), X and the creator's balance /
+                                         headroom, coverage + tier once on the pair (≥100% full cover, 50–100% bond, <50% no
+                                         badge), toFullCover, time left, buy-back progress, the creator's record
+  gang bond start --token <addr>         anyone, once the token graduated / launched: start the clock (deadline = now + days)
+  gang bond report --token <addr>        anyone, when the creator holds less than X: 1% of the bond to you, the rest buys
+                                         back and burns the token (simulated first; nothing is sent when not violated)
+  gang bond settle --token <addr>        anyone, after the deadline while X is held: the bond goes back to the creator
+  gang bond refund --token <addr>        creator, posted before the pair and still no pair 30 days later: run it once to ask
+                                         (a 3-day notice: X still binds, graduation / launch voids it), again after it to
+                                         get the bond back
+  gang bond burn --token <addr> [--slippage 1]
+                                         anyone: one buy-back chunk of a slashed bond (≤ 0.5% of the pair's quote side; waits
+                                         for a 10-minute average and skips when the price is > 2% above it). Slashed before the
+                                         pair: waits for it; none 30 days after the post → the rest goes to 0xdead as quote
+  gang bond tx --hash <0x..>             decode GangBond events. --testnet, --calldata, --from as in gang v3. A bonded
+                                         creator's gang v3 sell (curve or pool), gang fair sell and gang fair withdraw are
+                                         checked against X (--break-bond / --settle-first)
+BUYBACK (a V3 token whose recipient is a buy-back splitter; GANG_SPLITTER_FACTORY / GANG_TESTNET_SPLITTER_FACTORY):
+  gang buyback status --token <addr>     ratio, a cut asked for (applies from / lapses after), quote waiting to be bought
+                                         back, the payee and what is owed to it, the next chunk (the keeper buys it back
+                                         every few minutes)
+  gang buyback set --token <addr> --pct <0-100>
+                                         dev only: a higher share applies at once; a lower one after a 3-day notice
+  gang buyback set-payee --token <addr> --to <addr>
+                                         dev only: the part not bought back goes to --to from now on (at once; splitters
+                                         from the current factory; the first mainnet ones, buyback-burn-v1, pay the dev)
+  gang buyback apply --token <addr>      anyone: apply a cut whose notice ran (within 7 days, or it lapses)
+  gang buyback bind --token <addr> | gang buyback release --token <addr>
+                                         anyone: bind the splitter to its token (the launch does it) / push the payee what a
+                                         failed payment left owed. --testnet, --calldata, --from as in gang v3
   gang execute --request-id <id>         broadcast a previewed call
   gang tx --hash <0x..> [--testnet]      wait for receipt and decode Gang events: V2 / Soft / U / S, GangLaunchpad (V3 /
                                          打新, tax router, vaults) (publishes a queued --note; mainnet). GangLaunchpad events
@@ -662,6 +726,8 @@ const createGateAgent = (me) =>
 
 // what `gang v3` / `gang fair` (and `gang create`) get from here; each call adds its `notes` (padNotes)
 const PAD_IO = { opt, flag, out, fail, summarize: summarizePreview, resolveLogo: resolveLogoUri, checkMeta: parseMeta, resolveMeta: resolveMetaUri }
+/** `gang create … --dev-buy … [--bond …]` / `gang fair create … --bond …`: one command, one tx per run (launch.js). */
+const LAUNCH_DEPS = { io: PAD_IO, runV3, runFair, runBond, padNotes: (kind, sub, pre) => padNotes(kind, sub, pre) }
 
 // ---------------------------------------------------------------- one command per action, whatever the pad
 // gang buy|sell|info|status|claim|mint|withdraw|release --token <addr> ask GangLaunchpad's kindOf what the token is and
@@ -780,16 +846,19 @@ function create() {
   if (flag('fair')) {
     const wrong = V3_CREATE_FLAGS.find(flag)
     if (wrong) fail(`--${wrong} is a V3 tax setting; a 打新 sale's pool tax is fixed (1%): leave it out, or drop --fair for a V3 token`)
+    if (isLaunch('fair', flag)) return runLaunch('fair', LAUNCH_DEPS)
     return runFair('create', { ...PAD_IO, notes: padNotes('fair', 'create') })
   }
   const wrong = FAIR_CREATE_FLAGS.find(flag)
   if (wrong) fail(`--${wrong} is a 打新 (fair-mint) setting: add --fair to create a sale (gang create --fair …)`)
+  if (isLaunch('v3', flag)) return runLaunch('v3', LAUNCH_DEPS)
   return runV3('create', { ...PAD_IO, notes: padNotes('v3', 'create') })
 }
 
 // commands whose JSON result carries `update`; `watch` streams NDJSON and help is plain text
 const UPDATE_CHECKED = new Set(['preflight', 'list', 'hot', 'new', 'near-grad', 'notes', 'agents', 'token', 'info', 'status', 'quote',
-  'buy', 'follow', 'sell', 'claim', 'mint', 'withdraw', 'release', 'upload-logo', 'create', 'execute', 'tx', 'fair', 'v3'])
+  'buy', 'follow', 'sell', 'claim', 'mint', 'withdraw', 'release', 'upload-logo', 'create', 'execute', 'tx', 'fair', 'v3', 'bond',
+  'buyback'])
 // gang tx decodes these beside the V2 / Soft / U / S pads' events (GangLaunchpad: both kinds; the tax router; the vaults)
 const GANG_EVENT_ABIS = [...V3_EVENT_ABIS, ...FAIR_EVENT_ABIS]
 
@@ -803,11 +872,26 @@ async function main() {
   if (flag('description') && !tokenCreate) {
     fail('--description only applies when creating a token (`gang create`, `gang create --fair`; it goes into the token metadata)')
   }
+  // --bond-hold / --bond-days / --restart only mean something in a chained launch (--dev-buy / --bond); never drop them silently
+  // gang fair create and gang create --fair are 打新 creates; the rest V3
+  const launchKind = cmd === 'fair' || (cmd === 'create' && flag('fair')) ? 'fair' : 'v3'
+  if (tokenCreate && !isLaunch(launchKind, flag)) {
+    // a 打新 dev buys with --shares in the create itself: say so here, not "add --bond" (which would only lead to that)
+    if (launchKind === 'fair' && flag('dev-buy')) fail(FAIR_DEV_BUY)
+    const lone = LAUNCH_FLAGS.find((f) => flag(f))
+    if (lone) fail(`--${lone} only applies to a launch in one command: add --bond <quote>${launchKind === 'fair' ? '' : ' (or --dev-buy <quote> / --buyback <pct>)'}`)
+  }
   switch (cmd) {
     case 'fair':
+      if (args[1] === 'create' && isLaunch('fair', flag)) return runLaunch('fair', LAUNCH_DEPS)
       return runFair(args[1], alias('fair', args[1]))
     case 'v3':
+      if (args[1] === 'create' && isLaunch('v3', flag)) return runLaunch('v3', LAUNCH_DEPS)
       return runV3(args[1], alias('v3', args[1]))
+    case 'bond':
+      return runBond(args[1], { opt, flag, out, fail, summarize: summarizePreview })
+    case 'buyback':
+      return runBuyback(args[1], { opt, flag, out, fail, summarize: summarizePreview })
     case 'preflight': {
       const issues = []
       const status = bawStatus()