@paylobster/cli 4.3.1 → 4.5.0

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