@paylobster/cli 4.0.2 → 4.2.0

package/src/commands/portfolio.ts

@@ -0,0 +1,227 @@
+import { Command } from 'commander';
+import { getWalletAddress } from '../lib/wallet';
+import { getPublicClient, getContracts, formatUSDC, formatETH } from '../lib/contracts';
+import { loadConfig } from '../lib/config';
+import { error, outputJSON, withSpinner, createTable, formatNumber } from '../lib/display';
+import chalk from 'chalk';
+import type { Address } from 'viem';
+import type { OutputOptions } from '../lib/types';
+
+// Token configuration for Base
+interface TokenConfig {
+  symbol: string;
+  address: Address;
+  decimals: number;
+  isNative?: boolean;
+}
+
+const BASE_TOKENS: TokenConfig[] = [
+  { symbol: 'ETH', address: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE' as Address, decimals: 18, isNative: true },
+  { symbol: 'USDC', address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913' as Address, decimals: 6 },
+  { symbol: 'WETH', address: '0x4200000000000000000000000000000000000006' as Address, decimals: 18 },
+  { symbol: 'DAI', address: '0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb' as Address, decimals: 18 },
+  { symbol: 'USDbC', address: '0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA' as Address, decimals: 6 },
+];
+
+const ERC20_ABI = [
+  {
+    inputs: [{ name: 'account', type: 'address' }],
+    name: 'balanceOf',
+    outputs: [{ name: '', type: 'uint256' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const;
+
+interface TokenBalance {
+  symbol: string;
+  balance: string;
+  balanceRaw: bigint;
+  valueUSD: number;
+}
+
+/**
+ * Format token amount with decimals
+ */
+function formatTokenAmount(amount: bigint, decimals: number): string {
+  const num = amount;
+  const divisor = BigInt(10 ** decimals);
+  const whole = num / divisor;
+  const fraction = num % divisor;
+  
+  if (fraction === 0n) {
+    return whole.toString();
+  }
+  
+  const fractionStr = fraction.toString().padStart(decimals, '0');
+  const trimmed = fractionStr.replace(/0+$/, '');
+  const limited = trimmed.slice(0, 6); // Limit to 6 decimal places for display
+  return `${whole}.${limited}`;
+}
+
+/**
+ * Get token price in USD (mock - in production, use price oracle)
+ */
+async function getTokenPriceUSD(symbol: string): Promise<number> {
+  // Mock prices - in production, integrate with price oracle
+  const prices: Record<string, number> = {
+    ETH: 3000,
+    WETH: 3000,
+    USDC: 1,
+    DAI: 1,
+    USDbC: 1,
+  };
+  
+  return prices[symbol] || 0;
+}
+
+/**
+ * Get token balance
+ */
+async function getTokenBalance(
+  address: Address,
+  token: TokenConfig
+): Promise<bigint> {
+  const config = loadConfig();
+  const publicClient = getPublicClient(config.network);
+
+  if (token.isNative) {
+    // Get native ETH balance
+    return await publicClient.getBalance({ address });
+  }
+
+  // Get ERC20 token balance
+  try {
+    const balance = await publicClient.readContract({
+      address: token.address,
+      abi: ERC20_ABI,
+      functionName: 'balanceOf',
+      args: [address],
+    });
+    return balance;
+  } catch (err) {
+    // If token doesn't exist or error, return 0
+    return 0n;
+  }
+}
+
+/**
+ * Get all token balances
+ */
+async function getPortfolioBalances(
+  address: Address,
+  tokens: TokenConfig[]
+): Promise<TokenBalance[]> {
+  const balances = await Promise.all(
+    tokens.map(async (token) => {
+      const balanceRaw = await getTokenBalance(address, token);
+      const balance = formatTokenAmount(balanceRaw, token.decimals);
+      const price = await getTokenPriceUSD(token.symbol);
+      const valueUSD = parseFloat(balance) * price;
+
+      return {
+        symbol: token.symbol,
+        balance,
+        balanceRaw,
+        valueUSD,
+      };
+    })
+  );
+
+  // Filter out zero balances and sort by USD value
+  return balances
+    .filter((b) => b.balanceRaw > 0n)
+    .sort((a, b) => b.valueUSD - a.valueUSD);
+}
+
+/**
+ * Create portfolio command
+ */
+export function createPortfolioCommand(): Command {
+  const cmd = new Command('portfolio')
+    .description('View token portfolio and balances')
+    .option('--chain <chain>', 'Filter by chain (currently only Base supported)', 'base')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      chain: string;
+    } & OutputOptions) => {
+      try {
+        const address = getWalletAddress() as `0x${string}`;
+        
+        if (options.chain.toLowerCase() !== 'base') {
+          error('Currently only Base chain is supported');
+          process.exit(1);
+        }
+
+        const balances = await withSpinner(
+          'Fetching portfolio balances...',
+          async () => getPortfolioBalances(address, BASE_TOKENS)
+        );
+
+        if (balances.length === 0) {
+          if (outputJSON({ balances: [], totalUSD: 0 }, options)) {
+            return;
+          }
+          console.log();
+          console.log(chalk.yellow('No token balances found'));
+          console.log();
+          return;
+        }
+
+        const totalUSD = balances.reduce((sum, b) => sum + b.valueUSD, 0);
+
+        if (outputJSON({
+          address,
+          chain: 'Base',
+          balances: balances.map(b => ({
+            symbol: b.symbol,
+            balance: b.balance,
+            valueUSD: b.valueUSD.toFixed(2),
+          })),
+          totalUSD: totalUSD.toFixed(2),
+        }, options)) {
+          return;
+        }
+
+        // Pretty output
+        console.log();
+        console.log(chalk.bold.cyan('💼 Portfolio'));
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log(chalk.gray('Address: ') + chalk.white(address));
+        console.log(chalk.gray('Chain:   ') + chalk.white('Base'));
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log();
+
+        // Create table
+        const table = createTable({
+          head: ['Token', 'Balance', 'Value (USD)'],
+          colAligns: ['left', 'right', 'right'] as any,
+        });
+
+        for (const token of balances) {
+          table.push([
+            chalk.white.bold(token.symbol),
+            chalk.white(formatNumber(token.balance)),
+            chalk.green('$' + formatNumber(token.valueUSD.toFixed(2))),
+          ]);
+        }
+
+        console.log(table.toString());
+        console.log();
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log(
+          chalk.white.bold('Total Portfolio Value:'),
+          chalk.green.bold('$' + formatNumber(totalUSD.toFixed(2)))
+        );
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log();
+        console.log(chalk.dim('Note: Prices are approximate and for display only.'));
+        console.log();
+      } catch (err) {
+        error(`Failed to fetch portfolio: ${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;
+}

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