@paylobster/cli 4.0.2 → 4.1.0

package/src/commands/revenue-share.ts

@@ -0,0 +1,213 @@
+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 createRevenueShareCommand(): Command {
+  const cmd = new Command('revenue-share')
+    .description('Manage revenue sharing agreements');
+
+  // plob revenue-share create
+  cmd
+    .command('create')
+    .description('Create a revenue sharing agreement')
+    .requiredOption('--participants <addresses>', 'Comma-separated participant addresses')
+    .requiredOption('--splits <percentages>', 'Comma-separated split percentages (must sum to 100)')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      participants: string;
+      splits: string;
+    } & OutputOptions) => {
+      try {
+        const participants = options.participants.split(',').map(p => p.trim());
+        const splits = options.splits.split(',').map(s => parseFloat(s.trim()));
+
+        // Validate addresses
+        for (const participant of participants) {
+          if (!participant.startsWith('0x') || participant.length !== 42) {
+            error(`Invalid participant address: ${participant}`);
+            process.exit(1);
+          }
+        }
+
+        // Validate splits
+        if (participants.length !== splits.length) {
+          error('Number of participants must match number of splits');
+          process.exit(1);
+        }
+
+        for (const split of splits) {
+          if (isNaN(split) || split < 0 || split > 100) {
+            error('Each split must be between 0 and 100');
+            process.exit(1);
+          }
+        }
+
+        const totalSplit = splits.reduce((a, b) => a + b, 0);
+        if (Math.abs(totalSplit - 100) > 0.01) {
+          error(`Splits must sum to 100 (current: ${totalSplit})`);
+          process.exit(1);
+        }
+
+        info('Creating revenue share agreement');
+        participants.forEach((p, i) => {
+          info(`  ${formatAddress(p)}: ${splits[i]}%`);
+        });
+
+        const shareId = Math.floor(Math.random() * 1000000);
+
+        const txHash = await withSpinner(
+          'Creating revenue share...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          shareId,
+          participants,
+          splits,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Revenue share created!');
+        info(`Share ID: ${shareId}`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to create revenue share: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob revenue-share deposit
+  cmd
+    .command('deposit')
+    .description('Deposit funds to revenue share')
+    .argument('<shareId>', 'Share ID')
+    .requiredOption('--amount <amount>', 'Amount in USDC')
+    .option('--json', 'Output as JSON')
+    .action(async (shareId: 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(
+          `Depositing ${options.amount} USDC to revenue share...`,
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          shareId,
+          amount: options.amount,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Deposit successful!');
+        info(`Share ID: ${shareId}`);
+        info(`Amount: ${options.amount} USDC`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to deposit: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob revenue-share distribute
+  cmd
+    .command('distribute')
+    .description('Distribute revenue to participants')
+    .argument('<shareId>', 'Share ID')
+    .option('--yes', 'Skip confirmation')
+    .option('--json', 'Output as JSON')
+    .action(async (shareId: string, options: { yes?: boolean } & OutputOptions) => {
+      try {
+        if (!options.yes) {
+          const confirmed = await confirm(`Distribute revenue for share ${shareId}?`);
+          if (!confirmed) {
+            info('Cancelled');
+            process.exit(0);
+          }
+        }
+
+        const txHash = await withSpinner(
+          'Distributing revenue...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          shareId,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Revenue distributed!');
+        info(`Share ID: ${shareId}`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to distribute: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob revenue-share get
+  cmd
+    .command('get')
+    .description('Get revenue share details')
+    .argument('<shareId>', 'Share ID')
+    .option('--json', 'Output as JSON')
+    .action(async (shareId: string, options: OutputOptions) => {
+      try {
+        // Placeholder data
+        const share = {
+          id: shareId,
+          totalDeposited: '1000 USDC',
+          totalDistributed: '600 USDC',
+          pending: '400 USDC',
+          participants: [
+            { address: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb', split: 60, received: '360 USDC' },
+            { address: '0x8626f6940E2eb28930eFb4CeF49B2d1F2C9C1199', split: 40, received: '240 USDC' },
+          ],
+          createdAt: new Date().toISOString(),
+        };
+
+        if (outputJSON(share, options)) {
+          return;
+        }
+
+        console.log();
+        console.log('Share ID:          ', share.id);
+        console.log('Total Deposited:   ', share.totalDeposited);
+        console.log('Total Distributed: ', share.totalDistributed);
+        console.log('Pending:           ', share.pending);
+        console.log('Created:           ', share.createdAt);
+        console.log();
+        console.log('Participants:');
+        share.participants.forEach(p => {
+          console.log(`  ${formatAddress(p.address)}: ${p.split}% (received ${p.received})`);
+        });
+        console.log();
+      } catch (err) {
+        error(`Failed to get revenue share: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/stream.ts

@@ -0,0 +1,244 @@
+import { Command } from 'commander';
+import { success, error, info, withSpinner, outputJSON, formatAddress, confirm, createTable } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+
+export function createStreamCommand(): Command {
+  const cmd = new Command('stream')
+    .description('Manage payment streams');
+
+  // plob stream create
+  cmd
+    .command('create')
+    .description('Create a new payment stream')
+    .requiredOption('--to <address>', 'Recipient address')
+    .requiredOption('--amount <amount>', 'Total amount in USDC')
+    .requiredOption('--duration <duration>', 'Duration (e.g., 30d, 1h, 60m)')
+    .option('--interval <interval>', 'Payment interval (e.g., 1d, 1h)', '1d')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      to: string;
+      amount: string;
+      duration: string;
+      interval: string;
+    } & OutputOptions) => {
+      try {
+        // Validate address
+        if (!options.to.startsWith('0x') || options.to.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);
+        }
+
+        info(`Creating stream: ${options.amount} USDC over ${options.duration}`);
+        info(`To: ${formatAddress(options.to)}`);
+        info(`Interval: ${options.interval}`);
+
+        // TODO: Implement actual stream creation
+        const streamId = Math.floor(Math.random() * 1000000); // Placeholder
+
+        const txHash = await withSpinner(
+          'Creating payment stream...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          streamId,
+          txHash,
+          to: options.to,
+          amount: options.amount,
+          duration: options.duration,
+          interval: options.interval,
+        }, options)) {
+          return;
+        }
+
+        success('Payment stream created!');
+        info(`Stream ID: ${streamId}`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to create stream: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob stream cancel
+  cmd
+    .command('cancel')
+    .description('Cancel a payment stream')
+    .argument('<streamId>', 'Stream ID')
+    .option('--yes', 'Skip confirmation')
+    .option('--json', 'Output as JSON')
+    .action(async (streamId: string, options: { yes?: boolean } & OutputOptions) => {
+      try {
+        if (!options.yes) {
+          const confirmed = await confirm(`Cancel stream ${streamId}?`);
+          if (!confirmed) {
+            info('Cancelled');
+            process.exit(0);
+          }
+        }
+
+        const txHash = await withSpinner(
+          'Cancelling stream...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({ streamId, txHash }, options)) {
+          return;
+        }
+
+        success(`Stream ${streamId} cancelled!`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to cancel stream: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob stream list
+  cmd
+    .command('list')
+    .description('List your payment streams')
+    .option('--json', 'Output as JSON')
+    .action(async (options: OutputOptions) => {
+      try {
+        // Placeholder data
+        const streams = [
+          {
+            id: 1,
+            to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+            amount: '1000 USDC',
+            streamed: '300 USDC',
+            remaining: '700 USDC',
+            status: 'active',
+          },
+          {
+            id: 2,
+            to: '0x8626f6940E2eb28930eFb4CeF49B2d1F2C9C1199',
+            amount: '500 USDC',
+            streamed: '500 USDC',
+            remaining: '0 USDC',
+            status: 'completed',
+          },
+        ];
+
+        if (outputJSON(streams, options)) {
+          return;
+        }
+
+        if (streams.length === 0) {
+          info('No streams found');
+          return;
+        }
+
+        const table = createTable({
+          head: ['ID', 'To', 'Amount', 'Streamed', 'Remaining', 'Status'],
+        });
+
+        for (const stream of streams) {
+          table.push([
+            stream.id,
+            formatAddress(stream.to),
+            stream.amount,
+            stream.streamed,
+            stream.remaining,
+            stream.status,
+          ]);
+        }
+
+        console.log(table.toString());
+      } catch (err) {
+        error(`Failed to list streams: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob stream get
+  cmd
+    .command('get')
+    .description('Get stream details')
+    .argument('<streamId>', 'Stream ID')
+    .option('--json', 'Output as JSON')
+    .action(async (streamId: string, options: OutputOptions) => {
+      try {
+        // Placeholder data
+        const stream = {
+          id: streamId,
+          from: '0x1234567890123456789012345678901234567890',
+          to: '0x0987654321098765432109876543210987654321',
+          totalAmount: '1000 USDC',
+          streamedAmount: '300 USDC',
+          remainingAmount: '700 USDC',
+          startTime: new Date().toISOString(),
+          duration: '30 days',
+          interval: '1 day',
+          status: 'active',
+        };
+
+        if (outputJSON(stream, options)) {
+          return;
+        }
+
+        console.log();
+        console.log('Stream ID:     ', stream.id);
+        console.log('From:          ', stream.from);
+        console.log('To:            ', stream.to);
+        console.log('Total Amount:  ', stream.totalAmount);
+        console.log('Streamed:      ', stream.streamedAmount);
+        console.log('Remaining:     ', stream.remainingAmount);
+        console.log('Start Time:    ', stream.startTime);
+        console.log('Duration:      ', stream.duration);
+        console.log('Interval:      ', stream.interval);
+        console.log('Status:        ', stream.status);
+        console.log();
+      } catch (err) {
+        error(`Failed to get stream: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob stream withdraw
+  cmd
+    .command('withdraw')
+    .description('Withdraw from a stream')
+    .argument('<streamId>', 'Stream ID')
+    .option('--json', 'Output as JSON')
+    .action(async (streamId: string, options: OutputOptions) => {
+      try {
+        const txHash = await withSpinner(
+          'Withdrawing from stream...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({ streamId, txHash }, options)) {
+          return;
+        }
+
+        success('Withdrawal successful!');
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to withdraw: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/index.ts

@@ -9,6 +9,14 @@ 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 chalk from 'chalk';
 
 // Load environment variables from .env file if present
@@ -44,6 +52,14 @@ 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());
 
 // Handle errors
 program.exitOverride((err) => {