@paylobster/cli 4.0.2 → 4.2.0

package/src/commands/cascade.ts

@@ -0,0 +1,280 @@
+import { Command } from 'commander';
+import { success, error, info, warning, withSpinner, outputJSON, formatAddress, confirm, createTable } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+
+export function createCascadeCommand(): Command {
+  const cmd = new Command('cascade')
+    .description('Manage cascading payments');
+
+  // plob cascade create
+  cmd
+    .command('create')
+    .description('Create a cascading payment')
+    .requiredOption('--stages <number>', 'Number of stages')
+    .requiredOption('--amount <amount>', 'Total amount in USDC')
+    .requiredOption('--recipients <addresses>', 'Comma-separated recipient addresses')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      stages: string;
+      amount: string;
+      recipients: string;
+    } & OutputOptions) => {
+      try {
+        const stages = parseInt(options.stages);
+        if (isNaN(stages) || stages < 2) {
+          error('Invalid stages. Must be at least 2');
+          process.exit(1);
+        }
+
+        const amount = parseFloat(options.amount);
+        if (isNaN(amount) || amount <= 0) {
+          error('Invalid amount. Must be a positive number');
+          process.exit(1);
+        }
+
+        const recipients = options.recipients.split(',').map(r => r.trim());
+        
+        // Validate all addresses
+        for (const recipient of recipients) {
+          if (!recipient.startsWith('0x') || recipient.length !== 42) {
+            error(`Invalid recipient address: ${recipient}`);
+            process.exit(1);
+          }
+        }
+
+        if (recipients.length !== stages) {
+          error(`Number of recipients (${recipients.length}) must match stages (${stages})`);
+          process.exit(1);
+        }
+
+        info(`Creating ${stages}-stage cascade`);
+        info(`Total amount: ${options.amount} USDC`);
+        info(`Recipients: ${recipients.map(formatAddress).join(' → ')}`);
+
+        const cascadeId = Math.floor(Math.random() * 1000000);
+
+        const txHash = await withSpinner(
+          'Creating cascade payment...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          cascadeId,
+          stages,
+          amount: options.amount,
+          recipients,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Cascade payment created!');
+        info(`Cascade ID: ${cascadeId}`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to create cascade: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob cascade release
+  cmd
+    .command('release')
+    .description('Release a specific cascade level')
+    .argument('<cascadeId>', 'Cascade ID')
+    .requiredOption('--level <level>', 'Level to release (1-based)')
+    .option('--yes', 'Skip confirmation')
+    .option('--json', 'Output as JSON')
+    .action(async (cascadeId: string, options: {
+      level: string;
+      yes?: boolean;
+    } & OutputOptions) => {
+      try {
+        const level = parseInt(options.level);
+        if (isNaN(level) || level < 1) {
+          error('Invalid level. Must be at least 1');
+          process.exit(1);
+        }
+
+        if (!options.yes) {
+          const confirmed = await confirm(`Release level ${level} of cascade ${cascadeId}?`);
+          if (!confirmed) {
+            info('Cancelled');
+            process.exit(0);
+          }
+        }
+
+        const txHash = await withSpinner(
+          `Releasing cascade level ${level}...`,
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          cascadeId,
+          level,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success(`Cascade level ${level} released!`);
+        info(`Cascade ID: ${cascadeId}`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to release cascade: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob cascade release-all
+  cmd
+    .command('release-all')
+    .description('Release all remaining cascade levels')
+    .argument('<cascadeId>', 'Cascade ID')
+    .option('--yes', 'Skip confirmation')
+    .option('--json', 'Output as JSON')
+    .action(async (cascadeId: string, options: { yes?: boolean } & OutputOptions) => {
+      try {
+        if (!options.yes) {
+          const confirmed = await confirm(`Release ALL levels of cascade ${cascadeId}?`);
+          if (!confirmed) {
+            info('Cancelled');
+            process.exit(0);
+          }
+        }
+
+        const txHash = await withSpinner(
+          'Releasing all cascade levels...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          cascadeId,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('All cascade levels released!');
+        info(`Cascade ID: ${cascadeId}`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to release cascade: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob cascade get
+  cmd
+    .command('get')
+    .description('Get cascade details')
+    .argument('<cascadeId>', 'Cascade ID')
+    .option('--json', 'Output as JSON')
+    .action(async (cascadeId: string, options: OutputOptions) => {
+      try {
+        // Placeholder data
+        const cascade = {
+          id: cascadeId,
+          creator: '0x1234567890123456789012345678901234567890',
+          totalAmount: '1000 USDC',
+          stages: 3,
+          currentStage: 1,
+          recipients: [
+            { address: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb', released: true },
+            { address: '0x8626f6940E2eb28930eFb4CeF49B2d1F2C9C1199', released: false },
+            { address: '0x1111111111111111111111111111111111111111', released: false },
+          ],
+        };
+
+        if (outputJSON(cascade, options)) {
+          return;
+        }
+
+        console.log();
+        console.log('Cascade ID:    ', cascade.id);
+        console.log('Creator:       ', cascade.creator);
+        console.log('Total Amount:  ', cascade.totalAmount);
+        console.log('Stages:        ', cascade.stages);
+        console.log('Current Stage: ', cascade.currentStage);
+        console.log();
+        console.log('Recipients:');
+        cascade.recipients.forEach((r, i) => {
+          const status = r.released ? '✅ Released' : '⏳ Pending';
+          console.log(`  ${i + 1}. ${formatAddress(r.address)} - ${status}`);
+        });
+        console.log();
+      } catch (err) {
+        error(`Failed to get cascade: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob cascade list
+  cmd
+    .command('list')
+    .description('List your cascades')
+    .option('--json', 'Output as JSON')
+    .action(async (options: OutputOptions) => {
+      try {
+        // Placeholder data
+        const cascades = [
+          {
+            id: 1,
+            amount: '1000 USDC',
+            stages: 3,
+            currentStage: 1,
+            status: 'active',
+          },
+          {
+            id: 2,
+            amount: '500 USDC',
+            stages: 2,
+            currentStage: 2,
+            status: 'completed',
+          },
+        ];
+
+        if (outputJSON(cascades, options)) {
+          return;
+        }
+
+        if (cascades.length === 0) {
+          info('No cascades found');
+          return;
+        }
+
+        const table = createTable({
+          head: ['ID', 'Amount', 'Stages', 'Current', 'Status'],
+        });
+
+        for (const cascade of cascades) {
+          table.push([
+            cascade.id,
+            cascade.amount,
+            cascade.stages,
+            cascade.currentStage,
+            cascade.status,
+          ]);
+        }
+
+        console.log(table.toString());
+      } catch (err) {
+        error(`Failed to list cascades: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/compliance.ts

@@ -0,0 +1,123 @@
+import { Command } from 'commander';
+import { success, error, info, warning, outputJSON, formatAddress, formatBoolean } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+import chalk from 'chalk';
+
+export function createComplianceCommand(): Command {
+  const cmd = new Command('compliance')
+    .description('Check compliance and policy status');
+
+  // plob compliance check
+  cmd
+    .command('check')
+    .description('Check compliance status for an address')
+    .argument('<address>', 'Address to check')
+    .option('--json', 'Output as JSON')
+    .action(async (address: string, options: OutputOptions) => {
+      try {
+        if (!address.startsWith('0x') || address.length !== 42) {
+          error('Invalid address format');
+          process.exit(1);
+        }
+
+        info(`Checking compliance for ${formatAddress(address)}`);
+
+        // Placeholder data
+        const compliance = {
+          address,
+          approved: true,
+          sanctioned: false,
+          kycVerified: true,
+          riskLevel: 'low',
+          jurisdiction: 'US',
+          lastChecked: new Date().toISOString(),
+          policies: [
+            { id: 1, name: 'AML Policy', compliant: true },
+            { id: 2, name: 'KYC Policy', compliant: true },
+            { id: 3, name: 'Sanctions Screening', compliant: true },
+          ],
+        };
+
+        if (outputJSON(compliance, options)) {
+          return;
+        }
+
+        console.log();
+        console.log(chalk.bold.cyan('🦞 Compliance Check'));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log('Address:       ', compliance.address);
+        console.log('Approved:      ', formatBoolean(compliance.approved));
+        console.log('Sanctioned:    ', formatBoolean(compliance.sanctioned));
+        console.log('KYC Verified:  ', formatBoolean(compliance.kycVerified));
+        console.log('Risk Level:    ', compliance.riskLevel === 'low' ? chalk.green(compliance.riskLevel) : chalk.yellow(compliance.riskLevel));
+        console.log('Jurisdiction:  ', compliance.jurisdiction);
+        console.log('Last Checked:  ', compliance.lastChecked);
+        console.log();
+        console.log(chalk.bold('Policy Compliance:'));
+        compliance.policies.forEach(policy => {
+          console.log(`  ${formatBoolean(policy.compliant)} ${policy.name}`);
+        });
+        console.log();
+
+        if (!compliance.approved) {
+          warning('This address is NOT approved for transactions');
+        } else {
+          success('Address is compliant');
+        }
+      } catch (err) {
+        error(`Failed to check compliance: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob compliance policy
+  cmd
+    .command('policy')
+    .description('Get policy details')
+    .argument('<policyId>', 'Policy ID')
+    .option('--json', 'Output as JSON')
+    .action(async (policyId: string, options: OutputOptions) => {
+      try {
+        // Placeholder data
+        const policy = {
+          id: policyId,
+          name: 'AML Policy',
+          version: '1.2.0',
+          description: 'Anti-Money Laundering compliance policy',
+          requirements: [
+            'Transaction monitoring',
+            'Suspicious activity reporting',
+            'Record keeping (5 years)',
+            'Customer due diligence',
+          ],
+          effectiveDate: '2024-01-01',
+          jurisdiction: 'Global',
+        };
+
+        if (outputJSON(policy, options)) {
+          return;
+        }
+
+        console.log();
+        console.log(chalk.bold.cyan('🦞 Policy Details'));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log('Policy ID:      ', policy.id);
+        console.log('Name:           ', policy.name);
+        console.log('Version:        ', policy.version);
+        console.log('Description:    ', policy.description);
+        console.log('Effective Date: ', policy.effectiveDate);
+        console.log('Jurisdiction:   ', policy.jurisdiction);
+        console.log();
+        console.log(chalk.bold('Requirements:'));
+        policy.requirements.forEach(req => {
+          console.log(`  • ${req}`);
+        });
+        console.log();
+      } catch (err) {
+        error(`Failed to get policy: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/credit-score.ts

@@ -0,0 +1,193 @@
+import { Command } from 'commander';
+import { success, error, info, warning, withSpinner, outputJSON, formatAddress, printReputation, createTable } from '../lib/display';
+import { getWalletAddress } from '../lib/wallet';
+import type { OutputOptions } from '../lib/types';
+import chalk from 'chalk';
+
+export function createCreditScoreCommand(): Command {
+  const cmd = new Command('credit-score')
+    .description('Check credit scores and manage credit lines')
+    .argument('[address]', 'Address to check (optional, defaults to your address)')
+    .option('--json', 'Output as JSON')
+    .action(async (address: string | undefined, options: OutputOptions) => {
+      try {
+        const targetAddress = address || getWalletAddress();
+
+        if (address && (!address.startsWith('0x') || address.length !== 42)) {
+          error('Invalid address format');
+          process.exit(1);
+        }
+
+        // Placeholder data
+        const creditData = {
+          address: targetAddress,
+          score: 750,
+          creditLine: '5000 USDC',
+          availableCredit: '3500 USDC',
+          usedCredit: '1500 USDC',
+          paymentHistory: 'Excellent',
+          onTimePayments: 45,
+          latePayments: 2,
+          totalTransactions: 47,
+        };
+
+        if (outputJSON(creditData, options)) {
+          return;
+        }
+
+        console.log();
+        console.log(chalk.bold.cyan('🦞 Credit Score Report'));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log('Address:          ', formatAddress(creditData.address));
+        console.log('Credit Score:     ', printReputation(creditData.score / 10)); // Convert to 0-100 scale
+        console.log();
+        console.log(chalk.bold('Credit Line'));
+        console.log('  Total:          ', creditData.creditLine);
+        console.log('  Available:      ', chalk.green(creditData.availableCredit));
+        console.log('  Used:           ', chalk.yellow(creditData.usedCredit));
+        console.log();
+        console.log(chalk.bold('Payment History'));
+        console.log('  On-time:        ', chalk.green(creditData.onTimePayments));
+        console.log('  Late:           ', chalk.red(creditData.latePayments));
+        console.log('  Total:          ', creditData.totalTransactions);
+        console.log('  Rating:         ', chalk.green(creditData.paymentHistory));
+        console.log();
+      } catch (err) {
+        error(`Failed to get credit score: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob credit-score request
+  cmd
+    .command('request')
+    .description('Request a credit line')
+    .requiredOption('--amount <amount>', 'Credit line amount in USDC')
+    .option('--json', 'Output as JSON')
+    .action(async (options: { amount: string } & OutputOptions) => {
+      try {
+        const amount = parseFloat(options.amount);
+        if (isNaN(amount) || amount <= 0) {
+          error('Invalid amount. Must be a positive number');
+          process.exit(1);
+        }
+
+        info(`Requesting credit line: ${options.amount} USDC`);
+
+        const requestId = Math.floor(Math.random() * 1000000);
+
+        const txHash = await withSpinner(
+          'Submitting credit line request...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          requestId,
+          amount: options.amount,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Credit line request submitted!');
+        info(`Request ID: ${requestId}`);
+        info(`Amount: ${options.amount} USDC`);
+        info(`Transaction: ${txHash}`);
+        console.log();
+        warning('Credit requests are subject to approval based on your credit score.');
+      } catch (err) {
+        error(`Failed to request credit line: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob credit-score draw
+  cmd
+    .command('draw')
+    .description('Draw from credit line')
+    .argument('<creditLineId>', 'Credit line ID')
+    .requiredOption('--amount <amount>', 'Amount to draw in USDC')
+    .option('--json', 'Output as JSON')
+    .action(async (creditLineId: string, options: { amount: string } & OutputOptions) => {
+      try {
+        const amount = parseFloat(options.amount);
+        if (isNaN(amount) || amount <= 0) {
+          error('Invalid amount. Must be a positive number');
+          process.exit(1);
+        }
+
+        const txHash = await withSpinner(
+          `Drawing ${options.amount} USDC from credit line...`,
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          creditLineId,
+          amount: options.amount,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Credit drawn successfully!');
+        info(`Credit Line ID: ${creditLineId}`);
+        info(`Amount: ${options.amount} USDC`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to draw credit: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob credit-score repay
+  cmd
+    .command('repay')
+    .description('Repay credit line')
+    .argument('<creditLineId>', 'Credit line ID')
+    .requiredOption('--amount <amount>', 'Amount to repay in USDC')
+    .option('--json', 'Output as JSON')
+    .action(async (creditLineId: string, options: { amount: string } & OutputOptions) => {
+      try {
+        const amount = parseFloat(options.amount);
+        if (isNaN(amount) || amount <= 0) {
+          error('Invalid amount. Must be a positive number');
+          process.exit(1);
+        }
+
+        const txHash = await withSpinner(
+          `Repaying ${options.amount} USDC to credit line...`,
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          creditLineId,
+          amount: options.amount,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Repayment successful!');
+        info(`Credit Line ID: ${creditLineId}`);
+        info(`Amount: ${options.amount} USDC`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to repay credit: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}