@paylobster/cli 4.0.2 → 4.2.0

package/src/commands/dispute.ts

@@ -0,0 +1,274 @@
+import { Command } from 'commander';
+import { success, error, info, warning, withSpinner, outputJSON, formatAddress, confirm, createTable, formatStatus } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+import fs from 'fs/promises';
+import path from 'path';
+
+export function createDisputeCommand(): Command {
+  const cmd = new Command('dispute')
+    .description('Manage escrow disputes');
+
+  // plob dispute open
+  cmd
+    .command('open')
+    .description('Open a dispute for an escrow')
+    .requiredOption('--escrow <id>', 'Escrow ID')
+    .requiredOption('--reason <reason>', 'Dispute reason')
+    .option('--evidence <file>', 'Evidence file path')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      escrow: string;
+      reason: string;
+      evidence?: string;
+    } & OutputOptions) => {
+      try {
+        let evidenceHash = null;
+
+        // Handle evidence file if provided
+        if (options.evidence) {
+          const evidencePath = path.resolve(options.evidence);
+          try {
+            const evidenceData = await fs.readFile(evidencePath);
+            info(`Evidence file loaded: ${path.basename(evidencePath)} (${evidenceData.length} bytes)`);
+            
+            // Placeholder: Upload to IPFS or similar
+            evidenceHash = '0x' + Math.random().toString(16).substring(2, 66);
+            info(`Evidence uploaded: ${evidenceHash}`);
+          } catch (err) {
+            error(`Failed to read evidence file: ${err}`);
+            process.exit(1);
+          }
+        }
+
+        const disputeId = Math.floor(Math.random() * 1000000);
+
+        const txHash = await withSpinner(
+          'Opening dispute...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          disputeId,
+          escrowId: options.escrow,
+          reason: options.reason,
+          evidenceHash,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Dispute opened!');
+        info(`Dispute ID: ${disputeId}`);
+        info(`Escrow ID: ${options.escrow}`);
+        info(`Reason: ${options.reason}`);
+        if (evidenceHash) {
+          info(`Evidence: ${evidenceHash}`);
+        }
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to open dispute: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob dispute submit
+  cmd
+    .command('submit')
+    .description('Submit additional evidence for a dispute')
+    .argument('<disputeId>', 'Dispute ID')
+    .requiredOption('--evidence <file>', 'Evidence file path')
+    .option('--json', 'Output as JSON')
+    .action(async (disputeId: string, options: { evidence: string } & OutputOptions) => {
+      try {
+        const evidencePath = path.resolve(options.evidence);
+        const evidenceData = await fs.readFile(evidencePath);
+        
+        info(`Submitting evidence: ${path.basename(evidencePath)} (${evidenceData.length} bytes)`);
+
+        const evidenceHash = '0x' + Math.random().toString(16).substring(2, 66);
+
+        const txHash = await withSpinner(
+          'Submitting evidence...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          disputeId,
+          evidenceHash,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Evidence submitted!');
+        info(`Dispute ID: ${disputeId}`);
+        info(`Evidence: ${evidenceHash}`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to submit evidence: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob dispute get
+  cmd
+    .command('get')
+    .description('Get dispute details')
+    .argument('<disputeId>', 'Dispute ID')
+    .option('--json', 'Output as JSON')
+    .action(async (disputeId: string, options: OutputOptions) => {
+      try {
+        // Placeholder data
+        const dispute = {
+          id: disputeId,
+          escrowId: '123',
+          plaintiff: '0x1234567890123456789012345678901234567890',
+          defendant: '0x0987654321098765432109876543210987654321',
+          reason: 'Service not delivered as agreed',
+          status: 'pending',
+          evidence: [
+            '0xabcd1234...',
+            '0xef567890...',
+          ],
+          createdAt: new Date().toISOString(),
+        };
+
+        if (outputJSON(dispute, options)) {
+          return;
+        }
+
+        console.log();
+        console.log('Dispute ID:    ', dispute.id);
+        console.log('Escrow ID:     ', dispute.escrowId);
+        console.log('Plaintiff:     ', dispute.plaintiff);
+        console.log('Defendant:     ', dispute.defendant);
+        console.log('Reason:        ', dispute.reason);
+        console.log('Status:        ', formatStatus(dispute.status));
+        console.log('Evidence:      ', dispute.evidence.length, 'file(s)');
+        console.log('Created:       ', dispute.createdAt);
+        console.log();
+      } catch (err) {
+        error(`Failed to get dispute: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob dispute settle
+  cmd
+    .command('settle')
+    .description('Settle a dispute')
+    .argument('<disputeId>', 'Dispute ID')
+    .requiredOption('--terms <terms>', 'Settlement terms')
+    .option('--yes', 'Skip confirmation')
+    .option('--json', 'Output as JSON')
+    .action(async (disputeId: string, options: {
+      terms: string;
+      yes?: boolean;
+    } & OutputOptions) => {
+      try {
+        if (!options.yes) {
+          console.log();
+          console.log('Settlement terms:', options.terms);
+          console.log();
+
+          const confirmed = await confirm(`Settle dispute ${disputeId}?`);
+          if (!confirmed) {
+            info('Cancelled');
+            process.exit(0);
+          }
+        }
+
+        const txHash = await withSpinner(
+          'Settling dispute...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          disputeId,
+          terms: options.terms,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Dispute settled!');
+        info(`Dispute ID: ${disputeId}`);
+        info(`Terms: ${options.terms}`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to settle dispute: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob dispute list
+  cmd
+    .command('list')
+    .description('List disputes')
+    .option('--json', 'Output as JSON')
+    .action(async (options: OutputOptions) => {
+      try {
+        // Placeholder data
+        const disputes = [
+          {
+            id: 1,
+            escrowId: 123,
+            plaintiff: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+            defendant: '0x8626f6940E2eb28930eFb4CeF49B2d1F2C9C1199',
+            reason: 'Service not delivered',
+            status: 'pending',
+          },
+          {
+            id: 2,
+            escrowId: 456,
+            plaintiff: '0x1234567890123456789012345678901234567890',
+            defendant: '0x0987654321098765432109876543210987654321',
+            reason: 'Quality issues',
+            status: 'settled',
+          },
+        ];
+
+        if (outputJSON(disputes, options)) {
+          return;
+        }
+
+        if (disputes.length === 0) {
+          info('No disputes found');
+          return;
+        }
+
+        const table = createTable({
+          head: ['ID', 'Escrow', 'Plaintiff', 'Defendant', 'Status'],
+        });
+
+        for (const dispute of disputes) {
+          table.push([
+            dispute.id,
+            dispute.escrowId,
+            formatAddress(dispute.plaintiff),
+            formatAddress(dispute.defendant),
+            formatStatus(dispute.status),
+          ]);
+        }
+
+        console.log(table.toString());
+      } catch (err) {
+        error(`Failed to list disputes: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

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