@megatao/sdk 1.1.0

package/cli/interactive.ts

@@ -0,0 +1,530 @@
+/**
+ * Interactive Trading Mode
+ *
+ * Provides a real-time interactive interface for trading
+ */
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { parseEther } from 'viem';
+import { AlphaFuturesClient } from '../src';
+import { formatUSD, formatTAO, formatPercentage } from '../src/utils';
+import { getClient, handleError } from './utils/client';
+import { displayPositionDetails, displayMarketSummary } from './utils/display';
+
+interface InteractiveOptions {
+  network?: string;
+  rpc?: string;
+  key?: string;
+}
+
+export async function startInteractiveMode(options: InteractiveOptions) {
+  console.clear();
+  console.log(chalk.cyan.bold('🚀 Alpha Futures Interactive Trading Mode'));
+  console.log(chalk.gray('Type "help" for available commands or "exit" to quit\n'));
+
+  let client: AlphaFuturesClient;
+  let running = true;
+
+  // Initialize client
+  const spinner = ora('Connecting to Alpha Futures...').start();
+  try {
+    client = await getClient(options);
+    const address = await client.getSignerAddress();
+    spinner.succeed(`Connected as ${chalk.cyan(address)}`);
+  } catch (error: unknown) {
+    spinner.fail('Failed to connect');
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(chalk.red(errorMessage));
+    return;
+  }
+
+  // Main loop
+  while (running) {
+    try {
+      // Get user input
+      const { command } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'command',
+          message: chalk.green('>'),
+          prefix: '',
+        },
+      ]);
+
+      // Parse command
+      const [cmd, ...args] = command.trim().toLowerCase().split(' ');
+
+      switch (cmd) {
+        case 'help':
+        case 'h':
+          showHelp();
+          break;
+
+        case 'balance':
+        case 'bal':
+          await showBalance(client);
+          break;
+
+        case 'positions':
+        case 'pos':
+          await showPositions(client);
+          break;
+
+        case 'market':
+        case 'mkt':
+          await showMarket(client, args[0]);
+          break;
+
+        case 'trade':
+        case 't':
+          await executeTrade(client);
+          break;
+
+        case 'open':
+          await quickOpen(client, args);
+          break;
+
+        case 'close':
+          await quickClose(client, args[0]);
+          break;
+
+        case 'deposit':
+        case 'dep':
+          await deposit(client, args[0]);
+          break;
+
+        case 'withdraw':
+        case 'wd':
+          await withdraw(client, args[0]);
+          break;
+
+        case 'stats':
+          await showStats(client);
+          break;
+
+        case 'clear':
+        case 'cls':
+          console.clear();
+          break;
+
+        case 'exit':
+        case 'quit':
+        case 'q':
+          running = false;
+          break;
+
+        case '':
+          // Empty command, do nothing
+          break;
+
+        default:
+          console.log(chalk.yellow(`Unknown command: ${cmd}. Type "help" for available commands.`));
+      }
+    } catch (error: unknown) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(chalk.red('Error:'), errorMessage);
+    }
+  }
+
+  console.log(chalk.cyan('\n👋 Goodbye!'));
+}
+
+function showHelp() {
+  console.log(chalk.bold('\n📚 Available Commands:'));
+  console.log('  ' + chalk.cyan('help, h') + '           Show this help message');
+  console.log('  ' + chalk.cyan('balance, bal') + '      Show account balance');
+  console.log('  ' + chalk.cyan('positions, pos') + '    List open positions');
+  console.log('  ' + chalk.cyan('market, mkt') + ' <asset> Show market data');
+  console.log('  ' + chalk.cyan('trade, t') + '          Open interactive trade dialog');
+  console.log(
+    '  ' + chalk.cyan('open') + ' <asset> <long/short> <size> <margin>  Quick open position',
+  );
+  console.log('  ' + chalk.cyan('close') + ' <positionId> Close position (use bytes16 format)');
+  console.log('  ' + chalk.cyan('deposit, dep') + ' <amount>  Deposit TAO');
+  console.log('  ' + chalk.cyan('withdraw, wd') + ' <amount> Withdraw TAO');
+  console.log('  ' + chalk.cyan('stats') + '             Show protocol statistics');
+  console.log('  ' + chalk.cyan('clear, cls') + '        Clear screen');
+  console.log('  ' + chalk.cyan('exit, quit, q') + '     Exit interactive mode');
+  console.log();
+}
+
+async function showBalance(client: AlphaFuturesClient) {
+  const spinner = ora('Loading balance...').start();
+
+  try {
+    const address = await client.getSignerAddress();
+    const addressTyped = address as `0x${string}`;
+    const summary = await client.getAlpha().getAccountSummary(addressTyped);
+
+    spinner.stop();
+
+    console.log(chalk.bold('\n💰 Account Balance:'));
+    console.log(`  Deposited: ${chalk.bold(formatTAO(summary.depositedBalance) + ' TAO')}`);
+    console.log(`  Equity: ${chalk.bold(formatTAO(summary.accountEquity) + ' TAO')}`);
+    console.log(`  Available: ${chalk.green(formatTAO(summary.availableMargin) + ' TAO')}`);
+    console.log(`  Locked: ${chalk.yellow(formatTAO(summary.lockedMargin) + ' TAO')}`);
+    console.log();
+  } catch (error) {
+    spinner.fail('Failed to load balance');
+    throw error;
+  }
+}
+
+async function showPositions(client: AlphaFuturesClient) {
+  const spinner = ora('Loading positions...').start();
+
+  try {
+    const address = await client.getSignerAddress();
+    const addressTyped = address as `0x${string}`;
+    const positionIds = await client.getAlpha().getUserPositions(addressTyped);
+
+    if (positionIds.length === 0) {
+      spinner.stop();
+      console.log(chalk.yellow('\nNo open positions'));
+      return;
+    }
+
+    // Get position details which includes market info
+    const positionDetails = await Promise.all(
+      positionIds.map((id) => client.getAlpha().getPositionDetails(id)),
+    );
+
+    // Filter active positions (notionalValue > 0 means active)
+    const activePositionsWithIds = positionDetails
+      .map((pos, index) => ({ ...pos, positionId: positionIds[index] }))
+      .filter((p) => p.notionalValue > 0n);
+
+    spinner.stop();
+
+    console.log(chalk.bold(`\n📊 Open Positions (${activePositionsWithIds.length}):`));
+
+    for (const pos of activePositionsWithIds) {
+      const currentPrice = await client.oracle.getPrice(pos.market);
+      // Compute total unrealized P&L from components
+      const pnl = pos.pricePnl + pos.fundingPayment + pos.interestPayment;
+
+      console.log(
+        `\n  ${pos.positionId} - ${pos.market} ${pos.isLong ? chalk.green('LONG') : chalk.red('SHORT')}`,
+      );
+      console.log(`  Notional: ${formatUSD(pos.notionalValue)} | Margin: ${formatTAO(pos.margin)}`);
+      console.log(`  Entry: ${formatUSD(pos.entryPrice)} | Current: ${formatUSD(currentPrice)}`);
+      console.log(
+        `  P&L: ${pnl >= 0n ? chalk.green('+' + formatUSD(pnl)) : chalk.red(formatUSD(pnl))}`,
+      );
+    }
+    console.log();
+  } catch (error) {
+    spinner.fail('Failed to load positions');
+    throw error;
+  }
+}
+
+async function showMarket(client: AlphaFuturesClient, asset?: string) {
+  if (!asset) {
+    console.log(chalk.yellow('Usage: market <asset>'));
+    return;
+  }
+
+  const spinner = ora('Loading market data...').start();
+
+  try {
+    asset = asset.toUpperCase();
+    const [price, fundingRate] = await Promise.all([
+      client.oracle.getPrice(asset as `0x${string}`),
+      client.getAlpha().getFundingRate(asset as `0x${string}`),
+    ]);
+
+    spinner.stop();
+
+    console.log(chalk.bold(`\n💹 ${asset} Market:`));
+    console.log(`  Price: ${chalk.cyan(formatUSD(price))}`);
+    console.log(`  Funding Rate: ${formatPercentage(fundingRate)} per 8h`);
+    console.log();
+  } catch (error) {
+    spinner.fail('Failed to load market data');
+    throw error;
+  }
+}
+
+async function executeTrade(client: AlphaFuturesClient) {
+  try {
+    const address = await client.getSignerAddress();
+    const addressTyped = address as `0x${string}`;
+    const available = await client.getAlpha().getAvailableMargin(addressTyped);
+
+    console.log(chalk.cyan(`\nAvailable Balance: ${formatTAO(available)} TAO`));
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'asset',
+        message: 'Asset:',
+        default: 'ALPHA',
+        transformer: (input) => input.toUpperCase(),
+      },
+      {
+        type: 'list',
+        name: 'direction',
+        message: 'Direction:',
+        choices: [
+          { name: chalk.green('Long ↗'), value: 'long' },
+          { name: chalk.red('Short ↘'), value: 'short' },
+        ],
+      },
+      {
+        type: 'input',
+        name: 'margin',
+        message: 'Margin (TAO):',
+        validate: (input) => {
+          const amount = parseFloat(input);
+          if (isNaN(amount) || amount <= 0) return 'Invalid amount';
+          if (parseEther(input) > available) return 'Insufficient balance';
+          return true;
+        },
+      },
+      {
+        type: 'list',
+        name: 'leverage',
+        message: 'Leverage:',
+        choices: ['1x', '2x', '3x', '5x', '10x'],
+        default: '3x',
+      },
+    ]);
+
+    const marginAmount = parseEther(answers.margin);
+    const leverage = parseFloat(answers.leverage);
+    const positionSize = (marginAmount * BigInt(Math.floor(leverage * 100))) / 100n;
+    const isLong = answers.direction === 'long';
+
+    // Get current price
+    const currentPrice = await client.oracle.getPrice(answers.asset as `0x${string}`);
+
+    // Show summary and confirm
+    console.log(chalk.bold('\n📋 Order Summary:'));
+    console.log(`  ${isLong ? chalk.green('LONG') : chalk.red('SHORT')} ${answers.asset}`);
+    console.log(`  Size: ${formatUSD(positionSize)}`);
+    console.log(`  Entry: ${formatUSD(currentPrice)}`);
+    console.log(`  Leverage: ${leverage}x`);
+
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Execute trade?',
+        default: true,
+      },
+    ]);
+
+    if (!confirm) {
+      console.log(chalk.yellow('Trade cancelled'));
+      return;
+    }
+
+    const spinner = ora('Opening position...').start();
+
+    const txHash = await client.getAlpha().openMarketPosition(
+      answers.asset as `0x${string}`,
+      isLong,
+      marginAmount,
+      parseEther(answers.leverage.replace('x', '')),
+      100n, // 1% max slippage
+      {
+        waitForConfirmation: true,
+      },
+    );
+
+    spinner.succeed('Position opened!');
+    console.log(chalk.green(`Transaction: ${txHash}\n`));
+  } catch (error) {
+    throw error;
+  }
+}
+
+async function quickOpen(client: AlphaFuturesClient, args: string[]) {
+  if (args.length < 4) {
+    console.log(chalk.yellow('Usage: open <asset> <long/short> <margin> <leverage>'));
+    console.log(chalk.gray('Example: open ALPHA long 100 3'));
+    return;
+  }
+
+  const [asset, direction, margin, leverage] = args;
+  const isLong = direction === 'long';
+
+  const spinner = ora('Opening position...').start();
+
+  try {
+    const txHash = await client.getAlpha().openMarketPosition(
+      asset.toUpperCase() as `0x${string}`,
+      isLong,
+      parseEther(margin),
+      parseEther(leverage),
+      100n, // 1% max slippage
+      { waitForConfirmation: true },
+    );
+
+    spinner.succeed(`Position opened: ${asset.toUpperCase()} ${direction.toUpperCase()}`);
+    console.log(chalk.green(`Transaction: ${txHash}`));
+  } catch (error) {
+    spinner.fail('Failed to open position');
+    throw error;
+  }
+}
+
+/**
+ * Validates position ID format and provides helpful error message
+ * @param positionId Position ID to validate
+ * @throws Error with helpful message if format is incorrect
+ */
+function validatePositionIdFormat(positionId: string): void {
+  if (!positionId) {
+    throw new Error(`Position ID cannot be empty.
+    
+Expected format: 32 hex characters after 0x (bytes16)
+Example: 0x00000000000000000000000000000001`);
+  }
+
+  const hex = positionId.startsWith('0x') ? positionId.slice(2) : positionId;
+
+  // Check if contains only hex characters
+  if (!/^[0-9a-fA-F]*$/.test(hex)) {
+    throw new Error(`Invalid position ID format: "${positionId}"
+    
+Position ID must contain only hexadecimal characters (0-9, a-f, A-F).
+Expected format: 32 hex characters after 0x (bytes16)
+Example: 0x00000000000000000000000000000001`);
+  }
+
+  // Warn if too long (would be truncated)
+  if (hex.length > 32) {
+    console.warn(
+      chalk.yellow(`⚠️  Position ID is longer than 32 hex characters and will be truncated.
+    Given: ${positionId}
+    Will use: 0x${hex.slice(0, 32)}`),
+    );
+  }
+}
+
+async function quickClose(client: AlphaFuturesClient, positionId?: string) {
+  if (!positionId) {
+    console.log(chalk.yellow('Usage: close <positionId>'));
+    console.log(chalk.gray('Example: close 0x00000000000000000000000000000001'));
+    console.log(
+      chalk.gray('Note: Position ID must be in bytes16 format (32 hex characters after 0x)'),
+    );
+    return;
+  }
+
+  try {
+    // Validate format first
+    validatePositionIdFormat(positionId);
+  } catch (error: any) {
+    console.error(chalk.red('❌ ' + error.message));
+    return;
+  }
+
+  const spinner = ora('Closing position...').start();
+
+  try {
+    // Convert position ID to proper format - pad to 32 characters if needed
+    const hex = positionId.startsWith('0x') ? positionId.slice(2) : positionId;
+    const normalizedHex = hex.length > 32 ? hex.slice(0, 32) : hex.padEnd(32, '0');
+    const formattedPositionId = `0x${normalizedHex}` as `0x${string}`;
+
+    const position = await client.getAlpha().getPosition(formattedPositionId);
+    const txHash = await client
+      .getAlpha()
+      .closePosition(formattedPositionId, position.notionalValue, {
+        waitForConfirmation: true,
+      });
+
+    spinner.succeed(`Position #${positionId} closed`);
+    console.log(chalk.green(`Transaction: ${txHash}`));
+  } catch (error) {
+    spinner.fail('Failed to close position');
+    throw error;
+  }
+}
+
+async function deposit(client: AlphaFuturesClient, amount?: string) {
+  if (!amount) {
+    console.log(chalk.yellow('Usage: deposit <amount>'));
+    return;
+  }
+
+  const spinner = ora('Processing deposit...').start();
+
+  try {
+    const txHash = await client.getAlpha().deposit(parseEther(amount), {
+      waitForConfirmation: true,
+    });
+
+    spinner.succeed(`Deposited ${amount} TAO`);
+
+    // Show new balance
+    const address = await client.getSignerAddress();
+    const addressTyped = address as `0x${string}`;
+    const balance = await client.getAlpha().getMarginBalance(addressTyped);
+    console.log(chalk.gray(`New balance: ${formatTAO(balance)} TAO\n`));
+    console.log(chalk.green(`Transaction: ${txHash}`));
+  } catch (error) {
+    spinner.fail('Deposit failed');
+    throw error;
+  }
+}
+
+async function withdraw(client: AlphaFuturesClient, amount?: string) {
+  if (!amount) {
+    console.log(chalk.yellow('Usage: withdraw <amount>'));
+    return;
+  }
+
+  const spinner = ora('Processing withdrawal...').start();
+
+  try {
+    const address = await client.getSignerAddress();
+    const addressTyped = address as `0x${string}`;
+    const withdrawAmount =
+      amount === 'all'
+        ? await client.getAlpha().getAvailableMargin(addressTyped)
+        : parseEther(amount);
+
+    const txHash = await client.getAlpha().withdraw(withdrawAmount, {
+      waitForConfirmation: true,
+    });
+
+    spinner.succeed(`Withdrew ${formatTAO(withdrawAmount)} TAO`);
+
+    // Show new balance
+    const balance = await client.getAlpha().getMarginBalance(addressTyped);
+    console.log(chalk.gray(`Remaining balance: ${formatTAO(balance)} TAO\n`));
+    console.log(chalk.green(`Transaction: ${txHash}`));
+  } catch (error) {
+    spinner.fail('Withdrawal failed');
+    throw error;
+  }
+}
+
+async function showStats(client: AlphaFuturesClient) {
+  const spinner = ora('Loading statistics...').start();
+
+  try {
+    const [vaultBalance, vaultStats] = await Promise.all([
+      client.getAlpha().getVaultBalance(),
+      client.getAlpha().getVaultStats(),
+    ]);
+
+    spinner.stop();
+
+    console.log(chalk.bold('\n📊 Protocol Statistics:'));
+    console.log(`  Vault Balance: ${formatTAO(vaultBalance)} TAO`);
+    console.log(`  Total Reserves: ${formatTAO(vaultStats.totalReserves)} TAO`);
+    console.log(`  Available Reserves: ${formatTAO(vaultStats.availableReserves)} TAO`);
+    console.log(`  Total Exposure: ${formatTAO(vaultStats.totalExposure)} TAO`);
+    console.log();
+  } catch (error) {
+    spinner.fail('Failed to load statistics');
+    throw error;
+  }
+}