@steerprotocol/sdk 1.26.0 → 1.28.0

package/src/const/quoter.ts

@@ -0,0 +1,571 @@
+import type { Address, PublicClient } from 'viem';
+import { getContract } from 'viem';
+import { Protocol } from "./chain.js";
+import { getProtocolTypeByBeacon } from "./amm/utils/beacon.js";
+import { isAlgebraProtocol, isAlgebraIntegralProtocol, isThickV2Protocol, isShadowProtocol } from "./protocol.js";
+import { 
+  UniswapV3QuoterABI, 
+  QuickSwapQuoterV2, 
+  QuoterV2Thick, 
+  QuoterV2AlgebgraIntegral, 
+  QuoterV2AlgebgraIntegral21, 
+  QuoterV2Shadow 
+} from "./abis/quoter.js";
+import { NetworkConfig } from './network.js';
+import { getProtocolContractAddresses } from './amm/index.js';
+
+/**
+ * Base interface for quote parameters
+ */
+export interface BaseQuoteParams {
+  tokenIn: Address;
+  tokenOut: Address;
+  amountIn: bigint;
+}
+
+/**
+ * Quote parameters for Uniswap V3 style quoters (fee-based)
+ */
+export interface UniswapQuoteParams extends BaseQuoteParams {
+  fee: number; // uint24
+  sqrtPriceLimitX96?: bigint; // uint160
+}
+
+/**
+ * Quote parameters for Algebra style quoters (limit price)
+ */
+export interface AlgebraQuoteParams extends BaseQuoteParams {
+  limitSqrtPrice?: bigint; // uint160
+}
+
+/**
+ * Quote parameters for Thick V2 quoters (tick spacing)
+ */
+export interface ThickQuoteParams extends BaseQuoteParams {
+  tickSpacing: number; // int24
+  sqrtPriceLimitX96?: bigint; // uint160
+}
+
+/**
+ * Quote parameters for Algebra Integral v2.1 quoters (with deployer)
+ */
+export interface AlgebraIntegral21QuoteParams extends BaseQuoteParams {
+  deployer: Address;
+  limitSqrtPrice?: bigint; // uint160
+}
+
+/**
+ * Quote parameters for Shadow quoters (tick spacing)
+ */
+export interface ShadowQuoteParams extends BaseQuoteParams {
+  tickSpacing: number; // int24
+  sqrtPriceLimitX96?: bigint; // uint160
+}
+
+/**
+ * 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.js';
+ * 
+ * // 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 class QuoterV2Factory {
+  private networkConfig: NetworkConfig;
+
+  constructor(networkConfig: NetworkConfig) {
+    this.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) {
+    // Validate parameters first
+    validateQuoteParams(protocol, params);
+    
+    if (!protocol) {
+      throw Error('Protocol not found');
+    }
+    // Check for Algebra Integral v2.1 vaults (newer version with deployer)
+    if (this.isAlgebraIntegral21Vault(protocol)) {
+      const p = params as AlgebraIntegral21QuoteParams;
+      return {
+        tokenIn: p.tokenIn,
+        tokenOut: p.tokenOut,
+        deployer: p.deployer,
+        amountIn: p.amountIn,
+        limitSqrtPrice: p.limitSqrtPrice || 0n
+      };
+    }
+
+    // Check for Shadow protocol vaults
+    if (isShadowProtocol(protocol)) {
+      const p = params as ShadowQuoteParams;
+      return {
+        tokenIn: p.tokenIn,
+        tokenOut: p.tokenOut,
+        amountIn: p.amountIn,
+        tickSpacing: p.tickSpacing,
+        sqrtPriceLimitX96: p.sqrtPriceLimitX96 || 0n
+      };
+    }
+
+    // Check for Algebra Integral vaults (older version)
+    if (isAlgebraIntegralProtocol(protocol)) {
+      const p = params as AlgebraQuoteParams;
+      return {
+        tokenIn: p.tokenIn,
+        tokenOut: p.tokenOut,
+        amountIn: p.amountIn,
+        limitSqrtPrice: p.limitSqrtPrice || 0n
+      };
+    }
+
+    // Check for Algebra-based protocols (QuickSwap, etc.)
+    if (protocol && isAlgebraProtocol(protocol)) {
+      const p = params as AlgebraQuoteParams;
+      return {
+        tokenIn: p.tokenIn,
+        tokenOut: p.tokenOut,
+        amountIn: p.amountIn,
+        limitSqrtPrice: p.limitSqrtPrice || 0n
+      };
+    }
+
+    // Check for Thick V2 protocols
+    if (isThickV2Protocol(protocol)) {
+      const p = params as ThickQuoteParams;
+      return {
+        tokenIn: p.tokenIn,
+        tokenOut: p.tokenOut,
+        amountIn: p.amountIn,
+        tickSpacing: p.tickSpacing,
+        sqrtPriceLimitX96: p.sqrtPriceLimitX96 || 0n
+      };
+    }
+
+    // Default to Uniswap V3 style (fee-based)
+    const p = params as UniswapQuoteParams;
+    return {
+      tokenIn: p.tokenIn,
+      tokenOut: p.tokenOut,
+      amountIn: p.amountIn,
+      fee: p.fee,
+      sqrtPriceLimitX96: p.sqrtPriceLimitX96 || 0n
+    };
+  }
+
+  /**
+   * 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) {
+    const quoterV2Address = this.getQuoterV2Address(protocol);
+
+    if (!quoterV2Address) {
+      throw new Error(`QuoterV2 address not found for protocol: ${protocol}`);
+    }
+
+    const abi = this.getQuoterAbi(protocol);
+    
+    return getContract({
+      address: quoterV2Address as Address,
+      abi,
+      client
+    });
+  }
+
+  /**
+   * 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) {
+    const quoter = this.createQuoterV2(protocol, client);
+    const formattedParams = this.getQuoteParams(protocol, params);
+    
+    return {
+      quoter,
+      params: formattedParams
+    };
+  }
+
+  /**
+   * Gets the appropriate QuoterV2 ABI based on the beacon name and protocol.
+   * 
+   * @param protocol - The detected protocol type
+   * @returns The appropriate ABI array
+   */
+  public getQuoterAbi(protocol: Protocol | null): QuoterV2ABI {
+
+    if (!protocol) {
+      throw Error('Protocol not avaiable')
+    }
+    // Check for Algebra Integral v2.1 vaults (newer version)
+    if (this.isAlgebraIntegral21Vault(protocol)) {
+      return QuoterV2AlgebgraIntegral21;
+    }
+
+    // Check for Shadow protocol vaults
+    if (isShadowProtocol(protocol)) {
+      return QuoterV2Shadow;
+    }
+
+    // Check for Algebra Integral vaults (older version)
+    if (isAlgebraIntegralProtocol(protocol)) {
+      return QuoterV2AlgebgraIntegral;
+    }
+
+    // Check for Lynex protocol (special case)
+    if (protocol === Protocol.Lynex) {
+      // Note: Lynex currently uses the same ABI as QuickSwap in this implementation
+      // If Lynex has a different ABI, add it to the ABIs in quoter.ts as QuoterV2Lynex
+      // and import it at the top of this file
+      return QuickSwapQuoterV2;
+    }
+
+    // Check for Algebra-based protocols
+    if (protocol && isAlgebraProtocol(protocol)) {
+      return QuickSwapQuoterV2;
+    }
+
+    // Check for Thick V2 protocols
+    if (isThickV2Protocol(protocol)) {
+      return QuoterV2Thick;
+    }
+
+    // Default to standard Uniswap V3 QuoterV2 ABI
+    return UniswapV3QuoterABI;
+  }
+
+  /**
+   * 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
+   */
+  public getQuoterV2Address(protocol: Protocol | null): string | undefined {
+
+    if (!protocol) {
+      return undefined;
+    }
+    const contractAddresses = getProtocolContractAddresses(protocol, this.networkConfig.name, 'QuoterV2')
+
+    if (!protocol || !contractAddresses) {
+      return undefined;
+    }
+    return contractAddresses.quoterV2Address;
+  }
+
+  /**
+   * 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(protocol: Protocol): boolean {
+    return protocol === Protocol.KatanaIntegral;
+  }
+
+ 
+}
+
+/**
+ * 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 function isUniswapQuoteParams(params: QuoteParams): params is UniswapQuoteParams {
+  return 'fee' in params;
+}
+
+/**
+ * Type guard to check if parameters are for Algebra style quoter
+ */
+export function isAlgebraQuoteParams(params: QuoteParams): params is AlgebraQuoteParams {
+  return 'limitSqrtPrice' in params ;
+}
+
+/**
+ * Type guard to check if parameters are for Thick V2 style quoter
+ */
+export function isThickQuoteParams(params: QuoteParams): params is ThickQuoteParams {
+  return 'tickSpacing' in params && 'sqrtPriceLimitX96' in params;
+}
+
+/**
+ * Type guard to check if parameters are for Algebra Integral v2.1 style quoter
+ */
+export function isAlgebraIntegral21QuoteParams(params: QuoteParams): params is AlgebraIntegral21QuoteParams {
+  return 'deployer' in params;
+}
+
+/**
+ * Type guard to check if parameters are for Shadow style quoter
+ */
+export function isShadowQuoteParams(params: QuoteParams): params is ShadowQuoteParams {
+  return 'tickSpacing' in params && 'sqrtPriceLimitX96' in params;
+}
+
+/**
+ * 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 function validateQuoteParams(protocol: Protocol, params: QuoteParams): void {
+  if (!protocol) {
+    throw Error('Protocol not found');
+  }
+  
+  // Validate required fields
+  if (!params.tokenIn || !params.tokenOut || !params.amountIn) {
+    throw new Error('Missing required parameters: tokenIn, tokenOut, and amountIn are required');
+  }
+
+  // Check for Algebra Integral v2.1 vaults (newer version with deployer)
+  if (protocol === Protocol.KatanaIntegral) {
+    if (!isAlgebraIntegral21QuoteParams(params)) {
+      throw new Error('AlgebraIntegral21QuoteParams required: must include deployer field');
+    }
+    return;
+  }
+
+  // Check for Shadow protocol vaults
+  if (protocol && isShadowProtocol(protocol)) {
+    if (!isShadowQuoteParams(params) && !isThickQuoteParams(params)) {
+      throw new Error('ShadowQuoteParams required: must include tickSpacing field');
+    }
+    return;
+  }
+
+  // Check for Thick V2 protocols
+  if (protocol && isThickV2Protocol(protocol)) {
+    if (!isThickQuoteParams(params)) {
+      throw new Error('ThickQuoteParams required: must include tickSpacing field');
+    }
+    return;
+  }
+
+  // Check for Algebra-based protocols
+  if (protocol && isAlgebraProtocol(protocol)) {
+    if (!isAlgebraQuoteParams(params)) {
+      throw new Error('AlgebraQuoteParams required: limitSqrtPrice field expected');
+    }
+    return;
+  }
+
+  // Default to Uniswap V3 style validation
+  if (!isUniswapQuoteParams(params)) {
+    throw new Error('UniswapQuoteParams required: must include fee field');
+  }
+}
+
+/**
+ * Gets the expected parameter type for a given beacon name
+ * 
+ * @param beaconName - The beacon identifier
+ * @returns String describing the expected parameter type
+ */
+export function getExpectedParamType(beaconName: string): string {
+  const protocol = getProtocolTypeByBeacon(beaconName);
+  
+  if (beaconName.toLowerCase().includes('katanaintegral') || protocol === Protocol.KatanaIntegral) {
+    return 'AlgebraIntegral21QuoteParams (requires: tokenIn, tokenOut, amountIn, deployer, limitSqrtPrice?)';
+  }
+  
+  if (protocol && isShadowProtocol(protocol)) {
+    return 'ShadowQuoteParams (requires: tokenIn, tokenOut, amountIn, tickSpacing, sqrtPriceLimitX96?)';
+  }
+  
+  if (protocol && isThickV2Protocol(protocol)) {
+    return 'ThickQuoteParams (requires: tokenIn, tokenOut, amountIn, tickSpacing, sqrtPriceLimitX96?)';
+  }
+  
+  if (protocol && isAlgebraProtocol(protocol)) {
+    return 'AlgebraQuoteParams (requires: tokenIn, tokenOut, amountIn, limitSqrtPrice?)';
+  }
+  
+  return 'UniswapQuoteParams (requires: tokenIn, tokenOut, amountIn, fee, sqrtPriceLimitX96?)';
+} 

package/src/const/stabilityVaults/index.ts

@@ -0,0 +1,2 @@
+export * from './stabilityVaultsConfig';
+

package/src/const/stabilityVaults/stabilityVaultsConfig.ts

@@ -0,0 +1,41 @@
+import { Chain } from '../chain';
+
+export interface StabilityVaultInfo {
+  beaconContract: string;
+  peripheryAddress: Partial<{ [chain in Chain]: string }>;
+  subgraphUrl: Partial<{ [chain in Chain]: string }>;
+  beaconContractSaga?: string;
+}
+
+
+export const stabilityVaultsConfig: StabilityVaultInfo = {
+  beaconContract: 'TestStabilityVault',
+  beaconContractSaga: 'StabilityTest',
+  peripheryAddress: {
+    [Chain.Arbitrum]: '0xAc9d57AdaDC3593A8BB66729C7d2436dA8A13E7d',
+    [Chain.Saga]: '0x2292d6ad79e932ae80ee6e03607341301705742d',
+  },
+  subgraphUrl: {
+    [Chain.Arbitrum]: 'https://api.subgraph.ormilabs.com/api/public/803c8c8c-be12-4188-8523-b9853e23051d/subgraphs/steer-protocol-arbitrum/preprod/gn',
+    [Chain.Saga]: 'https://api.goldsky.com/api/public/project_clohj3ta78ok12nzs5m8yag0b/subgraphs/steer-protocol-saga-evm-stability/prod/gn',
+  },
+};
+
+/**
+ * Get the periphery address for a specific chain
+ * @param chainId - The chain ID to lookup
+ * @returns The periphery address for the chain, or undefined if not configured
+ */
+export function getStabilityVaultsPeripheryAddress(chain: Chain): string | undefined {
+  return stabilityVaultsConfig.peripheryAddress[chain];
+}
+
+/**
+ * Get the subgraph URL for a specific chain
+ * @param chainId - The chain ID to lookup
+ * @returns The subgraph URL for the chain, or undefined if not configured
+ */
+export function getStabilityVaultsSubgraphUrl(chain: Chain): string | undefined {
+  return stabilityVaultsConfig.subgraphUrl[chain];
+}
+