@megatao/sdk 1.1.0

package/cli/commands/account.ts

@@ -0,0 +1,545 @@
+/**
+ * Account Commands - Manage margin accounts and balances
+ */
+
+import { Command } from 'commander';
+import { parseEther, formatEther, Address } from 'viem';
+import chalk from 'chalk';
+import ora from 'ora';
+import Table from 'cli-table3';
+import { formatTAO, formatUSD } from '../../src/utils';
+import { getClient, handleError } from '../utils/client';
+import { confirmAction } from '../utils/prompts';
+
+export function accountCommands(program: Command) {
+  const account = program.command('account').alias('acc').description('Manage margin accounts');
+
+  // Deposit command
+  account
+    .command('deposit <amount>')
+    .description('Deposit TAO to your margin account')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (amount, options) => {
+      const spinner = ora('Processing deposit...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+        const walletClient = client.getWalletClient();
+
+        if (!walletClient) {
+          throw new Error('Wallet client not initialized. Please provide a private key.');
+        }
+
+        const depositAmount = parseEther(amount);
+
+        spinner.stop();
+
+        // Show deposit details
+        console.log(chalk.bold('\n💰 Deposit Details:'));
+        console.log(`  Amount: ${chalk.green(amount + ' TAO')}`);
+        console.log(`  To: Margin Account`);
+
+        // Confirm action
+        if (!options.yes) {
+          const confirmed = await confirmAction('Proceed with deposit?');
+          if (!confirmed) {
+            console.log(chalk.yellow('Deposit cancelled'));
+            return;
+          }
+        }
+
+        // Check and approve TAO token spending if needed
+        spinner.start('Checking TAO allowance...');
+        const publicClient = client.getPublicClient();
+        const alphaAddress = alpha.getContractAddress();
+        const userAddress = walletClient.account!.address;
+
+        // Get TAO token contract
+        const taoTokenAddress = client.getCollateralTokenAddress();
+        if (!taoTokenAddress) {
+          throw new Error('TAO token address not configured');
+        }
+
+        // Check current allowance
+        const currentAllowance = (await publicClient.readContract({
+          address: taoTokenAddress,
+          abi: [
+            {
+              name: 'allowance',
+              type: 'function',
+              stateMutability: 'view',
+              inputs: [
+                { name: 'owner', type: 'address' },
+                { name: 'spender', type: 'address' },
+              ],
+              outputs: [{ name: '', type: 'uint256' }],
+            },
+          ],
+          functionName: 'allowance',
+          args: [userAddress, alphaAddress],
+        })) as bigint;
+
+        if (currentAllowance < depositAmount) {
+          spinner.text = 'Approving TAO spending...';
+          const approveHash = await walletClient.writeContract({
+            address: taoTokenAddress,
+            abi: [
+              {
+                name: 'approve',
+                type: 'function',
+                stateMutability: 'nonpayable',
+                inputs: [
+                  { name: 'spender', type: 'address' },
+                  { name: 'amount', type: 'uint256' },
+                ],
+                outputs: [{ name: '', type: 'bool' }],
+              },
+            ],
+            functionName: 'approve',
+            args: [alphaAddress, depositAmount],
+          });
+
+          await publicClient.waitForTransactionReceipt({ hash: approveHash });
+        }
+
+        spinner.text = 'Depositing TAO...';
+        const hash = await alpha.deposit(depositAmount);
+
+        spinner.text = 'Waiting for confirmation...';
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+        spinner.succeed('Deposit successful!');
+        console.log(chalk.gray(`  Transaction: ${receipt.transactionHash}`));
+        console.log(chalk.gray(`  Gas used: ${receipt.gasUsed.toString()}`));
+
+        // Show updated balance
+        const balance = await alpha.getMarginBalance(walletClient.account!.address);
+        console.log(chalk.cyan(`\n  New balance: ${formatTAO(balance)} TAO`));
+      } catch (error) {
+        spinner.fail('Deposit failed');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Withdraw command
+  account
+    .command('withdraw <amount>')
+    .description('Withdraw TAO from your margin account')
+    .option('-y, --yes', 'Skip confirmation')
+    .option('-a, --all', 'Withdraw all available balance')
+    .action(async (amount, options) => {
+      const spinner = ora('Processing withdrawal...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+        const walletClient = client.getWalletClient();
+
+        if (!walletClient) {
+          throw new Error('Wallet client not initialized. Please provide a private key.');
+        }
+
+        const userAddress = walletClient.account!.address;
+
+        let withdrawAmount: bigint;
+        if (options.all) {
+          withdrawAmount = await alpha.getAvailableMargin(userAddress);
+          amount = formatEther(withdrawAmount);
+        } else {
+          withdrawAmount = parseEther(amount);
+        }
+
+        spinner.stop();
+
+        // Check available balance
+        const available = await alpha.getAvailableMargin(userAddress);
+        if (withdrawAmount > available) {
+          spinner.fail('Insufficient available balance');
+          console.log(`  Available: ${formatTAO(available)} TAO`);
+          console.log(`  Requested: ${formatTAO(withdrawAmount)} TAO`);
+          process.exit(1);
+        }
+
+        // Show withdrawal details
+        console.log(chalk.bold('\n💸 Withdrawal Details:'));
+        console.log(`  Amount: ${chalk.red(amount + ' TAO')}`);
+        console.log(`  From: Margin Account`);
+        console.log(`  Available: ${formatTAO(available)} TAO`);
+
+        // Confirm action
+        if (!options.yes) {
+          const confirmed = await confirmAction('Proceed with withdrawal?');
+          if (!confirmed) {
+            console.log(chalk.yellow('Withdrawal cancelled'));
+            return;
+          }
+        }
+
+        spinner.start('Withdrawing TAO...');
+        const hash = await alpha.withdraw(withdrawAmount);
+
+        spinner.text = 'Waiting for confirmation...';
+        const publicClient = client.getPublicClient();
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+        spinner.succeed('Withdrawal successful!');
+        console.log(chalk.gray(`  Transaction: ${receipt.transactionHash}`));
+        console.log(chalk.gray(`  Gas used: ${receipt.gasUsed.toString()}`));
+
+        // Show updated balance
+        const balance = await alpha.getMarginBalance(userAddress);
+        console.log(chalk.cyan(`\n  Remaining balance: ${formatTAO(balance)} TAO`));
+      } catch (error) {
+        spinner.fail('Withdrawal failed');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Enhanced balance command
+  account
+    .command('balance [address]')
+    .alias('bal')
+    .description('Check balances (TAO wallet where P&L settles + margin account for trading)')
+    .option('-d, --detailed', 'Show detailed breakdown')
+    .option('-w, --wallet-only', 'Show only TAO wallet balance')
+    .option('-m, --margin-only', 'Show only margin account balance')
+    .action(async (address, options) => {
+      const spinner = ora('Fetching balance...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+        const walletClient = client.getWalletClient();
+
+        // Use provided address or wallet address
+        const userAddress = address || walletClient?.account?.address;
+
+        if (!userAddress) {
+          spinner.fail('No address provided and no wallet client available');
+          return;
+        }
+
+        // Fetch balance data using alpha - use direct methods for better compatibility
+        const balance = await alpha.getMarginBalance(userAddress as Address);
+        const available = await alpha.getAvailableMargin(userAddress as Address);
+        const locked = await alpha.getLockedMargin(userAddress as Address);
+
+        // For margin ratio, we'll need to calculate it based on positions
+        const userPositions = await alpha.getUserPositions(userAddress as Address);
+        let marginRatio = 0n;
+        if (userPositions.length > 0) {
+          // Get first position's margin ratio as proxy (in real app, would aggregate)
+          try {
+            marginRatio = await alpha.getMarginRatio(userPositions[0]);
+          } catch {
+            marginRatio = 0n;
+          }
+        }
+
+        spinner.stop();
+
+        // Get TAO wallet balance if requested
+        let taoWalletBalance = 0n;
+        if (!options.marginOnly) {
+          try {
+            const publicClient = client.getPublicClient();
+            const taoTokenAddress = client.getCollateralTokenAddress();
+            if (taoTokenAddress) {
+              taoWalletBalance = (await publicClient.readContract({
+                address: taoTokenAddress,
+                abi: [
+                  {
+                    name: 'balanceOf',
+                    type: 'function',
+                    stateMutability: 'view',
+                    inputs: [{ name: 'account', type: 'address' }],
+                    outputs: [{ name: '', type: 'uint256' }],
+                  },
+                ],
+                functionName: 'balanceOf',
+                args: [userAddress as Address],
+              })) as bigint;
+            }
+          } catch (error) {
+            // TAO token not available or error reading balance
+          }
+        }
+
+        spinner.stop();
+
+        // Display balance summary
+        if (options.walletOnly) {
+          console.log(chalk.bold(`\n💳 TAO Wallet (P&L Settlement): ${chalk.cyan(userAddress)}`));
+          console.log(`  TAO Balance: ${chalk.green(formatTAO(taoWalletBalance) + ' TAO')}`);
+          console.log(chalk.gray('  💡 All position profits and losses are settled here'));
+        } else if (options.marginOnly) {
+          console.log(chalk.bold(`\n💰 Margin Account: ${chalk.cyan(userAddress)}`));
+          console.log(`  Balance: ${chalk.green(formatTAO(balance) + ' TAO')}`);
+          console.log(`  Available: ${chalk.cyan(formatTAO(available) + ' TAO')}`);
+          console.log(`  Locked: ${chalk.yellow(formatTAO(locked) + ' TAO')}`);
+          console.log(
+            chalk.gray(
+              '  💡 Tip: Use "alpha-futures account balance" to see TAO wallet where P&L settles',
+            ),
+          );
+        } else {
+          console.log(chalk.bold(`\n💰 Account Overview: ${chalk.cyan(userAddress)}`));
+          console.log(chalk.bold('\n💳 TAO Wallet (P&L Settlement):'));
+          console.log(`  Balance: ${chalk.green(formatTAO(taoWalletBalance) + ' TAO')}`);
+          console.log(chalk.gray('  💡 All position P&L is credited/debited here'));
+          console.log(chalk.bold('\n🏦 Margin Account (Trading Collateral):'));
+          console.log(`  Total: ${chalk.green(formatTAO(balance) + ' TAO')}`);
+          console.log(`  Available: ${chalk.cyan(formatTAO(available) + ' TAO')}`);
+          console.log(`  Locked: ${chalk.yellow(formatTAO(locked) + ' TAO')}`);
+        }
+
+        if (options.detailed && !options.walletOnly) {
+          // Detailed table view
+          const table = new Table({
+            head: ['Type', 'Amount (TAO)', 'USD Value'],
+            colWidths: [20, 20, 20],
+          });
+
+          // For now, we'll use a placeholder TAO price
+          // In production, this would come from an oracle
+          const taoPrice = parseEther('100'); // $100 placeholder
+
+          table.push(
+            [
+              'Total Balance',
+              formatTAO(balance),
+              formatUSD((balance * taoPrice) / parseEther('1')),
+            ],
+            [
+              'Available',
+              chalk.green(formatTAO(available)),
+              chalk.green(formatUSD((available * taoPrice) / parseEther('1'))),
+            ],
+            [
+              'Locked',
+              chalk.yellow(formatTAO(locked)),
+              chalk.yellow(formatUSD((locked * taoPrice) / parseEther('1'))),
+            ],
+          );
+
+          console.log(table.toString());
+
+          // Margin ratio display
+          if (marginRatio > 0n) {
+            const marginRatioPercent = Number(marginRatio) / 100;
+            let marginColor = chalk.green;
+            if (marginRatioPercent < 50) marginColor = chalk.yellow;
+            if (marginRatioPercent < 30) marginColor = chalk.red;
+
+            console.log(`\n📊 Margin Ratio: ${marginColor(marginRatioPercent.toFixed(2) + '%')}`);
+          }
+        }
+      } catch (error) {
+        spinner.fail('Failed to fetch balance');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Token transfer command
+  account
+    .command('transfer <recipient> <amount>')
+    .description('Transfer TAO tokens to another address')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (recipient, amount, options) => {
+      const spinner = ora('Processing TAO transfer...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const walletClient = client.getWalletClient();
+
+        if (!walletClient) {
+          throw new Error('Wallet client not initialized. Please provide a private key.');
+        }
+
+        const transferAmount = parseEther(amount);
+        const publicClient = client.getPublicClient();
+        const userAddress = walletClient.account!.address;
+
+        // Get TAO token contract address
+        const taoTokenAddress = client.getCollateralTokenAddress();
+        if (!taoTokenAddress) {
+          throw new Error('TAO token address not configured. Set TAO_TOKEN environment variable.');
+        }
+
+        // Check sender's TAO balance
+        const senderBalance = (await publicClient.readContract({
+          address: taoTokenAddress,
+          abi: [
+            {
+              name: 'balanceOf',
+              type: 'function',
+              stateMutability: 'view',
+              inputs: [{ name: 'account', type: 'address' }],
+              outputs: [{ name: '', type: 'uint256' }],
+            },
+          ],
+          functionName: 'balanceOf',
+          args: [userAddress],
+        })) as bigint;
+
+        if (senderBalance < transferAmount) {
+          spinner.fail('Insufficient TAO balance');
+          console.log(`  Balance: ${formatTAO(senderBalance)} TAO`);
+          console.log(`  Required: ${formatTAO(transferAmount)} TAO`);
+          return;
+        }
+
+        spinner.stop();
+
+        // Show transfer details
+        console.log(chalk.bold('\n💸 TAO Transfer Details:'));
+        console.log(`  From: ${chalk.cyan(userAddress)}`);
+        console.log(`  To: ${chalk.cyan(recipient)}`);
+        console.log(`  Amount: ${chalk.green(amount + ' TAO')}`);
+        console.log(`  Available: ${formatTAO(senderBalance)} TAO`);
+
+        // Confirm action
+        if (!options.yes) {
+          const confirmed = await confirmAction('Proceed with transfer?');
+          if (!confirmed) {
+            console.log(chalk.yellow('Transfer cancelled'));
+            return;
+          }
+        }
+
+        spinner.start('Transferring TAO...');
+        const hash = await walletClient.writeContract({
+          address: taoTokenAddress,
+          abi: [
+            {
+              name: 'transfer',
+              type: 'function',
+              stateMutability: 'nonpayable',
+              inputs: [
+                { name: 'to', type: 'address' },
+                { name: 'amount', type: 'uint256' },
+              ],
+              outputs: [{ name: '', type: 'bool' }],
+            },
+          ],
+          functionName: 'transfer',
+          args: [recipient as Address, transferAmount],
+        });
+
+        spinner.text = 'Waiting for confirmation...';
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+        spinner.succeed('TAO transfer successful!');
+        console.log(chalk.gray(`  Transaction: ${receipt.transactionHash}`));
+        console.log(chalk.gray(`  Gas used: ${receipt.gasUsed.toString()}`));
+
+        // Show updated balances
+        const newSenderBalance = (await publicClient.readContract({
+          address: taoTokenAddress,
+          abi: [
+            {
+              name: 'balanceOf',
+              type: 'function',
+              stateMutability: 'view',
+              inputs: [{ name: 'account', type: 'address' }],
+              outputs: [{ name: '', type: 'uint256' }],
+            },
+          ],
+          functionName: 'balanceOf',
+          args: [userAddress],
+        })) as bigint;
+
+        console.log(chalk.cyan(`\n  Your new balance: ${formatTAO(newSenderBalance)} TAO`));
+      } catch (error) {
+        spinner.fail('TAO transfer failed');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Account info command
+  account
+    .command('info [address]')
+    .description('Get detailed account information (use "balance" for quick balance check)')
+    .action(async (address) => {
+      const spinner = ora('Fetching account info...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+        const walletClient = client.getWalletClient();
+
+        const userAddress = address || walletClient?.account?.address;
+
+        if (!userAddress) {
+          spinner.fail('No address provided and no wallet client available');
+          return;
+        }
+
+        // Fetch comprehensive account data via single RPC call
+        const [summary, positionIds] = await Promise.all([
+          alpha.getAccountSummary(userAddress as Address),
+          alpha.getUserPositions(userAddress as Address),
+        ]);
+        const balance = summary.accountEquity;
+        const available = summary.availableMargin;
+        const locked = summary.lockedMargin;
+
+        // Calculate margin ratio from positions
+        let marginRatio = 0n;
+        if (positionIds.length > 0) {
+          try {
+            marginRatio = await alpha.getMarginRatio(positionIds[0]);
+          } catch {
+            marginRatio = 0n;
+          }
+        }
+
+        spinner.stop();
+
+        // Display account summary
+        console.log(chalk.bold(`\n📋 Account Information`));
+        console.log(chalk.gray(`Address: ${userAddress}`));
+
+        // Balance info
+        console.log(chalk.bold('\n💰 Balances:'));
+        console.log(`  Total: ${formatTAO(balance)} TAO`);
+        console.log(`  Available: ${chalk.green(formatTAO(available) + ' TAO')}`);
+        console.log(`  Locked: ${chalk.yellow(formatTAO(locked) + ' TAO')}`);
+
+        // Margin info
+        if (marginRatio > 0n) {
+          const marginRatioPercent = Number(marginRatio) / 100;
+          let marginColor = chalk.green;
+          if (marginRatioPercent < 50) marginColor = chalk.yellow;
+          if (marginRatioPercent < 30) marginColor = chalk.red;
+
+          console.log(chalk.bold('\n📊 Margin Status:'));
+          console.log(`  Ratio: ${marginColor(marginRatioPercent.toFixed(2) + '%')}`);
+          console.log(
+            `  Health: ${marginRatioPercent >= 50 ? '✅ Healthy' : marginRatioPercent >= 30 ? '⚠️  Warning' : '🚨 Critical'}`,
+          );
+        }
+
+        // Position summary
+        console.log(chalk.bold('\n📈 Positions:'));
+        console.log(`  Active: ${positionIds.length}`);
+        if (positionIds.length > 0) {
+          // Fetch full position details for summary
+          const positions = await Promise.all(positionIds.map((id) => alpha.getPosition(id)));
+
+          let totalNotionalValue = 0n;
+          let totalMargin = 0n;
+          for (const pos of positions) {
+            totalNotionalValue += pos.notionalValue;
+            totalMargin += pos.margin;
+          }
+          console.log(`  Total Notional: ${formatTAO(totalNotionalValue)} TAO`);
+          console.log(`  Total Margin: ${formatTAO(totalMargin)} TAO`);
+        }
+      } catch (error) {
+        spinner.fail('Failed to fetch account info');
+        handleError(error, program.opts());
+      }
+    });
+}