@steerprotocol/sdk 1.19.16 → 1.19.18

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

@@ -1,17 +1,456 @@
-import type { Address } from 'viem';
-import { Chain } from './chain';
+import type { Address, PublicClient } from 'viem';
+import { Protocol } from "./chain";
+import { UniswapV3QuoterABI, QuickSwapQuoterV2, QuoterV2Thick, QuoterV2AlgebgraIntegral, QuoterV2AlgebgraIntegral21, QuoterV2Shadow } from "./abis/quoter";
+import { NetworkConfig } from './network';
 /**
- * Get the Quoter contract address for a given chain
- * @param chain - The chain to get the Quoter address for
- * @returns The Quoter contract address
- * @throws Error if no Quoter address is available for the chain
+ * Base interface for quote parameters
  */
-export declare function getQuoterAddress(chain: Chain): Address;
+export interface BaseQuoteParams {
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: bigint;
+}
 /**
- * Get the Quoter contract address for a given chain ID
- * @param chainId - The chain ID to get the Quoter address for
- * @returns The Quoter contract address
- * @throws Error if no Quoter address is available for the chain ID
+ * Quote parameters for Uniswap V3 style quoters (fee-based)
  */
-export declare function getQuoterAddressByChainId(chainId: number): Address;
+export interface UniswapQuoteParams extends BaseQuoteParams {
+    fee: number;
+    sqrtPriceLimitX96?: bigint;
+}
+/**
+ * Quote parameters for Algebra style quoters (limit price)
+ */
+export interface AlgebraQuoteParams extends BaseQuoteParams {
+    limitSqrtPrice?: bigint;
+}
+/**
+ * Quote parameters for Thick V2 quoters (tick spacing)
+ */
+export interface ThickQuoteParams extends BaseQuoteParams {
+    tickSpacing: number;
+    sqrtPriceLimitX96?: bigint;
+}
+/**
+ * Quote parameters for Algebra Integral v2.1 quoters (with deployer)
+ */
+export interface AlgebraIntegral21QuoteParams extends BaseQuoteParams {
+    deployer: Address;
+    limitSqrtPrice?: bigint;
+}
+/**
+ * Quote parameters for Shadow quoters (tick spacing)
+ */
+export interface ShadowQuoteParams extends BaseQuoteParams {
+    tickSpacing: number;
+    sqrtPriceLimitX96?: bigint;
+}
+/**
+ * Union type for all possible quote parameters
+ */
+export type QuoteParams = UniswapQuoteParams | AlgebraQuoteParams | ThickQuoteParams | AlgebraIntegral21QuoteParams | ShadowQuoteParams;
+/**
+ * Union type for all possible QuoterV2 ABIs
+ */
+export type QuoterV2ABI = typeof UniswapV3QuoterABI | typeof QuickSwapQuoterV2 | typeof QuoterV2Thick | typeof QuoterV2AlgebgraIntegral | typeof QuoterV2AlgebgraIntegral21 | typeof QuoterV2Shadow;
+/**
+ * Union type for all possible quoter function arguments
+ */
+export type QuoterFunctionArgs = {
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: bigint;
+    fee: number;
+    sqrtPriceLimitX96: bigint;
+} | {
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: bigint;
+    limitSqrtPrice: bigint;
+} | {
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: bigint;
+    tickSpacing: number;
+    sqrtPriceLimitX96: bigint;
+} | {
+    tokenIn: Address;
+    tokenOut: Address;
+    deployer: Address;
+    amountIn: bigint;
+    limitSqrtPrice: bigint;
+};
+/**
+ * Factory class for creating QuoterV2 contract instances with the appropriate ABI
+ * based on the protocol type detected from beacon names.
+ *
+ * @example
+ * ```typescript
+ * import { createPublicClient, http, parseEther } from 'viem';
+ * import { polygon } from 'viem/chains';
+ * import { QuoterV2Factory } from './quoter';
+ *
+ * // Create a viem client
+ * const client = createPublicClient({
+ *   chain: polygon,
+ *   transport: http()
+ * });
+ *
+ * // Configure network with quoter addresses
+ * const networkConfig = {
+ *   quoterV2: {
+ *     'QuickSwap': '0x...',
+ *     'Uniswap': '0x...',
+ *     'ThickV2': '0x...',
+ *     'Shadow': '0x...',
+ *     'KatanaIntegral': '0x...'
+ *   }
+ * };
+ *
+ * const factory = new QuoterV2Factory(networkConfig);
+ *
+ * // Example 1: Uniswap V3 style (fee-based)
+ * const { quoter: uniQuoter, params: uniParams } = factory.createQuoterWithParams('uniswap', client, {
+ *   tokenIn: '0xA0b86a33E6f73c7C6789b65f71C1ab8EbAbD3A01',
+ *   tokenOut: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174',
+ *   amountIn: parseEther('1'),
+ *   fee: 3000,
+ *   sqrtPriceLimitX96: 0n
+ * });
+ *
+ * // Example 2: QuickSwap (Algebra style)
+ * const { quoter: quickQuoter, params: quickParams } = factory.createQuoterWithParams('quickswap', client, {
+ *   tokenIn: '0xA0b86a33E6f73c7C6789b65f71C1ab8EbAbD3A01',
+ *   tokenOut: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174',
+ *   amountIn: parseEther('1'),
+ *   limitSqrtPrice: 0n
+ * });
+ *
+ * // Example 3: Thick V2 (tick spacing)
+ * const { quoter: thickQuoter, params: thickParams } = factory.createQuoterWithParams('thickv2', client, {
+ *   tokenIn: '0xA0b86a33E6f73c7C6789b65f71C1ab8EbAbD3A01',
+ *   tokenOut: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174',
+ *   amountIn: parseEther('1'),
+ *   tickSpacing: 60,
+ *   sqrtPriceLimitX96: 0n
+ * });
+ *
+ * // Example 4: Katana Integral (with deployer)
+ * const { quoter: katanaQuoter, params: katanaParams } = factory.createQuoterWithParams('katanaintegral', client, {
+ *   tokenIn: '0xA0b86a33E6f73c7C6789b65f71C1ab8EbAbD3A01',
+ *   tokenOut: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174',
+ *   amountIn: parseEther('1'),
+ *   deployer: '0x...',
+ *   limitSqrtPrice: 0n
+ * });
+ *
+ * // Use the quoter contracts
+ * const uniResult = await uniQuoter.read.quoteExactInputSingle([uniParams]);
+ * const quickResult = await quickQuoter.read.quoteExactInputSingle([quickParams]);
+ * const thickResult = await thickQuoter.read.quoteExactInputSingle([thickParams]);
+ * const katanaResult = await katanaQuoter.read.quoteExactInputSingle([katanaParams]);
+ * ```
+ */
+export declare class QuoterV2Factory {
+    private networkConfig;
+    constructor(networkConfig: NetworkConfig);
+    /**
+     * Creates quote parameters for the quoteExactInputSingle function based on the protocol type.
+     *
+     * @param beaconName - The beacon identifier to determine the protocol type
+     * @param params - The input parameters for the quote
+     * @returns Formatted parameters object for the specific protocol's quoteExactInputSingle function
+     * @throws Error if protocol type is not supported
+     *
+     * @example
+     * ```typescript
+     * const factory = new QuoterV2Factory(networkConfig);
+     *
+     * // For Uniswap V3
+     * const uniParams = factory.getQuoteParams('uniswap', {
+     *   tokenIn: '0x...',
+     *   tokenOut: '0x...',
+     *   amountIn: parseEther('1'),
+     *   fee: 3000,
+     *   sqrtPriceLimitX96: 0n
+     * });
+     *
+     * // For QuickSwap (Algebra)
+     * const quickParams = factory.getQuoteParams('quickswap', {
+     *   tokenIn: '0x...',
+     *   tokenOut: '0x...',
+     *   amountIn: parseEther('1'),
+     *   limitSqrtPrice: 0n
+     * });
+     * ```
+     */
+    getQuoteParams(protocol: Protocol, params: QuoteParams): {
+        tokenIn: `0x${string}`;
+        tokenOut: `0x${string}`;
+        deployer: `0x${string}`;
+        amountIn: bigint;
+        limitSqrtPrice: bigint;
+        tickSpacing?: undefined;
+        sqrtPriceLimitX96?: undefined;
+        fee?: undefined;
+    } | {
+        tokenIn: `0x${string}`;
+        tokenOut: `0x${string}`;
+        amountIn: bigint;
+        tickSpacing: number;
+        sqrtPriceLimitX96: bigint;
+        deployer?: undefined;
+        limitSqrtPrice?: undefined;
+        fee?: undefined;
+    } | {
+        tokenIn: `0x${string}`;
+        tokenOut: `0x${string}`;
+        amountIn: bigint;
+        limitSqrtPrice: bigint;
+        deployer?: undefined;
+        tickSpacing?: undefined;
+        sqrtPriceLimitX96?: undefined;
+        fee?: undefined;
+    } | {
+        tokenIn: `0x${string}`;
+        tokenOut: `0x${string}`;
+        amountIn: bigint;
+        fee: number;
+        sqrtPriceLimitX96: bigint;
+        deployer?: undefined;
+        limitSqrtPrice?: undefined;
+        tickSpacing?: undefined;
+    };
+    /**
+     * Creates a QuoterV2 contract instance with the appropriate ABI for the given beacon.
+     *
+     * @param beaconName - The beacon identifier to determine the protocol type
+     * @param client - The viem client for contract interactions
+     * @returns A viem contract instance with the appropriate ABI
+     * @throws Error if quoter address is not found for the protocol
+     */
+    createQuoterV2(protocol: Protocol, client: PublicClient): {
+        read: {
+            [x: string]: (args: readonly unknown[], options?: import("viem").Prettify<import("viem").UnionOmit<import("viem").ReadContractParameters<QuoterV2ABI, never, readonly unknown[]>, "address" | "abi" | "functionName" | "args">> | undefined) => Promise<unknown>;
+        };
+        estimateGas: {
+            [x: string]: (args: readonly unknown[], options: import("viem").Prettify<import("viem").UnionOmit<import("viem").EstimateContractGasParameters<QuoterV2ABI, never, readonly unknown[], import("viem").Chain | undefined>, "address" | "abi" | "functionName" | "args">>) => Promise<import("viem").EstimateContractGasReturnType>;
+        } & {
+            [x: string]: (args: readonly unknown[], options: import("viem").Prettify<import("viem").UnionOmit<import("viem").EstimateContractGasParameters<QuoterV2ABI, never, readonly unknown[], import("viem").Chain | undefined>, "address" | "abi" | "functionName" | "args">>) => Promise<import("viem").EstimateContractGasReturnType>;
+        };
+        simulate: {
+            [x: string]: <chainOverride extends import("viem").Chain | undefined = undefined, accountOverride extends import("viem").Account | Address | undefined = undefined>(args: readonly unknown[], options?: Omit<import("viem").SimulateContractParameters<QuoterV2ABI, never, readonly unknown[], import("viem").Chain | undefined, chainOverride, accountOverride>, "address" | "abi" | "functionName" | "args"> | undefined) => Promise<import("viem").SimulateContractReturnType<QuoterV2ABI, never, readonly unknown[], import("viem").Chain | undefined, undefined, chainOverride, accountOverride>>;
+        };
+        createEventFilter: {
+            [x: string]: <const args extends Record<string, unknown> | readonly unknown[] | undefined, strict extends boolean | undefined = undefined>(options?: ({
+                fromBlock?: bigint | import("viem").BlockTag | undefined;
+                toBlock?: bigint | import("viem").BlockTag | undefined;
+            } & {
+                strict?: strict | undefined;
+            }) | undefined) => Promise<import("viem").CreateContractEventFilterReturnType<QuoterV2ABI, string, args, strict>>;
+        };
+        getEvents: {
+            [x: string]: (options?: {
+                strict?: boolean | undefined;
+                fromBlock?: bigint | import("viem").BlockTag | undefined;
+                toBlock?: bigint | import("viem").BlockTag | undefined;
+                blockHash?: `0x${string}` | undefined;
+            } | undefined) => Promise<import("viem").GetContractEventsReturnType<QuoterV2ABI, string>>;
+        };
+        watchEvent: {
+            [x: string]: (options: {
+                batch?: boolean | undefined | undefined;
+                pollingInterval?: number | undefined | undefined;
+                strict?: boolean | undefined;
+                fromBlock?: bigint | undefined;
+                onError?: ((error: Error) => void) | undefined | undefined;
+                onLogs: import("viem").WatchContractEventOnLogsFn<QuoterV2ABI, string, undefined>;
+                poll?: true | undefined | undefined;
+            }) => import("viem").WatchContractEventReturnType;
+        };
+        write: {
+            [x: string]: <chainOverride extends import("viem").Chain | undefined, options extends import("viem").UnionOmit<import("viem").WriteContractParameters<QuoterV2ABI, never, readonly unknown[], import("viem").Chain | undefined, undefined, chainOverride>, "address" | "abi" | "functionName" | "args"> extends infer T ? { [K in keyof T]: import("viem").UnionOmit<import("viem").WriteContractParameters<QuoterV2ABI, never, readonly unknown[], import("viem").Chain | undefined, undefined, chainOverride>, "address" | "abi" | "functionName" | "args">[K]; } : never>(args: readonly unknown[], options: options) => Promise<import("viem").WriteContractReturnType>;
+        };
+        address: `0x${string}`;
+        abi: QuoterV2ABI;
+    };
+    /**
+     * Convenience function that creates both the quoter contract and properly formatted quote parameters.
+     *
+     * @param beaconName - The beacon identifier to determine the protocol type
+     * @param client - The viem client for contract interactions
+     * @param params - The input parameters for the quote
+     * @returns Object containing the quoter contract and formatted parameters
+     * @throws Error if quoter address is not found for the protocol
+     *
+     * @example
+     * ```typescript
+     * const factory = new QuoterV2Factory(networkConfig);
+     *
+     * const { quoter, params } = factory.createQuoterWithParams('quickswap', client, {
+     *   tokenIn: '0x...',
+     *   tokenOut: '0x...',
+     *   amountIn: parseEther('1'),
+     *   limitSqrtPrice: 0n
+     * });
+     *
+     * // Use directly
+     * const result = await quoter.read.quoteExactInputSingle([params]);
+     * ```
+     */
+    createQuoterWithParams(protocol: Protocol, client: PublicClient, params: QuoteParams): {
+        quoter: {
+            read: {
+                [x: string]: (args: readonly unknown[], options?: import("viem").Prettify<import("viem").UnionOmit<import("viem").ReadContractParameters<QuoterV2ABI, never, readonly unknown[]>, "address" | "abi" | "functionName" | "args">> | undefined) => Promise<unknown>;
+            };
+            estimateGas: {
+                [x: string]: (args: readonly unknown[], options: import("viem").Prettify<import("viem").UnionOmit<import("viem").EstimateContractGasParameters<QuoterV2ABI, never, readonly unknown[], import("viem").Chain | undefined>, "address" | "abi" | "functionName" | "args">>) => Promise<import("viem").EstimateContractGasReturnType>;
+            } & {
+                [x: string]: (args: readonly unknown[], options: import("viem").Prettify<import("viem").UnionOmit<import("viem").EstimateContractGasParameters<QuoterV2ABI, never, readonly unknown[], import("viem").Chain | undefined>, "address" | "abi" | "functionName" | "args">>) => Promise<import("viem").EstimateContractGasReturnType>;
+            };
+            simulate: {
+                [x: string]: <chainOverride extends import("viem").Chain | undefined = undefined, accountOverride extends import("viem").Account | Address | undefined = undefined>(args: readonly unknown[], options?: Omit<import("viem").SimulateContractParameters<QuoterV2ABI, never, readonly unknown[], import("viem").Chain | undefined, chainOverride, accountOverride>, "address" | "abi" | "functionName" | "args"> | undefined) => Promise<import("viem").SimulateContractReturnType<QuoterV2ABI, never, readonly unknown[], import("viem").Chain | undefined, undefined, chainOverride, accountOverride>>;
+            };
+            createEventFilter: {
+                [x: string]: <const args extends Record<string, unknown> | readonly unknown[] | undefined, strict extends boolean | undefined = undefined>(options?: ({
+                    fromBlock?: bigint | import("viem").BlockTag | undefined;
+                    toBlock?: bigint | import("viem").BlockTag | undefined;
+                } & {
+                    strict?: strict | undefined;
+                }) | undefined) => Promise<import("viem").CreateContractEventFilterReturnType<QuoterV2ABI, string, args, strict>>;
+            };
+            getEvents: {
+                [x: string]: (options?: {
+                    strict?: boolean | undefined;
+                    fromBlock?: bigint | import("viem").BlockTag | undefined;
+                    toBlock?: bigint | import("viem").BlockTag | undefined;
+                    blockHash?: `0x${string}` | undefined;
+                } | undefined) => Promise<import("viem").GetContractEventsReturnType<QuoterV2ABI, string>>;
+            };
+            watchEvent: {
+                [x: string]: (options: {
+                    batch?: boolean | undefined | undefined;
+                    pollingInterval?: number | undefined | undefined;
+                    strict?: boolean | undefined;
+                    fromBlock?: bigint | undefined;
+                    onError?: ((error: Error) => void) | undefined | undefined;
+                    onLogs: import("viem").WatchContractEventOnLogsFn<QuoterV2ABI, string, undefined>;
+                    poll?: true | undefined | undefined;
+                }) => import("viem").WatchContractEventReturnType;
+            };
+            write: {
+                [x: string]: <chainOverride extends import("viem").Chain | undefined, options extends import("viem").UnionOmit<import("viem").WriteContractParameters<QuoterV2ABI, never, readonly unknown[], import("viem").Chain | undefined, undefined, chainOverride>, "address" | "abi" | "functionName" | "args"> extends infer T ? { [K in keyof T]: import("viem").UnionOmit<import("viem").WriteContractParameters<QuoterV2ABI, never, readonly unknown[], import("viem").Chain | undefined, undefined, chainOverride>, "address" | "abi" | "functionName" | "args">[K]; } : never>(args: readonly unknown[], options: options) => Promise<import("viem").WriteContractReturnType>;
+            };
+            address: `0x${string}`;
+            abi: QuoterV2ABI;
+        };
+        params: {
+            tokenIn: `0x${string}`;
+            tokenOut: `0x${string}`;
+            deployer: `0x${string}`;
+            amountIn: bigint;
+            limitSqrtPrice: bigint;
+            tickSpacing?: undefined;
+            sqrtPriceLimitX96?: undefined;
+            fee?: undefined;
+        } | {
+            tokenIn: `0x${string}`;
+            tokenOut: `0x${string}`;
+            amountIn: bigint;
+            tickSpacing: number;
+            sqrtPriceLimitX96: bigint;
+            deployer?: undefined;
+            limitSqrtPrice?: undefined;
+            fee?: undefined;
+        } | {
+            tokenIn: `0x${string}`;
+            tokenOut: `0x${string}`;
+            amountIn: bigint;
+            limitSqrtPrice: bigint;
+            deployer?: undefined;
+            tickSpacing?: undefined;
+            sqrtPriceLimitX96?: undefined;
+            fee?: undefined;
+        } | {
+            tokenIn: `0x${string}`;
+            tokenOut: `0x${string}`;
+            amountIn: bigint;
+            fee: number;
+            sqrtPriceLimitX96: bigint;
+            deployer?: undefined;
+            limitSqrtPrice?: undefined;
+            tickSpacing?: undefined;
+        };
+    };
+    /**
+     * Gets the appropriate QuoterV2 ABI based on the beacon name and protocol.
+     *
+     * @param protocol - The detected protocol type
+     * @returns The appropriate ABI array
+     */
+    getQuoterAbi(protocol: Protocol | null): QuoterV2ABI;
+    /**
+     * Gets the QuoterV2 address for the given protocol from the network configuration.
+     *
+     * @param protocol - The protocol type
+     * @returns The quoter address or undefined if not found
+     */
+    getQuoterV2Address(protocol: Protocol | null): string | undefined;
+    /**
+     * Checks if the beacon represents an Algebra Integral v2.1 vault.
+     *
+     * @param beaconName - The beacon identifier
+     * @returns True if it's an Algebra Integral v2.1 vault
+     */
+    private isAlgebraIntegral21Vault;
+}
+/**
+ * Helper function to get QuoterV2 address for a protocol from network config.
+ *
+ * @param protocol - The protocol to get the quoter address for
+ * @param networkConfig - The network configuration object
+ * @returns The quoter address or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const quoterAddress = getQuoterV2Address(Protocol.QuickSwap, networkConfig);
+ * if (quoterAddress) {
+ *   // Use the quoter address
+ * }
+ * ```
+ */
+/**
+ * Type guard to check if parameters are for Uniswap V3 style quoter
+ */
+export declare function isUniswapQuoteParams(params: QuoteParams): params is UniswapQuoteParams;
+/**
+ * Type guard to check if parameters are for Algebra style quoter
+ */
+export declare function isAlgebraQuoteParams(params: QuoteParams): params is AlgebraQuoteParams;
+/**
+ * Type guard to check if parameters are for Thick V2 style quoter
+ */
+export declare function isThickQuoteParams(params: QuoteParams): params is ThickQuoteParams;
+/**
+ * Type guard to check if parameters are for Algebra Integral v2.1 style quoter
+ */
+export declare function isAlgebraIntegral21QuoteParams(params: QuoteParams): params is AlgebraIntegral21QuoteParams;
+/**
+ * Type guard to check if parameters are for Shadow style quoter
+ */
+export declare function isShadowQuoteParams(params: QuoteParams): params is ShadowQuoteParams;
+/**
+ * Validates quote parameters based on the protocol type detected from beacon name
+ *
+ * @param beaconName - The beacon identifier to determine the protocol type
+ * @param params - The parameters to validate
+ * @throws Error if parameters don't match the expected protocol type
+ */
+export declare function validateQuoteParams(protocol: Protocol, params: QuoteParams): void;
+/**
+ * Gets the expected parameter type for a given beacon name
+ *
+ * @param beaconName - The beacon identifier
+ * @returns String describing the expected parameter type
+ */
+export declare function getExpectedParamType(beaconName: string): string;
 //# sourceMappingURL=quoter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"quoter.d.ts","sourceRoot":"","sources":["../../../src/const/quoter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,EAAE,KAAK,EAAW,MAAM,SAAS,CAAC;AAKzC;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAYtD;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAYlE"}
+{"version":3,"file":"quoter.d.ts","sourceRoot":"","sources":["../../../src/const/quoter.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steerprotocol/sdk",
-  "version": "1.19.16",
+  "version": "1.19.18",
   "description": "Steer Protocol SDK",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",