@steerprotocol/sdk 1.31.0 → 2.0.0

package/dist/esm/base/vault/single-asset/simulateSwap.js

@@ -1,336 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.simulateSwap = simulateSwap;
-exports.determineSwapDirection = determineSwapDirection;
-exports.validateSwapParams = validateSwapParams;
-exports.simulateSwapWithSlippage = simulateSwapWithSlippage;
-const viem_1 = require("viem");
-const index_js_1 = require("../../../const/index.js");
-const quoter_js_1 = require("../../../const/quoter.js");
-const utils_js_1 = require("../utils.js");
-const calculateLimitPrice_js_1 = require("./calculateLimitPrice.js");
-const types_js_1 = require("./types.js");
-/**
- * Simulates a swap to get the expected output amounts without executing the swap
- * Uses Uniswap V3 Quoter contract for accurate simulation
- *
- * @param publicClient - Viem public client for blockchain reads
- * @param params - Parameters for swap simulation
- * @param chainId - Chain ID to get the appropriate Quoter address
- * @returns Promise resolving to the simulated swap results
- *
- * @example
- * ```typescript
- * const result = await simulateSwap(publicClient, {
- *   pool: '0x...',
- *   recipient: '0x...',
- *   zeroForOne: true,
- *   amountSpecified: parseEther('10'),
- *   sqrtPriceLimitX96: limitPrice,
- *   ammType: AMMType.UniswapV3,
- *   tokenIn: '0x...',
- *   tokenOut: '0x...',
- *   fee: 3000
- * }, 137); // Polygon chain ID
- *
- * if (result.success) {
- *   console.log('Amount out:', result.data.amountOut);
- * }
- * ```
- */
-async function simulateSwap(publicClient, params, chainId) {
-    try {
-        // For now, only handle UniswapV3 - other AMMs can be added later
-        // Get the appropriate Quoter contract address
-        const networkConfig = (0, index_js_1.getNetworkByChainId)(chainId);
-        if (!networkConfig) {
-            throw Error('Network config not found');
-        }
-        const protocol = params.protocol || (0, index_js_1.getProtcolTypeByAmmType)(params.ammType);
-        const quoterFactory = new quoter_js_1.QuoterV2Factory(networkConfig);
-        const quoterABI = quoterFactory.getQuoterAbi(protocol);
-        const quoteParams = quoterFactory.getQuoteParams(protocol, {
-            tokenIn: params.tokenIn,
-            tokenOut: params.tokenOut,
-            fee: params.fee,
-            tickSpacing: params.tickSpacing,
-            amountIn: params.amountSpecified,
-            sqrtPriceLimitX96: params.sqrtPriceLimitX96,
-            limitSqrtPrice: params.sqrtPriceLimitX96,
-        });
-        const quoterAddress = quoterFactory.getQuoterV2Address(protocol);
-        // Use Quoter's quoteExactInputSingle for simulation
-        const result = await publicClient.call({
-            to: quoterAddress,
-            data: (0, viem_1.encodeFunctionData)({
-                abi: quoterABI,
-                functionName: 'quoteExactInputSingle',
-                //@ts-expect-error Parameters are dynamic in nature and very based on abi types
-                args: [{
-                        ...quoteParams
-                    }]
-            })
-        });
-        if (!result.data) {
-            throw new Error('No data returned from quoter simulation');
-        }
-        // Decode the result - Different quoters return different tuple structures:
-        // - Standard Uniswap/QuickSwap: [amountOut, sqrtPriceX96After, initializedTicksCrossed, gasEstimate]
-        // - AlgebraIntegral: [amountOut, amountIn, sqrtPriceX96After, initializedTicksCrossed, gasEstimate, fee]
-        const decodedResult = (0, viem_1.decodeFunctionResult)({
-            abi: quoterABI,
-            functionName: 'quoteExactInputSingle',
-            data: result.data
-        });
-        // Extract values based on protocol type
-        let amountOut;
-        let sqrtPriceX96After;
-        // Check if this is an AlgebraIntegral protocol (which has amountIn as second return value)
-        if (protocol && (0, index_js_1.isAlgebraIntegralProtocol)(protocol)) {
-            // AlgebraIntegral format: [amountOut, amountIn, sqrtPriceX96After, ...]
-            const [out, , priceAfter] = decodedResult;
-            amountOut = out;
-            sqrtPriceX96After = priceAfter;
-        }
-        else {
-            // Standard format: [amountOut, sqrtPriceX96After, ...]
-            const [out, priceAfter] = decodedResult;
-            amountOut = out;
-            sqrtPriceX96After = priceAfter;
-        }
-        // Convert to the expected SwapSimulationResponse format
-        // For exact input swaps, we know the input amount and get the output amount
-        let amount0, amount1;
-        if (params.zeroForOne) {
-            // Swapping token0 for token1
-            amount0 = -params.amountSpecified; // negative because we're giving token0
-            amount1 = amountOut; // positive because we're receiving token1
-        }
-        else {
-            // Swapping token1 for token0
-            amount0 = amountOut; // positive because we're receiving token0
-            amount1 = -params.amountSpecified; // negative because we're giving token1
-        }
-        return {
-            data: {
-                amount0,
-                amount1,
-                sqrtPriceX96After
-            },
-            status: 200,
-            success: true
-        };
-    }
-    catch (error) {
-        return {
-            data: null,
-            status: 500,
-            success: false,
-            error: error instanceof Error ? error.message : 'Failed to simulate swap'
-        };
-    }
-}
-/**
- * Determines the swap direction based on the token being deposited
- *
- * @param isToken0 - true if depositing token0, false if token1
- * @returns true if swapping token0 → token1, false otherwise
- */
-function determineSwapDirection(isToken0) {
-    // If depositing token0, we need to swap some token0 to token1
-    // If depositing token1, we need to swap some token1 to token0
-    return isToken0;
-}
-/**
- * Validates swap simulation parameters
- *
- * @param params - Parameters to validate
- * @throws Error if parameters are invalid
- */
-function validateSwapParams(params) {
-    if (!params.pool || params.pool === '0x0000000000000000000000000000000000000000') {
-        throw new Error('Invalid pool address');
-    }
-    if (!params.recipient || params.recipient === '0x0000000000000000000000000000000000000000') {
-        throw new Error('Invalid recipient address');
-    }
-    if (params.amountSpecified <= 0n) {
-        throw new Error('Amount specified must be greater than 0');
-    }
-    if (params.sqrtPriceLimitX96 <= 0n) {
-        throw new Error('Sqrt price limit must be greater than 0');
-    }
-    if (!params.tokenIn || params.tokenIn === '0x0000000000000000000000000000000000000000') {
-        throw new Error('Invalid tokenIn address');
-    }
-    if (!params.tokenOut || params.tokenOut === '0x0000000000000000000000000000000000000000') {
-        throw new Error('Invalid tokenOut address');
-    }
-    if (params.fee <= 0) {
-        throw new Error('Pool fee must be greater than 0');
-    }
-}
-/**
- * Simulates a swap with slippage analysis by first getting current pool state,
- * then simulating the swap and calculating price impact
- *
- * @param publicClient - Viem public client for blockchain reads
- * @param params - Parameters for swap simulation with slippage analysis
- * @param chainId - Chain ID to get the appropriate Quoter address
- * @returns Promise resolving to swap results with slippage analysis
- *
- * @example
- * ```typescript
- * const result = await simulateSwapWithSlippage(publicClient, {
- *   poolAddress: '0x...',
- *   recipient: '0x...',
- *   zeroForOne: true,
- *   amountSpecified: parseEther('10'),
- *   sqrtPriceLimitX96: limitPrice,
- *   ammType: AMMType.UniswapV3,
- *   tokenIn: '0x...',
- *   tokenOut: '0x...',
- *   fee: 3000
- * }, 137); // Polygon chain ID
- *
- * if (result.success) {
- *   console.log('Price slippage:', result.data.priceSlippagePercent, '%');
- *   console.log('Current price:', result.data.currentPrice);
- *   console.log('Price after swap:', result.data.priceAfter);
- * }
- * ```
- */
-async function simulateSwapWithSlippage(publicClient, params, chainId) {
-    try {
-        // Validate params
-        validateSwapWithSlippageParams(params);
-        // Step 1: Get current pool state from slot0
-        const slot0Result = await (0, calculateLimitPrice_js_1.getPoolSlot0)(publicClient, params.poolAddress, params.ammType);
-        if (!slot0Result.data) {
-            throw new Error('Failed to get pool slot0 data');
-        }
-        // Decode slot0 result
-        const currentSlot0 = {
-            sqrtPriceX96: (0, utils_js_1.getPoolPrice)(slot0Result.data, {
-                isAlgebraPool: params.ammType === types_js_1.AMMType.Algebra,
-                isAlgebraIntegralPool: params.ammType === types_js_1.AMMType.AlgebraIntegral,
-                isPoolSharkPool: false // PoolShark not defined in AMMType enum
-            }) || BigInt(0),
-            tick: slot0Result.data.tick,
-            observationIndex: slot0Result.data.observationIndex,
-            observationCardinality: slot0Result.data.observationCardinality,
-            observationCardinalityNext: slot0Result.data.observationCardinalityNext,
-            feeProtocol: slot0Result.data.feeProtocol,
-            unlocked: slot0Result.data.unlocked
-        };
-        const tickSpacing = await publicClient.readContract({
-            abi: [{
-                    "inputs": [],
-                    "name": "tickSpacing",
-                    "outputs": [
-                        {
-                            "internalType": "int24",
-                            "name": "",
-                            "type": "int24"
-                        }
-                    ],
-                    "stateMutability": "view",
-                    "type": "function"
-                },],
-            functionName: 'tickSpacing',
-            address: params.poolAddress,
-        });
-        // Step 2: Simulate the swap using existing function
-        const swapParams = {
-            pool: params.poolAddress,
-            recipient: params.recipient,
-            zeroForOne: params.zeroForOne,
-            amountSpecified: params.amountSpecified,
-            sqrtPriceLimitX96: params.sqrtPriceLimitX96,
-            ammType: params.ammType,
-            tokenIn: params.tokenIn,
-            tokenOut: params.tokenOut,
-            fee: params.fee,
-            tickSpacing: tickSpacing,
-            quoterAddress: params.quoterAddress,
-            protocol: params.protocol
-        };
-        const swapResult = await simulateSwap(publicClient, swapParams, chainId);
-        if (!swapResult.success || !swapResult.data) {
-            throw new Error(swapResult.error || 'Swap simulation failed');
-        }
-        // Step 3: Calculate price slippage
-        const currentPrice = (0, calculateLimitPrice_js_1.getQuoteFromSqrtRatioX96)((0, calculateLimitPrice_js_1.bigintToDecimal)(currentSlot0.sqrtPriceX96), (0, calculateLimitPrice_js_1.bigintToDecimal)(10n ** 18n), params.tokenIn, params.tokenOut);
-        const priceAfter = (0, calculateLimitPrice_js_1.getQuoteFromSqrtRatioX96)((0, calculateLimitPrice_js_1.bigintToDecimal)(swapResult.data.sqrtPriceX96After), (0, calculateLimitPrice_js_1.bigintToDecimal)(10n ** 18n), params.tokenIn, params.tokenOut);
-        // Calculate slippage percentage
-        // Positive slippage means unfavorable price movement
-        const priceSlippagePercent = calculatePriceSlippage(currentPrice, priceAfter, params.zeroForOne);
-        return {
-            data: {
-                currentSlot0,
-                swapSimulation: swapResult.data,
-                priceSlippagePercent: priceSlippagePercent.toFixed(5),
-                currentPrice: (0, calculateLimitPrice_js_1.decimalToBigint)(currentPrice),
-                priceAfter: (0, calculateLimitPrice_js_1.decimalToBigint)(priceAfter)
-            },
-            status: 200,
-            success: true
-        };
-    }
-    catch (error) {
-        return {
-            data: null,
-            status: 500,
-            success: false,
-            error: error instanceof Error ? error.message : 'Failed to simulate swap with slippage'
-        };
-    }
-}
-/**
- * Calculates price slippage percentage using Decimal.js
- *
- * @param priceBefore - Price before the swap (Decimal)
- * @param priceAfter - Price after the swap (Decimal)
- * @param zeroForOne - Swap direction (true if token0 → token1)
- * @returns Slippage percentage (positive means unfavorable movement)
- */
-function calculatePriceSlippage(priceBefore, priceAfter, zeroForOne) {
-    if (priceBefore.isZero()) {
-        throw new Error('Price before cannot be zero');
-    }
-    const priceChange = priceAfter.minus(priceBefore).dividedBy(priceBefore).times(100);
-    // For zeroForOne swaps (selling token0), favorable movement is price going down
-    // For oneForZero swaps (selling token1), favorable movement is price going up
-    // We return positive values for unfavorable movement (slippage)
-    return zeroForOne ? priceChange : priceChange.negated();
-}
-/**
- * Validates swap with slippage parameters
- *
- * @param params - Parameters to validate
- * @throws Error if parameters are invalid
- */
-function validateSwapWithSlippageParams(params) {
-    if (!params.poolAddress || params.poolAddress === '0x0000000000000000000000000000000000000000') {
-        throw new Error('Invalid pool address');
-    }
-    if (!params.recipient || params.recipient === '0x0000000000000000000000000000000000000000') {
-        throw new Error('Invalid recipient address');
-    }
-    if (params.amountSpecified <= 0n) {
-        throw new Error('Amount specified must be greater than 0');
-    }
-    if (params.sqrtPriceLimitX96 <= 0n) {
-        throw new Error('Sqrt price limit must be greater than 0');
-    }
-    if (!params.tokenIn || params.tokenIn === '0x0000000000000000000000000000000000000000') {
-        throw new Error('Invalid tokenIn address');
-    }
-    if (!params.tokenOut || params.tokenOut === '0x0000000000000000000000000000000000000000') {
-        throw new Error('Invalid tokenOut address');
-    }
-    if (params.fee <= 0) {
-        throw new Error('Pool fee must be greater than 0');
-    }
-}
-//# sourceMappingURL=simulateSwap.js.map

package/dist/esm/base/vault/single-asset/simulateSwap.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"simulateSwap.js","sourceRoot":"","sources":["../../../../../src/base/vault/single-asset/simulateSwap.ts"],"names":[],"mappings":"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","sourcesContent":["import { Decimal } from 'decimal.js';\nimport type { Address, PublicClient } from 'viem';\nimport { decodeFunctionResult, encodeFunctionData } from 'viem';\nimport { getNetworkByChainId, getProtcolTypeByAmmType, Protocol, isAlgebraIntegralProtocol } from '../../../const/index.js';\nimport { QuoterV2Factory } from '../../../const/quoter.js';\nimport { SteerResponse } from '../../../types.js';\nimport { getPoolPrice } from '../utils.js';\nimport { bigintToDecimal, decimalToBigint, getPoolSlot0, getQuoteFromSqrtRatioX96 } from './calculateLimitPrice.js';\nimport type { PoolSlot0, SimulateSwapParams, SwapSimulationResponse } from './types.js';\nimport { AMMType } from './types.js';\n\n/**\n * Simulates a swap to get the expected output amounts without executing the swap\n * Uses Uniswap V3 Quoter contract for accurate simulation\n * \n * @param publicClient - Viem public client for blockchain reads\n * @param params - Parameters for swap simulation\n * @param chainId - Chain ID to get the appropriate Quoter address\n * @returns Promise resolving to the simulated swap results\n * \n * @example\n * ```typescript\n * const result = await simulateSwap(publicClient, {\n *   pool: '0x...',\n *   recipient: '0x...',\n *   zeroForOne: true,\n *   amountSpecified: parseEther('10'),\n *   sqrtPriceLimitX96: limitPrice,\n *   ammType: AMMType.UniswapV3,\n *   tokenIn: '0x...',\n *   tokenOut: '0x...',\n *   fee: 3000\n * }, 137); // Polygon chain ID\n * \n * if (result.success) {\n *   console.log('Amount out:', result.data.amountOut);\n * }\n * ```\n */\nexport async function simulateSwap(\n  publicClient: PublicClient,\n  params: SimulateSwapParams,\n  chainId: number\n): Promise<SteerResponse<SwapSimulationResponse>> {\n  try {\n    // For now, only handle UniswapV3 - other AMMs can be added later\n\n    // Get the appropriate Quoter contract address\n\n    const networkConfig = getNetworkByChainId(chainId);\n\n    if (!networkConfig) {\n      throw Error('Network config not found')\n    }\n     \n    const protocol = params.protocol || getProtcolTypeByAmmType(params.ammType);\n\n    const quoterFactory = new QuoterV2Factory(networkConfig);\n\n    const quoterABI = quoterFactory.getQuoterAbi(protocol);\n\n    const quoteParams = quoterFactory.getQuoteParams(protocol, {\n      tokenIn: params.tokenIn,\n      tokenOut: params.tokenOut,\n      fee: params.fee,\n      tickSpacing: params.tickSpacing,\n      amountIn: params.amountSpecified,\n      sqrtPriceLimitX96: params.sqrtPriceLimitX96,\n      limitSqrtPrice: params.sqrtPriceLimitX96,\n    })\n\n    const quoterAddress = quoterFactory.getQuoterV2Address(\n      protocol\n    )\n    // Use Quoter's quoteExactInputSingle for simulation\n    const result = await publicClient.call({\n      to: quoterAddress as Address,\n      data: encodeFunctionData({\n        abi: quoterABI,\n        functionName: 'quoteExactInputSingle',\n        //@ts-expect-error Parameters are dynamic in nature and very based on abi types\n        args: [{\n          ...quoteParams\n        }]\n      })\n    });\n\n    if (!result.data) {\n      throw new Error('No data returned from quoter simulation');\n    }\n\n    // Decode the result - Different quoters return different tuple structures:\n    // - Standard Uniswap/QuickSwap: [amountOut, sqrtPriceX96After, initializedTicksCrossed, gasEstimate]\n    // - AlgebraIntegral: [amountOut, amountIn, sqrtPriceX96After, initializedTicksCrossed, gasEstimate, fee]\n    const decodedResult = decodeFunctionResult({\n      abi: quoterABI,\n      functionName: 'quoteExactInputSingle',\n      data: result.data\n    });\n\n    // Extract values based on protocol type\n    let amountOut: bigint;\n    let sqrtPriceX96After: bigint;\n    \n    // Check if this is an AlgebraIntegral protocol (which has amountIn as second return value)\n    if (protocol && isAlgebraIntegralProtocol(protocol)) {\n      // AlgebraIntegral format: [amountOut, amountIn, sqrtPriceX96After, ...]\n      const [out, , priceAfter] = decodedResult as readonly [bigint, bigint, bigint, number, bigint, number];\n      amountOut = out;\n      sqrtPriceX96After = priceAfter;\n    } else {\n      // Standard format: [amountOut, sqrtPriceX96After, ...]\n      const [out, priceAfter] = decodedResult as readonly [bigint, bigint, number, bigint];\n      amountOut = out;\n      sqrtPriceX96After = priceAfter;\n    }\n\n    // Convert to the expected SwapSimulationResponse format\n    // For exact input swaps, we know the input amount and get the output amount\n    let amount0: bigint, amount1: bigint;\n    \n    if (params.zeroForOne) {\n      // Swapping token0 for token1\n      amount0 = -params.amountSpecified; // negative because we're giving token0\n      amount1 = amountOut; // positive because we're receiving token1\n    } else {\n      // Swapping token1 for token0\n      amount0 = amountOut; // positive because we're receiving token0\n      amount1 = -params.amountSpecified; // negative because we're giving token1\n    }\n\n    return {\n      data: {\n        amount0,\n        amount1,\n        sqrtPriceX96After\n      },\n      status: 200,\n      success: true\n    };\n  } catch (error) {\n    return {\n      data: null,\n      status: 500,\n      success: false,\n      error: error instanceof Error ? error.message : 'Failed to simulate swap'\n    };\n  }\n}\n\n/**\n * Determines the swap direction based on the token being deposited\n * \n * @param isToken0 - true if depositing token0, false if token1\n * @returns true if swapping token0 → token1, false otherwise\n */\nexport function determineSwapDirection(isToken0: boolean): boolean {\n  // If depositing token0, we need to swap some token0 to token1\n  // If depositing token1, we need to swap some token1 to token0\n  return isToken0;\n}\n\n/**\n * Validates swap simulation parameters\n * \n * @param params - Parameters to validate\n * @throws Error if parameters are invalid\n */\nexport function validateSwapParams(params: SimulateSwapParams): void {\n  if (!params.pool || params.pool === '0x0000000000000000000000000000000000000000') {\n    throw new Error('Invalid pool address');\n  }\n  \n  if (!params.recipient || params.recipient === '0x0000000000000000000000000000000000000000') {\n    throw new Error('Invalid recipient address');\n  }\n  \n  if (params.amountSpecified <= 0n) {\n    throw new Error('Amount specified must be greater than 0');\n  }\n  \n  if (params.sqrtPriceLimitX96 <= 0n) {\n    throw new Error('Sqrt price limit must be greater than 0');\n  }\n\n  if (!params.tokenIn || params.tokenIn === '0x0000000000000000000000000000000000000000') {\n    throw new Error('Invalid tokenIn address');\n  }\n\n  if (!params.tokenOut || params.tokenOut === '0x0000000000000000000000000000000000000000') {\n    throw new Error('Invalid tokenOut address');\n  }\n\n  if (params.fee <= 0) {\n    throw new Error('Pool fee must be greater than 0');\n  }\n} \n\n/**\n * Parameters for swap with slippage analysis\n */\nexport interface SwapWithSlippageParams {\n  /** Address of the pool */\n  poolAddress: string;\n  /** Address that will receive the swap output (or address(this) for simulation) */\n  recipient: string;\n  /** true if swapping token0 → token1, else false */\n  zeroForOne: boolean;\n  /** Amount to swap */\n  amountSpecified: bigint;\n  /** Slippage-adjusted limit price */\n  sqrtPriceLimitX96: bigint;\n  /** AMM type */\n  ammType: AMMType;\n  /** Input token address (required for Quoter) */\n  tokenIn: string;\n  /** Output token address (required for Quoter) */\n  tokenOut: string;\n  /** Pool fee (required for Quoter) */\n  fee: number;\n  /** Quoter contract address (optional - will use default if not provided) */\n  quoterAddress?: string;\n  /** Protocol */\n  protocol?: Protocol | null;\n}\n\n/**\n * Response from swap simulation with slippage analysis\n */\nexport interface SwapWithSlippageResponse {\n  /** Current pool slot0 data */\n  currentSlot0: PoolSlot0;\n  /** Swap simulation results */\n  swapSimulation: SwapSimulationResponse;\n  /** Price slippage percentage (positive means price moved unfavorably) */\n  priceSlippagePercent: string;\n  /** Current price (derived from sqrtPriceX96) */\n  currentPrice: bigint;\n  /** Price after swap (derived from sqrtPriceX96After) */\n  priceAfter: bigint;\n}\n\n/**\n * Simulates a swap with slippage analysis by first getting current pool state,\n * then simulating the swap and calculating price impact\n * \n * @param publicClient - Viem public client for blockchain reads\n * @param params - Parameters for swap simulation with slippage analysis\n * @param chainId - Chain ID to get the appropriate Quoter address\n * @returns Promise resolving to swap results with slippage analysis\n * \n * @example\n * ```typescript\n * const result = await simulateSwapWithSlippage(publicClient, {\n *   poolAddress: '0x...',\n *   recipient: '0x...',\n *   zeroForOne: true,\n *   amountSpecified: parseEther('10'),\n *   sqrtPriceLimitX96: limitPrice,\n *   ammType: AMMType.UniswapV3,\n *   tokenIn: '0x...',\n *   tokenOut: '0x...',\n *   fee: 3000\n * }, 137); // Polygon chain ID\n * \n * if (result.success) {\n *   console.log('Price slippage:', result.data.priceSlippagePercent, '%');\n *   console.log('Current price:', result.data.currentPrice);\n *   console.log('Price after swap:', result.data.priceAfter);\n * }\n * ```\n */\nexport async function simulateSwapWithSlippage(\n  publicClient: PublicClient,\n  params: SwapWithSlippageParams,\n  chainId: number\n): Promise<SteerResponse<SwapWithSlippageResponse>> {\n  try {\n    // Validate params\n    validateSwapWithSlippageParams(params);\n\n    // Step 1: Get current pool state from slot0\n\n    const slot0Result = await getPoolSlot0(\n      publicClient,\n      params.poolAddress as `0x${string}`,\n      params.ammType\n    )\n\n    if (!slot0Result.data) {\n      throw new Error('Failed to get pool slot0 data');\n    }\n\n    // Decode slot0 result\n    const currentSlot0: PoolSlot0 = {\n      sqrtPriceX96: getPoolPrice(slot0Result.data, {\n        isAlgebraPool: params.ammType === AMMType.Algebra,\n        isAlgebraIntegralPool: params.ammType === AMMType.AlgebraIntegral,\n        isPoolSharkPool: false // PoolShark not defined in AMMType enum\n      }) || BigInt(0),\n      tick: slot0Result.data.tick,\n      observationIndex: slot0Result.data.observationIndex,\n      observationCardinality: slot0Result.data.observationCardinality,\n      observationCardinalityNext: slot0Result.data.observationCardinalityNext,\n      feeProtocol: slot0Result.data.feeProtocol,\n      unlocked: slot0Result.data.unlocked\n    };\n\n    const tickSpacing = await publicClient.readContract({\n      abi: [  {\n        \"inputs\": [],\n        \"name\": \"tickSpacing\",\n        \"outputs\": [\n          {\n            \"internalType\": \"int24\",\n            \"name\": \"\",\n            \"type\": \"int24\"\n          }\n        ],\n        \"stateMutability\": \"view\",\n        \"type\": \"function\"\n      },],\n      functionName: 'tickSpacing',\n      address: params.poolAddress as `0x${string}`,\n    })\n\n    // Step 2: Simulate the swap using existing function\n    const swapParams: SimulateSwapParams = {\n      pool: params.poolAddress as `0x${string}`,\n      recipient: params.recipient as `0x${string}`,\n      zeroForOne: params.zeroForOne,\n      amountSpecified: params.amountSpecified,\n      sqrtPriceLimitX96: params.sqrtPriceLimitX96,\n      ammType: params.ammType,\n      tokenIn: params.tokenIn as `0x${string}`,\n      tokenOut: params.tokenOut as `0x${string}`,\n      fee: params.fee,\n      tickSpacing: tickSpacing,\n      quoterAddress: params.quoterAddress as `0x${string}` | undefined,\n      protocol: params.protocol\n    };\n\n    const swapResult = await simulateSwap(publicClient, swapParams, chainId);\n\n    if (!swapResult.success || !swapResult.data) {\n      throw new Error(swapResult.error || 'Swap simulation failed');\n    }\n\n    // Step 3: Calculate price slippage\n    const currentPrice = getQuoteFromSqrtRatioX96(\n      bigintToDecimal(currentSlot0.sqrtPriceX96),\n      bigintToDecimal(10n**18n),\n      params.tokenIn as `0x${string}`,\n      params.tokenOut as `0x${string}`\n    );\n    const priceAfter = getQuoteFromSqrtRatioX96(\n      bigintToDecimal(swapResult.data.sqrtPriceX96After),\n      bigintToDecimal(10n**18n),\n      params.tokenIn as `0x${string}`,\n      params.tokenOut as `0x${string}`\n    );\n    \n    // Calculate slippage percentage\n    // Positive slippage means unfavorable price movement\n    const priceSlippagePercent = calculatePriceSlippage(\n      currentPrice,\n      priceAfter,\n      params.zeroForOne\n    );\n\n    return {\n      data: {\n        currentSlot0,\n        swapSimulation: swapResult.data,\n        priceSlippagePercent: priceSlippagePercent.toFixed(5),\n        currentPrice: decimalToBigint(currentPrice),\n        priceAfter: decimalToBigint(priceAfter)\n      },\n      status: 200,\n      success: true\n    };\n  } catch (error) {\n    return {\n      data: null,\n      status: 500,\n      success: false,\n      error: error instanceof Error ? error.message : 'Failed to simulate swap with slippage'\n    };\n  }\n}\n\n/**\n * Calculates price slippage percentage using Decimal.js\n * \n * @param priceBefore - Price before the swap (Decimal)\n * @param priceAfter - Price after the swap (Decimal)\n * @param zeroForOne - Swap direction (true if token0 → token1)\n * @returns Slippage percentage (positive means unfavorable movement)\n */\nfunction calculatePriceSlippage(\n  priceBefore: Decimal,\n  priceAfter: Decimal,\n  zeroForOne: boolean\n): Decimal {\n  if (priceBefore.isZero()) {\n    throw new Error('Price before cannot be zero');\n  }\n\n  const priceChange = priceAfter.minus(priceBefore).dividedBy(priceBefore).times(100);\n  \n  // For zeroForOne swaps (selling token0), favorable movement is price going down\n  // For oneForZero swaps (selling token1), favorable movement is price going up\n  // We return positive values for unfavorable movement (slippage)\n  return zeroForOne ? priceChange : priceChange.negated();\n}\n\n/**\n * Validates swap with slippage parameters\n * \n * @param params - Parameters to validate\n * @throws Error if parameters are invalid\n */\nfunction validateSwapWithSlippageParams(params: SwapWithSlippageParams): void {\n  if (!params.poolAddress || params.poolAddress === '0x0000000000000000000000000000000000000000') {\n    throw new Error('Invalid pool address');\n  }\n  \n  if (!params.recipient || params.recipient === '0x0000000000000000000000000000000000000000') {\n    throw new Error('Invalid recipient address');\n  }\n  \n  if (params.amountSpecified <= 0n) {\n    throw new Error('Amount specified must be greater than 0');\n  }\n  \n  if (params.sqrtPriceLimitX96 <= 0n) {\n    throw new Error('Sqrt price limit must be greater than 0');\n  }\n\n  if (!params.tokenIn || params.tokenIn === '0x0000000000000000000000000000000000000000') {\n    throw new Error('Invalid tokenIn address');\n  }\n\n  if (!params.tokenOut || params.tokenOut === '0x0000000000000000000000000000000000000000') {\n    throw new Error('Invalid tokenOut address');\n  }\n\n  if (params.fee <= 0) {\n    throw new Error('Pool fee must be greater than 0');\n  }\n} "]}