@steerprotocol/sdk 1.27.0 → 1.28.0

package/src/base/vault/single-asset/simulateSwap.ts

@@ -0,0 +1,451 @@
+import { Decimal } from 'decimal.js';
+import type { Address, PublicClient } from 'viem';
+import { decodeFunctionResult, encodeFunctionData } from 'viem';
+import { getNetworkByChainId, getProtcolTypeByAmmType, Protocol, isAlgebraIntegralProtocol } from '../../../const/index.js';
+import { QuoterV2Factory } from '../../../const/quoter.js';
+import { SteerResponse } from '../../../types.js';
+import { getPoolPrice } from '../utils.js';
+import { bigintToDecimal, decimalToBigint, getPoolSlot0, getQuoteFromSqrtRatioX96 } from './calculateLimitPrice.js';
+import type { PoolSlot0, SimulateSwapParams, SwapSimulationResponse } from './types.js';
+import { AMMType } from './types.js';
+
+/**
+ * Simulates a swap to get the expected output amounts without executing the swap
+ * Uses Uniswap V3 Quoter contract for accurate simulation
+ * 
+ * @param publicClient - Viem public client for blockchain reads
+ * @param params - Parameters for swap simulation
+ * @param chainId - Chain ID to get the appropriate Quoter address
+ * @returns Promise resolving to the simulated swap results
+ * 
+ * @example
+ * ```typescript
+ * const result = await simulateSwap(publicClient, {
+ *   pool: '0x...',
+ *   recipient: '0x...',
+ *   zeroForOne: true,
+ *   amountSpecified: parseEther('10'),
+ *   sqrtPriceLimitX96: limitPrice,
+ *   ammType: AMMType.UniswapV3,
+ *   tokenIn: '0x...',
+ *   tokenOut: '0x...',
+ *   fee: 3000
+ * }, 137); // Polygon chain ID
+ * 
+ * if (result.success) {
+ *   console.log('Amount out:', result.data.amountOut);
+ * }
+ * ```
+ */
+export async function simulateSwap(
+  publicClient: PublicClient,
+  params: SimulateSwapParams,
+  chainId: number
+): Promise<SteerResponse<SwapSimulationResponse>> {
+  try {
+    // For now, only handle UniswapV3 - other AMMs can be added later
+
+    // Get the appropriate Quoter contract address
+
+    const networkConfig = getNetworkByChainId(chainId);
+
+    if (!networkConfig) {
+      throw Error('Network config not found')
+    }
+     
+    const protocol = params.protocol || getProtcolTypeByAmmType(params.ammType);
+
+    const quoterFactory = new QuoterV2Factory(networkConfig);
+
+    const quoterABI = quoterFactory.getQuoterAbi(protocol);
+
+    const quoteParams = quoterFactory.getQuoteParams(protocol, {
+      tokenIn: params.tokenIn,
+      tokenOut: params.tokenOut,
+      fee: params.fee,
+      tickSpacing: params.tickSpacing,
+      amountIn: params.amountSpecified,
+      sqrtPriceLimitX96: params.sqrtPriceLimitX96,
+      limitSqrtPrice: params.sqrtPriceLimitX96,
+    })
+
+    const quoterAddress = quoterFactory.getQuoterV2Address(
+      protocol
+    )
+    // Use Quoter's quoteExactInputSingle for simulation
+    const result = await publicClient.call({
+      to: quoterAddress as Address,
+      data: encodeFunctionData({
+        abi: quoterABI,
+        functionName: 'quoteExactInputSingle',
+        //@ts-expect-error Parameters are dynamic in nature and very based on abi types
+        args: [{
+          ...quoteParams
+        }]
+      })
+    });
+
+    if (!result.data) {
+      throw new Error('No data returned from quoter simulation');
+    }
+
+    // Decode the result - Different quoters return different tuple structures:
+    // - Standard Uniswap/QuickSwap: [amountOut, sqrtPriceX96After, initializedTicksCrossed, gasEstimate]
+    // - AlgebraIntegral: [amountOut, amountIn, sqrtPriceX96After, initializedTicksCrossed, gasEstimate, fee]
+    const decodedResult = decodeFunctionResult({
+      abi: quoterABI,
+      functionName: 'quoteExactInputSingle',
+      data: result.data
+    });
+
+    // Extract values based on protocol type
+    let amountOut: bigint;
+    let sqrtPriceX96After: bigint;
+    
+    // Check if this is an AlgebraIntegral protocol (which has amountIn as second return value)
+    if (protocol && isAlgebraIntegralProtocol(protocol)) {
+      // AlgebraIntegral format: [amountOut, amountIn, sqrtPriceX96After, ...]
+      const [out, , priceAfter] = decodedResult as readonly [bigint, bigint, bigint, number, bigint, number];
+      amountOut = out;
+      sqrtPriceX96After = priceAfter;
+    } else {
+      // Standard format: [amountOut, sqrtPriceX96After, ...]
+      const [out, priceAfter] = decodedResult as readonly [bigint, bigint, number, bigint];
+      amountOut = out;
+      sqrtPriceX96After = priceAfter;
+    }
+
+    // Convert to the expected SwapSimulationResponse format
+    // For exact input swaps, we know the input amount and get the output amount
+    let amount0: bigint, amount1: bigint;
+    
+    if (params.zeroForOne) {
+      // Swapping token0 for token1
+      amount0 = -params.amountSpecified; // negative because we're giving token0
+      amount1 = amountOut; // positive because we're receiving token1
+    } else {
+      // Swapping token1 for token0
+      amount0 = amountOut; // positive because we're receiving token0
+      amount1 = -params.amountSpecified; // negative because we're giving token1
+    }
+
+    return {
+      data: {
+        amount0,
+        amount1,
+        sqrtPriceX96After
+      },
+      status: 200,
+      success: true
+    };
+  } catch (error) {
+    return {
+      data: null,
+      status: 500,
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to simulate swap'
+    };
+  }
+}
+
+/**
+ * Determines the swap direction based on the token being deposited
+ * 
+ * @param isToken0 - true if depositing token0, false if token1
+ * @returns true if swapping token0 → token1, false otherwise
+ */
+export function determineSwapDirection(isToken0: boolean): boolean {
+  // If depositing token0, we need to swap some token0 to token1
+  // If depositing token1, we need to swap some token1 to token0
+  return isToken0;
+}
+
+/**
+ * Validates swap simulation parameters
+ * 
+ * @param params - Parameters to validate
+ * @throws Error if parameters are invalid
+ */
+export function validateSwapParams(params: SimulateSwapParams): void {
+  if (!params.pool || params.pool === '0x0000000000000000000000000000000000000000') {
+    throw new Error('Invalid pool address');
+  }
+  
+  if (!params.recipient || params.recipient === '0x0000000000000000000000000000000000000000') {
+    throw new Error('Invalid recipient address');
+  }
+  
+  if (params.amountSpecified <= 0n) {
+    throw new Error('Amount specified must be greater than 0');
+  }
+  
+  if (params.sqrtPriceLimitX96 <= 0n) {
+    throw new Error('Sqrt price limit must be greater than 0');
+  }
+
+  if (!params.tokenIn || params.tokenIn === '0x0000000000000000000000000000000000000000') {
+    throw new Error('Invalid tokenIn address');
+  }
+
+  if (!params.tokenOut || params.tokenOut === '0x0000000000000000000000000000000000000000') {
+    throw new Error('Invalid tokenOut address');
+  }
+
+  if (params.fee <= 0) {
+    throw new Error('Pool fee must be greater than 0');
+  }
+} 
+
+/**
+ * Parameters for swap with slippage analysis
+ */
+export interface SwapWithSlippageParams {
+  /** Address of the pool */
+  poolAddress: string;
+  /** Address that will receive the swap output (or address(this) for simulation) */
+  recipient: string;
+  /** true if swapping token0 → token1, else false */
+  zeroForOne: boolean;
+  /** Amount to swap */
+  amountSpecified: bigint;
+  /** Slippage-adjusted limit price */
+  sqrtPriceLimitX96: bigint;
+  /** AMM type */
+  ammType: AMMType;
+  /** Input token address (required for Quoter) */
+  tokenIn: string;
+  /** Output token address (required for Quoter) */
+  tokenOut: string;
+  /** Pool fee (required for Quoter) */
+  fee: number;
+  /** Quoter contract address (optional - will use default if not provided) */
+  quoterAddress?: string;
+  /** Protocol */
+  protocol?: Protocol | null;
+}
+
+/**
+ * Response from swap simulation with slippage analysis
+ */
+export interface SwapWithSlippageResponse {
+  /** Current pool slot0 data */
+  currentSlot0: PoolSlot0;
+  /** Swap simulation results */
+  swapSimulation: SwapSimulationResponse;
+  /** Price slippage percentage (positive means price moved unfavorably) */
+  priceSlippagePercent: string;
+  /** Current price (derived from sqrtPriceX96) */
+  currentPrice: bigint;
+  /** Price after swap (derived from sqrtPriceX96After) */
+  priceAfter: bigint;
+}
+
+/**
+ * Simulates a swap with slippage analysis by first getting current pool state,
+ * then simulating the swap and calculating price impact
+ * 
+ * @param publicClient - Viem public client for blockchain reads
+ * @param params - Parameters for swap simulation with slippage analysis
+ * @param chainId - Chain ID to get the appropriate Quoter address
+ * @returns Promise resolving to swap results with slippage analysis
+ * 
+ * @example
+ * ```typescript
+ * const result = await simulateSwapWithSlippage(publicClient, {
+ *   poolAddress: '0x...',
+ *   recipient: '0x...',
+ *   zeroForOne: true,
+ *   amountSpecified: parseEther('10'),
+ *   sqrtPriceLimitX96: limitPrice,
+ *   ammType: AMMType.UniswapV3,
+ *   tokenIn: '0x...',
+ *   tokenOut: '0x...',
+ *   fee: 3000
+ * }, 137); // Polygon chain ID
+ * 
+ * if (result.success) {
+ *   console.log('Price slippage:', result.data.priceSlippagePercent, '%');
+ *   console.log('Current price:', result.data.currentPrice);
+ *   console.log('Price after swap:', result.data.priceAfter);
+ * }
+ * ```
+ */
+export async function simulateSwapWithSlippage(
+  publicClient: PublicClient,
+  params: SwapWithSlippageParams,
+  chainId: number
+): Promise<SteerResponse<SwapWithSlippageResponse>> {
+  try {
+    // Validate params
+    validateSwapWithSlippageParams(params);
+
+    // Step 1: Get current pool state from slot0
+
+    const slot0Result = await getPoolSlot0(
+      publicClient,
+      params.poolAddress as `0x${string}`,
+      params.ammType
+    )
+
+    if (!slot0Result.data) {
+      throw new Error('Failed to get pool slot0 data');
+    }
+
+    // Decode slot0 result
+    const currentSlot0: PoolSlot0 = {
+      sqrtPriceX96: getPoolPrice(slot0Result.data, {
+        isAlgebraPool: params.ammType === AMMType.Algebra,
+        isAlgebraIntegralPool: params.ammType === AMMType.AlgebraIntegral,
+        isPoolSharkPool: false // PoolShark not defined in AMMType enum
+      }) || BigInt(0),
+      tick: slot0Result.data.tick,
+      observationIndex: slot0Result.data.observationIndex,
+      observationCardinality: slot0Result.data.observationCardinality,
+      observationCardinalityNext: slot0Result.data.observationCardinalityNext,
+      feeProtocol: slot0Result.data.feeProtocol,
+      unlocked: slot0Result.data.unlocked
+    };
+
+    const tickSpacing = await publicClient.readContract({
+      abi: [  {
+        "inputs": [],
+        "name": "tickSpacing",
+        "outputs": [
+          {
+            "internalType": "int24",
+            "name": "",
+            "type": "int24"
+          }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+      },],
+      functionName: 'tickSpacing',
+      address: params.poolAddress as `0x${string}`,
+    })
+
+    // Step 2: Simulate the swap using existing function
+    const swapParams: SimulateSwapParams = {
+      pool: params.poolAddress as `0x${string}`,
+      recipient: params.recipient as `0x${string}`,
+      zeroForOne: params.zeroForOne,
+      amountSpecified: params.amountSpecified,
+      sqrtPriceLimitX96: params.sqrtPriceLimitX96,
+      ammType: params.ammType,
+      tokenIn: params.tokenIn as `0x${string}`,
+      tokenOut: params.tokenOut as `0x${string}`,
+      fee: params.fee,
+      tickSpacing: tickSpacing,
+      quoterAddress: params.quoterAddress as `0x${string}` | undefined,
+      protocol: params.protocol
+    };
+
+    const swapResult = await simulateSwap(publicClient, swapParams, chainId);
+
+    if (!swapResult.success || !swapResult.data) {
+      throw new Error(swapResult.error || 'Swap simulation failed');
+    }
+
+    // Step 3: Calculate price slippage
+    const currentPrice = getQuoteFromSqrtRatioX96(
+      bigintToDecimal(currentSlot0.sqrtPriceX96),
+      bigintToDecimal(10n**18n),
+      params.tokenIn as `0x${string}`,
+      params.tokenOut as `0x${string}`
+    );
+    const priceAfter = getQuoteFromSqrtRatioX96(
+      bigintToDecimal(swapResult.data.sqrtPriceX96After),
+      bigintToDecimal(10n**18n),
+      params.tokenIn as `0x${string}`,
+      params.tokenOut as `0x${string}`
+    );
+    
+    // Calculate slippage percentage
+    // Positive slippage means unfavorable price movement
+    const priceSlippagePercent = calculatePriceSlippage(
+      currentPrice,
+      priceAfter,
+      params.zeroForOne
+    );
+
+    return {
+      data: {
+        currentSlot0,
+        swapSimulation: swapResult.data,
+        priceSlippagePercent: priceSlippagePercent.toFixed(5),
+        currentPrice: decimalToBigint(currentPrice),
+        priceAfter: decimalToBigint(priceAfter)
+      },
+      status: 200,
+      success: true
+    };
+  } catch (error) {
+    return {
+      data: null,
+      status: 500,
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to simulate swap with slippage'
+    };
+  }
+}
+
+/**
+ * Calculates price slippage percentage using Decimal.js
+ * 
+ * @param priceBefore - Price before the swap (Decimal)
+ * @param priceAfter - Price after the swap (Decimal)
+ * @param zeroForOne - Swap direction (true if token0 → token1)
+ * @returns Slippage percentage (positive means unfavorable movement)
+ */
+function calculatePriceSlippage(
+  priceBefore: Decimal,
+  priceAfter: Decimal,
+  zeroForOne: boolean
+): Decimal {
+  if (priceBefore.isZero()) {
+    throw new Error('Price before cannot be zero');
+  }
+
+  const priceChange = priceAfter.minus(priceBefore).dividedBy(priceBefore).times(100);
+  
+  // For zeroForOne swaps (selling token0), favorable movement is price going down
+  // For oneForZero swaps (selling token1), favorable movement is price going up
+  // We return positive values for unfavorable movement (slippage)
+  return zeroForOne ? priceChange : priceChange.negated();
+}
+
+/**
+ * Validates swap with slippage parameters
+ * 
+ * @param params - Parameters to validate
+ * @throws Error if parameters are invalid
+ */
+function validateSwapWithSlippageParams(params: SwapWithSlippageParams): void {
+  if (!params.poolAddress || params.poolAddress === '0x0000000000000000000000000000000000000000') {
+    throw new Error('Invalid pool address');
+  }
+  
+  if (!params.recipient || params.recipient === '0x0000000000000000000000000000000000000000') {
+    throw new Error('Invalid recipient address');
+  }
+  
+  if (params.amountSpecified <= 0n) {
+    throw new Error('Amount specified must be greater than 0');
+  }
+  
+  if (params.sqrtPriceLimitX96 <= 0n) {
+    throw new Error('Sqrt price limit must be greater than 0');
+  }
+
+  if (!params.tokenIn || params.tokenIn === '0x0000000000000000000000000000000000000000') {
+    throw new Error('Invalid tokenIn address');
+  }
+
+  if (!params.tokenOut || params.tokenOut === '0x0000000000000000000000000000000000000000') {
+    throw new Error('Invalid tokenOut address');
+  }
+
+  if (params.fee <= 0) {
+    throw new Error('Pool fee must be greater than 0');
+  }
+}