@steerprotocol/sdk 1.26.0 → 1.28.0

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

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