@megatao/sdk 1.1.0

package/cli/commands/orders.ts

@@ -0,0 +1,395 @@
+/**
+ * Order Management Commands - Manage limit orders and order book
+ */
+
+import { Command } from 'commander';
+import { parseEther } from 'viem';
+import chalk from 'chalk';
+import ora from 'ora';
+import Table from 'cli-table3';
+import { formatUSD, formatTAO, formatPercentage } from '../../src/utils';
+import { getClient, handleError, getMarketAddress } from '../utils/client';
+import { confirmAction } from '../utils/prompts';
+
+export function orderCommands(program: Command) {
+  const orders = program
+    .command('orders')
+    .alias('order')
+    .description('Manage limit orders and view order book');
+
+  // Place limit order command
+  orders
+    .command('place')
+    .description('Place a limit order')
+    .requiredOption('-a, --asset <asset>', 'Asset to trade (e.g., BITMIND)')
+    .requiredOption('-s, --side <side>', 'Order side: buy or sell')
+    .requiredOption('-z, --size <size>', 'Order size in USD')
+    .requiredOption('-p, --price <price>', 'Limit price in USD')
+    .requiredOption('-l, --leverage <leverage>', 'Leverage (1-10x)')
+    .option('-t, --type <type>', 'Order type: limit, post-only, ioc, fok', 'limit')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (options) => {
+      const spinner = ora('Preparing order...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+        const userAddress = await client.getSignerAddress();
+
+        // Parse inputs
+        const asset = options.asset.toUpperCase();
+        const isBuy = options.side.toLowerCase() === 'buy';
+        const isLong = isBuy; // For perpetuals, buy = long, sell = short
+        const orderSizeUSD = parseEther(options.size);
+        const limitPrice = parseEther(options.price);
+        const leverage = parseEther(options.leverage);
+
+        // Validate leverage
+        if (parseFloat(options.leverage) > 10 || parseFloat(options.leverage) < 1) {
+          spinner.fail('Invalid leverage: must be between 1x and 10x');
+          process.exit(1);
+        }
+
+        // Get market address
+        const marketAddress = getMarketAddress(asset);
+
+        // Calculate required margin
+        const requiredMargin = orderSizeUSD / leverage;
+
+        // Check available balance
+        const available = await alpha.getAvailableMargin(userAddress);
+        if (requiredMargin > available) {
+          spinner.fail('Insufficient available margin');
+          console.log(`  Required: ${formatTAO(requiredMargin)} TAO`);
+          console.log(`  Available: ${formatTAO(available)} TAO`);
+          process.exit(1);
+        }
+
+        spinner.stop();
+
+        // Get current price
+        const currentPrice = await client.oracle.getPrice(marketAddress);
+
+        // Convert USD position size to token amount at limit price
+        // Both orderSizeUSD and limitPrice are already in wei (18 decimals)
+        const positionSize = orderSizeUSD / limitPrice;
+
+        // Display order preview
+        console.log(chalk.bold('\n📋 Limit Order Preview:'));
+        console.log(`  Asset: ${chalk.cyan(asset)}`);
+        console.log(`  Side: ${isBuy ? chalk.green('BUY (LONG)') : chalk.red('SELL (SHORT)')}`);
+        console.log(`  Current Price: ${formatUSD(currentPrice)}`);
+        console.log(`  Limit Price: ${formatUSD(limitPrice)}`);
+        console.log(`  Size: ${formatUSD(orderSizeUSD)} (${formatUSD(positionSize)} tokens)`);
+        console.log(`  Required Margin: ${formatTAO(requiredMargin)} TAO`);
+        console.log(`  Leverage: ${chalk.yellow(options.leverage + 'x')}`);
+        console.log(`  Order Type: ${chalk.blue(options.type.toUpperCase())}`);
+
+        // Show price difference
+        const priceDiff =
+          ((Number(limitPrice) - Number(currentPrice)) / Number(currentPrice)) * 100;
+        console.log(
+          `  Price Difference: ${priceDiff >= 0 ? chalk.green('+' + priceDiff.toFixed(2) + '%') : chalk.red(priceDiff.toFixed(2) + '%')}`,
+        );
+
+        // Calculate and display fees
+        const tradingFee = (orderSizeUSD * 10n) / 10000n; // 0.1% of notional
+        console.log(`  Trading Fee: ${formatUSD(tradingFee)} (0.1%)`);
+
+        // Confirm action
+        if (!options.yes) {
+          const confirmed = await confirmAction('Place this order?');
+          if (!confirmed) {
+            console.log(chalk.yellow('Order cancelled'));
+            return;
+          }
+        }
+
+        spinner.start('Placing limit order...');
+
+        // Map order type to contract enum
+        // Assuming: 0 = LIMIT, 1 = POST_ONLY, 2 = IOC, 3 = FOK
+        let orderTypeEnum = 0;
+        switch (options.type.toLowerCase()) {
+          case 'post-only':
+            orderTypeEnum = 1;
+            break;
+          case 'ioc':
+            orderTypeEnum = 2;
+            break;
+          case 'fok':
+            orderTypeEnum = 3;
+            break;
+        }
+
+        const hash = await alpha.placeLimitOrder(
+          marketAddress,
+          isLong,
+          requiredMargin,
+          leverage,
+          limitPrice,
+          false, // reduceOnly
+        );
+
+        spinner.text = 'Waiting for confirmation...';
+        const publicClient = client.getPublicClient();
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+        spinner.succeed('Limit order placed successfully!');
+        console.log(chalk.gray(`  Transaction: ${receipt.transactionHash}`));
+        console.log(chalk.gray(`  Gas used: ${receipt.gasUsed.toString()}`));
+
+        // Parse order placed event
+        const orderEvent = alpha.parseOrderPlacedEvent(receipt);
+        if (orderEvent) {
+          console.log(chalk.green(`\n✓ Order ID: ${orderEvent.orderId}`));
+          console.log(
+            chalk.gray(
+              `  Status: ${orderEvent.orderType === 0 ? 'Resting in book' : 'Processing'}`,
+            ),
+          );
+        }
+      } catch (error) {
+        spinner.fail('Failed to place order');
+        handleError(error, program.opts());
+      }
+    });
+
+  // List orders command
+  orders
+    .command('list [address]')
+    .alias('ls')
+    .description('List all orders for an address')
+    .option('-a, --asset <asset>', 'Filter by asset')
+    .option('-s, --status <status>', 'Filter by status: open, filled, cancelled')
+    .option('-l, --limit <limit>', 'Number of orders to show', '20')
+    .action(async (address, options) => {
+      const spinner = ora('Loading orders...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+        const userAddress = address || (await client.getSignerAddress());
+
+        if (!userAddress) {
+          spinner.fail('No address provided');
+          return;
+        }
+
+        // Get all user positions which may have associated orders
+        const positionIds = await alpha.getUserPositions(userAddress);
+
+        spinner.stop();
+
+        if (positionIds.length === 0) {
+          console.log(chalk.yellow('\nNo orders found'));
+          return;
+        }
+
+        console.log(chalk.bold(`\n📋 Orders for ${chalk.cyan(userAddress)}:`));
+
+        const table = new Table({
+          head: ['ID', 'Asset', 'Side', 'Size', 'Price', 'Filled', 'Status', 'Created'],
+          colWidths: [8, 8, 8, 15, 12, 12, 10, 12],
+        });
+
+        // Try to get order data from the orderbook client
+        try {
+          // Note: Order listing would require event indexing or state queries
+          console.log(chalk.yellow('\nNote: Order listing functionality is being developed'));
+          console.log(chalk.gray('This feature requires event indexing to show historical orders'));
+          console.log(
+            chalk.gray('For now, you can view your positions using "alpha-futures position list"'),
+          );
+        } catch (error) {
+          console.log(chalk.yellow('\nNote: Order listing requires orderbook integration'));
+          console.log(
+            chalk.gray('This feature will be available once orderbook queries are implemented'),
+          );
+        }
+
+        // Placeholder table data
+        table.push([
+          '1',
+          'BITMIND',
+          chalk.green('BUY'),
+          '$5,000',
+          '$52,000',
+          '0%',
+          chalk.yellow('Open'),
+          '2 min ago',
+        ]);
+
+        console.log(table.toString());
+      } catch (error) {
+        spinner.fail('Failed to load orders');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Cancel order command
+  orders
+    .command('cancel <market> <orderId>')
+    .description('Cancel an open order')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (market, orderId, options) => {
+      const spinner = ora('Loading order...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+
+        spinner.stop();
+
+        console.log(chalk.bold('\n🚫 Cancel Order:'));
+        console.log(`  Market: ${chalk.cyan(market)}`);
+        console.log(`  Order ID: ${chalk.cyan(orderId)}`);
+
+        // Confirm action
+        if (!options.yes) {
+          const confirmed = await confirmAction('Cancel this order?');
+          if (!confirmed) {
+            console.log(chalk.yellow('Cancellation cancelled'));
+            return;
+          }
+        }
+
+        spinner.start('Cancelling order...');
+
+        const hash = await alpha.cancelOrder(market as `0x${string}`, orderId as `0x${string}`);
+
+        spinner.text = 'Waiting for confirmation...';
+        const publicClient = client.getPublicClient();
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+        spinner.succeed('Order cancelled successfully!');
+        console.log(chalk.gray(`  Transaction: ${receipt.transactionHash}`));
+        console.log(chalk.gray(`  Gas used: ${receipt.gasUsed.toString()}`));
+      } catch (error) {
+        spinner.fail('Failed to cancel order');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Cancel all orders command
+  orders
+    .command('cancel-all')
+    .description('Cancel all open orders')
+    .option('-a, --asset <asset>', 'Cancel orders for specific asset only')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (options) => {
+      const spinner = ora('Loading orders...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+        const userAddress = await client.getSignerAddress();
+
+        spinner.stop();
+
+        console.log(chalk.bold('\n🚫 Cancel All Orders:'));
+        if (options.asset) {
+          console.log(`  Asset: ${chalk.cyan(options.asset.toUpperCase())}`);
+        } else {
+          console.log(`  Scope: ${chalk.yellow('All assets')}`);
+        }
+
+        // Confirm action
+        if (!options.yes) {
+          const confirmed = await confirmAction('Cancel all orders?');
+          if (!confirmed) {
+            console.log(chalk.yellow('Cancellation cancelled'));
+            return;
+          }
+        }
+
+        spinner.start('Cancelling all orders...');
+
+        // Try to use the batch cancel function if available
+        try {
+          const marketAddress = options.asset
+            ? getMarketAddress(options.asset.toUpperCase())
+            : (('0x' + '0'.repeat(40)) as `0x${string}`);
+
+          const hash = await alpha.cancelAllOrders(marketAddress);
+
+          spinner.text = 'Waiting for confirmation...';
+          const publicClient = client.getPublicClient();
+          const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+          spinner.succeed('All orders cancelled successfully!');
+          console.log(chalk.gray(`  Transaction: ${receipt.transactionHash}`));
+          console.log(chalk.gray(`  Gas used: ${receipt.gasUsed.toString()}`));
+        } catch (error) {
+          spinner.stop();
+          console.log(
+            chalk.yellow('\nNote: Batch order cancellation not available in current deployment'),
+          );
+          console.log(
+            chalk.gray(
+              'Please cancel orders individually using "alpha-futures orders cancel <orderId>"',
+            ),
+          );
+        }
+      } catch (error) {
+        spinner.fail('Failed to cancel orders');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Order history command
+  orders
+    .command('history [address]')
+    .description('View order history')
+    .option('-a, --asset <asset>', 'Filter by asset')
+    .option('-d, --days <days>', 'Number of days to look back', '7')
+    .option('-l, --limit <limit>', 'Number of orders to show', '50')
+    .action(async (address, options) => {
+      const spinner = ora('Loading order history...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const userAddress = address || (await client.getSignerAddress());
+
+        if (!userAddress) {
+          spinner.fail('No address provided');
+          return;
+        }
+
+        spinner.stop();
+
+        console.log(chalk.bold(`\n📜 Order History: ${chalk.cyan(userAddress)}`));
+        console.log(`  Period: Last ${options.days} days`);
+
+        const table = new Table({
+          head: ['Date', 'Asset', 'Side', 'Size', 'Price', 'Status', 'P&L'],
+          colWidths: [20, 8, 8, 15, 12, 12, 15],
+        });
+
+        // Note: This would require event filtering from the blockchain
+        console.log(chalk.yellow('\nNote: Order history requires event indexing'));
+        console.log(
+          chalk.gray('This feature will be available once event queries are implemented'),
+        );
+        console.log(
+          chalk.gray('For now, you can view your positions using "alpha-futures position list"'),
+        );
+
+        // Placeholder data
+        table.push([
+          '2024-01-15 14:32',
+          'BITMIND',
+          chalk.green('BUY'),
+          '$10,000',
+          '$48,500',
+          chalk.green('Filled'),
+          chalk.green('+$234'),
+        ]);
+
+        console.log(table.toString());
+      } catch (error) {
+        spinner.fail('Failed to load order history');
+        handleError(error, program.opts());
+      }
+    });
+}