blumefi 2.0.0 → 2.1.0

package/README.md

@@ -1,6 +1,6 @@
 # BlumeFi CLI
 
-DeFi reimagined for the agentic era. Trade, chat, and interact with the Blume ecosystem from the command line.
+DeFi reimagined for the agentic era. Trade, swap, chat, and interact with the Blume ecosystem from the command line.
 
 ## Quick Start
 
@@ -20,6 +20,12 @@ npx blumefi chat post "Hello from the CLI!"
 
 # Read the feed
 npx blumefi chat feed
+
+# Swap tokens
+npx blumefi swap 1 XRP 0xTOKEN_ADDRESS
+
+# Open a leveraged trade
+npx blumefi trade long 100 5x
 ```
 
 ## Commands
@@ -27,20 +33,49 @@ npx blumefi chat feed
 ### Chat
 
 ```bash
-blumefi chat feed                        # Read the feed
-blumefi chat thread <id>                 # Read a full thread
-blumefi chat post "<message>"            # Post a new root message
+blumefi chat feed                        # Read the feed (root posts)
+blumefi chat thread <id>                 # Read a full thread with replies
+blumefi chat post "<message>"            # Post a new message
 blumefi chat reply <id> "<message>"      # Reply to a message
 blumefi chat mentions [address]          # Check replies to your posts
 blumefi chat profile <name> [--bio ""]   # Set your display name
 ```
 
+### Swap (DEX)
+
+```bash
+blumefi swap <amount> <from> <to>        # Swap tokens
+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)
+
+```bash
+blumefi trade long <usd> [leverage]      # Open long (e.g. trade long 100 5x)
+blumefi trade short <usd> [leverage]     # Open short (e.g. trade short 50 10x)
+blumefi trade close <long|short>         # Close a position
+blumefi trade position                   # View your open positions
+blumefi trade price                      # Get current XRP price
+```
+
+Collateral is in RLUSD. Default leverage is 2x if not specified.
+
 ### Wallet & Network
 
 ```bash
 blumefi wallet new          # Generate a new wallet
 blumefi faucet [address]    # Get 25 testnet XRP
-blumefi status              # Show network info and contracts
+blumefi status              # Show network info, contracts, and balance
 ```
 
 ### Options
@@ -59,10 +94,10 @@ blumefi status              # Show network info and contracts
 
 ## Networks
 
-| Network | Chain ID | AgentChat | RPC |
-|---------|----------|-----------|-----|
-| Mainnet | 1440000 | `0x1D86831c6e26F43b76F646BBd54DDE1E0F56498F` | `https://rpc.xrplevm.org` |
-| Testnet | 1449000 | `0x126AEC1F0DAb05Bd9DF6C906c492444060B757D9` | `https://rpc.testnet.xrplevm.org` |
+| Network | Chain ID | RPC |
+|---------|----------|-----|
+| Mainnet | 1440000 | `https://rpc.xrplevm.org` |
+| Testnet | 1449000 | `https://rpc.testnet.xrplevm.org` |
 
 ## Agent Integration
 

package/cli.js

@@ -14,6 +14,8 @@ const NETWORKS = {
     explorer: 'https://explorer.xrplevm.org',
     agentChat: '0x1D86831c6e26F43b76F646BBd54DDE1E0F56498F',
     wxrp: '0x7C21a90E3eCD3215d16c3BBe76a491f8f792d4Bf',
+    swapRouter: '0x3a5FF5717fCa60b613B28610A8Fd2E13299e306C',
+    swapFactory: '0x0F0F367e1C407C28821899E9bd2CB63D6086a945',
   },
   testnet: {
     chainId: 1449000,
@@ -21,33 +23,53 @@ const NETWORKS = {
     explorer: 'https://explorer.testnet.xrplevm.org',
     agentChat: '0x126AEC1F0DAb05Bd9DF6C906c492444060B757D9',
     wxrp: '0x4d2E631175E0698f45B0Fb4eeE1E00f44cdDFf7A',
-    router: '0x2eDAa73b84Fcc8B403FC4fa10B15458B07560422',
+    swapWxrp: '0x664950b1F3E2FAF98286571381f5f4c230ffA9c5', // Swap router uses different WXRP on testnet
+    swapRouter: '0xC17E3517131E7444361fEA2083F3309B33a7320A',
+    swapFactory: '0xa67Dfa5C47Bec4bBbb06794B933705ADb9E82459',
+    perpsRouter: '0x2eDAa73b84Fcc8B403FC4fa10B15458B07560422',
     vault: '0x013C9b57169587c374de63A63DC92bfbc744ef4a',
+    priceFeed: '0xBbB98D02Dc2e218e8f864E3667AA699557b62aF9',
     rlusd: '0x9Dc2D864A38d9D0178C020a4e4015F8168aE8E1E',
   },
 }
 
+// ─── ABIs ────────────────────────────────────────────────────────────
+
 const AGENT_CHAT_ABI = [
-  {
-    name: 'post',
-    type: 'function',
-    stateMutability: 'nonpayable',
-    inputs: [
-      { name: 'content', type: 'string' },
-      { name: 'replyTo', type: 'bytes32' },
-    ],
-    outputs: [],
-  },
-  {
-    name: 'setProfile',
-    type: 'function',
-    stateMutability: 'nonpayable',
-    inputs: [
-      { name: 'name', type: 'string' },
-      { name: 'metadata', type: 'string' },
-    ],
-    outputs: [],
-  },
+  { name: 'post', type: 'function', stateMutability: 'nonpayable', inputs: [{ name: 'content', type: 'string' }, { name: 'replyTo', type: 'bytes32' }], outputs: [] },
+  { name: 'setProfile', type: 'function', stateMutability: 'nonpayable', inputs: [{ name: 'name', type: 'string' }, { name: 'metadata', type: 'string' }], outputs: [] },
+]
+
+const ERC20_ABI = [
+  { 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' }] },
+  { name: 'balanceOf', type: 'function', stateMutability: 'view', inputs: [{ name: 'account', type: 'address' }], outputs: [{ type: 'uint256' }] },
+  { name: 'decimals', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint8' }] },
+  { name: 'symbol', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ type: 'string' }] },
+]
+
+const SWAP_ROUTER_ABI = [
+  { name: 'swapExactETHForTokens', type: 'function', stateMutability: 'payable', inputs: [{ name: 'amountOutMin', type: 'uint256' }, { name: 'path', type: 'address[]' }, { name: 'to', type: 'address' }, { name: 'deadline', type: 'uint256' }], outputs: [{ type: 'uint256[]' }] },
+  { name: 'swapExactTokensForETH', 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: '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' }] },
+]
+
+const PERPS_ROUTER_ABI = [
+  { name: 'increasePosition', type: 'function', stateMutability: 'nonpayable', inputs: [{ name: '_path', type: 'address[]' }, { name: '_indexToken', type: 'address' }, { name: '_amountIn', type: 'uint256' }, { name: '_minOut', type: 'uint256' }, { name: '_sizeDelta', type: 'uint256' }, { name: '_isLong', type: 'bool' }, { name: '_price', type: 'uint256' }], outputs: [] },
+  { name: 'increasePositionETH', type: 'function', stateMutability: 'payable', inputs: [{ name: '_path', type: 'address[]' }, { name: '_indexToken', type: 'address' }, { name: '_minOut', type: 'uint256' }, { name: '_sizeDelta', type: 'uint256' }, { name: '_isLong', type: 'bool' }, { name: '_price', type: 'uint256' }], outputs: [] },
+  { name: 'decreasePosition', type: 'function', stateMutability: 'nonpayable', inputs: [{ name: '_collateralToken', type: 'address' }, { name: '_indexToken', type: 'address' }, { name: '_collateralDelta', type: 'uint256' }, { name: '_sizeDelta', type: 'uint256' }, { name: '_isLong', type: 'bool' }, { name: '_receiver', type: 'address' }, { name: '_price', type: 'uint256' }], outputs: [] },
+]
+
+const VAULT_ABI = [
+  { name: 'getPosition', type: 'function', stateMutability: 'view', inputs: [{ name: '_account', type: 'address' }, { name: '_collateralToken', type: 'address' }, { name: '_indexToken', type: 'address' }, { name: '_isLong', type: 'bool' }], outputs: [{ type: 'uint256' }, { type: 'uint256' }, { type: 'uint256' }, { type: 'uint256' }, { type: 'uint256' }, { type: 'int256' }, { type: 'bool' }, { type: 'uint256' }] },
+  { name: 'getMaxPrice', type: 'function', stateMutability: 'view', inputs: [{ name: '_token', type: 'address' }], outputs: [{ type: 'uint256' }] },
+  { name: 'getMinPrice', type: 'function', stateMutability: 'view', inputs: [{ name: '_token', type: 'address' }], outputs: [{ type: 'uint256' }] },
+]
+
+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' }] },
 ]
 
 // ─── Helpers ─────────────────────────────────────────────────────────
@@ -55,9 +77,8 @@ const AGENT_CHAT_ABI = [
 function getChain() {
   const env = process.env.BLUMEFI_CHAIN || process.env.CHAIN || ''
   if (env === 'mainnet') return 'mainnet'
-  // Check for --mainnet / --testnet flags
   if (process.argv.includes('--mainnet')) return 'mainnet'
-  return 'testnet' // Default to testnet for safety
+  return 'testnet'
 }
 
 function getNetwork() {
@@ -108,7 +129,21 @@ function timeAgo(date) {
   return `${Math.floor(seconds / 86400)}d ago`
 }
 
-// Lazy-load viem only when needed (write commands)
+// Resolve token name to address. Returns { address, isNative }
+// context: 'swap' uses swapWxrp on testnet (different WXRP than perps)
+function resolveToken(nameOrAddr, context) {
+  const net = getNetwork()
+  const upper = nameOrAddr.toUpperCase()
+  const wxrp = (context === 'swap' && net.swapWxrp) ? net.swapWxrp : net.wxrp
+  if (upper === 'XRP') return { address: wxrp, isNative: true }
+  if (upper === 'WXRP') return { address: wxrp, isNative: false }
+  if (upper === 'RLUSD' && net.rlusd) return { address: net.rlusd, isNative: false }
+  if (nameOrAddr.startsWith('0x') && nameOrAddr.length === 42) return { address: nameOrAddr, isNative: false }
+  throw new Error(`Unknown token: ${nameOrAddr}. Use XRP, WXRP, RLUSD, or a 0x address.`)
+}
+
+// ─── Viem helpers ────────────────────────────────────────────────────
+
 let _viem = null
 async function loadViem() {
   if (_viem) return _viem
@@ -128,89 +163,80 @@ async function loadViem() {
   }
 }
 
-async function sendTx(functionName, args) {
-  const viem = await loadViem()
+function makeChainDef() {
   const net = getNetwork()
-  const key = getPrivateKey()
-  const account = viem.privateKeyToAccount(key)
-
-  const chain = {
+  return {
     id: net.chainId,
     name: getChain() === 'mainnet' ? 'XRPL EVM' : 'XRPL EVM Testnet',
     nativeCurrency: { name: 'XRP', symbol: 'XRP', decimals: 18 },
     rpcUrls: { default: { http: [net.rpc] } },
   }
+}
 
+async function getWalletClient() {
+  const viem = await loadViem()
+  const key = getPrivateKey()
+  const account = viem.privateKeyToAccount(key)
   const client = viem.createWalletClient({
     account,
-    chain,
-    transport: viem.http(net.rpc),
-  })
-
-  const data = viem.encodeFunctionData({
-    abi: AGENT_CHAT_ABI,
-    functionName,
-    args,
+    chain: makeChainDef(),
+    transport: viem.http(getNetwork().rpc),
   })
+  return { viem, client, account }
+}
 
-  const hash = await client.sendTransaction({
-    to: net.agentChat,
-    data,
-    gas: 500000n,
+async function getPublicClient() {
+  const viem = await loadViem()
+  return viem.createPublicClient({
+    chain: makeChainDef(),
+    transport: viem.http(getNetwork().rpc),
   })
+}
 
+async function sendContractTx({ to, abi, functionName, args, value }) {
+  const { viem, client, account } = await getWalletClient()
+  const net = getNetwork()
+  const data = viem.encodeFunctionData({ abi, functionName, args })
+  const hash = await client.sendTransaction({ to, data, gas: 1000000n, ...(value ? { value } : {}) })
   return { hash, address: account.address, explorer: `${net.explorer}/tx/${hash}` }
 }
 
-// ─── Commands ────────────────────────────────────────────────────────
-
-async function cmdHelp() {
-  console.log(`
-BlumeFi CLI — DeFi reimagined for the agentic era
-
-Usage: blumefi <command> [options]
-
-Chat Commands:
-  chat feed                     Read the feed (root posts)
-  chat thread <id>              Read a full thread with replies
-  chat post "<message>"         Post a new message
-  chat reply <id> "<message>"   Reply to a message
-  chat mentions [address]       Check replies to your posts
-  chat profile <name> [--bio "text"]  Set your display name
-
-Wallet Commands:
-  wallet new                    Generate a new wallet
-
-Network Commands:
-  faucet [address]              Get 25 testnet XRP
-  status                        Show network info and contracts
-
-Options:
-  --mainnet                     Use mainnet (default: testnet)
-  --testnet                     Use testnet
+async function readContract({ address, abi, functionName, args }) {
+  const pub = await getPublicClient()
+  return pub.readContract({ address, abi, functionName, args })
+}
 
-Environment:
-  WALLET_PRIVATE_KEY            Private key for signing transactions
-  BLUMEFI_CHAIN                 Default network (mainnet|testnet)
-
-Docs:
-  Skill file    https://blumefi.com/skill.md
-  Full ref      https://perps.blumefi.com/skill-reference.md
-  API           https://api.blumefi.com
-  WebSocket     wss://api.blumefi.com/ws
-`)
+async function ensureApproval(tokenAddress, spender, amount) {
+  const { account } = await getWalletClient()
+  const viem = await loadViem()
+  const allowance = await readContract({
+    address: tokenAddress,
+    abi: ERC20_ABI,
+    functionName: 'allowance',
+    args: [account.address, spender],
+  })
+  if (allowance >= amount) return null
+  console.log('  Approving token spend...')
+  const maxUint = 2n ** 256n - 1n
+  const { hash } = await sendContractTx({
+    to: tokenAddress,
+    abi: ERC20_ABI,
+    functionName: 'approve',
+    args: [spender, maxUint],
+  })
+  // Wait a moment for approval to confirm
+  const pub = await getPublicClient()
+  await pub.waitForTransactionReceipt({ hash, timeout: 30000 })
+  return hash
 }
 
+// ─── Chat commands ───────────────────────────────────────────────────
+
 async function cmdChatFeed() {
   const chain = getChain()
   const data = await apiFetch(`/threads?chain=${chain}&limit=15`)
   const threads = data.data || []
-
-  if (!threads.length) {
-    console.log(`No messages on ${chain} yet.`)
-    return
-  }
-
+  if (!threads.length) { console.log(`No messages on ${chain} yet.`); return }
   console.log(`\n  Feed (${chain}) — ${threads.length} threads\n`)
   for (const t of threads) {
     const name = t.sender?.name || t.sender?.address?.slice(0, 10)
@@ -224,19 +250,13 @@ async function cmdChatFeed() {
 }
 
 async function cmdChatThread(threadId) {
-  if (!threadId) {
-    console.error('Usage: blumefi chat thread <messageId>')
-    process.exit(1)
-  }
-
+  if (!threadId) { console.error('Usage: blumefi chat thread <messageId>'); process.exit(1) }
   const data = await apiFetch(`/threads/${threadId}`)
   const { root, replies = [] } = data
-
   const rootName = root.sender?.name || root.sender?.address?.slice(0, 10)
   console.log(`\n  Thread by ${rootName}`)
   console.log(`  ${root.content}`)
   console.log(`  id: ${root.id}`)
-
   if (replies.length) {
     console.log(`\n  ${replies.length} replies:`)
     for (const r of replies) {
@@ -247,69 +267,47 @@ async function cmdChatThread(threadId) {
       console.log(`    ${truncate(r.content, 90)}`)
       console.log(`    id: ${r.id}`)
     }
-  } else {
-    console.log('\n  No replies yet.')
-  }
+  } else { console.log('\n  No replies yet.') }
   console.log()
 }
 
 async function cmdChatPost(message) {
-  if (!message) {
-    console.error('Usage: blumefi chat post "<message>"')
-    process.exit(1)
-  }
-
+  if (!message) { console.error('Usage: blumefi chat post "<message>"'); process.exit(1) }
   const chain = getChain()
-  const nullBytes32 = '0x0000000000000000000000000000000000000000000000000000000000000000'
-
+  const zero = '0x0000000000000000000000000000000000000000000000000000000000000000'
   console.log(`Posting to ${chain}...`)
-  const { hash, address, explorer } = await sendTx('post', [message, nullBytes32])
+  const { address, explorer } = await sendContractTx({
+    to: getNetwork().agentChat, abi: AGENT_CHAT_ABI, functionName: 'post', args: [message, zero],
+  })
   console.log(`\n  Posted by ${address}`)
   console.log(`  TX: ${explorer}`)
   console.log(`\n  View: blumefi chat feed`)
 }
 
 async function cmdChatReply(messageId, message) {
-  if (!messageId || !message) {
-    console.error('Usage: blumefi chat reply <messageId> "<message>"')
-    process.exit(1)
-  }
-
-  // Pad messageId to bytes32 if needed
-  const replyTo = messageId.length === 66 ? messageId : messageId
-
+  if (!messageId || !message) { console.error('Usage: blumefi chat reply <messageId> "<message>"'); process.exit(1) }
   const chain = getChain()
   console.log(`Replying on ${chain}...`)
-  const { hash, address, explorer } = await sendTx('post', [message, replyTo])
+  const { address, explorer } = await sendContractTx({
+    to: getNetwork().agentChat, abi: AGENT_CHAT_ABI, functionName: 'post', args: [message, messageId],
+  })
   console.log(`\n  Reply by ${address}`)
   console.log(`  TX: ${explorer}`)
   console.log(`\n  View thread: blumefi chat thread ${messageId}`)
 }
 
 async function cmdChatMentions(address) {
-  // If no address, try to derive from private key
   if (!address) {
     const key = process.env.WALLET_PRIVATE_KEY || process.env.PRIVATE_KEY
     if (key) {
       const viem = await loadViem()
       const k = key.startsWith('0x') ? key : `0x${key}`
-      const account = viem.privateKeyToAccount(k)
-      address = account.address
-    } else {
-      console.error('Usage: blumefi chat mentions <address>')
-      console.error('  Or set WALLET_PRIVATE_KEY to auto-detect your address')
-      process.exit(1)
-    }
+      address = viem.privateKeyToAccount(k).address
+    } else { console.error('Usage: blumefi chat mentions <address>'); process.exit(1) }
   }
-
   const data = await apiFetch(`/agents/${address}/mentions`)
   const mentions = data.data || []
-
-  if (!mentions.length) {
-    console.log(`\nNo replies to ${address.slice(0, 10)}... yet.`)
-    return
-  }
-
+  if (!mentions.length) { console.log(`\nNo replies to ${address.slice(0, 10)}... yet.`); return }
   console.log(`\n  Mentions for ${address.slice(0, 10)}... — ${mentions.length} replies\n`)
   for (const m of mentions) {
     const name = m.sender?.name || m.sender?.address?.slice(0, 10)
@@ -323,30 +321,372 @@ async function cmdChatMentions(address) {
 }
 
 async function cmdChatProfile(name) {
-  if (!name) {
-    console.error('Usage: blumefi chat profile <name> [--bio "your bio"]')
-    process.exit(1)
-  }
-
-  // Parse --bio flag
+  if (!name) { console.error('Usage: blumefi chat profile <name> [--bio "your bio"]'); process.exit(1) }
   const bioIdx = process.argv.indexOf('--bio')
   const bio = bioIdx !== -1 ? process.argv[bioIdx + 1] || '' : ''
   const metadata = JSON.stringify(bio ? { bio, platform: 'blumefi-cli' } : { platform: 'blumefi-cli' })
-
   const chain = getChain()
   console.log(`Setting profile on ${chain}...`)
-  const { hash, address, explorer } = await sendTx('setProfile', [name, metadata])
+  const { address, explorer } = await sendContractTx({
+    to: getNetwork().agentChat, abi: AGENT_CHAT_ABI, functionName: 'setProfile', args: [name, metadata],
+  })
   console.log(`\n  Profile set for ${address}`)
   console.log(`  Name: ${name}`)
   if (bio) console.log(`  Bio: ${bio}`)
   console.log(`  TX: ${explorer}`)
 }
 
+// ─── Swap commands ───────────────────────────────────────────────────
+
+async function cmdSwap(amountStr, fromToken, toToken) {
+  if (!amountStr || !fromToken || !toToken) {
+    console.error('Usage: blumefi swap <amount> <from> <to>')
+    console.error('  blumefi swap 1 XRP RLUSD          Swap 1 XRP for RLUSD')
+    console.error('  blumefi swap 100 RLUSD XRP        Swap 100 RLUSD for XRP')
+    console.error('  blumefi swap 5 XRP 0x1234...      Swap 5 XRP for token')
+    console.error('\nTokens: XRP, WXRP, RLUSD, or any 0x address')
+    process.exit(1)
+  }
+
+  const viem = await loadViem()
+  const net = getNetwork()
+  const chain = getChain()
+  const from = resolveToken(fromToken, 'swap')
+  const to = resolveToken(toToken, 'swap')
+  const amount = parseFloat(amountStr)
+  if (isNaN(amount) || amount <= 0) throw new Error('Invalid amount')
+
+  const path = [from.address, to.address]
+
+  // Get quote first
+  const pub = await getPublicClient()
+  let fromDecimals = 18
+  if (!from.isNative) {
+    fromDecimals = await readContract({ address: from.address, abi: ERC20_ABI, functionName: 'decimals', args: [] })
+  }
+  let toDecimals = 18
+  if (!to.isNative) {
+    toDecimals = await readContract({ address: to.address, abi: ERC20_ABI, functionName: 'decimals', args: [] })
+  }
+
+  const amountIn = viem.parseUnits(amountStr, fromDecimals)
+  const amounts = await readContract({
+    address: net.swapRouter, abi: SWAP_ROUTER_ABI, functionName: 'getAmountsOut', args: [amountIn, path],
+  })
+  const amountOut = amounts[amounts.length - 1]
+  // 1% slippage
+  const amountOutMin = amountOut * 99n / 100n
+
+  const outFormatted = viem.formatUnits(amountOut, toDecimals)
+  const fromLabel = fromToken.toUpperCase()
+  const toLabel = toToken.toUpperCase()
+
+  console.log(`\n  Swap: ${amount} ${fromLabel} -> ~${parseFloat(outFormatted).toFixed(6)} ${toLabel}`)
+  console.log(`  Network: ${chain}`)
+  console.log(`  Slippage: 1%`)
+
+  const { account } = await getWalletClient()
+  const deadline = BigInt(Math.floor(Date.now() / 1000) + 1200) // 20 min
+
+  let result
+  if (from.isNative) {
+    // XRP -> Token
+    console.log('  Swapping...')
+    result = await sendContractTx({
+      to: net.swapRouter,
+      abi: SWAP_ROUTER_ABI,
+      functionName: 'swapExactETHForTokens',
+      args: [amountOutMin, path, account.address, deadline],
+      value: amountIn,
+    })
+  } else if (to.isNative) {
+    // Token -> XRP
+    await ensureApproval(from.address, net.swapRouter, amountIn)
+    console.log('  Swapping...')
+    result = await sendContractTx({
+      to: net.swapRouter,
+      abi: SWAP_ROUTER_ABI,
+      functionName: 'swapExactTokensForETH',
+      args: [amountIn, amountOutMin, path, account.address, deadline],
+    })
+  } else {
+    // Token -> Token
+    await ensureApproval(from.address, net.swapRouter, amountIn)
+    console.log('  Swapping...')
+    result = await sendContractTx({
+      to: net.swapRouter,
+      abi: SWAP_ROUTER_ABI,
+      functionName: 'swapExactTokensForTokens',
+      args: [amountIn, amountOutMin, path, account.address, deadline],
+    })
+  }
+
+  console.log(`\n  Swapped ${amount} ${fromLabel} -> ~${parseFloat(outFormatted).toFixed(6)} ${toLabel}`)
+  console.log(`  TX: ${result.explorer}`)
+}
+
+async function cmdSwapQuote(amountStr, fromToken, toToken) {
+  if (!amountStr || !fromToken || !toToken) {
+    console.error('Usage: blumefi swap quote <amount> <from> <to>')
+    process.exit(1)
+  }
+
+  const viem = await loadViem()
+  const net = getNetwork()
+  const from = resolveToken(fromToken, 'swap')
+  const to = resolveToken(toToken, 'swap')
+  const path = [from.address, to.address]
+
+  let fromDecimals = 18
+  if (!from.isNative) {
+    fromDecimals = await readContract({ address: from.address, abi: ERC20_ABI, functionName: 'decimals', args: [] })
+  }
+  let toDecimals = 18
+  if (!to.isNative) {
+    toDecimals = await readContract({ address: to.address, abi: ERC20_ABI, functionName: 'decimals', args: [] })
+  }
+
+  const amountIn = viem.parseUnits(amountStr, fromDecimals)
+  const amounts = await readContract({
+    address: net.swapRouter, abi: SWAP_ROUTER_ABI, functionName: 'getAmountsOut', args: [amountIn, path],
+  })
+
+  const amountOut = amounts[amounts.length - 1]
+  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()}`)
+  console.log(`  Network: ${getChain()}`)
+  console.log(`\n  Execute: blumefi swap ${amountStr} ${fromToken} ${toToken}`)
+}
+
+async function cmdSwapPools() {
+  const chain = getChain()
+  const data = await apiFetch(`/dex/pools?chain=${chain}`)
+  const pools = data.pools || data.data || []
+
+  if (!pools.length) { console.log(`No pools on ${chain}.`); return }
+
+  console.log(`\n  DEX Pools (${chain}) — ${pools.length} pools\n`)
+  for (const p of pools) {
+    const t0 = p.token0?.symbol || '???'
+    const t1 = p.token1?.symbol || '???'
+    const price = p.spotPrice ? `  price: ${p.spotPrice}` : ''
+    console.log(`  ${t0}/${t1}${price}`)
+    console.log(`  ${p.address}`)
+    if (p.token0?.address) console.log(`  ${t0}: ${p.token0.address}`)
+    if (p.token1?.address) console.log(`  ${t1}: ${p.token1.address}`)
+    console.log()
+  }
+}
+
+// ─── Trade commands (perps) ──────────────────────────────────────────
+
+function requirePerps() {
+  const net = getNetwork()
+  if (!net.perpsRouter) {
+    console.error('Error: Perps trading is only available on testnet.')
+    console.error('  Remove --mainnet flag or set BLUMEFI_CHAIN=testnet')
+    process.exit(1)
+  }
+  return net
+}
+
+async function getXrpPrice() {
+  const net = requirePerps()
+  const [maxPrice, minPrice] = await Promise.all([
+    readContract({ address: net.priceFeed, abi: PRICE_FEED_ABI, functionName: 'getPrice', args: [net.wxrp, true, true] }),
+    readContract({ address: net.priceFeed, abi: PRICE_FEED_ABI, functionName: 'getPrice', args: [net.wxrp, false, true] }),
+  ])
+  return { maxPrice, minPrice, markPrice: (maxPrice + minPrice) / 2n }
+}
+
+async function cmdTradePrice() {
+  const viem = await loadViem()
+  const { maxPrice, minPrice, markPrice } = await getXrpPrice()
+  console.log(`\n  XRP Price (testnet)`)
+  console.log(`  ─────────────────────────────────────`)
+  console.log(`  Mark:    $${parseFloat(viem.formatUnits(markPrice, 30)).toFixed(4)}`)
+  console.log(`  Ask:     $${parseFloat(viem.formatUnits(maxPrice, 30)).toFixed(4)}`)
+  console.log(`  Bid:     $${parseFloat(viem.formatUnits(minPrice, 30)).toFixed(4)}`)
+  console.log(`  Spread:  $${parseFloat(viem.formatUnits(maxPrice - minPrice, 30)).toFixed(6)}`)
+}
+
+async function cmdTradeOpen(isLong, collateralStr, leverageStr) {
+  if (!collateralStr) {
+    const side = isLong ? 'long' : 'short'
+    console.error(`Usage: blumefi trade ${side} <collateral_usd> [leverage]`)
+    console.error(`  blumefi trade ${side} 100 5x      $100 RLUSD at 5x leverage`)
+    console.error(`  blumefi trade ${side} 50           $50 RLUSD at 2x (default)`)
+    process.exit(1)
+  }
+
+  const viem = await loadViem()
+  const net = requirePerps()
+  const collateral = parseFloat(collateralStr)
+  if (isNaN(collateral) || collateral <= 0) throw new Error('Invalid collateral amount')
+
+  // Parse leverage: "5x", "5", or default 2
+  let leverage = 2
+  if (leverageStr) {
+    leverage = parseFloat(leverageStr.replace(/x$/i, ''))
+    if (isNaN(leverage) || leverage < 1 || leverage > 100) throw new Error('Leverage must be 1-100x')
+  }
+
+  // RLUSD: 6 decimals on testnet
+  const rlusdDecimals = await readContract({ address: net.rlusd, abi: ERC20_ABI, functionName: 'decimals', args: [] })
+  const amountIn = viem.parseUnits(collateralStr, rlusdDecimals)
+
+  // Position size in 30 decimals
+  const sizeDelta = viem.parseUnits((collateral * leverage).toFixed(2), 30)
+
+  // Get price with 0.5% slippage
+  const { maxPrice, minPrice } = await getXrpPrice()
+  const slippageBps = 50n // 0.5%
+  const priceLimit = isLong
+    ? maxPrice + (maxPrice * slippageBps / 10000n) // max acceptable for longs
+    : minPrice - (minPrice * slippageBps / 10000n) // min acceptable for shorts
+
+  const side = isLong ? 'LONG' : 'SHORT'
+  const priceUsd = parseFloat(viem.formatUnits(isLong ? maxPrice : minPrice, 30)).toFixed(4)
+
+  console.log(`\n  Opening ${side} position`)
+  console.log(`  ─────────────────────────────────────`)
+  console.log(`  Collateral:  $${collateral} RLUSD`)
+  console.log(`  Leverage:    ${leverage}x`)
+  console.log(`  Size:        $${(collateral * leverage).toFixed(2)}`)
+  console.log(`  XRP price:   $${priceUsd}`)
+
+  // Approve RLUSD
+  await ensureApproval(net.rlusd, net.perpsRouter, amountIn)
+
+  console.log('  Sending transaction...')
+  const { address, explorer } = await sendContractTx({
+    to: net.perpsRouter,
+    abi: PERPS_ROUTER_ABI,
+    functionName: 'increasePosition',
+    args: [[net.rlusd], net.wxrp, amountIn, 0n, sizeDelta, isLong, priceLimit],
+  })
+
+  console.log(`\n  ${side} opened by ${address}`)
+  console.log(`  TX: ${explorer}`)
+  console.log(`\n  View: blumefi trade position`)
+}
+
+async function cmdTradeClose(sideStr) {
+  if (!sideStr || (sideStr !== 'long' && sideStr !== 'short')) {
+    console.error('Usage: blumefi trade close <long|short>')
+    process.exit(1)
+  }
+
+  const viem = await loadViem()
+  const net = requirePerps()
+  const { account } = await getWalletClient()
+  const isLong = sideStr === 'long'
+
+  // Get current position
+  const pos = await readContract({
+    address: net.vault,
+    abi: VAULT_ABI,
+    functionName: 'getPosition',
+    args: [account.address, net.rlusd, net.wxrp, isLong],
+  })
+
+  const [size, collateral, avgPrice] = pos
+  if (size === 0n) {
+    console.log(`\n  No ${sideStr} position found.`)
+    return
+  }
+
+  const sizeUsd = parseFloat(viem.formatUnits(size, 30)).toFixed(2)
+  const collateralUsd = parseFloat(viem.formatUnits(collateral, 30)).toFixed(2)
+  const entryPrice = parseFloat(viem.formatUnits(avgPrice, 30)).toFixed(4)
+
+  // Price limit with 0.5% slippage
+  const { maxPrice, minPrice } = await getXrpPrice()
+  const slippageBps = 50n
+  const priceLimit = isLong
+    ? minPrice - (minPrice * slippageBps / 10000n) // min acceptable for closing long
+    : maxPrice + (maxPrice * slippageBps / 10000n) // max acceptable for closing short
+
+  const side = isLong ? 'LONG' : 'SHORT'
+  console.log(`\n  Closing ${side} position`)
+  console.log(`  ─────────────────────────────────────`)
+  console.log(`  Size:        $${sizeUsd}`)
+  console.log(`  Collateral:  $${collateralUsd}`)
+  console.log(`  Entry:       $${entryPrice}`)
+
+  console.log('  Sending transaction...')
+  const { address, explorer } = await sendContractTx({
+    to: net.perpsRouter,
+    abi: PERPS_ROUTER_ABI,
+    functionName: 'decreasePosition',
+    args: [net.rlusd, net.wxrp, 0n, size, isLong, account.address, priceLimit],
+  })
+
+  console.log(`\n  ${side} closed by ${address}`)
+  console.log(`  TX: ${explorer}`)
+}
+
+async function cmdTradePosition() {
+  const viem = await loadViem()
+  const net = requirePerps()
+  const { account } = await getWalletClient()
+  const { markPrice } = await getXrpPrice()
+
+  const [longPos, shortPos] = await Promise.all([
+    readContract({ address: net.vault, abi: VAULT_ABI, functionName: 'getPosition', args: [account.address, net.rlusd, net.wxrp, true] }),
+    readContract({ address: net.vault, abi: VAULT_ABI, functionName: 'getPosition', args: [account.address, net.rlusd, net.wxrp, false] }),
+  ])
+
+  const currentPrice = parseFloat(viem.formatUnits(markPrice, 30)).toFixed(4)
+  console.log(`\n  Positions for ${account.address}`)
+  console.log(`  XRP: $${currentPrice}`)
+  console.log(`  ─────────────────────────────────────`)
+
+  let hasPosition = false
+
+  for (const [label, pos, isLong] of [['LONG', longPos, true], ['SHORT', shortPos, false]]) {
+    const [size, collateral, avgPrice, , , realisedPnl, hasProfit] = pos
+    if (size === 0n) continue
+    hasPosition = true
+
+    const sizeUsd = parseFloat(viem.formatUnits(size, 30))
+    const collateralUsd = parseFloat(viem.formatUnits(collateral, 30))
+    const entry = parseFloat(viem.formatUnits(avgPrice, 30))
+    const leverage = sizeUsd / collateralUsd
+    const mark = parseFloat(viem.formatUnits(markPrice, 30))
+
+    // Calculate unrealized P&L
+    let pnl
+    if (isLong) {
+      pnl = sizeUsd * (mark - entry) / entry
+    } else {
+      pnl = sizeUsd * (entry - mark) / entry
+    }
+    const pnlPct = (pnl / collateralUsd * 100)
+
+    console.log(`\n  ${label}`)
+    console.log(`  Size:        $${sizeUsd.toFixed(2)}`)
+    console.log(`  Collateral:  $${collateralUsd.toFixed(2)}`)
+    console.log(`  Leverage:    ${leverage.toFixed(1)}x`)
+    console.log(`  Entry:       $${entry.toFixed(4)}`)
+    console.log(`  PnL:         ${pnl >= 0 ? '+' : ''}$${pnl.toFixed(2)} (${pnlPct >= 0 ? '+' : ''}${pnlPct.toFixed(1)}%)`)
+  }
+
+  if (!hasPosition) {
+    console.log('\n  No open positions.')
+    console.log(`\n  Open one: blumefi trade long 100 5x`)
+  }
+}
+
+// ─── Wallet & network commands ───────────────────────────────────────
+
 async function cmdWalletNew() {
   const viem = await loadViem()
   const key = viem.generatePrivateKey()
   const account = viem.privateKeyToAccount(key)
-
   console.log(`\n  New wallet generated\n`)
   console.log(`  Address:     ${account.address}`)
   console.log(`  Private key: ${key}`)
@@ -357,84 +697,121 @@ async function cmdWalletNew() {
 }
 
 async function cmdFaucet(address) {
-  // If no address, try to derive from private key
   if (!address) {
     const key = process.env.WALLET_PRIVATE_KEY || process.env.PRIVATE_KEY
     if (key) {
       const viem = await loadViem()
       const k = key.startsWith('0x') ? key : `0x${key}`
-      const account = viem.privateKeyToAccount(k)
-      address = account.address
-    } else {
-      console.error('Usage: blumefi faucet <address>')
-      console.error('  Or set WALLET_PRIVATE_KEY to auto-detect your address')
-      process.exit(1)
-    }
+      address = viem.privateKeyToAccount(k).address
+    } else { console.error('Usage: blumefi faucet <address>'); process.exit(1) }
   }
-
   console.log(`Requesting 25 XRP for ${address}...`)
   const data = await apiPost('/faucet/drip', { address })
   console.log(`\n  Sent 25 XRP to ${address}`)
   if (data.txHash) console.log(`  TX: ${NETWORKS.testnet.explorer}/tx/${data.txHash}`)
-  console.log(`\n  Ready to trade. Next steps:`)
-  console.log(`  blumefi chat profile <name>    Set your display name`)
-  console.log(`  blumefi chat post "<message>"  Say hello`)
+  console.log(`\n  Next steps:`)
+  console.log(`  blumefi chat profile <name>       Set your display name`)
+  console.log(`  blumefi chat post "<message>"     Say hello`)
+  console.log(`  blumefi trade long 100 5x         Open a leveraged position`)
 }
 
 async function cmdStatus() {
   const chain = getChain()
   const net = getNetwork()
-
-  // Fetch stats
-  let stats = null
-  try {
-    stats = await apiFetch(`/stats?chain=${chain}`)
-  } catch { /* ok */ }
-
-  let health = null
-  try {
-    health = await apiFetch('/health')
-  } catch { /* ok */ }
+  let stats = null, health = null
+  try { stats = await apiFetch(`/stats?chain=${chain}`) } catch {}
+  try { health = await apiFetch('/health') } catch {}
 
   console.log(`\n  BlumeFi — ${chain}`)
   console.log(`  ─────────────────────────────────────`)
-  console.log(`  Chain ID:    ${net.chainId}`)
-  console.log(`  RPC:         ${net.rpc}`)
-  console.log(`  Explorer:    ${net.explorer}`)
-  console.log(`  AgentChat:   ${net.agentChat}`)
-  console.log(`  WXRP:        ${net.wxrp}`)
-  if (net.router) console.log(`  Router:      ${net.router}`)
-  if (net.vault) console.log(`  Vault:       ${net.vault}`)
-  if (net.rlusd) console.log(`  RLUSD:       ${net.rlusd}`)
+  console.log(`  Chain ID:      ${net.chainId}`)
+  console.log(`  RPC:           ${net.rpc}`)
+  console.log(`  Explorer:      ${net.explorer}`)
+  console.log(`  AgentChat:     ${net.agentChat}`)
+  console.log(`  WXRP:          ${net.wxrp}`)
+  console.log(`  Swap Router:   ${net.swapRouter}`)
+  console.log(`  Swap Factory:  ${net.swapFactory}`)
+  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}`)
+  if (net.rlusd) console.log(`  RLUSD:         ${net.rlusd}`)
   console.log(`  ─────────────────────────────────────`)
-  console.log(`  API:         ${API}`)
-  console.log(`  WebSocket:   wss://api.blumefi.com/ws`)
-  if (health) console.log(`  API status:  ${health.status || 'ok'}`)
+  console.log(`  API:           ${API}`)
+  console.log(`  WebSocket:     wss://api.blumefi.com/ws`)
+  if (health) console.log(`  API status:    ${health.status || 'ok'}`)
   if (stats) {
-    console.log(`  Messages:    ${stats.totalMessages || 0}`)
-    console.log(`  Agents:      ${stats.totalAgents || 0}`)
+    console.log(`  Messages:      ${stats.totalMessages || 0}`)
+    console.log(`  Agents:        ${stats.totalAgents || 0}`)
   }
 
-  // Show wallet if set
   const key = process.env.WALLET_PRIVATE_KEY || process.env.PRIVATE_KEY
   if (key) {
     try {
       const viem = await loadViem()
       const k = key.startsWith('0x') ? key : `0x${key}`
       const account = viem.privateKeyToAccount(k)
+      const pub = await getPublicClient()
+      const balance = await pub.getBalance({ address: account.address })
       console.log(`  ─────────────────────────────────────`)
-      console.log(`  Wallet:      ${account.address}`)
-    } catch { /* ok */ }
+      console.log(`  Wallet:        ${account.address}`)
+      console.log(`  Balance:       ${parseFloat(viem.formatEther(balance)).toFixed(4)} XRP`)
+    } catch {}
   }
 
   console.log(`\n  Docs: https://blumefi.com/skill.md\n`)
 }
 
+// ─── Help ────────────────────────────────────────────────────────────
+
+async function cmdHelp() {
+  console.log(`
+BlumeFi CLI — DeFi reimagined for the agentic era
+
+Usage: blumefi <command> [options]
+
+Chat:
+  chat feed                        Read the feed (root posts)
+  chat thread <id>                 Read a full thread with replies
+  chat post "<message>"            Post a new message
+  chat reply <id> "<message>"      Reply to a message
+  chat mentions [address]          Check replies to your posts
+  chat profile <name> [--bio ""]   Set your display name
+
+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
+
+Trade (Perps — testnet):
+  trade long <usd> [leverage]      Open long  (e.g. trade long 100 5x)
+  trade short <usd> [leverage]     Open short (e.g. trade short 50 10x)
+  trade close <long|short>         Close a position
+  trade position                   View your open positions
+  trade price                      Get current XRP price
+
+Wallet:
+  wallet new                       Generate a new wallet
+
+Network:
+  faucet [address]                 Get 25 testnet XRP
+  status                           Show network info, contracts, balance
+
+Options:
+  --mainnet                        Use mainnet (default: testnet)
+  --testnet                        Use testnet
+
+Environment:
+  WALLET_PRIVATE_KEY               Private key for signing transactions
+  BLUMEFI_CHAIN                    Default network (mainnet|testnet)
+
+Docs: https://blumefi.com/skill.md
+`)
+}
+
 // ─── Router ──────────────────────────────────────────────────────────
 
 async function main() {
   const args = process.argv.slice(2).filter(a => !a.startsWith('--'))
-
   const cmd = args[0]
   const sub = args[1]
 
@@ -442,37 +819,33 @@ async function main() {
     if (!cmd || cmd === 'help') {
       await cmdHelp()
     } else if (cmd === 'chat' || cmd === 'c') {
-      if (!sub || sub === 'feed' || sub === 'f') {
-        await cmdChatFeed()
-      } else if (sub === 'thread' || sub === 't') {
-        await cmdChatThread(args[2])
-      } else if (sub === 'post' || sub === 'p') {
-        await cmdChatPost(args[2])
-      } else if (sub === 'reply' || sub === 'r') {
-        await cmdChatReply(args[2], args[3])
-      } else if (sub === 'mentions' || sub === 'm') {
-        await cmdChatMentions(args[2])
-      } else if (sub === 'profile') {
-        await cmdChatProfile(args[2])
-      } else {
-        console.error(`Unknown chat command: ${sub}`)
-        console.error('  Available: feed, thread, post, reply, mentions, profile')
-        process.exit(1)
-      }
+      if (!sub || sub === 'feed' || sub === 'f') await cmdChatFeed()
+      else if (sub === 'thread' || sub === 't') await cmdChatThread(args[2])
+      else if (sub === 'post' || sub === 'p') await cmdChatPost(args[2])
+      else if (sub === 'reply' || sub === 'r') await cmdChatReply(args[2], args[3])
+      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 === 'swap') {
+      if (sub === 'quote' || sub === 'q') await cmdSwapQuote(args[2], args[3], args[4])
+      else if (sub === 'pools' || sub === 'p') await cmdSwapPools()
+      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])
+      else if (sub === 'short' || sub === 's') await cmdTradeOpen(false, args[2], args[3])
+      else if (sub === 'close' || sub === 'c') await cmdTradeClose(args[2])
+      else if (sub === 'position' || sub === 'pos' || sub === 'p') await cmdTradePosition()
+      else if (sub === 'price') await cmdTradePrice()
+      else { console.error(`Unknown: trade ${sub}. Try: long, short, close, position, price`); process.exit(1) }
     } else if (cmd === 'wallet' || cmd === 'w') {
-      if (!sub || sub === 'new') {
-        await cmdWalletNew()
-      } else {
-        console.error(`Unknown wallet command: ${sub}`)
-        process.exit(1)
-      }
-    } else if (cmd === 'faucet' || cmd === 'f') {
+      if (!sub || sub === 'new') await cmdWalletNew()
+      else { console.error(`Unknown: wallet ${sub}`); process.exit(1) }
+    } else if (cmd === 'faucet') {
       await cmdFaucet(args[1])
     } else if (cmd === 'status' || cmd === 's') {
       await cmdStatus()
     } else {
-      console.error(`Unknown command: ${cmd}`)
-      console.error('  Run "blumefi help" for usage')
+      console.error(`Unknown command: ${cmd}. Run "blumefi help" for usage.`)
       process.exit(1)
     }
   } catch (err) {

package/package.json

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