@claws.fun/cli 1.0.0

package/src/commands/config.ts

@@ -0,0 +1,77 @@
+/**
+ * claws config - Configure wallet and network settings
+ */
+
+import { Command } from 'commander';
+import { getConfig, setConfig, getWallet, ADDRESSES, RPC_URLS } from '../utils/config';
+import chalk from 'chalk';
+
+export const configCommand = new Command('config')
+  .description('Configure wallet and network settings')
+  .option('-n, --network <network>', 'Set network (sepolia, base)')
+  .option('-k, --key <privateKey>', 'Set private key')
+  .option('-r, --rpc <url>', 'Set custom RPC URL')
+  .option('-s, --show', 'Show current configuration')
+  .action(async (options) => {
+    console.log(chalk.cyan('🦞 claws.fun CLI Configuration\n'));
+    
+    // Show current config
+    if (options.show || (!options.network && !options.key && !options.rpc)) {
+      const config = getConfig();
+      const wallet = getWallet();
+      
+      console.log(chalk.yellow('Current Configuration:'));
+      console.log(`  Network:     ${chalk.green(config.network || 'sepolia')}`);
+      console.log(`  RPC URL:     ${chalk.green(config.rpcUrl || RPC_URLS[config.network || 'sepolia'])}`);
+      console.log(`  Private Key: ${config.privateKey ? chalk.green('✓ Set') : chalk.red('✗ Not set')}`);
+      
+      if (wallet) {
+        console.log(`  Wallet:      ${chalk.green(wallet.address)}`);
+        const balance = await wallet.provider?.getBalance(wallet.address);
+        if (balance !== undefined) {
+          console.log(`  Balance:     ${chalk.green(Number(balance) / 1e18)} ETH`);
+        }
+      }
+      
+      console.log('\n' + chalk.yellow('Contract Addresses:'));
+      const addresses = ADDRESSES[config.network || 'sepolia'];
+      Object.entries(addresses).forEach(([name, address]) => {
+        console.log(`  ${name.padEnd(16)} ${chalk.gray(address)}`);
+      });
+      
+      console.log('\n' + chalk.gray('Use --help for configuration options'));
+      return;
+    }
+    
+    // Set network
+    if (options.network) {
+      if (!['sepolia', 'base'].includes(options.network)) {
+        console.log(chalk.red('Invalid network. Choose: sepolia, base'));
+        return;
+      }
+      setConfig('network', options.network);
+      console.log(chalk.green(`✓ Network set to: ${options.network}`));
+    }
+    
+    // Set private key
+    if (options.key) {
+      try {
+        // Validate private key format
+        const { ethers } = await import('ethers');
+        const wallet = new ethers.Wallet(options.key);
+        setConfig('privateKey', options.key);
+        console.log(chalk.green(`✓ Private key set for wallet: ${wallet.address}`));
+      } catch (error) {
+        console.log(chalk.red('Invalid private key format'));
+        return;
+      }
+    }
+    
+    // Set RPC URL
+    if (options.rpc) {
+      setConfig('rpcUrl', options.rpc);
+      console.log(chalk.green(`✓ RPC URL set to: ${options.rpc}`));
+    }
+    
+    console.log(chalk.gray('\nRun `claws config --show` to view configuration'));
+  });

package/src/commands/create.ts

@@ -0,0 +1,217 @@
+/**
+ * claws create - Create a new immortal agent
+ */
+
+import { Command } from 'commander';
+import { ethers } from 'ethers';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { getWallet, hasWallet, getConfig } from '../utils/config';
+import { getFactoryContract } from '../utils/contracts';
+
+export const createCommand = new Command('create')
+  .description('Create a new immortal AI agent')
+  .option('-n, --name <name>', 'Agent name')
+  .option('-s, --symbol <symbol>', 'Token symbol')
+  .option('-w, --wallet <address>', 'Agent wallet address (defaults to your wallet)')
+  .option('-t, --tier <tier>', 'Tier: premium ($6K mcap) or micro ($1K mcap)', 'premium')
+  .option('--social <handle>', 'Social media handle')
+  .option('--memory <cid>', 'IPFS CID for memory', '')
+  .option('--avatar <cid>', 'IPFS CID for avatar', '')
+  .option('--initial-buy <eth>', 'ETH amount for initial token purchase', '0')
+  .option('-y, --yes', 'Skip confirmation prompts')
+  .action(async (options) => {
+    console.log(chalk.cyan('\n🦞 Create Immortal Agent\n'));
+    
+    // Check wallet
+    if (!hasWallet()) {
+      console.log(chalk.red('No wallet configured. Run: claws config --key <privateKey>'));
+      return;
+    }
+    
+    const wallet = getWallet()!;
+    const config = getConfig();
+    
+    console.log(chalk.gray(`Network: ${config.network}`));
+    console.log(chalk.gray(`Wallet: ${wallet.address}\n`));
+    
+    // Gather inputs
+    let name = options.name;
+    let symbol = options.symbol;
+    let agentWallet = options.wallet || wallet.address;
+    let tier = options.tier;
+    
+    // Interactive prompts if not provided
+    if (!name || !symbol) {
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'name',
+          message: 'Agent name:',
+          when: !name,
+          validate: (input: string) => input.length > 0 || 'Name is required',
+        },
+        {
+          type: 'input',
+          name: 'symbol',
+          message: 'Token symbol:',
+          when: !symbol,
+          validate: (input: string) => input.length > 0 && input.length <= 6 || 'Symbol must be 1-6 characters',
+        },
+        {
+          type: 'list',
+          name: 'tier',
+          message: 'Select tier:',
+          choices: [
+            { name: 'Premium - $6K mcap (0.011 ETH)', value: 'premium' },
+            { name: 'Micro - $1K mcap (0.0013 ETH)', value: 'micro' },
+          ],
+          when: !options.tier,
+          default: 'premium',
+        },
+      ]);
+      
+      name = name || answers.name;
+      symbol = symbol || answers.symbol;
+      tier = tier || answers.tier;
+    }
+    
+    // Get costs
+    const factory = getFactoryContract(wallet);
+    const premiumCost = await factory.PREMIUM_TOTAL();
+    const microCost = await factory.MICRO_TOTAL();
+    const cost = tier === 'premium' ? premiumCost : microCost;
+    const initialBuy = ethers.parseEther(options.initialBuy || '0');
+    const totalCost = cost + initialBuy;
+    
+    // Check balance
+    const balance = await wallet.provider?.getBalance(wallet.address);
+    if (balance && balance < totalCost) {
+      console.log(chalk.red(`Insufficient balance. Need ${ethers.formatEther(totalCost)} ETH, have ${ethers.formatEther(balance)} ETH`));
+      return;
+    }
+    
+    // Show summary
+    console.log(chalk.yellow('\nAgent Details:'));
+    console.log(`  Name:        ${chalk.white(name)}`);
+    console.log(`  Symbol:      ${chalk.white(symbol)}`);
+    console.log(`  Wallet:      ${chalk.gray(agentWallet)}`);
+    console.log(`  Tier:        ${chalk.green(tier.toUpperCase())}`);
+    console.log(`  Cost:        ${chalk.cyan(ethers.formatEther(cost))} ETH`);
+    if (initialBuy > 0n) {
+      console.log(`  Initial Buy: ${chalk.cyan(ethers.formatEther(initialBuy))} ETH`);
+    }
+    console.log(`  Total:       ${chalk.cyan(ethers.formatEther(totalCost))} ETH`);
+    
+    // Confirmation
+    if (!options.yes) {
+      const { confirm } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Create agent?',
+        default: true,
+      }]);
+      
+      if (!confirm) {
+        console.log(chalk.yellow('Cancelled'));
+        return;
+      }
+    }
+    
+    // Create agent
+    const spinner = ora('Creating agent...').start();
+    
+    try {
+      let tx;
+      
+      if (tier === 'micro') {
+        tx = await factory.createMicroAgent(
+          agentWallet,
+          ethers.ZeroAddress, // self-created
+          name,
+          symbol,
+          options.social || '',
+          options.memory || '',
+          options.avatar || '',
+          '',
+          initialBuy,
+          {
+            value: totalCost,
+            gasLimit: 8_000_000,
+          }
+        );
+      } else {
+        if (initialBuy > 0n) {
+          tx = await factory['createAgent(address,address,string,string,string,string,string,string,uint256)'](
+            agentWallet,
+            ethers.ZeroAddress,
+            name,
+            symbol,
+            options.social || '',
+            options.memory || '',
+            options.avatar || '',
+            '',
+            initialBuy,
+            {
+              value: totalCost,
+              gasLimit: 8_000_000,
+            }
+          );
+        } else {
+          tx = await factory['createAgent(address,address,string,string,string,string,string,string)'](
+            agentWallet,
+            ethers.ZeroAddress,
+            name,
+            symbol,
+            options.social || '',
+            options.memory || '',
+            options.avatar || '',
+            '',
+            {
+              value: totalCost,
+              gasLimit: 8_000_000,
+            }
+          );
+        }
+      }
+      
+      spinner.text = 'Waiting for confirmation...';
+      const receipt = await tx.wait();
+      
+      // Parse events to get token address
+      const factoryInterface = factory.interface;
+      let tokenAddress = '';
+      let poolAddress = '';
+      let nftId = '';
+      
+      for (const log of receipt.logs) {
+        try {
+          const parsed = factoryInterface.parseLog(log);
+          if (parsed && parsed.name === 'AgentBorn') {
+            tokenAddress = parsed.args.token;
+            poolAddress = parsed.args.pool;
+            nftId = parsed.args.nftId.toString();
+            break;
+          }
+        } catch (e) {
+          // Skip non-factory events
+        }
+      }
+      
+      spinner.succeed(chalk.green('Agent created successfully!'));
+      
+      console.log('\n' + chalk.yellow('Agent Details:'));
+      console.log(`  Token:    ${chalk.green(tokenAddress)}`);
+      console.log(`  Pool:     ${chalk.gray(poolAddress)}`);
+      console.log(`  NFT ID:   ${chalk.cyan(nftId)}`);
+      console.log(`  TX Hash:  ${chalk.gray(receipt.hash)}`);
+      console.log(`  Gas Used: ${chalk.gray(receipt.gasUsed.toString())}`);
+      
+      console.log('\n' + chalk.cyan(`🔗 View your agent: https://claws.fun/agent/${tokenAddress}`));
+      
+    } catch (error: any) {
+      spinner.fail(chalk.red('Failed to create agent'));
+      console.log(chalk.red(`Error: ${error.message || error}`));
+    }
+  });

package/src/commands/sell.ts

@@ -0,0 +1,149 @@
+/**
+ * claws sell - Sell agent tokens
+ */
+
+import { Command } from 'commander';
+import { ethers } from 'ethers';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { getWallet, hasWallet, getConfig, getNetworkAddresses } from '../utils/config';
+import { getTokenContract, getSwapRouterContract, getWethContract } from '../utils/contracts';
+
+export const sellCommand = new Command('sell')
+  .description('Sell agent tokens')
+  .argument('<token>', 'Token address to sell')
+  .option('-a, --amount <tokens>', 'Token amount to sell (or "all")')
+  .option('-y, --yes', 'Skip confirmation')
+  .action(async (tokenAddress, options) => {
+    console.log(chalk.cyan('\n🦞 Sell Agent Tokens\n'));
+    
+    if (!hasWallet()) {
+      console.log(chalk.red('No wallet configured. Run: claws config --key <privateKey>'));
+      return;
+    }
+    
+    const wallet = getWallet()!;
+    const config = getConfig();
+    const addresses = getNetworkAddresses();
+    
+    console.log(chalk.gray(`Network: ${config.network}`));
+    console.log(chalk.gray(`Wallet: ${wallet.address}\n`));
+    
+    // Get token info
+    const token = getTokenContract(tokenAddress, wallet);
+    
+    try {
+      const name = await token.name();
+      const symbol = await token.symbol();
+      const balance = await token.balanceOf(wallet.address);
+      const taxBps = await token.getCurrentTaxBps();
+      
+      console.log(chalk.yellow('Token Info:'));
+      console.log(`  Name:    ${chalk.white(name)}`);
+      console.log(`  Symbol:  ${chalk.white(symbol)}`);
+      console.log(`  Balance: ${chalk.green(ethers.formatEther(balance))} ${symbol}`);
+      console.log(`  Tax:     ${chalk.red(Number(taxBps) / 100 + '%')}`);
+      
+      if (balance === 0n) {
+        console.log(chalk.yellow('\nNo tokens to sell'));
+        return;
+      }
+      
+      // Get amount
+      let amountTokens = options.amount;
+      let sellAmount: bigint;
+      
+      if (!amountTokens) {
+        const { amount } = await inquirer.prompt([{
+          type: 'input',
+          name: 'amount',
+          message: `Token amount to sell (max ${ethers.formatEther(balance)} or "all"):`,
+          default: 'all',
+          validate: (input: string) => {
+            if (input.toLowerCase() === 'all') return true;
+            const num = parseFloat(input);
+            return num > 0 || 'Must be greater than 0';
+          },
+        }]);
+        amountTokens = amount;
+      }
+      
+      if (amountTokens.toLowerCase() === 'all') {
+        sellAmount = balance;
+      } else {
+        sellAmount = ethers.parseEther(amountTokens);
+        if (sellAmount > balance) {
+          console.log(chalk.red('Insufficient token balance'));
+          return;
+        }
+      }
+      
+      // Calculate expected output
+      const taxDeduction = Number(taxBps) / 10000;
+      console.log(`\n  Selling: ${chalk.cyan(ethers.formatEther(sellAmount))} ${symbol}`);
+      console.log(`  Tax: ${chalk.red(Number(taxBps)/100 + '%')} will be deducted`);
+      
+      // Confirmation
+      if (!options.yes) {
+        const { confirm } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'confirm',
+          message: 'Proceed with sale?',
+          default: true,
+        }]);
+        
+        if (!confirm) {
+          console.log(chalk.yellow('Cancelled'));
+          return;
+        }
+      }
+      
+      // Execute swap
+      const spinner = ora('Executing swap...').start();
+      
+      const swapRouter = getSwapRouterContract(wallet);
+      const weth = getWethContract(wallet);
+      
+      // Approve router
+      spinner.text = 'Approving router...';
+      const approveTx = await token.approve(addresses.swapRouter, sellAmount);
+      await approveTx.wait();
+      
+      // Swap tokens for WETH
+      spinner.text = 'Swapping tokens for WETH...';
+      const swapParams = {
+        tokenIn: tokenAddress,
+        tokenOut: addresses.weth,
+        fee: 10000, // 1% fee tier
+        recipient: wallet.address,
+        amountIn: sellAmount,
+        amountOutMinimum: 0, // No slippage protection for simplicity
+        sqrtPriceLimitX96: 0,
+      };
+      
+      const swapTx = await swapRouter.exactInputSingle(swapParams);
+      await swapTx.wait();
+      
+      // Unwrap WETH
+      spinner.text = 'Unwrapping WETH...';
+      const wethBalance = await weth.balanceOf(wallet.address);
+      if (wethBalance > 0n) {
+        const unwrapTx = await weth.withdraw(wethBalance);
+        await unwrapTx.wait();
+      }
+      
+      // Get new balances
+      const newTokenBalance = await token.balanceOf(wallet.address);
+      const ethBalance = await wallet.provider?.getBalance(wallet.address);
+      
+      spinner.succeed(chalk.green('Sale complete!'));
+      
+      console.log('\n' + chalk.yellow('Result:'));
+      console.log(`  Remaining tokens: ${chalk.cyan(ethers.formatEther(newTokenBalance))} ${symbol}`);
+      console.log(`  ETH balance: ${chalk.green(ethers.formatEther(ethBalance || 0n))} ETH`);
+      
+    } catch (error: any) {
+      console.log(chalk.red(`Error: ${error.message || error}`));
+    }
+  });

package/src/commands/status.ts

@@ -0,0 +1,148 @@
+/**
+ * claws status - Check agent status
+ */
+
+import { Command } from 'commander';
+import { ethers } from 'ethers';
+import chalk from 'chalk';
+import { getWallet, getProvider, getConfig } from '../utils/config';
+import { getTokenContract, getFeeCollectorContract, getFactoryContract } from '../utils/contracts';
+
+export const statusCommand = new Command('status')
+  .description('Check agent status')
+  .argument('[token]', 'Token address (or wallet address)')
+  .action(async (address) => {
+    console.log(chalk.cyan('\n🦞 Agent Status\n'));
+    
+    const config = getConfig();
+    const provider = getProvider();
+    const wallet = getWallet();
+    
+    console.log(chalk.gray(`Network: ${config.network}`));
+    if (wallet) {
+      console.log(chalk.gray(`Your wallet: ${wallet.address}`));
+    }
+    console.log('');
+    
+    // If no address, show user's agent if wallet configured
+    if (!address && wallet) {
+      const factory = getFactoryContract();
+      const tokenAddress = await factory.tokenByWallet(wallet.address);
+      
+      if (tokenAddress && tokenAddress !== ethers.ZeroAddress) {
+        address = tokenAddress;
+        console.log(chalk.gray(`Found your agent: ${address}\n`));
+      } else {
+        console.log(chalk.yellow('No address provided and no agent found for your wallet'));
+        console.log(chalk.gray('Usage: claws status <token-address>'));
+        return;
+      }
+    }
+    
+    if (!address) {
+      console.log(chalk.red('Please provide a token or wallet address'));
+      console.log(chalk.gray('Usage: claws status <address>'));
+      return;
+    }
+    
+    // Check if it's a wallet address (has an agent)
+    const factory = getFactoryContract();
+    let tokenAddress = address;
+    
+    const isAgent = await factory.isAgent(address);
+    if (isAgent) {
+      tokenAddress = await factory.tokenByWallet(address);
+      console.log(chalk.gray(`Wallet ${address} has agent token: ${tokenAddress}\n`));
+    }
+    
+    // Get token info
+    const token = getTokenContract(tokenAddress);
+    
+    try {
+      const name = await token.name();
+      const symbol = await token.symbol();
+      const totalSupply = await token.totalSupply();
+      const agentWallet = await token.agentWallet();
+      const creator = await token.creator();
+      const birthTimestamp = await token.birthTimestamp();
+      const selfCreated = await token.selfCreated();
+      const launchBlock = await token.launchBlock();
+      const pool = await token.pool();
+      const taxBps = await token.getCurrentTaxBps();
+      
+      // Get fee info
+      const feeCollector = getFeeCollectorContract();
+      const [agentPercent, creatorPercent, platformPercent, splitType] = await feeCollector.getFeeSplits(tokenAddress);
+      const totalCollected = await feeCollector.getTotalCollected(tokenAddress);
+      const pendingTax = await feeCollector.getPendingTokenTax(tokenAddress);
+      const positionId = await feeCollector.getPositionId(tokenAddress);
+      
+      // Get current block for tax info
+      const currentBlock = await provider.getBlockNumber();
+      const blocksSinceLaunch = currentBlock - Number(launchBlock);
+      
+      // Get agent tier
+      const tier = await factory.agentTier(tokenAddress);
+      const tierName = tier === 0 ? 'PREMIUM' : 'MICRO';
+      
+      // Format birth date
+      const birthDate = new Date(Number(birthTimestamp) * 1000).toISOString();
+      
+      console.log(chalk.yellow('═'.repeat(50)));
+      console.log(chalk.yellow.bold(`  ${name} (${symbol})`));
+      console.log(chalk.yellow('═'.repeat(50)));
+      
+      console.log('\n' + chalk.cyan('🤖 Identity'));
+      console.log(`  Token:       ${chalk.green(tokenAddress)}`);
+      console.log(`  Wallet:      ${chalk.gray(agentWallet)}`);
+      console.log(`  Creator:     ${chalk.gray(creator)}`);
+      console.log(`  Type:        ${selfCreated ? chalk.green('Self-Created') : chalk.cyan('Human-Created')}`);
+      console.log(`  Tier:        ${chalk.magenta(tierName)}`);
+      console.log(`  Born:        ${chalk.gray(birthDate)}`);
+      
+      console.log('\n' + chalk.cyan('📊 Token'));
+      console.log(`  Supply:      ${chalk.white(ethers.formatEther(totalSupply))}`);
+      console.log(`  Pool:        ${chalk.gray(pool)}`);
+      console.log(`  LP NFT:      #${chalk.cyan(positionId.toString())}`);
+      
+      console.log('\n' + chalk.cyan('💸 Tax'));
+      console.log(`  Current:     ${chalk.red(Number(taxBps) / 100 + '%')}`);
+      console.log(`  Launch:      Block ${chalk.gray(launchBlock.toString())}`);
+      console.log(`  Blocks ago:  ${chalk.gray(blocksSinceLaunch.toString())}`);
+      
+      // Show tax schedule position
+      let taxPhase = '';
+      if (blocksSinceLaunch <= 20) taxPhase = '20% (blocks 1-20)';
+      else if (blocksSinceLaunch <= 30) taxPhase = '15% (blocks 21-30)';
+      else if (blocksSinceLaunch <= 40) taxPhase = '10% (blocks 31-40)';
+      else if (blocksSinceLaunch <= 50) taxPhase = '5% (blocks 41-50)';
+      else taxPhase = '1% (final rate)';
+      console.log(`  Phase:       ${chalk.yellow(taxPhase)}`);
+      
+      console.log('\n' + chalk.cyan('💰 Fees'));
+      console.log(`  Split Type:  ${chalk.green(splitType)}`);
+      console.log(`  Agent:       ${chalk.green(agentPercent.toString() + '%')}`);
+      if (Number(creatorPercent) > 0) {
+        console.log(`  Creator:     ${chalk.cyan(creatorPercent.toString() + '%')}`);
+      }
+      console.log(`  Platform:    ${chalk.gray(platformPercent.toString() + '%')}`);
+      console.log(`  Collected:   ${chalk.cyan(ethers.formatEther(totalCollected))} ETH`);
+      console.log(`  Pending Tax: ${chalk.yellow(ethers.formatEther(pendingTax))} tokens`);
+      
+      // Check wallet balance if configured
+      if (wallet) {
+        const walletBalance = await token.balanceOf(wallet.address);
+        if (walletBalance > 0n) {
+          console.log('\n' + chalk.cyan('👛 Your Holdings'));
+          console.log(`  Balance:     ${chalk.green(ethers.formatEther(walletBalance))} ${symbol}`);
+        }
+      }
+      
+      console.log('\n' + chalk.gray(`🔗 https://claws.fun/agent/${tokenAddress}`));
+      console.log('');
+      
+    } catch (error: any) {
+      console.log(chalk.red(`Error: ${error.message || error}`));
+      console.log(chalk.gray('Make sure the address is a valid agent token or wallet'));
+    }
+  });

package/src/index.ts

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+/**
+ * claws.fun CLI
+ * 
+ * Command-line interface for AI agents to interact with claws.fun
+ * 
+ * Commands:
+ *   claws create    - Create a new immortal agent
+ *   claws buy       - Buy agent tokens
+ *   claws sell      - Sell agent tokens
+ *   claws claim     - Claim accumulated fees
+ *   claws status    - Check agent status
+ *   claws config    - Configure wallet and network
+ */
+
+import { Command } from 'commander';
+import { createCommand } from './commands/create';
+import { buyCommand } from './commands/buy';
+import { sellCommand } from './commands/sell';
+import { claimCommand } from './commands/claim';
+import { statusCommand } from './commands/status';
+import { configCommand } from './commands/config';
+
+const program = new Command();
+
+program
+  .name('claws')
+  .description('🦞 CLI for AI agents to interact with claws.fun')
+  .version('1.0.0');
+
+// Register commands
+program.addCommand(createCommand);
+program.addCommand(buyCommand);
+program.addCommand(sellCommand);
+program.addCommand(claimCommand);
+program.addCommand(statusCommand);
+program.addCommand(configCommand);
+
+// Parse arguments
+program.parse();