@megatao/sdk 1.1.0

package/cli/commands/shared/positionUtils.ts

@@ -0,0 +1,239 @@
+/**
+ * Shared Position Utilities
+ * Common functions for opening positions used across multiple commands
+ */
+
+import { parseEther, formatEther } from 'viem';
+import type { Address, Hash } from 'viem';
+import chalk from 'chalk';
+import ora from 'ora';
+import { formatUSD, formatTAO, formatPercentage } from '../../../src/utils';
+import { getClient, getMarketAddress } from '../../utils/client';
+import { confirmAction } from '../../utils/prompts';
+import {
+  calculatePositionSizeFromCollateral,
+  calculateCollateralFromSize,
+  leverageToWei,
+} from '../../../src/utils/positionCalculations';
+import type { AlphaViem } from '../../../src';
+
+export interface PositionOptions {
+  asset: string;
+  direction: 'long' | 'short';
+  size: string; // USD size
+  leverage?: number;
+  margin?: string; // TAO margin
+  skipConfirmation?: boolean;
+  stopLoss?: string;
+  takeProfit?: string;
+}
+
+/**
+ * Detect which paradigm to use based on provided options
+ */
+export function detectParadigm(options: {
+  size?: string;
+  margin?: string;
+  collateral?: string;
+  leverage?: number;
+}): 'collateral-first' | 'size-first' | 'invalid' {
+  const hasCollateral = options.collateral !== undefined;
+  const hasSize = options.size !== undefined;
+  const hasMargin = options.margin !== undefined;
+
+  // Check for paradigm mixing (error case)
+  if (hasCollateral && (hasSize || hasMargin)) {
+    return 'invalid';
+  }
+
+  // Collateral-first: has --collateral
+  if (hasCollateral) {
+    return 'collateral-first';
+  }
+
+  // Size-first: has --size or --margin
+  if (hasSize || hasMargin) {
+    return 'size-first';
+  }
+
+  // No paradigm detected (missing required flags)
+  return 'invalid';
+}
+
+/**
+ * Open position using collateral-first paradigm (NEW)
+ * @param alpha - AlphaViem instance
+ * @param marketAddress - Market address
+ * @param isLong - True for long, false for short
+ * @param collateralUSD - Collateral amount in USD
+ * @param leverage - Leverage multiplier (supports decimals, e.g., 3.5)
+ * @param currentPrice - Current token price in USD (as bigint with 18 decimals)
+ * @returns Transaction hash
+ */
+export async function openPositionFromCollateral(
+  alpha: AlphaViem,
+  marketAddress: Address,
+  isLong: boolean,
+  collateralUSD: number,
+  leverage: number,
+  currentPrice: bigint,
+): Promise<Hash> {
+  // Validate inputs
+  if (collateralUSD <= 0) {
+    throw new Error('Collateral must be greater than 0');
+  }
+  if (leverage < 1 || leverage > 30) {
+    throw new Error('Leverage must be between 1x and 30x');
+  }
+  if (currentPrice <= 0n) {
+    throw new Error('Invalid token price');
+  }
+
+  // Convert price from bigint (wei) to number (USD)
+  const currentPriceUSD = parseFloat(formatEther(currentPrice));
+
+  // Calculate position size from collateral
+  const positionSize = calculatePositionSizeFromCollateral(
+    collateralUSD,
+    leverage,
+    currentPriceUSD,
+  );
+
+  // Convert leverage to wei
+  const leverageWei = leverageToWei(leverage);
+
+  console.log(`Opening position:`);
+  console.log(`  Collateral: $${collateralUSD}`);
+  console.log(`  Leverage: ${leverage}x`);
+  console.log(`  Position Value: $${(collateralUSD * leverage).toFixed(2)}`);
+  console.log(`  Position Size: ${formatEther(positionSize)} tokens`);
+  console.log(`  Entry Price: $${currentPriceUSD}`);
+
+  // Open position
+  return await alpha.openPosition(marketAddress, isLong, positionSize, leverageWei);
+}
+
+// Size-First Paradigm (LEGACY - for backward compatibility)
+export async function openPositionCommon(
+  options: PositionOptions,
+  programOptions: any,
+): Promise<boolean> {
+  const spinner = ora('Preparing position...').start();
+
+  try {
+    const client = await getClient(programOptions);
+    const alpha = client.getAlpha();
+    const userAddress = await client.getSignerAddress();
+
+    // Parse inputs
+    const asset = options.asset.toUpperCase();
+    const isLong = options.direction === 'long';
+    const positionSizeUSD = parseEther(options.size);
+    const leverage = options.leverage || 3;
+
+    // Validate leverage
+    if (leverage > 10 || leverage < 1) {
+      spinner.fail('Invalid leverage: must be between 1x and 10x');
+      return false;
+    }
+
+    // Get market data
+    const marketAddress = getMarketAddress(asset);
+    const currentPrice = await client.oracle.getPrice(marketAddress);
+
+    // Calculate margin if not provided
+    const marginAmount = options.margin
+      ? parseEther(options.margin)
+      : (positionSizeUSD * 100n) / BigInt(Math.floor(leverage * 100));
+
+    // Check available balance
+    const available = await alpha.getAvailableMargin(userAddress);
+    if (marginAmount > available) {
+      spinner.fail('Insufficient available margin');
+      console.log(`  Required: ${formatTAO(marginAmount)} TAO`);
+      console.log(`  Available: ${formatTAO(available)} TAO`);
+      return false;
+    }
+
+    // Get funding rate
+    const fundingRate = await alpha.getFundingRate(marketAddress);
+
+    spinner.stop();
+
+    // 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)}`);
+    console.log(`  Margin: ${formatTAO(marginAmount)} TAO`);
+    console.log(`  Leverage: ${chalk.yellow(leverage + 'x')}`);
+
+    // Calculate liquidation price (simplified calculation)
+    const liquidationBuffer = parseEther('0.2'); // 20% maintenance margin
+    const liquidationPrice = isLong
+      ? currentPrice - (marginAmount * liquidationBuffer) / parseEther('1')
+      : currentPrice + (marginAmount * liquidationBuffer) / parseEther('1');
+
+    console.log(`  Liquidation Price: ${formatUSD(liquidationPrice)}`);
+    console.log(`  Funding Rate: ${formatPercentage(fundingRate)} per 8h`);
+
+    // Show stop loss and take profit if provided
+    if (options.stopLoss) {
+      console.log(`  Stop Loss: ${formatUSD(parseEther(options.stopLoss))}`);
+    }
+    if (options.takeProfit) {
+      console.log(`  Take Profit: ${formatUSD(parseEther(options.takeProfit))}`);
+    }
+
+    // Calculate and display fees
+    const tradingFee = (positionSizeUSD * 10n) / 10000n; // 0.1% of notional
+    console.log(`  Trading Fee: ${formatUSD(tradingFee)} (0.1%)`);
+
+    // Confirm action
+    if (!options.skipConfirmation) {
+      const confirmed = await confirmAction('Open this position?');
+      if (!confirmed) {
+        console.log(chalk.yellow('Position cancelled'));
+        return false;
+      }
+    }
+
+    spinner.start('Opening position...');
+
+    // Convert USD position size to token amount at current price
+    // positionSizeUSD is in USD with 18 decimals (e.g., 30e18 for $30)
+    // currentPrice is price per token with 18 decimals (e.g., 0.019e18 for $0.019)
+    // We want: tokens = USD / price, but need to maintain 18 decimal precision
+    // So: positionSize = (positionSizeUSD * 1e18) / currentPrice
+    const positionSize = (positionSizeUSD * parseEther('1')) / currentPrice;
+
+    // Open the position
+    // Convert leverage to wei format (e.g., 3 -> 3e18)
+    const leverageWei = parseEther(leverage.toString());
+    const hash = await alpha.openPosition(marketAddress, isLong, positionSize, leverageWei);
+
+    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}`));
+      console.log(
+        chalk.cyan(`  View details: alpha-futures position info ${positionEvent.positionId}`),
+      );
+    }
+
+    return true;
+  } catch (error: any) {
+    spinner.fail('Failed to open position');
+    console.error(chalk.red(`Error: ${error.message}`));
+    return false;
+  }
+}