@steerprotocol/sdk 1.30.8 → 2.0.0

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

@@ -1,279 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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'
-    };
-  }
-}