@steerprotocol/sdk 1.19.14 → 1.19.16

package/dist/cjs/base/vault/single-asset/singleAssetDeposit.js

@@ -0,0 +1,324 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleAssetDepositClient = void 0;
+const const_1 = require("../../../const");
+const singleTokenDeposit_1 = require("../../../const/abis/singleTokenDeposit");
+const UniswapPool_1 = require("../../../const/abis/UniswapPool");
+const calculateLimitPrice_1 = require("./calculateLimitPrice");
+const calculateSwapAmount_1 = require("./calculateSwapAmount");
+const estimateLpTokens_1 = require("./estimateLpTokens");
+const simulateSwap_1 = require("./simulateSwap");
+const types_1 = require("./types");
+/**
+ * Main single-asset deposit client that orchestrates all the steps
+ */
+class SingleAssetDepositClient {
+    constructor(publicClient, walletClient) {
+        this.publicClient = publicClient;
+        this.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);
+     * }
+     * ```
+     */
+    async previewDeposit(params, poolAddress) {
+        try {
+            const chainId = await this.publicClient.getChainId();
+            const singleAssentDeposit = params.singleAssetDepositContract || (0, const_1.getContractAddressByChainIdAndContractName)(chainId, 'SingleAssetDeposit');
+            // Step 1: Calculate swap amount
+            const swapAmountParams = {
+                depositAmount: params.assets,
+                isToken0: params.isToken0,
+                vault: params.vault,
+                pool: poolAddress,
+                ammType: params.ammType,
+                singleAssetDepositContract: singleAssentDeposit
+            };
+            const swapAmountResult = await (0, calculateSwapAmount_1.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 = (0, simulateSwap_1.determineSwapDirection)(params.isToken0);
+            // Get token addresses from the pool contract
+            const [token0, token1] = await Promise.all([
+                this.publicClient.readContract({
+                    address: poolAddress,
+                    abi: UniswapPool_1.UniswapV3PoolABI,
+                    functionName: 'token0'
+                }),
+                this.publicClient.readContract({
+                    address: poolAddress,
+                    abi: UniswapPool_1.UniswapV3PoolABI,
+                    functionName: 'token1'
+                })
+            ]);
+            // Step 2: Calculate limit price
+            const limitPriceParams = {
+                pool: poolAddress,
+                slippageBP: params.swapSlippageBP,
+                zeroForOne,
+                ammType: params.ammType,
+                token0,
+                token1
+            };
+            const limitPriceResult = await (0, calculateLimitPrice_1.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;
+            // Get pool fee from the contract
+            const fee = await this.publicClient.readContract({
+                address: poolAddress,
+                abi: UniswapPool_1.UniswapV3PoolABI,
+                functionName: 'fee'
+            });
+            // Step 3: Simulate swap
+            const simulateSwapParams = {
+                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
+            };
+            const swapSimulationResult = await (0, simulateSwap_1.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 (0, estimateLpTokens_1.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);
+     * }
+     * ```
+     */
+    async deposit(params) {
+        try {
+            const account = await this.walletClient.getAddresses();
+            if (!account[0]) {
+                throw new Error('No account found');
+            }
+            const singleAssentDeposit = params.singleAssetDepositContract || (0, const_1.getContractAddressByChainIdAndContractName)(this.publicClient.chain?.id || 1, 'SingleAssetDeposit');
+            // Prepare the transaction
+            const { request } = await this.publicClient.simulateContract({
+                address: singleAssentDeposit,
+                abi: singleTokenDeposit_1.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
+     */
+    async prepareDepositTx(params) {
+        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 || (0, const_1.getContractAddressByChainIdAndContractName)(chainId, 'SingleAssetDeposit');
+            await this.publicClient.simulateContract({
+                address: singleAssentDeposit,
+                abi: singleTokenDeposit_1.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,
+                    abi: singleTokenDeposit_1.singleTokenDepositAbi,
+                    functionName: 'deposit',
+                    args: [
+                        params.assets,
+                        params.receiver,
+                        params.vault,
+                        params.isToken0,
+                        params.depositSlippagePercent,
+                        params.swapSlippageBP,
+                        params.ammType
+                    ]
+                },
+                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
+     */
+    validateDepositParams(params) {
+        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(types_1.AMMType).includes(params.ammType)) {
+            throw new Error('Invalid AMM type');
+        }
+    }
+}
+exports.SingleAssetDepositClient = SingleAssetDepositClient;
+//# sourceMappingURL=singleAssetDeposit.js.map

package/dist/cjs/base/vault/single-asset/singleAssetDeposit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleAssetDeposit.js","sourceRoot":"","sources":["../../../../../src/base/vault/single-asset/singleAssetDeposit.ts"],"names":[],"mappings":"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"}

package/dist/cjs/base/vault/single-asset/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AMMType = void 0;
+/**
+ * AMM Types supported by single-asset deposits
+ */
+var AMMType;
+(function (AMMType) {
+    AMMType[AMMType["UniswapV3"] = 0] = "UniswapV3";
+    AMMType[AMMType["Algebra"] = 1] = "Algebra";
+    AMMType[AMMType["AlgebraDirectional"] = 2] = "AlgebraDirectional";
+    AMMType[AMMType["AlgebraVE33"] = 3] = "AlgebraVE33";
+    AMMType[AMMType["AlgebraIntegral"] = 4] = "AlgebraIntegral";
+})(AMMType || (exports.AMMType = AMMType = {}));
+//# sourceMappingURL=types.js.map

package/dist/cjs/base/vault/single-asset/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../src/base/vault/single-asset/types.ts"],"names":[],"mappings":";;;AAGA;;GAEG;AACH,IAAY,OAMX;AAND,WAAY,OAAO;IACjB,+CAAa,CAAA;IACb,2CAAW,CAAA;IACX,iEAAsB,CAAA;IACtB,mDAAe,CAAA;IACf,2DAAmB,CAAA;AACrB,CAAC,EANW,OAAO,uBAAP,OAAO,QAMlB"}

package/dist/cjs/base/vault/utils.js

@@ -4,23 +4,26 @@ exports.getSlot0 = getSlot0;
 exports.getGlobalState = getGlobalState;
 exports.getGlobalStatePoolShark = getGlobalStatePoolShark;
 exports.getGlobalStateAlgebraIntegral = getGlobalStateAlgebraIntegral;
-const SLOT0_ABI = [
-    {
-        inputs: [],
-        name: 'slot0',
-        outputs: [
-            { internalType: 'uint160', name: 'sqrtPriceX96', type: 'uint160' },
-            { internalType: 'int24', name: 'tick', type: 'int24' },
-            { internalType: 'uint16', name: 'observationIndex', type: 'uint16' },
-            { internalType: 'uint16', name: 'observationCardinality', type: 'uint16' },
-            { internalType: 'uint16', name: 'observationCardinalityNext', type: 'uint16' },
-            { internalType: 'uint8', name: 'feeProtocol', type: 'uint8' },
-            { internalType: 'bool', name: 'unlocked', type: 'bool' },
-        ],
-        stateMutability: 'view',
-        type: 'function',
-    },
-];
+exports.getPoolState = getPoolState;
+exports.getPoolPrice = getPoolPrice;
+exports.getPoolStateWithPrice = getPoolStateWithPrice;
+// const SLOT0_ABI: any = [
+//   {
+//     inputs: [],
+//     name: 'slot0',
+//     outputs: [
+//       { internalType: 'uint160', name: 'sqrtPriceX96', type: 'uint160' },
+//       { internalType: 'int24', name: 'tick', type: 'int24' },
+//       { internalType: 'uint16', name: 'observationIndex', type: 'uint16' },
+//       { internalType: 'uint16', name: 'observationCardinality', type: 'uint16' },
+//       { internalType: 'uint16', name: 'observationCardinalityNext', type: 'uint16' },
+//       { internalType: 'uint8', name: 'feeProtocol', type: 'uint8' },
+//       { internalType: 'bool', name: 'unlocked', type: 'bool' },
+//     ],
+//     stateMutability: 'view',
+//     type: 'function',
+//   },
+// ] as const;
 const GLOBAL_STATE_ABI = [
     {
         inputs: [],
@@ -128,7 +131,23 @@ async function getSlot0(publicClient, poolAddress) {
     try {
         const slot0 = await publicClient.readContract({
             address: poolAddress,
-            abi: SLOT0_ABI,
+            abi: [
+                {
+                    inputs: [],
+                    name: 'slot0',
+                    outputs: [
+                        { internalType: 'uint160', name: 'sqrtPriceX96', type: 'uint160' },
+                        { internalType: 'int24', name: 'tick', type: 'int24' },
+                        { internalType: 'uint16', name: 'observationIndex', type: 'uint16' },
+                        { internalType: 'uint16', name: 'observationCardinality', type: 'uint16' },
+                        { internalType: 'uint16', name: 'observationCardinalityNext', type: 'uint16' },
+                        { internalType: 'uint8', name: 'feeProtocol', type: 'uint8' },
+                        { internalType: 'bool', name: 'unlocked', type: 'bool' },
+                    ],
+                    stateMutability: 'view',
+                    type: 'function',
+                },
+            ],
             functionName: 'slot0',
         });
         return {
@@ -285,4 +304,196 @@ async function getGlobalStateAlgebraIntegral(publicClient, poolAddress, isDirect
         };
     }
 }
+/**
+ * Unified method to get pool state across different AMM types
+ * Automatically calls the correct function based on pool type parameters
+ *
+ * @param publicClient - The public client for blockchain reads
+ * @param params - Parameters specifying the pool and its type
+ * @returns Promise resolving to standardized pool state data
+ *
+ * @example
+ * ```typescript
+ * // For Uniswap V3 pool
+ * const uniV3State = await getPoolState(publicClient, {
+ *   poolAddress: '0x...',
+ * });
+ *
+ * // For Algebra pool
+ * const algebraState = await getPoolState(publicClient, {
+ *   poolAddress: '0x...',
+ *   isAlgebraPool: true,
+ *   isAlgebraDirectionPool: false
+ * });
+ *
+ * // For PoolShark pool
+ * const poolSharkState = await getPoolState(publicClient, {
+ *   poolAddress: '0x...',
+ *   isPoolSharkPool: true
+ * });
+ * ```
+ */
+async function getPoolState(publicClient, params) {
+    try {
+        let stateResponse;
+        // Handle different protocol types following the same logic as getPoolInstance
+        if (params.isAlgebraIntegralPool) {
+            // For Algebra Integral pools
+            stateResponse = await getGlobalStateAlgebraIntegral(publicClient, params.poolAddress, params.isAlgebraDirectionPool || false);
+        }
+        else if (params.isPoolSharkPool) {
+            // For PoolShark pools - convert to standardized format
+            const poolSharkResponse = await getGlobalStatePoolShark(publicClient, params.poolAddress);
+            if (poolSharkResponse.success && poolSharkResponse.data) {
+                stateResponse = {
+                    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 {
+                stateResponse = {
+                    data: null,
+                    status: poolSharkResponse.status,
+                    success: false,
+                    error: poolSharkResponse.error
+                };
+            }
+        }
+        else if (params.isAlgebraPool) {
+            // For Algebra pools
+            stateResponse = await getGlobalState(publicClient, params.poolAddress, params.isAlgebraDirectionPool || false);
+        }
+        else {
+            // For standard Uniswap V3 pools
+            stateResponse = await getSlot0(publicClient, params.poolAddress);
+        }
+        if (!stateResponse.success || !stateResponse.data) {
+            throw new Error(stateResponse.error || 'Failed to read pool state');
+        }
+        return {
+            data: stateResponse.data,
+            status: 200,
+            success: true
+        };
+    }
+    catch (error) {
+        return {
+            data: null,
+            status: 500,
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to get pool state'
+        };
+    }
+}
+/**
+ * Extracts the appropriate price value from pool state based on AMM type
+ * Different AMM protocols store price information in different fields
+ *
+ * @param poolStateData - The pool state data returned from getPoolState
+ * @param params - Pool type parameters to determine which price field to use
+ * @returns The price as bigint, or null if price cannot be extracted
+ *
+ * @example
+ * ```typescript
+ * const stateResponse = await getPoolState(publicClient, {
+ *   poolAddress: '0x...',
+ *   isAlgebraPool: true
+ * });
+ *
+ * if (stateResponse.success && stateResponse.data) {
+ *   const price = getPoolPrice(stateResponse.data, {
+ *     isAlgebraPool: true,
+ *     isAlgebraDirectionPool: false
+ *   });
+ *   console.log('Pool price:', price);
+ * }
+ * ```
+ */
+function getPoolPrice(poolStateData, params) {
+    try {
+        let price;
+        // Extract price based on AMM type - following the same logic as getPoolInstance
+        if (params.isAlgebraPool && !params.isAlgebraIntegralPool) {
+            // For Algebra pools (non-integral)
+            price = (poolStateData)?.price;
+        }
+        else if (params.isAlgebraIntegralPool) {
+            // For Algebra Integral pools
+            price = (poolStateData)?.price;
+        }
+        else if (params.isPoolSharkPool) {
+            // For PoolShark pools - price is stored in a nested structure
+            price = poolStateData.tick?.price;
+        }
+        else {
+            // For standard Uniswap V3 pools
+            price = poolStateData.sqrtPriceX96;
+        }
+        return price || null;
+    }
+    catch (error) {
+        console.error('Error extracting pool price:', error);
+        return null;
+    }
+}
+/**
+ * Combined method to get both pool state and extract price in one call
+ * Convenience method that combines getPoolState and getPoolPrice
+ *
+ * @param publicClient - The public client for blockchain reads
+ * @param params - Parameters specifying the pool and its type
+ * @returns Promise resolving to object containing both state and price
+ *
+ * @example
+ * ```typescript
+ * const result = await getPoolStateWithPrice(publicClient, {
+ *   poolAddress: '0x...',
+ *   isAlgebraPool: true
+ * });
+ *
+ * if (result.success && result.data) {
+ *   console.log('Pool state:', result.data.state);
+ *   console.log('Pool price:', result.data.price);
+ * }
+ * ```
+ */
+async function getPoolStateWithPrice(publicClient, params) {
+    try {
+        const stateResponse = await getPoolState(publicClient, params);
+        if (!stateResponse.success || !stateResponse.data) {
+            return {
+                data: null,
+                status: stateResponse.status,
+                success: false,
+                error: stateResponse.error || 'Failed to get pool state'
+            };
+        }
+        const price = getPoolPrice(stateResponse.data, params);
+        return {
+            data: {
+                state: stateResponse.data,
+                price
+            },
+            status: 200,
+            success: true
+        };
+    }
+    catch (error) {
+        return {
+            data: null,
+            status: 500,
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to get pool state with price'
+        };
+    }
+}
 //# sourceMappingURL=utils.js.map