@paylobster/cli 4.0.1 → 4.1.0

package/src/commands/intent.ts

@@ -0,0 +1,261 @@
+import { Command } from 'commander';
+import { success, error, info, withSpinner, outputJSON, formatAddress, createTable } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+
+export function createIntentCommand(): Command {
+  const cmd = new Command('intent')
+    .description('Manage payment intents');
+
+  // plob intent post
+  cmd
+    .command('post')
+    .description('Post a payment intent')
+    .requiredOption('--description <desc>', 'Intent description')
+    .requiredOption('--budget <amount>', 'Budget in USDC')
+    .option('--tags <tags>', 'Comma-separated tags', '')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      description: string;
+      budget: string;
+      tags: string;
+    } & OutputOptions) => {
+      try {
+        const budget = parseFloat(options.budget);
+        if (isNaN(budget) || budget <= 0) {
+          error('Invalid budget. Must be a positive number');
+          process.exit(1);
+        }
+
+        const tags = options.tags ? options.tags.split(',').map(t => t.trim()) : [];
+
+        info('Posting payment intent');
+        info(`Description: ${options.description}`);
+        info(`Budget: ${options.budget} USDC`);
+        if (tags.length > 0) {
+          info(`Tags: ${tags.join(', ')}`);
+        }
+
+        const intentId = Math.floor(Math.random() * 1000000);
+
+        const txHash = await withSpinner(
+          'Creating intent...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          intentId,
+          description: options.description,
+          budget: options.budget,
+          tags,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Payment intent posted!');
+        info(`Intent ID: ${intentId}`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to post intent: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob intent offer
+  cmd
+    .command('offer')
+    .description('Make an offer on an intent')
+    .argument('<intentId>', 'Intent ID')
+    .requiredOption('--amount <amount>', 'Offer amount in USDC')
+    .option('--message <message>', 'Offer message', '')
+    .option('--json', 'Output as JSON')
+    .action(async (intentId: string, options: {
+      amount: string;
+      message: 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 offerId = Math.floor(Math.random() * 1000000);
+
+        const txHash = await withSpinner(
+          'Submitting offer...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          offerId,
+          intentId,
+          amount: options.amount,
+          message: options.message,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Offer submitted!');
+        info(`Offer ID: ${offerId}`);
+        info(`Intent ID: ${intentId}`);
+        info(`Amount: ${options.amount} USDC`);
+        if (options.message) {
+          info(`Message: ${options.message}`);
+        }
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to submit offer: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob intent accept
+  cmd
+    .command('accept')
+    .description('Accept an offer on your intent')
+    .argument('<intentId>', 'Intent ID')
+    .argument('<offerId>', 'Offer ID')
+    .option('--json', 'Output as JSON')
+    .action(async (intentId: string, offerId: string, options: OutputOptions) => {
+      try {
+        const txHash = await withSpinner(
+          'Accepting offer...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          intentId,
+          offerId,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Offer accepted!');
+        info(`Intent ID: ${intentId}`);
+        info(`Offer ID: ${offerId}`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to accept offer: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob intent list
+  cmd
+    .command('list')
+    .description('List payment intents')
+    .option('--json', 'Output as JSON')
+    .action(async (options: OutputOptions) => {
+      try {
+        // Placeholder data
+        const intents = [
+          {
+            id: 1,
+            description: 'Code review for TypeScript project',
+            budget: '50 USDC',
+            offers: 3,
+            status: 'open',
+          },
+          {
+            id: 2,
+            description: 'Design new logo',
+            budget: '100 USDC',
+            offers: 5,
+            status: 'accepted',
+          },
+        ];
+
+        if (outputJSON(intents, options)) {
+          return;
+        }
+
+        if (intents.length === 0) {
+          info('No intents found');
+          return;
+        }
+
+        const table = createTable({
+          head: ['ID', 'Description', 'Budget', 'Offers', 'Status'],
+        });
+
+        for (const intent of intents) {
+          table.push([
+            intent.id,
+            intent.description.substring(0, 40) + (intent.description.length > 40 ? '...' : ''),
+            intent.budget,
+            intent.offers,
+            intent.status,
+          ]);
+        }
+
+        console.log(table.toString());
+      } catch (err) {
+        error(`Failed to list intents: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob intent get
+  cmd
+    .command('get')
+    .description('Get intent details')
+    .argument('<intentId>', 'Intent ID')
+    .option('--json', 'Output as JSON')
+    .action(async (intentId: string, options: OutputOptions) => {
+      try {
+        // Placeholder data
+        const intent = {
+          id: intentId,
+          creator: '0x1234567890123456789012345678901234567890',
+          description: 'Code review for TypeScript project',
+          budget: '50 USDC',
+          tags: ['code-review', 'typescript'],
+          status: 'open',
+          offers: [
+            { id: 1, provider: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb', amount: '40 USDC' },
+            { id: 2, provider: '0x8626f6940E2eb28930eFb4CeF49B2d1F2C9C1199', amount: '45 USDC' },
+          ],
+          createdAt: new Date().toISOString(),
+        };
+
+        if (outputJSON(intent, options)) {
+          return;
+        }
+
+        console.log();
+        console.log('Intent ID:     ', intent.id);
+        console.log('Creator:       ', intent.creator);
+        console.log('Description:   ', intent.description);
+        console.log('Budget:        ', intent.budget);
+        console.log('Tags:          ', intent.tags.join(', '));
+        console.log('Status:        ', intent.status);
+        console.log('Created:       ', intent.createdAt);
+        console.log();
+        console.log('Offers:');
+        intent.offers.forEach((offer, i) => {
+          console.log(`  ${offer.id}. ${formatAddress(offer.provider)} - ${offer.amount}`);
+        });
+        console.log();
+      } catch (err) {
+        error(`Failed to get intent: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/oracle.ts

@@ -0,0 +1,116 @@
+import { Command } from 'commander';
+import { success, error, info, outputJSON, formatBoolean } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+import chalk from 'chalk';
+
+export function createOracleCommand(): Command {
+  const cmd = new Command('oracle')
+    .description('Check oracle requirements and status');
+
+  // plob oracle status
+  cmd
+    .command('status')
+    .description('Check oracle status for an escrow')
+    .argument('<escrowId>', 'Escrow ID')
+    .option('--json', 'Output as JSON')
+    .action(async (escrowId: string, options: OutputOptions) => {
+      try {
+        // Placeholder data
+        const oracleStatus = {
+          escrowId,
+          oracleRequired: true,
+          oracleApproved: true,
+          oracleProvider: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+          approvalTime: new Date().toISOString(),
+          conditions: [
+            { name: 'Delivery confirmation', met: true },
+            { name: 'Quality threshold', met: true },
+            { name: 'Time limit', met: true },
+          ],
+        };
+
+        if (outputJSON(oracleStatus, options)) {
+          return;
+        }
+
+        console.log();
+        console.log(chalk.bold.cyan('🦞 Oracle Status'));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log('Escrow ID:        ', oracleStatus.escrowId);
+        console.log('Oracle Required:  ', formatBoolean(oracleStatus.oracleRequired));
+        console.log('Oracle Approved:  ', formatBoolean(oracleStatus.oracleApproved));
+        console.log('Oracle Provider:  ', oracleStatus.oracleProvider);
+        if (oracleStatus.approvalTime) {
+          console.log('Approval Time:    ', oracleStatus.approvalTime);
+        }
+        console.log();
+        console.log(chalk.bold('Conditions:'));
+        oracleStatus.conditions.forEach(condition => {
+          console.log(`  ${formatBoolean(condition.met)} ${condition.name}`);
+        });
+        console.log();
+
+        if (oracleStatus.oracleApproved) {
+          success('Oracle has approved this escrow');
+        } else {
+          info('Oracle approval pending');
+        }
+      } catch (err) {
+        error(`Failed to check oracle status: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob oracle required
+  cmd
+    .command('required')
+    .description('Check if oracle is required for a value')
+    .requiredOption('--value <amount>', 'Transaction value in USDC')
+    .option('--json', 'Output as JSON')
+    .action(async (options: { value: string } & OutputOptions) => {
+      try {
+        const value = parseFloat(options.value);
+        if (isNaN(value) || value < 0) {
+          error('Invalid value. Must be a non-negative number');
+          process.exit(1);
+        }
+
+        // Placeholder logic - oracle required for transactions > 1000 USDC
+        const threshold = 1000;
+        const required = value > threshold;
+
+        const result = {
+          value: options.value,
+          threshold: `${threshold} USDC`,
+          oracleRequired: required,
+          reason: required 
+            ? 'Value exceeds threshold for automated release'
+            : 'Value is below oracle requirement threshold',
+        };
+
+        if (outputJSON(result, options)) {
+          return;
+        }
+
+        console.log();
+        console.log(chalk.bold.cyan('🦞 Oracle Requirement Check'));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log('Transaction Value: ', result.value, 'USDC');
+        console.log('Oracle Threshold:  ', result.threshold);
+        console.log('Oracle Required:   ', formatBoolean(result.oracleRequired));
+        console.log('Reason:            ', result.reason);
+        console.log();
+
+        if (required) {
+          info('An oracle will be required to approve this transaction');
+        } else {
+          success('No oracle required for this transaction value');
+        }
+      } catch (err) {
+        error(`Failed to check oracle requirement: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

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;
+}