@bitflowlabs/core-sdk 2.3.0 → 2.3.2-beta.0

package/src/BitflowSDK.ts

@@ -1,1244 +0,0 @@
-import { STACKS_MAINNET } from '@stacks/network';
-import type { StacksProvider } from '@stacks/connect';
-import { validateStacksAddress } from '@stacks/transactions';
-import {
-  SwapContext,
-  Token,
-  SwapOptions,
-  SelectedSwapRoute,
-  QuoteResult,
-  SwapExecutionData,
-  RouteQuote,
-  SwapDataParamsAndPostConditions,
-  BitflowSDKConfig,
-} from './types';
-import { fetchAllTokensFromAPI } from './helpers/fetchDataHelper';
-import { executeSwapHelper } from './helpers/callSwapHelper';
-import {
-  callReadOnlyFunctionHelper,
-  callReadOnlyFunctionHelperWithoutScaling,
-} from './helpers/callReadOnlyHelper';
-import { fetchPossibleSwapsFromAPI } from './helpers/fetchPossibleSwap';
-import { getContractInterfaceAndFunction } from './helpers/getContractInterfaceAndFunction';
-import { configs, validateConfig } from './config';
-import { executeGetParams } from './helpers/callGetSwapParams';
-import {
-  ActionFunctionArgs,
-  AggregatorRouteData,
-  ALLOWED_CONTRACTS,
-  CancelGroupOrderResponse,
-  CancelOrderResponse,
-  CreateGroupOrderParams,
-  CreateGroupOrderResponse,
-  CreateOrderParams,
-  CreateOrderResponse,
-  GetGroupOrderResponse,
-  GetKeeperContractParams,
-  GetKeeperContractResponse,
-  GetOrderResponse,
-  GetQuoteParams,
-  GetQuoteResponse,
-  GetUserResponse,
-  KeeperOrderRouteData,
-} from './keeper/types';
-import {
-  cancelGroupOrderAPI,
-  cancelOrderAPI,
-  createGroupOrderAPI,
-  createOrderAPI,
-  getGroupOrderAPI,
-  getOrCreateKeeperContractAPI,
-  getOrderAPI,
-  getQuoteAPI,
-  getUserAPI,
-} from './keeper/keeperAPI';
-
-export const safeStringify = (obj: any, indent = 2) => {
-  return JSON.stringify(
-    obj,
-    (_, value) => (typeof value === 'bigint' ? value.toString() + 'n' : value),
-    indent
-  );
-};
-
-export class BitflowSDK {
-  private context: SwapContext;
-  private stacksProvider: StacksProvider | undefined;
-
-  constructor(config?: Partial<BitflowSDKConfig>) {
-    if (config) Object.assign(configs, config);
-
-    validateConfig();
-
-    this.context = {
-      availableTokens: [],
-      contractInterfaces: {},
-      functionArgs: {},
-      network: STACKS_MAINNET,
-      swapOptions: {},
-    };
-
-    this.initializeContext();
-  }
-  private async loadConnectDependencies() {
-    if (typeof window === 'undefined') {
-      throw new Error(
-        'Connect features are only available in browser environments'
-      );
-    }
-
-    try {
-      const { getStacksProvider } = await import('@stacks/connect');
-      if (!this.stacksProvider) {
-        this.stacksProvider = await getStacksProvider();
-      }
-      return this.stacksProvider;
-    } catch (error) {
-      console.error('Error loading Stacks Connect:', error);
-      throw new Error('Failed to load Stacks Connect dependencies');
-    }
-  }
-  private async initializeContext(): Promise<void> {
-    this.context.availableTokens = await fetchAllTokensFromAPI();
-  }
-
-  public async getAvailableTokens(): Promise<Token[]> {
-    if (this.context.availableTokens.length === 0) {
-      await this.initializeContext();
-    }
-    return this.context.availableTokens;
-  }
-
-  public async getKeeperTokens(): Promise<Token[]> {
-    if (this.context.availableTokens.length === 0) {
-      await this.initializeContext();
-    }
-    return this.context.availableTokens.filter((token) => token.isKeeperToken);
-  }
-
-  public async getPossibleSwaps(tokenX: string): Promise<SwapOptions> {
-    if (!this.context.swapOptions[tokenX]) {
-      this.context.swapOptions[tokenX] = await fetchPossibleSwapsFromAPI(
-        tokenX
-      );
-    }
-    return this.context.swapOptions[tokenX];
-  }
-
-  public async getKeeperPossibleSwaps(tokenX: string): Promise<SwapOptions> {
-    // Use a separate cache key for keeper routes
-    const cacheKey = `keeper_${tokenX}`;
-    if (!this.context.swapOptions[cacheKey]) {
-      this.context.swapOptions[cacheKey] = await fetchPossibleSwapsFromAPI(
-        tokenX,
-        'KEEPER'
-      );
-    }
-    return this.context.swapOptions[cacheKey];
-  }
-
-  public async getAllPossibleTokenY(tokenX: string): Promise<string[]> {
-    const swapOptions = await this.getPossibleSwaps(tokenX);
-    return Object.keys(swapOptions);
-  }
-
-  public async getAllKeeperPossibleTokenY(tokenX: string): Promise<string[]> {
-    const swapOptions = await this.getKeeperPossibleSwaps(tokenX);
-    return Object.keys(swapOptions);
-  }
-
-  public async getAllPossibleTokenYRoutes(
-    tokenX: string,
-    tokenY: string
-  ): Promise<SelectedSwapRoute[]> {
-    const swapOptions = await this.getPossibleSwaps(tokenX);
-    return swapOptions[tokenY] || [];
-  }
-
-  public async getAllKeeperPossibleTokenYRoutes(
-    tokenX: string,
-    tokenY: string
-  ): Promise<SelectedSwapRoute[]> {
-    const swapOptions = await this.getKeeperPossibleSwaps(tokenX);
-    return swapOptions[tokenY] || [];
-  }
-
-  public async getQuoteForRoute(
-    tokenX: string,
-    tokenY: string,
-    amountInput: number
-  ): Promise<QuoteResult> {
-    const providerAddress = configs.BITFLOW_PROVIDER_ADDRESS;
-
-    const routes = await this.getAllPossibleTokenYRoutes(tokenX, tokenY);
-    const allRoutes: RouteQuote[] = [];
-
-    for (let routeIndex = 0; routeIndex < routes.length; routeIndex++) {
-      const route = routes[routeIndex];
-      try {
-        if (!route.quoteData) {
-          console.warn(
-            `Skipping route ${routeIndex + 1} due to null quoteData:`,
-            route
-          );
-          continue;
-        }
-
-        const {
-          contract,
-          function: functionName,
-          parameters,
-        } = route.quoteData;
-
-        if (!contract || !functionName || !parameters) {
-          console.warn(
-            `Skipping route ${
-              routeIndex + 1
-            } due to missing required properties:`,
-            route.quoteData
-          );
-          continue;
-        }
-
-        const [contractDeployer, contractName] = contract.split('.');
-
-        if (!this.context.contractInterfaces[contract]) {
-          this.context.contractInterfaces[contract] =
-            await getContractInterfaceAndFunction(
-              contractDeployer,
-              contractName,
-              functionName
-            );
-        }
-        const { interface: contractInterface, functionArgs } =
-          this.context.contractInterfaces[contract];
-
-        const params = { ...parameters };
-
-        if ('dx' in params && params.dx === null) {
-          params.dx = amountInput;
-        } else if ('dy' in params && params.dy === null) {
-          params.dy = amountInput;
-        } else if ('amount' in params && params.amount === null) {
-          params.amount = amountInput;
-        } else if ('amt-in' in params && params['amt-in'] === null) {
-          params['amt-in'] = amountInput;
-        } else if ('amt-in-max' in params && params['amt-in-max'] === null) {
-          params['amt-in-max'] = amountInput;
-        } else if ('y-amount' in params && params['y-amount'] === null) {
-          params['y-amount'] = amountInput;
-          params['x-amount'] = amountInput;
-        } else if ('x-amount' in params && params['x-amount'] === null) {
-          params['x-amount'] = amountInput;
-        } else {
-          params.dx = amountInput;
-        }
-        
-        // Robust provider check
-        const functionRequiresProvider = functionArgs.some((arg: { name: string; }) => arg.name === 'provider');
-        if (
-          functionRequiresProvider &&
-          (params.provider === null || params.provider === undefined) &&
-          providerAddress && validateStacksAddress(providerAddress)
-        ) {
-          params.provider = providerAddress;
-        }
-
-        const { convertedResult, rawResult, tokenXDecimals, tokenYDecimals } =
-          await callReadOnlyFunctionHelper(
-            contractDeployer,
-            contractName,
-            functionName,
-            params,
-            contractDeployer,
-            tokenX,
-            tokenY,
-            route.swapData,
-            this.context
-          );
-
-        if (typeof convertedResult === 'number' && convertedResult > 0) {
-          const updatedQuoteData = {
-            ...route.quoteData,
-            parameters: { ...params },
-          };
-
-          const updatedSwapData = {
-            ...route.swapData,
-            parameters: {
-              ...route.swapData.parameters,
-              amount:
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              dx:
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              dy:
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              'amt-in':
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              'amt-in-max':
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              'y-amount':
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              'x-amount':
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-
-              'min-received': rawResult,
-              'min-dy': rawResult,
-              'min-dz': rawResult,
-              'min-dw': rawResult,
-              'amt-out': rawResult,
-              'amt-out-min': rawResult,
-              'min-x-amount': rawResult,
-              'min-dv': rawResult,
-              'min-y-amount': rawResult,
-              'min-dx': rawResult,
-              'provider': 
-                providerAddress ||
-                params.provider
-            },
-          };
-
-          const quoteResult: RouteQuote = {
-            route: {
-              ...route,
-              quoteData: updatedQuoteData,
-              swapData: updatedSwapData,
-            },
-            quote: convertedResult,
-            params: params,
-            quoteData: updatedQuoteData,
-            swapData: updatedSwapData,
-            dexPath: route.dex_path,
-            tokenPath: route.token_path,
-            tokenXDecimals: tokenXDecimals,
-            tokenYDecimals: tokenYDecimals,
-          };
-
-          allRoutes.push(quoteResult);
-        } else {
-          throw new Error('Invalid quote result');
-        }
-      } catch (error) {
-        console.warn(
-          `Failed to get quote for route ${routeIndex + 1}:`,
-          route,
-          error
-        );
-        allRoutes.push({
-          route,
-          quote: null,
-          params: route.quoteData
-            ? { ...route.quoteData.parameters, amountInput }
-            : { amountInput },
-          quoteData: route.quoteData,
-          swapData: route.swapData,
-          dexPath: route.dex_path,
-          tokenPath: route.token_path,
-          tokenXDecimals: route.tokenXDecimals,
-          tokenYDecimals: route.tokenYDecimals,
-          error: (error as Error).message,
-        });
-      }
-    }
-
-    allRoutes.sort((a, b) => (b.quote || 0) - (a.quote || 0));
-
-    const result = {
-      bestRoute: allRoutes[0]?.quote !== null ? allRoutes[0] : null,
-      allRoutes,
-      inputData: { tokenX, tokenY, amountInput, provider: providerAddress },
-    };
-
-    return result;
-  }
-
-  public async getKeeperQuoteForRoute(
-    tokenX: string,
-    tokenY: string,
-    amountInput: number
-  ): Promise<QuoteResult> {
-    const COMPATIBLE_DEX_PATHS = new Set([
-      'BITFLOW_STABLE_XY_2',
-      'BITFLOW_XYK_XY_2',
-    ]);
-
-    const isCompatibleRoute = (dexPath: string[]): boolean => {
-      return dexPath.every((path) => COMPATIBLE_DEX_PATHS.has(path));
-    };
-
-    let routes = await this.getAllPossibleTokenYRoutes(tokenX, tokenY);
-    routes = routes.filter((route) => isCompatibleRoute(route.dex_path));
-
-    const allRoutes: RouteQuote[] = [];
-
-    for (let routeIndex = 0; routeIndex < routes.length; routeIndex++) {
-      const route = routes[routeIndex];
-
-      try {
-        if (!route.quoteData) {
-          console.warn(
-            `Skipping route ${routeIndex + 1} due to null quoteData:`,
-            route
-          );
-          continue;
-        }
-
-        const {
-          contract,
-          function: functionName,
-          parameters,
-        } = route.quoteData;
-
-        if (!contract || !functionName || !parameters) {
-          console.warn(
-            `Skipping route ${
-              routeIndex + 1
-            } due to missing required properties:`,
-            route.quoteData
-          );
-          continue;
-        }
-
-        const [contractDeployer, contractName] = contract.split('.');
-
-        if (!this.context.contractInterfaces[contract]) {
-          this.context.contractInterfaces[contract] =
-            await getContractInterfaceAndFunction(
-              contractDeployer,
-              contractName,
-              functionName
-            );
-        }
-        const { interface: contractInterface, functionArgs } =
-          this.context.contractInterfaces[contract];
-
-        const params = { ...parameters };
-
-        if ('dx' in params && params.dx === null) {
-          params.dx = amountInput;
-        } else if ('dy' in params && params.dy === null) {
-          params.dy = amountInput;
-        } else if ('amount' in params && params.amount === null) {
-          params.amount = amountInput;
-        } else if ('amt-in' in params && params['amt-in'] === null) {
-          params['amt-in'] = amountInput;
-        } else if ('amt-in-max' in params && params['amt-in-max'] === null) {
-          params['amt-in-max'] = amountInput;
-        } else if ('y-amount' in params && params['y-amount'] === null) {
-          params['y-amount'] = amountInput;
-          params['x-amount'] = amountInput;
-        } else if ('x-amount' in params && params['x-amount'] === null) {
-          params['x-amount'] = amountInput;
-        } else {
-          params.dx = amountInput;
-        }
-
-        const { convertedResult, rawResult, tokenXDecimals, tokenYDecimals } =
-          await callReadOnlyFunctionHelper(
-            contractDeployer,
-            contractName,
-            functionName,
-            params,
-            contractDeployer,
-            tokenX,
-            tokenY,
-            route.swapData,
-            this.context
-          );
-
-        if (typeof convertedResult === 'number' && convertedResult > 0) {
-          const updatedQuoteData = {
-            ...route.quoteData,
-            parameters: { ...params },
-          };
-
-          const updatedSwapData = {
-            ...route.swapData,
-            parameters: {
-              ...route.swapData.parameters,
-              amount:
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              dx:
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              'amt-in':
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              'amt-in-max':
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              'y-amount':
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              'x-amount':
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              'min-received': rawResult,
-              'min-dy': rawResult,
-              'min-dz': rawResult,
-              'min-dw': rawResult,
-              'amt-out': rawResult,
-              'amt-out-min': rawResult,
-              'min-x-amount': rawResult,
-              'min-dv': rawResult,
-              'min-y-amount': rawResult,
-              'min-dx': rawResult,
-            },
-          };
-
-          const quoteResult: RouteQuote = {
-            route: {
-              ...route,
-              quoteData: updatedQuoteData,
-              swapData: updatedSwapData,
-            },
-            quote: convertedResult,
-            params: params,
-            quoteData: updatedQuoteData,
-            swapData: updatedSwapData,
-            dexPath: route.dex_path,
-            tokenPath: route.token_path,
-            tokenXDecimals: tokenXDecimals,
-            tokenYDecimals: tokenYDecimals,
-          };
-
-          allRoutes.push(quoteResult);
-        } else {
-          throw new Error('Invalid quote result');
-        }
-      } catch (error) {
-        console.warn(
-          `Failed to get quote for route ${routeIndex + 1}:`,
-          route,
-          error
-        );
-        allRoutes.push({
-          route,
-          quote: null,
-          params: route.quoteData
-            ? { ...route.quoteData.parameters, amountInput }
-            : { amountInput },
-          quoteData: route.quoteData,
-          swapData: route.swapData,
-          dexPath: route.dex_path,
-          tokenPath: route.token_path,
-          tokenXDecimals: route.tokenXDecimals,
-          tokenYDecimals: route.tokenYDecimals,
-          error: (error as Error).message,
-        });
-      }
-    }
-
-    allRoutes.sort((a, b) => (b.quote || 0) - (a.quote || 0));
-    const result = {
-      bestRoute: allRoutes[0]?.quote !== null ? allRoutes[0] : null,
-      allRoutes,
-      inputData: { tokenX, tokenY, amountInput },
-    };
-
-    return result;
-  }
-
-  public async getKeeperQuoteForRouteWithoutScaling(
-    tokenX: string,
-    tokenY: string,
-    amountInput: number
-  ): Promise<QuoteResult> {
-    const COMPATIBLE_DEX_PATHS = new Set([
-      'BITFLOW_STABLE_XY_2',
-      'BITFLOW_XYK_XY_2',
-    ]);
-
-    const isCompatibleRoute = (dexPath: string[]): boolean => {
-      return dexPath.every((path) => COMPATIBLE_DEX_PATHS.has(path));
-    };
-
-    let routes = await this.getAllPossibleTokenYRoutes(tokenX, tokenY);
-    routes = routes.filter((route) => isCompatibleRoute(route.dex_path));
-
-    const allRoutes: RouteQuote[] = [];
-
-    for (let routeIndex = 0; routeIndex < routes.length; routeIndex++) {
-      const route = routes[routeIndex];
-
-      try {
-        if (!route.quoteData) {
-          console.warn(
-            `Skipping route ${routeIndex + 1} due to null quoteData:`,
-            route
-          );
-          continue;
-        }
-
-        const {
-          contract,
-          function: functionName,
-          parameters,
-        } = route.quoteData;
-
-        if (!contract || !functionName || !parameters) {
-          console.warn(
-            `Skipping route ${
-              routeIndex + 1
-            } due to missing required properties:`,
-            route.quoteData
-          );
-          continue;
-        }
-
-        const [contractDeployer, contractName] = contract.split('.');
-
-        if (!this.context.contractInterfaces[contract]) {
-          this.context.contractInterfaces[contract] =
-            await getContractInterfaceAndFunction(
-              contractDeployer,
-              contractName,
-              functionName
-            );
-        }
-        const { interface: contractInterface, functionArgs } =
-          this.context.contractInterfaces[contract];
-
-        const params = { ...parameters };
-
-        if ('dx' in params && params.dx === null) {
-          params.dx = amountInput;
-        } else if ('dy' in params && params.dy === null) {
-          params.dy = amountInput;
-        } else if ('amount' in params && params.amount === null) {
-          params.amount = amountInput;
-        } else if ('amt-in' in params && params['amt-in'] === null) {
-          params['amt-in'] = amountInput;
-        } else if ('amt-in-max' in params && params['amt-in-max'] === null) {
-          params['amt-in-max'] = amountInput;
-        } else if ('y-amount' in params && params['y-amount'] === null) {
-          params['y-amount'] = amountInput;
-          params['x-amount'] = amountInput;
-        } else if ('x-amount' in params && params['x-amount'] === null) {
-          params['x-amount'] = amountInput;
-        } else {
-          params.dx = amountInput;
-        }
-
-        const { convertedResult, rawResult, tokenXDecimals, tokenYDecimals } =
-          await callReadOnlyFunctionHelperWithoutScaling(
-            contractDeployer,
-            contractName,
-            functionName,
-            params,
-            contractDeployer,
-            tokenX,
-            tokenY,
-            route.swapData,
-            this.context
-          );
-
-        if (typeof convertedResult === 'number' && convertedResult > 0) {
-          const updatedQuoteData = {
-            ...route.quoteData,
-            parameters: { ...params },
-          };
-
-          const updatedSwapData = {
-            ...route.swapData,
-            parameters: {
-              ...route.swapData.parameters,
-              amount:
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              dx:
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              'amt-in':
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              'amt-in-max':
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              'y-amount':
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              'x-amount':
-                params.amount ||
-                params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
-                params.dy,
-              'min-received': rawResult,
-              'min-dy': rawResult,
-              'min-dz': rawResult,
-              'min-dw': rawResult,
-              'amt-out': rawResult,
-              'amt-out-min': rawResult,
-              'min-x-amount': rawResult,
-              'min-dv': rawResult,
-              'min-y-amount': rawResult,
-              'min-dx': rawResult,
-            },
-          };
-
-          const quoteResult: RouteQuote = {
-            route: {
-              ...route,
-              quoteData: updatedQuoteData,
-              swapData: updatedSwapData,
-            },
-            quote: convertedResult,
-            params: params,
-            quoteData: updatedQuoteData,
-            swapData: updatedSwapData,
-            dexPath: route.dex_path,
-            tokenPath: route.token_path,
-            tokenXDecimals: tokenXDecimals,
-            tokenYDecimals: tokenYDecimals,
-          };
-
-          allRoutes.push(quoteResult);
-        } else {
-          throw new Error('Invalid quote result');
-        }
-      } catch (error) {
-        console.warn(
-          `Failed to get quote for route ${routeIndex + 1}:`,
-          route,
-          error
-        );
-        allRoutes.push({
-          route,
-          quote: null,
-          params: route.quoteData
-            ? { ...route.quoteData.parameters, amountInput }
-            : { amountInput },
-          quoteData: route.quoteData,
-          swapData: route.swapData,
-          dexPath: route.dex_path,
-          tokenPath: route.token_path,
-          tokenXDecimals: route.tokenXDecimals,
-          tokenYDecimals: route.tokenYDecimals,
-          error: (error as Error).message,
-        });
-      }
-    }
-
-    allRoutes.sort((a, b) => (b.quote || 0) - (a.quote || 0));
-    const result = {
-      bestRoute: allRoutes[0]?.quote !== null ? allRoutes[0] : null,
-      allRoutes,
-      inputData: { tokenX, tokenY, amountInput },
-    };
-
-    return result;
-  }
-  public async getSwapParams(
-    swapExecutionData: SwapExecutionData,
-    senderAddress: string,
-    slippageTolerance: number = 0.015
-  ): Promise<SwapDataParamsAndPostConditions> {
-    const { route, amount, tokenXDecimals, tokenYDecimals } = swapExecutionData;
-
-    const executionData: SwapExecutionData = {
-      route: {
-        ...route,
-        swapData: {
-          ...route.swapData,
-          parameters: {
-            ...route.swapData.parameters,
-            amount:
-              route.swapData.parameters.amount ||
-              amount ||
-              route.swapData.parameters['amt-in'] ||
-              route.swapData.parameters['amt-in-max'] ||
-              route.swapData.parameters['y-amount'],
-            dx:
-              route.swapData.parameters.dx ||
-              amount ||
-              route.swapData.parameters['amt-in'] ||
-              route.swapData.parameters['amt-in-max'] ||
-              route.swapData.parameters['y-amount'],
-            'amt-in':
-              route.swapData.parameters.dx ||
-              amount ||
-              route.swapData.parameters['amt-in'] ||
-              route.swapData.parameters['amt-in-max'] ||
-              route.swapData.parameters['y-amount'] ||
-              route.swapData.parameters.dy,
-            'amt-in-max':
-              route.swapData.parameters.dx ||
-              amount ||
-              route.swapData.parameters['amt-in'] ||
-              route.swapData.parameters['amt-in-max'] ||
-              route.swapData.parameters['y-amount'] ||
-              route.swapData.parameters.dy,
-            'y-amount':
-              route.swapData.parameters.dx ||
-              amount ||
-              route.swapData.parameters['amt-in'] ||
-              route.swapData.parameters['amt-in-max'] ||
-              route.swapData.parameters['y-amount'] ||
-              route.swapData.parameters.dy,
-            dy:
-              route.swapData.parameters.dy ||
-              amount ||
-              route.swapData.parameters['amt-in'] ||
-              route.swapData.parameters['amt-in-max'] ||
-              route.swapData.parameters['y-amount'] ||
-              route.swapData.parameters.dy,
-            provider:
-              route.swapData.parameters.provider
-          },
-        },
-      },
-      amount,
-      tokenXDecimals: tokenXDecimals,
-      tokenYDecimals: tokenYDecimals,
-    };
-
-    return await executeGetParams(
-      executionData,
-      senderAddress,
-      slippageTolerance,
-      this.context
-    );
-  }
-
-  public async executeSwap(
-    swapExecutionData: SwapExecutionData,
-    senderAddress: string,
-    slippageTolerance: number = 0.015,
-    stacksProvider?: StacksProvider,
-    onFinish?: (data: any) => void,
-    onCancel?: () => void
-  ): Promise<void> {
-    const swapParams = await this.getSwapParams(
-      swapExecutionData,
-      senderAddress,
-      slippageTolerance
-    );
-
-    if (typeof window === 'undefined') {
-      throw new Error(
-        'executeSwap is only available in browser environments. ' +
-          'For Node.js environments, use getSwapParams to get the transaction parameters ' +
-          'and handle the transaction execution separately.'
-      );
-    }
-
-    try {
-      let provider: StacksProvider;
-      if (stacksProvider) {
-        provider = stacksProvider;
-      } else {
-        const loadedProvider = await this.loadConnectDependencies();
-        if (!loadedProvider) {
-          throw new Error('Failed to initialize Stacks provider');
-        }
-        provider = loadedProvider;
-      }
-
-      await executeSwapHelper(
-        swapParams,
-        senderAddress,
-        this.context,
-        provider,
-        onFinish,
-        onCancel
-      );
-    } catch (error) {
-      if (
-        error instanceof Error &&
-        error.message.includes('only available in browser environments')
-      ) {
-        throw error;
-      }
-      console.error('Error executing swap:', error);
-      throw new Error(
-        `Failed to execute swap: ${
-          error instanceof Error ? error.message : 'Unknown error'
-        }`
-      );
-    }
-  }
-
-  public async prepareSwap(
-    swapExecutionData: SwapExecutionData,
-    senderAddress: string,
-    slippageTolerance: number = 0.015
-  ): Promise<SwapDataParamsAndPostConditions> {
-    return await this.getSwapParams(
-      swapExecutionData,
-      senderAddress,
-      slippageTolerance
-    );
-  }
-
-  public async getOrCreateKeeperContract(
-    params: GetKeeperContractParams
-  ): Promise<GetKeeperContractResponse> {
-    try {
-      return await getOrCreateKeeperContractAPI(params);
-    } catch (error) {
-      console.error('Error in BitflowSDK.getOrCreateKeeperContract:', error);
-      throw error;
-    }
-  }
-
-  public async getOrder(orderId: string): Promise<GetOrderResponse> {
-    try {
-      return await getOrderAPI(orderId);
-    } catch (error) {
-      console.error('Error in BitflowSDK.getOrder:', error);
-      throw error;
-    }
-  }
-
-  public async getUser(stacksAddress: string): Promise<GetUserResponse> {
-    try {
-      return await getUserAPI(stacksAddress);
-    } catch (error) {
-      console.error('Error in BitflowSDK.getUser:', error);
-      throw error;
-    }
-  }
-
-  public async createOrder(
-    params: CreateOrderParams
-  ): Promise<CreateOrderResponse> {
-    try {
-      return await createOrderAPI(params);
-    } catch (error) {
-      console.error('Error in BitflowSDK.createOrder:', error);
-      throw error;
-    }
-  }
-
-  public async getQuote(params: GetQuoteParams): Promise<GetQuoteResponse> {
-    try {
-      return await getQuoteAPI(params);
-    } catch (error) {
-      console.error('Error in BitflowSDK.getQuote:', error);
-      throw error;
-    }
-  }
-
-  private async transformRouteToActionArgs(
-    route: RouteQuote
-  ): Promise<ActionFunctionArgs> {
-    const actionFunctionArgs: ActionFunctionArgs = {
-      tokenList: {},
-      xykPoolList: {},
-      stableswapPoolList: {},
-      boolList: {},
-    };
-
-    const swapData = route.swapData;
-    if (!swapData || !swapData.parameters) {
-      throw new Error(
-        'Invalid route data - missing swapData or swapData.parameters'
-      );
-    }
-
-    try {
-      const availableTokens = await this.getAvailableTokens();
-      const tokenPath = route.tokenPath;
-      const expandedTokenPath: string[] = [];
-
-      // Expand token path
-      for (let i = 0; i < tokenPath.length - 1; i++) {
-        expandedTokenPath.push(tokenPath[i]);
-        if (i > 0 && i < tokenPath.length - 1) {
-          expandedTokenPath.push(tokenPath[i]);
-        }
-      }
-      expandedTokenPath.push(tokenPath[tokenPath.length - 1]);
-
-      // Map tokens to contract identifiers
-      const tokenList: Record<string, string> = {};
-      for (let index = 0; index < expandedTokenPath.length; index++) {
-        const tokenId = expandedTokenPath[index];
-        let contractIdentifier: string;
-
-        if (tokenId === 'token-stx') {
-          contractIdentifier =
-            'SM1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.token-stx-v-1-2';
-        } else {
-          const token = availableTokens.find((t) => t.tokenId === tokenId);
-          if (!token || !token.tokenContract) {
-            throw new Error(
-              `Could not find contract identifier for token ${tokenId}`
-            );
-          }
-          contractIdentifier = token.tokenContract;
-        }
-
-        const key = String.fromCharCode(97 + index); // 97 = 'a'
-        tokenList[key] = contractIdentifier;
-      }
-
-      actionFunctionArgs.tokenList = tokenList;
-
-      // Determine if this is a stableswap or XYK route
-      const dexPath = route.dexPath;
-      const isStableswapRoute = dexPath.some((path) =>
-        path.toLowerCase().includes('stable')
-      );
-
-      // Transform pool lists
-      const transformPoolList = (pools: any): Record<string, string> => {
-        if (typeof pools === 'string') {
-          return { a: pools };
-        }
-        if (Array.isArray(pools)) {
-          const poolObject: Record<string, string> = {};
-          const letters = 'abcdefghijklmnopqrstuvwxyz';
-          pools.forEach((pool, index) => {
-            poolObject[letters[index]] = pool;
-          });
-          return poolObject;
-        }
-        if (typeof pools === 'object' && pools !== null) {
-          return pools;
-        }
-        return {};
-      };
-
-      // Handle pools based on whether they're stableswap or XYK
-      if (swapData.parameters['pool-trait']) {
-        const poolIdentifier = swapData.parameters['pool-trait'];
-        const transformedPool = transformPoolList(poolIdentifier);
-
-        // Check if the pool name contains 'stableswap'
-        if (
-          isStableswapRoute ||
-          (typeof poolIdentifier === 'string' &&
-            poolIdentifier.toLowerCase().includes('stableswap'))
-        ) {
-          actionFunctionArgs.stableswapPoolList = transformedPool;
-        } else {
-          actionFunctionArgs.xykPoolList = transformedPool;
-        }
-      } else {
-        // Handle specific pool types
-        if (swapData.parameters['xyk-pools']) {
-          actionFunctionArgs.xykPoolList = transformPoolList(
-            swapData.parameters['xyk-pools']
-          );
-        }
-
-        if (swapData.parameters['stableswap-pools']) {
-          actionFunctionArgs.stableswapPoolList = transformPoolList(
-            swapData.parameters['stableswap-pools']
-          );
-        }
-      }
-
-      if ('swaps-reversed' in swapData.parameters) {
-        actionFunctionArgs.boolList = {
-          a: swapData.parameters['swaps-reversed'].toString(),
-        };
-      } else {
-        delete actionFunctionArgs.boolList;
-      }
-
-      const trait = this.mapDexPathToActionTrait(dexPath);
-      actionFunctionArgs.actionTrait = trait;
-
-      return actionFunctionArgs;
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  private mapDexPathToActionTrait(dexPath: string[]): string {
-    const isXYK = dexPath.some((d) => d.toLowerCase().includes('xyk'));
-    const isStable = dexPath.some((d) => d.toLowerCase().includes('stable'));
-
-    if (isXYK && !isStable) {
-      return 'SM1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.keeper-action-1-v-1-1';
-    }
-    if (isXYK && isStable) {
-      return 'SM1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.keeper-action-2-v-1-1';
-    }
-    if (!isXYK && isStable) {
-      return 'SM1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.keeper-action-3-v-1-1';
-    }
-
-    throw new Error(`Unsupported DEX path: ${dexPath.join(', ')}`);
-  }
-
-  public async getKeeperAggregatorRouteData(
-    tokenX: string,
-    tokenY: string,
-    amountX: number
-  ): Promise<ActionFunctionArgs> {
-    try {
-      const quoteResult = await this.getKeeperQuoteForRouteWithoutScaling(
-        tokenX,
-        tokenY,
-        amountX
-      );
-
-      if (
-        !quoteResult ||
-        !quoteResult.allRoutes ||
-        quoteResult.allRoutes.length === 0
-      ) {
-        throw new Error('No routes found');
-      }
-
-      const { bestRoute } = quoteResult;
-      if (!bestRoute) {
-        throw new Error('No best route found for keeper-compatible DEX paths');
-      }
-
-      const actionFunctionArgs = await this.transformRouteToActionArgs(
-        bestRoute
-      );
-      return actionFunctionArgs;
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  public async createGroupOrder(
-    params: CreateGroupOrderParams
-  ): Promise<CreateGroupOrderResponse> {
-    try {
-      return await createGroupOrderAPI(params);
-    } catch (error) {
-      console.error('Error in BitflowSDK.createGroupOrder:', error);
-      throw error;
-    }
-  }
-
-  public async getGroupOrder(
-    groupId: string,
-    includeOrders?: boolean
-  ): Promise<GetGroupOrderResponse> {
-    try {
-      return await getGroupOrderAPI(groupId, includeOrders);
-    } catch (error) {
-      console.error('Error in BitflowSDK.getGroupOrder:', error);
-      throw error;
-    }
-  }
-
-  public async cancelOrder(orderId: string): Promise<CancelOrderResponse> {
-    try {
-      return await cancelOrderAPI(orderId);
-    } catch (error) {
-      console.error('Error in BitflowSDK.cancelOrder:', error);
-      throw error;
-    }
-  }
-
-  public async cancelGroupOrder(
-    groupId: string
-  ): Promise<CancelGroupOrderResponse> {
-    try {
-      return await cancelGroupOrderAPI(groupId);
-    } catch (error) {
-      console.error('Error in BitflowSDK.cancelGroupOrder:', error);
-      throw error;
-    }
-  }
-}