@paylobster/cli 4.0.2 → 4.2.0

package/src/commands/swap.ts

@@ -0,0 +1,365 @@
+import { Command } from 'commander';
+import { getWalletAddress } from '../lib/wallet';
+import { loadConfig, getConfigValue } from '../lib/config';
+import { success, error, info, withSpinner, outputJSON, confirm, formatNumber } from '../lib/display';
+import chalk from 'chalk';
+import type { OutputOptions } from '../lib/types';
+
+const ZERO_X_API_URL = 'https://api.0x.org';
+const BASE_CHAIN_ID = '8453';
+
+interface SwapQuoteResponse {
+  sellAmount: string;
+  buyAmount: string;
+  price: string;
+  estimatedGas: string;
+  gasPrice: string;
+  sellTokenAddress: string;
+  buyTokenAddress: string;
+  allowanceTarget: string;
+  transaction: {
+    to: string;
+    data: string;
+    value: string;
+    gas: string;
+    gasPrice: string;
+  };
+}
+
+interface TokenInfo {
+  symbol: string;
+  address: string;
+  decimals: number;
+}
+
+// Common Base tokens
+const BASE_TOKENS: Record<string, TokenInfo> = {
+  USDC: { symbol: 'USDC', address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', decimals: 6 },
+  WETH: { symbol: 'WETH', address: '0x4200000000000000000000000000000000000006', decimals: 18 },
+  DAI: { symbol: 'DAI', address: '0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb', decimals: 18 },
+  USDbC: { symbol: 'USDbC', address: '0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA', decimals: 6 },
+  ETH: { symbol: 'ETH', address: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', decimals: 18 },
+};
+
+/**
+ * Resolve token symbol or address to token address
+ */
+function resolveToken(input: string): string {
+  const upperInput = input.toUpperCase();
+  if (BASE_TOKENS[upperInput]) {
+    return BASE_TOKENS[upperInput].address;
+  }
+  // Assume it's an address
+  if (input.startsWith('0x')) {
+    return input;
+  }
+  throw new Error(`Unknown token: ${input}`);
+}
+
+/**
+ * Get token decimals
+ */
+function getTokenDecimals(symbolOrAddress: string): number {
+  const upperInput = symbolOrAddress.toUpperCase();
+  if (BASE_TOKENS[upperInput]) {
+    return BASE_TOKENS[upperInput].decimals;
+  }
+  // Default to 18 decimals for unknown tokens
+  return 18;
+}
+
+/**
+ * Format amount with decimals
+ */
+function formatTokenAmount(amount: string, decimals: number): string {
+  const num = BigInt(amount);
+  const divisor = BigInt(10 ** decimals);
+  const whole = num / divisor;
+  const fraction = num % divisor;
+  
+  if (fraction === 0n) {
+    return whole.toString();
+  }
+  
+  const fractionStr = fraction.toString().padStart(decimals, '0');
+  // Trim trailing zeros
+  const trimmed = fractionStr.replace(/0+$/, '');
+  return `${whole}.${trimmed}`;
+}
+
+/**
+ * Parse amount with decimals
+ */
+function parseTokenAmount(amount: string, decimals: number): string {
+  const [whole = '0', fraction = '0'] = amount.split('.');
+  const paddedFraction = fraction.padEnd(decimals, '0').slice(0, decimals);
+  return (BigInt(whole) * BigInt(10 ** decimals) + BigInt(paddedFraction)).toString();
+}
+
+/**
+ * Call 0x API
+ */
+async function call0xAPI(endpoint: string): Promise<any> {
+  const config = loadConfig();
+  const apiKey = getConfigValue('0xApiKey') || process.env.ZERO_X_API_KEY;
+  
+  if (!apiKey) {
+    throw new Error('0x API key not configured. Set it with: plob config set 0xApiKey YOUR_KEY');
+  }
+
+  const response = await fetch(`${ZERO_X_API_URL}${endpoint}`, {
+    headers: {
+      '0x-api-key': apiKey,
+      '0x-version': 'v2',
+    },
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`0x API error: ${response.status} - ${errorText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Get swap quote
+ */
+async function getSwapQuote(
+  sellToken: string,
+  buyToken: string,
+  amount: string,
+  taker: string
+): Promise<SwapQuoteResponse> {
+  const endpoint = `/swap/allowance-holder/quote?chainId=${BASE_CHAIN_ID}&sellToken=${sellToken}&buyToken=${buyToken}&sellAmount=${amount}&taker=${taker}`;
+  return call0xAPI(endpoint);
+}
+
+/**
+ * Get swap price
+ */
+async function getSwapPrice(
+  sellToken: string,
+  buyToken: string,
+  amount: string
+): Promise<SwapQuoteResponse> {
+  const endpoint = `/swap/allowance-holder/price?chainId=${BASE_CHAIN_ID}&sellToken=${sellToken}&buyToken=${buyToken}&sellAmount=${amount}`;
+  return call0xAPI(endpoint);
+}
+
+/**
+ * Get token price
+ */
+async function getTokenPrice(tokenAddress: string): Promise<any> {
+  const endpoint = `/swap/allowance-holder/price?chainId=${BASE_CHAIN_ID}&sellToken=${tokenAddress}&buyToken=USDC&sellAmount=${parseTokenAmount('1', getTokenDecimals(tokenAddress))}`;
+  return call0xAPI(endpoint);
+}
+
+/**
+ * Create swap command
+ */
+export function createSwapCommand(): Command {
+  const cmd = new Command('swap')
+    .description('Token swaps on Base using 0x');
+
+  // Swap quote subcommand
+  cmd
+    .command('quote')
+    .description('Get swap quote')
+    .requiredOption('--from <token>', 'Token to sell (symbol or address)')
+    .requiredOption('--to <token>', 'Token to buy (symbol or address)')
+    .requiredOption('--amount <amount>', 'Amount to sell')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      from: string;
+      to: string;
+      amount: string;
+    } & OutputOptions) => {
+      try {
+        const address = getWalletAddress() as `0x${string}`;
+        
+        const sellToken = resolveToken(options.from);
+        const buyToken = resolveToken(options.to);
+        const sellDecimals = getTokenDecimals(options.from);
+        const buyDecimals = getTokenDecimals(options.to);
+        
+        const sellAmount = parseTokenAmount(options.amount, sellDecimals);
+
+        const quote = await withSpinner(
+          'Fetching swap quote...',
+          async () => getSwapQuote(sellToken, buyToken, sellAmount, address)
+        );
+
+        const buyAmountFormatted = formatTokenAmount(quote.buyAmount, buyDecimals);
+        const sellAmountFormatted = formatTokenAmount(quote.sellAmount, sellDecimals);
+        const pricePerToken = parseFloat(quote.price);
+        
+        // Calculate USD values (approximation using price ratio)
+        const buyValueUSD = parseFloat(sellAmountFormatted) * pricePerToken;
+        
+        // Calculate fee
+        const gasEstimate = BigInt(quote.estimatedGas);
+        const gasPrice = BigInt(quote.gasPrice);
+        const gasCostWei = gasEstimate * gasPrice;
+        const gasCostEth = formatTokenAmount(gasCostWei.toString(), 18);
+
+        if (outputJSON({
+          sellToken: options.from.toUpperCase(),
+          sellAmount: sellAmountFormatted,
+          buyToken: options.to.toUpperCase(),
+          buyAmount: buyAmountFormatted,
+          price: quote.price,
+          estimatedGas: quote.estimatedGas,
+          gasCostEth,
+        }, options)) {
+          return;
+        }
+
+        // Pretty output
+        console.log();
+        console.log(chalk.bold.cyan('🔄 Swap Quote'));
+        console.log();
+        console.log('   Sell:', chalk.white.bold(sellAmountFormatted), chalk.gray(options.from.toUpperCase()));
+        console.log('   Buy: ', chalk.white.bold(buyAmountFormatted), chalk.gray(options.to.toUpperCase()), chalk.green(`(~$${buyValueUSD.toFixed(2)})`));
+        console.log('   Rate:', chalk.white(`1 ${options.to.toUpperCase()} = ${(1 / pricePerToken).toFixed(6)} ${options.from.toUpperCase()}`));
+        console.log('   Gas: ', chalk.gray(`~$${(parseFloat(gasCostEth) * 3000).toFixed(2)}`), chalk.dim(`(${gasCostEth} ETH)`));
+        console.log();
+      } catch (err) {
+        error(`Failed to get swap quote: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Swap execute subcommand
+  cmd
+    .command('execute')
+    .description('Execute token swap')
+    .requiredOption('--from <token>', 'Token to sell (symbol or address)')
+    .requiredOption('--to <token>', 'Token to buy (symbol or address)')
+    .requiredOption('--amount <amount>', 'Amount to sell')
+    .option('--yes', 'Skip confirmation')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      from: string;
+      to: string;
+      amount: string;
+      yes?: boolean;
+    } & OutputOptions) => {
+      try {
+        const address = getWalletAddress() as `0x${string}`;
+        
+        const sellToken = resolveToken(options.from);
+        const buyToken = resolveToken(options.to);
+        const sellDecimals = getTokenDecimals(options.from);
+        const buyDecimals = getTokenDecimals(options.to);
+        
+        const sellAmount = parseTokenAmount(options.amount, sellDecimals);
+
+        const quote = await withSpinner(
+          'Fetching swap quote...',
+          async () => getSwapQuote(sellToken, buyToken, sellAmount, address)
+        );
+
+        const buyAmountFormatted = formatTokenAmount(quote.buyAmount, buyDecimals);
+        const sellAmountFormatted = formatTokenAmount(quote.sellAmount, sellDecimals);
+
+        // Show quote and confirm
+        if (!options.yes) {
+          console.log();
+          console.log(chalk.bold.cyan('🔄 Swap Quote'));
+          console.log();
+          console.log('   Sell:', chalk.white.bold(sellAmountFormatted), chalk.gray(options.from.toUpperCase()));
+          console.log('   Buy: ', chalk.white.bold(buyAmountFormatted), chalk.gray(options.to.toUpperCase()));
+          console.log();
+
+          const confirmed = await confirm('Confirm swap?');
+          if (!confirmed) {
+            info('Cancelled');
+            process.exit(0);
+          }
+        }
+
+        info('Swap execution not yet implemented - requires viem integration');
+        info('Transaction data available in quote response');
+        
+        if (outputJSON({
+          quote,
+          note: 'Execute swap by sending transaction to quote.transaction.to with quote.transaction.data',
+        }, options)) {
+          return;
+        }
+
+        console.log();
+        info('To execute this swap, send a transaction with the following data:');
+        console.log(chalk.gray('  To:   '), quote.transaction.to);
+        console.log(chalk.gray('  Data: '), quote.transaction.data.slice(0, 66) + '...');
+        console.log();
+      } catch (err) {
+        error(`Failed to execute swap: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // List tokens subcommand
+  cmd
+    .command('tokens')
+    .description('List available tokens on Base')
+    .option('--json', 'Output as JSON')
+    .action(async (options: OutputOptions) => {
+      const tokens = Object.values(BASE_TOKENS).map(t => ({
+        symbol: t.symbol,
+        address: t.address,
+        decimals: t.decimals,
+      }));
+
+      if (outputJSON({ tokens }, options)) {
+        return;
+      }
+
+      console.log();
+      console.log(chalk.bold.cyan('🪙  Available Tokens on Base'));
+      console.log();
+      
+      for (const token of tokens) {
+        console.log(chalk.white.bold(token.symbol.padEnd(8)), chalk.gray(token.address), chalk.dim(`(${token.decimals} decimals)`));
+      }
+      console.log();
+    });
+
+  // Get token price subcommand
+  cmd
+    .command('price')
+    .description('Get token price in USDC')
+    .argument('<address>', 'Token address')
+    .option('--json', 'Output as JSON')
+    .action(async (address: string, options: OutputOptions) => {
+      try {
+        const priceData = await withSpinner(
+          'Fetching token price...',
+          async () => getTokenPrice(address)
+        );
+
+        const decimals = getTokenDecimals(address);
+        const buyAmount = formatTokenAmount(priceData.buyAmount, 6); // USDC has 6 decimals
+
+        if (outputJSON({
+          tokenAddress: address,
+          priceUSDC: buyAmount,
+        }, options)) {
+          return;
+        }
+
+        console.log();
+        console.log(chalk.bold.cyan('💵 Token Price'));
+        console.log();
+        console.log('   Token:  ', chalk.white(address));
+        console.log('   Price:  ', chalk.white.bold(buyAmount), chalk.gray('USDC'));
+        console.log();
+      } catch (err) {
+        error(`Failed to get token price: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/index.ts

@@ -9,6 +9,17 @@ import { createEscrowCommand } from './commands/escrow';
 import { createMandateCommand } from './commands/mandate';
 import { createPayCommand } from './commands/pay';
 import { createReputationCommand } from './commands/reputation';
+import { createStreamCommand } from './commands/stream';
+import { createDisputeCommand } from './commands/dispute';
+import { createCreditScoreCommand } from './commands/credit-score';
+import { createCascadeCommand } from './commands/cascade';
+import { createIntentCommand } from './commands/intent';
+import { createComplianceCommand } from './commands/compliance';
+import { createOracleCommand } from './commands/oracle';
+import { createRevenueShareCommand } from './commands/revenue-share';
+import { createSwapCommand } from './commands/swap';
+import { createBridgeCommand } from './commands/bridge';
+import { createPortfolioCommand } from './commands/portfolio';
 import chalk from 'chalk';
 
 // Load environment variables from .env file if present
@@ -20,7 +31,7 @@ const program = new Command();
 program
   .name('plob')
   .description('🦞 PayLobster CLI - Payment infrastructure for AI agents')
-  .version('4.0.0');
+  .version('4.2.0');
 
 // ASCII art banner
 const banner = `
@@ -44,6 +55,17 @@ program.addCommand(createEscrowCommand());
 program.addCommand(createMandateCommand());
 program.addCommand(createPayCommand());
 program.addCommand(createReputationCommand());
+program.addCommand(createStreamCommand());
+program.addCommand(createDisputeCommand());
+program.addCommand(createCreditScoreCommand());
+program.addCommand(createCascadeCommand());
+program.addCommand(createIntentCommand());
+program.addCommand(createComplianceCommand());
+program.addCommand(createOracleCommand());
+program.addCommand(createRevenueShareCommand());
+program.addCommand(createSwapCommand());
+program.addCommand(createBridgeCommand());
+program.addCommand(createPortfolioCommand());
 
 // Handle errors
 program.exitOverride((err) => {

package/src/lib/types.ts

@@ -10,6 +10,7 @@ export interface CLIConfig {
     path?: string;
   };
   indexerUrl?: string;
+  '0xApiKey'?: string;
 }
 
 export interface AgentInfo {