@paylobster/cli 4.3.0 → 4.5.0

package/src/commands/invest.ts

@@ -0,0 +1,810 @@
+import { Command } from 'commander';
+import { type Address, parseUnits, decodeEventLog } from 'viem';
+import { base } from 'viem/chains';
+import { getWalletAddress, loadWallet } from '../lib/wallet';
+import { getPublicClient } from '../lib/contracts';
+import { success, error, info, withSpinner, outputJSON, createTable, formatAddress } from '../lib/display';
+import chalk from 'chalk';
+import type { OutputOptions } from '../lib/types';
+
+// InvestmentTermSheet contract
+const INVESTMENT_CONTRACT = '0xfa4d9933422401e8b0846f14889b383e068860eb' as Address;
+
+enum ReturnType {
+  REVENUE_SHARE = 0,
+  FIXED_RETURN = 1,
+  MILESTONE_BASED = 2,
+  STREAMING = 3,
+}
+
+enum InvestmentStatus {
+  PROPOSED = 0,
+  FUNDED = 1,
+  ACTIVE = 2,
+  COMPLETED = 3,
+  DEFAULTED = 4,
+  CANCELLED = 5,
+}
+
+const RETURN_TYPE_NAMES: Record<number, string> = {
+  0: 'Revenue Share',
+  1: 'Fixed Return',
+  2: 'Milestone Based',
+  3: 'Streaming',
+};
+
+const STATUS_NAMES: Record<number, string> = {
+  0: 'Proposed',
+  1: 'Funded',
+  2: 'Active',
+  3: 'Completed',
+  4: 'Defaulted',
+  5: 'Cancelled',
+};
+
+// ABI
+const INVESTMENT_ABI = [
+  {
+    type: 'function',
+    name: 'propose',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { name: '_treasury', type: 'address' },
+      { name: '_token', type: 'address' },
+      { name: '_amount', type: 'uint256' },
+      {
+        name: '_terms',
+        type: 'tuple',
+        components: [
+          { name: 'returnType', type: 'uint8' },
+          { name: 'revShareBps', type: 'uint256' },
+          { name: 'fixedReturnBps', type: 'uint256' },
+          { name: 'durationSeconds', type: 'uint256' },
+          { name: 'cliffSeconds', type: 'uint256' },
+          { name: 'milestoneCount', type: 'uint256' },
+        ],
+      },
+      {
+        name: '_protections',
+        type: 'tuple',
+        components: [
+          { name: 'liquidationPreference', type: 'bool' },
+          { name: 'maxInvestorsBps', type: 'uint256' },
+          { name: 'minReserveBps', type: 'uint256' },
+          { name: 'minReputationScore', type: 'uint256' },
+        ],
+      },
+    ],
+    outputs: [{ name: '', type: 'uint256' }],
+  },
+  {
+    type: 'function',
+    name: 'fund',
+    stateMutability: 'nonpayable',
+    inputs: [{ name: 'investmentId', type: 'uint256' }],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'claimReturn',
+    stateMutability: 'nonpayable',
+    inputs: [{ name: 'investmentId', type: 'uint256' }],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'completeMilestone',
+    stateMutability: 'nonpayable',
+    inputs: [{ name: 'investmentId', type: 'uint256' }],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'triggerDefault',
+    stateMutability: 'nonpayable',
+    inputs: [{ name: 'investmentId', type: 'uint256' }],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'cancel',
+    stateMutability: 'nonpayable',
+    inputs: [{ name: 'investmentId', type: 'uint256' }],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'getInvestment',
+    stateMutability: 'view',
+    inputs: [{ name: 'investmentId', type: 'uint256' }],
+    outputs: [
+      { name: 'investor', type: 'address' },
+      { name: 'treasury', type: 'address' },
+      { name: 'token', type: 'address' },
+      { name: 'investedAmount', type: 'uint256' },
+      { name: 'returnedAmount', type: 'uint256' },
+      { name: 'targetReturn', type: 'uint256' },
+      { name: 'status', type: 'uint8' },
+      { name: 'createdAt', type: 'uint256' },
+      { name: 'fundedAt', type: 'uint256' },
+      { name: 'returnType', type: 'uint8' },
+      { name: 'durationSeconds', type: 'uint256' },
+      { name: 'milestonesCompleted', type: 'uint256' },
+      { name: 'milestoneCount', type: 'uint256' },
+    ],
+  },
+  {
+    type: 'function',
+    name: 'getTreasuryInvestments',
+    stateMutability: 'view',
+    inputs: [{ name: 'treasury', type: 'address' }],
+    outputs: [{ name: '', type: 'uint256[]' }],
+  },
+  {
+    type: 'function',
+    name: 'getInvestorPortfolio',
+    stateMutability: 'view',
+    inputs: [{ name: 'investor', type: 'address' }],
+    outputs: [{ name: '', type: 'uint256[]' }],
+  },
+  {
+    type: 'function',
+    name: 'getClaimable',
+    stateMutability: 'view',
+    inputs: [{ name: 'investmentId', type: 'uint256' }],
+    outputs: [{ name: '', type: 'uint256' }],
+  },
+  {
+    type: 'function',
+    name: 'getStats',
+    stateMutability: 'view',
+    inputs: [],
+    outputs: [
+      { name: '_totalInvestments', type: 'uint256' },
+      { name: '_totalInvested', type: 'uint256' },
+      { name: '_totalReturned', type: 'uint256' },
+      { name: '_totalProtocolFees', type: 'uint256' },
+    ],
+  },
+  {
+    type: 'event',
+    name: 'InvestmentProposed',
+    inputs: [
+      { indexed: true, name: 'investmentId', type: 'uint256' },
+      { indexed: true, name: 'investor', type: 'address' },
+      { indexed: true, name: 'treasury', type: 'address' },
+      { indexed: false, name: 'amount', type: 'uint256' },
+    ],
+  },
+] as const;
+
+const USDC_ADDRESS = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913' as Address;
+const USDC_ABI = [
+  {
+    type: 'function',
+    name: 'approve',
+    inputs: [
+      { name: 'spender', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+    ],
+    outputs: [{ name: '', type: 'bool' }],
+    stateMutability: 'nonpayable',
+  },
+] as const;
+
+function parseReturnType(type: string): ReturnType {
+  const lowerType = type.toLowerCase();
+  switch (lowerType) {
+    case 'revenue-share':
+      return ReturnType.REVENUE_SHARE;
+    case 'fixed':
+      return ReturnType.FIXED_RETURN;
+    case 'milestone':
+      return ReturnType.MILESTONE_BASED;
+    case 'streaming':
+      return ReturnType.STREAMING;
+    default:
+      throw new Error(`Invalid return type: ${type}. Use: revenue-share, fixed, milestone, or streaming`);
+  }
+}
+
+export function registerInvestCommand(program: Command) {
+  const invest = program
+    .command('invest')
+    .description('Investment term sheet operations');
+
+  // plob invest propose
+  invest
+    .command('propose')
+    .description('Propose an investment to a treasury')
+    .requiredOption('--treasury <address>', 'Treasury address')
+    .requiredOption('--amount <number>', 'Investment amount in USDC')
+    .requiredOption('--type <type>', 'Return type: revenue-share, fixed, milestone, or streaming')
+    .requiredOption('--duration <days>', 'Investment duration in days')
+    .option('--share <bps>', 'Revenue share in basis points (e.g., 1000 = 10%)', '0')
+    .option('--fixed-return <bps>', 'Fixed return in basis points', '0')
+    .option('--milestones <count>', 'Number of milestones', '0')
+    .option('--cliff <days>', 'Cliff period in days', '0')
+    .option('--token <address>', 'Token address (default: USDC)', USDC_ADDRESS)
+    .option('--liquidation-pref', 'Enable liquidation preference', false)
+    .option('--max-investors <bps>', 'Max investors percentage (basis points)', '5000')
+    .option('--min-reserve <bps>', 'Min reserve percentage (basis points)', '2000')
+    .option('--min-reputation <score>', 'Min reputation score', '0')
+    .option('--json', 'Output as JSON')
+    .action(async (options: OutputOptions & {
+      treasury: string;
+      amount: string;
+      type: string;
+      duration: string;
+      share: string;
+      fixedReturn: string;
+      milestones: string;
+      cliff: string;
+      token: string;
+      liquidationPref: boolean;
+      maxInvestors: string;
+      minReserve: string;
+      minReputation: string;
+    }) => {
+      try {
+        const { client, account } = await loadWallet();
+        const publicClient = getPublicClient();
+
+        const returnType = parseReturnType(options.type);
+        const amountBigInt = parseUnits(options.amount, 6); // USDC has 6 decimals
+        const durationSeconds = BigInt(parseInt(options.duration) * 86400);
+        const cliffSeconds = BigInt(parseInt(options.cliff) * 86400);
+
+        const terms = {
+          returnType,
+          revShareBps: BigInt(parseInt(options.share)),
+          fixedReturnBps: BigInt(parseInt(options.fixedReturn)),
+          durationSeconds,
+          cliffSeconds,
+          milestoneCount: BigInt(parseInt(options.milestones)),
+        };
+
+        const protections = {
+          liquidationPreference: options.liquidationPref,
+          maxInvestorsBps: BigInt(parseInt(options.maxInvestors)),
+          minReserveBps: BigInt(parseInt(options.minReserve)),
+          minReputationScore: BigInt(parseInt(options.minReputation)),
+        };
+
+        // Approve USDC first
+        info('Approving USDC spend...');
+        const approveHash = await client.writeContract({
+          address: USDC_ADDRESS,
+          abi: USDC_ABI,
+          functionName: 'approve',
+          args: [INVESTMENT_CONTRACT, amountBigInt],
+          account,
+          chain: base,
+        });
+        await publicClient.waitForTransactionReceipt({ hash: approveHash });
+
+        const hash = await withSpinner('Proposing investment', async () => {
+          return await client.writeContract({
+            address: INVESTMENT_CONTRACT,
+            abi: INVESTMENT_ABI,
+            functionName: 'propose',
+            args: [options.treasury as Address, options.token as Address, amountBigInt, terms, protections],
+          account,
+          chain: base,
+          });
+        });
+
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+        // Parse event to get investment ID
+        const proposedEvent = receipt.logs
+          .map((log) => {
+            try {
+              return {
+                ...log,
+                decoded: decodeEventLog({
+                  abi: INVESTMENT_ABI,
+                  data: log.data,
+                  topics: log.topics,
+                }),
+              };
+            } catch {
+              return null;
+            }
+          })
+          .find((log) => log?.decoded?.eventName === 'InvestmentProposed');
+
+        const investmentId = proposedEvent?.decoded?.args?.investmentId?.toString() || 'unknown';
+
+        if (options.json) {
+          outputJSON({
+            investmentId,
+            transactionHash: hash,
+            blockNumber: receipt.blockNumber.toString(),
+          });
+        } else {
+          success(`Investment proposed!`);
+          info(`Investment ID: ${chalk.cyan(investmentId)}`);
+          info(`Transaction: ${chalk.gray(hash)}`);
+        }
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to propose investment');
+        process.exit(1);
+      }
+    });
+
+  // plob invest fund
+  invest
+    .command('fund')
+    .description('Fund a proposed investment')
+    .argument('<id>', 'Investment ID')
+    .option('--json', 'Output as JSON')
+    .action(async (id: string, options: OutputOptions) => {
+      try {
+        const { client, account } = await loadWallet();
+        const publicClient = getPublicClient();
+
+        const hash = await withSpinner('Funding investment', async () => {
+          return await client.writeContract({
+            address: INVESTMENT_CONTRACT,
+            abi: INVESTMENT_ABI,
+            functionName: 'fund',
+            args: [BigInt(id)],
+          account,
+          chain: base,
+          });
+        });
+
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+        if (options.json) {
+          outputJSON({
+            investmentId: id,
+            transactionHash: hash,
+            blockNumber: receipt.blockNumber.toString(),
+          });
+        } else {
+          success('Investment funded!');
+          info(`Transaction: ${chalk.gray(hash)}`);
+        }
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to fund investment');
+        process.exit(1);
+      }
+    });
+
+  // plob invest claim
+  invest
+    .command('claim')
+    .description('Claim investment returns')
+    .argument('<id>', 'Investment ID')
+    .option('--json', 'Output as JSON')
+    .action(async (id: string, options: OutputOptions) => {
+      try {
+        const { client, account } = await loadWallet();
+        const publicClient = getPublicClient();
+
+        // Get claimable amount first
+        const claimable = await publicClient.readContract({
+          address: INVESTMENT_CONTRACT,
+          abi: INVESTMENT_ABI,
+          functionName: 'getClaimable',
+          args: [BigInt(id)],
+        }) as bigint;
+
+        const hash = await withSpinner('Claiming returns', async () => {
+          return await client.writeContract({
+            address: INVESTMENT_CONTRACT,
+            abi: INVESTMENT_ABI,
+            functionName: 'claimReturn',
+            args: [BigInt(id)],
+          account,
+          chain: base,
+          });
+        });
+
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+        if (options.json) {
+          outputJSON({
+            investmentId: id,
+            amount: claimable.toString(),
+            transactionHash: hash,
+            blockNumber: receipt.blockNumber.toString(),
+          });
+        } else {
+          success(`Claimed ${chalk.green(parseFloat((Number(claimable) / 1e6).toFixed(2)).toString())} USDC`);
+          info(`Transaction: ${chalk.gray(hash)}`);
+        }
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to claim returns');
+        process.exit(1);
+      }
+    });
+
+  // plob invest milestone
+  invest
+    .command('milestone')
+    .description('Complete a milestone (oracle only)')
+    .argument('<id>', 'Investment ID')
+    .option('--json', 'Output as JSON')
+    .action(async (id: string, options: OutputOptions) => {
+      try {
+        const { client, account } = await loadWallet();
+        const publicClient = getPublicClient();
+
+        const hash = await withSpinner('Completing milestone', async () => {
+          return await client.writeContract({
+            address: INVESTMENT_CONTRACT,
+            abi: INVESTMENT_ABI,
+            functionName: 'completeMilestone',
+            args: [BigInt(id)],
+          account,
+          chain: base,
+          });
+        });
+
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+        if (options.json) {
+          outputJSON({
+            investmentId: id,
+            transactionHash: hash,
+            blockNumber: receipt.blockNumber.toString(),
+          });
+        } else {
+          success('Milestone completed!');
+          info(`Transaction: ${chalk.gray(hash)}`);
+        }
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to complete milestone');
+        process.exit(1);
+      }
+    });
+
+  // plob invest default
+  invest
+    .command('default')
+    .description('Trigger default on investment')
+    .argument('<id>', 'Investment ID')
+    .option('--json', 'Output as JSON')
+    .action(async (id: string, options: OutputOptions) => {
+      try {
+        const { client, account } = await loadWallet();
+        const publicClient = getPublicClient();
+
+        const hash = await withSpinner('Triggering default', async () => {
+          return await client.writeContract({
+            address: INVESTMENT_CONTRACT,
+            abi: INVESTMENT_ABI,
+            functionName: 'triggerDefault',
+            args: [BigInt(id)],
+          account,
+          chain: base,
+          });
+        });
+
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+        if (options.json) {
+          outputJSON({
+            investmentId: id,
+            transactionHash: hash,
+            blockNumber: receipt.blockNumber.toString(),
+          });
+        } else {
+          success('Default triggered');
+          info(`Transaction: ${chalk.gray(hash)}`);
+        }
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to trigger default');
+        process.exit(1);
+      }
+    });
+
+  // plob invest cancel
+  invest
+    .command('cancel')
+    .description('Cancel an unfunded investment')
+    .argument('<id>', 'Investment ID')
+    .option('--json', 'Output as JSON')
+    .action(async (id: string, options: OutputOptions) => {
+      try {
+        const { client, account } = await loadWallet();
+        const publicClient = getPublicClient();
+
+        const hash = await withSpinner('Cancelling investment', async () => {
+          return await client.writeContract({
+            address: INVESTMENT_CONTRACT,
+            abi: INVESTMENT_ABI,
+            functionName: 'cancel',
+            args: [BigInt(id)],
+          account,
+          chain: base,
+          });
+        });
+
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+        if (options.json) {
+          outputJSON({
+            investmentId: id,
+            transactionHash: hash,
+            blockNumber: receipt.blockNumber.toString(),
+          });
+        } else {
+          success('Investment cancelled');
+          info(`Transaction: ${chalk.gray(hash)}`);
+        }
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to cancel investment');
+        process.exit(1);
+      }
+    });
+
+  // plob invest info
+  invest
+    .command('info')
+    .description('View investment details')
+    .argument('<id>', 'Investment ID')
+    .option('--json', 'Output as JSON')
+    .action(async (id: string, options: OutputOptions) => {
+      try {
+        const publicClient = getPublicClient();
+
+        const result = await publicClient.readContract({
+          address: INVESTMENT_CONTRACT,
+          abi: INVESTMENT_ABI,
+          functionName: 'getInvestment',
+          args: [BigInt(id)],
+        }) as [Address, Address, Address, bigint, bigint, bigint, number, bigint, bigint, number, bigint, bigint, bigint];
+
+        const [
+          investor,
+          treasury,
+          token,
+          investedAmount,
+          returnedAmount,
+          targetReturn,
+          status,
+          createdAt,
+          fundedAt,
+          returnType,
+          durationSeconds,
+          milestonesCompleted,
+          milestoneCount,
+        ] = result;
+
+        if (options.json) {
+          outputJSON({
+            investmentId: id,
+            investor,
+            treasury,
+            token,
+            investedAmount: investedAmount.toString(),
+            returnedAmount: returnedAmount.toString(),
+            targetReturn: targetReturn.toString(),
+            status: STATUS_NAMES[status],
+            createdAt: Number(createdAt),
+            fundedAt: Number(fundedAt),
+            returnType: RETURN_TYPE_NAMES[returnType],
+            durationSeconds: Number(durationSeconds),
+            milestonesCompleted: Number(milestonesCompleted),
+            milestoneCount: Number(milestoneCount),
+          });
+        } else {
+          console.log(chalk.bold.cyan('\n📊 Investment Details\n'));
+
+          const table = createTable(['Property', 'Value']);
+          table.push(
+            ['ID', chalk.white(id)],
+            ['Status', chalk.yellow(STATUS_NAMES[status])],
+            ['Type', chalk.cyan(RETURN_TYPE_NAMES[returnType])],
+            ['Investor', formatAddress(investor)],
+            ['Treasury', formatAddress(treasury)],
+            ['Token', formatAddress(token)],
+            ['Invested', `${chalk.green((Number(investedAmount) / 1e6).toFixed(2))} USDC`],
+            ['Returned', `${chalk.green((Number(returnedAmount) / 1e6).toFixed(2))} USDC`],
+            ['Target Return', `${chalk.green((Number(targetReturn) / 1e6).toFixed(2))} USDC`],
+            ['Duration', `${Number(durationSeconds) / 86400} days`],
+            ['Milestones', `${Number(milestonesCompleted)} / ${Number(milestoneCount)}`],
+            ['Created', new Date(Number(createdAt) * 1000).toLocaleDateString()],
+            ['Funded', fundedAt > 0n ? new Date(Number(fundedAt) * 1000).toLocaleDateString() : 'Not funded'],
+          );
+
+          console.log(table.toString());
+        }
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to get investment info');
+        process.exit(1);
+      }
+    });
+
+  // plob invest portfolio
+  invest
+    .command('portfolio')
+    .description('View investor portfolio')
+    .argument('[address]', 'Investor address (default: your address)')
+    .option('--json', 'Output as JSON')
+    .action(async (address: string | undefined, options: OutputOptions) => {
+      try {
+        const publicClient = getPublicClient();
+        const investor = (address || (await getWalletAddress())) as Address;
+
+        const investmentIds = await publicClient.readContract({
+          address: INVESTMENT_CONTRACT,
+          abi: INVESTMENT_ABI,
+          functionName: 'getInvestorPortfolio',
+          args: [investor],
+        }) as bigint[];
+
+        if (options.json) {
+          outputJSON({
+            investor,
+            count: investmentIds.length,
+            investments: investmentIds.map(id => id.toString()),
+          });
+        } else {
+          console.log(chalk.bold.cyan(`\n💼 Portfolio for ${formatAddress(investor)}\n`));
+
+          if (investmentIds.length === 0) {
+            info('No investments found');
+            return;
+          }
+
+          const table = createTable(['ID', 'Status', 'Invested', 'Returned', 'Type']);
+
+          for (const investmentId of investmentIds) {
+            const result = await publicClient.readContract({
+              address: INVESTMENT_CONTRACT,
+              abi: INVESTMENT_ABI,
+              functionName: 'getInvestment',
+              args: [investmentId],
+            }) as [Address, Address, Address, bigint, bigint, bigint, number, bigint, bigint, number, bigint, bigint, bigint];
+
+            const [, , , investedAmount, returnedAmount, , status, , , returnType] = result;
+
+            table.push([
+              chalk.white(investmentId.toString()),
+              chalk.yellow(STATUS_NAMES[status]),
+              `${chalk.green((Number(investedAmount) / 1e6).toFixed(2))} USDC`,
+              `${chalk.green((Number(returnedAmount) / 1e6).toFixed(2))} USDC`,
+              chalk.cyan(RETURN_TYPE_NAMES[returnType]),
+            ]);
+          }
+
+          console.log(table.toString());
+          info(`Total investments: ${investmentIds.length}`);
+        }
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to get portfolio');
+        process.exit(1);
+      }
+    });
+
+  // plob invest treasury
+  invest
+    .command('treasury')
+    .description('View treasury investments')
+    .argument('[address]', 'Treasury address (default: your treasury)')
+    .option('--json', 'Output as JSON')
+    .action(async (address: string | undefined, options: OutputOptions) => {
+      try {
+        const publicClient = getPublicClient();
+        
+        let treasury: Address;
+        if (address) {
+          treasury = address as Address;
+        } else {
+          // Try to get user's treasury from TreasuryFactory
+          const owner = await getWalletAddress();
+          treasury = await publicClient.readContract({
+            address: '0x171a685f28546a0ebb13059184db1f808b915066' as Address,
+            abi: [
+              {
+                type: 'function',
+                name: 'treasuries',
+                inputs: [{ name: '', type: 'address' }],
+                outputs: [{ name: '', type: 'address' }],
+                stateMutability: 'view',
+              },
+            ] as const,
+            functionName: 'treasuries',
+            args: [owner as Address],
+          }) as Address;
+        }
+
+        const investmentIds = await publicClient.readContract({
+          address: INVESTMENT_CONTRACT,
+          abi: INVESTMENT_ABI,
+          functionName: 'getTreasuryInvestments',
+          args: [treasury],
+        }) as bigint[];
+
+        if (options.json) {
+          outputJSON({
+            treasury,
+            count: investmentIds.length,
+            investments: investmentIds.map(id => id.toString()),
+          });
+        } else {
+          console.log(chalk.bold.cyan(`\n🏦 Treasury Investments: ${formatAddress(treasury)}\n`));
+
+          if (investmentIds.length === 0) {
+            info('No investments found');
+            return;
+          }
+
+          const table = createTable(['ID', 'Status', 'Amount', 'Investor', 'Type']);
+
+          for (const investmentId of investmentIds) {
+            const result = await publicClient.readContract({
+              address: INVESTMENT_CONTRACT,
+              abi: INVESTMENT_ABI,
+              functionName: 'getInvestment',
+              args: [investmentId],
+            }) as [Address, Address, Address, bigint, bigint, bigint, number, bigint, bigint, number, bigint, bigint, bigint];
+
+            const [investor, , , investedAmount, , , status, , , returnType] = result;
+
+            table.push([
+              chalk.white(investmentId.toString()),
+              chalk.yellow(STATUS_NAMES[status]),
+              `${chalk.green((Number(investedAmount) / 1e6).toFixed(2))} USDC`,
+              formatAddress(investor),
+              chalk.cyan(RETURN_TYPE_NAMES[returnType]),
+            ]);
+          }
+
+          console.log(table.toString());
+          info(`Total investments: ${investmentIds.length}`);
+        }
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to get treasury investments');
+        process.exit(1);
+      }
+    });
+
+  // plob invest stats
+  invest
+    .command('stats')
+    .description('View protocol-wide investment statistics')
+    .option('--json', 'Output as JSON')
+    .action(async (options: OutputOptions) => {
+      try {
+        const publicClient = getPublicClient();
+
+        const [totalInvestments, totalInvested, totalReturned, totalProtocolFees] = await publicClient.readContract({
+          address: INVESTMENT_CONTRACT,
+          abi: INVESTMENT_ABI,
+          functionName: 'getStats',
+          args: [],
+        }) as [bigint, bigint, bigint, bigint];
+
+        if (options.json) {
+          outputJSON({
+            totalInvestments: Number(totalInvestments),
+            totalInvested: totalInvested.toString(),
+            totalReturned: totalReturned.toString(),
+            totalProtocolFees: totalProtocolFees.toString(),
+          });
+        } else {
+          console.log(chalk.bold.cyan('\n📊 Protocol Investment Statistics\n'));
+
+          const table = createTable(['Metric', 'Value']);
+          table.push(
+            ['Total Investments', chalk.white(totalInvestments.toString())],
+            ['Total Invested', `${chalk.green((Number(totalInvested) / 1e6).toFixed(2))} USDC`],
+            ['Total Returned', `${chalk.green((Number(totalReturned) / 1e6).toFixed(2))} USDC`],
+            ['Protocol Fees', `${chalk.yellow((Number(totalProtocolFees) / 1e6).toFixed(2))} USDC`],
+            ['Avg Return Rate', `${chalk.cyan(((Number(totalReturned) / Number(totalInvested)) * 100).toFixed(2))}%`],
+          );
+
+          console.log(table.toString());
+        }
+      } catch (err) {
+        error(err instanceof Error ? err.message : 'Failed to get stats');
+        process.exit(1);
+      }
+    });
+}