@paylobster/cli 4.0.2 → 4.2.0

package/src/commands/bridge.ts

@@ -0,0 +1,443 @@
+import { Command } from 'commander';
+import { getWalletAddress } from '../lib/wallet';
+import { success, error, info, withSpinner, outputJSON, confirm } from '../lib/display';
+import chalk from 'chalk';
+import type { OutputOptions } from '../lib/types';
+
+const LIFI_API_URL = 'https://li.quest/v1';
+
+interface LiFiChain {
+  id: number;
+  name: string;
+  key: string;
+  chainType: string;
+  nativeToken: {
+    symbol: string;
+    decimals: number;
+  };
+}
+
+interface LiFiQuoteResponse {
+  estimate: {
+    fromAmount: string;
+    toAmount: string;
+    approvalAddress: string;
+    gasCosts: Array<{
+      amount: string;
+      amountUSD: string;
+    }>;
+    feeCosts: Array<{
+      amount: string;
+      amountUSD: string;
+      token: {
+        symbol: string;
+      };
+    }>;
+    executionDuration: number;
+  };
+  toolDetails: {
+    name: string;
+  };
+  action: {
+    fromChainId: number;
+    toChainId: number;
+    fromToken: {
+      symbol: string;
+      decimals: number;
+    };
+    toToken: {
+      symbol: string;
+      decimals: number;
+    };
+  };
+  transactionRequest?: {
+    to: string;
+    data: string;
+    value: string;
+    gasLimit: string;
+  };
+}
+
+interface LiFiStatusResponse {
+  status: string;
+  substatus: string;
+  sending: {
+    txHash: string;
+    amount: string;
+    token: {
+      symbol: string;
+    };
+  };
+  receiving?: {
+    txHash: string;
+    amount: string;
+    token: {
+      symbol: string;
+    };
+  };
+}
+
+// Chain name to ID mapping
+const CHAIN_IDS: Record<string, number> = {
+  base: 8453,
+  solana: 1151111081099710,
+  ethereum: 1,
+  polygon: 137,
+  arbitrum: 42161,
+  optimism: 10,
+  avalanche: 43114,
+  bsc: 56,
+};
+
+/**
+ * Resolve chain name to chain ID
+ */
+function resolveChainId(input: string): number {
+  const lowerInput = input.toLowerCase();
+  if (CHAIN_IDS[lowerInput]) {
+    return CHAIN_IDS[lowerInput];
+  }
+  // Try to parse as number
+  const parsed = parseInt(input, 10);
+  if (!isNaN(parsed)) {
+    return parsed;
+  }
+  throw new Error(`Unknown chain: ${input}`);
+}
+
+/**
+ * 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');
+  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 Li.Fi API
+ */
+async function callLiFiAPI(endpoint: string): Promise<any> {
+  const response = await fetch(`${LIFI_API_URL}${endpoint}`);
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Li.Fi API error: ${response.status} - ${errorText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Get bridge quote
+ */
+async function getBridgeQuote(
+  fromChain: number,
+  toChain: number,
+  fromToken: string,
+  toToken: string,
+  amount: string,
+  fromAddress: string
+): Promise<LiFiQuoteResponse> {
+  const endpoint = `/quote?fromChain=${fromChain}&toChain=${toChain}&fromToken=${fromToken}&toToken=${toToken}&fromAmount=${amount}&fromAddress=${fromAddress}`;
+  const response = await callLiFiAPI(endpoint);
+  return response;
+}
+
+/**
+ * Get bridge status
+ */
+async function getBridgeStatus(txHash: string): Promise<LiFiStatusResponse> {
+  const endpoint = `/status?txHash=${txHash}`;
+  return callLiFiAPI(endpoint);
+}
+
+/**
+ * Get supported chains
+ */
+async function getChains(): Promise<LiFiChain[]> {
+  const response = await callLiFiAPI('/chains');
+  return response.chains;
+}
+
+/**
+ * Create bridge command
+ */
+export function createBridgeCommand(): Command {
+  const cmd = new Command('bridge')
+    .description('Cross-chain token bridges using Li.Fi');
+
+  // Bridge quote subcommand
+  cmd
+    .command('quote')
+    .description('Get bridge quote')
+    .requiredOption('--from <chain>', 'Source chain (e.g., base, ethereum, solana)')
+    .requiredOption('--to <chain>', 'Destination chain')
+    .requiredOption('--token <token>', 'Token symbol (e.g., USDC)')
+    .requiredOption('--amount <amount>', 'Amount to bridge')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      from: string;
+      to: string;
+      token: string;
+      amount: string;
+    } & OutputOptions) => {
+      try {
+        const address = getWalletAddress() as `0x${string}`;
+        
+        const fromChainId = resolveChainId(options.from);
+        const toChainId = resolveChainId(options.to);
+        
+        // Assume 6 decimals for USDC, 18 for others
+        const decimals = options.token.toUpperCase() === 'USDC' ? 6 : 18;
+        const amount = parseTokenAmount(options.amount, decimals);
+
+        const quote = await withSpinner(
+          'Fetching bridge quote...',
+          async () => getBridgeQuote(
+            fromChainId,
+            toChainId,
+            options.token,
+            options.token,
+            amount,
+            address
+          )
+        );
+
+        const fromAmount = formatTokenAmount(
+          quote.estimate.fromAmount,
+          quote.action.fromToken.decimals
+        );
+        const toAmount = formatTokenAmount(
+          quote.estimate.toAmount,
+          quote.action.toToken.decimals
+        );
+
+        // Calculate fee
+        const totalFeeUSD = quote.estimate.feeCosts.reduce(
+          (sum, fee) => sum + parseFloat(fee.amountUSD || '0'),
+          0
+        );
+        const feeAmount = parseFloat(fromAmount) - parseFloat(toAmount);
+
+        // Format time
+        const timeMinutes = Math.ceil(quote.estimate.executionDuration / 60);
+
+        if (outputJSON({
+          fromChain: options.from,
+          toChain: options.to,
+          token: options.token.toUpperCase(),
+          fromAmount,
+          toAmount,
+          fee: feeAmount.toFixed(decimals),
+          feeUSD: totalFeeUSD.toFixed(2),
+          estimatedTime: `${timeMinutes} min`,
+          via: quote.toolDetails.name,
+        }, options)) {
+          return;
+        }
+
+        // Pretty output
+        console.log();
+        console.log(chalk.bold.cyan('🌉 Bridge Quote'));
+        console.log();
+        console.log('   From:', chalk.white.bold(fromAmount), chalk.gray(`${options.token.toUpperCase()} (${options.from})`));
+        console.log('   To:  ', chalk.white.bold(toAmount), chalk.gray(`${options.token.toUpperCase()} (${options.to})`));
+        console.log('   Fee: ', chalk.yellow(feeAmount.toFixed(decimals)), chalk.gray(`${options.token.toUpperCase()} (~$${totalFeeUSD.toFixed(2)})`));
+        console.log('   Time:', chalk.gray(`~${timeMinutes} min`));
+        console.log('   Via: ', chalk.gray(quote.toolDetails.name));
+        console.log();
+      } catch (err) {
+        error(`Failed to get bridge quote: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Bridge execute subcommand
+  cmd
+    .command('execute')
+    .description('Execute cross-chain bridge')
+    .requiredOption('--from <chain>', 'Source chain (e.g., base, ethereum, solana)')
+    .requiredOption('--to <chain>', 'Destination chain')
+    .requiredOption('--token <token>', 'Token symbol (e.g., USDC)')
+    .requiredOption('--amount <amount>', 'Amount to bridge')
+    .option('--yes', 'Skip confirmation')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      from: string;
+      to: string;
+      token: string;
+      amount: string;
+      yes?: boolean;
+    } & OutputOptions) => {
+      try {
+        const address = getWalletAddress() as `0x${string}`;
+        
+        const fromChainId = resolveChainId(options.from);
+        const toChainId = resolveChainId(options.to);
+        
+        const decimals = options.token.toUpperCase() === 'USDC' ? 6 : 18;
+        const amount = parseTokenAmount(options.amount, decimals);
+
+        const quote = await withSpinner(
+          'Fetching bridge quote...',
+          async () => getBridgeQuote(
+            fromChainId,
+            toChainId,
+            options.token,
+            options.token,
+            amount,
+            address
+          )
+        );
+
+        const fromAmount = formatTokenAmount(
+          quote.estimate.fromAmount,
+          quote.action.fromToken.decimals
+        );
+        const toAmount = formatTokenAmount(
+          quote.estimate.toAmount,
+          quote.action.toToken.decimals
+        );
+
+        // Show quote and confirm
+        if (!options.yes) {
+          console.log();
+          console.log(chalk.bold.cyan('🌉 Bridge Quote'));
+          console.log();
+          console.log('   From:', chalk.white.bold(fromAmount), chalk.gray(`${options.token.toUpperCase()} (${options.from})`));
+          console.log('   To:  ', chalk.white.bold(toAmount), chalk.gray(`${options.token.toUpperCase()} (${options.to})`));
+          console.log();
+
+          const confirmed = await confirm('Confirm bridge?');
+          if (!confirmed) {
+            info('Cancelled');
+            process.exit(0);
+          }
+        }
+
+        info('Bridge execution not yet implemented - requires viem integration');
+        info('Transaction data available in quote response');
+        
+        if (outputJSON({
+          quote,
+          note: 'Execute bridge by sending transaction with quote.transactionRequest',
+        }, options)) {
+          return;
+        }
+
+        if (quote.transactionRequest) {
+          console.log();
+          info('To execute this bridge, send a transaction with the following data:');
+          console.log(chalk.gray('  To:   '), quote.transactionRequest.to);
+          console.log(chalk.gray('  Data: '), quote.transactionRequest.data.slice(0, 66) + '...');
+          console.log();
+        }
+      } catch (err) {
+        error(`Failed to execute bridge: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Bridge status subcommand
+  cmd
+    .command('status')
+    .description('Check bridge transaction status')
+    .argument('<txHash>', 'Transaction hash')
+    .option('--json', 'Output as JSON')
+    .action(async (txHash: string, options: OutputOptions) => {
+      try {
+        const status = await withSpinner(
+          'Fetching bridge status...',
+          async () => getBridgeStatus(txHash)
+        );
+
+        if (outputJSON(status, options)) {
+          return;
+        }
+
+        console.log();
+        console.log(chalk.bold.cyan('🌉 Bridge Status'));
+        console.log();
+        console.log('   Status:  ', chalk.white.bold(status.status));
+        console.log('   Substatus:', chalk.gray(status.substatus));
+        console.log();
+        console.log('   Sending:');
+        console.log('     Tx:    ', chalk.gray(status.sending.txHash));
+        console.log('     Amount:', chalk.white(status.sending.amount), chalk.gray(status.sending.token.symbol));
+        
+        if (status.receiving) {
+          console.log();
+          console.log('   Receiving:');
+          console.log('     Tx:    ', chalk.gray(status.receiving.txHash));
+          console.log('     Amount:', chalk.white(status.receiving.amount), chalk.gray(status.receiving.token.symbol));
+        }
+        console.log();
+      } catch (err) {
+        error(`Failed to get bridge status: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // List chains subcommand
+  cmd
+    .command('chains')
+    .description('List supported chains')
+    .option('--json', 'Output as JSON')
+    .action(async (options: OutputOptions) => {
+      try {
+        const chains = await withSpinner(
+          'Fetching supported chains...',
+          async () => getChains()
+        );
+
+        if (outputJSON({ chains }, options)) {
+          return;
+        }
+
+        console.log();
+        console.log(chalk.bold.cyan('🌐 Supported Chains'));
+        console.log();
+        
+        // Show popular chains first
+        const popularChains = chains.filter(c => 
+          ['bas', 'eth', 'pol', 'arb', 'opt', 'sol', 'ava', 'bsc'].includes(c.key.toLowerCase())
+        );
+        
+        for (const chain of popularChains) {
+          console.log(
+            chalk.white.bold(chain.name.padEnd(15)),
+            chalk.gray(`ID: ${chain.id}`),
+            chalk.dim(`(${chain.nativeToken.symbol})`)
+          );
+        }
+        
+        console.log();
+        console.log(chalk.dim(`${chains.length} total chains supported`));
+        console.log();
+      } catch (err) {
+        error(`Failed to fetch chains: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}