@steerprotocol/sdk 1.31.0 → 2.0.1

package/dist/esm/base/vault/deposit/index.js

@@ -1,594 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VaultDepositClient = void 0;
-const sdk_core_1 = require("@uniswap/sdk-core");
-const v3_sdk_1 = require("@uniswap/v3-sdk");
-const decimal_js_1 = require("decimal.js");
-const UniswapPool_js_1 = require("../../../const/abis/UniswapPool.js");
-const abis_js_1 = require("../../../const/deployments/abis.js");
-const network_js_1 = require("../../../const/network.js");
-const protocol_js_1 = require("../../../const/protocol.js");
-const utils_js_1 = require("../utils.js");
-const index_js_1 = require("../../../const/index.js");
-const VAULT_ABI = abis_js_1.abis.QuickSwapUniv3MultiPositionLiquidityManager;
-const PERIPHERY_ABI = abis_js_1.abis.SteerPeriphery;
-class VaultDepositClient {
-    constructor(publicClient, walletClient) {
-        this.publicClient = publicClient;
-        this.walletClient = walletClient;
-    }
-    /**
-     * Deposits tokens into a vault
-     * @param params The deposit parameters
-     */
-    async deposit(params) {
-        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;
-            // If using Steer Periphery
-            if (params.isSteerPeriphery) {
-                if (!params.chainId) {
-                    throw new Error('chainId is required when using Steer Periphery');
-                }
-                const steerPeripheryAddress = (0, network_js_1.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,
-                    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
-     */
-    async prepareDepositTx(params) {
-        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 = (0, network_js_1.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,
-                        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],
-                        ],
-                    },
-                    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],
-                    ],
-                },
-                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
-     */
-    async getDepositRatio(vaultAddress, zeroForOne) {
-        try {
-            // Try to get vault details, first attempt with regular vault
-            let vaultDetails;
-            let isAlgebraVault = false;
-            const chainId = await this.publicClient.getChainId();
-            const steerPeripheryAddress = (0, network_js_1.getContractAddressByChainIdAndContractName)(chainId, 'SteerPeriphery');
-            if (!steerPeripheryAddress)
-                throw new Error('SteerPeriphery address not found');
-            try {
-                // First try regular vault
-                vaultDetails = (await this.publicClient.readContract({
-                    address: steerPeripheryAddress,
-                    abi: PERIPHERY_ABI,
-                    functionName: 'vaultDetailsByAddress',
-                    args: [vaultAddress],
-                }));
-            }
-            catch (error) {
-                // If regular vault fails, try Algebra vault
-                vaultDetails = (await this.publicClient.readContract({
-                    address: steerPeripheryAddress,
-                    abi: PERIPHERY_ABI,
-                    functionName: 'algebraVaultDetailsByAddress',
-                    args: [vaultAddress],
-                }));
-                isAlgebraVault = true;
-            }
-            const token0Balance = vaultDetails.token0Balance;
-            const token1Balance = vaultDetails.token1Balance;
-            const token0Decimals = vaultDetails.token0Decimals;
-            const token1Decimals = vaultDetails.token1Decimals;
-            let ratio;
-            // 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 = (0, index_js_1.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: (0, protocol_js_1.isAlgebraProtocol)(protocol),
-                    isPoolSharkPool: (0, protocol_js_1.isPoolSharkProtocol)(protocol),
-                    isAlgebraIntegralPool: (0, protocol_js_1.isAlgebraIntegralProtocol)(protocol),
-                    isAlgebraDirectionPool: (0, protocol_js_1.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, sdk_core_1.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_js_1.Decimal(token0Balance.toString());
-                const token1Bal = new decimal_js_1.Decimal(token1Balance.toString());
-                const token0Dec = new decimal_js_1.Decimal(10).pow(Number(token0Decimals));
-                const token1Dec = new decimal_js_1.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
-     */
-    async getPool(vaultAddress) {
-        try {
-            const pool = (await this.publicClient.readContract({
-                address: vaultAddress,
-                abi: VAULT_ABI,
-                functionName: 'pool',
-            }));
-            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
-     */
-    async getPoolInstance(params) {
-        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 (0, utils_js_1.getGlobalStateAlgebraIntegral)(this.publicClient, poolData.data.id, params.isAlgebraDirectionPool);
-            }
-            else if (params.isPoolSharkPool) {
-                // For PoolShark pools
-                const poolSharkResponse = await (0, utils_js_1.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 (0, utils_js_1.getGlobalState)(this.publicClient, poolData.data.id, params.isAlgebraDirectionPool);
-            }
-            else {
-                // For standard Uniswap V3 pools
-                slot0Response = await (0, utils_js_1.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 sdk_core_1.Token(params.chain.id, poolData.data.token0.id, Number(poolData.data.token0.decimals), poolData.data.token0.symbol, poolData.data.token0.name);
-            const token1 = new sdk_core_1.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;
-            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?.price;
-            }
-            else {
-                price = slot0Response?.data?.sqrtPriceX96;
-            }
-            if (!price) {
-                throw new Error('Failed to get pool price');
-            }
-            return {
-                data: new v3_sdk_1.Pool(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
-     */
-    async getPoolLiquidity(poolAddress) {
-        try {
-            const liquidity = (await this.publicClient.readContract({
-                address: poolAddress,
-                abi: UniswapPool_js_1.UniswapV3PoolABI,
-                functionName: 'liquidity',
-            }));
-            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
-     */
-    async getCorrespondingTokenAmount(vaultAddress, amount, zeroForOne) {
-        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_js_1.Decimal(amount.toString());
-            const ratioDecimal = new decimal_js_1.Decimal(ratio);
-            const adjustmentDecimal = new decimal_js_1.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
-     */
-    async preparePoolData(vaultAddress) {
-        try {
-            // Try to get vault details, first attempt with regular vault
-            let vaultDetails;
-            const chainId = await this.publicClient.getChainId();
-            const steerPeripheryAddress = (0, network_js_1.getContractAddressByChainIdAndContractName)(chainId, 'SteerPeriphery');
-            if (!steerPeripheryAddress)
-                throw new Error('SteerPeriphery address not found');
-            try {
-                // First try regular vault
-                vaultDetails = (await this.publicClient.readContract({
-                    address: steerPeripheryAddress,
-                    abi: PERIPHERY_ABI,
-                    functionName: 'vaultDetailsByAddress',
-                    args: [vaultAddress],
-                }));
-            }
-            catch (error) {
-                // If regular vault fails, try Algebra vault
-                vaultDetails = (await this.publicClient.readContract({
-                    address: steerPeripheryAddress,
-                    abi: PERIPHERY_ABI,
-                    functionName: 'algebraVaultDetailsByAddress',
-                    args: [vaultAddress],
-                }));
-            }
-            // 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: UniswapPool_js_1.UniswapV3PoolABI,
-                functionName: 'tickSpacing',
-            }));
-            const 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',
-            };
-        }
-    }
-}
-exports.VaultDepositClient = VaultDepositClient;
-//# sourceMappingURL=index.js.map