@megatao/sdk 1.1.0

package/cli/commands/trading.ts

@@ -0,0 +1,483 @@
+/**
+ * Trading Commands - Execute trades and manage orders
+ */
+
+import { Command } from 'commander';
+import { parseEther } from 'viem';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { AlphaFuturesClient } from '../../src';
+import { formatUSD, formatTAO, formatPercentage } from '../../src/utils';
+import { getClient, handleError, getMarketAddress } from '../utils/client';
+import { confirmAction, validateDirection } from '../utils/prompts';
+import { displayMarketSummary, calculatePnL } from '../utils/display';
+import { openPositionCommon } from './shared/positionUtils';
+
+export function tradingCommands(program: Command) {
+  const trade = program.command('trade').description('Execute trades');
+
+  // Market order command (redirects to position open)
+  trade
+    .command('market')
+    .description('Execute a market order (opens a position)')
+    .requiredOption('-a, --asset <asset>', 'Asset to trade')
+    .requiredOption('-s, --side <side>', 'Trade side: buy/long or sell/short')
+    .option(
+      '-z, --size <size>',
+      'Position size in TAO (auto-calculated from margin × leverage if not provided)',
+    )
+    .option('-m, --margin <margin>', 'Margin amount in TAO')
+    .option('-l, --leverage <leverage>', 'Leverage (1-10x)', '3')
+    .option('-y, --yes', 'Skip confirmation')
+    .option('--sl, --stop-loss <price>', 'Stop loss price')
+    .option('--tp, --take-profit <price>', 'Take profit price')
+    .action(async (options) => {
+      try {
+        // Auto-calculate size if margin and leverage are provided
+        let size = options.size;
+        if (!size && options.margin) {
+          const marginValue = parseFloat(options.margin);
+          const leverageValue = parseFloat(options.leverage);
+          size = (marginValue * leverageValue).toString();
+          console.log(
+            chalk.gray(
+              `Auto-calculated position size: ${size} TAO (${marginValue} TAO margin × ${leverageValue}x leverage)`,
+            ),
+          );
+        } else if (!size && !options.margin) {
+          console.error(chalk.red('Error: Either --size or --margin must be provided'));
+          process.exit(1);
+        }
+
+        // Convert trade options to position options with strict validation
+        let direction: 'long' | 'short';
+        try {
+          direction = validateDirection(options.side);
+        } catch (error: any) {
+          console.error(chalk.red(`Error: ${error.message}`));
+          process.exit(1);
+        }
+
+        const positionOptions = {
+          asset: options.asset,
+          direction,
+          size: size,
+          leverage: parseFloat(options.leverage),
+          margin: options.margin,
+          skipConfirmation: options.yes,
+          stopLoss: options.stopLoss,
+          takeProfit: options.takeProfit,
+        };
+
+        const success = await openPositionCommon(positionOptions, program.opts());
+
+        if (success && (options.stopLoss || options.takeProfit)) {
+          console.log(chalk.yellow('\n⚠️  Stop loss and take profit orders coming soon'));
+        }
+      } catch (error) {
+        console.error(chalk.red('Market order failed'));
+        handleError(error, program.opts());
+      }
+    });
+
+  // Limit order command (placeholder for orderbook integration)
+  trade
+    .command('limit')
+    .description('Place a limit order')
+    .requiredOption('-a, --asset <asset>', 'Asset to trade')
+    .requiredOption('-s, --side <side>', 'Trade side: buy/long or sell/short')
+    .requiredOption('-p, --price <price>', 'Limit price')
+    .requiredOption('-z, --size <size>', 'Order size in USD')
+    .option('-m, --margin <margin>', 'Margin amount in TAO')
+    .option('-l, --leverage <leverage>', 'Leverage (1-10x)', '3')
+    .option('--post-only', 'Post-only order (maker only)')
+    .option('--ioc', 'Immediate or cancel')
+    .option('--fok', 'Fill or kill')
+    .action(async (options) => {
+      console.log(chalk.yellow('\n⚠️  Limit orders are coming soon!'));
+      console.log('The orderbook module is currently being integrated.');
+
+      // Show what the order would look like
+      const asset = options.asset.toUpperCase();
+
+      // Validate direction
+      let direction: 'long' | 'short';
+      try {
+        direction = validateDirection(options.side);
+      } catch (error: any) {
+        console.error(chalk.red(`Error: ${error.message}`));
+        return;
+      }
+
+      const price = parseEther(options.price);
+      const size = parseEther(options.size);
+      const leverage = parseFloat(options.leverage);
+
+      console.log(chalk.bold('\n📋 Limit Order Preview:'));
+      console.log(`  Asset: ${chalk.cyan(asset)}`);
+      const isBuy = direction === 'long';
+      console.log(`  Side: ${isBuy ? chalk.green('BUY') : chalk.red('SELL')}`);
+      console.log(`  Price: ${formatUSD(price)}`);
+      console.log(`  Size: ${formatUSD(size)}`);
+      console.log(`  Leverage: ${leverage}x`);
+
+      if (options.postOnly) console.log(`  Type: ${chalk.blue('Post-Only')}`);
+      if (options.ioc) console.log(`  Type: ${chalk.orange('IOC')}`);
+      if (options.fok) console.log(`  Type: ${chalk.red('FOK')}`);
+    });
+
+  // Quick trade command with interactive prompts
+  trade
+    .command('quick')
+    .description('Quick trade with interactive prompts')
+    .action(async () => {
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+        const userAddress = await client.getSignerAddress();
+
+        // Get available balance first
+        const available = await alpha.getAvailableMargin(userAddress);
+        console.log(chalk.cyan(`\nAvailable Balance: ${formatTAO(available)} TAO`));
+
+        // Interactive prompts
+        const answers = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'asset',
+            message: 'Asset to trade:',
+            default: 'ALPHA',
+            transformer: (input) => input.toUpperCase(),
+            filter: (input) => input.toUpperCase(),
+          },
+          {
+            type: 'list',
+            name: 'side',
+            message: 'Direction:',
+            choices: [
+              { name: chalk.green('Long (Buy) ↗'), value: 'long' },
+              { name: chalk.red('Short (Sell) ↘'), value: 'short' },
+            ],
+          },
+          {
+            type: 'input',
+            name: 'margin',
+            message: 'Margin amount (TAO):',
+            validate: (input: string) => {
+              const trimmed = input.trim();
+              const amount = parseFloat(trimmed);
+              if (isNaN(amount) || amount <= 0) {
+                return 'Please enter a valid amount greater than 0';
+              }
+              try {
+                if (parseEther(trimmed) > available) {
+                  return `Insufficient balance (available: ${formatTAO(available)} TAO)`;
+                }
+              } catch {
+                return 'Please enter a valid number';
+              }
+              return true;
+            },
+            filter: (input: string) => input.trim(),
+          },
+          {
+            type: 'list',
+            name: 'leverage',
+            message: 'Leverage:',
+            choices: ['1x', '2x', '3x', '5x', '10x'],
+            default: '3x',
+            filter: (input) => parseFloat(input),
+          },
+          {
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Execute trade?',
+            default: true,
+          },
+        ]);
+
+        if (!answers.confirm) {
+          console.log(chalk.yellow('Trade cancelled'));
+          return;
+        }
+
+        // Calculate position size
+        const marginAmount = parseEther(answers.margin);
+        const positionSize = (marginAmount * BigInt(Math.floor(answers.leverage * 100))) / 100n;
+
+        // Get current price
+        const currentPrice = await client.oracle.getPrice(answers.asset);
+
+        // Show final summary
+        console.log(chalk.bold('\n📊 Executing Trade:'));
+        console.log(
+          `  ${answers.side === 'long' ? chalk.green('LONG') : chalk.red('SHORT')} ${answers.asset}`,
+        );
+        console.log(`  Size: ${formatUSD(positionSize)}`);
+        console.log(`  Entry: ${formatUSD(currentPrice)}`);
+
+        const spinner = ora('Opening position...').start();
+
+        const marketAddress = getMarketAddress(asset);
+        const leverageBigInt = BigInt(Math.floor(answers.leverage * 100));
+        const hash = await alpha.openPosition(
+          marketAddress,
+          answers.side === 'long',
+          positionSize,
+          leverageBigInt,
+        );
+
+        const publicClient = client.getPublicClient();
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+        spinner.succeed('Trade executed successfully!');
+
+        // Parse position opened event
+        const positionEvent = alpha.parsePositionOpenedEvent(receipt);
+        if (positionEvent) {
+          console.log(chalk.green(`\n✓ Position ID: ${positionEvent.positionId}`));
+        }
+      } catch (error) {
+        handleError(error, program.opts());
+      }
+    });
+
+  // Close all positions command
+  trade
+    .command('close-all')
+    .description('Close all open positions')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (options) => {
+      const spinner = ora('Loading positions...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+        const userAddress = await client.getSignerAddress();
+
+        // Get all active positions
+        const positionIds = await alpha.getUserPositions(userAddress);
+        const positions = await Promise.all(positionIds.map((id) => alpha.getPosition(id)));
+
+        const activePositions = positions.filter((p) => p.size > 0n);
+
+        if (activePositions.length === 0) {
+          spinner.stop();
+          console.log(chalk.yellow('\nNo active positions to close'));
+          return;
+        }
+
+        spinner.stop();
+
+        // Calculate total P&L
+        let totalPnL = 0n;
+        console.log(chalk.bold(`\n🔒 Closing ${activePositions.length} positions:`));
+
+        const currentPrice = await client.oracle.getPrice('ALPHA'); // Placeholder asset
+
+        for (const pos of activePositions) {
+          const pnl = calculatePnL(pos, currentPrice, pos.size);
+
+          totalPnL += pnl;
+
+          console.log(
+            `  Position: ALPHA ${pos.isLong ? 'LONG' : 'SHORT'} - P&L: ${pnl >= 0 ? chalk.green('+' + formatUSD(pnl)) : chalk.red(formatUSD(pnl))}`,
+          );
+        }
+
+        console.log(
+          chalk.bold(
+            `\nTotal P&L: ${totalPnL >= 0 ? chalk.green('+' + formatUSD(totalPnL)) : chalk.red(formatUSD(totalPnL))}`,
+          ),
+        );
+
+        // Confirm
+        if (!options.yes) {
+          const confirmed = await confirmAction('Close all positions?');
+          if (!confirmed) {
+            console.log(chalk.yellow('Cancelled'));
+            return;
+          }
+        }
+
+        spinner.start('Closing positions...');
+
+        // Close all positions
+        const results = await Promise.allSettled(
+          activePositions.map((pos, index) => alpha.closePosition(positionIds[index], pos.size)),
+        );
+
+        spinner.stop();
+
+        // Report results
+        const successful = results.filter((r) => r.status === 'fulfilled').length;
+        const failed = results.filter((r) => r.status === 'rejected').length;
+
+        if (successful > 0) {
+          console.log(chalk.green(`\n✓ Successfully closed ${successful} positions`));
+        }
+        if (failed > 0) {
+          console.log(chalk.red(`✗ Failed to close ${failed} positions`));
+        }
+      } catch (error) {
+        spinner.fail('Failed to close positions');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Trading calculator
+  trade
+    .command('calc')
+    .description('Trading calculator for position sizing and risk management')
+    .action(async () => {
+      try {
+        const answers = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'balance',
+            message: 'Account balance (TAO):',
+            validate: (input: string) => {
+              const value = parseFloat(input.trim());
+              if (isNaN(value)) {
+                return 'Please enter a valid number';
+              }
+              if (value <= 0) {
+                return 'Balance must be greater than 0';
+              }
+              return true;
+            },
+            filter: (input: string) => input.trim(),
+          },
+          {
+            type: 'input',
+            name: 'risk',
+            message: 'Risk per trade (%):',
+            default: '2',
+            validate: (input: string) => {
+              const value = parseFloat(input.trim());
+              if (isNaN(value)) {
+                return 'Please enter a valid number';
+              }
+              if (value <= 0 || value > 100) {
+                return 'Risk percentage must be between 0 and 100';
+              }
+              return true;
+            },
+            filter: (input: string) => input.trim(),
+          },
+          {
+            type: 'input',
+            name: 'entry',
+            message: 'Entry price ($):',
+            validate: (input: string) => {
+              const value = parseFloat(input.trim());
+              if (isNaN(value)) {
+                return 'Please enter a valid number';
+              }
+              if (value <= 0) {
+                return 'Entry price must be greater than 0';
+              }
+              return true;
+            },
+            filter: (input: string) => input.trim(),
+          },
+          {
+            type: 'input',
+            name: 'stop',
+            message: 'Stop loss price ($):',
+            validate: (input: string) => {
+              const value = parseFloat(input.trim());
+              if (isNaN(value)) {
+                return 'Please enter a valid number';
+              }
+              if (value <= 0) {
+                return 'Stop loss price must be greater than 0';
+              }
+              return true;
+            },
+            filter: (input: string) => input.trim(),
+          },
+          {
+            type: 'list',
+            name: 'leverage',
+            message: 'Leverage:',
+            choices: [
+              { name: '1x (No leverage)', value: '1' },
+              { name: '2x', value: '2' },
+              { name: '3x (Recommended)', value: '3' },
+              { name: '5x', value: '5' },
+              { name: '10x (High risk)', value: '10' },
+            ],
+            default: '3',
+          },
+        ]);
+
+        // Calculate position sizing
+        const balance = parseFloat(answers.balance);
+        const riskPercent = parseFloat(answers.risk) / 100;
+        const entry = parseFloat(answers.entry);
+        const stop = parseFloat(answers.stop);
+        const leverage = parseFloat(answers.leverage);
+
+        // Validate that entry and stop make sense
+        if (entry === stop) {
+          console.error(chalk.red('❌ Entry price and stop loss cannot be the same'));
+          return;
+        }
+
+        const isLong = stop < entry;
+        const riskPerUnit = Math.abs(entry - stop);
+        const riskAmount = balance * riskPercent;
+        const maxLoss = riskAmount;
+
+        // Validate risk per unit is reasonable
+        const riskPercentFromEntry = (riskPerUnit / entry) * 100;
+        if (riskPercentFromEntry > 50) {
+          console.log(
+            chalk.yellow(
+              `⚠️  Warning: Large price difference (${riskPercentFromEntry.toFixed(1)}% from entry price)`,
+            ),
+          );
+        }
+
+        // Position size calculation
+        const marginRequired = maxLoss / (riskPerUnit / entry);
+        const positionSize = marginRequired * leverage;
+
+        // Validate calculations
+        if (marginRequired <= 0 || positionSize <= 0) {
+          console.error(chalk.red('❌ Invalid calculation result. Please check your inputs.'));
+          return;
+        }
+
+        console.log(chalk.bold('\n📊 Position Calculation:'));
+        console.log(`  Direction: ${isLong ? chalk.green('LONG') : chalk.red('SHORT')}`);
+        console.log(`  Risk Amount: ${riskAmount.toFixed(2)} TAO (${answers.risk}%)`);
+        console.log(`  Margin Required: ${marginRequired.toFixed(2)} TAO`);
+        console.log(`  Position Size: $${positionSize.toFixed(2)}`);
+        console.log(`  Risk per Unit: $${riskPerUnit.toFixed(2)}`);
+
+        // Calculate potential profit with different R multiples
+        console.log(chalk.bold('\n💰 Risk/Reward Scenarios:'));
+
+        const scenarios = [1, 2, 3, 5];
+        scenarios.forEach((r) => {
+          const target = isLong ? entry + riskPerUnit * r : entry - riskPerUnit * r;
+          const profit = riskAmount * r;
+          console.log(`  ${r}R Target: $${target.toFixed(2)} → Profit: ${profit.toFixed(2)} TAO`);
+        });
+
+        // Liquidation info
+        const liquidationDistance = 0.2; // 20% for simplicity
+        const liquidationPrice = isLong
+          ? entry * (1 - liquidationDistance)
+          : entry * (1 + liquidationDistance);
+
+        console.log(chalk.bold('\n⚠️  Risk Management:'));
+        console.log(`  Liquidation Price: ${chalk.red('$' + liquidationPrice.toFixed(2))}`);
+        console.log(`  Max Leverage Safe: ${(1 / (riskPerUnit / entry)).toFixed(1)}x`);
+      } catch (error) {
+        handleError(error, program.opts());
+      }
+    });
+}