@paylobster/cli 4.5.0 → 4.6.1

package/src/commands/link.ts

@@ -0,0 +1,240 @@
+import { Command } from 'commander';
+import { success, error, info, withSpinner, outputJSON, formatAddress } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+
+const API_URL = process.env.PAYLOBSTER_API_URL || 'https://paylobster.com';
+
+interface PaymentLink {
+  id: string;
+  url: string;
+  shortUrl: string;
+  amount: string;
+  token: string;
+  memo: string;
+  recipient: string;
+  mode: 'direct' | 'escrow';
+  expiresAt: string | null;
+  createdAt: string;
+  paid?: boolean;
+  txHash?: string | null;
+}
+
+/**
+ * Payment links command
+ */
+export function createLinkCommand(): Command {
+  const cmd = new Command('link')
+    .description('Create and manage payment links');
+
+  // Create subcommand
+  cmd
+    .command('create')
+    .description('Create a payment link')
+    .requiredOption('--amount <amount>', 'Amount in tokens')
+    .requiredOption('--recipient <address>', 'Recipient address')
+    .option('--memo <text>', 'Payment memo/description')
+    .option('--token <symbol>', 'Token symbol', 'USDC')
+    .option('--mode <mode>', 'Payment mode: direct or escrow', 'direct')
+    .option('--expires-in <seconds>', 'Expiration time in seconds')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      amount: string;
+      recipient: string;
+      memo?: string;
+      token?: string;
+      mode?: string;
+      expiresIn?: string;
+    } & OutputOptions) => {
+      try {
+        // Validate recipient address
+        if (!options.recipient.startsWith('0x') || options.recipient.length !== 42) {
+          error('Invalid recipient address format');
+          process.exit(1);
+        }
+
+        // Validate amount
+        const amount = parseFloat(options.amount);
+        if (isNaN(amount) || amount <= 0) {
+          error('Invalid amount. Must be a positive number');
+          process.exit(1);
+        }
+
+        // Validate mode
+        if (options.mode && !['direct', 'escrow'].includes(options.mode)) {
+          error('Mode must be either "direct" or "escrow"');
+          process.exit(1);
+        }
+
+        const link = await withSpinner(
+          'Creating payment link...',
+          async () => {
+            const response = await fetch(`${API_URL}/api/v3/links`, {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+              },
+              body: JSON.stringify({
+                amount: options.amount,
+                recipient: options.recipient,
+                memo: options.memo,
+                token: options.token,
+                mode: options.mode,
+                expiresIn: options.expiresIn ? parseInt(options.expiresIn) : undefined,
+              }),
+            });
+
+            if (!response.ok) {
+              const err = await response.json() as { error?: string };
+              throw new Error(err.error || 'Failed to create payment link');
+            }
+
+            return response.json() as Promise<PaymentLink>;
+          }
+        );
+
+        if (outputJSON(link, options)) {
+          return;
+        }
+
+        success('Payment link created!');
+        console.log();
+        console.log('  Link ID:    ', link.id);
+        console.log('  URL:        ', link.url);
+        console.log('  Amount:     ', link.amount, link.token);
+        console.log('  Recipient:  ', formatAddress(link.recipient));
+        console.log('  Mode:       ', link.mode);
+        if (link.memo) {
+          console.log('  Memo:       ', link.memo);
+        }
+        if (link.expiresAt) {
+          console.log('  Expires:    ', new Date(link.expiresAt).toLocaleString());
+        }
+        console.log();
+        info('Share this link with the payer!');
+      } catch (err) {
+        error(`Failed to create payment link: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  // Get subcommand
+  cmd
+    .command('get <code>')
+    .description('Get payment link details')
+    .option('--json', 'Output as JSON')
+    .action(async (code: string, options: OutputOptions) => {
+      try {
+        const link = await withSpinner(
+          'Fetching payment link...',
+          async () => {
+            const response = await fetch(`${API_URL}/api/v3/links/${code}`, {
+              method: 'GET',
+              headers: {
+                'Content-Type': 'application/json',
+              },
+            });
+
+            if (!response.ok) {
+              const err = await response.json() as { error?: string };
+              throw new Error(err.error || 'Failed to fetch payment link');
+            }
+
+            return response.json() as Promise<PaymentLink & { expired?: boolean }>;
+          }
+        );
+
+        if (outputJSON(link, options)) {
+          return;
+        }
+
+        console.log();
+        console.log('Payment Link Details:');
+        console.log('  Link ID:    ', link.id);
+        console.log('  Amount:     ', link.amount, link.token);
+        console.log('  Recipient:  ', formatAddress(link.recipient));
+        console.log('  Mode:       ', link.mode);
+        console.log('  Status:     ', link.paid ? '✅ Paid' : link.expired ? '❌ Expired' : '⏳ Pending');
+        if (link.memo) {
+          console.log('  Memo:       ', link.memo);
+        }
+        if (link.txHash) {
+          console.log('  TX Hash:    ', link.txHash);
+        }
+        console.log('  Created:    ', new Date(link.createdAt).toLocaleString());
+        if (link.expiresAt) {
+          console.log('  Expires:    ', new Date(link.expiresAt).toLocaleString());
+        }
+        console.log();
+      } catch (err) {
+        error(`Failed to fetch payment link: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  // List subcommand
+  cmd
+    .command('list <recipient>')
+    .description('List payment links for a recipient')
+    .option('--json', 'Output as JSON')
+    .action(async (recipient: string, options: OutputOptions) => {
+      try {
+        // Validate recipient address
+        if (!recipient.startsWith('0x') || recipient.length !== 42) {
+          error('Invalid recipient address format');
+          process.exit(1);
+        }
+
+        const result = await withSpinner(
+          'Fetching payment links...',
+          async () => {
+            const response = await fetch(
+              `${API_URL}/api/v3/links?recipient=${encodeURIComponent(recipient)}`,
+              {
+                method: 'GET',
+                headers: {
+                  'Content-Type': 'application/json',
+                },
+              }
+            );
+
+            if (!response.ok) {
+              const err = await response.json() as { error?: string };
+              throw new Error(err.error || 'Failed to fetch payment links');
+            }
+
+            return response.json() as Promise<{ links: PaymentLink[]; total: number }>;
+          }
+        );
+
+        if (outputJSON(result, options)) {
+          return;
+        }
+
+        if (result.links.length === 0) {
+          info('No payment links found for this recipient');
+          return;
+        }
+
+        console.log();
+        console.log(`Found ${result.total} payment link(s):`);
+        console.log();
+
+        for (const link of result.links) {
+          console.log(`  ${link.id}`);
+          console.log(`    Amount:  ${link.amount} ${link.token}`);
+          console.log(`    Status:  ${link.paid ? '✅ Paid' : '⏳ Pending'}`);
+          console.log(`    Mode:    ${link.mode}`);
+          if (link.memo) {
+            console.log(`    Memo:    ${link.memo}`);
+          }
+          console.log(`    Created: ${new Date(link.createdAt).toLocaleString()}`);
+          console.log();
+        }
+      } catch (err) {
+        error(`Failed to fetch payment links: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/refund.ts

@@ -0,0 +1,250 @@
+import { Command } from 'commander';
+import { success, error, info, withSpinner, outputJSON, confirm } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+
+const API_URL = process.env.PAYLOBSTER_API_URL || 'https://paylobster.com';
+
+interface Refund {
+  refundId: string;
+  escrowId: number;
+  status: 'pending' | 'approved' | 'rejected' | 'processed';
+  amount: string;
+  reason: string;
+  txHash?: string;
+  auto?: boolean;
+  createdAt: string;
+  processedAt?: string;
+}
+
+/**
+ * Refunds command
+ */
+export function createRefundCommand(): Command {
+  const cmd = new Command('refund')
+    .description('Request and manage refunds');
+
+  // Request subcommand
+  cmd
+    .command('request')
+    .description('Request a refund for an escrow')
+    .requiredOption('--escrow-id <id>', 'Escrow ID')
+    .requiredOption('--reason <text>', 'Reason for refund')
+    .option('--tx-hash <hash>', 'Transaction hash (if applicable)')
+    .option('--yes', 'Skip confirmation')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      escrowId: string;
+      reason: string;
+      txHash?: string;
+      yes?: boolean;
+    } & OutputOptions) => {
+      try {
+        // Validate escrow ID
+        const escrowId = parseInt(options.escrowId);
+        if (isNaN(escrowId) || escrowId < 0) {
+          error('Invalid escrow ID. Must be a non-negative number');
+          process.exit(1);
+        }
+
+        // Confirm refund request
+        if (!options.yes) {
+          console.log();
+          console.log('Refund Request:');
+          console.log('  Escrow ID: ', escrowId);
+          console.log('  Reason:    ', options.reason);
+          console.log();
+
+          const confirmed = await confirm('Submit this refund request?');
+          if (!confirmed) {
+            info('Cancelled');
+            process.exit(0);
+          }
+        }
+
+        const refund = await withSpinner(
+          'Submitting refund request...',
+          async () => {
+            const response = await fetch(`${API_URL}/api/v3/refunds`, {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+              },
+              body: JSON.stringify({
+                escrowId,
+                reason: options.reason,
+                txHash: options.txHash,
+              }),
+            });
+
+            if (!response.ok) {
+              const err = await response.json() as { error?: string };
+              throw new Error(err.error || 'Failed to request refund');
+            }
+
+            return response.json() as Promise<Refund>;
+          }
+        );
+
+        if (outputJSON(refund, options)) {
+          return;
+        }
+
+        success('Refund request submitted!');
+        console.log();
+        console.log('  Refund ID:  ', refund.refundId);
+        console.log('  Escrow ID:  ', refund.escrowId);
+        console.log('  Status:     ', getStatusEmoji(refund.status), refund.status);
+        console.log('  Amount:     ', refund.amount);
+        console.log('  Reason:     ', refund.reason);
+        console.log('  Created:    ', new Date(refund.createdAt).toLocaleString());
+        console.log();
+        info('Your refund request will be processed according to the escrow terms');
+      } catch (err) {
+        error(`Failed to request refund: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  // Get subcommand
+  cmd
+    .command('get <refund-id>')
+    .description('Get refund status')
+    .option('--json', 'Output as JSON')
+    .action(async (refundId: string, options: OutputOptions) => {
+      try {
+        const refund = await withSpinner(
+          'Fetching refund details...',
+          async () => {
+            const response = await fetch(
+              `${API_URL}/api/v3/refunds?refundId=${encodeURIComponent(refundId)}`,
+              {
+                method: 'GET',
+                headers: {
+                  'Content-Type': 'application/json',
+                },
+              }
+            );
+
+            if (!response.ok) {
+              const err = await response.json() as { error?: string };
+              throw new Error(err.error || 'Failed to fetch refund');
+            }
+
+            return response.json() as Promise<Refund>;
+          }
+        );
+
+        if (outputJSON(refund, options)) {
+          return;
+        }
+
+        console.log();
+        console.log('Refund Details:');
+        console.log('  Refund ID:  ', refund.refundId);
+        console.log('  Escrow ID:  ', refund.escrowId);
+        console.log('  Status:     ', getStatusEmoji(refund.status), refund.status);
+        console.log('  Amount:     ', refund.amount);
+        console.log('  Reason:     ', refund.reason);
+        if (refund.auto) {
+          console.log('  Auto:       ', '✅ Automatic refund');
+        }
+        if (refund.txHash) {
+          console.log('  TX Hash:    ', refund.txHash);
+        }
+        console.log('  Created:    ', new Date(refund.createdAt).toLocaleString());
+        if (refund.processedAt) {
+          console.log('  Processed:  ', new Date(refund.processedAt).toLocaleString());
+        }
+        console.log();
+      } catch (err) {
+        error(`Failed to fetch refund: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  // List by escrow subcommand
+  cmd
+    .command('list <escrow-id>')
+    .description('List all refunds for an escrow')
+    .option('--json', 'Output as JSON')
+    .action(async (escrowIdStr: string, options: OutputOptions) => {
+      try {
+        // Validate escrow ID
+        const escrowId = parseInt(escrowIdStr);
+        if (isNaN(escrowId) || escrowId < 0) {
+          error('Invalid escrow ID. Must be a non-negative number');
+          process.exit(1);
+        }
+
+        const result = await withSpinner(
+          'Fetching refunds...',
+          async () => {
+            const response = await fetch(
+              `${API_URL}/api/v3/refunds?escrowId=${escrowId}`,
+              {
+                method: 'GET',
+                headers: {
+                  'Content-Type': 'application/json',
+                },
+              }
+            );
+
+            if (!response.ok) {
+              const err = await response.json() as { error?: string };
+              throw new Error(err.error || 'Failed to fetch refunds');
+            }
+
+            return response.json() as Promise<{ escrowId: number; refunds: Refund[] }>;
+          }
+        );
+
+        if (outputJSON(result, options)) {
+          return;
+        }
+
+        if (result.refunds.length === 0) {
+          info(`No refunds found for escrow ID ${escrowId}`);
+          return;
+        }
+
+        console.log();
+        console.log(`Found ${result.refunds.length} refund(s) for escrow ${escrowId}:`);
+        console.log();
+
+        for (const refund of result.refunds) {
+          console.log(`  ${refund.refundId}`);
+          console.log(`    Status:   ${getStatusEmoji(refund.status)} ${refund.status}`);
+          console.log(`    Amount:   ${refund.amount}`);
+          console.log(`    Reason:   ${refund.reason}`);
+          if (refund.auto) {
+            console.log(`    Auto:     ✅ Automatic`);
+          }
+          console.log(`    Created:  ${new Date(refund.createdAt).toLocaleString()}`);
+          if (refund.processedAt) {
+            console.log(`    Processed: ${new Date(refund.processedAt).toLocaleString()}`);
+          }
+          console.log();
+        }
+      } catch (err) {
+        error(`Failed to fetch refunds: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}
+
+function getStatusEmoji(status: string): string {
+  switch (status) {
+    case 'pending':
+      return '⏳';
+    case 'approved':
+      return '✅';
+    case 'rejected':
+      return '❌';
+    case 'processed':
+      return '✅';
+    default:
+      return '❓';
+  }
+}

package/src/commands/swap.ts

@@ -155,12 +155,42 @@ async function getTokenPrice(tokenAddress: string): Promise<any> {
   return call0xAPI(endpoint);
 }
 
+const API_BASE = process.env.PAYLOBSTER_API_URL || 'https://paylobster.com';
+
+/**
+ * Get smart route from PayLobster API
+ */
+async function getSmartRoute(
+  sellToken: string,
+  buyToken: string,
+  sellAmount: string,
+  takerAddress?: string
+): Promise<any> {
+  const res = await fetch(`${API_BASE}/api/v3/swap/route`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      tokenIn: sellToken,
+      tokenOut: buyToken,
+      amountIn: sellAmount,
+      takerAddress,
+    }),
+  });
+
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    throw new Error(data.error || `Smart route failed: ${res.status}`);
+  }
+
+  return res.json();
+}
+
 /**
  * Create swap command
  */
 export function createSwapCommand(): Command {
   const cmd = new Command('swap')
-    .description('Token swaps on Base using 0x');
+    .description('Token swaps on Base using 0x (with smart routing)');
 
   // Swap quote subcommand
   cmd
@@ -300,6 +330,95 @@ export function createSwapCommand(): Command {
       }
     });
 
+  // Smart swap subcommand (natural language style)
+  cmd
+    .command('auto')
+    .description('Smart swap with auto-routing (multi-hop if needed)')
+    .argument('<amount>', 'Amount to sell')
+    .argument('<fromToken>', 'Token to sell')
+    .argument('[toKeyword]', '"to" keyword (ignored)')
+    .argument('[toToken]', 'Token to buy')
+    .option('--usd', 'Interpret amount as USD value')
+    .option('--slippage <percent>', 'Slippage tolerance (default: 0.5)', '0.5')
+    .option('--yes', 'Skip confirmation')
+    .option('--json', 'Output as JSON')
+    .action(async (amount: string, fromTokenArg: string, toKeyword: string, toTokenArg: string, options: {
+      usd?: boolean;
+      slippage?: string;
+      yes?: boolean;
+    } & OutputOptions) => {
+      try {
+        const address = getWalletAddress() as `0x${string}`;
+
+        // Handle "10 USDC to ANTIHUNTER" pattern
+        let toToken = toTokenArg;
+        if (toKeyword && toKeyword.toLowerCase() !== 'to') {
+          // "swap auto 10 USDC ANTIHUNTER" — no "to" keyword
+          toToken = toKeyword;
+        }
+
+        if (!toToken) {
+          error('Missing destination token. Usage: paylobster swap auto 10 USDC to ANTIHUNTER');
+          process.exit(1);
+        }
+
+        const sellTokenAddr = resolveToken(fromTokenArg);
+        const buyTokenAddr = resolveToken(toToken);
+        const sellDecimals = getTokenDecimals(fromTokenArg);
+        const sellAmount = parseTokenAmount(amount.replace('$', ''), sellDecimals);
+
+        const routeData = await withSpinner(
+          '🧠 Finding best route...',
+          async () => getSmartRoute(sellTokenAddr, buyTokenAddr, sellAmount, address)
+        );
+
+        if (!routeData.bestRoute) {
+          error('No route found for this swap');
+          process.exit(1);
+        }
+
+        const route = routeData.bestRoute;
+        const hopCount = route.hops?.length || 1;
+
+        if (outputJSON(routeData, options)) return;
+
+        console.log();
+        console.log(chalk.bold.cyan('🧠 Smart Route Found'));
+        console.log();
+        console.log('   From:   ', chalk.white.bold(amount), chalk.gray(fromTokenArg.toUpperCase()));
+        console.log('   To:     ', chalk.white.bold(toToken.toUpperCase()));
+        console.log('   Route:  ', chalk.white(route.source || 'Auto'));
+        console.log('   Hops:   ', chalk.white(hopCount.toString()));
+
+        // Show each hop
+        if (route.hops) {
+          for (let i = 0; i < route.hops.length; i++) {
+            const hop = route.hops[i];
+            console.log(chalk.gray(`   Step ${i + 1}: `), chalk.dim(`${hop.dex}: ${hop.tokenIn.slice(0, 8)}... → ${hop.tokenOut.slice(0, 8)}...`));
+          }
+        }
+
+        console.log('   Output: ', chalk.green.bold(routeData.estimatedOutput));
+        console.log('   Impact: ', chalk.yellow(`${((routeData.priceImpact || 0) * 100).toFixed(2)}%`));
+        console.log('   Gas:    ', chalk.gray(`~${routeData.gasEstimate}`));
+        console.log();
+
+        if (!options.yes) {
+          const confirmed = await confirm('Execute this swap?');
+          if (!confirmed) {
+            info('Cancelled');
+            process.exit(0);
+          }
+        }
+
+        info('Swap execution requires wallet signing. Transaction data is available above.');
+        console.log();
+      } catch (err) {
+        error(`Smart swap failed: ${err}`);
+        process.exit(1);
+      }
+    });
+
   // List tokens subcommand
   cmd
     .command('tokens')