@paylobster/cli 4.3.0 → 4.5.0

package/src/commands/trust-graph.ts

@@ -0,0 +1,267 @@
+import { Command } from 'commander';
+import { getTrustGraph } from '../lib/contracts';
+import { error, success, outputJSON, header, info } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+import type { Address } from 'viem';
+
+export function createTrustGraphCommand(): Command {
+  const cmd = new Command('trust')
+    .description('Manage and query trust network')
+    .addHelpText('after', `
+Examples:
+  $ plob trust endorse 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb 85
+  $ plob trust revoke 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb
+  $ plob trust check 0xAlice 0xBob
+  $ plob trust score 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb
+  $ plob trust endorsements 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb
+    `);
+
+  // Endorse agent
+  cmd
+    .command('endorse')
+    .description('Endorse another agent with a trust level')
+    .argument('<address>', 'Agent address to endorse')
+    .argument('<score>', 'Trust score (1-100)')
+    .option('--json', 'Output as JSON')
+    .action(async (addressArg: string, scoreArg: string, options: OutputOptions) => {
+      try {
+        const address = addressArg as Address;
+        const score = parseInt(scoreArg);
+
+        if (score < 1 || score > 100) {
+          error('Trust score must be between 1 and 100');
+          process.exit(1);
+        }
+
+        const trustGraph = getTrustGraph();
+        
+        info(`Endorsing ${address} with trust level ${score}...`);
+        const hash = await trustGraph.endorseAgent(address, score);
+
+        if (outputJSON({ transactionHash: hash, endorsed: address, trustLevel: score }, options)) {
+          return;
+        }
+
+        success(`Endorsed ${address} with trust level ${score}/100`);
+        console.log(`Transaction: ${hash}`);
+      } catch (err) {
+        error(`Failed to endorse agent: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Revoke endorsement
+  cmd
+    .command('revoke')
+    .description('Revoke an endorsement')
+    .argument('<address>', 'Agent address to revoke endorsement from')
+    .option('--json', 'Output as JSON')
+    .action(async (addressArg: string, options: OutputOptions) => {
+      try {
+        const address = addressArg as Address;
+        const trustGraph = getTrustGraph();
+        
+        info(`Revoking endorsement of ${address}...`);
+        const hash = await trustGraph.revokeEndorsement(address);
+
+        if (outputJSON({ transactionHash: hash, revoked: address }, options)) {
+          return;
+        }
+
+        success(`Revoked endorsement of ${address}`);
+        console.log(`Transaction: ${hash}`);
+      } catch (err) {
+        error(`Failed to revoke endorsement: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Check trust between two agents
+  cmd
+    .command('check')
+    .description('Check trust level between two agents')
+    .argument('<from>', 'Source agent address')
+    .argument('<to>', 'Target agent address')
+    .option('--inferred', 'Calculate inferred trust through network')
+    .option('--depth <number>', 'Max hops for inferred trust (default: 4)', '4')
+    .option('--json', 'Output as JSON')
+    .action(async (fromArg: string, toArg: string, options: any) => {
+      try {
+        const from = fromArg as Address;
+        const to = toArg as Address;
+        const trustGraph = getTrustGraph();
+
+        if (options.inferred) {
+          // Get inferred trust through network
+          const maxDepth = parseInt(options.depth);
+          const result = await trustGraph.getInferredTrust(from, to, maxDepth);
+
+          if (outputJSON({ from, to, trustScore: result.trustScore, pathLength: result.pathLength, type: 'inferred' }, options)) {
+            return;
+          }
+
+          header('Inferred Trust');
+          console.log();
+          console.log('From:        ', from);
+          console.log('To:          ', to);
+          console.log('Trust Score: ', result.trustScore);
+          console.log('Path Length: ', result.pathLength, 'hops');
+          console.log();
+        } else {
+          // Get direct trust
+          const trustLevel = await trustGraph.getDirectTrust(from, to);
+
+          if (outputJSON({ from, to, trustLevel, type: 'direct' }, options)) {
+            return;
+          }
+
+          header('Direct Trust');
+          console.log();
+          console.log('From:        ', from);
+          console.log('To:          ', to);
+          console.log('Trust Level: ', trustLevel === 0 ? 'No direct endorsement' : `${trustLevel}/100`);
+          console.log();
+        }
+      } catch (err) {
+        error(`Failed to check trust: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Get aggregate trust score
+  cmd
+    .command('score')
+    .description('Get aggregate trust score for an agent')
+    .argument('<address>', 'Agent address')
+    .option('--json', 'Output as JSON')
+    .action(async (addressArg: string, options: OutputOptions) => {
+      try {
+        const address = addressArg as Address;
+        const trustGraph = getTrustGraph();
+
+        const [aggregateScore, endorsers] = await Promise.all([
+          trustGraph.getAggregateTrust(address),
+          trustGraph.getEndorsers(address),
+        ]);
+
+        if (outputJSON({ address, aggregateScore, endorserCount: endorsers.length }, options)) {
+          return;
+        }
+
+        header('Trust Score');
+        console.log();
+        console.log('Agent:            ', address);
+        console.log('Aggregate Score:  ', aggregateScore);
+        console.log('Endorser Count:   ', endorsers.length);
+        console.log();
+
+        if (aggregateScore >= 80) {
+          console.log('✅ Highly trusted in the network');
+        } else if (aggregateScore >= 60) {
+          console.log('✅ Well trusted in the network');
+        } else if (aggregateScore >= 40) {
+          console.log('⚠️  Moderately trusted');
+        } else if (aggregateScore > 0) {
+          console.log('⚠️  Limited trust in the network');
+        } else {
+          console.log('❌ No endorsements yet');
+        }
+        console.log();
+      } catch (err) {
+        error(`Failed to get trust score: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Get endorsements (agents this address has endorsed)
+  cmd
+    .command('endorsements')
+    .description('List all agents endorsed by an address')
+    .argument('[address]', 'Agent address (default: your wallet)')
+    .option('--json', 'Output as JSON')
+    .action(async (addressArg: string | undefined, options: OutputOptions) => {
+      try {
+        let address: Address;
+
+        if (addressArg) {
+          address = addressArg as Address;
+        } else {
+          const { getWalletAddress } = await import('../lib/wallet');
+          address = getWalletAddress() as Address;
+        }
+
+        const trustGraph = getTrustGraph();
+        const endorsed = await trustGraph.getEndorsements(address);
+
+        if (outputJSON({ address, endorsed, count: endorsed.length }, options)) {
+          return;
+        }
+
+        header('Endorsements');
+        console.log();
+        console.log('Endorser:    ', address);
+        console.log('Endorsed:    ', endorsed.length, 'agents');
+        console.log();
+
+        if (endorsed.length > 0) {
+          endorsed.forEach((agent, i) => {
+            console.log(`  ${i + 1}. ${agent}`);
+          });
+          console.log();
+        } else {
+          console.log('No endorsements yet.');
+          console.log();
+        }
+      } catch (err) {
+        error(`Failed to get endorsements: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // Get endorsers (agents who endorse this address)
+  cmd
+    .command('endorsers')
+    .description('List all agents who endorse an address')
+    .argument('[address]', 'Agent address (default: your wallet)')
+    .option('--json', 'Output as JSON')
+    .action(async (addressArg: string | undefined, options: OutputOptions) => {
+      try {
+        let address: Address;
+
+        if (addressArg) {
+          address = addressArg as Address;
+        } else {
+          const { getWalletAddress } = await import('../lib/wallet');
+          address = getWalletAddress() as Address;
+        }
+
+        const trustGraph = getTrustGraph();
+        const endorsers = await trustGraph.getEndorsers(address);
+
+        if (outputJSON({ address, endorsers, count: endorsers.length }, options)) {
+          return;
+        }
+
+        header('Endorsers');
+        console.log();
+        console.log('Endorsed:    ', address);
+        console.log('Endorsers:   ', endorsers.length, 'agents');
+        console.log();
+
+        if (endorsers.length > 0) {
+          endorsers.forEach((agent, i) => {
+            console.log(`  ${i + 1}. ${agent}`);
+          });
+          console.log();
+        } else {
+          console.log('No endorsers yet.');
+          console.log();
+        }
+      } catch (err) {
+        error(`Failed to get endorsers: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/whoami.ts

@@ -0,0 +1,172 @@
+import { Command } from 'commander';
+import { getAgentInfo, getReputation, getCreditStatus, getBalance, getUserEscrowCount, formatUSDC, formatETH } from '../lib/contracts';
+import { getWalletAddress } from '../lib/wallet';
+import { loadConfig } from '../lib/config';
+import { error, outputJSON } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+import chalk from 'chalk';
+import ora from 'ora';
+
+export function createWhoamiCommand(): Command {
+  const cmd = new Command('whoami')
+    .description('🦞 Show your complete PayLobster profile')
+    .option('--json', 'Output as JSON')
+    .action(async (options: OutputOptions) => {
+      const spinner = ora('Loading your profile...').start();
+
+      try {
+        const address = getWalletAddress() as `0x${string}`;
+        const config = loadConfig();
+
+        // Fetch all data in parallel
+        const [agentInfo, reputation, creditStatus, balance, escrowCount] = await Promise.all([
+          getAgentInfo(address),
+          getReputation(address),
+          getCreditStatus(address),
+          getBalance(address),
+          getUserEscrowCount(address),
+        ]);
+
+        spinner.stop();
+
+        // Calculate metrics
+        const reputationScore = Number(reputation.score);
+        const usdcBalance = formatUSDC(balance.usdc);
+        const ethBalance = formatETH(balance.eth);
+        const creditLimit = formatUSDC(creditStatus.limit);
+        const creditAvailable = formatUSDC(creditStatus.available);
+        const creditInUse = formatUSDC(creditStatus.inUse);
+        const creditUtilization = creditStatus.limit > 0n 
+          ? ((Number(creditStatus.inUse) / Number(creditStatus.limit)) * 100).toFixed(1)
+          : '0';
+
+        // Calculate total net worth (USDC + credit available)
+        const totalNetWorth = parseFloat(usdcBalance) + parseFloat(creditAvailable);
+
+        // JSON output
+        if (outputJSON({
+          identity: {
+            name: agentInfo.name,
+            address,
+            registered: agentInfo.registered,
+            tokenId: agentInfo.tokenId.toString(),
+            registrationDate: agentInfo.registered ? 'N/A' : null, // TODO: get from events
+          },
+          reputation: {
+            score: reputationScore,
+            totalInteractions: 0, // TODO: get from events
+            successRate: 0, // TODO: calculate
+          },
+          credit: {
+            score: reputationScore, // Using reputation as proxy
+            limit: creditLimit,
+            available: creditAvailable,
+            inUse: creditInUse,
+            utilization: parseFloat(creditUtilization),
+          },
+          treasury: {
+            name: null, // TODO: get from TreasuryFactory
+            aum: 0,
+            budgetAllocation: {},
+            memberCount: 0,
+          },
+          activity: {
+            activeEscrows: escrowCount,
+            activeStreams: 0, // TODO: get from Stream contract
+          },
+          balance: {
+            usdc: usdcBalance,
+            eth: ethBalance,
+            totalNetWorth: totalNetWorth.toFixed(2),
+          },
+          network: config.network,
+        }, options)) {
+          return;
+        }
+
+        // Pretty output
+        console.log('\n' + chalk.cyan.bold('═══════════════════════════════════════════════════════════'));
+        console.log(chalk.cyan.bold('                   🦞 PayLobster Profile'));
+        console.log(chalk.cyan.bold('═══════════════════════════════════════════════════════════\n'));
+
+        // Identity Section
+        console.log(chalk.bold.underline('👤 IDENTITY'));
+        console.log();
+        console.log(chalk.gray('  Name:           '), agentInfo.registered ? chalk.bold.white(agentInfo.name) : chalk.yellow('Not Registered'));
+        console.log(chalk.gray('  Address:        '), chalk.dim(address));
+        console.log(chalk.gray('  Token ID:       '), agentInfo.registered ? chalk.white(`#${agentInfo.tokenId.toString()}`) : chalk.gray('N/A'));
+        console.log(chalk.gray('  Network:        '), chalk.white(config.network === 'mainnet' ? '🟢 Base Mainnet' : '🟡 Base Sepolia'));
+        console.log();
+
+        // Reputation Section
+        console.log(chalk.bold.underline('⭐ REPUTATION'));
+        console.log();
+        
+        let reputationColor = chalk.red;
+        let reputationEmoji = '❌';
+        if (reputationScore >= 80) {
+          reputationColor = chalk.green;
+          reputationEmoji = '🌟';
+        } else if (reputationScore >= 50) {
+          reputationColor = chalk.yellow;
+          reputationEmoji = '⭐';
+        }
+        
+        console.log(chalk.gray('  Score:          '), reputationColor.bold(reputationScore.toString()), reputationEmoji);
+        console.log(chalk.gray('  Total Txs:      '), chalk.white('N/A')); // TODO
+        console.log(chalk.gray('  Success Rate:   '), chalk.white('N/A')); // TODO
+        console.log();
+
+        // Credit Section
+        console.log(chalk.bold.underline('💳 CREDIT'));
+        console.log();
+        console.log(chalk.gray('  Score:          '), reputationColor.bold(reputationScore.toString())); // Using reputation
+        console.log(chalk.gray('  Credit Limit:   '), chalk.white(creditLimit), chalk.dim('USDC'));
+        console.log(chalk.gray('  Available:      '), chalk.green(creditAvailable), chalk.dim('USDC'));
+        console.log(chalk.gray('  In Use:         '), chalk.yellow(creditInUse), chalk.dim('USDC'));
+        console.log(chalk.gray('  Utilization:    '), chalk.white(creditUtilization + '%'));
+        console.log();
+
+        // Treasury Section
+        console.log(chalk.bold.underline('🏦 TREASURY'));
+        console.log();
+        console.log(chalk.gray('  Name:           '), chalk.yellow('Not implemented yet'));
+        console.log(chalk.gray('  AUM:            '), chalk.white('N/A'));
+        console.log(chalk.gray('  Budget:         '), chalk.white('N/A'));
+        console.log(chalk.gray('  Members:        '), chalk.white('N/A'));
+        console.log();
+
+        // Activity Section
+        console.log(chalk.bold.underline('📊 ACTIVITY'));
+        console.log();
+        console.log(chalk.gray('  Active Escrows: '), chalk.white(escrowCount.toString()));
+        console.log(chalk.gray('  Active Streams: '), chalk.white('N/A')); // TODO
+        console.log(chalk.gray('  Investments:    '), chalk.white('N/A')); // TODO
+        console.log();
+
+        // Balance Section
+        console.log(chalk.bold.underline('💰 BALANCES'));
+        console.log();
+        console.log(chalk.gray('  USDC:           '), chalk.green.bold(usdcBalance), chalk.dim('USDC'));
+        console.log(chalk.gray('  ETH:            '), chalk.blue(ethBalance), chalk.dim('ETH'));
+        console.log(chalk.gray('  Net Worth:      '), chalk.bold.white(totalNetWorth.toFixed(2)), chalk.dim('USDC equiv'));
+        console.log();
+
+        console.log(chalk.cyan.bold('═══════════════════════════════════════════════════════════\n'));
+
+        // Quick actions
+        console.log(chalk.dim('Quick actions:'));
+        console.log(chalk.dim('  • Open dashboard:   ') + chalk.green('plob dashboard'));
+        console.log(chalk.dim('  • Check health:     ') + chalk.green('plob health'));
+        console.log(chalk.dim('  • View transactions:') + chalk.green('plob status'));
+        console.log();
+
+      } catch (err: any) {
+        spinner.stop();
+        error(`Failed to fetch profile: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/index.ts

@@ -21,6 +21,14 @@ import { createSwapCommand } from './commands/swap';
 import { createBridgeCommand } from './commands/bridge';
 import { createPortfolioCommand } from './commands/portfolio';
 import { createTreasuryCommand } from './commands/treasury';
+import { registerInvestCommand } from './commands/invest';
+import { createQuickstartCommand } from './commands/quickstart';
+import { createWhoamiCommand } from './commands/whoami';
+import { createDashboardCommand } from './commands/dashboard';
+import { createHealthCommand } from './commands/health';
+import { createSearchCommand } from './commands/search';
+import { createExportCommand } from './commands/export';
+import { createTrustGraphCommand } from './commands/trust-graph';
 import chalk from 'chalk';
 
 // Load environment variables from .env file if present
@@ -30,9 +38,9 @@ dotenv.config();
 const program = new Command();
 
 program
-  .name('plob')
+  .name('paylobster')
   .description('🦞 PayLobster CLI - Payment infrastructure for AI agents')
-  .version('4.3.0');
+  .version('4.5.0');
 
 // ASCII art banner
 const banner = `
@@ -68,6 +76,14 @@ program.addCommand(createSwapCommand());
 program.addCommand(createBridgeCommand());
 program.addCommand(createPortfolioCommand());
 program.addCommand(createTreasuryCommand());
+program.addCommand(createQuickstartCommand());
+program.addCommand(createWhoamiCommand());
+program.addCommand(createDashboardCommand());
+program.addCommand(createHealthCommand());
+program.addCommand(createSearchCommand());
+program.addCommand(createExportCommand());
+program.addCommand(createTrustGraphCommand());
+registerInvestCommand(program);
 
 // Handle errors
 program.exitOverride((err) => {

package/src/lib/contracts.ts

@@ -11,6 +11,7 @@ const CONTRACTS_MAINNET = {
   CREDIT: '0xD9241Ce8a721Ef5fcCAc5A11983addC526eC80E1' as Address,
   ESCROW: '0x49EdEe04c78B7FeD5248A20706c7a6c540748806' as Address,
   USDC: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913' as Address,
+  TRUST_GRAPH: '0x0000000000000000000000000000000000000000' as Address, // TODO: Deploy TrustGraph
 };
 
 const CONTRACTS_SEPOLIA = {
@@ -21,6 +22,7 @@ const CONTRACTS_SEPOLIA = {
   CREDIT: '0xBA64e2b2F2a80D03A4B13b3396942C1e78205C7d' as Address,
   ESCROW: '0x78D1f50a1965dE34f6b5a3D3546C94FE1809Cd82' as Address,
   USDC: '0x036CbD53842c5426634e7929541eC2318f3dCF7e' as Address,
+  TRUST_GRAPH: '0x0000000000000000000000000000000000000000' as Address, // TODO: Deploy TrustGraph
 };
 
 // ABIs
@@ -390,3 +392,160 @@ export function formatUSDC(amount: bigint): string {
 export function formatETH(amount: bigint): string {
   return formatUnits(amount, 18);
 }
+
+// TrustGraph ABI
+const TRUST_GRAPH_ABI = [
+  {
+    inputs: [
+      { name: 'agent', type: 'address' },
+      { name: 'trustLevel', type: 'uint8' },
+    ],
+    name: 'endorseAgent',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [{ name: 'agent', type: 'address' }],
+    name: 'revokeEndorsement',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      { name: 'from', type: 'address' },
+      { name: 'to', type: 'address' },
+    ],
+    name: 'getDirectTrust',
+    outputs: [{ name: 'trustLevel', type: 'uint8' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      { name: 'from', type: 'address' },
+      { name: 'to', type: 'address' },
+      { name: 'maxDepth', type: 'uint8' },
+    ],
+    name: 'getInferredTrust',
+    outputs: [
+      { name: 'trustScore', type: 'uint256' },
+      { name: 'pathLength', type: 'uint8' },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [{ name: 'agent', type: 'address' }],
+    name: 'getEndorsements',
+    outputs: [{ name: 'endorsed', type: 'address[]' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [{ name: 'agent', type: 'address' }],
+    name: 'getEndorsers',
+    outputs: [{ name: 'endorsers', type: 'address[]' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [{ name: 'agent', type: 'address' }],
+    name: 'getTrustScore',
+    outputs: [{ name: 'score', type: 'uint256' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+] as const;
+
+/**
+ * Get TrustGraph module instance
+ */
+export function getTrustGraph() {
+  const config = loadConfig();
+  const publicClient = getPublicClient(config.network);
+  const contracts = getContracts(config.network);
+  const chain = config.network === 'mainnet' ? base : baseSepolia;
+
+  return {
+    async endorseAgent(agent: Address, trustLevel: number) {
+      const { client, account } = await loadWallet();
+      const hash = await client.writeContract({
+        address: contracts.TRUST_GRAPH,
+        abi: TRUST_GRAPH_ABI,
+        functionName: 'endorseAgent',
+        args: [agent, trustLevel],
+        account,
+        chain,
+      });
+      return hash;
+    },
+
+    async revokeEndorsement(agent: Address) {
+      const { client, account } = await loadWallet();
+      const hash = await client.writeContract({
+        address: contracts.TRUST_GRAPH,
+        abi: TRUST_GRAPH_ABI,
+        functionName: 'revokeEndorsement',
+        args: [agent],
+        account,
+        chain,
+      });
+      return hash;
+    },
+
+    async getDirectTrust(from: Address, to: Address): Promise<number> {
+      const result = await publicClient.readContract({
+        address: contracts.TRUST_GRAPH,
+        abi: TRUST_GRAPH_ABI,
+        functionName: 'getDirectTrust',
+        args: [from, to],
+      });
+      return Number(result);
+    },
+
+    async getInferredTrust(from: Address, to: Address, maxDepth: number = 4) {
+      const result = await publicClient.readContract({
+        address: contracts.TRUST_GRAPH,
+        abi: TRUST_GRAPH_ABI,
+        functionName: 'getInferredTrust',
+        args: [from, to, maxDepth],
+      });
+      return {
+        trustScore: Number(result[0]),
+        pathLength: Number(result[1]),
+      };
+    },
+
+    async getEndorsements(agent: Address): Promise<Address[]> {
+      const result = await publicClient.readContract({
+        address: contracts.TRUST_GRAPH,
+        abi: TRUST_GRAPH_ABI,
+        functionName: 'getEndorsements',
+        args: [agent],
+      });
+      return result as Address[];
+    },
+
+    async getEndorsers(agent: Address): Promise<Address[]> {
+      const result = await publicClient.readContract({
+        address: contracts.TRUST_GRAPH,
+        abi: TRUST_GRAPH_ABI,
+        functionName: 'getEndorsers',
+        args: [agent],
+      });
+      return result as Address[];
+    },
+
+    async getAggregateTrust(agent: Address): Promise<number> {
+      const result = await publicClient.readContract({
+        address: contracts.TRUST_GRAPH,
+        abi: TRUST_GRAPH_ABI,
+        functionName: 'getTrustScore',
+        args: [agent],
+      });
+      return Number(result);
+    },
+  };
+}