@megatao/sdk 1.1.0

package/cli/commands/funding.ts

@@ -0,0 +1,481 @@
+/**
+ * Funding Rate Commands - Manage and view funding rates
+ */
+
+import { Command } from 'commander';
+import { parseEther, Address } from 'viem';
+import chalk from 'chalk';
+import ora from 'ora';
+import Table from 'cli-table3';
+import { formatPercentage, formatTAO } from '../../src/utils';
+import { getClient, handleError, getMarketAddress } from '../utils/client';
+import { confirmAction } from '../utils/prompts';
+
+/**
+ * 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 fundingCommands(program: Command) {
+  const funding = program
+    .command('funding')
+    .alias('fund')
+    .description('Manage and view funding rates');
+
+  // Get current funding rate
+  funding
+    .command('rate [asset]')
+    .description('Get current funding rate for an asset')
+    .option('-a, --all', 'Show funding rates for all available assets')
+    .action(async (asset, options) => {
+      const spinner = ora('Fetching funding rates...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+
+        if (options.all) {
+          // Get funding rates for all available assets
+          const { listAvailableMarketAddresses } = await import('../utils/client');
+          const availableMarkets = listAvailableMarketAddresses();
+
+          if (Object.keys(availableMarkets).length === 0) {
+            spinner.fail('No market addresses configured');
+            console.log(chalk.yellow('Available subnet markets: BITMIND, CHUTES, AFFINE, RIDGES'));
+            return;
+          }
+
+          const fundingData: Array<[string, string, string, string]> = [];
+
+          for (const [assetSymbol, marketAddress] of Object.entries(availableMarkets)) {
+            try {
+              const marketInfo = await alpha.getMarketInfo(marketAddress as Address);
+              const openInterest = await alpha.getMarketOpenInterest(marketAddress as Address);
+
+              const fundingRate = marketInfo.fundingRate;
+              const longOI = openInterest.longOI;
+              const shortOI = openInterest.shortOI;
+              const totalOI = longOI + shortOI;
+              const skew = totalOI > 0n ? ((longOI - shortOI) * 10000n) / totalOI : 0n;
+
+              fundingData.push([
+                assetSymbol,
+                formatPercentage(fundingRate) + ' per 8h',
+                formatTAO(totalOI) + ' TAO',
+                (Number(skew) / 100).toFixed(2) + '%',
+              ]);
+            } catch (error) {
+              fundingData.push([
+                assetSymbol,
+                chalk.red('Error'),
+                chalk.red('Error'),
+                chalk.red('Error'),
+              ]);
+            }
+          }
+
+          spinner.stop();
+
+          console.log(chalk.bold('\n📊 Funding Rates Overview:'));
+          const table = new Table({
+            head: ['Asset', 'Funding Rate', 'Total OI', 'Long Bias'],
+            colWidths: [10, 20, 15, 12],
+          });
+
+          fundingData.forEach((row) => table.push(row));
+          console.log(table.toString());
+        } else {
+          // Get funding rate for specific asset
+          const targetAsset = asset || 'BITMIND';
+          const marketAddress = getMarketAddress(targetAsset);
+
+          const marketInfo = await alpha.getMarketInfo(marketAddress);
+          const openInterest = await alpha.getMarketOpenInterest(marketAddress);
+          const fundingState = await alpha.getFundingState(marketAddress);
+
+          spinner.stop();
+
+          console.log(chalk.bold(`\n📈 Funding Rate: ${chalk.cyan(targetAsset.toUpperCase())}`));
+          console.log(`  Current Rate: ${formatPercentage(marketInfo.fundingRate)} per 8h`);
+          console.log(
+            `  Last Update: ${new Date(Number(marketInfo.lastFundingUpdate) * 1000).toLocaleString()}`,
+          );
+
+          // Open Interest breakdown
+          console.log(chalk.bold('\n📊 Open Interest:'));
+          console.log(`  Long OI: ${formatTAO(openInterest.longOI)} TAO`);
+          console.log(`  Short OI: ${formatTAO(openInterest.shortOI)} TAO`);
+          console.log(`  Total OI: ${formatTAO(openInterest.longOI + openInterest.shortOI)} TAO`);
+
+          // Calculate and show bias
+          const totalOI = openInterest.longOI + openInterest.shortOI;
+          if (totalOI > 0n) {
+            const longBias = (Number(openInterest.longOI) * 100) / Number(totalOI);
+            const shortBias = 100 - longBias;
+            console.log(`  Long Bias: ${chalk.green(longBias.toFixed(1) + '%')}`);
+            console.log(`  Short Bias: ${chalk.red(shortBias.toFixed(1) + '%')}`);
+          }
+
+          // Rate direction indicator
+          const rateNumber = Number(marketInfo.fundingRate);
+          let direction = 'Neutral';
+          let directionColor = chalk.gray;
+
+          if (rateNumber > 0) {
+            direction = 'Longs pay Shorts';
+            directionColor = chalk.red;
+          } else if (rateNumber < 0) {
+            direction = 'Shorts pay Longs';
+            directionColor = chalk.green;
+          }
+
+          console.log(`  Direction: ${directionColor(direction)}`);
+        }
+      } catch (error) {
+        spinner.fail('Failed to fetch funding rates');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Calculate funding payment for a position
+  funding
+    .command('payment <positionId>')
+    .description('Calculate funding payment for a position')
+    .addHelpText(
+      'after',
+      `
+Examples:
+  $ alpha-futures funding payment 0x00000000000000000000000000000001
+  $ alpha-futures funding payment 0x12345000000000000000000000000000
+
+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) => {
+      const spinner = ora('Calculating funding payment...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+
+        // Get position details
+        const normalizedPositionId = normalizePositionId(positionId);
+        const position = await alpha.getPosition(normalizedPositionId);
+
+        if (position.notionalValue === 0n) {
+          spinner.fail('Position not found or inactive');
+          return;
+        }
+
+        // For this calculation, we'll use BITMIND as default market
+        // In a real implementation, you'd need to track which market the position belongs to
+        const marketAddress = getMarketAddress('BITMIND');
+        const marketInfo = await alpha.getMarketInfo(marketAddress);
+
+        spinner.stop();
+
+        // Calculate funding payment
+        const fundingRate = marketInfo.fundingRate;
+        const positionValue = position.notionalValue;
+        // Both positionValue and fundingRate are in wei (18 decimals), so division by BASIS_POINTS is correct
+        const fundingPayment = (positionValue * fundingRate) / 10000n;
+
+        console.log(chalk.bold(`\n💰 Funding Payment Calculation:`));
+        console.log(`  Position ID: ${chalk.cyan(positionId)}`);
+        console.log(`  Position Size: ${formatTAO(position.notionalValue)} TAO`);
+        console.log(`  Direction: ${position.isLong ? chalk.green('LONG') : chalk.red('SHORT')}`);
+        console.log(`  Current Rate: ${formatPercentage(fundingRate)} per 8h`);
+
+        const isPayment =
+          (position.isLong && fundingRate > 0n) || (!position.isLong && fundingRate < 0n);
+        const paymentAmount = fundingPayment < 0n ? -fundingPayment : fundingPayment;
+
+        if (isPayment) {
+          console.log(
+            `  Payment: ${chalk.red('-' + formatTAO(paymentAmount) + ' TAO')} ${chalk.gray('(you pay)')}`,
+          );
+        } else {
+          console.log(
+            `  Receive: ${chalk.green('+' + formatTAO(paymentAmount) + ' TAO')} ${chalk.gray('(you receive)')}`,
+          );
+        }
+
+        // Show next funding time
+        const fundingInterval = 8 * 60 * 60; // 8 hours in seconds
+        const lastUpdate = Number(marketInfo.lastFundingUpdate);
+        const nextFunding = lastUpdate + fundingInterval;
+        const timeUntilNext = nextFunding - Math.floor(Date.now() / 1000);
+
+        if (timeUntilNext > 0) {
+          const hours = Math.floor(timeUntilNext / 3600);
+          const minutes = Math.floor((timeUntilNext % 3600) / 60);
+          console.log(`  Next Payment: ${chalk.yellow(`${hours}h ${minutes}m`)}`);
+        } else {
+          console.log(`  Next Payment: ${chalk.yellow('Due now')}`);
+        }
+      } catch (error) {
+        spinner.fail('Failed to calculate funding payment');
+        handleError(error, program.opts());
+      }
+    });
+
+  // Funding rate history (placeholder for future implementation)
+  funding
+    .command('history [asset]')
+    .description('Show funding rate history')
+    .option('-d, --days <days>', 'Number of days to show', '7')
+    .action(async (asset, options) => {
+      console.log(chalk.yellow('\n⚠️  Funding rate history is coming soon!'));
+      console.log('This feature will show historical funding rates and payments.');
+
+      const targetAsset = asset || 'BITMIND';
+      const days = parseInt(options.days);
+
+      console.log(chalk.bold('\n📅 Parameters:'));
+      console.log(`  Asset: ${chalk.cyan(targetAsset.toUpperCase())}`);
+      console.log(`  Period: ${days} days`);
+      console.log(`  Would fetch: Hourly funding rates, payment events, OI changes`);
+    });
+
+  // Simulate funding rate impact
+  funding
+    .command('simulate')
+    .description('Simulate funding rate scenarios')
+    .option('-a, --asset <asset>', 'Asset to simulate', 'BITMIND')
+    .option('-s, --size <size>', 'Position size in TAO', '1000')
+    .option('-l, --long', 'Simulate long position')
+    .option('-r, --rate <rate>', 'Funding rate to simulate (in %)', '0.01')
+    .action(async (options) => {
+      try {
+        const asset = options.asset.toUpperCase();
+        const positionSize = parseEther(options.size);
+        const isLong = options.long || false;
+        const simulatedRate = parseEther((parseFloat(options.rate) / 100).toString());
+
+        console.log(chalk.bold('\n🎯 Funding Rate Simulation:'));
+        console.log(`  Asset: ${chalk.cyan(asset)}`);
+        console.log(
+          `  Position: ${formatTAO(positionSize)} TAO ${isLong ? chalk.green('LONG') : chalk.red('SHORT')}`,
+        );
+        console.log(`  Simulated Rate: ${formatPercentage(simulatedRate)} per 8h`);
+
+        // Calculate payment scenarios
+        const scenarios = [
+          { period: '8 hours', multiplier: 1 },
+          { period: '1 day', multiplier: 3 },
+          { period: '1 week', multiplier: 21 },
+          { period: '1 month', multiplier: 90 },
+        ];
+
+        console.log(chalk.bold('\n📊 Payment Scenarios:'));
+        const table = new Table({
+          head: ['Period', 'Total Payment', 'Direction'],
+          colWidths: [15, 20, 15],
+        });
+
+        scenarios.forEach((scenario) => {
+          const totalPayment =
+            (positionSize * simulatedRate * BigInt(scenario.multiplier)) / 10000n;
+          const isPayment = (isLong && simulatedRate > 0n) || (!isLong && simulatedRate < 0n);
+          const paymentAmount = totalPayment < 0n ? -totalPayment : totalPayment;
+
+          const paymentStr = isPayment
+            ? chalk.red('-' + formatTAO(paymentAmount) + ' TAO')
+            : chalk.green('+' + formatTAO(paymentAmount) + ' TAO');
+
+          const directionStr = isPayment ? 'Pay' : 'Receive';
+
+          table.push([scenario.period, paymentStr, directionStr]);
+        });
+
+        console.log(table.toString());
+
+        console.log(chalk.bold('\n💡 Tips:'));
+        console.log('  • Positive rates = Longs pay Shorts');
+        console.log('  • Negative rates = Shorts pay Longs');
+        console.log('  • Rates are typically 0.01% to 0.1% per 8h');
+        console.log('  • High OI imbalance increases funding rates');
+      } catch (error) {
+        handleError(error, program.opts());
+      }
+    });
+
+  // Update funding rates (keeper function)
+  funding
+    .command('update [assets...]')
+    .description('Update funding rates for assets (requires keeper role)')
+    .option('-a, --all', 'Update funding rates for all available assets')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (assets, options) => {
+      const spinner = ora('Preparing funding rate update...').start();
+
+      try {
+        const client = await getClient(program.opts());
+        const alpha = client.getAlpha();
+
+        // Get assets to update
+        let assetsToUpdate: Address[] = [];
+
+        if (options.all) {
+          // Update all available assets
+          const { listAvailableMarketAddresses } = await import('../utils/client');
+          const availableMarkets = listAvailableMarketAddresses();
+          assetsToUpdate = Object.values(availableMarkets) as Address[];
+
+          if (assetsToUpdate.length === 0) {
+            spinner.fail('No market addresses configured');
+            console.log(chalk.yellow('Available subnet markets: BITMIND, CHUTES, AFFINE, RIDGES'));
+            return;
+          }
+        } else if (assets && assets.length > 0) {
+          // Update specific assets
+          for (const asset of assets) {
+            const marketAddress = getMarketAddress(asset);
+            assetsToUpdate.push(marketAddress);
+          }
+        } else {
+          spinner.fail('Please specify assets or use --all flag');
+          return;
+        }
+
+        spinner.stop();
+
+        // Show what we're updating
+        console.log(chalk.bold('\n📊 Funding Rate Update:'));
+        console.log(`  Assets to update: ${chalk.cyan(assetsToUpdate.length)}`);
+
+        if (!options.all && assets) {
+          console.log(`  Assets: ${assets.map((a) => chalk.cyan(a.toUpperCase())).join(', ')}`);
+        }
+
+        // Get current rates for display
+        const currentRates: string[] = [];
+        for (const assetAddress of assetsToUpdate) {
+          try {
+            const marketInfo = await alpha.getMarketInfo(assetAddress);
+            currentRates.push(formatPercentage(marketInfo.fundingRate));
+          } catch {
+            currentRates.push('N/A');
+          }
+        }
+
+        if (!options.all && assets && currentRates.length > 0) {
+          console.log(`  Current rates: ${currentRates.join(', ')}`);
+        }
+
+        // Confirmation
+        if (!options.yes) {
+          const confirmed = await confirmAction(
+            'Update funding rates?',
+            'This will calculate and apply new funding rates based on current market conditions.',
+          );
+
+          if (!confirmed) {
+            console.log(chalk.yellow('Update cancelled'));
+            return;
+          }
+        }
+
+        // Update funding rates
+        const updateSpinner = ora('Updating funding rates...').start();
+
+        try {
+          const tx = await alpha.updateFundingRates(assetsToUpdate);
+
+          updateSpinner.text = 'Waiting for confirmation...';
+          const receipt = await tx.wait();
+
+          updateSpinner.succeed('Funding rates updated successfully!');
+
+          console.log(chalk.green(`\n✅ Transaction confirmed`));
+          console.log(`  Hash: ${chalk.cyan(receipt.transactionHash)}`);
+          console.log(`  Gas used: ${chalk.yellow(receipt.gasUsed.toLocaleString())}`);
+
+          // Show new rates
+          console.log(chalk.bold('\n📈 New Funding Rates:'));
+          const table = new Table({
+            head: ['Asset', 'New Rate', 'Direction'],
+            colWidths: [10, 15, 25],
+          });
+
+          for (let i = 0; i < assetsToUpdate.length; i++) {
+            const assetAddress = assetsToUpdate[i];
+            const assetName = assets ? assets[i].toUpperCase() : `Asset ${i + 1}`;
+
+            try {
+              const marketInfo = await alpha.getMarketInfo(assetAddress);
+              const rate = Number(marketInfo.fundingRate);
+
+              let direction = 'Neutral';
+              if (rate > 0) direction = 'Longs pay Shorts';
+              else if (rate < 0) direction = 'Shorts pay Longs';
+
+              table.push([assetName, formatPercentage(marketInfo.fundingRate), direction]);
+            } catch {
+              table.push([assetName, 'Error', '-']);
+            }
+          }
+
+          console.log(table.toString());
+        } catch (error: any) {
+          updateSpinner.fail('Failed to update funding rates');
+          if (error.message?.includes('Unauthorized') || error.message?.includes('KEEPER_ROLE')) {
+            console.log(chalk.red('\n❌ Error: This operation requires keeper role'));
+            console.log(chalk.yellow('Only authorized keepers can update funding rates'));
+          } else {
+            throw error;
+          }
+        }
+      } catch (error) {
+        spinner.fail('Failed to prepare funding rate update');
+        handleError(error, program.opts());
+      }
+    });
+}