@megatao/sdk 1.1.0

package/cli/utils/display.ts

@@ -0,0 +1,258 @@
+/**
+ * Display Utilities
+ *
+ * Helper functions for formatting and displaying data in the CLI
+ */
+
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { formatUSD, formatTAO, formatPercentage } from '../../src/utils';
+
+// Asset name mapping for subnet market addresses
+const ASSET_NAMES_DATA = [
+  { address: '0x0000000000000000000000000000000000000022', name: 'BITMIND' }, // Subnet 34
+  { address: '0x0000000000000000000000000000000000000040', name: 'CHUTES' }, // Subnet 64
+  { address: '0x0000000000000000000000000000000000000078', name: 'AFFINE' }, // Subnet 120
+  { address: '0x0000000000000000000000000000000000000003E', name: 'RIDGES' }, // Subnet 62
+];
+
+const ASSET_NAMES: { [address: string]: string } = {};
+ASSET_NAMES_DATA.forEach(({ address, name }) => {
+  ASSET_NAMES[address] = name;
+  ASSET_NAMES[address.toLowerCase()] = name;
+});
+
+/**
+ * Display detailed position information
+ */
+export function displayPositionDetails(position: any, currentPrice: bigint) {
+  // Handle both old and new position structures
+  // Get asset name from mapping or fallback to UNKNOWN
+  let assetName = 'UNKNOWN';
+  if (position.asset) {
+    const assetAddress = position.asset.toLowerCase();
+    assetName = ASSET_NAMES[assetAddress] || ASSET_NAMES[position.asset] || 'UNKNOWN';
+  }
+  const status =
+    position.isActive !== undefined
+      ? position.isActive
+        ? chalk.green('Active')
+        : chalk.gray('Closed')
+      : position.notionalValue > 0n
+        ? chalk.green('Active')
+        : chalk.gray('Closed');
+
+  console.log(`  Asset: ${chalk.cyan(assetName)}`);
+  console.log(`  Direction: ${position.isLong ? chalk.green('LONG ↗') : chalk.red('SHORT ↘')}`);
+  console.log(`  Size: ${formatUSD(position.notionalValue)}`);
+  console.log(`  Margin: ${formatTAO(position.margin)} TAO`);
+
+  // Calculate leverage from position size and margin
+  if (position.notionalValue && position.margin && position.margin !== 0n) {
+    // Both size and margin are in 18-decimal format (wei)
+    // Leverage = position.notionalValue / position.margin
+    const leverageRaw = BigInt(position.notionalValue) / BigInt(position.margin);
+
+    // Convert to number for display (leverage is typically a small number like 3x)
+    const leverageValue = Number(leverageRaw);
+
+    // If the calculated leverage seems too high, it might be in different format
+    const displayLeverage =
+      leverageValue > 1000
+        ? (leverageValue / 1e18).toFixed(2) // Handle if still in wei format
+        : leverageValue.toFixed(2);
+
+    console.log(`  Leverage: ${displayLeverage}x`);
+  } else if (position.leverage !== undefined) {
+    // Handle leverage field - could be in basis points or regular number
+    const leverageRaw = Number(position.leverage);
+    let leverageValue: number;
+
+    if (leverageRaw > 100) {
+      // Leverage is in basis points (e.g., 3000 = 30x, 10000 = 100%, so 30000 = 3x)
+      // Actually, if it's basis points for leverage calculation: 3x = 30000 basis points
+      // But the contract seems to multiply by 10000, so 3x = 30000
+      leverageValue = leverageRaw / 10000;
+    } else {
+      // Leverage is in regular format (e.g., 3 = 3x)
+      leverageValue = leverageRaw;
+    }
+
+    console.log(`  Leverage: ${leverageValue.toFixed(2)}x`);
+  }
+
+  console.log(`  Entry Price: ${formatUSD(position.entryPrice)}`);
+  console.log(`  Current Price: ${formatUSD(currentPrice)}`);
+  console.log(`  Status: ${status}`);
+
+  // Handle timestamps - could be lastUpdated (monolith) or timestamp (old)
+  const timestamp = position.lastUpdated || position.timestamp;
+  if (timestamp) {
+    console.log(`  Last Updated: ${new Date(Number(timestamp) * 1000).toLocaleString()}`);
+  }
+
+  // Only show liquidation price if available
+  if (position.liquidationPrice !== undefined) {
+    console.log(`  Liquidation Price: ${formatUSD(position.liquidationPrice)}`);
+  }
+}
+
+/**
+ * Calculate position P&L
+ */
+export function calculatePnL(position: any, currentPrice: bigint, size: bigint): bigint {
+  // Ensure all values are BigInt
+  const entryPrice = BigInt(position.entryPrice);
+  const currPrice = BigInt(currentPrice);
+  const posSize = BigInt(size);
+
+  const priceDiff = position.isLong ? currPrice - entryPrice : entryPrice - currPrice;
+
+  // Avoid division by zero
+  if (entryPrice === 0n) {
+    return 0n;
+  }
+
+  return (priceDiff * posSize) / entryPrice;
+}
+
+/**
+ * Display market summary
+ */
+export function displayMarketSummary(marketData: any) {
+  const table = new Table({
+    head: ['Metric', 'Value'],
+    colWidths: [20, 30],
+  });
+
+  table.push(
+    ['Price', formatUSD(marketData.price)],
+    [
+      '24h Change',
+      marketData.change24h ? formatPercentage(marketData.change24h) : chalk.gray('N/A'),
+    ],
+    ['24h Volume', marketData.volume24h ? formatUSD(marketData.volume24h) : chalk.gray('N/A')],
+    ['Funding Rate', formatPercentage(marketData.fundingRate) + ' per 8h'],
+    [
+      'Open Interest',
+      marketData.openInterest ? formatUSD(marketData.openInterest) : chalk.gray('N/A'),
+    ],
+  );
+
+  console.log(table.toString());
+}
+
+/**
+ * Create a simple ASCII price chart (placeholder)
+ */
+export function createPriceChart(): string {
+  // This is a placeholder for ASCII chart generation
+  const chart = `
+    $110 |     ╱╲    
+    $108 |    ╱  ╲   
+    $106 |   ╱    ╲  
+    $104 |  ╱      ╲ 
+    $102 | ╱        ╲
+    $100 |╱          
+         └──────────
+         1h  2h  3h`;
+
+  return chalk.gray(chart);
+}
+
+/**
+ * Create a volume chart (placeholder)
+ */
+export function createVolumeChart(): string {
+  const chart = `
+    10M |  ▐▌       
+     8M |  ▐▌  ▐▌   
+     6M |  ▐▌  ▐▌   
+     4M |▐▌▐▌  ▐▌▐▌ 
+     2M |▐▌▐▌▐▌▐▌▐▌ 
+        └──────────
+        1h  2h  3h`;
+
+  return chalk.gray(chart);
+}
+
+/**
+ * Format a large number with K/M/B suffixes
+ */
+export function formatLargeNumber(value: bigint): string {
+  const num = Number(value);
+
+  if (num >= 1e9) {
+    return (num / 1e9).toFixed(2) + 'B';
+  } else if (num >= 1e6) {
+    return (num / 1e6).toFixed(2) + 'M';
+  } else if (num >= 1e3) {
+    return (num / 1e3).toFixed(2) + 'K';
+  }
+
+  return num.toFixed(2);
+}
+
+/**
+ * Display a progress bar
+ */
+export function progressBar(current: number, total: number, width: number = 20): string {
+  const percentage = current / total;
+  const filled = Math.round(width * percentage);
+  const empty = width - filled;
+
+  const bar = chalk.green('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+  const percentStr = (percentage * 100).toFixed(1) + '%';
+
+  return `${bar} ${percentStr}`;
+}
+
+/**
+ * Display risk indicator
+ */
+export function riskIndicator(riskLevel: number): string {
+  if (riskLevel < 20) {
+    return chalk.green('●●●●●') + ' Low Risk';
+  } else if (riskLevel < 40) {
+    return chalk.green('●●●') + chalk.gray('●●') + ' Low-Medium Risk';
+  } else if (riskLevel < 60) {
+    return chalk.yellow('●●●') + chalk.gray('●●') + ' Medium Risk';
+  } else if (riskLevel < 80) {
+    return chalk.red('●●') + chalk.gray('●●●') + ' High Risk';
+  } else {
+    return chalk.red('●') + chalk.gray('●●●●') + ' Very High Risk';
+  }
+}
+
+/**
+ * Format time remaining
+ */
+export function formatTimeRemaining(seconds: number): string {
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const secs = seconds % 60;
+
+  if (hours > 0) {
+    return `${hours}h ${minutes}m`;
+  } else if (minutes > 0) {
+    return `${minutes}m ${secs}s`;
+  } else {
+    return `${secs}s`;
+  }
+}
+
+/**
+ * Display a summary card
+ */
+export function displaySummaryCard(title: string, data: Array<[string, string]>) {
+  const maxKeyLength = Math.max(...data.map(([key]) => key.length));
+
+  console.log(chalk.bold(`\n╔══ ${title} ${'═'.repeat(40 - title.length)}`));
+
+  data.forEach(([key, value]) => {
+    const padding = ' '.repeat(maxKeyLength - key.length);
+    console.log(`║ ${key}:${padding} ${value}`);
+  });
+
+  console.log('╚' + '═'.repeat(44));
+}

package/cli/utils/index.ts

@@ -0,0 +1,10 @@
+/**
+ * CLI Utilities Index
+ *
+ * Export all utility functions
+ */
+
+export * from './client';
+export * from './config';
+export * from './display';
+export * from './prompts';

package/cli/utils/prompts.ts

@@ -0,0 +1,364 @@
+/**
+ * Prompt Utilities
+ *
+ * Helper functions for user input and confirmation
+ */
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { privateKeyToAccount } from 'viem/accounts';
+import { parseEther, formatEther, getAddress as viemGetAddress } from 'viem';
+
+/**
+ * Confirm an action with the user
+ */
+export async function confirmAction(
+  message: string,
+  defaultValue: boolean = false,
+): Promise<boolean> {
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message,
+      default: defaultValue,
+    },
+  ]);
+
+  return confirmed;
+}
+
+/**
+ * Select from a list of options
+ */
+export async function selectFromList<T>(
+  message: string,
+  choices: Array<{ name: string; value: T }>,
+  defaultValue?: T,
+): Promise<T> {
+  const { selected } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selected',
+      message,
+      choices,
+      default: defaultValue,
+    },
+  ]);
+
+  return selected;
+}
+
+/**
+ * Get a numeric input with validation
+ */
+export async function getNumericInput(
+  message: string,
+  options: {
+    min?: number;
+    max?: number;
+    decimals?: number;
+    default?: number;
+  } = {},
+): Promise<number> {
+  const { value } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'value',
+      message,
+      default: options.default?.toString(),
+      validate: (input) => {
+        const num = parseFloat(input);
+
+        if (isNaN(num)) {
+          return 'Please enter a valid number';
+        }
+
+        if (options.min !== undefined && num < options.min) {
+          return `Value must be at least ${options.min}`;
+        }
+
+        if (options.max !== undefined && num > options.max) {
+          return `Value must be at most ${options.max}`;
+        }
+
+        return true;
+      },
+      filter: (input) => {
+        const num = parseFloat(input);
+        if (options.decimals !== undefined) {
+          return parseFloat(num.toFixed(options.decimals));
+        }
+        return num;
+      },
+    },
+  ]);
+
+  return value;
+}
+
+/**
+ * Get an Ethereum address with validation
+ */
+export async function getAddress(message: string, defaultValue?: string): Promise<string> {
+  const { address } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'address',
+      message,
+      default: defaultValue,
+      validate: (input) => {
+        try {
+          viemGetAddress(input);
+          return true;
+        } catch {
+          return 'Please enter a valid Ethereum address';
+        }
+      },
+      filter: (input) => {
+        try {
+          return viemGetAddress(input);
+        } catch {
+          return input;
+        }
+      },
+    },
+  ]);
+
+  return address;
+}
+
+/**
+ * Get a private key with validation (masked input)
+ */
+export async function getPrivateKey(message: string = 'Enter private key:'): Promise<string> {
+  const { key } = await inquirer.prompt([
+    {
+      type: 'password',
+      name: 'key',
+      message,
+      mask: '*',
+      validate: (input) => {
+        if (!input || input.length === 0) {
+          return 'Private key is required';
+        }
+
+        try {
+          // Validate it's a valid private key format
+          const cleanKey = input.startsWith('0x') ? input : '0x' + input;
+          if (cleanKey.length !== 66) {
+            return 'Invalid private key length';
+          }
+
+          // Try to create an account to validate
+          privateKeyToAccount(cleanKey as `0x${string}`);
+          return true;
+        } catch {
+          return 'Invalid private key format';
+        }
+      },
+      filter: (input) => {
+        return input.startsWith('0x') ? input : '0x' + input;
+      },
+    },
+  ]);
+
+  return key;
+}
+
+/**
+ * Get TAO amount with validation
+ */
+export async function getTaoAmount(
+  message: string,
+  options: {
+    maxAmount?: bigint;
+    minAmount?: bigint;
+    default?: string;
+  } = {},
+): Promise<bigint> {
+  const { amount } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'amount',
+      message,
+      default: options.default,
+      validate: (input) => {
+        try {
+          const value = parseEther(input);
+
+          if (options.minAmount && value < options.minAmount) {
+            return `Minimum amount is ${formatEther(options.minAmount)} TAO`;
+          }
+
+          if (options.maxAmount && value > options.maxAmount) {
+            return `Maximum amount is ${formatEther(options.maxAmount)} TAO`;
+          }
+
+          return true;
+        } catch {
+          return 'Please enter a valid amount';
+        }
+      },
+    },
+  ]);
+
+  return parseEther(amount);
+}
+
+/**
+ * Multi-select from a list
+ */
+export async function multiSelect<T>(
+  message: string,
+  choices: Array<{ name: string; value: T; checked?: boolean }>,
+): Promise<T[]> {
+  const { selected } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selected',
+      message,
+      choices,
+    },
+  ]);
+
+  return selected;
+}
+
+/**
+ * Validates direction input
+ */
+export function validateDirection(direction: string): 'long' | 'short' {
+  const normalizedDirection = direction.toLowerCase().trim();
+
+  if (['long', 'buy'].includes(normalizedDirection)) {
+    return 'long';
+  } else if (['short', 'sell'].includes(normalizedDirection)) {
+    return 'short';
+  } else {
+    throw new Error(`Invalid direction: "${direction}". Must be one of: long, short, buy, sell`);
+  }
+}
+
+/**
+ * Get asset symbol with validation
+ */
+export async function getAssetSymbol(
+  message: string = 'Enter asset symbol:',
+  defaultValue: string = 'ALPHA',
+): Promise<string> {
+  const { asset } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'asset',
+      message,
+      default: defaultValue,
+      transformer: (input) => input.toUpperCase(),
+      filter: (input) => input.toUpperCase(),
+      validate: (input) => {
+        if (!input || input.length === 0) {
+          return 'Asset symbol is required';
+        }
+
+        if (!/^[A-Z0-9]+$/.test(input.toUpperCase())) {
+          return 'Asset symbol must contain only letters and numbers';
+        }
+
+        return true;
+      },
+    },
+  ]);
+
+  return asset;
+}
+
+/**
+ * Display a warning and get confirmation
+ */
+export async function confirmWarning(
+  warning: string,
+  confirmMessage: string = 'Do you want to proceed?',
+): Promise<boolean> {
+  console.log(chalk.yellow.bold('\n⚠️  Warning:'));
+  console.log(chalk.yellow(warning));
+
+  return confirmAction(confirmMessage, false);
+}
+
+/**
+ * Get leverage selection
+ */
+export async function selectLeverage(
+  message: string = 'Select leverage:',
+  defaultValue: number = 3,
+): Promise<number> {
+  const leverageOptions = [
+    { 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 },
+  ];
+
+  return selectFromList(message, leverageOptions, defaultValue);
+}
+
+/**
+ * Get position size with smart defaults
+ */
+export async function getPositionSize(
+  availableBalance: bigint,
+  leverage: number = 3,
+): Promise<{ size: bigint; margin: bigint }> {
+  console.log(chalk.cyan(`Available balance: ${formatEther(availableBalance)} TAO`));
+
+  const { sizeType } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'sizeType',
+      message: 'How would you like to specify position size?',
+      choices: [
+        { name: 'By margin amount (TAO)', value: 'margin' },
+        { name: 'By position size (USD)', value: 'size' },
+        { name: 'By percentage of balance', value: 'percentage' },
+      ],
+    },
+  ]);
+
+  let margin: bigint;
+  let size: bigint;
+
+  switch (sizeType) {
+    case 'margin':
+      margin = await getTaoAmount('Enter margin amount:', {
+        maxAmount: availableBalance,
+        minAmount: parseEther('10'), // Minimum 10 TAO
+      });
+      size = margin * BigInt(leverage);
+      break;
+
+    case 'size':
+      const sizeUsd = await getNumericInput('Enter position size (USD):', {
+        min: 100,
+        max: Number(formatEther(availableBalance)) * leverage * 100, // Rough USD estimate
+      });
+      size = parseEther(sizeUsd.toString());
+      margin = size / BigInt(leverage);
+      break;
+
+    case 'percentage':
+      const percentage = await getNumericInput('Enter percentage of balance:', {
+        min: 1,
+        max: 100,
+        decimals: 1,
+      });
+      margin = (availableBalance * BigInt(Math.floor(percentage * 10))) / 1000n;
+      size = margin * BigInt(leverage);
+      break;
+
+    default:
+      throw new Error('Invalid size type');
+  }
+
+  return { size, margin };
+}

package/config.example.json

@@ -0,0 +1,23 @@
+{
+  "network": "mainnet",
+  "rpcUrl": "https://your-rpc-endpoint.com",
+  "contracts": {
+    "positionManager": "0x0000000000000000000000000000000000000000",
+    "marginAccount": "0x0000000000000000000000000000000000000000",
+    "fundingRate": "0x0000000000000000000000000000000000000000",
+    "liquidationEngine": "0x0000000000000000000000000000000000000000",
+    "protocolVault": "0x0000000000000000000000000000000000000000",
+    "priceOracle": "0x0000000000000000000000000000000000000000"
+  },
+  "defaultSettings": {
+    "leverage": 3,
+    "slippage": 0.5,
+    "gasLimit": 500000,
+    "confirmations": 2
+  },
+  "display": {
+    "currency": "USD",
+    "decimals": 2,
+    "timezone": "UTC"
+  }
+}

package/dist/AlphaFuturesClient.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Alpha Futures Client
+ * Main client class that provides access to all protocol contracts
+ */
+import { PriceOracleViem } from './contracts/viem/PriceOracleViem';
+import { AlphaViem } from './contracts/viem/AlphaViem';
+import { type Environment } from './config/environments';
+import { type PublicClient, type WalletClient, type Address } from 'viem';
+export interface AlphaClientConfig {
+    rpcUrl?: string;
+    privateKey?: `0x${string}`;
+    walletClient?: WalletClient;
+}
+export declare class AlphaFuturesClient {
+    private alphaContract;
+    private oracleContract;
+    private publicClient;
+    private walletClient?;
+    private environment?;
+    readonly oracle: PriceOracleViem;
+    constructor(environment: Environment, config?: AlphaClientConfig);
+    getAlpha(): AlphaViem;
+    getPublicClient(): PublicClient;
+    getWalletClient(): WalletClient | undefined;
+    getEnvironment(): Environment | undefined;
+    get isInitialized(): boolean;
+    get isConnected(): boolean;
+    getSignerAddress(): Promise<Address | undefined>;
+    /**
+     * Get the collateral token address (TAO/USDC) for the current environment
+     * @returns The collateral token contract address
+     */
+    getCollateralTokenAddress(): Address | undefined;
+    static forEnvironment(environment: Environment, config?: AlphaClientConfig): AlphaFuturesClient;
+}
+//# sourceMappingURL=AlphaFuturesClient.d.ts.map

package/dist/AlphaFuturesClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlphaFuturesClient.d.ts","sourceRoot":"","sources":["../src/AlphaFuturesClient.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAwB,KAAK,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAC/E,OAAO,EAIL,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,OAAO,EACb,MAAM,MAAM,CAAC;AAGd,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;IAC3B,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAED,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,aAAa,CAAY;IACjC,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,YAAY,CAAC,CAAe;IACpC,OAAO,CAAC,WAAW,CAAC,CAAc;IAClC,SAAgB,MAAM,EAAE,eAAe,CAAC;gBAE5B,WAAW,EAAE,WAAW,EAAE,MAAM,GAAE,iBAAsB;IAiFpE,QAAQ,IAAI,SAAS;IAIrB,eAAe,IAAI,YAAY;IAI/B,eAAe,IAAI,YAAY,GAAG,SAAS;IAI3C,cAAc,IAAI,WAAW,GAAG,SAAS;IAIzC,IAAI,aAAa,IAAI,OAAO,CAE3B;IAED,IAAI,WAAW,IAAI,OAAO,CAEzB;IAEK,gBAAgB,IAAI,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC;IAItD;;;OAGG;IACH,yBAAyB,IAAI,OAAO,GAAG,SAAS;IAMhD,MAAM,CAAC,cAAc,CACnB,WAAW,EAAE,WAAW,EACxB,MAAM,GAAE,iBAAsB,GAC7B,kBAAkB;CAGtB"}