@steerprotocol/sdk 1.31.0 → 2.0.1

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

@@ -1,411 +0,0 @@
-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

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