@steerprotocol/sdk 1.26.0 → 1.28.0

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

@@ -0,0 +1,279 @@
+import { Decimal } from 'decimal.js';
+import type { PublicClient } from 'viem';
+import { erc20Abi } from '../../../const/abis/erc20.js';
+import { SteerResponse } from '../../../types.js';
+import { getPoolPrice, getPoolState, getPoolStateWithPrice } from '../utils.js';
+import type { CalculateLimitPriceParams, PoolSlot0 } from './types.js';
+import { AMMType } from './types.js';
+
+/**
+ * Configure Decimal.js for high precision calculations
+ */
+Decimal.config({ 
+  precision: 50, // High precision for financial calculations
+  rounding: Decimal.ROUND_DOWN // Conservative rounding for safety
+});
+
+/**
+ * Constants matching the Solidity contract using Decimal.js
+ */
+const BASIS_POINTS = new Decimal(10000);
+const Q96 = new Decimal(2).pow(96);
+const Q192 = Q96.mul(Q96);
+const Q128 = new Decimal(2).pow(128);
+const Q64 = new Decimal(2).pow(64);
+const UINT128_MAX = new Decimal(2).pow(128).sub(1);
+
+/**
+ * High-precision multiplication and division using Decimal.js
+ * Equivalent to Solidity's FullMath.mulDiv
+ */
+function mulDiv(a: Decimal, b: Decimal, denominator: Decimal): Decimal {
+  return a.mul(b).div(denominator);
+}
+
+/**
+ * High-precision square root using Decimal.js
+ */
+function sqrt(value: Decimal): Decimal {
+  if (value.isZero()) return new Decimal(0);
+  return value.sqrt();
+}
+
+/**
+ * Convert BigInt to Decimal for calculations
+ */
+export function bigintToDecimal(value: bigint): Decimal {
+  return new Decimal(value.toString());
+}
+
+/**
+ * Convert Decimal back to BigInt for return values
+ * Uses toFixed(0) to get full decimal representation without scientific notation
+ */
+export function decimalToBigint(value: Decimal): bigint {
+  // Use toFixed(0) to get full integer representation without scientific notation
+  const stringValue = value.floor().toFixed(0);
+  return BigInt(stringValue);
+}
+
+/**
+ * Get quote from sqrtRatioX96 using high-precision Decimal arithmetic
+ * Equivalent to Solidity's getQuoteFromSqrtRatioX96
+ * @param sqrtRatioX96 The sqrt ratio for which to compute the quote
+ * @param baseAmount Amount of base token
+ * @param baseToken Address of base token
+ * @param quoteToken Address of quote token
+ * @returns The quote amount as Decimal
+ */
+export function getQuoteFromSqrtRatioX96(
+  sqrtRatioX96: Decimal,
+  baseAmount: Decimal,
+  baseToken: `0x${string}`,
+  quoteToken: `0x${string}`
+): Decimal {
+  // Calculate quoteAmount with better precision if it doesn't overflow when multiplied by itself
+  if (sqrtRatioX96.lte(UINT128_MAX)) {
+    const ratioX192 = sqrtRatioX96.mul(sqrtRatioX96);
+    return baseToken < quoteToken
+      ? mulDiv(ratioX192, baseAmount, Q192)
+      : mulDiv(Q192, baseAmount, ratioX192);
+  } else {
+    const ratioX128 = mulDiv(sqrtRatioX96, sqrtRatioX96, Q64);
+    return baseToken < quoteToken
+      ? mulDiv(ratioX128, baseAmount, Q128)
+      : mulDiv(Q128, baseAmount, ratioX128);
+  }
+}
+
+/**
+ * Applies slippage protection to sqrtPriceX96 based on swap direction using high-precision arithmetic
+ * Equivalent to Solidity's applySlippageProtection function
+ * @param sqrtPriceX96 The current square root price
+ * @param slippageBP Slippage protection in basis points (e.g., 300 = 3%)
+ * @param zeroForOne True if swapping token0 for token1
+ * @param token0 Address of token0
+ * @param token1 Address of token1
+ * @param publicClient Viem public client for reading token decimals
+ * @returns The price limit with slippage protection as Decimal
+ */
+async function applySlippageProtection(
+  sqrtPriceX96: Decimal,
+  slippageBP: Decimal,
+  zeroForOne: boolean,
+  token0: `0x${string}`,
+  token1: `0x${string}`,
+  publicClient: PublicClient
+): Promise<Decimal> {
+  // Get current price: how much token1 per 1 unit of token0
+  const decimals0 = await publicClient.readContract({
+    address: token0,
+    abi: erc20Abi,
+    functionName: 'decimals'
+  }) as number;
+  
+  const baseAmount = new Decimal(10).pow(decimals0);
+  
+  const currentQuote = getQuoteFromSqrtRatioX96(
+    sqrtPriceX96,
+    baseAmount,
+    token0,
+    token1
+  );
+  
+  let adjustedQuote: Decimal;
+  
+  if (zeroForOne) {
+    // Swapping token0 for token1
+    // We want to ensure we don't get less than expected token1
+    // So we set a minimum acceptable rate (decrease the quote)
+    adjustedQuote = mulDiv(currentQuote, BASIS_POINTS.sub(slippageBP), BASIS_POINTS);
+  } else {
+    // Swapping token1 for token0  
+    // We want to ensure we don't pay more than expected token1
+    // So we set a maximum acceptable rate (increase the quote)
+    adjustedQuote = mulDiv(currentQuote, BASIS_POINTS.add(slippageBP), BASIS_POINTS);
+  }
+  
+  if (adjustedQuote.isZero()) {
+    throw new Error('AdjustedQuoteCalculationFailed');
+  }
+  
+  // Convert adjusted quote back to sqrtPriceX96
+  // This is the reverse of getQuoteFromSqrtRatioX96
+  let adjustedRatioX192: Decimal;
+  if (token0 < token1) {
+    // ratioX192 = (adjustedQuote * 2^192) / baseAmount
+    adjustedRatioX192 = mulDiv(adjustedQuote, Q192, baseAmount);
+  } else {
+    // ratioX192 = (baseAmount * 2^192) / adjustedQuote  
+    adjustedRatioX192 = mulDiv(baseAmount, Q192, adjustedQuote);
+  }
+  
+  return sqrt(adjustedRatioX192);
+}
+
+/**
+ * Calculates the sqrt price limit for slippage protection during swaps using high-precision arithmetic
+ * 
+ * @param publicClient - Viem public client for blockchain reads
+ * @param params - Parameters for limit price calculation
+ * @returns Promise resolving to the calculated sqrt price limit
+ * 
+ * @example
+ * ```typescript
+ * const result = await calculateLimitPrice(publicClient, {
+ *   pool: '0x...',
+ *   slippageBP: 500, // 5% slippage
+ *   zeroForOne: true,
+ *   ammType: AMMType.UniswapV3,
+ *   token0: '0x...',
+ *   token1: '0x...'
+ * });
+ * 
+ * if (result.success) {
+ *   console.log('Sqrt price limit:', result.data);
+ * }
+ * ```
+ */
+export async function calculateLimitPrice(
+  publicClient: PublicClient,
+  params: CalculateLimitPriceParams
+): Promise<SteerResponse<bigint>> {
+  try {
+    // Get current pool state from slot0
+    const slot0Data = await getPoolState(
+      publicClient,
+      {
+        poolAddress: params.pool,
+        isAlgebraPool: params.ammType === AMMType.Algebra,
+        isAlgebraIntegralPool: params.ammType === AMMType.AlgebraIntegral,
+        isAlgebraDirectionPool: params.ammType === AMMType.AlgebraDirectional,
+        isPoolSharkPool: false // PoolShark not defined in AMMType enum
+      }
+    );
+
+    if (!slot0Data.success || !slot0Data.data) {
+      throw new Error(slot0Data.error || 'Failed to get pool state');
+    }
+
+    const sqrtPriceX96BigInt = getPoolPrice(slot0Data.data, {
+      isAlgebraPool: params.ammType === AMMType.Algebra,
+      isAlgebraIntegralPool: params.ammType === AMMType.AlgebraIntegral,
+      isPoolSharkPool: false // PoolShark not defined in AMMType enum
+    });
+
+    if (!sqrtPriceX96BigInt) {
+      throw new Error('Failed to extract pool price');
+    }
+    
+    // Convert to Decimal for high-precision calculations
+    const sqrtPriceX96 = bigintToDecimal(sqrtPriceX96BigInt);
+    const slippageBP = new Decimal(params.slippageBP);
+
+    // Apply slippage protection using high-precision arithmetic
+    const limitSqrtPriceX96Decimal = await applySlippageProtection(
+      sqrtPriceX96,
+      slippageBP,
+      params.zeroForOne,
+      params.token0,
+      params.token1,
+      publicClient
+    );
+
+    return {
+      data: decimalToBigint(limitSqrtPriceX96Decimal),
+      status: 200,
+      success: true
+    };
+  } catch (error) {
+    return {
+      data: null,
+      status: 500,
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to calculate limit price'
+    };
+  }
+}
+
+/**
+ * Gets the current pool state from slot0
+ * Currently supports UniswapV3 only
+ * 
+ * @param publicClient - Viem public client for blockchain reads
+ * @param poolAddress - Address of the pool
+ * @param ammType - Type of AMM
+ * @returns Promise resolving to the pool slot0 data
+ */
+export async function getPoolSlot0(
+  publicClient: PublicClient,
+  poolAddress: `0x${string}`,
+  ammType: AMMType
+): Promise<SteerResponse<PoolSlot0>> {
+  try {
+    const poolState = await getPoolStateWithPrice(publicClient, {
+      poolAddress,
+      isAlgebraPool: ammType === AMMType.Algebra,
+      isAlgebraIntegralPool: ammType === AMMType.AlgebraIntegral,
+      isAlgebraDirectionPool: ammType === AMMType.AlgebraDirectional,
+      isPoolSharkPool: false // PoolShark not defined in AMMType enum
+    });
+
+    if (!poolState.success || !poolState.data) {
+      throw new Error(poolState.error || 'Failed to get pool state');
+    }
+
+    return {
+      data: poolState.data.state as PoolSlot0,
+      status: 200,
+      success: true
+    };
+  } catch (error) {
+    return {
+      data: null,
+      status: 500,
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to get pool slot0 data'
+    };
+  }
+} 

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

@@ -0,0 +1,74 @@
+import type { PublicClient } from 'viem';
+import { singleTokenDepositAbi } from '../../../const/abis/singleTokenDeposit.js';
+import { SteerResponse } from '../../../types.js';
+import type { CalculateSwapAmountParams, SwapAmountResponse } from './types.js';
+import { getContractAddressByChainIdAndContractName } from '../../../const/index.js';
+
+/**
+ * Calculates the amount that needs to be swapped for a single-asset deposit
+ * This function calls the smart contract's calculateSwapAmount function
+ * 
+ * @param publicClient - Viem public client for blockchain reads
+ * @param params - Parameters for swap amount calculation
+ * @returns Promise resolving to swap amount and current sqrt price
+ * 
+ * @example
+ * ```typescript
+ * const result = await calculateSwapAmount(publicClient, {
+ *   depositAmount: parseEther('100'),
+ *   isToken0: true,
+ *   vault: '0x...',
+ *   pool: '0x...',
+ *   ammType: AMMType.UniswapV3,
+ *   singleAssetDepositContract: '0x...'
+ * });
+ * 
+ * if (result.success) {
+ *   console.log('Swap amount:', result.data.swapAmount);
+ *   console.log('Current sqrt price:', result.data.sqrtPrice);
+ * }
+ * ```
+ */
+export async function calculateSwapAmount(
+  publicClient: PublicClient,
+  params: CalculateSwapAmountParams
+): Promise<SteerResponse<SwapAmountResponse>> {
+  try {
+    // Call the smart contract's calculateSwapAmount function
+
+    const chainId = await publicClient.getChainId();
+    const singleAssentDeposit = params.singleAssetDepositContract || getContractAddressByChainIdAndContractName(chainId, 'SingleAssetDeposit')
+
+    const result = await publicClient.readContract({
+      address: singleAssentDeposit,
+      abi: singleTokenDepositAbi,
+      functionName: 'calculateSwapAmount',
+      args: [
+        params.depositAmount,
+        params.isToken0,
+        params.vault,
+        params.pool,
+        params.ammType
+      ]
+    });
+
+    // The contract returns [swapAmount, sqrtPrice]
+    const [swapAmount, sqrtPrice] = result as [bigint, bigint];
+
+    return {
+      data: {
+        swapAmount,
+        sqrtPrice
+      },
+      status: 200,
+      success: true
+    };
+  } catch (error) {
+    return {
+      data: null,
+      status: 500,
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to calculate swap amount'
+    };
+  }
+}