@gangfun/cli 0.1.4 → 0.3.0

package/src/index.js

@@ -1,13 +1,23 @@
 #!/usr/bin/env node
-import { CONFIG, listTokens, tokenInfo, quoteBuy, quoteSell, isAgent, balanceOf, allowance, calldata, decodeTx, parseEther, fmt, fmtTok } from './chain.js'
+import {
+  CONFIG, ADDR, listTokens, tokenInfo, quoteBuy, quoteSell, isAgent, balanceOf, allowance,
+  calldata, decodeTx, parseEther, fmt, fmtTok, resolvePad, assertCreateTarget, zeroAddress,
+} from './chain.js'
 import { bawAddress, bawSettings, bawStatus, bawPreview, bawExecute } from './baw.js'
+import { uploadLogoFile, LOGO_UI } from './logo.js'
+import { API, fetchMarket, rank, watch, parseDuration } from './discover.js'
 
 const args = process.argv.slice(2)
 const cmd = args[0]
 const opt = (name, def) => { const i = args.indexOf(`--${name}`); return i >= 0 ? args[i + 1] : def }
 const flag = (name) => args.includes(`--${name}`)
 const out = (o) => console.log(JSON.stringify(o, (_, v) => (typeof v === 'bigint' ? v.toString() : v), 2))
-const fail = (msg, extra = {}) => { out({ success: false, error: msg, ...extra }); process.exit(1) }
+// `gang watch` speaks NDJSON, so its failures are one line too (with event/fatal for stream consumers)
+const fail = (msg, extra = {}) => {
+  if (cmd === 'watch') console.log(JSON.stringify({ event: 'error', fatal: true, success: false, error: msg, ...extra }))
+  else out({ success: false, error: msg, ...extra })
+  process.exit(1)
+}
 
 const parseSlippage = (raw) => {
   const s = Number(raw)
@@ -15,19 +25,41 @@ const parseSlippage = (raw) => {
   return s
 }
 
-const HELP = `gang — agent-only launchpad on BNB Chain (Binance Agentic Wallet)
+const parseCount = (name, raw, max) => {
+  const n = Number(raw)
+  if (!Number.isInteger(n) || n < 1 || n > max) fail(`--${name} must be an integer between 1 and ${max}`, { got: raw })
+  return n
+}
+const parsePct = (raw) => {
+  const n = Number(raw)
+  if (!Number.isFinite(n) || n < 0 || n > 100) fail('--min-pct must be a number between 0 and 100', { got: raw })
+  return n
+}
+const WATCH_EVENTS = ['trade', 'progress', 'graduated', 'new_token', 'near_grad']
+
+const HELP = `gang — agent-only launchpad on BNB Chain (Binance Agentic Wallet) · LaunchpadV2 create
 
   gang preflight                         check sign-in, Developer Mode, tradeAllTokens, Agent ID
-  gang list                              all tokens with price, progress, my balance
-  gang token --token <addr>              one token in detail
-  gang quote --token <addr> --bnb <n>    buy quote for my wallet (fee, cap, refund)
-  gang buy --token <addr> --bnb <n> [--slippage 1]      preview a buy  -> requestId
-  gang sell --token <addr> (--amount <tokens> | --all) [--slippage 1]  preview approve or sell -> requestId
-  gang create --name <n> --symbol <s>    preview token creation -> requestId
+  gang list                              tokens across V2 / Soft / U / S
+  gang hot [--limit 10] [--track all|v2|soft] [--include-graduated]
+                                         curve tokens ranked by 24h USD volume
+  gang new [--limit 10] [--max-age 2h] [--track …]      newest curve tokens first
+  gang near-grad [--min-pct 50] [--limit 10] [--track …]  closest to graduation
+  gang watch [<addr>] [--interval 10] [--min-pct 50] [--events a,b] [--max-events N] [--timeout 30m] [--webhook URL]
+                                         NDJSON stream (min interval: 3s token, 10s market). <addr>: trade / progress / graduated.
+                                         no addr: new_token / near_grad / graduated across the market
+  gang token --token <addr>              one token (auto-resolves pad)
+  gang quote --token <addr> --bnb <n>    Soft: BNB quote; V2/U/S: quote-token amount (same flag)
+  gang buy --token <addr> --bnb <n> [--slippage 1]      Soft: payable BNB; V2: approve quote then buy
+  gang sell --token <addr> (--amount <tokens> | --all) [--slippage 1]
+  gang upload-logo --file <path>         POST image → https://gang.fun/api/logos → logoUrl
+  gang create --name <n> --symbol <s> [--logo-uri URL | --logo <file>] [--taxed] [--pair-or-quote 0x…]
+                                         LaunchpadV2 ONLY (${ADDR.v2}); Soft/U/S create refused
   gang execute --request-id <id>         broadcast a previewed call
   gang tx --hash <0x..>                  wait for receipt and decode Gang events
 
-env: GANG_LAUNCHPAD (default ${CONFIG.launchpad}), GANG_RPC_URL`
+Logo UI (browser): ${LOGO_UI}
+env: GANG_LAUNCHPAD (default V2 ${ADDR.v2}), GANG_RPC_URL, GANG_LOGO_API, GANG_API (default ${API})`
 
 function summarizePreview(p, extra = {}) {
   if (!p.success) return { success: false, step: extra.step, error: p.error }
@@ -43,6 +75,18 @@ function summarizePreview(p, extra = {}) {
   }
 }
 
+async function resolveLogoUri() {
+  const uri = opt('logo-uri')
+  const file = opt('logo') || opt('logo-file') || opt('file-logo')
+  if (uri && file) fail('use either --logo-uri or --logo/--logo-file, not both')
+  if (uri) return { logoURI: uri, uploaded: false }
+  if (file) {
+    const up = await uploadLogoFile(file)
+    return { logoURI: up.logoUrl, uploaded: true, upload: up }
+  }
+  return { logoURI: '', uploaded: false }
+}
+
 async function main() {
   switch (cmd) {
     case 'preflight': {
@@ -55,13 +99,97 @@ async function main() {
         if (!settings.devMode?.enabled) issues.push({ code: 'DEV_MODE_OFF', fix: 'Enable Developer Mode in Binance App → Agentic Wallet settings.' })
         if (!settings.tradeAllTokens) issues.push({ code: 'TRADE_ALL_TOKENS_OFF', fix: 'Enable "Trade all tokens" in Binance App → Agentic Wallet settings, otherwise SELLING Gang tokens is blocked by risk control (buying still works).' })
         agent = await isAgent(me)
-        if (!agent) issues.push({ code: 'NO_AGENT_ID', fix: 'Claim a .ai Agent ID in Binance Wallet (Agent ID banner). Gang only lets Agent ID holders buy.' })
+        if (!agent) issues.push({ code: 'NO_AGENT_ID', fix: 'Claim a .ai Agent ID in Binance Wallet (Agent ID banner). Gang only lets Agent ID holders buy/create.' })
       }
-      return out({ success: issues.length === 0, status, address: me, launchpad: CONFIG.launchpad, isAgent: agent, devMode: settings?.devMode?.enabled ?? null, tradeAllTokens: settings?.tradeAllTokens ?? null, issues })
+      return out({
+        success: issues.length === 0, status, address: me,
+        launchpad: CONFIG.launchpad, createPad: ADDR.v2, isAgent: agent,
+        devMode: settings?.devMode?.enabled ?? null, tradeAllTokens: settings?.tradeAllTokens ?? null, issues,
+        note: 'New create → LaunchpadV2 only (~15 BNB graduation). Soft/U/S: existing buy/sell/claim only.',
+      })
     }
     case 'list': {
       const me = bawStatus() === 'CONNECTED' ? bawAddress() : undefined
-      return out({ success: true, launchpad: CONFIG.launchpad, tokens: await listTokens(me) })
+      return out({ success: true, createPad: ADDR.v2, tokens: await listTokens(me) })
+    }
+    case 'hot':
+    case 'new':
+    case 'near-grad': {
+      const limit = parseCount('limit', opt('limit', '10'), 100)
+      const minPct = parsePct(opt('min-pct', '50'))
+      const maxAgeSec = opt('max-age') ? parseDuration(opt('max-age'), 'max-age') : null
+      const track = opt('track', 'all')
+      const includeGraduated = flag('include-graduated')
+      const market = await fetchMarket(track)
+      const tokens = rank(market.tokens, cmd, { limit, minPct, maxAgeSec, includeGraduated })
+      const empty = {
+        hot: includeGraduated ? 'No token traded in the last 24h.' : 'No curve token traded in the last 24h.',
+        new: maxAgeSec != null ? `No curve token created in the last ${opt('max-age')}.` : 'No curve tokens.',
+        'near-grad': `No curve token at ≥${minPct}% of graduation; lower --min-pct to see the closest ones.`,
+      }[cmd]
+      return out({
+        success: true, source: API, sort: cmd, track, count: tokens.length,
+        ...(cmd === 'near-grad' ? { minPct } : {}), ...(maxAgeSec != null ? { maxAgeSec } : {}),
+        ...(market.truncated ? { truncated: true } : {}),
+        tokens,
+        note: tokens.length ? 'Amounts are in each token\'s `quote` unit; pass that unit to `gang quote/buy --bnb`. Data, not advice.' : empty,
+      })
+    }
+    case 'watch': {
+      const positional = args[1] && !args[1].startsWith('--') ? args[1] : null
+      if (positional && flag('token')) fail('give the token either as <addr> or via --token, not both')
+      if (!positional && flag('token') && !opt('token')) fail('--token needs an address (or omit it to watch the whole market)')
+      const token = positional || opt('token')
+      if (token && !/^0x[0-9a-fA-F]{40}$/.test(token)) fail('watch: token must be a 0x… address', { got: token })
+      // market mode pulls the full token list every tick, so it gets a higher floor than a single token
+      const intervalSec = Math.max(token ? 3 : 10, parseDuration(opt('interval', '10'), 'interval'))
+      const maxEvents = opt('max-events') ? parseCount('max-events', opt('max-events'), 1e6) : Infinity
+      const deadline = opt('timeout') ? Date.now() + parseDuration(opt('timeout'), 'timeout') * 1000 : Infinity
+      const minPct = parsePct(opt('min-pct', '50'))
+      const webhook = opt('webhook')
+      if (webhook && !/^https?:\/\//.test(webhook)) fail('--webhook must be an http(s) URL', { got: webhook })
+      let events = null
+      if (opt('events')) {
+        events = new Set(opt('events').split(',').map((s) => s.trim().replace(/-/g, '_')).filter(Boolean))
+        const bad = [...events].filter((e) => !WATCH_EVENTS.includes(e))
+        if (bad.length) fail(`unknown --events: ${bad.join(', ')}`, { allowed: WATCH_EVENTS })
+      }
+
+      let count = 0
+      const hooks = new Set()
+      const line = (o) => console.log(JSON.stringify({ ...o, emittedAt: Math.floor(Date.now() / 1000) }))
+      // meta events (watching / error / ended / timeout) go to stdout only and do not count toward --max-events
+      const emit = (ev, { meta = false } = {}) => {
+        line(ev)
+        if (meta) return
+        count++
+        if (webhook) {
+          const p = fetch(webhook, {
+            method: 'POST', headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(ev), signal: AbortSignal.timeout(10_000),
+          }).then((r) => { if (!r.ok) line({ event: 'error', error: `webhook ${r.status}` }) })
+            .catch((e) => line({ event: 'error', error: `webhook: ${e.message}` }))
+            .finally(() => hooks.delete(p))
+          hooks.add(p)
+        }
+      }
+      // aborts in-flight API requests at the deadline so --timeout isn't stretched by a slow API.
+      // setTimeout caps at 2^31-1 ms (~24.8d) and fires at once beyond it; longer timeouts rely on sleep's check.
+      const stopper = new AbortController()
+      const delay = deadline - Date.now()
+      const deadlineTimer = delay <= 2 ** 31 - 1 ? setTimeout(() => stopper.abort(), delay) : null
+      // the timer runs on the monotonic clock and may beat Date.now() by a hair; treat its firing as the deadline
+      const shouldStop = () => count >= maxEvents || stopper.signal.aborted || Date.now() >= deadline
+      try {
+        await watch({ token, intervalSec, minPct, track: opt('track', 'all'), events, emit, shouldStop, stop: stopper.signal })
+      } catch (e) {
+        if (!shouldStop()) throw e // startup failure → fail() prints it as one NDJSON line
+      } finally {
+        clearTimeout(deadlineTimer)
+      }
+      if (count < maxEvents && (stopper.signal.aborted || Date.now() >= deadline)) line({ event: 'timeout', events: count })
+      await Promise.allSettled([...hooks])
+      return
     }
     case 'token': {
       const token = opt('token'); if (!token) fail('--token required')
@@ -69,10 +197,17 @@ async function main() {
       return out({ success: true, ...(await tokenInfo(token, me)) })
     }
     case 'quote': {
-      const token = opt('token'), bnb = opt('bnb'); if (!token || !bnb) fail('--token and --bnb required')
+      const token = opt('token'), bnb = opt('bnb'); if (!token || !bnb) fail('--token and --bnb required (Soft archive: BNB; V2: quote ERC-20 amount)')
       const me = bawAddress()
       const q = await quoteBuy(token, me, bnb)
-      return out({ success: true, token, buyer: me, tokensOut: q.tokensOutFmt, bnbSpent: q.bnbInFmt, fee: q.feeFmt, refund: q.refundFmt, note: q.refund > 0n ? 'Part of the BNB would be refunded (wallet 1% cap or graduation cap).' : undefined })
+      return out({
+        success: true, token, buyer: me, pad: q.pad, kind: q.kind, quote: q.quote,
+        quotePath: q.quotePath, deterministic: q.deterministic || false,
+        tokensOut: q.tokensOutFmt, spent: q.spentFmt, fee: q.feeFmt, refund: q.refundFmt, unit: q.unit,
+        note: q.refund > 0n
+          ? 'Part of the input would be refunded (wallet 1% cap or graduation cap).'
+          : (q.deterministic ? 'V2 quote = LaunchpadV2.sol curve math (unique path; no Soft/U/S fallback).' : undefined),
+      })
     }
     case 'buy': {
       const token = opt('token'), bnb = opt('bnb'); if (!token || !bnb) fail('--token and --bnb required')
@@ -81,12 +216,38 @@ async function main() {
       const info = await tokenInfo(token, me)
       if (info.graduated) fail('token already graduated; trade it on PancakeSwap', { pair: info.pair })
       if (!(await isAgent(me))) fail('this wallet holds no Agent ID (.ai); buying is gated', { address: me })
+      const pad = await resolvePad(token)
       const q = await quoteBuy(token, me, bnb)
-      if (q.tokensOut === 0n) fail('wallet cap reached: this wallet already holds 1% of supply', { myBalance: info.myBalance })
+      if (q.tokensOut === 0n) fail('wallet cap reached or zero out', { myBalance: info.myBalance })
       const minOut = (q.tokensOut * BigInt(Math.round((100 - slippage) * 100))) / 10000n
-      const data = calldata.buy(token, minOut)
-      const p = bawPreview({ from: me, to: CONFIG.launchpad, value: parseEther(bnb), data })
-      return out(summarizePreview(p, { step: 'buy', token, symbol: info.symbol, bnbSent: bnb, expectTokens: q.tokensOutFmt, expectBnbSpent: q.bnbInFmt, fee: q.feeFmt, expectRefund: q.refundFmt, minTokensOut: fmtTok(minOut) }))
+
+      if (pad.kind === 'soft') {
+        const data = calldata.softBuy(token, minOut)
+        const p = bawPreview({ from: me, to: pad.address, value: parseEther(bnb), data })
+        return out(summarizePreview(p, {
+          step: 'buy', kind: 'soft', token, symbol: info.symbol, pad: pad.id,
+          bnbSent: bnb, expectTokens: q.tokensOutFmt, expectSpent: q.spentFmt, fee: q.feeFmt,
+          expectRefund: q.refundFmt, minTokensOut: fmtTok(minOut),
+        }))
+      }
+
+      // V2 / U / S: quote ERC-20 approve then buy(token, quoteIn, minTokensOut)
+      const quoteIn = parseEther(bnb)
+      const allow = await allowance(info.quote, me, pad.address)
+      if (allow < quoteIn) {
+        const p = bawPreview({ from: me, to: info.quote, data: calldata.approve(pad.address, quoteIn) })
+        return out(summarizePreview(p, {
+          step: 'approve-quote', kind: 'v2', token, symbol: info.symbol, pad: pad.id, quote: info.quote,
+          amount: bnb, note: 'Approve quote ERC-20 first. After it confirms, re-run the same `gang buy` to preview the buy.',
+        }))
+      }
+      const data = calldata.v2Buy(token, quoteIn, minOut)
+      const p = bawPreview({ from: me, to: pad.address, data })
+      return out(summarizePreview(p, {
+        step: 'buy', kind: 'v2', token, symbol: info.symbol, pad: pad.id, quote: info.quote,
+        quoteIn: bnb, expectTokens: q.tokensOutFmt, expectSpent: q.spentFmt, fee: q.feeFmt,
+        expectRefund: q.refundFmt, minTokensOut: fmtTok(minOut), quotePath: q.quotePath, deterministic: q.deterministic || false,
+      }))
     }
     case 'sell': {
       const token = opt('token'); if (!token) fail('--token required')
@@ -99,22 +260,56 @@ async function main() {
       if (flag('all') && opt('amount')) fail('use either --all or --amount, not both')
       const amount = flag('all') ? bal : parseEther(opt('amount'))
       if (amount > bal) fail('amount exceeds balance', { balance: fmtTok(bal) })
-      const allow = await allowance(token, me)
+      const pad = await resolvePad(token)
+      const allow = await allowance(token, me, pad.address)
       if (allow < amount) {
-        const p = bawPreview({ from: me, to: token, data: calldata.approve(amount) })
-        return out(summarizePreview(p, { step: 'approve', token, symbol: info.symbol, amount: fmtTok(amount), note: 'Approve first. After it confirms on-chain, run the same `gang sell` again to preview the sell.' }))
+        const p = bawPreview({ from: me, to: token, data: calldata.approve(pad.address, amount) })
+        return out(summarizePreview(p, {
+          step: 'approve', token, symbol: info.symbol, pad: pad.id, amount: fmtTok(amount),
+          note: 'Approve first. After it confirms on-chain, run the same `gang sell` again to preview the sell.',
+        }))
       }
       const slippage = parseSlippage(opt('slippage', '1'))
       const q = await quoteSell(token, amount)
-      const minOut = (q.bnbToUser * BigInt(Math.round((100 - slippage) * 100))) / 10000n
-      const p = bawPreview({ from: me, to: CONFIG.launchpad, data: calldata.sell(token, amount, minOut) })
-      return out(summarizePreview(p, { step: 'sell', token, symbol: info.symbol, amount: fmtTok(amount), expectBnb: q.bnbToUserFmt, fee: q.feeFmt, minBnbOut: fmt(minOut) }))
+      const minOut = (q.out * BigInt(Math.round((100 - slippage) * 100))) / 10000n
+      if (pad.kind === 'soft') {
+        const p = bawPreview({ from: me, to: pad.address, data: calldata.softSell(token, amount, minOut) })
+        return out(summarizePreview(p, {
+          step: 'sell', kind: 'soft', token, symbol: info.symbol, pad: pad.id,
+          amount: fmtTok(amount), expectOut: q.outFmt, fee: q.feeFmt, minOut: fmt(minOut), unit: 'BNB',
+        }))
+      }
+      const p = bawPreview({ from: me, to: pad.address, data: calldata.v2Sell(token, amount, minOut) })
+      return out(summarizePreview(p, {
+        step: 'sell', kind: 'v2', token, symbol: info.symbol, pad: pad.id, quote: info.quote,
+        amount: fmtTok(amount), expectOut: q.outFmt, fee: q.feeFmt, minOut: fmt(minOut), unit: 'quote', quotePath: q.quotePath, deterministic: q.deterministic || false,
+      }))
+    }
+    case 'upload-logo': {
+      const file = opt('file') || opt('path') || opt('logo')
+      if (!file) fail('--file <path> required (png/jpeg/webp/gif ≤512KB)')
+      const up = await uploadLogoFile(file)
+      return out({ success: true, ...up, ui: LOGO_UI, next: `gang create --name … --symbol … --logo-uri ${up.logoUrl}` })
     }
     case 'create': {
       const name = opt('name'), symbol = opt('symbol'); if (!name || !symbol) fail('--name and --symbol required')
+      try { assertCreateTarget(CONFIG.launchpad) } catch (e) { fail(e.message) }
       const me = bawAddress()
-      const p = bawPreview({ from: me, to: CONFIG.launchpad, data: calldata.create(name, symbol) })
-      return out(summarizePreview(p, { step: 'create', name, symbol, note: 'No creation fee. The token address appears in the Created event: run `gang tx --hash <txHash>` after execute.' }))
+      if (!(await isAgent(me))) fail('this wallet holds no Agent ID (.ai); create is gated', { address: me })
+      const logo = await resolveLogoUri()
+      const taxed = flag('taxed')
+      const pairOrQuote = opt('pair-or-quote') || opt('pair') || zeroAddress
+      if (taxed && (!pairOrQuote || pairOrQuote === zeroAddress)) {
+        fail('--taxed requires --pair-or-quote <pair or quote CA>')
+      }
+      const data = calldata.createV2(name, symbol, logo.logoURI, taxed, pairOrQuote)
+      const p = bawPreview({ from: me, to: ADDR.v2, data })
+      return out(summarizePreview(p, {
+        step: 'create', pad: 'v2', launchpad: ADDR.v2, name, symbol,
+        logoURI: logo.logoURI || '(empty)', uploaded: logo.uploaded, upload: logo.upload,
+        taxed, pairOrQuote,
+        note: 'LaunchpadV2 only. Graduation ≈15 BNB (PoolCheck). No creation fee. Soft/U/S create archived. After execute: `gang tx --hash …` for Created.',
+      }))
     }
     case 'execute': {
       const id = opt('request-id'); if (!id) fail('--request-id required')
@@ -122,7 +317,12 @@ async function main() {
       if (!r.success) return out({ success: false, error: r.error })
       const d = r.data
       const pending = d.status === 'PENDING_CONFIRMATION'
-      return out({ success: true, status: d.status, txHash: d.txHash, orderId: d.orderId, pendingConfirmation: pending, next: pending ? 'Ask the user to approve this transaction in the Binance App, then poll `baw wallet tx-history --binanceChainId 56 --type confirmed --json` for the tx hash and run `gang tx --hash <hash>`.' : (d.txHash ? `gang tx --hash ${d.txHash}` : undefined) })
+      return out({
+        success: true, status: d.status, txHash: d.txHash, orderId: d.orderId, pendingConfirmation: pending,
+        next: pending
+          ? 'Ask the user to approve this transaction in the Binance App, then poll `baw wallet tx-history --binanceChainId 56 --type confirmed --json` for the tx hash and run `gang tx --hash <hash>`.'
+          : (d.txHash ? `gang tx --hash ${d.txHash}` : undefined),
+      })
     }
     case 'tx': {
       const hash = opt('hash'); if (!hash) fail('--hash required')

package/src/logo.js

@@ -0,0 +1,40 @@
+import { readFileSync, statSync } from 'node:fs'
+import { extname, resolve } from 'node:path'
+
+const MAX_BYTES = 512 * 1024
+const MIME = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.webp': 'image/webp',
+  '.gif': 'image/gif',
+}
+
+export const LOGO_API = process.env.GANG_LOGO_API || 'https://gang.fun/api/logos'
+export const LOGO_UI = 'https://gang.fun/dev/logo'
+
+/** Read a local image → data URL → POST /api/logos → { logoUrl, id, bytes }. */
+export async function uploadLogoFile(filePath) {
+  const abs = resolve(filePath)
+  const st = statSync(abs)
+  if (!st.isFile()) throw new Error(`not a file: ${abs}`)
+  if (st.size <= 0) throw new Error(`empty file: ${abs}`)
+  if (st.size > MAX_BYTES) throw new Error(`logo too large: ${st.size} bytes (max ${MAX_BYTES})`)
+  const ext = extname(abs).toLowerCase()
+  const mime = MIME[ext]
+  if (!mime) throw new Error(`unsupported image type ${ext || '(none)'}; use png/jpeg/webp/gif`)
+  const b64 = readFileSync(abs).toString('base64')
+  const image = `data:${mime};base64,${b64}`
+  const res = await fetch(LOGO_API, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', accept: 'application/json' },
+    body: JSON.stringify({ image }),
+  })
+  const text = await res.text()
+  let json
+  try { json = JSON.parse(text) } catch { throw new Error(`logo upload non-JSON (${res.status}): ${text.slice(0, 200)}`) }
+  if (!res.ok || !json?.ok || !json?.logoUrl) {
+    throw new Error(json?.error || `logo upload failed (${res.status}): ${text.slice(0, 200)}`)
+  }
+  return { logoUrl: json.logoUrl, id: json.id, bytes: json.bytes ?? st.size, api: LOGO_API }
+}