@megatao/sdk 1.1.0

package/cli/commands/position.ts

@@ -0,0 +1,1085 @@
+/**
+ * Position Commands - Manage trading positions
+ */
+
+import { Command } from 'commander';
+import { parseEther } from 'viem';
+import chalk from 'chalk';
+import ora from 'ora';
+import Table from 'cli-table3';
+import { AlphaFuturesClient } from '../../src';
+import { formatUSD, formatTAO, formatPercentage } from '../../src/utils';
+import { calculateMaintenanceMargin } from '../../src/utils/calculations';
+import { getClient, handleError, validateMarketAddresses, getMarketAddress } from '../utils/client';
+import type { Address } from 'viem';
+import { confirmAction, selectFromList, validateDirection } from '../utils/prompts';
+import { displayPositionDetails, calculatePnL } from '../utils/display';
+import { detectParadigm, openPositionFromCollateral } from './shared/positionUtils';
+
+/**
+ * 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)}`),
+    );
+  }
+}
+
+/**
+ * Convert position ID to proper bytes16 format (32 hex characters)
+ * @param positionId Raw position ID (could be short like 0x123 or full bytes16)
+ * @returns Properly formatted bytes16 position ID
+ */
+function normalizePositionId(positionId: string): `0x${string}` {
+  // Validate format first
+  validatePositionIdFormat(positionId);
+
+  // Remove 0x prefix if present
+  const hex = positionId.startsWith('0x') ? positionId.slice(2) : positionId;
+
+  // Pad to 32 characters (16 bytes) or truncate if too long
+  const normalizedHex = hex.length > 32 ? hex.slice(0, 32) : hex.padEnd(32, '0');
+
+  return `0x${normalizedHex}` as `0x${string}`;
+}
+
+export function positionCommands(program: Command) {
+  const position = program.command('position').alias('pos').description('Manage trading positions');
+
+  // Open position command
+  position
+    .command('open')
+    .description(
+      `Open a new position
+
+Two modes available:
+
+1. Collateral-First (NEW - Recommended):
+   $ alpha-futures position open --asset BITMIND --direction long --collateral 100 --leverage 3.5
+
+2. Size-First (Legacy - Backward Compatible):
+   $ alpha-futures position open --asset BITMIND --direction long --size 30 --margin 10
+`,
+    )
+    .requiredOption('-a, --asset <asset>', 'Asset to trade (e.g., BITMIND)')
+    .requiredOption('-d, --direction <direction>', 'Direction: long or short')
+    .option('-c, --collateral <amount>', 'Collateral amount in USD (e.g., 100 for $100) [NEW]')
+    .option('-s, --size <size>', 'Position size in USD [LEGACY]')
+    .option('-m, --margin <margin>', 'Margin amount in TAO [LEGACY]')
+    .option(
+      '-l, --leverage <leverage>',
+      'Leverage multiplier (supports decimals, e.g., 3.5)',
+      parseFloat,
+    )
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (options) => {
+      const spinner = ora('Preparing position...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const userAddress = await client.getSignerAddress();
+        const alpha = client.getAlpha();
+
+        // Detect paradigm
+        const paradigm = detectParadigm({
+          size: options.size,
+          margin: options.margin,
+          collateral: options.collateral,
+          leverage: options.leverage,
+        });
+
+        if (paradigm === 'invalid') {
+          spinner.stop();
+          if (options.collateral && (options.size || options.margin)) {
+            console.error(chalk.red('❌ Cannot mix paradigms! Use either:'));
+            console.error(chalk.cyan('  • Collateral-First: --collateral and --leverage'));
+            console.error(chalk.cyan('  • Size-First: --size and --margin'));
+            process.exit(1);
+          } else {
+            console.error(chalk.red('❌ Missing required options! Use either:'));
+            console.error(chalk.cyan('  • Collateral-First: --collateral and --leverage'));
+            console.error(chalk.cyan('  • Size-First: --size and --margin (or --leverage)'));
+            process.exit(1);
+          }
+        }
+
+        // Parse common inputs
+        const asset = options.asset.toUpperCase();
+
+        // Validate direction with strict checking
+        let direction: 'long' | 'short';
+        try {
+          direction = validateDirection(options.direction);
+        } catch (error: any) {
+          spinner.fail(error.message);
+          return;
+        }
+
+        const isLong = direction === 'long';
+
+        // Get market data
+        const marketAddress = getMarketAddress(asset);
+        const currentPrice = await client.oracle.getPrice(marketAddress);
+
+        spinner.stop();
+
+        // Execute based on paradigm
+        if (paradigm === 'collateral-first') {
+          // NEW PARADIGM
+          console.log(chalk.bold('📊 Using Collateral-First mode'));
+
+          const collateral = parseFloat(options.collateral);
+          const leverage = options.leverage || 3; // Default 3x
+
+          // Validate leverage precision (0.1x increments)
+          const leverageDecimal = leverage % 0.1;
+          if (leverageDecimal > 0.001 && leverageDecimal < 0.099) {
+            // Allow some floating point error
+            console.error(
+              chalk.red('❌ Leverage must be in 0.1x increments (e.g., 1.5, 2.3, 10.0)'),
+            );
+            process.exit(1);
+          }
+
+          // Validate leverage range
+          if (leverage < 1 || leverage > 30) {
+            console.error(chalk.red('❌ Leverage must be between 1x and 30x'));
+            process.exit(1);
+          }
+
+          // Check available balance
+          const collateralWei = parseEther(collateral.toString());
+          const available = await alpha.getAvailableMargin(userAddress);
+          if (collateralWei > available) {
+            console.error(chalk.red('❌ Insufficient available balance'));
+            console.log(`  Required: ${formatTAO(collateralWei)} TAO`);
+            console.log(`  Available: ${formatTAO(available)} TAO`);
+            process.exit(1);
+          }
+
+          // Display position preview
+          console.log(chalk.bold('\n📊 Position Preview:'));
+          console.log(`  Asset: ${chalk.cyan(asset)}`);
+          console.log(`  Direction: ${isLong ? chalk.green('LONG ↗') : chalk.red('SHORT ↘')}`);
+          console.log(`  Current Price: ${formatUSD(currentPrice)}`);
+          console.log(`  Collateral: $${collateral}`);
+          console.log(`  Leverage: ${chalk.yellow(leverage.toFixed(1) + 'x')}`);
+          console.log(`  Position Value: $${(collateral * leverage).toFixed(2)}`);
+
+          // Calculate and display fees
+          const positionValueUSD = parseEther((collateral * leverage).toString());
+          const tradingFee = (positionValueUSD * 10n) / 10000n; // 0.1%
+          console.log(`  Trading Fee: ${formatUSD(tradingFee)} (0.1%)`);
+
+          // Show liquidation price estimate
+          const liquidationPrice = isLong
+            ? (currentPrice * (100n - 2000n)) / 100n // 20% below for longs
+            : (currentPrice * (100n + 2000n)) / 100n; // 20% above for shorts
+          console.log(`  Est. Liquidation Price: ${chalk.red(formatUSD(liquidationPrice))}`);
+
+          // Confirm action
+          if (!options.yes) {
+            const confirmed = await confirmAction('Open this position?');
+            if (!confirmed) {
+              console.log(chalk.yellow('Position opening cancelled'));
+              return;
+            }
+          }
+
+          spinner.start('Opening position...');
+
+          const hash = await openPositionFromCollateral(
+            alpha,
+            marketAddress,
+            isLong,
+            collateral,
+            leverage,
+            currentPrice,
+          );
+
+          spinner.text = 'Waiting for confirmation...';
+          const publicClient = client.getPublicClient();
+          const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+          spinner.succeed('Position opened successfully!');
+          console.log(chalk.gray(`  Transaction: ${receipt.transactionHash}`));
+          console.log(chalk.gray(`  Gas used: ${receipt.gasUsed.toString()}`));
+
+          // Parse position opened event
+          const positionEvent = alpha.parsePositionOpenedEvent(receipt);
+          if (positionEvent) {
+            console.log(chalk.green(`\n✓ Position ID: ${positionEvent.positionId}`));
+          }
+        } else {
+          // LEGACY PARADIGM
+          console.log(chalk.bold('📊 Using Size-First mode (legacy)'));
+
+          const positionSizeUSD = parseEther(options.size); // USD amount
+          const marginAmount = parseEther(options.margin);
+
+          // Calculate leverage
+          const leverage = options.leverage
+            ? parseFloat(options.leverage)
+            : Number(positionSizeUSD) / Number(marginAmount);
+
+          // Validate leverage
+          if (leverage > 30 || leverage < 1) {
+            console.error(chalk.red('❌ Invalid leverage: must be between 1x and 30x'));
+            process.exit(1);
+          }
+
+          // Check available balance
+          const available = await alpha.getAvailableMargin(userAddress);
+          if (marginAmount > available) {
+            console.error(chalk.red('❌ Insufficient available balance'));
+            console.log(`  Required: ${formatTAO(marginAmount)} TAO`);
+            console.log(`  Available: ${formatTAO(available)} TAO`);
+            process.exit(1);
+          }
+
+          // Convert USD position size to token amount
+          const positionSize = (positionSizeUSD * parseEther('1')) / currentPrice;
+
+          // Display position preview
+          console.log(chalk.bold('\n📊 Position Preview:'));
+          console.log(`  Asset: ${chalk.cyan(asset)}`);
+          console.log(`  Direction: ${isLong ? chalk.green('LONG ↗') : chalk.red('SHORT ↘')}`);
+          console.log(`  Current Price: ${formatUSD(currentPrice)}`);
+          console.log(
+            `  Position Size: ${formatUSD(positionSizeUSD)} (${formatUSD(positionSize)} tokens)`,
+          );
+          console.log(`  Margin: ${formatTAO(marginAmount)} TAO`);
+          console.log(`  Leverage: ${chalk.yellow(leverage.toFixed(2) + 'x')}`);
+
+          // Calculate and display fees
+          const tradingFee = (positionSizeUSD * 10n) / 10000n; // 0.1% of USD notional
+          console.log(`  Trading Fee: ${formatUSD(tradingFee)} (0.1%)`);
+
+          // Show liquidation price
+          const liquidationPrice = isLong
+            ? (currentPrice * (100n - 2000n)) / 100n // 20% below for longs
+            : (currentPrice * (100n + 2000n)) / 100n; // 20% above for shorts
+          console.log(`  Liquidation Price: ${chalk.red(formatUSD(liquidationPrice))}`);
+
+          // Confirm action
+          if (!options.yes) {
+            const confirmed = await confirmAction('Open this position?');
+            if (!confirmed) {
+              console.log(chalk.yellow('Position opening cancelled'));
+              return;
+            }
+          }
+
+          spinner.start('Opening position...');
+          const leverageBigInt = parseEther(leverage.toString()); // Convert to PRECISION (1e18)
+          const maxSlippage = 100n; // 1% max slippage
+
+          const hash = await alpha.openMarketPosition(
+            marketAddress,
+            isLong,
+            marginAmount,
+            leverageBigInt,
+            maxSlippage,
+          );
+
+          spinner.text = 'Waiting for confirmation...';
+          const publicClient = client.getPublicClient();
+          const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+          spinner.succeed('Position opened successfully!');
+          console.log(chalk.gray(`  Transaction: ${receipt.transactionHash}`));
+          console.log(chalk.gray(`  Gas used: ${receipt.gasUsed.toString()}`));
+
+          // Parse position opened event
+          const positionEvent = alpha.parsePositionOpenedEvent(receipt);
+          if (positionEvent) {
+            console.log(chalk.green(`\n✓ Position ID: ${positionEvent.positionId}`));
+          }
+        }
+      } catch (error) {
+        spinner.fail('Failed to open position');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Close position command
+  position
+    .command('close <positionId>')
+    .description('Close an existing position')
+    .option('-s, --size <size>', 'Size to close (partial close)')
+    .option('-p, --percent <percent>', 'Percentage to close (e.g., 50 for 50%)')
+    .option('-y, --yes', 'Skip confirmation')
+    .addHelpText(
+      'after',
+      `
+Examples:
+  $ alpha-futures position close 0x00000000000000000000000000000001
+  $ alpha-futures position close 0x12345000000000000000000000000000 --percent 50
+  $ alpha-futures position close 0xabcd1234000000000000000000000000 --size 500 --yes
+
+Note: Position ID must be in bytes16 format (32 hex characters after 0x).
+Use "alpha-futures position find" to get your position IDs.`,
+    )
+    .action(async (positionId, options) => {
+      const spinner = ora('Loading position...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+
+        // Get position details - position ID needs to be converted to bytes16 format
+        const normalizedPositionId = normalizePositionId(positionId);
+        const position = await alpha.getPosition(normalizedPositionId);
+
+        // Note: Monolith positions don't have isActive field, we check size > 0
+        if (position.notionalValue === 0n) {
+          spinner.fail('Position is not active');
+          return;
+        }
+
+        // Calculate close size
+        let closeSize: bigint;
+        if (options.percent) {
+          const percent = BigInt(Math.floor(parseFloat(options.percent) * 100));
+          closeSize = (position.notionalValue * percent) / 10000n;
+        } else if (options.size) {
+          closeSize = parseEther(options.size);
+        } else {
+          // Close entire position - pass 0 to smart contract for full close
+          closeSize = 0n;
+        }
+
+        // Validate close size (only if not closing full position)
+        if (closeSize > 0n && closeSize > position.notionalValue) {
+          spinner.fail('Close size exceeds position size');
+          return;
+        }
+
+        spinner.stop();
+
+        // Get current price - derive market address from position or use environment lookup
+        // For now, using BITMIND as default since most tests use BITMIND
+        const marketAddress = getMarketAddress('BITMIND'); // Default to BITMIND for testing
+        const currentPrice = await client.oracle.getPrice(marketAddress);
+        // Use position.notionalValue for P&L calculation when closing full position
+        const sizeForPnl = closeSize === 0n ? position.notionalValue : closeSize;
+        const pnl = calculatePnL(position, currentPrice, sizeForPnl);
+
+        // Display close preview
+        console.log(chalk.bold('\n🔒 Position Close Preview:'));
+        displayPositionDetails(position, currentPrice);
+
+        console.log(chalk.bold('\nClose Details:'));
+        const displaySize = closeSize === 0n ? position.notionalValue : closeSize;
+        const closePercent =
+          position.notionalValue > 0n
+            ? ((Number(displaySize) * 100) / Number(position.notionalValue)).toFixed(1)
+            : '100.0';
+        console.log(`  Size to Close: ${formatUSD(displaySize)} (${closePercent}%)`);
+        console.log(
+          `  P&L: ${pnl >= 0 ? chalk.green('+' + formatUSD(pnl)) : chalk.red(formatUSD(pnl))}`,
+        );
+
+        // Confirm action
+        if (!options.yes) {
+          const confirmed = await confirmAction('Close this position?');
+          if (!confirmed) {
+            console.log(chalk.yellow('Position close cancelled'));
+            return;
+          }
+        }
+
+        spinner.start('Closing position...');
+        const hash = await alpha.closePosition(normalizedPositionId, closeSize);
+
+        spinner.text = 'Waiting for confirmation...';
+        const publicClient = client.getPublicClient();
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+        spinner.succeed('Position closed successfully!');
+        console.log(chalk.gray(`  Transaction: ${receipt.transactionHash}`));
+        console.log(chalk.gray(`  Gas used: ${receipt.gasUsed.toString()}`));
+
+        // Parse position closed event
+        const positionEvent = alpha.parsePositionClosedEvent(receipt);
+        if (positionEvent) {
+          const realizedPnL = positionEvent.pnl;
+          console.log(
+            chalk.bold(
+              `\n💰 Realized P&L: ${realizedPnL >= 0 ? chalk.green('+' + formatTAO(realizedPnL) + ' TAO') : chalk.red(formatTAO(realizedPnL) + ' TAO')}`,
+            ),
+          );
+          console.log(
+            chalk.cyan(`💳 P&L ${realizedPnL >= 0 ? 'credited to' : 'debited from'} TAO wallet`),
+          );
+
+          // Show updated TAO wallet balance
+          try {
+            const userAddress = await client.getSignerAddress();
+            const publicClient = client.getPublicClient();
+            const taoTokenAddress = client.getCollateralTokenAddress();
+            if (taoTokenAddress) {
+              const updatedTaoBalance = (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.gray(`💳 Updated TAO wallet balance: ${formatTAO(updatedTaoBalance)} TAO`),
+              );
+            }
+          } catch (error) {
+            // Ignore error fetching updated balance
+          }
+        }
+      } catch (error) {
+        spinner.fail('Failed to close position');
+        handleError(error, program.opts());
+      }
+    });
+
+  // List positions command
+  position
+    .command('list [address]')
+    .alias('ls')
+    .description('List all positions')
+    .option('-a, --active', 'Show only active positions')
+    .option('-c, --closed', 'Show only closed positions')
+    .option('-s, --sort <field>', 'Sort by: size, pnl, margin, age', 'size')
+    .action(async (address, options) => {
+      const spinner = ora('Loading positions...').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 position IDs
+        const positionIds = await alpha.getUserPositions(userAddress);
+
+        if (positionIds.length === 0) {
+          spinner.stop();
+          console.log(chalk.yellow('\nNo positions found'));
+          return;
+        }
+
+        // Fetch position details
+        const positions = await Promise.all(positionIds.map((id) => alpha.getPosition(id)));
+
+        // Filter positions - alpha positions use notionalValue > 0 to indicate active
+        let filteredPositions = positions;
+        if (options.active) {
+          filteredPositions = positions.filter((p) => p.notionalValue > 0n);
+        } else if (options.closed) {
+          filteredPositions = positions.filter((p) => p.notionalValue === 0n);
+        }
+
+        spinner.stop();
+
+        if (filteredPositions.length === 0) {
+          console.log(chalk.yellow('\nNo matching positions found'));
+          return;
+        }
+
+        // Get current prices for P&L calculation
+        // Use BITMIND as default market for testing
+        const marketAddress = getMarketAddress('BITMIND'); // Default to BITMIND for testing
+        const currentPrice = await client.oracle.getPrice(marketAddress);
+        const priceMap = new Map<string, bigint>();
+        priceMap.set('ALPHA', currentPrice);
+
+        // Create positions table
+        console.log(chalk.bold(`\n📊 Positions for ${chalk.cyan(userAddress)}:`));
+
+        const table = new Table({
+          head: ['ID', 'Asset', 'Direction', 'Size', 'Margin', 'Entry', 'Current', 'P&L', 'Status'],
+          colWidths: [6, 8, 10, 15, 15, 12, 12, 15, 8],
+        });
+
+        // Sort positions
+        const sortedPositions = [...filteredPositions].sort((a, b) => {
+          switch (options.sort) {
+            case 'size':
+              return Number(b.notionalValue - a.notionalValue);
+            case 'margin':
+              return Number(b.margin - a.margin);
+            case 'age':
+              return Number(b.lastUpdated - a.lastUpdated);
+            case 'pnl':
+              if (a.notionalValue === 0n || b.notionalValue === 0n) return 0;
+              const pnlA = calculatePnL(a, currentPrice, a.notionalValue);
+              const pnlB = calculatePnL(b, currentPrice, b.notionalValue);
+              return Number(pnlB - pnlA);
+            default:
+              return 0;
+          }
+        });
+
+        let totalPnL = 0n;
+        let totalMargin = 0n;
+
+        for (const pos of sortedPositions) {
+          const isActive = pos.notionalValue > 0n;
+          const pnl = isActive ? calculatePnL(pos, currentPrice, pos.notionalValue) : 0n;
+
+          if (isActive) {
+            totalPnL += pnl;
+            totalMargin += pos.margin;
+          }
+
+          const directionIcon = pos.isLong ? chalk.green('LONG ↗') : chalk.red('SHORT ↘');
+          const pnlDisplay = !isActive
+            ? '-'
+            : pnl >= 0
+              ? chalk.green('+' + formatUSD(pnl))
+              : chalk.red(formatUSD(pnl));
+          const statusDisplay = isActive ? chalk.green('Active') : chalk.gray('Closed');
+
+          // Calculate USD value of position: notionalValue represents the position's notional value
+          const positionValueUSD = pos.notionalValue;
+
+          table.push([
+            positionIds.indexOf(positionIds.find((id) => id === positionIds[0]) || positionIds[0]) +
+              1, // Simple index for now
+            'ALPHA', // Placeholder asset
+            directionIcon,
+            formatUSD(positionValueUSD),
+            formatTAO(pos.margin),
+            formatUSD(pos.entryPrice),
+            isActive ? formatUSD(currentPrice) : '-',
+            pnlDisplay,
+            statusDisplay,
+          ]);
+        }
+
+        console.log(table.toString());
+
+        // Show summary for active positions
+        const activePositions = filteredPositions.filter((p) => p.notionalValue > 0n);
+        if (activePositions.length > 0) {
+          console.log(chalk.bold('\nSummary:'));
+          console.log(`  Active Positions: ${activePositions.length}`);
+          console.log(`  Total Margin: ${formatTAO(totalMargin)} TAO`);
+          console.log(
+            `  Total P&L: ${totalPnL >= 0 ? chalk.green('+' + formatUSD(totalPnL)) : chalk.red(formatUSD(totalPnL))}`,
+          );
+        }
+      } catch (error) {
+        spinner.fail('Failed to load positions');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Position info command
+  position
+    .command('info <positionId>')
+    .description('Get detailed information about a position')
+    .option('-w, --watch', 'Watch position in real-time')
+    .addHelpText(
+      'after',
+      `
+Examples:
+  $ alpha-futures position info 0x00000000000000000000000000000001
+  $ alpha-futures position info 0x12345000000000000000000000000000 --watch
+
+Note: Position ID must be in bytes16 format (32 hex characters after 0x).
+Use "alpha-futures position find" to get your position IDs.`,
+    )
+    .action(async (positionId, options) => {
+      const spinner = ora('Loading position...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+
+        const displayInfo = async () => {
+          const normalizedPositionId = normalizePositionId(positionId);
+          const position = await alpha.getPosition(normalizedPositionId);
+          // Use BITMIND as default market for testing
+          const marketAddress = getMarketAddress('BITMIND'); // Default to BITMIND for testing
+          const currentPrice = await client.oracle.getPrice(marketAddress);
+
+          if (!options.watch) spinner.stop();
+
+          console.clear();
+          console.log(chalk.bold(`\n📊 Position #${positionId} Details:`));
+
+          displayPositionDetails(position, currentPrice);
+
+          if (position.notionalValue > 0n) {
+            // Calculate additional metrics
+            const pnl = calculatePnL(position, currentPrice, position.notionalValue);
+            const pnlPercent = (Number(pnl) * 100) / Number(position.margin);
+            const marginRatio = await alpha.getMarginRatio(normalizedPositionId);
+
+            console.log(chalk.bold('\n💰 Financial Metrics:'));
+            console.log(
+              `  Unrealized P&L: ${pnl >= 0 ? chalk.green('+' + formatUSD(pnl)) : chalk.red(formatUSD(pnl))}`,
+            );
+            console.log(
+              `  P&L %: ${pnlPercent >= 0 ? chalk.green('+' + pnlPercent.toFixed(2) + '%') : chalk.red(pnlPercent.toFixed(2) + '%')}`,
+            );
+            console.log(`  Margin Ratio: ${formatPercentage(marginRatio)}`);
+
+            // Use liquidation price from position structure
+            const liquidationPrice = position.liquidationPrice;
+
+            const distanceToLiquidation = position.isLong
+              ? ((Number(currentPrice) - Number(liquidationPrice)) / Number(currentPrice)) * 100
+              : ((Number(liquidationPrice) - Number(currentPrice)) / Number(currentPrice)) * 100;
+
+            console.log(`  Liquidation Price: ${chalk.red(formatUSD(liquidationPrice))}`);
+            console.log(`  Distance to Liquidation: ${distanceToLiquidation.toFixed(2)}%`);
+
+            // Show funding rate impact - use BITMIND market address
+            const fundingRate = await alpha.getFundingRate(marketAddress);
+            const fundingDirection = position.isLong
+              ? fundingRate > 0n
+                ? 'Pay'
+                : 'Receive'
+              : fundingRate > 0n
+                ? 'Receive'
+                : 'Pay';
+
+            console.log(chalk.bold('\n📈 Funding Rate:'));
+            console.log(`  Current Rate: ${formatPercentage(fundingRate)} per 8h`);
+            console.log(`  Direction: ${fundingDirection}`);
+          }
+
+          if (program.opts().json) {
+            console.log(
+              '\n' +
+                JSON.stringify(
+                  {
+                    position: {
+                      size: position.notionalValue.toString(),
+                      margin: position.margin.toString(),
+                      entryPrice: position.entryPrice.toString(),
+                      isLong: position.isLong,
+                      lastUpdated: position.lastUpdated.toString(),
+                      fundingIndex: position.fundingIndex.toString(),
+                      leverage: position.leverage.toString(),
+                      liquidationPrice: position.liquidationPrice.toString(),
+                    },
+                    currentPrice: currentPrice.toString(),
+                  },
+                  null,
+                  2,
+                ),
+            );
+          }
+        };
+
+        await displayInfo();
+
+        if (options.watch) {
+          // Update every 5 seconds
+          setInterval(displayInfo, 5000);
+
+          // Handle exit
+          process.on('SIGINT', () => {
+            console.log(chalk.yellow('\n\nStopped watching'));
+            process.exit(0);
+          });
+        }
+      } catch (error) {
+        spinner.fail('Failed to load position');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Position ID lookup command
+  position
+    .command('id <trader> [asset]')
+    .description('Get position ID for a trader and asset')
+    .action(async (trader, asset) => {
+      const spinner = ora('Looking up position ID...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+
+        const targetAsset = asset || 'BITMIND';
+        const marketAddress = getMarketAddress(targetAsset);
+
+        // Check if position exists
+        const hasPosition = await alpha.hasPosition(trader as Address, marketAddress);
+
+        if (!hasPosition) {
+          spinner.stop();
+          console.log(chalk.yellow(`\nNo active position found`));
+          console.log(`  Trader: ${chalk.cyan(trader)}`);
+          console.log(`  Asset: ${chalk.cyan(targetAsset.toUpperCase())}`);
+          return;
+        }
+
+        // Get position ID
+        const positionId = await alpha.getPositionId(trader as Address, marketAddress);
+
+        spinner.stop();
+
+        console.log(chalk.bold('\n🔍 Position ID Lookup:'));
+        console.log(`  Trader: ${chalk.cyan(trader)}`);
+        console.log(`  Asset: ${chalk.cyan(targetAsset.toUpperCase())}`);
+        console.log(`  Market: ${chalk.gray(marketAddress)}`);
+        console.log(`  Position ID: ${chalk.green(positionId)}`);
+
+        // Get basic position info
+        try {
+          const position = await alpha.getPosition(positionId);
+          console.log(chalk.bold('\n📊 Quick Info:'));
+          console.log(`  Size: ${formatUSD(position.notionalValue)}`);
+          console.log(
+            `  Direction: ${position.isLong ? chalk.green('LONG ↗') : chalk.red('SHORT ↘')}`,
+          );
+          console.log(`  Margin: ${formatTAO(position.margin)} TAO`);
+          console.log(`  Entry Price: ${formatUSD(position.entryPrice)}`);
+
+          console.log(
+            chalk.gray(
+              '\n💡 Use "alpha-futures position info ' + positionId + '" for detailed information',
+            ),
+          );
+        } catch (error) {
+          console.log(chalk.yellow('\n⚠️  Could not fetch position details'));
+        }
+      } catch (error) {
+        spinner.fail('Failed to lookup position ID');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Find positions command
+  position
+    .command('find [trader]')
+    .description('Find all position IDs for a trader')
+    .option('-a, --asset <asset>', 'Filter by specific asset')
+    .action(async (trader, options) => {
+      const spinner = ora('Finding positions...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+        const walletClient = client.getWalletClient();
+
+        // Use provided trader or wallet address
+        const userAddress = trader || walletClient?.account?.address;
+
+        if (!userAddress) {
+          spinner.fail('No trader address provided and no wallet client available');
+          return;
+        }
+
+        if (options.asset) {
+          // Find position for specific asset
+          const marketAddress = getMarketAddress(options.asset);
+
+          const hasPosition = await alpha.hasPosition(userAddress as Address, marketAddress);
+
+          if (hasPosition) {
+            const positionId = await alpha.getPositionId(userAddress as Address, marketAddress);
+            const position = await alpha.getPosition(positionId);
+
+            spinner.stop();
+
+            console.log(
+              chalk.bold(`\n🎯 Position Found: ${chalk.cyan(options.asset.toUpperCase())}`),
+            );
+            console.log(`  Trader: ${chalk.cyan(userAddress)}`);
+            console.log(`  Position ID: ${chalk.green(positionId)}`);
+            console.log(`  Size: ${formatUSD(position.notionalValue)}`);
+            console.log(
+              `  Direction: ${position.isLong ? chalk.green('LONG ↗') : chalk.red('SHORT ↘')}`,
+            );
+            console.log(
+              `  Status: ${position.notionalValue > 0n ? chalk.green('Active') : chalk.gray('Closed')}`,
+            );
+          } else {
+            spinner.stop();
+            console.log(chalk.yellow(`\nNo position found for ${options.asset.toUpperCase()}`));
+          }
+        } else {
+          // Find all positions for trader
+          const positionIds = await alpha.getUserPositions(userAddress as Address);
+
+          if (positionIds.length === 0) {
+            spinner.stop();
+            console.log(chalk.yellow(`\nNo positions found for trader: ${userAddress}`));
+            return;
+          }
+
+          spinner.stop();
+
+          console.log(chalk.bold(`\n📋 All Positions: ${chalk.cyan(userAddress)}`));
+          console.log(`  Total Positions: ${positionIds.length}`);
+
+          const table = new Table({
+            head: ['#', 'Position ID', 'Size', 'Direction', 'Status'],
+            colWidths: [5, 42, 15, 12, 10],
+          });
+
+          for (let i = 0; i < positionIds.length; i++) {
+            try {
+              const position = await alpha.getPosition(positionIds[i]);
+              const status =
+                position.notionalValue > 0n ? chalk.green('Active') : chalk.gray('Closed');
+              const direction = position.isLong ? chalk.green('LONG') : chalk.red('SHORT');
+
+              table.push([
+                i + 1,
+                positionIds[i],
+                formatUSD(position.notionalValue),
+                direction,
+                status,
+              ]);
+            } catch (error) {
+              table.push([
+                i + 1,
+                positionIds[i],
+                chalk.red('Error'),
+                chalk.red('Error'),
+                chalk.red('Error'),
+              ]);
+            }
+          }
+
+          console.log(table.toString());
+          console.log(
+            chalk.gray(
+              '\n💡 Use "alpha-futures position info <positionId>" for detailed information',
+            ),
+          );
+        }
+      } catch (error) {
+        spinner.fail('Failed to find positions');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Modify position command
+  position
+    .command('modify <positionId>')
+    .description('Modify an existing position (add/remove margin)')
+    .option('-a, --add <amount>', 'Add margin to position')
+    .option('-r, --remove <amount>', 'Remove margin from position')
+    .option('-y, --yes', 'Skip confirmation')
+    .addHelpText(
+      'after',
+      `
+Examples:
+  $ alpha-futures position modify 0x00000000000000000000000000000001 --add 100
+  $ alpha-futures position modify 0x12345000000000000000000000000000 --remove 50 --yes
+
+Note: Position ID must be in bytes16 format (32 hex characters after 0x).
+Use "alpha-futures position find" to get your position IDs.`,
+    )
+    .action(async (positionId, options) => {
+      if (!options.add && !options.remove) {
+        console.error(chalk.red('❌ Must specify either --add or --remove'));
+        return;
+      }
+
+      const spinner = ora('Loading position...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+        const normalizedPositionId = normalizePositionId(positionId);
+        const position = await alpha.getPosition(normalizedPositionId);
+
+        if (position.notionalValue === 0n) {
+          spinner.fail('Position is not active');
+          return;
+        }
+
+        spinner.stop();
+
+        // Use BITMIND as default market for testing
+        const marketAddress = getMarketAddress('BITMIND'); // Default to BITMIND for testing
+        const currentPrice = await client.oracle.getPrice(marketAddress);
+
+        console.log(chalk.bold('\n📊 Current Position:'));
+        displayPositionDetails(position, currentPrice);
+
+        if (options.add) {
+          const addAmount = parseEther(options.add);
+
+          // Check available balance first
+          const userAddress = await client.getSignerAddress();
+          const availableMargin = await alpha.getAvailableMargin(userAddress);
+          if (addAmount > availableMargin) {
+            console.error(chalk.red('❌ Insufficient available margin'));
+            console.log(`  Required: ${formatTAO(addAmount)} TAO`);
+            console.log(`  Available: ${formatTAO(availableMargin)} TAO`);
+            console.log(
+              chalk.yellow('💡 Use "alpha-futures account deposit <amount>" to deposit more TAO'),
+            );
+            return;
+          }
+
+          const newMargin = position.margin + addAmount;
+          const newLeverage =
+            position.notionalValue > 0n ? Number(position.notionalValue) / Number(newMargin) : 0;
+
+          console.log(chalk.bold('\n➕ Add Margin:'));
+          console.log(`  Amount to Add: ${formatTAO(addAmount)} TAO`);
+          console.log(`  New Margin: ${formatTAO(newMargin)} TAO`);
+          console.log(`  New Leverage: ${newLeverage.toFixed(2)}x`);
+
+          if (!options.yes && !(await confirmAction('Add margin to position?'))) {
+            console.log(chalk.yellow('Cancelled'));
+            return;
+          }
+
+          spinner.start('Adding margin...');
+          try {
+            const hash = await alpha.addMargin(normalizedPositionId, addAmount);
+            spinner.text = 'Waiting for confirmation...';
+            const publicClient = client.getPublicClient();
+            const receipt = await publicClient.waitForTransactionReceipt({ hash });
+            spinner.succeed('Margin added successfully!');
+            console.log(chalk.gray(`  Transaction: ${receipt.transactionHash}`));
+            console.log(chalk.gray(`  Gas used: ${receipt.gasUsed.toString()}`));
+          } catch (error: any) {
+            spinner.fail('Failed to add margin');
+            if (error.message?.includes('insufficient funds')) {
+              console.error(chalk.red('\n❌ Insufficient TAO balance'));
+              console.log(
+                chalk.yellow(
+                  '💡 Make sure you have deposited enough TAO using "alpha-futures account deposit <amount>"',
+                ),
+              );
+            } else if (error.message?.includes('revert')) {
+              console.error(chalk.red('\n❌ Contract reverted the transaction'));
+              console.log(chalk.gray('Reason: ' + (error.reason || error.message)));
+            } else {
+              console.error(chalk.red('\n❌ Error: ' + error.message));
+            }
+            return;
+          }
+        } else if (options.remove) {
+          const removeAmount = parseEther(options.remove);
+
+          // Validate remove amount
+          if (removeAmount > position.margin) {
+            console.error(chalk.red('❌ Cannot remove more than current margin'));
+            console.log(`  Current margin: ${formatTAO(position.margin)} TAO`);
+            console.log(`  Requested removal: ${formatTAO(removeAmount)} TAO`);
+            return;
+          }
+
+          const newMargin = position.margin - removeAmount;
+
+          // Simple maintenance margin check: ensure position doesn't exceed max leverage (30x)
+          // Minimum margin = position size / max leverage
+          const maxLeverage = 30n;
+          const minMarginForMaxLeverage = position.notionalValue / maxLeverage;
+
+          // Also ensure we don't go below 20% margin ratio (maintenance margin)
+          // For a position, minimum margin ≈ position value * 0.2 / current_price
+          // Simplified: position.notionalValue already includes leverage, so min = position.notionalValue / 5 (20%)
+          const maintenanceMarginSimple = position.notionalValue / 5n; // 20% maintenance
+          const minMargin =
+            minMarginForMaxLeverage > maintenanceMarginSimple
+              ? minMarginForMaxLeverage
+              : maintenanceMarginSimple;
+
+          if (newMargin < minMargin) {
+            console.error(chalk.red('❌ Cannot remove that much margin'));
+            console.log(`  Current margin: ${formatTAO(position.margin)} TAO`);
+            console.log(`  Requested removal: ${formatTAO(removeAmount)} TAO`);
+            console.log(`  New margin would be: ${formatTAO(newMargin)} TAO`);
+            console.log(`  Minimum required margin: ${formatTAO(minMargin)} TAO`);
+            console.log(`  Maximum removable: ${formatTAO(position.margin - minMargin)} TAO`);
+            console.log(chalk.gray('  (Based on 30x max leverage and 20% maintenance margin)'));
+            return;
+          }
+
+          const newLeverage =
+            position.notionalValue > 0n ? Number(position.notionalValue) / Number(newMargin) : 0;
+
+          // The margin validation above already handles max leverage, so this is just for display
+
+          console.log(chalk.bold('\n➖ Remove Margin:'));
+          console.log(`  Amount to Remove: ${formatTAO(removeAmount)} TAO`);
+          console.log(`  New Margin: ${formatTAO(newMargin)} TAO`);
+          console.log(`  New Leverage: ${newLeverage.toFixed(2)}x`);
+          console.log(`  Required Margin: ${formatTAO(minMargin)} TAO`);
+
+          if (!options.yes && !(await confirmAction('Remove margin from position?'))) {
+            console.log(chalk.yellow('Cancelled'));
+            return;
+          }
+
+          spinner.start('Removing margin...');
+          try {
+            const hash = await alpha.removeMargin(normalizedPositionId, removeAmount);
+            spinner.text = 'Waiting for confirmation...';
+            const publicClient = client.getPublicClient();
+            const receipt = await publicClient.waitForTransactionReceipt({ hash });
+            spinner.succeed('Margin removed successfully!');
+            console.log(chalk.gray(`  Transaction: ${receipt.transactionHash}`));
+            console.log(chalk.gray(`  Gas used: ${receipt.gasUsed.toString()}`));
+          } catch (error: any) {
+            spinner.fail('Failed to remove margin');
+            if (error.message?.includes('insufficient margin')) {
+              console.error(chalk.red('\n❌ Insufficient margin for removal'));
+              console.log(
+                chalk.yellow(
+                  '💡 The contract rejected the removal. Position may be too close to liquidation.',
+                ),
+              );
+            } else if (error.message?.includes('revert')) {
+              console.error(chalk.red('\n❌ Contract reverted the transaction'));
+              console.log(chalk.gray('Reason: ' + (error.reason || error.message)));
+            } else {
+              console.error(chalk.red('\n❌ Error: ' + error.message));
+            }
+            return;
+          }
+        }
+      } catch (error) {
+        spinner.fail('Failed to modify position');
+        handleError(error, program.opts());
+      }
+    });
+}