@steerprotocol/sdk 1.26.0 → 1.28.0

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

@@ -0,0 +1,411 @@
+import type { Address, Hash, PublicClient, WalletClient } from 'viem';
+import { getContractAddressByChainIdAndContractName, getProtocolTypeByBeacon, Protocol } from '../../../const/index.js';
+import { singleTokenDepositAbi } from '../../../const/abis/singleTokenDeposit.js';
+import { UniswapV3PoolABI } from '../../../const/abis/UniswapPool.js';
+import { AlgebraVaultDetails, SteerResponse, VaultDetails } from '../../../types.js';
+import { calculateLimitPrice } from './calculateLimitPrice.js';
+import { calculateSwapAmount } from './calculateSwapAmount.js';
+import { estimateLpTokens } from './estimateLpTokens.js';
+import { determineSwapDirection, simulateSwapWithSlippage, SwapWithSlippageParams } from './simulateSwap.js';
+import type {
+  CalculateLimitPriceParams,
+  CalculateSwapAmountParams,
+  SingleAssetDepositParams,
+  SingleAssetDepositPreview
+} from './types.js';
+import { AMMType } from './types.js';
+import { abis } from '../../../const/deployments/abis.js';
+
+const PERIPHERY_ABI = abis.SteerPeriphery;
+
+/**
+ * Main single-asset deposit client that orchestrates all the steps
+ */
+export class SingleAssetDepositClient {
+  constructor(
+    private readonly publicClient: PublicClient,
+    private readonly walletClient: WalletClient
+  ) {}
+
+  /**
+   * Previews a single-asset deposit by running all simulation steps
+   * This allows users to see the expected outcome before executing the transaction
+   * 
+   * @param params - Single-asset deposit parameters
+   * @param poolAddress - Address of the pool (must be provided separately)
+   * @returns Promise resolving to the complete deposit preview
+   * 
+   * @example
+   * ```typescript
+   * const preview = await client.previewDeposit({
+   *   assets: parseEther('100'),
+   *   receiver: userAddress,
+   *   vault: vaultAddress,
+   *   isToken0: true,
+   *   depositSlippagePercent: 5n,
+   *   swapSlippageBP: 500,
+   *   ammType: AMMType.UniswapV3,
+   *   singleAssetDepositContract: contractAddress
+   * }, poolAddress);
+   * 
+   * if (preview.success) {
+   *   console.log('Expected LP tokens:', preview.data.lpEstimation.lpTokens);
+   *   console.log('Swap amount:', preview.data.swapAmount);
+   * }
+   * ```
+   */
+  public async previewDeposit(
+    params: SingleAssetDepositParams,
+    poolAddress: `0x${string}`
+  ): Promise<SteerResponse<SingleAssetDepositPreview>> {
+    try {
+
+      const chainId = await this.publicClient.getChainId();
+      const singleAssentDeposit = params.singleAssetDepositContract || getContractAddressByChainIdAndContractName(
+        chainId,
+        'SingleAssetDeposit'
+      )
+
+      // Step 1: Calculate swap amount
+      const swapAmountParams: CalculateSwapAmountParams = {
+        depositAmount: params.assets,
+        isToken0: params.isToken0,
+        vault: params.vault,
+        pool: poolAddress,
+        ammType: params.ammType,
+        singleAssetDepositContract: singleAssentDeposit as Address
+      };
+
+
+      const swapAmountResult = await calculateSwapAmount(this.publicClient, swapAmountParams);
+      if (!swapAmountResult.success || !swapAmountResult.data) {
+        return {
+          data: null,
+          status: swapAmountResult.status,
+          success: false,
+          error: swapAmountResult.error || 'Failed to calculate swap amount'
+        };
+      }
+
+      const { swapAmount, sqrtPrice } = swapAmountResult.data;
+      const zeroForOne = determineSwapDirection(params.isToken0);
+
+      // Get token addresses from the pool contract
+      const [token0, token1] = await Promise.all([
+        this.publicClient.readContract({
+          address: poolAddress,
+          abi: UniswapV3PoolABI,
+          functionName: 'token0'
+        }) as Promise<`0x${string}`>,
+        this.publicClient.readContract({
+          address: poolAddress,
+          abi: UniswapV3PoolABI,
+          functionName: 'token1'
+        }) as Promise<`0x${string}`>
+      ]);
+
+      // Step 2: Calculate limit price
+      const limitPriceParams: CalculateLimitPriceParams = {
+        pool: poolAddress,
+        slippageBP: params.swapSlippageBP,
+        zeroForOne,
+        ammType: params.ammType,
+        token0,
+        token1
+      };
+
+      const limitPriceResult = await calculateLimitPrice(this.publicClient, limitPriceParams);
+      if (!limitPriceResult.success || limitPriceResult.data === null) {
+        return {
+          data: null,
+          status: limitPriceResult.status,
+          success: false,
+          error: limitPriceResult.error || 'Failed to calculate limit price'
+        };
+      }
+
+      const sqrtPriceLimitX96 = limitPriceResult.data;
+
+      let fee = 3000;
+      if (params.ammType === AMMType.UniswapV3) {
+        fee = await this.publicClient.readContract({
+          address: poolAddress,
+          abi: UniswapV3PoolABI,
+          functionName: 'fee'
+        }) as number;
+      }
+      // Get pool fee from the contract
+
+      let vaultDetails: VaultDetails | AlgebraVaultDetails;
+      const steerPeripheryAddress = getContractAddressByChainIdAndContractName(chainId, 'SteerPeriphery');
+      if (!steerPeripheryAddress) throw new Error('SteerPeriphery address not found');
+
+      let protocol: Protocol | null;
+
+      try {
+        // First try regular vault
+        vaultDetails = await this.publicClient.readContract({
+          address: params.vault,
+          abi: PERIPHERY_ABI,
+          functionName: 'vaultDetailsByAddress',
+          args: [params.vault]
+        }) as VaultDetails;
+
+        protocol = getProtocolTypeByBeacon(vaultDetails.vaultType);
+      } catch (error) {
+        // If regular vault fails, try Algebra vault
+        vaultDetails = await this.publicClient.readContract({
+          address: steerPeripheryAddress as Address,
+          abi: PERIPHERY_ABI,
+          functionName: 'algebraVaultDetailsByAddress',
+          args: [params.vault]
+        }) as AlgebraVaultDetails;
+
+        protocol = getProtocolTypeByBeacon(vaultDetails.vaultType);
+      }
+      // Step 3: Simulate swap
+      const simulateSwapParams: SwapWithSlippageParams = {
+        poolAddress: poolAddress,
+        recipient: params.receiver, // For simulation, use receiver address
+        zeroForOne,
+        amountSpecified: swapAmount,
+        sqrtPriceLimitX96,
+        ammType: params.ammType,
+        tokenIn: zeroForOne ? token0 : token1,
+        tokenOut: zeroForOne ? token1 : token0,
+        fee,
+        protocol
+      };
+
+      const swapSimulationResult = await simulateSwapWithSlippage(
+        this.publicClient, 
+        simulateSwapParams, 
+        this.publicClient.chain?.id || 1 // Use chain ID from public client, fallback to mainnet
+      );
+      if (!swapSimulationResult.success || !swapSimulationResult.data) {
+        return {
+          data: null,
+          status: swapSimulationResult.status,
+          success: false,
+          error: swapSimulationResult.error || 'Failed to simulate swap'
+        };
+      }
+
+      const swapSimulation = swapSimulationResult.data;
+
+      // Step 4: Estimate LP tokens
+      const lpEstimationResult = await estimateLpTokens(this.publicClient, {
+        vault: params.vault,
+        originalAssets: params.assets,
+        swapAmount,
+        swapResult: swapSimulation.swapSimulation,
+        isToken0: params.isToken0
+      });
+
+      if (!lpEstimationResult.success || !lpEstimationResult.data) {
+        return {
+          data: null,
+          status: lpEstimationResult.status,
+          success: false,
+          error: lpEstimationResult.error || 'Failed to estimate LP tokens'
+        };
+      }
+
+      const lpEstimation = lpEstimationResult.data;
+
+      return {
+        data: {
+          swapAmount,
+          currentSqrtPrice: sqrtPrice,
+          sqrtPriceLimitX96,
+          swapSimulation,
+          lpEstimation,
+          zeroForOne
+        },
+        status: 200,
+        success: true
+      };
+
+    } catch (error) {
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to preview single-asset deposit'
+      };
+    }
+  }
+
+  /**
+   * Executes a single-asset deposit transaction
+   * 
+   * @param params - Single-asset deposit parameters
+   * @returns Promise resolving to the transaction hash
+   * 
+   * @example
+   * ```typescript
+   * const result = await client.deposit({
+   *   assets: parseEther('100'),
+   *   receiver: userAddress,
+   *   vault: vaultAddress,
+   *   isToken0: true,
+   *   depositSlippagePercent: 5n,
+   *   swapSlippageBP: 500,
+   *   ammType: AMMType.UniswapV3,
+   *   singleAssetDepositContract: contractAddress
+   * });
+   * 
+   * if (result.success) {
+   *   console.log('Transaction hash:', result.data);
+   * }
+   * ```
+   */
+  public async deposit(params: SingleAssetDepositParams): Promise<SteerResponse<Hash>> {
+    try {
+      const account = await this.walletClient.getAddresses();
+      if (!account[0]) {
+        throw new Error('No account found');
+      }
+
+      const singleAssentDeposit = params.singleAssetDepositContract || getContractAddressByChainIdAndContractName(
+        this.publicClient.chain?.id || 1,
+        'SingleAssetDeposit'
+      )
+
+      // Prepare the transaction
+      const { request } = await this.publicClient.simulateContract({
+        address: singleAssentDeposit as Address,
+        abi: singleTokenDepositAbi,
+        functionName: 'deposit',
+        args: [
+          params.assets,
+          params.receiver,
+          params.vault,
+          params.isToken0,
+          params.depositSlippagePercent,
+          params.swapSlippageBP,
+          params.ammType
+        ],
+        account: account[0]
+      });
+
+      // Execute the transaction
+      const 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 : 'Failed to execute single-asset deposit'
+      };
+    }
+  }
+
+  /**
+   * Prepares a single-asset deposit transaction without executing it
+   * Useful for batching transactions or custom execution logic
+   * 
+   * @param params - Single-asset deposit parameters
+   * @returns Promise resolving to the prepared transaction data
+   */
+  public async prepareDepositTx(params: SingleAssetDepositParams) {
+    try {
+      const account = await this.walletClient.getAddresses();
+      if (!account[0]) {
+        throw new Error('No account found');
+      }
+
+      const chainId = await this.publicClient.getChainId();
+
+      const singleAssentDeposit = params.singleAssetDepositContract || getContractAddressByChainIdAndContractName(
+        chainId,
+        'SingleAssetDeposit'
+      )
+      // await this.publicClient.simulateContract({
+      //   address: singleAssentDeposit as Address,
+      //   abi: singleTokenDepositAbi,
+      //   functionName: 'deposit',
+      //   args: [
+      //     params.assets,
+      //     params.receiver,
+      //     params.vault,
+      //     params.isToken0,
+      //     params.depositSlippagePercent,
+      //     params.swapSlippageBP,
+      //     params.ammType
+      //   ],
+      //   account: account[0]
+      // });
+
+      return {
+        data: {
+          address: params.singleAssetDepositContract  || singleAssentDeposit,
+          abi: singleTokenDepositAbi,
+          functionName: 'deposit' as const,
+          args: [
+            params.assets,
+            params.receiver,
+            params.vault,
+            params.isToken0,
+            params.depositSlippagePercent,
+            params.swapSlippageBP,
+            params.ammType
+          ] as const
+        },
+        status: 200,
+        success: true
+      };
+
+    } catch (error) {
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to prepare single-asset deposit transaction'
+      };
+    }
+  }
+
+  /**
+   * Validates single-asset deposit parameters
+   * 
+   * @param params - Parameters to validate
+   * @throws Error if parameters are invalid
+   */
+  public validateDepositParams(params: SingleAssetDepositParams): void {
+    if (params.assets <= 0n) {
+      throw new Error('Assets amount must be greater than 0');
+    }
+
+    if (!params.vault || params.vault === '0x0000000000000000000000000000000000000000') {
+      throw new Error('Invalid vault address');
+    }
+
+    if (!params.receiver || params.receiver === '0x0000000000000000000000000000000000000000') {
+      throw new Error('Invalid receiver address');
+    }
+
+    if (!params.singleAssetDepositContract || params.singleAssetDepositContract === '0x0000000000000000000000000000000000000000') {
+      throw new Error('Invalid single-asset deposit contract address');
+    }
+
+    if (params.depositSlippagePercent > 100n) {
+      throw new Error('Deposit slippage percent cannot exceed 100%');
+    }
+
+    if (params.swapSlippageBP > 10000) {
+      throw new Error('Swap slippage BP cannot exceed 10000 (100%)');
+    }
+
+    if (!Object.values(AMMType).includes(params.ammType)) {
+      throw new Error('Invalid AMM type');
+    }
+  }
+} 

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

@@ -0,0 +1,186 @@
+import type { Address } from 'viem';
+import { SwapWithSlippageResponse } from './simulateSwap.js';
+import { Protocol } from '../../../const/index.js';
+
+/**
+ * AMM Types supported by single-asset deposits
+ */
+export enum AMMType {
+  UniswapV3 = 0,
+  Algebra = 1,
+  AlgebraDirectional = 2,
+  AlgebraVE33 = 3,
+  AlgebraIntegral = 4,
+  Aerodrome = 5
+  
+}
+
+/**
+ * Parameters for single-asset deposit
+ */
+export interface SingleAssetDepositParams {
+  /** Amount of input token provided by the user */
+  assets: bigint;
+  /** Address to receive LP tokens */
+  receiver: Address;
+  /** Address of the vault to deposit into */
+  vault: Address;
+  /** true if input token is token0, false if token1 */
+  isToken0: boolean;
+  /** Maximum allowed slippage during deposit (in %) */
+  depositSlippagePercent: bigint;
+  /** Slippage tolerance for internal swap (in basis points) */
+  swapSlippageBP: number;
+  /** Type of AMM */
+  ammType: AMMType;
+  /** Address of the single-asset deposit contract */
+  singleAssetDepositContract?: Address;
+}
+
+/**
+ * Parameters for calculating swap amount
+ */
+export interface CalculateSwapAmountParams {
+  /** Amount of tokens being deposited */
+  depositAmount: bigint;
+  /** true if depositing token0, false if token1 */
+  isToken0: boolean;
+  /** Address of the vault */
+  vault: Address;
+  /** Address of the pool */
+  pool: Address;
+  /** Type of AMM */
+  ammType: AMMType;
+  /** Address of the single-asset deposit contract */
+  singleAssetDepositContract: Address;
+}
+
+/**
+ * Response from calculateSwapAmount
+ */
+export interface SwapAmountResponse {
+  /** Amount to be swapped from the input token */
+  swapAmount: bigint;
+  /** Current sqrt price (used for internal calculation) */
+  sqrtPrice: bigint;
+}
+
+/**
+ * Parameters for calculating sqrt price limit
+ */
+export interface CalculateLimitPriceParams {
+  /** Address of the pool */
+  pool: Address;
+  /** Slippage tolerance in basis points */
+  slippageBP: number;
+  /** true if swapping token0 for token1, false otherwise */
+  zeroForOne: boolean;
+  /** Type of AMM */
+  ammType: AMMType;
+  /** Address of token0 */
+  token0: Address;
+  /** Address of token1 */
+  token1: Address;
+}
+
+/**
+ * Parameters for simulating a swap
+ */
+export interface SimulateSwapParams {
+  /** Address of the pool */
+  pool: Address;
+  /** Address that will receive the swap output (or address(this) for simulation) */
+  recipient: Address;
+  /** true if swapping token0 → token1, else false */
+  zeroForOne: boolean;
+  /** Value from calculateSwapAmount */
+  amountSpecified: bigint;
+  /** Slippage-adjusted limit price */
+  sqrtPriceLimitX96: bigint;
+  /** AMM type */
+  ammType: AMMType;
+  /** Input token address (required for Quoter) */
+  tokenIn: Address;
+  /** Output token address (required for Quoter) */
+  tokenOut: Address;
+  /** Pool fee (required for Quoter) */
+  fee: number;
+  /** Quoter contract address (optional - will use default if not provided) */
+  quoterAddress?: Address;
+  /*** Tick spacing */
+  tickSpacing: number;
+
+  /** Protocol */
+  protocol?: Protocol | null;
+}
+
+/**
+ * Response from swap simulation
+ */
+export interface SwapSimulationResponse {
+  /** Final token0 amount after swap */
+  amount0: bigint;
+  /** Final token1 amount after swap */
+  amount1: bigint;
+
+  sqrtPriceX96After: bigint
+}
+
+/**
+ * Parameters for estimating LP tokens
+ */
+export interface EstimateLpTokensParams {
+  /** Address of the vault */
+  vault: Address;
+  /** Original deposit amount */
+  originalAssets: bigint;
+  /** Amount that was swapped internally */
+  swapAmount: bigint;
+  /** Tokens received from the swap (amount0 and amount1) */
+  swapResult: SwapSimulationResponse;
+  /** true if original deposit was token0, false if token1 */
+  isToken0: boolean;
+}
+
+/**
+ * Response from LP token estimation
+ */
+export interface LpTokenEstimationResponse {
+  /** Estimated amount of LP tokens to be received */
+  lpTokens: bigint;
+  /** Final amount of token0 that will be deposited */
+  finalAmount0: bigint;
+  /** Final amount of token1 that will be deposited */
+  finalAmount1: bigint;
+}
+
+/**
+ * Comprehensive single-asset deposit preview
+ */
+export interface SingleAssetDepositPreview {
+  /** Amount to be swapped internally */
+  swapAmount: bigint;
+  /** Current sqrt price */
+  currentSqrtPrice: bigint;
+  /** Slippage-adjusted limit price for swap */
+  sqrtPriceLimitX96: bigint;
+  /** Simulated swap result */
+  swapSimulation: SwapWithSlippageResponse;
+  /** LP token estimation */
+  lpEstimation: LpTokenEstimationResponse;
+  /** Whether the swap direction is token0 → token1 */
+  zeroForOne: boolean;
+}
+
+/**
+ * Pool slot0 data structure for UniswapV3
+ */
+export interface PoolSlot0 {
+  sqrtPriceX96: bigint;
+  tick: number;
+  observationIndex: number;
+  observationCardinality: number;
+  observationCardinalityNext: number;
+  feeProtocol: number;
+  unlocked: boolean;
+}