@steerprotocol/sdk 1.31.0 → 2.0.0

package/src/base/vault/utils.ts

@@ -1,633 +0,0 @@
-import { Address, PublicClient } from 'viem';
-import { PoolSharkGlobalState, Slot0, SteerResponse } from '../../types.js';
-
-/**
- * Parameters for getting pool state across different AMM types
- */
-export interface PoolStateParams {
-  /** The pool address */
-  poolAddress: Address;
-  /** Whether the pool is an Algebra pool */
-  isAlgebraPool?: boolean;
-  /** Whether the pool is an Algebra directional pool */
-  isAlgebraDirectionPool?: boolean;
-  /** Whether the pool is a PoolShark pool */
-  isPoolSharkPool?: boolean;
-  /** Whether the pool is an Algebra Integral pool */
-  isAlgebraIntegralPool?: boolean;
-}
-
-// const SLOT0_ABI: any = [
-//   {
-//     inputs: [],
-//     name: 'slot0',
-//     outputs: [
-//       { internalType: 'uint160', name: 'sqrtPriceX96', type: 'uint160' },
-//       { internalType: 'int24', name: 'tick', type: 'int24' },
-//       { internalType: 'uint16', name: 'observationIndex', type: 'uint16' },
-//       { internalType: 'uint16', name: 'observationCardinality', type: 'uint16' },
-//       { internalType: 'uint16', name: 'observationCardinalityNext', type: 'uint16' },
-//       { internalType: 'uint8', name: 'feeProtocol', type: 'uint8' },
-//       { internalType: 'bool', name: 'unlocked', type: 'bool' },
-//     ],
-//     stateMutability: 'view',
-//     type: 'function',
-//   },
-// ] as const;
-
-const GLOBAL_STATE_ABI = [
-  {
-    inputs: [],
-    name: 'globalState',
-    outputs: [
-      { internalType: 'uint160', name: 'price', type: 'uint160' },
-      { internalType: 'int24', name: 'tick', type: 'int24' },
-      { internalType: 'int24', name: 'prevInitializedTick', type: 'int24' },
-      { internalType: 'uint16', name: 'fee', type: 'uint16' },
-      { internalType: 'uint16', name: 'timepointIndex', type: 'uint16' },
-      { internalType: 'uint8', name: 'communityFee', type: 'uint8' },
-      { internalType: 'bool', name: 'unlocked', type: 'bool' },
-    ],
-    stateMutability: 'view',
-    type: 'function',
-  },
-] as const;
-
-const GLOBAL_STATE_ABI_INTEGRAL_V_1 = [
-  {
-    inputs: [],
-    name: 'globalState',
-    outputs: [
-      {
-        internalType: 'uint160',
-        name: 'price',
-        type: 'uint160',
-      },
-      {
-        internalType: 'int24',
-        name: 'tick',
-        type: 'int24',
-      },
-      {
-        internalType: 'uint16',
-        name: 'lastFee',
-        type: 'uint16',
-      },
-      {
-        internalType: 'uint8',
-        name: 'pluginConfig',
-        type: 'uint8',
-      },
-      {
-        internalType: 'uint16',
-        name: 'communityFee',
-        type: 'uint16',
-      },
-      {
-        internalType: 'bool',
-        name: 'unlocked',
-        type: 'bool',
-      },
-    ],
-    stateMutability: 'view',
-    type: 'function',
-  },
-] as const;
-
-const GLOBAL_STATE_DIRECTIONAL_ABI = [
-  {
-    inputs: [],
-    name: 'globalState',
-    outputs: [
-      { internalType: 'uint160', name: 'price', type: 'uint160' },
-      { internalType: 'int24', name: 'tick', type: 'int24' },
-      { internalType: 'uint16', name: 'feeZto', type: 'uint16' },
-      { internalType: 'uint16', name: 'feeOtz', type: 'uint16' },
-      { internalType: 'uint16', name: 'timepointIndex', type: 'uint16' },
-      { internalType: 'uint8', name: 'communityFeeToken0', type: 'uint8' },
-      { internalType: 'uint8', name: 'communityFeeToken1', type: 'uint8' },
-      { internalType: 'bool', name: 'unlocked', type: 'bool' },
-    ],
-    stateMutability: 'view',
-    type: 'function',
-  },
-] as const;
-
-const POOLSHARK_GLOBAL_STATE_ABI = [
-  {
-    inputs: [],
-    name: 'globalState',
-    outputs: [
-      {
-        components: [
-          {
-            components: [
-              { internalType: 'uint16', name: 'index', type: 'uint16' },
-              { internalType: 'uint16', name: 'count', type: 'uint16' },
-              { internalType: 'uint16', name: 'countMax', type: 'uint16' },
-            ],
-            internalType: 'struct PoolsharkStructs.SampleState',
-            name: 'samples',
-            type: 'tuple',
-          },
-          { internalType: 'uint200', name: 'feeGrowthGlobal0', type: 'uint200' },
-          { internalType: 'uint200', name: 'feeGrowthGlobal1', type: 'uint200' },
-          { internalType: 'uint160', name: 'secondsPerLiquidityAccum', type: 'uint160' },
-          { internalType: 'uint160', name: 'price', type: 'uint160' },
-          { internalType: 'uint128', name: 'liquidity', type: 'uint128' },
-          { internalType: 'int56', name: 'tickSecondsAccum', type: 'int56' },
-          { internalType: 'int24', name: 'tickAtPrice', type: 'int24' },
-          { internalType: 'uint16', name: 'protocolSwapFee0', type: 'uint16' },
-          { internalType: 'uint16', name: 'protocolSwapFee1', type: 'uint16' },
-        ],
-        internalType: 'struct PoolsharkStructs.RangePoolState',
-        name: 'pool',
-        type: 'tuple',
-      },
-      {
-        components: [
-          { internalType: 'uint160', name: 'price', type: 'uint160' },
-          { internalType: 'uint128', name: 'liquidity', type: 'uint128' },
-          { internalType: 'uint128', name: 'protocolFees', type: 'uint128' },
-          { internalType: 'uint16', name: 'protocolFillFee', type: 'uint16' },
-          { internalType: 'int24', name: 'tickAtPrice', type: 'int24' },
-        ],
-        internalType: 'struct PoolsharkStructs.LimitPoolState',
-        name: 'pool0',
-        type: 'tuple',
-      },
-      {
-        components: [
-          { internalType: 'uint160', name: 'price', type: 'uint160' },
-          { internalType: 'uint128', name: 'liquidity', type: 'uint128' },
-          { internalType: 'uint128', name: 'protocolFees', type: 'uint128' },
-          { internalType: 'uint16', name: 'protocolFillFee', type: 'uint16' },
-          { internalType: 'int24', name: 'tickAtPrice', type: 'int24' },
-        ],
-        internalType: 'struct PoolsharkStructs.LimitPoolState',
-        name: 'pool1',
-        type: 'tuple',
-      },
-      { internalType: 'uint128', name: 'liquidityGlobal', type: 'uint128' },
-      { internalType: 'uint32', name: 'positionIdNext', type: 'uint32' },
-      { internalType: 'uint32', name: 'epoch', type: 'uint32' },
-      { internalType: 'uint8', name: 'unlocked', type: 'uint8' },
-    ],
-    stateMutability: 'view',
-    type: 'function',
-  },
-] as const;
-
-/**
- * Gets slot0 data from a standard Uniswap V3 pool
- * @param poolAddress The pool address
- */
-export async function getSlot0(
-  publicClient: PublicClient,
-  poolAddress: Address
-): Promise<SteerResponse<Slot0>> {
-  try {
-    const slot0 = await publicClient.readContract({
-      address: poolAddress,
-      abi: [
-        {
-          inputs: [],
-          name: 'slot0',
-          outputs: [
-            { internalType: 'uint160', name: 'sqrtPriceX96', type: 'uint160' },
-            { internalType: 'int24', name: 'tick', type: 'int24' },
-            { internalType: 'uint16', name: 'observationIndex', type: 'uint16' },
-            { internalType: 'uint16', name: 'observationCardinality', type: 'uint16' },
-            { internalType: 'uint16', name: 'observationCardinalityNext', type: 'uint16' },
-            { internalType: 'uint8', name: 'feeProtocol', type: 'uint8' },
-            { internalType: 'bool', name: 'unlocked', type: 'bool' },
-          ],
-          stateMutability: 'view',
-          type: 'function',
-        },
-      ],
-      functionName: 'slot0',
-    });
-
-    return {
-      data: {
-        sqrtPriceX96: slot0[0],
-        tick: Number(slot0[1]),
-        observationIndex: slot0[2],
-        observationCardinality: slot0[3],
-        observationCardinalityNext: slot0[4],
-        feeProtocol: slot0[5],
-        unlocked: slot0[6],
-      },
-      status: 200,
-      success: true,
-    };
-  } catch (error) {
-    return {
-      data: null,
-      status: 500,
-      success: false,
-      error: error instanceof Error ? error.message : 'Unknown error occurred',
-    };
-  }
-}
-
-/**
- * Gets global state from an Algebra pool
- * @param poolAddress The pool address
- * @param isDirectional Whether the pool is directional
- */
-export async function getGlobalState(
-  publicClient: PublicClient,
-  poolAddress: Address,
-  isDirectional = false
-): Promise<SteerResponse<Slot0>> {
-  try {
-    try {
-      const globalState = await publicClient.readContract({
-        address: poolAddress,
-        abi: isDirectional ? GLOBAL_STATE_DIRECTIONAL_ABI : GLOBAL_STATE_ABI,
-        functionName: 'globalState',
-      });
-
-      return {
-        data: {
-          price: globalState[0],
-          tick: Number(globalState[1]),
-          observationIndex: globalState[4], // timepointIndex
-          observationCardinality: 0, // Not available in Algebra
-          observationCardinalityNext: 0, // Not available in Algebra
-          feeProtocol: isDirectional ? Number(globalState[2]) : Number(globalState[3]), // fee or feeZto
-          unlocked: Boolean(globalState[isDirectional ? 7 : 6]),
-        },
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      const globalState = await publicClient.readContract({
-        address: poolAddress,
-        abi: GLOBAL_STATE_ABI_INTEGRAL_V_1,
-        functionName: 'globalState',
-      });
-
-      return {
-        data: {
-          price: globalState[0],
-          tick: Number(globalState[1]),
-          observationIndex: 0,
-          observationCardinality: 0,
-          observationCardinalityNext: 0,
-          feeProtocol: 0,
-          unlocked: false,
-        },
-        status: 200,
-        success: true,
-      };
-    }
-  } catch (error) {
-    return {
-      data: null,
-      status: 500,
-      success: false,
-      error: error instanceof Error ? error.message : 'Unknown error occurred',
-    };
-  }
-}
-
-/**
- * Gets global state from a PoolShark pool
- * @param poolAddress The pool address
- */
-export async function getGlobalStatePoolShark(
-  publicClient: PublicClient,
-  poolAddress: Address
-): Promise<SteerResponse<PoolSharkGlobalState>> {
-  try {
-    const globalState = await publicClient.readContract({
-      address: poolAddress,
-      abi: POOLSHARK_GLOBAL_STATE_ABI,
-      functionName: 'globalState',
-    });
-
-    return {
-      data: {
-        pool: {
-          samples: {
-            index: globalState[0].samples.index,
-            count: globalState[0].samples.count,
-            countMax: globalState[0].samples.countMax,
-          },
-          feeGrowthGlobal0: globalState[0].feeGrowthGlobal0,
-          feeGrowthGlobal1: globalState[0].feeGrowthGlobal1,
-          secondsPerLiquidityAccum: globalState[0].secondsPerLiquidityAccum,
-          price: globalState[0].price,
-          liquidity: globalState[0].liquidity,
-          tickSecondsAccum: Number(globalState[0].tickSecondsAccum),
-          tickAtPrice: globalState[0].tickAtPrice,
-          protocolSwapFee0: globalState[0].protocolSwapFee0,
-          protocolSwapFee1: globalState[0].protocolSwapFee1,
-        },
-        pool0: {
-          price: globalState[1].price,
-          liquidity: globalState[1].liquidity,
-          protocolFees: globalState[1].protocolFees,
-          protocolFillFee: globalState[1].protocolFillFee,
-          tickAtPrice: globalState[1].tickAtPrice,
-        },
-        pool1: {
-          price: globalState[2].price,
-          liquidity: globalState[2].liquidity,
-          protocolFees: globalState[2].protocolFees,
-          protocolFillFee: globalState[2].protocolFillFee,
-          tickAtPrice: globalState[2].tickAtPrice,
-        },
-        liquidityGlobal: globalState[3],
-        positionIdNext: Number(globalState[4]),
-        epoch: Number(globalState[5]),
-        unlocked: Number(globalState[6]),
-      },
-      status: 200,
-      success: true,
-    };
-  } catch (error) {
-    return {
-      data: null,
-      status: 500,
-      success: false,
-      error: error instanceof Error ? error.message : 'Unknown error occurred',
-    };
-  }
-}
-
-/**
- * Gets global state from an Algebra Integral pool
- * @param poolAddress The pool address
- * @param isDirectional Whether the pool is directional
- */
-export async function getGlobalStateAlgebraIntegral(
-  publicClient: PublicClient,
-  poolAddress: Address,
-  isDirectional = false
-): Promise<SteerResponse<Slot0>> {
-  try {
-    try {
-      const globalState = await publicClient.readContract({
-        address: poolAddress,
-        abi: isDirectional ? GLOBAL_STATE_DIRECTIONAL_ABI : GLOBAL_STATE_ABI,
-        functionName: 'globalState',
-      });
-
-      return {
-        data: {
-          price: globalState[0],
-          tick: Number(globalState[1]),
-          observationIndex: globalState[4], // timepointIndex
-          observationCardinality: 0, // Not available in Algebra Integral
-          observationCardinalityNext: 0, // Not available in Algebra Integral
-          feeProtocol: isDirectional ? Number(globalState[2]) : Number(globalState[3]), // fee or feeZto
-          unlocked: Boolean(globalState[isDirectional ? 7 : 6]),
-        },
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      const globalState = await publicClient.readContract({
-        address: poolAddress,
-        abi: GLOBAL_STATE_ABI_INTEGRAL_V_1,
-        functionName: 'globalState',
-      });
-
-      return {
-        data: {
-          price: globalState[0],
-          tick: Number(globalState[1]),
-          observationIndex: 0,
-          observationCardinality: 0,
-          observationCardinalityNext: 0,
-          feeProtocol: 0,
-          unlocked: false,
-        },
-        status: 200,
-        success: true,
-      };
-    }
-  } catch (error) {
-    return {
-      data: null,
-      status: 500,
-      success: false,
-      error: error instanceof Error ? error.message : 'Unknown error occurred',
-    };
-  }
-}
-
-/**
- * Unified method to get pool state across different AMM types
- * Automatically calls the correct function based on pool type parameters
- *
- * @param publicClient - The public client for blockchain reads
- * @param params - Parameters specifying the pool and its type
- * @returns Promise resolving to standardized pool state data
- *
- * @example
- * ```typescript
- * // For Uniswap V3 pool
- * const uniV3State = await getPoolState(publicClient, {
- *   poolAddress: '0x...',
- * });
- *
- * // For Algebra pool
- * const algebraState = await getPoolState(publicClient, {
- *   poolAddress: '0x...',
- *   isAlgebraPool: true,
- *   isAlgebraDirectionPool: false
- * });
- *
- * // For PoolShark pool
- * const poolSharkState = await getPoolState(publicClient, {
- *   poolAddress: '0x...',
- *   isPoolSharkPool: true
- * });
- * ```
- */
-export async function getPoolState(
-  publicClient: PublicClient,
-  params: PoolStateParams
-): Promise<SteerResponse<Slot0>> {
-  try {
-    let stateResponse: SteerResponse<Slot0 | PoolSharkGlobalState>;
-
-    // Handle different protocol types following the same logic as getPoolInstance
-    if (params.isAlgebraIntegralPool) {
-      // For Algebra Integral pools
-      stateResponse = await getGlobalStateAlgebraIntegral(
-        publicClient,
-        params.poolAddress,
-        params.isAlgebraDirectionPool || false
-      );
-    } else if (params.isPoolSharkPool) {
-      // For PoolShark pools - convert to standardized format
-      const poolSharkResponse = await getGlobalStatePoolShark(publicClient, params.poolAddress);
-      if (poolSharkResponse.success && poolSharkResponse.data) {
-        stateResponse = {
-          success: true,
-          status: 200,
-          data: {
-            sqrtPriceX96: poolSharkResponse.data.pool.price,
-            tick: poolSharkResponse.data.pool.tickAtPrice,
-            observationIndex: 0,
-            observationCardinality: 0,
-            observationCardinalityNext: 0,
-            feeProtocol: 0,
-            unlocked: poolSharkResponse.data.unlocked === 1,
-          },
-        };
-      } else {
-        stateResponse = {
-          data: null,
-          status: poolSharkResponse.status,
-          success: false,
-          error: poolSharkResponse.error,
-        };
-      }
-    } else if (params.isAlgebraPool) {
-      // For Algebra pools
-      stateResponse = await getGlobalState(
-        publicClient,
-        params.poolAddress,
-        params.isAlgebraDirectionPool || false
-      );
-    } else {
-      // For standard Uniswap V3 pools
-
-      stateResponse = await getSlot0(publicClient, params.poolAddress);
-    }
-
-    if (!stateResponse.success || !stateResponse.data) {
-      throw new Error(stateResponse.error || 'Failed to read pool state');
-    }
-
-    return {
-      data: stateResponse.data as Slot0,
-      status: 200,
-      success: true,
-    };
-  } catch (error) {
-    return {
-      data: null,
-      status: 500,
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to get pool state',
-    };
-  }
-}
-
-/**
- * Extracts the appropriate price value from pool state based on AMM type
- * Different AMM protocols store price information in different fields
- *
- * @param poolStateData - The pool state data returned from getPoolState
- * @param params - Pool type parameters to determine which price field to use
- * @returns The price as bigint, or null if price cannot be extracted
- *
- * @example
- * ```typescript
- * const stateResponse = await getPoolState(publicClient, {
- *   poolAddress: '0x...',
- *   isAlgebraPool: true
- * });
- *
- * if (stateResponse.success && stateResponse.data) {
- *   const price = getPoolPrice(stateResponse.data, {
- *     isAlgebraPool: true,
- *     isAlgebraDirectionPool: false
- *   });
- *   console.log('Pool price:', price);
- * }
- * ```
- */
-export function getPoolPrice(
-  poolStateData: Slot0,
-  params: Pick<PoolStateParams, 'isAlgebraPool' | 'isAlgebraIntegralPool' | 'isPoolSharkPool'>
-): bigint | null {
-  try {
-    let price: bigint | undefined;
-
-    // Extract price based on AMM type - following the same logic as getPoolInstance
-    if (params.isAlgebraPool && !params.isAlgebraIntegralPool) {
-      // For Algebra pools (non-integral)
-      price = poolStateData?.price;
-    } else if (params.isAlgebraIntegralPool) {
-      // For Algebra Integral pools
-      price = poolStateData?.price;
-    } else if (params.isPoolSharkPool) {
-      // For PoolShark pools - price is stored in a nested structure
-      price = (poolStateData.tick as unknown as { price: bigint })?.price;
-    } else {
-      // For standard Uniswap V3 pools
-      price = poolStateData.sqrtPriceX96;
-    }
-
-    return price || null;
-  } catch (error) {
-    console.error('Error extracting pool price:', error);
-    return null;
-  }
-}
-
-/**
- * Combined method to get both pool state and extract price in one call
- * Convenience method that combines getPoolState and getPoolPrice
- *
- * @param publicClient - The public client for blockchain reads
- * @param params - Parameters specifying the pool and its type
- * @returns Promise resolving to object containing both state and price
- *
- * @example
- * ```typescript
- * const result = await getPoolStateWithPrice(publicClient, {
- *   poolAddress: '0x...',
- *   isAlgebraPool: true
- * });
- *
- * if (result.success && result.data) {
- *   console.log('Pool state:', result.data.state);
- *   console.log('Pool price:', result.data.price);
- * }
- * ```
- */
-export async function getPoolStateWithPrice(
-  publicClient: PublicClient,
-  params: PoolStateParams
-): Promise<SteerResponse<{ state: Slot0; price: bigint | null }>> {
-  try {
-    const stateResponse = await getPoolState(publicClient, params);
-
-    if (!stateResponse.success || !stateResponse.data) {
-      return {
-        data: null,
-        status: stateResponse.status,
-        success: false,
-        error: stateResponse.error || 'Failed to get pool state',
-      };
-    }
-
-    const price = getPoolPrice(stateResponse.data, params);
-
-    return {
-      data: {
-        state: stateResponse.data,
-        price,
-      },
-      status: 200,
-      success: true,
-    };
-  } catch (error) {
-    return {
-      data: null,
-      status: 500,
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to get pool state with price',
-    };
-  }
-}