blumefi 2.1.0 → 2.3.0

package/README.md

@@ -1,6 +1,6 @@
 # BlumeFi CLI
 
-DeFi reimagined for the agentic era. Trade, swap, chat, and interact with the Blume ecosystem from the command line.
+DeFi reimagined for the agentic era. Launch tokens, trade perps, swap, and chat — all from the command line.
 
 ## Quick Start
 
@@ -11,25 +11,47 @@ npx blumefi wallet new
 # Get testnet gas
 npx blumefi faucet 0xYOUR_ADDRESS
 
-# Set your name
 export WALLET_PRIVATE_KEY=0x...
-npx blumefi chat profile "MyAgent"
 
-# Post a message
-npx blumefi chat post "Hello from the CLI!"
+# Launch a token
+npx blumefi pad launch "Moon Cat" MCAT "The first cat on the moon"
 
-# Read the feed
-npx blumefi chat feed
+# Buy tokens on bonding curve
+npx blumefi pad buy 0xTOKEN_ADDRESS 10
 
-# Swap tokens
+# Swap on DEX
 npx blumefi swap 1 XRP 0xTOKEN_ADDRESS
 
 # Open a leveraged trade
 npx blumefi trade long 100 5x
+
+# Chat with agents
+npx blumefi chat post "Hello from the CLI!"
 ```
 
 ## Commands
 
+### Pad (Launchpad)
+
+```bash
+blumefi pad launch <name> <symbol> [desc]   # Launch a token on bonding curve
+blumefi pad buy <token> <xrp_amount>        # Buy tokens with XRP
+blumefi pad sell <token> <amount|all>        # Sell tokens for XRP
+blumefi pad info <token>                     # View token info and progress
+blumefi pad search <query>                   # Search tokens by name or symbol
+blumefi pad tokens                           # List recent tokens
+```
+
+**Launch options:**
+```bash
+--image <url>           # Image URI (e.g. arweave URL)
+--supply <amount>       # Total supply (default: 1B)
+--dev-pct <0-10>        # Dev allocation % (default: 0)
+--grad <xrp>            # Graduation reserve in XRP (default: 500)
+```
+
+Tokens trade on a bonding curve until the reserve hits the graduation target, then liquidity is auto-seeded on BlumeSwap DEX.
+
 ### Chat
 
 ```bash
@@ -49,13 +71,6 @@ blumefi swap quote <amount> <from> <to>  # Get a quote without executing
 blumefi swap pools                       # List available pools
 ```
 
-**Examples:**
-```bash
-blumefi swap 1 XRP 0xe882...ecf3         # Swap 1 XRP for TULIP token
-blumefi swap 100 0xe882...ecf3 XRP       # Swap tokens back to XRP
-blumefi swap quote 5 XRP 0xe882...ecf3   # Quote only, no execution
-```
-
 Tokens: `XRP`, `WXRP`, `RLUSD`, or any `0x` token address.
 
 ### Trade (Perps — testnet only)
@@ -70,12 +85,13 @@ blumefi trade price                      # Get current XRP price
 
 Collateral is in RLUSD. Default leverage is 2x if not specified.
 
-### Wallet & Network
+### Wallet & Account
 
 ```bash
 blumefi wallet new          # Generate a new wallet
+blumefi balance [address]   # Show XRP and token balances
 blumefi faucet [address]    # Get 25 testnet XRP
-blumefi status              # Show network info, contracts, and balance
+blumefi status              # Show network info and contracts
 ```
 
 ### Options

package/cli.js

@@ -16,6 +16,7 @@ const NETWORKS = {
     wxrp: '0x7C21a90E3eCD3215d16c3BBe76a491f8f792d4Bf',
     swapRouter: '0x3a5FF5717fCa60b613B28610A8Fd2E13299e306C',
     swapFactory: '0x0F0F367e1C407C28821899E9bd2CB63D6086a945',
+    padFactory: '0x1fCBce3853188adbDDFe8401D461db78DBC875e1',
   },
   testnet: {
     chainId: 1449000,
@@ -26,6 +27,7 @@ const NETWORKS = {
     swapWxrp: '0x664950b1F3E2FAF98286571381f5f4c230ffA9c5', // Swap router uses different WXRP on testnet
     swapRouter: '0xC17E3517131E7444361fEA2083F3309B33a7320A',
     swapFactory: '0xa67Dfa5C47Bec4bBbb06794B933705ADb9E82459',
+    padFactory: '0x726AE28F353aCAF1c8c5787c2478659ba334c4C3',
     perpsRouter: '0x2eDAa73b84Fcc8B403FC4fa10B15458B07560422',
     vault: '0x013C9b57169587c374de63A63DC92bfbc744ef4a',
     priceFeed: '0xBbB98D02Dc2e218e8f864E3667AA699557b62aF9',
@@ -72,6 +74,29 @@ const PRICE_FEED_ABI = [
   { name: 'getPrice', type: 'function', stateMutability: 'view', inputs: [{ name: '_token', type: 'address' }, { name: '_maximise', type: 'bool' }, { name: '_includeSpread', type: 'bool' }], outputs: [{ type: 'uint256' }] },
 ]
 
+const PAD_FACTORY_ABI = [
+  { name: 'createToken', type: 'function', stateMutability: 'payable', inputs: [{ name: 'name', type: 'string' }, { name: 'symbol', type: 'string' }, { name: 'description', type: 'string' }, { name: 'imageURI', type: 'string' }, { name: 'totalSupply', type: 'uint256' }, { name: 'devAllocationBps', type: 'uint256' }, { name: 'graduationReserve', type: 'uint256' }], outputs: [{ type: 'address' }] },
+  { name: 'creationFee', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+  { type: 'event', name: 'TokenCreated', 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 }] },
+]
+
+const PAD_TOKEN_ABI = [
+  { name: 'buy', type: 'function', stateMutability: 'payable', inputs: [{ name: 'minTokensOut', type: 'uint256' }], outputs: [] },
+  { name: 'sell', type: 'function', stateMutability: 'nonpayable', inputs: [{ name: 'tokenAmount', type: 'uint256' }, { name: 'minXrpOut', type: 'uint256' }], outputs: [] },
+  { name: 'getCurrentPrice', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+  { name: 'getTokensForExactXRP', type: 'function', stateMutability: 'view', inputs: [{ name: 'xrpAmount', type: 'uint256' }], outputs: [{ type: 'uint256' }] },
+  { name: 'getSellPrice', type: 'function', stateMutability: 'view', inputs: [{ name: 'tokenAmount', type: 'uint256' }], outputs: [{ type: 'uint256' }] },
+  { name: 'curveSupply', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+  { name: 'reserveBalance', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+  { name: 'graduated', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'bool' }] },
+  { name: 'GRADUATION_RESERVE', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+  { name: 'name', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'string' }] },
+  { name: 'symbol', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'string' }] },
+  { name: 'description', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'string' }] },
+  { name: 'totalSupply', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+  { name: 'balanceOf', type: 'function', stateMutability: 'view', inputs: [{ name: 'account', type: 'address' }], outputs: [{ type: 'uint256' }] },
+]
+
 // ─── Helpers ─────────────────────────────────────────────────────────
 
 function getChain() {
@@ -378,8 +403,16 @@ async function cmdSwap(amountStr, fromToken, toToken) {
   const amountOutMin = amountOut * 99n / 100n
 
   const outFormatted = viem.formatUnits(amountOut, toDecimals)
-  const fromLabel = fromToken.toUpperCase()
-  const toLabel = toToken.toUpperCase()
+
+  // Resolve display labels — show symbol instead of raw address
+  let fromLabel = fromToken.toUpperCase()
+  let toLabel = toToken.toUpperCase()
+  if (fromToken.startsWith('0x')) {
+    try { fromLabel = await readContract({ address: from.address, abi: ERC20_ABI, functionName: 'symbol', args: [] }) } catch {}
+  }
+  if (toToken.startsWith('0x')) {
+    try { toLabel = await readContract({ address: to.address, abi: ERC20_ABI, functionName: 'symbol', args: [] }) } catch {}
+  }
 
   console.log(`\n  Swap: ${amount} ${fromLabel} -> ~${parseFloat(outFormatted).toFixed(6)} ${toLabel}`)
   console.log(`  Network: ${chain}`)
@@ -455,8 +488,17 @@ async function cmdSwapQuote(amountStr, fromToken, toToken) {
   const outFormatted = viem.formatUnits(amountOut, toDecimals)
   const rate = parseFloat(outFormatted) / parseFloat(amountStr)
 
-  console.log(`\n  Quote: ${amountStr} ${fromToken.toUpperCase()} -> ${parseFloat(outFormatted).toFixed(6)} ${toToken.toUpperCase()}`)
-  console.log(`  Rate: 1 ${fromToken.toUpperCase()} = ${rate.toFixed(6)} ${toToken.toUpperCase()}`)
+  let fromLabel = fromToken.toUpperCase()
+  let toLabel = toToken.toUpperCase()
+  if (fromToken.startsWith('0x')) {
+    try { fromLabel = await readContract({ address: from.address, abi: ERC20_ABI, functionName: 'symbol', args: [] }) } catch {}
+  }
+  if (toToken.startsWith('0x')) {
+    try { toLabel = await readContract({ address: to.address, abi: ERC20_ABI, functionName: 'symbol', args: [] }) } catch {}
+  }
+
+  console.log(`\n  Quote: ${amountStr} ${fromLabel} -> ${parseFloat(outFormatted).toFixed(6)} ${toLabel}`)
+  console.log(`  Rate: 1 ${fromLabel} = ${rate.toFixed(6)} ${toLabel}`)
   console.log(`  Network: ${getChain()}`)
   console.log(`\n  Execute: blumefi swap ${amountStr} ${fromToken} ${toToken}`)
 }
@@ -681,6 +723,389 @@ async function cmdTradePosition() {
   }
 }
 
+// ─── Pad commands (launchpad) ────────────────────────────────────────
+
+async function cmdPadLaunch(name, symbol, desc) {
+  if (!name || !symbol) {
+    console.error('Usage: blumefi pad launch <name> <symbol> [description]')
+    console.error('  blumefi pad launch "My Token" MTK "A cool meme token"')
+    console.error('\nOptions:')
+    console.error('  --image <url>           Image URI (e.g. arweave URL)')
+    console.error('  --supply <amount>       Total supply (default: 1000000000)')
+    console.error('  --dev-pct <0-10>        Dev allocation % (default: 0)')
+    console.error('  --grad <xrp>            Graduation reserve in XRP (default: 500)')
+    process.exit(1)
+  }
+
+  const viem = await loadViem()
+  const net = getNetwork()
+  const chain = getChain()
+
+  if (!net.padFactory) {
+    console.error('Error: Pad factory not configured for this network.')
+    process.exit(1)
+  }
+
+  // Parse optional flags
+  const argv = process.argv
+  const imageIdx = argv.indexOf('--image')
+  const imageURI = imageIdx !== -1 ? argv[imageIdx + 1] || '' : ''
+  const supplyIdx = argv.indexOf('--supply')
+  const totalSupply = supplyIdx !== -1
+    ? viem.parseEther(argv[supplyIdx + 1] || '1000000000')
+    : viem.parseEther('1000000000')
+  const devIdx = argv.indexOf('--dev-pct')
+  const devPct = devIdx !== -1 ? parseFloat(argv[devIdx + 1] || '0') : 0
+  const devBps = BigInt(Math.round(devPct * 100)) // 1% = 100 bps
+  const gradIdx = argv.indexOf('--grad')
+  const gradReserve = gradIdx !== -1
+    ? viem.parseEther(argv[gradIdx + 1] || '500')
+    : viem.parseEther('500')
+
+  // Get creation fee
+  const creationFee = await readContract({
+    address: net.padFactory, abi: PAD_FACTORY_ABI, functionName: 'creationFee', args: [],
+  })
+
+  const description = desc || ''
+  const feeXrp = parseFloat(viem.formatEther(creationFee)).toFixed(2)
+
+  console.log(`\n  Launching token on ${chain}`)
+  console.log(`  ─────────────────────────────────────`)
+  console.log(`  Name:        ${name}`)
+  console.log(`  Symbol:      ${symbol}`)
+  if (description) console.log(`  Description: ${description}`)
+  if (imageURI) console.log(`  Image:       ${imageURI}`)
+  console.log(`  Supply:      ${viem.formatEther(totalSupply)}`)
+  console.log(`  Dev alloc:   ${devPct}%`)
+  console.log(`  Grad target: ${viem.formatEther(gradReserve)} XRP`)
+  console.log(`  Fee:         ${feeXrp} XRP`)
+
+  console.log('  Sending transaction...')
+  const { client, account } = await getWalletClient()
+  const data = viem.encodeFunctionData({
+    abi: PAD_FACTORY_ABI,
+    functionName: 'createToken',
+    args: [name, symbol, description, imageURI, totalSupply, devBps, gradReserve],
+  })
+  const hash = await client.sendTransaction({
+    to: net.padFactory, data, gas: 3000000n, value: creationFee,
+  })
+
+  // Wait for receipt to extract token address from event
+  const pub = await getPublicClient()
+  const receipt = await pub.waitForTransactionReceipt({ hash, timeout: 60000 })
+
+  let tokenAddress = null
+  for (const log of receipt.logs) {
+    try {
+      const decoded = viem.decodeEventLog({ abi: PAD_FACTORY_ABI, data: log.data, topics: log.topics })
+      if (decoded.eventName === 'TokenCreated') {
+        tokenAddress = decoded.args.token
+        break
+      }
+    } catch {}
+  }
+
+  console.log(`\n  Token launched!`)
+  if (tokenAddress) console.log(`  Token:   ${tokenAddress}`)
+  console.log(`  TX:      ${net.explorer}/tx/${hash}`)
+  console.log(`  Creator: ${account.address}`)
+  if (tokenAddress) {
+    console.log(`\n  Next steps:`)
+    console.log(`  blumefi pad buy ${tokenAddress} 10     Buy with 10 XRP`)
+    console.log(`  blumefi pad info ${tokenAddress}       View token info`)
+  }
+}
+
+async function cmdPadBuy(tokenAddress, xrpAmountStr) {
+  if (!tokenAddress || !xrpAmountStr) {
+    console.error('Usage: blumefi pad buy <token_address> <xrp_amount>')
+    console.error('  blumefi pad buy 0x1234... 10       Buy tokens with 10 XRP')
+    process.exit(1)
+  }
+
+  const viem = await loadViem()
+  const chain = getChain()
+  const net = getNetwork()
+  const xrpAmount = parseFloat(xrpAmountStr)
+  if (isNaN(xrpAmount) || xrpAmount <= 0) throw new Error('Invalid XRP amount')
+
+  const value = viem.parseEther(xrpAmountStr)
+
+  // Get expected tokens
+  const tokensOut = await readContract({
+    address: tokenAddress, abi: PAD_TOKEN_ABI, functionName: 'getTokensForExactXRP', args: [value],
+  })
+  const [symbol, currentPrice] = await Promise.all([
+    readContract({ address: tokenAddress, abi: PAD_TOKEN_ABI, functionName: 'symbol', args: [] }),
+    readContract({ address: tokenAddress, abi: PAD_TOKEN_ABI, functionName: 'getCurrentPrice', args: [] }),
+  ])
+
+  // 2% slippage on minTokensOut
+  const minTokensOut = tokensOut * 98n / 100n
+  const tokensFormatted = parseFloat(viem.formatEther(tokensOut)).toLocaleString()
+  const priceFormatted = parseFloat(viem.formatEther(currentPrice)).toFixed(10)
+
+  console.log(`\n  Buying ${symbol} on ${chain}`)
+  console.log(`  ─────────────────────────────────────`)
+  console.log(`  Spend:     ${xrpAmount} XRP`)
+  console.log(`  Receive:   ~${tokensFormatted} ${symbol}`)
+  console.log(`  Price:     ${priceFormatted} XRP per token`)
+  console.log(`  Slippage:  2%`)
+
+  console.log('  Sending transaction...')
+  const { hash, address, explorer } = await sendContractTx({
+    to: tokenAddress,
+    abi: PAD_TOKEN_ABI,
+    functionName: 'buy',
+    args: [minTokensOut],
+    value,
+  })
+
+  console.log(`\n  Bought ~${tokensFormatted} ${symbol}`)
+  console.log(`  TX: ${explorer}`)
+}
+
+async function cmdPadSell(tokenAddress, tokenAmountStr) {
+  if (!tokenAddress || !tokenAmountStr) {
+    console.error('Usage: blumefi pad sell <token_address> <token_amount>')
+    console.error('  blumefi pad sell 0x1234... 1000000   Sell 1M tokens')
+    console.error('  blumefi pad sell 0x1234... all       Sell entire balance')
+    process.exit(1)
+  }
+
+  const viem = await loadViem()
+  const chain = getChain()
+  const net = getNetwork()
+  const { account } = await getWalletClient()
+
+  const [symbol, balance] = await Promise.all([
+    readContract({ address: tokenAddress, abi: PAD_TOKEN_ABI, functionName: 'symbol', args: [] }),
+    readContract({ address: tokenAddress, abi: PAD_TOKEN_ABI, functionName: 'balanceOf', args: [account.address] }),
+  ])
+
+  let tokenAmount
+  if (tokenAmountStr.toLowerCase() === 'all') {
+    tokenAmount = balance
+    if (tokenAmount === 0n) { console.log(`\n  No ${symbol} tokens to sell.`); return }
+  } else {
+    tokenAmount = viem.parseEther(tokenAmountStr)
+  }
+
+  if (tokenAmount > balance) {
+    console.error(`Error: Insufficient balance. You have ${parseFloat(viem.formatEther(balance)).toLocaleString()} ${symbol}`)
+    process.exit(1)
+  }
+
+  // Get expected XRP out
+  const xrpOut = await readContract({
+    address: tokenAddress, abi: PAD_TOKEN_ABI, functionName: 'getSellPrice', args: [tokenAmount],
+  })
+
+  // 2% slippage
+  const minXrpOut = xrpOut * 98n / 100n
+  const xrpFormatted = parseFloat(viem.formatEther(xrpOut)).toFixed(4)
+  const tokensFormatted = parseFloat(viem.formatEther(tokenAmount)).toLocaleString()
+
+  console.log(`\n  Selling ${symbol} on ${chain}`)
+  console.log(`  ─────────────────────────────────────`)
+  console.log(`  Sell:      ${tokensFormatted} ${symbol}`)
+  console.log(`  Receive:   ~${xrpFormatted} XRP`)
+  console.log(`  Slippage:  2%`)
+
+  console.log('  Sending transaction...')
+  const { hash, explorer } = await sendContractTx({
+    to: tokenAddress,
+    abi: PAD_TOKEN_ABI,
+    functionName: 'sell',
+    args: [tokenAmount, minXrpOut],
+  })
+
+  console.log(`\n  Sold ${tokensFormatted} ${symbol} for ~${xrpFormatted} XRP`)
+  console.log(`  TX: ${explorer}`)
+}
+
+async function cmdPadInfo(tokenAddress) {
+  if (!tokenAddress) {
+    console.error('Usage: blumefi pad info <token_address>')
+    process.exit(1)
+  }
+
+  const viem = await loadViem()
+  const chain = getChain()
+  const net = getNetwork()
+
+  const [name, symbol, desc, currentPrice, curveSupply, reserveBalance, graduated, gradReserve, totalSupply] = await Promise.all([
+    readContract({ address: tokenAddress, abi: PAD_TOKEN_ABI, functionName: 'name', args: [] }),
+    readContract({ address: tokenAddress, abi: PAD_TOKEN_ABI, functionName: 'symbol', args: [] }),
+    readContract({ address: tokenAddress, abi: PAD_TOKEN_ABI, functionName: 'description', args: [] }),
+    readContract({ address: tokenAddress, abi: PAD_TOKEN_ABI, functionName: 'getCurrentPrice', args: [] }),
+    readContract({ address: tokenAddress, abi: PAD_TOKEN_ABI, functionName: 'curveSupply', args: [] }),
+    readContract({ address: tokenAddress, abi: PAD_TOKEN_ABI, functionName: 'reserveBalance', args: [] }),
+    readContract({ address: tokenAddress, abi: PAD_TOKEN_ABI, functionName: 'graduated', args: [] }),
+    readContract({ address: tokenAddress, abi: PAD_TOKEN_ABI, functionName: 'GRADUATION_RESERVE', args: [] }),
+    readContract({ address: tokenAddress, abi: PAD_TOKEN_ABI, functionName: 'totalSupply', args: [] }),
+  ])
+
+  const priceStr = parseFloat(viem.formatEther(currentPrice)).toFixed(10)
+  const reserveStr = parseFloat(viem.formatEther(reserveBalance)).toFixed(4)
+  const gradStr = parseFloat(viem.formatEther(gradReserve)).toFixed(0)
+  const progressPct = gradReserve > 0n ? Number(reserveBalance * 10000n / gradReserve) / 100 : 0
+  const supplyStr = parseFloat(viem.formatEther(totalSupply)).toLocaleString()
+  const curveStr = parseFloat(viem.formatEther(curveSupply)).toLocaleString()
+
+  console.log(`\n  ${name} (${symbol}) — ${chain}`)
+  console.log(`  ─────────────────────────────────────`)
+  if (desc) console.log(`  ${truncate(desc, 80)}`)
+  console.log(`  Status:      ${graduated ? 'Graduated (DEX)' : 'Bonding Curve'}`)
+  console.log(`  Price:       ${priceStr} XRP`)
+  console.log(`  Reserve:     ${reserveStr} / ${gradStr} XRP (${progressPct.toFixed(1)}%)`)
+  console.log(`  Curve sold:  ${curveStr}`)
+  console.log(`  Total supply: ${supplyStr}`)
+  console.log(`  Contract:    ${tokenAddress}`)
+  console.log(`  Explorer:    ${net.explorer}/address/${tokenAddress}`)
+
+  // Show user balance if wallet is set
+  const key = process.env.WALLET_PRIVATE_KEY || process.env.PRIVATE_KEY
+  if (key) {
+    const k = key.startsWith('0x') ? key : `0x${key}`
+    const account = viem.privateKeyToAccount(k)
+    const userBalance = await readContract({
+      address: tokenAddress, abi: PAD_TOKEN_ABI, functionName: 'balanceOf', args: [account.address],
+    })
+    if (userBalance > 0n) {
+      console.log(`  Your balance: ${parseFloat(viem.formatEther(userBalance)).toLocaleString()} ${symbol}`)
+    }
+  }
+}
+
+async function cmdPadSearch(query) {
+  if (!query) {
+    console.error('Usage: blumefi pad search <name or symbol>')
+    console.error('  blumefi pad search tulip')
+    process.exit(1)
+  }
+
+  const chain = getChain()
+  const q = query.toLowerCase()
+
+  try {
+    const data = await apiFetch(`/pad/tokens?chain=${chain}&limit=50&sort=recent`)
+    const tokens = data.data || data.tokens || data || []
+    if (!Array.isArray(tokens)) { console.log('No tokens found.'); return }
+
+    const matches = tokens.filter(t => {
+      const name = (t.name || '').toLowerCase()
+      const symbol = (t.symbol || '').toLowerCase()
+      return name.includes(q) || symbol.includes(q)
+    })
+
+    if (!matches.length) { console.log(`\n  No tokens matching "${query}" on ${chain}.`); return }
+
+    console.log(`\n  Search: "${query}" on ${chain} — ${matches.length} match${matches.length === 1 ? '' : 'es'}\n`)
+    for (const t of matches) {
+      const name = t.name || '???'
+      const symbol = t.symbol || '???'
+      const graduated = t.graduated ? ' [GRADUATED]' : ''
+      const reserve = t.reserveBalance ? ` ${parseFloat(t.reserveBalance).toFixed(1)} XRP` : ''
+      console.log(`  ${name} (${symbol})${graduated}${reserve}`)
+      console.log(`  ${t.address}`)
+      console.log()
+    }
+  } catch {
+    console.log(`\n  Search not available. Browse: https://${chain === 'mainnet' ? '' : 'testnet.'}pad.blumefi.com`)
+  }
+}
+
+async function cmdPadTokens() {
+  const chain = getChain()
+  try {
+    const data = await apiFetch(`/pad/tokens?chain=${chain}&limit=20&sort=recent`)
+    const tokens = data.data || data.tokens || data || []
+    if (!Array.isArray(tokens) || !tokens.length) { console.log(`No tokens on ${chain} yet.`); return }
+
+    console.log(`\n  Pad Tokens (${chain}) — ${tokens.length} tokens\n`)
+    for (const t of tokens) {
+      const name = t.name || '???'
+      const symbol = t.symbol || '???'
+      const graduated = t.graduated ? ' [GRADUATED]' : ''
+      const reserve = t.reserveBalance ? ` ${parseFloat(t.reserveBalance).toFixed(1)} XRP` : ''
+      console.log(`  ${name} (${symbol})${graduated}${reserve}`)
+      console.log(`  ${t.address}`)
+      console.log()
+    }
+  } catch {
+    // Fallback: if API doesn't have /pad/tokens, just point to the website
+    console.log(`\n  Browse tokens: https://${chain === 'mainnet' ? '' : 'testnet.'}pad.blumefi.com`)
+    console.log(`  API: ${API}/pad/tokens?chain=${chain}`)
+  }
+}
+
+// ─── Balance command ─────────────────────────────────────────────────
+
+async function cmdBalance(address) {
+  const viem = await loadViem()
+  const chain = getChain()
+  const net = getNetwork()
+  const pub = await getPublicClient()
+
+  if (!address) {
+    const key = process.env.WALLET_PRIVATE_KEY || process.env.PRIVATE_KEY
+    if (key) {
+      const k = key.startsWith('0x') ? key : `0x${key}`
+      address = viem.privateKeyToAccount(k).address
+    } else { console.error('Usage: blumefi balance [address]'); process.exit(1) }
+  }
+
+  const xrpBalance = await pub.getBalance({ address })
+  const xrpFormatted = parseFloat(viem.formatEther(xrpBalance)).toFixed(4)
+
+  console.log(`\n  Balances for ${address}`)
+  console.log(`  Network: ${chain}`)
+  console.log(`  ─────────────────────────────────────`)
+  console.log(`  XRP:       ${xrpFormatted}`)
+
+  // Check known tokens
+  const tokens = []
+  if (net.rlusd) tokens.push({ address: net.rlusd, name: 'RLUSD' })
+
+  // Check pad tokens the user might hold — query API for recent tokens
+  try {
+    const data = await apiFetch(`/pad/tokens?chain=${chain}&limit=50&sort=recent`)
+    const padTokens = data.data || data.tokens || data || []
+    if (Array.isArray(padTokens)) {
+      for (const t of padTokens) {
+        if (t.address) tokens.push({ address: t.address, name: t.symbol || t.name || '???' })
+      }
+    }
+  } catch {}
+
+  // Batch check balances
+  const results = []
+  for (const t of tokens) {
+    try {
+      const [bal, decimals] = await Promise.all([
+        readContract({ address: t.address, abi: ERC20_ABI, functionName: 'balanceOf', args: [address] }),
+        readContract({ address: t.address, abi: ERC20_ABI, functionName: 'decimals', args: [] }),
+      ])
+      if (bal > 0n) {
+        const formatted = parseFloat(viem.formatUnits(bal, decimals))
+        results.push({ name: t.name, balance: formatted, address: t.address })
+      }
+    } catch {}
+  }
+
+  if (results.length > 0) {
+    for (const r of results) {
+      const balStr = r.balance > 1000 ? r.balance.toLocaleString() : r.balance.toFixed(4)
+      console.log(`  ${r.name.padEnd(9)}${balStr}`)
+    }
+  }
+
+  console.log()
+}
+
 // ─── Wallet & network commands ───────────────────────────────────────
 
 async function cmdWalletNew() {
@@ -731,6 +1156,7 @@ async function cmdStatus() {
   console.log(`  WXRP:          ${net.wxrp}`)
   console.log(`  Swap Router:   ${net.swapRouter}`)
   console.log(`  Swap Factory:  ${net.swapFactory}`)
+  if (net.padFactory) console.log(`  Pad Factory:   ${net.padFactory}`)
   if (net.perpsRouter) console.log(`  Perps Router:  ${net.perpsRouter}`)
   if (net.vault) console.log(`  Vault:         ${net.vault}`)
   if (net.priceFeed) console.log(`  Price Feed:    ${net.priceFeed}`)
@@ -777,6 +1203,14 @@ Chat:
   chat mentions [address]          Check replies to your posts
   chat profile <name> [--bio ""]   Set your display name
 
+Pad (Launchpad):
+  pad launch <name> <symbol> [desc]  Launch a token on bonding curve
+  pad buy <token> <xrp_amount>       Buy tokens with XRP
+  pad sell <token> <amount|all>      Sell tokens for XRP
+  pad info <token>                   View token info and progress
+  pad search <query>                 Search tokens by name or symbol
+  pad tokens                         List recent tokens
+
 Swap (DEX):
   swap <amount> <from> <to>        Swap tokens (e.g. swap 1 XRP RLUSD)
   swap quote <amount> <from> <to>  Get a quote without executing
@@ -789,12 +1223,11 @@ Trade (Perps — testnet):
   trade position                   View your open positions
   trade price                      Get current XRP price
 
-Wallet:
+Wallet & Account:
   wallet new                       Generate a new wallet
-
-Network:
+  balance [address]                Show XRP and token balances
   faucet [address]                 Get 25 testnet XRP
-  status                           Show network info, contracts, balance
+  status                           Show network info, contracts
 
 Options:
   --mainnet                        Use mainnet (default: testnet)
@@ -826,6 +1259,14 @@ async function main() {
       else if (sub === 'mentions' || sub === 'm') await cmdChatMentions(args[2])
       else if (sub === 'profile') await cmdChatProfile(args[2])
       else { console.error(`Unknown: chat ${sub}. Try: feed, thread, post, reply, mentions, profile`); process.exit(1) }
+    } else if (cmd === 'pad' || cmd === 'p') {
+      if (sub === 'launch' || sub === 'l' || sub === 'create') await cmdPadLaunch(args[2], args[3], args[4])
+      else if (sub === 'buy' || sub === 'b') await cmdPadBuy(args[2], args[3])
+      else if (sub === 'sell' || sub === 's') await cmdPadSell(args[2], args[3])
+      else if (sub === 'info' || sub === 'i') await cmdPadInfo(args[2])
+      else if (sub === 'search' || sub === 'find') await cmdPadSearch(args[2])
+      else if (sub === 'tokens' || sub === 'list') await cmdPadTokens()
+      else { console.error(`Unknown: pad ${sub}. Try: launch, buy, sell, info, tokens`); process.exit(1) }
     } else if (cmd === 'swap') {
       if (sub === 'quote' || sub === 'q') await cmdSwapQuote(args[2], args[3], args[4])
       else if (sub === 'pools' || sub === 'p') await cmdSwapPools()
@@ -840,6 +1281,8 @@ async function main() {
     } else if (cmd === 'wallet' || cmd === 'w') {
       if (!sub || sub === 'new') await cmdWalletNew()
       else { console.error(`Unknown: wallet ${sub}`); process.exit(1) }
+    } else if (cmd === 'balance' || cmd === 'bal' || cmd === 'b') {
+      await cmdBalance(args[1])
     } else if (cmd === 'faucet') {
       await cmdFaucet(args[1])
     } else if (cmd === 'status' || cmd === 's') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blumefi",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "BlumeFi CLI — DeFi reimagined for the agentic era. Trade, chat, and interact with the Blume ecosystem from the command line.",
   "main": "cli.js",
   "bin": {