@steerprotocol/sdk 1.19.15 → 1.19.16

package/dist/types/base/vault/single-asset/singleAssetDeposit.d.ts

@@ -0,0 +1,141 @@
+import type { Hash, PublicClient, WalletClient } from 'viem';
+import { SteerResponse } from '../../../types';
+import type { SingleAssetDepositParams, SingleAssetDepositPreview } from './types';
+import { AMMType } from './types';
+/**
+ * Main single-asset deposit client that orchestrates all the steps
+ */
+export declare class SingleAssetDepositClient {
+    private readonly publicClient;
+    private readonly walletClient;
+    constructor(publicClient: PublicClient, 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);
+     * }
+     * ```
+     */
+    previewDeposit(params: SingleAssetDepositParams, poolAddress: `0x${string}`): Promise<SteerResponse<SingleAssetDepositPreview>>;
+    /**
+     * 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);
+     * }
+     * ```
+     */
+    deposit(params: SingleAssetDepositParams): Promise<SteerResponse<Hash>>;
+    /**
+     * 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
+     */
+    prepareDepositTx(params: SingleAssetDepositParams): Promise<{
+        data: {
+            address: `0x${string}` | undefined;
+            abi: ({
+                type: string;
+                inputs: never[];
+                stateMutability: string;
+                name?: undefined;
+                outputs?: undefined;
+                anonymous?: undefined;
+            } | {
+                type: string;
+                name: string;
+                inputs: {
+                    name: string;
+                    type: string;
+                    internalType: string;
+                }[];
+                outputs: {
+                    name: string;
+                    type: string;
+                    internalType: string;
+                }[];
+                stateMutability: string;
+                anonymous?: undefined;
+            } | {
+                type: string;
+                name: string;
+                inputs: {
+                    name: string;
+                    type: string;
+                    indexed: boolean;
+                    internalType: string;
+                }[];
+                anonymous: boolean;
+                stateMutability?: undefined;
+                outputs?: undefined;
+            } | {
+                type: string;
+                name: string;
+                inputs: {
+                    name: string;
+                    type: string;
+                    internalType: string;
+                }[];
+                stateMutability?: undefined;
+                outputs?: undefined;
+                anonymous?: undefined;
+            })[];
+            functionName: "deposit";
+            args: readonly [bigint, `0x${string}`, `0x${string}`, boolean, bigint, number, AMMType];
+        };
+        status: number;
+        success: boolean;
+        error?: undefined;
+    } | {
+        data: null;
+        status: number;
+        success: boolean;
+        error: string;
+    }>;
+    /**
+     * Validates single-asset deposit parameters
+     *
+     * @param params - Parameters to validate
+     * @throws Error if parameters are invalid
+     */
+    validateDepositParams(params: SingleAssetDepositParams): void;
+}
+//# sourceMappingURL=singleAssetDeposit.d.ts.map

package/dist/types/base/vault/single-asset/singleAssetDeposit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleAssetDeposit.d.ts","sourceRoot":"","sources":["../../../../../src/base/vault/single-asset/singleAssetDeposit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,IAAI,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAItE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAK/C,OAAO,KAAK,EAGV,wBAAwB,EACxB,yBAAyB,EAC1B,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAElC;;GAEG;AACH,qBAAa,wBAAwB;IAEjC,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,YAAY;gBADZ,YAAY,EAAE,YAAY,EAC1B,YAAY,EAAE,YAAY;IAG7C;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACU,cAAc,CACzB,MAAM,EAAE,wBAAwB,EAChC,WAAW,EAAE,KAAK,MAAM,EAAE,GACzB,OAAO,CAAC,aAAa,CAAC,yBAAyB,CAAC,CAAC;IAmJpD;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACU,OAAO,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IAgDpF;;;;;;OAMG;IACU,gBAAgB,CAAC,MAAM,EAAE,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0D9D;;;;;OAKG;IACI,qBAAqB,CAAC,MAAM,EAAE,wBAAwB,GAAG,IAAI;CA6BrE"}

package/dist/types/base/vault/single-asset/types.d.ts

@@ -0,0 +1,167 @@
+import type { Address } from 'viem';
+import { SwapWithSlippageResponse } from './simulateSwap';
+/**
+ * AMM Types supported by single-asset deposits
+ */
+export declare enum AMMType {
+    UniswapV3 = 0,
+    Algebra = 1,
+    AlgebraDirectional = 2,
+    AlgebraVE33 = 3,
+    AlgebraIntegral = 4
+}
+/**
+ * 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;
+}
+/**
+ * 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;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/base/vault/single-asset/types.d.ts.map

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

package/dist/types/base/vault/utils.d.ts

@@ -1,5 +1,20 @@
 import { Address, PublicClient } from 'viem';
 import { PoolSharkGlobalState, Slot0, SteerResponse } from '../../types';
+/**
+ * Parameters for getting pool state across different AMM types
+ */
+export interface PoolStateParams {
+    /** The pool address */
+    poolAddress: Address;
+    /** Whether the pool is an Algebra pool */
+    isAlgebraPool?: boolean;
+    /** Whether the pool is an Algebra directional pool */
+    isAlgebraDirectionPool?: boolean;
+    /** Whether the pool is a PoolShark pool */
+    isPoolSharkPool?: boolean;
+    /** Whether the pool is an Algebra Integral pool */
+    isAlgebraIntegralPool?: boolean;
+}
 /**
  * Gets slot0 data from a standard Uniswap V3 pool
  * @param poolAddress The pool address
@@ -22,4 +37,84 @@ export declare function getGlobalStatePoolShark(publicClient: PublicClient, pool
  * @param isDirectional Whether the pool is directional
  */
 export declare function getGlobalStateAlgebraIntegral(publicClient: PublicClient, poolAddress: Address, isDirectional?: boolean): Promise<SteerResponse<Slot0>>;
+/**
+ * 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
+ * });
+ * ```
+ */
+export declare function getPoolState(publicClient: PublicClient, params: PoolStateParams): Promise<SteerResponse<Slot0>>;
+/**
+ * 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);
+ * }
+ * ```
+ */
+export declare function getPoolPrice(poolStateData: Slot0, params: Pick<PoolStateParams, 'isAlgebraPool' | 'isAlgebraIntegralPool' | 'isPoolSharkPool'>): bigint | 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);
+ * }
+ * ```
+ */
+export declare function getPoolStateWithPrice(publicClient: PublicClient, params: PoolStateParams): Promise<SteerResponse<{
+    state: Slot0;
+    price: bigint | null;
+}>>;
 //# sourceMappingURL=utils.d.ts.map

package/dist/types/base/vault/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/base/vault/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAC7C,OAAO,EAAE,oBAAoB,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AA4HzE;;;GAGG;AACH,wBAAsB,QAAQ,CAC5B,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,OAAO,GACnB,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CA6B/B;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,OAAO,EACpB,aAAa,UAAQ,GACpB,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CA6B/B;AAED;;;GAGG;AACH,wBAAsB,uBAAuB,CAC3C,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,OAAO,GACnB,OAAO,CAAC,aAAa,CAAC,oBAAoB,CAAC,CAAC,CAwD9C;AAED;;;;GAIG;AACH,wBAAsB,6BAA6B,CACjD,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,OAAO,EACpB,aAAa,UAAQ,GACpB,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CA6B/B"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/base/vault/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAC7C,OAAO,EAAE,oBAAoB,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEzE;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,uBAAuB;IACvB,WAAW,EAAE,OAAO,CAAC;IACrB,0CAA0C;IAC1C,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,sDAAsD;IACtD,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,2CAA2C;IAC3C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,mDAAmD;IACnD,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AA4HD;;;GAGG;AACH,wBAAsB,QAAQ,CAC5B,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,OAAO,GACnB,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CA6C/B;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,OAAO,EACpB,aAAa,UAAQ,GACpB,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CA6B/B;AAED;;;GAGG;AACH,wBAAsB,uBAAuB,CAC3C,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,OAAO,GACnB,OAAO,CAAC,aAAa,CAAC,oBAAoB,CAAC,CAAC,CAwD9C;AAED;;;;GAIG;AACH,wBAAsB,6BAA6B,CACjD,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,OAAO,EACpB,aAAa,UAAQ,GACpB,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CA6B/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,YAAY,CAChC,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAoE/B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,YAAY,CAC1B,aAAa,EAAE,KAAK,EACpB,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,eAAe,GAAG,uBAAuB,GAAG,iBAAiB,CAAC,GAC3F,MAAM,GAAG,IAAI,CAwBf;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,qBAAqB,CACzC,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,aAAa,CAAC;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAAC,CA+BhE"}

package/dist/types/const/abis/index.d.ts

@@ -1,4 +1,7 @@
 export * from './erc20';
 export * from './erc721';
 export * from './erc1155';
+export * from './singleTokenDeposit';
+export * from './UniswapPool';
+export * from './quoter';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/const/abis/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/const/abis/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/const/abis/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC"}

package/dist/types/const/abis/quoter.d.ts

@@ -0,0 +1,206 @@
+export declare const UniswapV3QuoterABI: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "_factory";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "_WETH9";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "WETH9";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "factory";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes";
+        readonly name: "path";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amountIn";
+        readonly type: "uint256";
+    }];
+    readonly name: "quoteExactInput";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "amountOut";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint160[]";
+        readonly name: "sqrtPriceX96AfterList";
+        readonly type: "uint160[]";
+    }, {
+        readonly internalType: "uint32[]";
+        readonly name: "initializedTicksCrossedList";
+        readonly type: "uint32[]";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "gasEstimate";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "tokenIn";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "tokenOut";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "amountIn";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "fee";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint160";
+            readonly name: "sqrtPriceLimitX96";
+            readonly type: "uint160";
+        }];
+        readonly internalType: "struct IQuoterV2.QuoteExactInputSingleParams";
+        readonly name: "params";
+        readonly type: "tuple";
+    }];
+    readonly name: "quoteExactInputSingle";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "amountOut";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint160";
+        readonly name: "sqrtPriceX96After";
+        readonly type: "uint160";
+    }, {
+        readonly internalType: "uint32";
+        readonly name: "initializedTicksCrossed";
+        readonly type: "uint32";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "gasEstimate";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes";
+        readonly name: "path";
+        readonly type: "bytes";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amountOut";
+        readonly type: "uint256";
+    }];
+    readonly name: "quoteExactOutput";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "amountIn";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint160[]";
+        readonly name: "sqrtPriceX96AfterList";
+        readonly type: "uint160[]";
+    }, {
+        readonly internalType: "uint32[]";
+        readonly name: "initializedTicksCrossedList";
+        readonly type: "uint32[]";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "gasEstimate";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "tokenIn";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "tokenOut";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "amount";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint24";
+            readonly name: "fee";
+            readonly type: "uint24";
+        }, {
+            readonly internalType: "uint160";
+            readonly name: "sqrtPriceLimitX96";
+            readonly type: "uint160";
+        }];
+        readonly internalType: "struct IQuoterV2.QuoteExactOutputSingleParams";
+        readonly name: "params";
+        readonly type: "tuple";
+    }];
+    readonly name: "quoteExactOutputSingle";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "amountIn";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint160";
+        readonly name: "sqrtPriceX96After";
+        readonly type: "uint160";
+    }, {
+        readonly internalType: "uint32";
+        readonly name: "initializedTicksCrossed";
+        readonly type: "uint32";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "gasEstimate";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "int256";
+        readonly name: "amount0Delta";
+        readonly type: "int256";
+    }, {
+        readonly internalType: "int256";
+        readonly name: "amount1Delta";
+        readonly type: "int256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "path";
+        readonly type: "bytes";
+    }];
+    readonly name: "uniswapV3SwapCallback";
+    readonly outputs: readonly [];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+//# sourceMappingURL=quoter.d.ts.map

package/dist/types/const/abis/quoter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quoter.d.ts","sourceRoot":"","sources":["../../../../src/const/abis/quoter.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmPrB,CAAC"}