@paylobster/cli 4.6.0 → 4.6.1

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')

package/src/commands/webhook.ts

@@ -0,0 +1,260 @@
+import { Command } from 'commander';
+import { success, error, info, withSpinner, outputJSON } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+
+const API_URL = process.env.PAYLOBSTER_API_URL || 'https://paylobster.com';
+
+interface Webhook {
+  id: string;
+  url: string;
+  events: string[];
+  secret?: string;
+  createdAt: string;
+  status: 'active' | 'paused';
+  lastDeliveryAttempt?: string;
+  lastDeliveryStatus?: 'success' | 'failed';
+}
+
+/**
+ * Webhooks command
+ */
+export function createWebhookCommand(): Command {
+  const cmd = new Command('webhooks')
+    .description('Register and manage webhooks');
+
+  // Register subcommand
+  cmd
+    .command('register')
+    .description('Register a new webhook')
+    .requiredOption('--url <url>', 'Webhook URL')
+    .requiredOption('--events <events>', 'Comma-separated event types')
+    .option('--secret <secret>', 'Webhook secret for signature verification')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      url: string;
+      events: string;
+      secret?: string;
+    } & OutputOptions) => {
+      try {
+        // Validate URL
+        try {
+          new URL(options.url);
+        } catch {
+          error('Invalid URL format');
+          process.exit(1);
+        }
+
+        // Parse events
+        const events = options.events.split(',').map(e => e.trim()).filter(Boolean);
+        if (events.length === 0) {
+          error('At least one event type is required');
+          process.exit(1);
+        }
+
+        const webhook = await withSpinner(
+          'Registering webhook...',
+          async () => {
+            const response = await fetch(`${API_URL}/api/v3/webhooks`, {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+              },
+              body: JSON.stringify({
+                url: options.url,
+                events,
+                secret: options.secret,
+              }),
+            });
+
+            if (!response.ok) {
+              const err = await response.json() as { error?: string };
+              throw new Error(err.error || 'Failed to register webhook');
+            }
+
+            return response.json() as Promise<Webhook>;
+          }
+        );
+
+        if (outputJSON(webhook, options)) {
+          return;
+        }
+
+        success('Webhook registered!');
+        console.log();
+        console.log('  Webhook ID: ', webhook.id);
+        console.log('  URL:        ', webhook.url);
+        console.log('  Events:     ', webhook.events.join(', '));
+        console.log('  Status:     ', webhook.status);
+        if (webhook.secret) {
+          console.log('  Secret:     ', webhook.secret);
+        }
+        console.log();
+        info('Your webhook will receive notifications for the specified events');
+      } catch (err) {
+        error(`Failed to register webhook: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  // List subcommand
+  cmd
+    .command('list')
+    .description('List all registered webhooks')
+    .option('--address <address>', 'Filter by address')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      address?: string;
+    } & OutputOptions) => {
+      try {
+        const result = await withSpinner(
+          'Fetching webhooks...',
+          async () => {
+            const url = new URL(`${API_URL}/api/v3/webhooks`);
+            if (options.address) {
+              url.searchParams.set('address', options.address);
+            }
+
+            const response = await fetch(url.toString(), {
+              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 webhooks');
+            }
+
+            return response.json() as Promise<{ webhooks: Webhook[] }>;
+          }
+        );
+
+        if (outputJSON(result, options)) {
+          return;
+        }
+
+        if (result.webhooks.length === 0) {
+          info('No webhooks registered');
+          return;
+        }
+
+        console.log();
+        console.log(`Found ${result.webhooks.length} webhook(s):`);
+        console.log();
+
+        for (const webhook of result.webhooks) {
+          console.log(`  ${webhook.id}`);
+          console.log(`    URL:     ${webhook.url}`);
+          console.log(`    Events:  ${webhook.events.join(', ')}`);
+          console.log(`    Status:  ${webhook.status === 'active' ? '✅ Active' : '⏸️  Paused'}`);
+          if (webhook.lastDeliveryAttempt) {
+            const status = webhook.lastDeliveryStatus === 'success' ? '✅' : '❌';
+            console.log(`    Last:    ${status} ${new Date(webhook.lastDeliveryAttempt).toLocaleString()}`);
+          }
+          console.log();
+        }
+      } catch (err) {
+        error(`Failed to fetch webhooks: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  // Get subcommand
+  cmd
+    .command('get <id>')
+    .description('Get webhook details')
+    .option('--include-secret', 'Include webhook secret in output')
+    .option('--json', 'Output as JSON')
+    .action(async (id: string, options: {
+      includeSecret?: boolean;
+    } & OutputOptions) => {
+      try {
+        const webhook = await withSpinner(
+          'Fetching webhook...',
+          async () => {
+            const url = new URL(`${API_URL}/api/v3/webhooks/${id}`);
+            if (options.includeSecret) {
+              url.searchParams.set('includeSecret', 'true');
+            }
+
+            const response = await fetch(url.toString(), {
+              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 webhook');
+            }
+
+            return response.json() as Promise<Webhook>;
+          }
+        );
+
+        if (outputJSON(webhook, options)) {
+          return;
+        }
+
+        console.log();
+        console.log('Webhook Details:');
+        console.log('  ID:      ', webhook.id);
+        console.log('  URL:     ', webhook.url);
+        console.log('  Events:  ', webhook.events.join(', '));
+        console.log('  Status:  ', webhook.status === 'active' ? '✅ Active' : '⏸️  Paused');
+        if (webhook.secret) {
+          console.log('  Secret:  ', webhook.secret);
+        }
+        console.log('  Created: ', new Date(webhook.createdAt).toLocaleString());
+        if (webhook.lastDeliveryAttempt) {
+          const status = webhook.lastDeliveryStatus === 'success' ? '✅ Success' : '❌ Failed';
+          console.log('  Last:    ', `${status} at ${new Date(webhook.lastDeliveryAttempt).toLocaleString()}`);
+        }
+        console.log();
+      } catch (err) {
+        error(`Failed to fetch webhook: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  // Delete subcommand
+  cmd
+    .command('delete <id>')
+    .description('Delete a webhook')
+    .option('--json', 'Output as JSON')
+    .action(async (id: string, options: OutputOptions) => {
+      try {
+        const result = await withSpinner(
+          'Deleting webhook...',
+          async () => {
+            const response = await fetch(`${API_URL}/api/v3/webhooks/${id}`, {
+              method: 'DELETE',
+              headers: {
+                'Content-Type': 'application/json',
+              },
+            });
+
+            if (!response.ok) {
+              const err = await response.json() as { error?: string };
+              throw new Error(err.error || 'Failed to delete webhook');
+            }
+
+            return response.json() as Promise<{ success: boolean; message: string }>;
+          }
+        );
+
+        if (outputJSON(result, options)) {
+          return;
+        }
+
+        success('Webhook deleted successfully');
+      } catch (err) {
+        error(`Failed to delete webhook: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/index.ts

@@ -29,6 +29,11 @@ import { createHealthCommand } from './commands/health';
 import { createSearchCommand } from './commands/search';
 import { createExportCommand } from './commands/export';
 import { createTrustGraphCommand } from './commands/trust-graph';
+import { createInitCommand } from './commands/init';
+import { createLinkCommand } from './commands/link';
+import { createWebhookCommand } from './commands/webhook';
+import { createRefundCommand } from './commands/refund';
+import { createAlertsCommand } from './commands/alerts';
 import chalk from 'chalk';
 
 // Load environment variables from .env file if present
@@ -83,6 +88,11 @@ program.addCommand(createHealthCommand());
 program.addCommand(createSearchCommand());
 program.addCommand(createExportCommand());
 program.addCommand(createTrustGraphCommand());
+program.addCommand(createInitCommand());
+program.addCommand(createLinkCommand());
+program.addCommand(createWebhookCommand());
+program.addCommand(createRefundCommand());
+program.addCommand(createAlertsCommand());
 registerInvestCommand(program);
 
 // Handle errors

package/src/lib/contracts.ts

@@ -8,21 +8,21 @@ import type { Network, AgentInfo, Reputation, CreditStatus, EscrowInfo, Balance
 const CONTRACTS_MAINNET = {
   IDENTITY: '0xA174ee274F870631B3c330a85EBCad74120BE662' as Address,
   REPUTATION: '0x02bb4132a86134684976E2a52E43D59D89E64b29' as Address,
-  CREDIT: '0xD9241Ce8a721Ef5fcCAc5A11983addC526eC80E1' as Address,
-  ESCROW: '0x49EdEe04c78B7FeD5248A20706c7a6c540748806' as Address,
+  CREDIT: '0x4c22B52eacAB9eD2Ce018d032739a93eC68eD27a' as Address,
+  ESCROW: '0x703B528C1b07cd27992af9Ae11DD67bE685E489e' as Address,
   USDC: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913' as Address,
-  TRUST_GRAPH: '0x0000000000000000000000000000000000000000' as Address, // TODO: Deploy TrustGraph
+  TRUST_GRAPH: '0xbccd1d0a37ce981a13b3392d7881f94e28fa693b' as Address,
 };
 
 const CONTRACTS_SEPOLIA = {
   IDENTITY: '0x3dfA02Ed4F0e4F10E8031d7a4cB8Ea0bBbFbCB8c' as Address,
   // NOTE: Reputation address provided has 41 hex chars (invalid). Using placeholder.
-  // Original (invalid): 0xb0033901e3b94f4F36dA0b3e396942C1e78205C7d
-  REPUTATION: '0x0000000000000000000000000000000000000000' as Address, // TODO: Fix this address
+  // Was broken (41 hex chars) — fixed to correct address
+  REPUTATION: '0xb0033901e3b94f4F36dA0b3e59A1F4AD9f4f1697' as Address,
   CREDIT: '0xBA64e2b2F2a80D03A4B13b3396942C1e78205C7d' as Address,
   ESCROW: '0x78D1f50a1965dE34f6b5a3D3546C94FE1809Cd82' as Address,
   USDC: '0x036CbD53842c5426634e7929541eC2318f3dCF7e' as Address,
-  TRUST_GRAPH: '0x0000000000000000000000000000000000000000' as Address, // TODO: Deploy TrustGraph
+  TRUST_GRAPH: '0xbccd1d0a37ce981a13b3392d7881f94e28fa693b' as Address,
 };
 
 // ABIs