@steerprotocol/sdk 1.31.0 → 2.0.1

package/src/base/vault/deposit/index.ts

@@ -1,705 +0,0 @@
-import { Rounding, Token } from '@uniswap/sdk-core';
-import { Pool as PoolV3 } from '@uniswap/v3-sdk';
-import { Decimal } from 'decimal.js';
-import { Address, Hash, PublicClient, WalletClient } from 'viem';
-import { UniswapV3PoolABI } from '../../../const/abis/UniswapPool.js';
-import { abis } from '../../../const/deployments/abis.js';
-import { getContractAddressByChainIdAndContractName } from '../../../const/network.js';
-import { isAlgebraDirectionProtocol, isAlgebraIntegralProtocol, isAlgebraProtocol, isPoolSharkProtocol } from '../../../const/protocol.js';
-import { AlgebraVaultDetails, PoolData, SteerResponse, VaultDetails } from '../../../types.js';
-import { getGlobalState, getGlobalStateAlgebraIntegral, getGlobalStatePoolShark, getSlot0 } from '../utils.js';
-import { DepositRatioResponse, PoolInstanceParams, VaultDepositParams } from './types.js';
-import { getProtocolTypeByBeacon } from "../../../const/index.js";
-
-const VAULT_ABI = abis.QuickSwapUniv3MultiPositionLiquidityManager;
-const PERIPHERY_ABI = abis.SteerPeriphery;
-
-export class VaultDepositClient {
-  constructor(
-    protected readonly publicClient: PublicClient,
-    protected readonly walletClient: WalletClient
-  ) {}
-
-  /**
-   * Deposits tokens into a vault
-   * @param params The deposit parameters
-   */
-  public async deposit(params: VaultDepositParams): Promise<SteerResponse<Hash>> {
-    try {
-      const account = await this.walletClient.getAddresses();
-      if (!account[0]) throw new Error('No account found');
-
-      // Calculate min amounts based on slippage
-      const amount0Min =
-        (params.amount0Desired * BigInt(Math.floor((1 - params.slippage) * 1000))) / 1000n;
-      const amount1Min =
-        (params.amount1Desired * BigInt(Math.floor((1 - params.slippage) * 1000))) / 1000n;
-
-      let hash: Hash;
-
-      // If using Steer Periphery
-      if (params.isSteerPeriphery) {
-        if (!params.chainId) {
-          throw new Error('chainId is required when using Steer Periphery');
-        }
-
-        const steerPeripheryAddress = getContractAddressByChainIdAndContractName(
-          params.chainId,
-          'SteerPeriphery'
-        );
-
-        if (!steerPeripheryAddress) {
-          throw new Error(`SteerPeriphery address not found for chainId: ${params.chainId}`);
-        }
-
-        const { request } = await this.publicClient.simulateContract({
-          address: steerPeripheryAddress as Address,
-          abi: PERIPHERY_ABI,
-          functionName: 'deposit',
-          args: [
-            params.vaultAddress,
-            params.amount0Desired,
-            params.amount1Desired,
-            amount0Min,
-            amount1Min,
-            params.to ?? account[0],
-          ],
-          account: account[0],
-        });
-        hash = await this.walletClient.writeContract(request);
-      } else {
-        // Regular vault deposit
-        const { request } = await this.publicClient.simulateContract({
-          address: params.vaultAddress,
-          abi: VAULT_ABI,
-          functionName: 'deposit',
-          args: [
-            params.amount0Desired,
-            params.amount1Desired,
-            amount0Min,
-            amount1Min,
-            params.to ?? account[0],
-          ],
-          account: account[0],
-        });
-        hash = await this.walletClient.writeContract(request);
-      }
-
-      return {
-        data: hash,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Prepares the transaction data for depositing tokens into a vault without executing it
-   * @param params The deposit parameters
-   */
-  public async prepareDepositTx(params: VaultDepositParams): Promise<
-    SteerResponse<{
-      address: Address;
-      abi: {
-        type: string;
-        inputs: {
-          name: string;
-          internalType: string;
-          type: string;
-        }[];
-        name: string;
-        outputs: {
-          internalType: string;
-          name: string;
-          type: string;
-        }[];
-        stateMutability: string;
-      }[];
-      functionName: string;
-      args: readonly [Address, bigint, bigint, bigint, bigint, Address] | readonly [bigint, bigint, bigint, bigint, Address];
-    }>
-  > {
-    try {
-      const account = await this.walletClient.getAddresses();
-      if (!params.to) {
-        if (!account[0]) throw new Error('No account found');
-      }
-
-      const amount0Min = 0n;
-      const amount1Min = 0n;
-
-      // If using Steer Periphery
-      if (params.isSteerPeriphery) {
-        if (!params.chainId) {
-          throw new Error('chainId is required when using Steer Periphery');
-        }
-
-        const steerPeripheryAddress = getContractAddressByChainIdAndContractName(
-          params.chainId,
-          'SteerPeriphery'
-        );
-
-        if (!steerPeripheryAddress) {
-          throw new Error(`SteerPeriphery address not found for chainId: ${params.chainId}`);
-        }
-
-        // Steer Periphery ABI and parameters
-        return {
-          data: {
-            address: steerPeripheryAddress as Address,
-            abi: [
-              {
-                type: 'function',
-                inputs: [
-                  { name: 'vaultAddress', internalType: 'address', type: 'address' },
-                  { name: 'amount0Desired', internalType: 'uint256', type: 'uint256' },
-                  { name: 'amount1Desired', internalType: 'uint256', type: 'uint256' },
-                  { name: 'amount0Min', internalType: 'uint256', type: 'uint256' },
-                  { name: 'amount1Min', internalType: 'uint256', type: 'uint256' },
-                  { name: 'to', internalType: 'address', type: 'address' },
-                ],
-                name: 'deposit',
-                outputs: [],
-                stateMutability: 'nonpayable',
-              },
-            ],
-            functionName: 'deposit',
-            args: [
-              params.vaultAddress,
-              params.amount0Desired,
-              params.amount1Desired,
-              amount0Min,
-              amount1Min,
-              params.to ?? account[0],
-            ] as const,
-          },
-          status: 200,
-          success: true,
-        };
-      }
-
-      // Regular vault deposit
-      return {
-        data: {
-          address: params.vaultAddress,
-          abi: [
-            {
-              inputs: [
-                {
-                  internalType: 'uint256',
-                  name: 'amount0Desired',
-                  type: 'uint256',
-                },
-                {
-                  internalType: 'uint256',
-                  name: 'amount1Desired',
-                  type: 'uint256',
-                },
-                {
-                  internalType: 'uint256',
-                  name: 'amount0Min',
-                  type: 'uint256',
-                },
-                {
-                  internalType: 'uint256',
-                  name: 'amount1Min',
-                  type: 'uint256',
-                },
-                {
-                  internalType: 'address',
-                  name: 'to',
-                  type: 'address',
-                },
-              ],
-              name: 'deposit',
-              outputs: [
-                {
-                  internalType: 'uint256',
-                  name: 'shares',
-                  type: 'uint256',
-                },
-                {
-                  internalType: 'uint256',
-                  name: 'amount0Used',
-                  type: 'uint256',
-                },
-                {
-                  internalType: 'uint256',
-                  name: 'amount1Used',
-                  type: 'uint256',
-                },
-              ],
-              stateMutability: 'nonpayable',
-              type: 'function',
-            },
-          ],
-          functionName: 'deposit',
-          args: [
-            params.amount0Desired,
-            params.amount1Desired,
-            amount0Min,
-            amount1Min,
-            params.to ?? account[0],
-          ] as const,
-        },
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Gets the deposit ratio for a vault
-   * @param vaultAddress The vault address
-   */
-  public async getDepositRatio(
-    vaultAddress: Address,
-    zeroForOne: boolean
-  ): Promise<SteerResponse<DepositRatioResponse>> {
-    try {
-      // Try to get vault details, first attempt with regular vault
-      let vaultDetails: VaultDetails | AlgebraVaultDetails;
-      let isAlgebraVault = false;
-
-      const chainId = await this.publicClient.getChainId();
-
-      const steerPeripheryAddress = getContractAddressByChainIdAndContractName(
-        chainId,
-        'SteerPeriphery'
-      );
-      if (!steerPeripheryAddress) throw new Error('SteerPeriphery address not found');
-      try {
-        // First try regular vault
-        vaultDetails = (await this.publicClient.readContract({
-          address: steerPeripheryAddress as Address,
-          abi: PERIPHERY_ABI,
-          functionName: 'vaultDetailsByAddress',
-          args: [vaultAddress],
-        })) as VaultDetails;
-      } catch (error) {
-        // If regular vault fails, try Algebra vault
-        vaultDetails = (await this.publicClient.readContract({
-          address: steerPeripheryAddress as Address,
-          abi: PERIPHERY_ABI,
-          functionName: 'algebraVaultDetailsByAddress',
-          args: [vaultAddress],
-        })) as AlgebraVaultDetails;
-        isAlgebraVault = true;
-      }
-
-      const token0Balance = vaultDetails.token0Balance;
-      const token1Balance = vaultDetails.token1Balance;
-      const token0Decimals = vaultDetails.token0Decimals;
-      const token1Decimals = vaultDetails.token1Decimals;
-
-      let ratio: string;
-
-      // Case 1: No liquidity in the vault
-      if (token0Balance === 0n && token1Balance === 0n) {
-        // Get pool instance to calculate price
-        const chainId = await this.publicClient.getChainId();
-
-        // Get the pool address
-        const pool = await this.getPool(vaultAddress);
-        if (!pool.data) throw new Error('Failed to retrieve pool for ratio calculation');
-
-        // Determine the protocol
-        const protocol = getProtocolTypeByBeacon(vaultDetails.vaultType);
-        if (!protocol) throw new Error('Unsupported protocol type');
-        console.log('Protocol detected:', protocol);
-
-        // Get pool instance with the correct protocol type
-        const poolInstanceResponse = await this.getPoolInstance({
-          vaultAddress,
-          chain: { id: chainId },
-          isAlgebraPool: isAlgebraProtocol(protocol),
-          isPoolSharkPool: isPoolSharkProtocol(protocol),
-          isAlgebraIntegralPool: isAlgebraIntegralProtocol(protocol),
-          isAlgebraDirectionPool: isAlgebraDirectionProtocol(protocol),
-        });
-
-        if (!poolInstanceResponse.success || !poolInstanceResponse.data) {
-          throw new Error('Failed to get pool instance for price calculation');
-        }
-
-        const poolInstance = poolInstanceResponse.data;
-        // Get price based on zeroForOne
-        const price = zeroForOne
-          ? poolInstance.priceOf(poolInstance.token0)
-          : poolInstance.priceOf(poolInstance.token0).invert();
-
-        // Convert price to string using Decimal for maximum precision
-        ratio = price.toSignificant(undefined, undefined, Rounding.ROUND_DOWN);
-      }
-      // Case 2: Vault has liquidity
-      else {
-        // Convert bigint values to Decimal instances for precise calculation
-        // Convert bigints to strings first to avoid type errors
-        const token0Bal = new Decimal(token0Balance.toString());
-        const token1Bal = new Decimal(token1Balance.toString());
-        const token0Dec = new Decimal(10).pow(Number(token0Decimals));
-        const token1Dec = new Decimal(10).pow(Number(token1Decimals));
-
-        // Calculate adjusted balances
-        const token0Adjusted = token0Bal.div(token0Dec);
-        const token1Adjusted = token1Bal.div(token1Dec);
-
-        // Calculate ratio based on token balances
-        // If zeroForOne is true: ratio = token1/token0
-        // If zeroForOne is false: ratio = token0/token1
-        ratio = zeroForOne
-          ? token1Adjusted.div(token0Adjusted).toString() // token1/token0 ratio
-          : token0Adjusted.div(token1Adjusted).toString(); // token0/token1 ratio
-      }
-
-      return {
-        data: {
-          ratio,
-          token0Balance,
-          token1Balance,
-          token0Decimals,
-          token1Decimals,
-          vaultDetails,
-          isAlgebraVault,
-        },
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Gets the pool address for a vault
-   * @param vaultAddress The vault address
-   */
-  private async getPool(vaultAddress: Address): Promise<SteerResponse<Address>> {
-    try {
-      const pool = (await this.publicClient.readContract({
-        address: vaultAddress,
-        abi: VAULT_ABI,
-        functionName: 'pool',
-      })) as Address;
-
-      return {
-        data: pool,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Gets a pool instance for a vault
-   * @param params The pool instance parameters
-   */
-  public async getPoolInstance(params: PoolInstanceParams): Promise<SteerResponse<PoolV3>> {
-    console.log('Fetching pool instance...');
-
-    try {
-      const poolData = await this.preparePoolData(params.vaultAddress);
-      console.log('Pool data fetched:', poolData);
-
-      if (!poolData.success || !poolData.data) {
-        throw new Error('Failed to fetch pool data');
-      }
-
-      let slot0Response;
-
-      // Handle different protocol types
-      if (params.isAlgebraIntegralPool) {
-        // For Algebra Integral pools
-        slot0Response = await getGlobalStateAlgebraIntegral(
-          this.publicClient,
-          poolData.data.id,
-          params.isAlgebraDirectionPool
-        );
-      } else if (params.isPoolSharkPool) {
-        // For PoolShark pools
-        const poolSharkResponse = await getGlobalStatePoolShark(
-          this.publicClient,
-          poolData.data.id
-        );
-        if (poolSharkResponse.success && poolSharkResponse.data) {
-          slot0Response = {
-            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 {
-          slot0Response = poolSharkResponse;
-        }
-      }
-      if (params.isAlgebraPool) {
-        // For Algebra pools
-        slot0Response = await getGlobalState(
-          this.publicClient,
-          poolData.data.id,
-          params.isAlgebraDirectionPool
-        );
-      } else {
-        // For standard Uniswap V3 pools
-        slot0Response = await getSlot0(this.publicClient, poolData.data.id);
-      }
-
-      if (!slot0Response.success || !slot0Response.data) {
-        throw new Error('Failed to read pool state');
-      }
-
-      const slot0 = slot0Response.data;
-
-      const token0 = new Token(
-        params.chain.id,
-        poolData.data.token0.id,
-        Number(poolData.data.token0.decimals),
-        poolData.data.token0.symbol,
-        poolData.data.token0.name
-      );
-
-      const token1 = new Token(
-        params.chain.id,
-        poolData.data.token1.id,
-        Number(poolData.data.token1.decimals),
-        poolData.data.token1.symbol,
-        poolData.data.token1.name
-      );
-
-      // Get liquidity
-      const liquidity = await this.getPoolLiquidity(poolData.data.id);
-      if (!liquidity.success || !liquidity.data) {
-        throw new Error('Failed to fetch pool liquidity');
-      }
-
-      let price: bigint | undefined;
-
-      if (params.isAlgebraPool && !params.isAlgebraIntegralPool) {
-        price = slot0Response?.data?.price;
-      } else if (params.isAlgebraIntegralPool) {
-        price = slot0Response?.data?.price;
-      } else if (params.isPoolSharkPool) {
-        price = (slot0Response?.data?.tick as unknown as { price: bigint })?.price;
-      } else {
-        price = slot0Response?.data?.sqrtPriceX96;
-      }
-
-      if (!price) {
-        throw new Error('Failed to get pool price');
-      }
-
-      return {
-        data: new PoolV3(
-          token0,
-          token1,
-          poolData.data.feeTier,
-          price.toString(),
-          liquidity.data.toString(),
-          slot0.tick
-        ),
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      console.error('Error creating pool instance:', error);
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Gets the pool liquidity
-   * @param poolAddress The pool address
-   */
-  private async getPoolLiquidity(poolAddress: Address): Promise<SteerResponse<bigint>> {
-    try {
-      const liquidity = (await this.publicClient.readContract({
-        address: poolAddress,
-        abi: UniswapV3PoolABI,
-        functionName: 'liquidity',
-      })) as bigint;
-
-      return {
-        data: liquidity,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Gets the corresponding token amount based on the provided token amount and ratio
-   * @param vaultAddress The vault address
-   * @param amount The amount of token to calculate the corresponding amount for
-   * @param zeroForOne If true, calculates token1 amount for given token0, if false calculates token0 amount for given token1
-   */
-  public async getCorrespondingTokenAmount(
-    vaultAddress: Address,
-    amount: bigint,
-    zeroForOne: boolean
-  ): Promise<SteerResponse<bigint>> {
-    try {
-      // Get the deposit ratio for the vault
-      const ratioResponse = await this.getDepositRatio(vaultAddress, zeroForOne);
-      if (!ratioResponse.success || !ratioResponse.data) {
-        throw new Error('Failed to get deposit ratio');
-      }
-
-      const { ratio, token0Decimals, token1Decimals } = ratioResponse.data;
-
-      // Calculate the decimal adjustment based on token decimals
-      const decimalDiff = zeroForOne
-        ? token1Decimals - token0Decimals
-        : token0Decimals - token1Decimals;
-
-      // Convert all values to Decimal for precise calculation
-      const amountDecimal = new Decimal(amount.toString());
-      const ratioDecimal = new Decimal(ratio);
-      const adjustmentDecimal = new Decimal(10).pow(Number(decimalDiff));
-
-      // Perform calculation using Decimal.js
-      const result = amountDecimal.times(ratioDecimal).times(adjustmentDecimal);
-
-      // Convert result back to bigint, rounding down to nearest integer
-      // Use toFixed(0) to avoid scientific notation which BigInt cannot parse
-      const correspondingAmount = BigInt(result.floor().toFixed(0));
-
-      return {
-        data: correspondingAmount,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Prepares pool data from vault details
-   * @param vaultAddress The vault address
-   */
-  private async preparePoolData(vaultAddress: Address): Promise<SteerResponse<PoolData>> {
-    try {
-      // Try to get vault details, first attempt with regular vault
-      let vaultDetails: VaultDetails | AlgebraVaultDetails;
-
-      const chainId = await this.publicClient.getChainId();
-
-      const steerPeripheryAddress = getContractAddressByChainIdAndContractName(
-        chainId,
-        'SteerPeriphery'
-      );
-      if (!steerPeripheryAddress) throw new Error('SteerPeriphery address not found');
-
-      try {
-        // First try regular vault
-        vaultDetails = (await this.publicClient.readContract({
-          address: steerPeripheryAddress as Address,
-          abi: PERIPHERY_ABI,
-          functionName: 'vaultDetailsByAddress',
-          args: [vaultAddress],
-        })) as VaultDetails;
-      } catch (error) {
-        // If regular vault fails, try Algebra vault
-        vaultDetails = (await this.publicClient.readContract({
-          address: steerPeripheryAddress as Address,
-          abi: PERIPHERY_ABI,
-          functionName: 'algebraVaultDetailsByAddress',
-          args: [vaultAddress],
-        })) as AlgebraVaultDetails;
-      }
-
-      // Get the pool contract to fetch tick spacing
-      const pool = await this.getPool(vaultAddress);
-      if (!pool.data) throw new Error('Failed to retrieve pool');
-
-      // Get tick spacing
-      const tickSpacing = (await this.publicClient.readContract({
-        address: pool.data,
-        abi: UniswapV3PoolABI,
-        functionName: 'tickSpacing',
-      })) as number;
-
-      const poolData: PoolData = {
-        id: pool.data,
-        token0: {
-          id: vaultDetails.token0,
-          decimals: vaultDetails.token0Decimals.toString(),
-          symbol: vaultDetails.token0Symbol,
-          name: vaultDetails.token0Symbol,
-        },
-        token1: {
-          id: vaultDetails.token1,
-          decimals: vaultDetails.token1Decimals.toString(),
-          symbol: vaultDetails.token1Symbol,
-          name: vaultDetails.token1Symbol,
-        },
-        chainId: await this.publicClient.getChainId(),
-        feeTier: 3000, // Fixed fee tier as specified
-        tickSpacing,
-      };
-
-      return {
-        data: poolData,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-}