blumefi 2.6.0 → 2.7.0

package/cli.js

@@ -16,6 +16,8 @@ const c = {
   yellow: s => `\x1b[33m${s}\x1b[39m`,
   red: s => `\x1b[31m${s}\x1b[39m`,
   white: s => `\x1b[97m${s}\x1b[39m`,
+  cyan: s => `\x1b[36m${s}\x1b[39m`,
+  brightGreen: s => `\x1b[92m${s}\x1b[39m`,
 }
 
 function progressBar(pct, width = 16) {
@@ -100,6 +102,22 @@ const SWAP_ROUTER_ABI = [
   { name: 'swapExactTokensForTokens', type: 'function', stateMutability: 'nonpayable', inputs: [{ name: 'amountIn', type: 'uint256' }, { name: 'amountOutMin', type: 'uint256' }, { name: 'path', type: 'address[]' }, { name: 'to', type: 'address' }, { name: 'deadline', type: 'uint256' }], outputs: [{ type: 'uint256[]' }] },
   { name: 'getAmountsOut', type: 'function', stateMutability: 'view', inputs: [{ name: 'amountIn', type: 'uint256' }, { name: 'path', type: 'address[]' }], outputs: [{ type: 'uint256[]' }] },
   { name: 'WETH', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'address' }] },
+  { name: 'addLiquidityETH', type: 'function', stateMutability: 'payable', inputs: [{ name: 'token', type: 'address' }, { name: 'amountTokenDesired', type: 'uint256' }, { name: 'amountTokenMin', type: 'uint256' }, { name: 'amountETHMin', type: 'uint256' }, { name: 'to', type: 'address' }, { name: 'deadline', type: 'uint256' }], outputs: [{ name: 'amountToken', type: 'uint256' }, { name: 'amountETH', type: 'uint256' }, { name: 'liquidity', type: 'uint256' }] },
+  { name: 'removeLiquidityETH', type: 'function', stateMutability: 'nonpayable', inputs: [{ name: 'token', type: 'address' }, { name: 'liquidity', type: 'uint256' }, { name: 'amountTokenMin', type: 'uint256' }, { name: 'amountETHMin', type: 'uint256' }, { name: 'to', type: 'address' }, { name: 'deadline', type: 'uint256' }], outputs: [{ name: 'amountToken', type: 'uint256' }, { name: 'amountETH', type: 'uint256' }] },
+]
+
+const SWAP_FACTORY_ABI = [
+  { name: 'getPair', type: 'function', stateMutability: 'view', inputs: [{ name: 'tokenA', type: 'address' }, { name: 'tokenB', type: 'address' }], outputs: [{ type: 'address' }] },
+]
+
+const SWAP_PAIR_ABI = [
+  { name: 'getReserves', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ name: 'reserve0', type: 'uint112' }, { name: 'reserve1', type: 'uint112' }, { name: 'blockTimestampLast', type: 'uint32' }] },
+  { name: 'token0', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'address' }] },
+  { name: 'token1', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'address' }] },
+  { name: 'totalSupply', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] },
+  { name: 'balanceOf', type: 'function', stateMutability: 'view', inputs: [{ name: 'account', type: 'address' }], outputs: [{ type: 'uint256' }] },
+  { name: 'approve', type: 'function', stateMutability: 'nonpayable', inputs: [{ name: 'spender', type: 'address' }, { name: 'amount', type: 'uint256' }], outputs: [{ type: 'bool' }] },
+  { name: 'allowance', type: 'function', stateMutability: 'view', inputs: [{ name: 'owner', type: 'address' }, { name: 'spender', type: 'address' }], outputs: [{ type: 'uint256' }] },
 ]
 
 const PERPS_ROUTER_ABI = [
@@ -583,6 +601,196 @@ async function cmdSwapPools() {
   }
 }
 
+async function cmdSwapAddLiquidity(tokenAddress, xrpAmountStr) {
+  if (!tokenAddress || !xrpAmountStr) {
+    console.error('Usage: blumefi swap add-liquidity <token_address> <xrp_amount>')
+    console.error('  blumefi swap add-liquidity 0x1234... 10       Add liquidity with 10 XRP')
+    console.error('  blumefi swap add-liquidity 0x1234... 10 --slippage 5')
+    process.exit(1)
+  }
+
+  const viem = await loadViem()
+  const net = getNetwork()
+  const chain = getChain()
+  const xrpAmount = parseFloat(xrpAmountStr)
+  if (isNaN(xrpAmount) || xrpAmount <= 0) throw new Error('Invalid XRP amount')
+
+  // Parse --slippage flag (default 2%)
+  const slippageIdx = process.argv.indexOf('--slippage')
+  const slippagePct = slippageIdx !== -1 ? parseFloat(process.argv[slippageIdx + 1] || '2') : 2
+  if (isNaN(slippagePct) || slippagePct <= 0 || slippagePct > 50) throw new Error('Slippage must be between 0 and 50')
+  const slippageBps = BigInt(Math.round(slippagePct * 100))
+
+  const wxrp = net.swapWxrp || net.wxrp
+  const xrpValue = viem.parseEther(xrpAmountStr)
+
+  // Get pair address
+  const pairAddress = await readContract({
+    address: net.swapFactory, abi: SWAP_FACTORY_ABI, functionName: 'getPair', args: [tokenAddress, wxrp],
+  })
+  const zeroPair = '0x0000000000000000000000000000000000000000'
+  if (!pairAddress || pairAddress === zeroPair) {
+    throw new Error(`No pool exists for this token/XRP pair. Create one on swap.blumefi.com first.`)
+  }
+
+  // Get reserves and figure out which side is the token vs WXRP
+  const [reserves, token0Addr, tokenDecimals, tokenSymbol] = await Promise.all([
+    readContract({ address: pairAddress, abi: SWAP_PAIR_ABI, functionName: 'getReserves', args: [] }),
+    readContract({ address: pairAddress, abi: SWAP_PAIR_ABI, functionName: 'token0', args: [] }),
+    readContract({ address: tokenAddress, abi: ERC20_ABI, functionName: 'decimals', args: [] }),
+    readContract({ address: tokenAddress, abi: ERC20_ABI, functionName: 'symbol', args: [] }),
+  ])
+
+  const isToken0 = token0Addr.toLowerCase() === tokenAddress.toLowerCase()
+  const tokenReserve = isToken0 ? reserves[0] : reserves[1]
+  const xrpReserve = isToken0 ? reserves[1] : reserves[0]
+
+  if (xrpReserve === 0n || tokenReserve === 0n) throw new Error('Pool has no liquidity')
+
+  // Calculate required token amount at current pool ratio
+  // tokenAmount = xrpAmount * tokenReserve / xrpReserve (+ 1 to round up)
+  const tokenAmountRaw = xrpValue * tokenReserve / xrpReserve
+  const tokenAmountDesired = tokenAmountRaw + 1n
+
+  const tokenFormatted = parseFloat(viem.formatUnits(tokenAmountDesired, tokenDecimals)).toLocaleString()
+
+  // Slippage minimums (from raw ratio, not bumped desired)
+  const amountTokenMin = tokenAmountRaw * (10000n - slippageBps) / 10000n
+  const amountETHMin = xrpValue * (10000n - slippageBps) / 10000n
+
+  console.log(`\n  Adding liquidity on ${chain}`)
+  console.log(`  ─────────────────────────────────────`)
+  console.log(`  Pool:      ${tokenSymbol} / XRP`)
+  console.log(`  XRP:       ${xrpAmount} XRP`)
+  console.log(`  Token:     ~${tokenFormatted} ${tokenSymbol}`)
+  console.log(`  Slippage:  ${slippagePct}%`)
+
+  // Approve token for router
+  await ensureApproval(tokenAddress, net.swapRouter, tokenAmountDesired)
+
+  const { account } = await getWalletClient()
+  const deadline = BigInt(Math.floor(Date.now() / 1000) + 1200) // 20 min
+
+  console.log('  Sending transaction...')
+  const { hash, explorer } = await sendContractTx({
+    to: net.swapRouter,
+    abi: SWAP_ROUTER_ABI,
+    functionName: 'addLiquidityETH',
+    args: [tokenAddress, tokenAmountDesired, amountTokenMin, amountETHMin, account.address, deadline],
+    value: xrpValue,
+  })
+
+  console.log(`\n  Added liquidity: ${xrpAmount} XRP + ~${tokenFormatted} ${tokenSymbol}`)
+  console.log(`  TX: ${explorer}`)
+}
+
+async function cmdSwapRemoveLiquidity(tokenAddress, lpAmountStr) {
+  if (!tokenAddress || !lpAmountStr) {
+    console.error('Usage: blumefi swap remove-liquidity <token_address> <lp_amount|all>')
+    console.error('  blumefi swap remove-liquidity 0x1234... all    Remove all liquidity')
+    console.error('  blumefi swap remove-liquidity 0x1234... 5      Remove 5 LP tokens')
+    console.error('  blumefi swap remove-liquidity 0x1234... 5 --slippage 5')
+    process.exit(1)
+  }
+
+  const viem = await loadViem()
+  const net = getNetwork()
+  const chain = getChain()
+  const { account } = await getWalletClient()
+
+  // Parse --slippage flag (default 2%)
+  const slippageIdx = process.argv.indexOf('--slippage')
+  const slippagePct = slippageIdx !== -1 ? parseFloat(process.argv[slippageIdx + 1] || '2') : 2
+  if (isNaN(slippagePct) || slippagePct <= 0 || slippagePct > 50) throw new Error('Slippage must be between 0 and 50')
+  const slippageBps = BigInt(Math.round(slippagePct * 100))
+
+  const wxrp = net.swapWxrp || net.wxrp
+
+  // Get pair address
+  const pairAddress = await readContract({
+    address: net.swapFactory, abi: SWAP_FACTORY_ABI, functionName: 'getPair', args: [tokenAddress, wxrp],
+  })
+  const zeroPair = '0x0000000000000000000000000000000000000000'
+  if (!pairAddress || pairAddress === zeroPair) {
+    throw new Error(`No pool exists for this token/XRP pair.`)
+  }
+
+  // Get LP balance, reserves, pair info
+  const [lpBalance, reserves, token0Addr, lpTotalSupply, tokenDecimals, tokenSymbol] = await Promise.all([
+    readContract({ address: pairAddress, abi: SWAP_PAIR_ABI, functionName: 'balanceOf', args: [account.address] }),
+    readContract({ address: pairAddress, abi: SWAP_PAIR_ABI, functionName: 'getReserves', args: [] }),
+    readContract({ address: pairAddress, abi: SWAP_PAIR_ABI, functionName: 'token0', args: [] }),
+    readContract({ address: pairAddress, abi: SWAP_PAIR_ABI, functionName: 'totalSupply', args: [] }),
+    readContract({ address: tokenAddress, abi: ERC20_ABI, functionName: 'decimals', args: [] }),
+    readContract({ address: tokenAddress, abi: ERC20_ABI, functionName: 'symbol', args: [] }),
+  ])
+
+  let lpAmount
+  if (lpAmountStr.toLowerCase() === 'all') {
+    lpAmount = lpBalance
+    if (lpAmount === 0n) { console.log(`\n  No LP tokens for ${tokenSymbol}/XRP pool.`); return }
+  } else {
+    lpAmount = viem.parseEther(lpAmountStr)
+  }
+
+  if (lpAmount > lpBalance) {
+    console.error(`Error: Insufficient LP balance. You have ${parseFloat(viem.formatEther(lpBalance)).toFixed(6)} LP tokens`)
+    process.exit(1)
+  }
+
+  // Estimate what you'll receive
+  const isToken0 = token0Addr.toLowerCase() === tokenAddress.toLowerCase()
+  const tokenReserve = isToken0 ? reserves[0] : reserves[1]
+  const xrpReserve = isToken0 ? reserves[1] : reserves[0]
+
+  if (lpTotalSupply === 0n) throw new Error('Pool total supply is zero')
+
+  const expectedToken = lpAmount * tokenReserve / lpTotalSupply
+  const expectedXrp = lpAmount * xrpReserve / lpTotalSupply
+
+  const tokenFormatted = parseFloat(viem.formatUnits(expectedToken, tokenDecimals)).toLocaleString()
+  const xrpFormatted = parseFloat(viem.formatEther(expectedXrp)).toFixed(4)
+  const lpFormatted = parseFloat(viem.formatEther(lpAmount)).toFixed(6)
+
+  // Slippage minimums
+  const amountTokenMin = expectedToken * (10000n - slippageBps) / 10000n
+  const amountETHMin = expectedXrp * (10000n - slippageBps) / 10000n
+
+  console.log(`\n  Removing liquidity on ${chain}`)
+  console.log(`  ─────────────────────────────────────`)
+  console.log(`  Pool:      ${tokenSymbol} / XRP`)
+  console.log(`  LP tokens: ${lpFormatted}`)
+  console.log(`  Receive:   ~${tokenFormatted} ${tokenSymbol} + ~${xrpFormatted} XRP`)
+  console.log(`  Slippage:  ${slippagePct}%`)
+
+  // Approve LP token for router
+  const lpAllowance = await readContract({
+    address: pairAddress, abi: SWAP_PAIR_ABI, functionName: 'allowance', args: [account.address, net.swapRouter],
+  })
+  if (lpAllowance < lpAmount) {
+    console.log('  Approving LP tokens...')
+    const maxUint = 2n ** 256n - 1n
+    const { hash: approveHash } = await sendContractTx({
+      to: pairAddress, abi: SWAP_PAIR_ABI, functionName: 'approve', args: [net.swapRouter, maxUint],
+    })
+    const pub = await getPublicClient()
+    await pub.waitForTransactionReceipt({ hash: approveHash, timeout: 30000 })
+  }
+
+  const deadline = BigInt(Math.floor(Date.now() / 1000) + 1200) // 20 min
+
+  console.log('  Sending transaction...')
+  const { hash, explorer } = await sendContractTx({
+    to: net.swapRouter,
+    abi: SWAP_ROUTER_ABI,
+    functionName: 'removeLiquidityETH',
+    args: [tokenAddress, lpAmount, amountTokenMin, amountETHMin, account.address, deadline],
+  })
+
+  console.log(`\n  Removed liquidity: ~${tokenFormatted} ${tokenSymbol} + ~${xrpFormatted} XRP`)
+  console.log(`  TX: ${explorer}`)
+}
+
 // ─── Trade commands (perps) ──────────────────────────────────────────
 
 function requirePerps() {
@@ -1098,7 +1306,7 @@ async function cmdPadSearch(query) {
   }
 }
 
-function renderTokenTable(tokens, total, chain, filter) {
+function renderTokenTable(tokens, total, chain, filter, frame = 0) {
   const lines = []
   if (!tokens.length) {
     lines.push(c.dim(`  No tokens found (${chain}, filter: ${filter})`))
@@ -1136,12 +1344,28 @@ function renderTokenTable(tokens, total, chain, filter) {
 
   for (const t of tokens) {
     const pct = Math.min(t.progress || 0, 100)
-    const pctStr = `${Math.round(pct)}%`
-    const bar = progressBar(pct) + ' ' + (pct >= 100 ? c.green(pctStr) : c.yellow(pctStr))
-    const status = t.graduated ? c.green('Graduated') : c.yellow('Active')
+    const hot = pct >= 75 && !t.graduated
+    const pulse = hot && frame % 2 === 0
+
+    let bar, pctStr, status, indicator
+    if (hot) {
+      pctStr = `${Math.round(pct)}%`
+      const barFn = pulse ? c.brightGreen : c.green
+      const clamped = Math.max(0, Math.min(pct, 100))
+      const filled = Math.round((clamped / 100) * 16)
+      const empty = 16 - filled
+      bar = barFn('█'.repeat(filled)) + c.dim('░'.repeat(empty)) + ' ' + (pulse ? c.bold(c.brightGreen(pctStr)) : c.bold(c.yellow(pctStr)))
+      indicator = pulse ? ' ▲' : ''
+      status = pulse ? c.bold(c.brightGreen('Hot')) : c.yellow('Active')
+    } else {
+      pctStr = `${Math.round(pct)}%`
+      bar = progressBar(pct) + ' ' + (pct >= 100 ? c.green(pctStr) : c.yellow(pctStr))
+      indicator = ''
+      status = t.graduated ? c.green('Graduated') : c.yellow('Active')
+    }
 
     const row =
-      padRight(c.bold(t.symbol || '???'), cols.symbol) +
+      padRight(c.bold(t.symbol || '???') + indicator, cols.symbol) +
       padRight((t.name || '—').slice(0, 18), cols.name) +
       padLeft(fmtPrice(t.price), cols.price) + '  ' +
       padLeft(fmtNum(t.marketCap), cols.mcap) + '  ' +
@@ -1186,7 +1410,8 @@ async function cmdPadTokens() {
   }
 
   // Live dashboard mode
-  const REFRESH = 5
+  const FETCH_INTERVAL = 5000 // fetch new data every 5s
+  const RENDER_INTERVAL = 500 // redraw for animation every 500ms
   const hideCursor = () => process.stdout.write('\x1b[?25l')
   const showCursor = () => process.stdout.write('\x1b[?25h')
   const clearScreen = () => process.stdout.write('\x1b[2J\x1b[H')
@@ -1203,30 +1428,39 @@ async function cmdPadTokens() {
 
   hideCursor()
 
+  let cachedTokens = [], cachedTotal = 0, lastFetch = 0, fetchError = null, frame = 0
+
   while (running) {
-    let output
-    try {
-      const data = await apiFetch(`/pad/tokens?chain=${chain}&filter=${filter}&sort=${sort}&limit=${limit}&offset=0`)
-      const tokens = data.tokens || data.data || []
-      const total = data.total || tokens.length
-      output = renderTokenTable(tokens, total, chain, filter)
-    } catch (err) {
-      output = c.red(`  Error fetching data: ${err.message}`) + '\n' + c.dim('  Will retry...')
+    // Fetch new data if stale
+    const now = Date.now()
+    if (now - lastFetch >= FETCH_INTERVAL) {
+      try {
+        const data = await apiFetch(`/pad/tokens?chain=${chain}&filter=${filter}&sort=${sort}&limit=${limit}&offset=0`)
+        cachedTokens = data.tokens || data.data || []
+        cachedTotal = data.total || cachedTokens.length
+        fetchError = null
+      } catch (err) {
+        fetchError = err.message
+      }
+      lastFetch = Date.now()
     }
 
+    // Render current frame
     clearScreen()
     console.log('')
-    console.log(output)
+    if (fetchError && !cachedTokens.length) {
+      console.log(c.red(`  Error fetching data: ${fetchError}`) + '\n' + c.dim('  Will retry...'))
+    } else {
+      console.log(renderTokenTable(cachedTokens, cachedTotal, chain, filter, frame))
+    }
 
-    const now = new Date()
-    const ts = now.toLocaleTimeString('en-US', { hour12: false })
+    const ts = new Date().toLocaleTimeString('en-US', { hour12: false })
+    const nextFetchIn = Math.max(0, Math.ceil((FETCH_INTERVAL - (Date.now() - lastFetch)) / 1000))
     console.log('')
-    console.log(c.dim(`  Updated ${ts} · Refreshing in ${REFRESH}s · Ctrl+C to exit`))
+    console.log(c.dim(`  Updated ${ts} · Refreshing in ${nextFetchIn}s · Ctrl+C to exit`))
 
-    // Countdown sleep — break early if stopped
-    for (let i = 0; i < REFRESH * 10 && running; i++) {
-      await new Promise(r => setTimeout(r, 100))
-    }
+    frame++
+    await new Promise(r => setTimeout(r, RENDER_INTERVAL))
   }
 }
 
@@ -1461,6 +1695,8 @@ Swap (DEX):
   swap <amount> <from> <to>        Swap tokens (e.g. swap 1 XRP RLUSD)
   swap quote <amount> <from> <to>  Get a quote without executing
   swap pools                       List available pools
+  swap add-liquidity <token> <xrp> Add liquidity to a token/XRP pool
+  swap remove-liquidity <token> <lp|all>  Remove liquidity from a pool
 
 Trade (Perps — testnet):
   trade long <usd> [leverage]      Open long  (e.g. trade long 100 5x)
@@ -1519,6 +1755,8 @@ async function main() {
     } 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()
+      else if (sub === 'add-liquidity' || sub === 'al') await cmdSwapAddLiquidity(args[2], args[3])
+      else if (sub === 'remove-liquidity' || sub === 'rl') await cmdSwapRemoveLiquidity(args[2], args[3])
       else await cmdSwap(sub, args[2], args[3]) // swap <amount> <from> <to>
     } else if (cmd === 'trade' || cmd === 't') {
       if (sub === 'long' || sub === 'l') await cmdTradeOpen(true, args[2], args[3])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blumefi",
-  "version": "2.6.0",
+  "version": "2.7.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": {