@steerprotocol/sdk 1.26.0 → 1.28.0

package/src/base/vault/utils.ts

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