@gangfun/cli 0.1.4 → 0.2.1

package/README.md

@@ -1,8 +1,8 @@
 # Gang CLI (`gang`)
 
-Operate [gang.fun](https://gang.fun) from a Binance **Agentic Wallet**. Curve buys require a SPACE ID `.ai` Agent ID. This CLI builds calldata; `baw` signs — no keys in this package.
+Operate [gang.fun](https://gang.fun) from a Binance **Agentic Wallet**. Curve buys/creates require a SPACE ID `.ai` Agent ID. This CLI builds calldata; `baw` signs — no keys in this package.
 
-Not an open-source product dump: install and run steps only.
+**Create path (0.2.1+):** LaunchpadV2 only (`0x1B8F3f69DFa0a7F63d308C7EB0Fd38D8b099966E`). Soft / LaunchpadU / LaunchpadS: **no new create** — buy/sell/claim existing tokens only. New tokens graduate at ≈ **15 BNB** (PoolCheck). Soft archive tokens still graduate at 20 BNB on-chain.
 
 ## Install
 
@@ -10,36 +10,23 @@ Node ≥ 18. Also install Binance Agentic Wallet CLI (`baw`):
 
 ```bash
 npm i -g @binance/agentic-wallet
-npm i -g @gangfun/cli@0.1.3 --registry=https://npm.pkg.github.com
+npm i -g @gangfun/cli@0.2.1 --registry=https://npm.pkg.github.com
 ```
 
-Package: [GitHub Packages `@gangfun/cli`](https://github.com/gangfun/cli/pkgs/npm/cli). GitHub Packages needs auth — one-liner: `npm login --registry=https://npm.pkg.github.com` (use a token with `read:packages`). Or put the token in `~/.npmrc` (or `NODE_AUTH_TOKEN`):
+Package: [GitHub Packages `@gangfun/cli`](https://github.com/gangfun/cli/pkgs/npm/cli). Auth:
 
 ```ini
 @gangfun:registry=https://npm.pkg.github.com
 //npm.pkg.github.com/:_authToken=YOUR_GITHUB_TOKEN
 ```
 
-Then you can omit the `--registry` flag: `npm i -g @gangfun/cli@0.1.3`.
-
-**Alternate** (no Packages token; installs from the public git repo `main` tip = `@gangfun/cli@0.1.3` / Launchpad v4.1):
-
-```bash
-npm i -g github:gangfun/cli
-# or one-shot:
-npx --yes github:gangfun/cli preflight
-```
-
-If a previous global is stale, clear it then reinstall:
+**Alternate** (public git tip):
 
 ```bash
-npm uninstall -g @gangfun/cli
 npm i -g github:gangfun/cli
 ```
 
-After install, run `gang preflight` — Launchpad must be `0x315Ba2e8952D06094CC636b2B84229FA32fb23A7` (v4.1). If you still see `0x86854…dDcc`, the old global is still in use; uninstall and reinstall.
-
-Skill install (Claude Code / Cursor / Codex / OpenClaw / Binance AI Pro):
+Skill:
 
 ```bash
 npx skills add gangfun/gang-launchpad/skill
@@ -50,7 +37,7 @@ npx skills add gangfun/gang-launchpad/skill
 1. Binance App → Wallet → Agentic Wallet → create; claim a `.ai` Agent ID.
 2. Enable **Developer Mode** and **Trade all tokens**.
 3. `baw auth signin` → confirm in the App.
-4. `gang preflight`
+4. `gang preflight` — `createPad` must be LaunchpadV2.
 
 ## Commands
 
@@ -58,20 +45,45 @@ npx skills add gangfun/gang-launchpad/skill
 gang preflight
 gang list
 gang token --token <addr>
-gang quote --token <addr> --bnb <n>
+gang quote --token <addr> --bnb <n>          # Soft archive: BNB; V2: quote ERC-20 (LaunchpadV2.sol math)
 gang buy --token <addr> --bnb <n> [--slippage 1]
 gang sell --token <addr> (--amount <tokens> | --all) [--slippage 1]
-gang create --name <n> --symbol <s>
+gang upload-logo --file ./avatar.png         # → https://gang.fun/api/logos/<id>.png
+gang create --name <n> --symbol <s> [--logo-uri URL | --logo ./avatar.png] [--taxed] [--pair-or-quote 0x…]
 gang execute --request-id <id>
 gang tx --hash <0x..>
 ```
 
-Buy / sell / create: **preview → you confirm → execute**. `requestId` expires in ~5 minutes. Sells may need App confirmation.
+### Logo + create
+
+Browser UI: https://gang.fun/dev/logo (pre-create tab).
+
+```bash
+# Option A — upload then create
+gang upload-logo --file ./avatar.png
+# → { "logoUrl": "https://gang.fun/api/logos/<id>.png", ... }
+gang create --name "My Agent Coin" --symbol MAC --logo-uri https://gang.fun/api/logos/<id>.png
+gang execute --request-id …
+
+# Option B — create uploads for you
+gang create --name "My Agent Coin" --symbol MAC --logo ./avatar.png
+gang execute --request-id …
+```
+
+`--logo-uri ""` / omit logo → empty `logoURI` on-chain (allowed). `--taxed` requires `--pair-or-quote`. Untaxed default: `taxed=false`, `pairOrQuote=0x0` (WBNB).
+
+Buy / sell / create: **preview → you confirm → execute**. `requestId` expires in ~5 minutes.
+
+## Quote path
+
+- **Soft archive tokens:** on-chain `quoteBuy` / `quoteSell`.
+- **LaunchpadV2 (and U/S-shaped pads for legacy trade):** unique off-chain path = `LaunchpadV2.sol` `_prepBuy` / `_tokensOut` / `_quoteOut` (1% fee, wallet cap, graduation clamp). No Soft/U/S create/quote fallback. Output fields `quotePath` + `deterministic: true`.
 
 ## Rules (short)
 
-- 1% per-wallet cap on the curve; excess BNB refunded in-tx.
-- 20 BNB → graduate to PancakeSwap V2, LP burned.
+- 1% per-wallet cap on the curve; excess input refunded in-tx.
+- **New** creates → ≈15 BNB graduation (LaunchpadV2 / PoolCheck) → PancakeSwap V2, LP burned.
+- Soft legacy (archive): 20 BNB graduation; buy/sell only — no Soft create from this CLI.
 - Before graduation: no transfers, curve only.
 - Graduated: trade on PancakeSwap (`pair` from `gang token`).
 
@@ -79,9 +91,10 @@ Buy / sell / create: **preview → you confirm → execute**. `requestId` expire
 
 | Var | Meaning |
 |---|---|
-| `GANG_LAUNCHPAD` | Launchpad address (default v4.1 `0x315Ba2e8952D06094CC636b2B84229FA32fb23A7`; override via env) |
+| `GANG_LAUNCHPAD` | Create target (default LaunchpadV2 `0x1B8F3f69…966E`) |
 | `GANG_RPC_URL` | BSC HTTP RPC |
+| `GANG_LOGO_API` | Logo upload endpoint (default `https://gang.fun/api/logos`) |
 
 ## Version
 
-`0.1.3` · repo [gangfun/cli](https://github.com/gangfun/cli) · distribute via [GitHub Packages](https://github.com/gangfun/cli/pkgs/npm/cli) (not npmjs)
+`0.2.1` · repo [gangfun/cli](https://github.com/gangfun/cli) · distribute via [GitHub Packages](https://github.com/gangfun/cli/pkgs/npm/cli) (not npmjs)

package/README.zh-CN.md

@@ -1,56 +1,28 @@
 # Gang CLI（`gang`）
 
-用 Binance **Agentic Wallet** 操作 [gang.fun](https://gang.fun)。内盘买入需要 SPACE ID `.ai` Agent ID。本 CLI 只组 calldata，签名走 `baw`，不持有私钥。
+用 Binance **Agentic Wallet** 操作 [gang.fun](https://gang.fun)。内盘买入/发币需要 SPACE ID `.ai` Agent ID。本 CLI 只组 calldata，签名走 `baw`，不持有私钥。
 
-这里只写操作步骤，不是开源说明书。
+**发币路径（0.2.1+）：** 仅 LaunchpadV2（`0x1B8F3f69DFa0a7F63d308C7EB0Fd38D8b099966E`）。Soft / LaunchpadU / LaunchpadS：**禁止新 create**，仅存量 buy/sell/claim。新币毕业 ≈ **15 BNB**（PoolCheck）。Soft 存量链上仍为 20 BNB 毕业。
 
 ## 安装
 
-Node ≥ 18。另需安装 Binance Agentic Wallet CLI（`baw`）：
+Node ≥ 18。另需 `baw`：
 
 ```bash
 npm i -g @binance/agentic-wallet
-npm i -g @gangfun/cli@0.1.3 --registry=https://npm.pkg.github.com
+npm i -g @gangfun/cli@0.2.1 --registry=https://npm.pkg.github.com
 ```
 
-包地址：[GitHub Packages `@gangfun/cli`](https://github.com/gangfun/cli/pkgs/npm/cli)。GitHub Packages 需要登录——一句：`npm login --registry=https://npm.pkg.github.com`（token 需带 `read:packages`）。或把 token 写进 `~/.npmrc`（或环境变量 `NODE_AUTH_TOKEN`）：
+或：`npm i -g github:gangfun/cli`
 
-```ini
-@gangfun:registry=https://npm.pkg.github.com
-//npm.pkg.github.com/:_authToken=YOUR_GITHUB_TOKEN
-```
-
-配好后可省略 `--registry`：`npm i -g @gangfun/cli@0.1.3`。
-
-**备选**（不需要 Packages token；从公开 git 仓 `main` tip 装 = `@gangfun/cli@0.1.3` / Launchpad v4.1）：
-
-```bash
-npm i -g github:gangfun/cli
-# 或一次性：
-npx --yes github:gangfun/cli preflight
-```
-
-若之前装过旧全局包，先卸再装：
-
-```bash
-npm uninstall -g @gangfun/cli
-npm i -g github:gangfun/cli
-```
-
-装完跑 `gang preflight`——Launchpad 必须是 `0x315Ba2e8952D06094CC636b2B84229FA32fb23A7`（v4.1）。若仍看到 `0x86854…dDcc`，说明旧全局还在，卸掉重装。
-
-Skill（Claude Code / Cursor / Codex / OpenClaw / Binance AI Pro）：
-
-```bash
-npx skills add gangfun/gang-launchpad/skill
-```
+Skill：`npx skills add gangfun/gang-launchpad/skill`
 
 ## 准备
 
-1. Binance App → 钱包 → Agentic Wallet → 创建；领取 `.ai` Agent ID。
-2. 打开 **Developer Mode** 和 **Trade all tokens**。
-3. `baw auth signin`，在 App 确认。
-4. `gang preflight`
+1. 币安 App → 钱包 → Agentic Wallet；领取 `.ai` Agent ID。
+2. 打开 **Developer Mode** 与 **Trade all tokens**。
+3. `baw auth signin`
+4. `gang preflight` — `createPad` 须为 LaunchpadV2。
 
 ## 命令
 
@@ -61,27 +33,45 @@ gang token --token <addr>
 gang quote --token <addr> --bnb <n>
 gang buy --token <addr> --bnb <n> [--slippage 1]
 gang sell --token <addr> (--amount <tokens> | --all) [--slippage 1]
-gang create --name <n> --symbol <s>
+gang upload-logo --file ./avatar.png
+gang create --name <n> --symbol <s> [--logo-uri URL | --logo ./avatar.png] [--taxed] [--pair-or-quote 0x…]
 gang execute --request-id <id>
 gang tx --hash <0x..>
 ```
 
-买 / 卖 / 发币：**预览 → 你确认 → execute**。`requestId` 约 5 分钟过期。卖出可能要在 App 里点确认。
+### Logo + 发币
+
+站内：https://gang.fun/dev/logo
+
+```bash
+gang upload-logo --file ./avatar.png
+gang create --name "My Agent Coin" --symbol MAC --logo-uri https://gang.fun/api/logos/<id>.png
+gang execute --request-id …
+
+# 或一步上传
+gang create --name "My Agent Coin" --symbol MAC --logo ./avatar.png
+gang execute --request-id …
+```
+
+## Quote 路径
+
+- Soft 存量：链上 `quoteBuy` / `quoteSell`。
+- **LaunchpadV2：** 唯一路径 = 合约 `LaunchpadV2.sol` 曲线公式（`_prepBuy` / `_tokensOut` / `_quoteOut`），无 Soft/U/S create/quote fallback；输出 `quotePath` + `deterministic: true`。
 
 ## 规则（短）
 
-- 内盘每钱包 1% 上限；多付的 BNB 同笔退回。
-- 筹满 20 BNB → 毕业到 PancakeSwap V2，LP 销毁。
-- 毕业前不可转账，只能走曲线。
-- 已毕业：去 PancakeSwap（`gang token` 里的 `pair`）。
+- 内盘每钱包 1%；多付同笔退回。
+- **新**发币 ≈15 BNB 毕业（LaunchpadV2）。Soft 存量归档：20 BNB，仅买卖。
+- 毕业前不可转账；毕业后走 PancakeSwap。
 
 ## 环境变量
 
 | 变量 | 含义 |
 |---|---|
-| `GANG_LAUNCHPAD` | Launchpad 地址（默认 v4.1 `0x315Ba2e8952D06094CC636b2B84229FA32fb23A7`；可用环境变量覆盖） |
-| `GANG_RPC_URL` | BSC HTTP RPC |
+| `GANG_LAUNCHPAD` | 发币目标（默认 V2） |
+| `GANG_RPC_URL` | BSC RPC |
+| `GANG_LOGO_API` | Logo 上传 API（默认 `https://gang.fun/api/logos`） |
 
 ## 版本
 
-`0.1.3` · 仓库 [gangfun/cli](https://github.com/gangfun/cli) · 分发走 [GitHub Packages](https://github.com/gangfun/cli/pkgs/npm/cli)（不上 npmjs）
+`0.2.1` · [gangfun/cli](https://github.com/gangfun/cli)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gangfun/cli",
-  "version": "0.1.4",
-  "description": "Gang launchpad CLI for Binance Agentic Wallet agents: list, quote, buy, sell, create on the agent-only bonding curve.",
+  "version": "0.2.1",
+  "description": "Gang launchpad CLI (LaunchpadV2-only create + legacy Soft/U/S trade) for Binance Agentic Wallet agents.",
   "type": "module",
   "bin": {
     "gang": "./src/index.js"

package/src/abi.js

@@ -1,8 +1,7 @@
-export const LAUNCHPAD_ABI = [
+/** Soft / legacy BNB-payable pad (create archived; buy/sell/claim only). */
+export const SOFT_ABI = [
   { type: 'function', name: 'create', stateMutability: 'nonpayable', inputs: [{ name: 'name', type: 'string' }, { name: 'symbol', type: 'string' }], outputs: [{ type: 'address' }] },
   { type: 'function', name: 'buy', stateMutability: 'payable', inputs: [{ name: 'token', type: 'address' }, { name: 'minTokensOut', type: 'uint256' }], outputs: [{ type: 'uint256' }] },
-  { type: 'function', name: 'withdraw', stateMutability: 'nonpayable', inputs: [], outputs: [] },
-  { type: 'function', name: 'pendingWithdrawals', stateMutability: 'view', inputs: [{ type: 'address' }], outputs: [{ type: 'uint256' }] },
   { type: 'function', name: 'sell', stateMutability: 'nonpayable', inputs: [{ name: 'token', type: 'address' }, { name: 'tokensIn', type: 'uint256' }, { name: 'minBnbOut', type: 'uint256' }], outputs: [{ type: 'uint256' }] },
   { type: 'function', name: 'quoteBuy', stateMutability: 'view', inputs: [{ name: 'token', type: 'address' }, { name: 'buyer', type: 'address' }, { name: 'bnbGross', type: 'uint256' }], outputs: [{ name: 'tokensOut', type: 'uint256' }, { name: 'bnbIn', type: 'uint256' }, { name: 'fee', type: 'uint256' }, { name: 'refund', type: 'uint256' }] },
   { type: 'function', name: 'quoteSell', stateMutability: 'view', inputs: [{ name: 'token', type: 'address' }, { name: 'tokensIn', type: 'uint256' }], outputs: [{ name: 'bnbToUser', type: 'uint256' }, { name: 'fee', type: 'uint256' }] },
@@ -20,11 +19,54 @@ export const LAUNCHPAD_ABI = [
   { type: 'event', name: 'Graduated', inputs: [{ name: 'token', type: 'address', indexed: true }, { name: 'pair', type: 'address', indexed: true }, { name: 'tokenAmount', type: 'uint256', indexed: false }, { name: 'bnbAmount', type: 'uint256', indexed: false }] },
 ]
 
+/** LaunchpadV2 (+ U/S-shaped quote pads): create with logoURI; buy/sell take quote ERC-20. */
+export const V2_ABI = [
+  { type: 'function', name: 'create', stateMutability: 'nonpayable', inputs: [{ name: 'name', type: 'string' }, { name: 'symbol', type: 'string' }, { name: 'logoURI', type: 'string' }, { name: 'taxed', type: 'bool' }, { name: 'pairOrQuote', type: 'address' }], outputs: [{ type: 'address' }] },
+  { type: 'function', name: 'buy', stateMutability: 'nonpayable', inputs: [{ name: 'token', type: 'address' }, { name: 'quoteIn', type: 'uint256' }, { name: 'minTokensOut', type: 'uint256' }], outputs: [{ type: 'uint256' }] },
+  { type: 'function', name: 'sell', stateMutability: 'nonpayable', inputs: [{ name: 'token', type: 'address' }, { name: 'tokensIn', type: 'uint256' }, { name: 'minQuoteOut', type: 'uint256' }], outputs: [{ type: 'uint256' }] },
+  { type: 'function', name: 'curves', stateMutability: 'view', inputs: [{ name: 'token', type: 'address' }], outputs: [
+    { name: 'creator', type: 'address' }, { name: 'quote', type: 'address' }, { name: 'realQuote', type: 'uint128' }, { name: 'sold', type: 'uint128' },
+    { name: 'gradAmt', type: 'uint128' }, { name: 'virtualQuote', type: 'uint128' }, { name: 'graduated', type: 'bool' }, { name: 'taxed', type: 'bool' },
+    { name: 'pair', type: 'address' }, { name: 'refPair', type: 'address' },
+  ] },
+  { type: 'function', name: 'allTokens', stateMutability: 'view', inputs: [{ type: 'uint256' }], outputs: [{ type: 'address' }] },
+  { type: 'function', name: 'tokenCount', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+  { type: 'function', name: 'isAgent', stateMutability: 'view', inputs: [{ name: 'account', type: 'address' }], outputs: [{ type: 'bool' }] },
+  { type: 'function', name: 'walletRoom', stateMutability: 'view', inputs: [{ name: 'token', type: 'address' }, { name: 'buyer', type: 'address' }], outputs: [{ type: 'uint256' }] },
+  { type: 'function', name: 'MAX_PER_WALLET', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+  { type: 'function', name: 'TARGET_GRAD_BNB', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+  { type: 'function', name: 'logoURIOf', stateMutability: 'view', inputs: [{ type: 'address' }], outputs: [{ type: 'string' }] },
+  { type: 'event', name: 'Created', inputs: [
+    { name: 'token', type: 'address', indexed: true }, { name: 'creator', type: 'address', indexed: true },
+    { name: 'name', type: 'string', indexed: false }, { name: 'symbol', type: 'string', indexed: false },
+    { name: 'logoURI', type: 'string', indexed: false }, { name: 'taxed', type: 'bool', indexed: false },
+    { name: 'quote', type: 'address', indexed: true }, { name: 'refPair', type: 'address', indexed: false }, { name: 'gradAmt', type: 'uint256', indexed: false },
+  ] },
+  { type: 'event', name: 'Buy', inputs: [
+    { name: 'token', type: 'address', indexed: true }, { name: 'buyer', type: 'address', indexed: true },
+    { name: 'quoteIn', type: 'uint256', indexed: false }, { name: 'taxDividend', type: 'uint256', indexed: false },
+    { name: 'taxPlatform', type: 'uint256', indexed: false }, { name: 'tokensOut', type: 'uint256', indexed: false }, { name: 'realQuote', type: 'uint256', indexed: false },
+  ] },
+  { type: 'event', name: 'Sell', inputs: [
+    { name: 'token', type: 'address', indexed: true }, { name: 'seller', type: 'address', indexed: true },
+    { name: 'tokensIn', type: 'uint256', indexed: false }, { name: 'taxDividend', type: 'uint256', indexed: false },
+    { name: 'taxPlatform', type: 'uint256', indexed: false }, { name: 'quoteOut', type: 'uint256', indexed: false }, { name: 'realQuote', type: 'uint256', indexed: false },
+  ] },
+  { type: 'event', name: 'Graduated', inputs: [
+    { name: 'token', type: 'address', indexed: true }, { name: 'pair', type: 'address', indexed: true },
+    { name: 'quote', type: 'address', indexed: false }, { name: 'tokenAmount', type: 'uint256', indexed: false }, { name: 'quoteAmount', type: 'uint256', indexed: false },
+  ] },
+]
+
 export const ERC20_ABI = [
   { type: 'function', name: 'name', stateMutability: 'view', inputs: [], outputs: [{ type: 'string' }] },
   { type: 'function', name: 'symbol', stateMutability: 'view', inputs: [], outputs: [{ type: 'string' }] },
+  { type: 'function', name: 'decimals', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint8' }] },
   { type: 'function', name: 'balanceOf', stateMutability: 'view', inputs: [{ type: 'address' }], outputs: [{ type: 'uint256' }] },
   { type: 'function', name: 'allowance', stateMutability: 'view', inputs: [{ type: 'address' }, { type: 'address' }], outputs: [{ type: 'uint256' }] },
   { type: 'function', name: 'approve', stateMutability: 'nonpayable', inputs: [{ type: 'address' }, { type: 'uint256' }], outputs: [{ type: 'bool' }] },
   { type: 'function', name: 'locked', stateMutability: 'view', inputs: [], outputs: [{ type: 'bool' }] },
 ]
+
+/** @deprecated alias kept for older imports */
+export const LAUNCHPAD_ABI = V2_ABI

package/src/chain.js

@@ -1,89 +1,280 @@
-import { createPublicClient, http, formatEther, parseEther, encodeFunctionData, decodeEventLog } from 'viem'
+import { createPublicClient, http, formatEther, parseEther, encodeFunctionData, decodeEventLog, zeroAddress } from 'viem'
 import { bsc } from 'viem/chains'
-import { LAUNCHPAD_ABI, ERC20_ABI } from './abi.js'
+import { SOFT_ABI, V2_ABI, ERC20_ABI } from './abi.js'
+
+export const ADDR = {
+  v2: '0x1B8F3f69DFa0a7F63d308C7EB0Fd38D8b099966E',
+  soft: '0x4E6f13c8A453c1b8b4E20b590082bb233a5b80d7',
+  u: '0xF81C4E51c48466c6025B0165b1Ea0F6978c712cb',
+  s: '0x60aee38576035E757deD30fF8db8A8DA476430C1',
+  wbnb: '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c',
+}
+
+const FORBIDDEN_CREATE = new Set([ADDR.soft, ADDR.u, ADDR.s].map((a) => a.toLowerCase()))
 
 export const CONFIG = {
   rpc: process.env.GANG_RPC_URL || 'https://bsc-dataseed.binance.org',
-  launchpad: process.env.GANG_LAUNCHPAD || '0x315Ba2e8952D06094CC636b2B84229FA32fb23A7',
+  launchpad: process.env.GANG_LAUNCHPAD || ADDR.v2,
   chainId: '56',
 }
 
 export const client = createPublicClient({ chain: bsc, transport: http(CONFIG.rpc) })
-const pad = (functionName, args = []) => client.readContract({ address: CONFIG.launchpad, abi: LAUNCHPAD_ABI, functionName, args })
-const erc = (address, functionName, args = []) => client.readContract({ address, abi: ERC20_ABI, functionName, args })
-
 export const fmt = (wei) => formatEther(wei)
 export const fmtTok = (units) => Number(formatEther(units)).toLocaleString('en-US', { maximumFractionDigits: 2 })
-export { parseEther, encodeFunctionData }
+export { parseEther, encodeFunctionData, zeroAddress }
 
-export async function tokenInfo(token, me) {
-  const [c, name, symbol, locked, grad, cap] = await Promise.all([
-    pad('curves', [token]), erc(token, 'name'), erc(token, 'symbol'), erc(token, 'locked'),
-    pad('GRADUATION_BNB'), pad('MAX_PER_WALLET'),
-  ])
-  const [creator, realBnb, sold, graduated, pair] = c
-  if (creator === '0x0000000000000000000000000000000000000000') {
+const erc = (address, functionName, args = []) => client.readContract({ address, abi: ERC20_ABI, functionName, args })
+const read = (address, abi, functionName, args = []) => client.readContract({ address, abi, functionName, args })
+
+export function assertCreateTarget(addr = CONFIG.launchpad) {
+  const a = String(addr || '').toLowerCase()
+  if (a !== ADDR.v2.toLowerCase()) {
     throw new Error(
-      `not a Gang token: ${token} (launchpad ${CONFIG.launchpad}). ` +
-      `Upgrade: npm i -g @gangfun/cli@0.1.3 --registry=https://npm.pkg.github.com  OR  ` +
-      `export GANG_LAUNCHPAD=0x315Ba2e8952D06094CC636b2B84229FA32fb23A7`
+      `create refused: only LaunchpadV2 ${ADDR.v2} (got ${addr}). ` +
+      `Soft/LaunchpadU/LaunchpadS are not create routes — buy/sell/claim existing only. ` +
+      `Unset GANG_LAUNCHPAD or set it to V2.`,
     )
   }
-  // curve end price (1e-7 BNB) for graduated tokens; live spot otherwise
-  const price = graduated ? 100000000000n : await pad('spotPrice', [token])
+}
+
+const PADS = [
+  { id: 'v2', address: ADDR.v2, kind: 'v2', abi: V2_ABI },
+  { id: 'soft', address: ADDR.soft, kind: 'soft', abi: SOFT_ABI },
+  { id: 'u', address: ADDR.u, kind: 'v2', abi: V2_ABI },
+  { id: 's', address: ADDR.s, kind: 'v2', abi: V2_ABI },
+]
+
+/** Resolve which pad hosts `token` by probing curves(token).creator != 0. */
+export async function resolvePad(token) {
+  for (const pad of PADS) {
+    try {
+      const c = await read(pad.address, pad.abi, 'curves', [token])
+      const creator = Array.isArray(c) ? c[0] : c.creator
+      if (creator && creator !== zeroAddress) {
+        return { ...pad, curve: c }
+      }
+    } catch { /* wrong ABI shape or empty */ }
+  }
+  throw new Error(
+    `not a Gang token on known pads (V2/Soft/U/S): ${token}. ` +
+    `Upgrade: npm i -g @gangfun/cli@0.2.1 --registry=https://npm.pkg.github.com  OR  npm i -g github:gangfun/cli`,
+  )
+}
+
+function softInfoFromCurve(c) {
+  const [creator, realBnb, sold, graduated, pair] = c
+  return { kind: 'soft', creator, raised: realBnb, sold, graduated, pair, quote: ADDR.wbnb, gradAmt: null, taxed: false, virtualQuote: null, refPair: null }
+}
+
+function v2InfoFromCurve(c) {
+  const [creator, quote, realQuote, sold, gradAmt, virtualQuote, graduated, taxed, pair, refPair] = c
+  return { kind: 'v2', creator, raised: realQuote, sold, graduated, pair, quote, gradAmt, taxed, virtualQuote, refPair }
+}
+
+export async function tokenInfo(token, me) {
+  const pad = await resolvePad(token)
+  const base = pad.kind === 'soft' ? softInfoFromCurve(pad.curve) : v2InfoFromCurve(pad.curve)
+  const [name, symbol] = await Promise.all([erc(token, 'name'), erc(token, 'symbol')])
+  let locked = null
+  try { locked = await erc(token, 'locked') } catch { /* */ }
+  let cap = null
+  try { cap = await read(pad.address, pad.abi, 'MAX_PER_WALLET') } catch { /* */ }
+
+  let price = null
+  if (pad.kind === 'soft') {
+    try { price = base.graduated ? 100000000000n : await read(pad.address, pad.abi, 'spotPrice', [token]) } catch { /* */ }
+  } else if (base.virtualQuote && base.virtualQuote > 0n) {
+    // spot ≈ virtualQuote / (VIRTUAL_TOKEN - sold) * 1e18-ish; expose raised/grad instead
+    const vq = BigInt(base.virtualQuote)
+    const sold = BigInt(base.sold)
+    const VIRTUAL_TOKEN = 1066666666666666666666666667n
+    const tReserve = VIRTUAL_TOKEN - sold
+    if (tReserve > 0n) price = (vq * 10n ** 18n) / tReserve
+  }
+
+  const grad = base.gradAmt != null ? BigInt(base.gradAmt) : (pad.kind === 'soft' ? await read(pad.address, pad.abi, 'GRADUATION_BNB') : 15n * 10n ** 18n)
+  const raised = BigInt(base.raised)
   const info = {
-    token, name, symbol, creator, graduated, pair: graduated ? pair : null, locked,
-    priceBnb: Number(price) / 1e18,
-    fdvBnb: (Number(price) / 1e18) * 1e9,
-    raisedBnb: fmt(realBnb), graduationBnb: fmt(grad),
-    progressPct: Number((realBnb * 10000n) / grad) / 100,
-    soldTokens: fmtTok(sold), walletCapTokens: fmtTok(cap),
+    token, name, symbol, creator: base.creator, graduated: base.graduated,
+    pair: base.graduated ? base.pair : null, locked,
+    pad: pad.id, padAddress: pad.address, kind: base.kind,
+    quote: base.quote, taxed: !!base.taxed,
+    priceBnb: price != null ? Number(price) / 1e18 : null,
+    fdvBnb: price != null ? (Number(price) / 1e18) * 1e9 : null,
+    raisedBnb: fmt(raised), graduationBnb: fmt(grad),
+    progressPct: grad > 0n ? Number((raised * 10000n) / grad) / 100 : 0,
+    soldTokens: fmtTok(base.sold), walletCapTokens: cap != null ? fmtTok(cap) : null,
+    logoURI: null,
+  }
+  if (pad.kind === 'v2') {
+    try { info.logoURI = await read(pad.address, pad.abi, 'logoURIOf', [token]) } catch { /* U/S may lack */ }
   }
   if (me) {
-    const [bal, room] = await Promise.all([erc(token, 'balanceOf', [me]), pad('walletRoom', [token, me])])
-    info.myBalance = fmtTok(bal); info.myBalanceRaw = bal.toString(); info.myRoomTokens = fmtTok(room); info.myRoomRaw = room.toString()
+    const bal = await erc(token, 'balanceOf', [me])
+    info.myBalance = fmtTok(bal); info.myBalanceRaw = bal.toString()
+    try {
+      const room = await read(pad.address, pad.abi, 'walletRoom', [token, me])
+      info.myRoomTokens = fmtTok(room); info.myRoomRaw = room.toString()
+    } catch { /* */ }
   }
   return info
 }
 
 export async function listTokens(me) {
-  const n = await pad('tokenCount')
-  const addrs = await Promise.all(Array.from({ length: Number(n) }, (_, i) => pad('allTokens', [BigInt(i)])))
-  return Promise.all(addrs.map((a) => tokenInfo(a, me)))
+  const out = []
+  for (const pad of PADS) {
+    try {
+      const n = await read(pad.address, pad.abi, 'tokenCount')
+      const addrs = await Promise.all(Array.from({ length: Number(n) }, (_, i) => read(pad.address, pad.abi, 'allTokens', [BigInt(i)])))
+      for (const a of addrs) {
+        try { out.push(await tokenInfo(a, me)) } catch { /* skip */ }
+      }
+    } catch { /* pad down */ }
+  }
+  return out
 }
 
-export async function quoteBuy(token, buyer, bnb) {
-  const gross = parseEther(bnb)
-  const [tokensOut, bnbIn, fee, refund] = await pad('quoteBuy', [token, buyer, gross])
-  return { bnbGross: bnb, tokensOut, bnbIn, fee, refund, tokensOutFmt: fmtTok(tokensOut), bnbInFmt: fmt(bnbIn), feeFmt: fmt(fee), refundFmt: fmt(refund) }
+/** LaunchpadV2 curve constants (LaunchpadV2.sol) — unique off-chain path = on-chain math. */
+const V2_VIRTUAL_TOKEN = 1066666666666666666666666667n
+const V2_BPS = 10000n
+const V2_PROTOCOL_FEE_BPS = 100n // 1%
+
+const ceilDiv = (a, b) => (b === 0n ? 0n : (a + b - 1n) / b)
+
+/** Contract-equivalent buy quote (_prepBuy + _tokensOut / _quoteInFor). No Soft/U/S fallback. */
+function v2QuoteBuyFromCurve(base, quoteIn, room) {
+  const vq = BigInt(base.virtualQuote)
+  const sold = BigInt(base.sold)
+  const raised = BigInt(base.raised)
+  const gradAmt = BigInt(base.gradAmt)
+  const tokensOutOf = (net) => {
+    const k = vq * V2_VIRTUAL_TOKEN
+    const qReserve = vq + raised
+    const tReserve = V2_VIRTUAL_TOKEN - sold
+    const newT = ceilDiv(k, qReserve + net)
+    return tReserve - newT
+  }
+  const quoteInFor = (tokensOut) => {
+    const k = vq * V2_VIRTUAL_TOKEN
+    const qReserve = vq + raised
+    const tReserve = V2_VIRTUAL_TOKEN - sold
+    return ceilDiv(k, tReserve - tokensOut) - qReserve
+  }
+  const recomputeFee = (gross, netIn) => {
+    let spentGross = ceilDiv(netIn * V2_BPS, V2_BPS - V2_PROTOCOL_FEE_BPS)
+    if (spentGross > gross) spentGross = gross
+    const taxPlat = (spentGross * V2_PROTOCOL_FEE_BPS) / V2_BPS
+    const net = spentGross - taxPlat
+    const refundGross = gross - spentGross
+    return { taxPlat, net, refundGross, spentGross }
+  }
+
+  let taxPlat = (quoteIn * V2_PROTOCOL_FEE_BPS) / V2_BPS
+  let net = quoteIn - taxPlat
+  let refundGross = 0n
+  const remaining = gradAmt > raised ? gradAmt - raised : 0n
+  if (net > remaining) {
+    net = remaining
+    ;({ taxPlat, net, refundGross } = recomputeFee(quoteIn, net))
+    if (net > remaining) net = remaining
+  }
+  let tokensOut = tokensOutOf(net)
+  if (room != null && tokensOut > room) {
+    tokensOut = room
+    net = quoteInFor(room)
+    ;({ taxPlat, net, refundGross } = recomputeFee(quoteIn, net))
+  }
+  return { tokensOut, spent: quoteIn - refundGross, fee: taxPlat, refund: refundGross }
+}
+
+/** Contract-equivalent sell quote (_quoteOut + 1% platform fee). */
+function v2QuoteSellFromCurve(base, tokensIn) {
+  const vq = BigInt(base.virtualQuote)
+  const sold = BigInt(base.sold)
+  const raised = BigInt(base.raised)
+  const k = vq * V2_VIRTUAL_TOKEN
+  const qReserve = vq + raised
+  const tReserve = V2_VIRTUAL_TOKEN - sold
+  const newQ = ceilDiv(k, tReserve + tokensIn)
+  const quoteOut = qReserve - newQ
+  const fee = (quoteOut * V2_PROTOCOL_FEE_BPS) / V2_BPS
+  return { out: quoteOut - fee, fee }
+}
+
+export async function quoteBuy(token, buyer, amountHuman) {
+  const pad = await resolvePad(token)
+  const gross = parseEther(amountHuman)
+  if (pad.kind === 'soft') {
+    const [tokensOut, bnbIn, fee, refund] = await read(pad.address, pad.abi, 'quoteBuy', [token, buyer, gross])
+    return { kind: 'soft', pad: pad.id, padAddress: pad.address, amountHuman, tokensOut, spent: bnbIn, fee, refund,
+      tokensOutFmt: fmtTok(tokensOut), spentFmt: fmt(bnbIn), feeFmt: fmt(fee), refundFmt: fmt(refund), unit: 'BNB',
+      quotePath: 'onchain-quoteBuy' }
+  }
+  // Unique path: LaunchpadV2.sol _prepBuy / _tokensOut / _quoteInFor (no on-chain quoteBuy view).
+  const base = v2InfoFromCurve(pad.curve)
+  let room = null
+  try { room = await read(pad.address, pad.abi, 'walletRoom', [token, buyer]) } catch { /* */ }
+  const q = v2QuoteBuyFromCurve(base, gross, room)
+  return { kind: 'v2', pad: pad.id, padAddress: pad.address, quote: base.quote, amountHuman,
+    tokensOut: q.tokensOut, spent: q.spent, fee: q.fee, refund: q.refund,
+    tokensOutFmt: fmtTok(q.tokensOut), spentFmt: fmt(q.spent), feeFmt: fmt(q.fee), refundFmt: fmt(q.refund),
+    unit: 'quote', quotePath: 'LaunchpadV2.sol#_prepBuy', deterministic: true }
 }
 
 export async function quoteSell(token, tokensIn) {
-  const [bnbToUser, fee] = await pad('quoteSell', [token, tokensIn])
-  return { tokensIn, bnbToUser, fee, tokensInFmt: fmtTok(tokensIn), bnbToUserFmt: fmt(bnbToUser), feeFmt: fmt(fee) }
+  const pad = await resolvePad(token)
+  if (pad.kind === 'soft') {
+    const [bnbToUser, fee] = await read(pad.address, pad.abi, 'quoteSell', [token, tokensIn])
+    return { kind: 'soft', pad: pad.id, padAddress: pad.address, tokensIn, out: bnbToUser, fee,
+      tokensInFmt: fmtTok(tokensIn), outFmt: fmt(bnbToUser), feeFmt: fmt(fee), unit: 'BNB',
+      quotePath: 'onchain-quoteSell' }
+  }
+  const base = v2InfoFromCurve(pad.curve)
+  const q = v2QuoteSellFromCurve(base, tokensIn)
+  return { kind: 'v2', pad: pad.id, padAddress: pad.address, quote: base.quote, tokensIn, out: q.out, fee: q.fee,
+    tokensInFmt: fmtTok(tokensIn), outFmt: fmt(q.out), feeFmt: fmt(q.fee), unit: 'quote',
+    quotePath: 'LaunchpadV2.sol#_quoteOut', deterministic: true }
+}
+
+export async function isAgent(account) {
+  // Prefer V2 gate (create path); fall back Soft.
+  try { return await read(ADDR.v2, V2_ABI, 'isAgent', [account]) } catch { /* */ }
+  try { return await read(ADDR.soft, SOFT_ABI, 'isAgent', [account]) } catch { /* */ }
+  return false
 }
 
-export const isAgent = (a) => pad('isAgent', [a])
 export const balanceOf = (token, a) => erc(token, 'balanceOf', [a])
-export const allowance = (token, a) => erc(token, 'allowance', [a, CONFIG.launchpad])
+export async function allowance(token, owner, spender) {
+  return erc(token, 'allowance', [owner, spender])
+}
 
 export const calldata = {
-  buy: (token, minTokensOut) => encodeFunctionData({ abi: LAUNCHPAD_ABI, functionName: 'buy', args: [token, minTokensOut] }),
-  sell: (token, tokensIn, minBnbOut) => encodeFunctionData({ abi: LAUNCHPAD_ABI, functionName: 'sell', args: [token, tokensIn, minBnbOut] }),
-  approve: (amount) => encodeFunctionData({ abi: ERC20_ABI, functionName: 'approve', args: [CONFIG.launchpad, amount] }),
-  create: (name, symbol) => encodeFunctionData({ abi: LAUNCHPAD_ABI, functionName: 'create', args: [name, symbol] }),
+  softBuy: (token, minTokensOut) => encodeFunctionData({ abi: SOFT_ABI, functionName: 'buy', args: [token, minTokensOut] }),
+  softSell: (token, tokensIn, minBnbOut) => encodeFunctionData({ abi: SOFT_ABI, functionName: 'sell', args: [token, tokensIn, minBnbOut] }),
+  v2Buy: (token, quoteIn, minTokensOut) => encodeFunctionData({ abi: V2_ABI, functionName: 'buy', args: [token, quoteIn, minTokensOut] }),
+  v2Sell: (token, tokensIn, minQuoteOut) => encodeFunctionData({ abi: V2_ABI, functionName: 'sell', args: [token, tokensIn, minQuoteOut] }),
+  approve: (spender, amount) => encodeFunctionData({ abi: ERC20_ABI, functionName: 'approve', args: [spender, amount] }),
+  createV2: (name, symbol, logoURI, taxed, pairOrQuote) =>
+    encodeFunctionData({ abi: V2_ABI, functionName: 'create', args: [name, symbol, logoURI, taxed, pairOrQuote] }),
 }
 
 export async function decodeTx(hash) {
   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) {
-    if (log.address.toLowerCase() !== CONFIG.launchpad.toLowerCase()) continue
+    const pad = known.get(log.address.toLowerCase())
+    if (!pad) continue
     try {
-      const ev = decodeEventLog({ abi: LAUNCHPAD_ABI, data: log.data, topics: log.topics })
-      const a = Object.fromEntries(Object.entries(ev.args).map(([k, v]) => [k, typeof v === 'bigint' ? (k.toLowerCase().includes('token') && k !== 'token' ? fmtTok(v) : fmt(v)) : v]))
-      events.push({ event: ev.eventName, ...a })
-    } catch { /* not ours */ }
+      const ev = decodeEventLog({ abi: pad.abi, data: log.data, topics: log.topics })
+      const a = Object.fromEntries(Object.entries(ev.args).map(([k, v]) => {
+        if (typeof v !== 'bigint') return [k, v]
+        const lk = k.toLowerCase()
+        if (lk.includes('token') && k !== 'token' && !lk.includes('amount')) return [k, fmtTok(v)]
+        return [k, fmt(v)]
+      }))
+      events.push({ event: ev.eventName, pad: pad.id, ...a })
+    } catch { /* */ }
   }
   return { hash, status: r.status, block: Number(r.blockNumber), events }
 }

package/src/index.js

@@ -1,6 +1,10 @@
 #!/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'
 
 const args = process.argv.slice(2)
 const cmd = args[0]
@@ -15,19 +19,22 @@ const parseSlippage = (raw) => {
   return s
 }
 
-const HELP = `gang — agent-only launchpad on BNB Chain (Binance Agentic Wallet)
+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 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`
 
 function summarizePreview(p, extra = {}) {
   if (!p.success) return { success: false, step: extra.step, error: p.error }
@@ -43,6 +50,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 +74,18 @@ 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 'token': {
       const token = opt('token'); if (!token) fail('--token required')
@@ -69,10 +93,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 +112,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 +156,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 +213,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 }
+}