@bitflowlabs/core-sdk 1.0.1 → 2.0.0

package/src/BitflowSDK.ts

@@ -1,5 +1,5 @@
-import { StacksMainnet } from '@stacks/network';
-import { StacksProvider } from '@stacks/connect';
+import { STACKS_MAINNET } from "@stacks/network";
+import type { StacksProvider } from "@stacks/connect";
 import {
   SwapContext,
   Token,
@@ -10,17 +10,48 @@ import {
   RouteQuote,
   SwapDataParamsAndPostConditions,
   BitflowSDKConfig,
-} from './types';
-import { fetchAllTokensFromAPI } from './helpers/fetchDataHelper';
-import { executeSwapHelper } from './helpers/callSwapHelper';
-import { callReadOnlyFunctionHelper } from './helpers/callReadOnlyHelper';
-import { fetchPossibleSwapsFromAPI } from './helpers/fetchPossibleSwap';
-import { getContractInterfaceAndFunction } from './helpers/getContractInterfaceAndFunction';
-import { configs, validateConfig } from './config';
-import { executeGetParams } from './helpers/callGetSwapParams';
+} from "./types";
+import { fetchAllTokensFromAPI } from "./helpers/fetchDataHelper";
+import { executeSwapHelper } from "./helpers/callSwapHelper";
+import { callReadOnlyFunctionHelper } 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 class BitflowSDK {
   private context: SwapContext;
+  private stacksProvider: StacksProvider | undefined;
 
   constructor(config?: Partial<BitflowSDKConfig>) {
     if (config) Object.assign(configs, config);
@@ -31,13 +62,30 @@ export class BitflowSDK {
       availableTokens: [],
       contractInterfaces: {},
       functionArgs: {},
-      network: new StacksMainnet(),
+      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();
   }
@@ -49,6 +97,13 @@ export class BitflowSDK {
     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(
@@ -58,11 +113,28 @@ export class BitflowSDK {
     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
@@ -71,6 +143,14 @@ export class BitflowSDK {
     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,
@@ -82,7 +162,6 @@ export class BitflowSDK {
     for (let routeIndex = 0; routeIndex < routes.length; routeIndex++) {
       const route = routes[routeIndex];
       try {
-        // Check if quoteData is null or undefined
         if (!route.quoteData) {
           console.warn(
             `Skipping route ${routeIndex + 1} due to null quoteData:`,
@@ -97,7 +176,6 @@ export class BitflowSDK {
           parameters,
         } = route.quoteData;
 
-        // Check if any required property is missing
         if (!contract || !functionName || !parameters) {
           console.warn(
             `Skipping route ${
@@ -108,7 +186,7 @@ export class BitflowSDK {
           continue;
         }
 
-        const [contractDeployer, contractName] = contract.split('.');
+        const [contractDeployer, contractName] = contract.split(".");
 
         if (!this.context.contractInterfaces[contract]) {
           this.context.contractInterfaces[contract] =
@@ -123,21 +201,21 @@ export class BitflowSDK {
 
         const params = { ...parameters };
 
-        if ('dx' in params && params.dx === null) {
+        if ("dx" in params && params.dx === null) {
           params.dx = amountInput;
-        } else if ('dy' in params && params.dy === null) {
+        } else if ("dy" in params && params.dy === null) {
           params.dy = amountInput;
-        } else if ('amount' in params && params.amount === null) {
+        } 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 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;
         }
@@ -155,7 +233,7 @@ export class BitflowSDK {
             this.context
           );
 
-        if (typeof convertedResult === 'number' && convertedResult > 0) {
+        if (typeof convertedResult === "number" && convertedResult > 0) {
           const updatedQuoteData = {
             ...route.quoteData,
             parameters: { ...params },
@@ -168,70 +246,70 @@ export class BitflowSDK {
               amount:
                 params.amount ||
                 params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
+                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["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["amt-in"] ||
+                params["amt-in-max"] ||
+                params["y-amount"] ||
+                params["x-amount"] ||
                 params.dy,
-              'amt-in':
+              "amt-in":
                 params.amount ||
                 params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
+                params["amt-in"] ||
+                params["amt-in-max"] ||
+                params["y-amount"] ||
+                params["x-amount"] ||
                 params.dy,
-              'amt-in-max':
+              "amt-in-max":
                 params.amount ||
                 params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
+                params["amt-in"] ||
+                params["amt-in-max"] ||
+                params["y-amount"] ||
+                params["x-amount"] ||
                 params.dy,
-              'y-amount':
+              "y-amount":
                 params.amount ||
                 params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
+                params["amt-in"] ||
+                params["amt-in-max"] ||
+                params["y-amount"] ||
+                params["x-amount"] ||
                 params.dy,
-              'x-amount':
+              "x-amount":
                 params.amount ||
                 params.dx ||
-                params['amt-in'] ||
-                params['amt-in-max'] ||
-                params['y-amount'] ||
-                params['x-amount'] ||
+                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,
+              "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,
             },
           };
 
@@ -253,7 +331,7 @@ export class BitflowSDK {
 
           allRoutes.push(quoteResult);
         } else {
-          throw new Error('Invalid quote result');
+          throw new Error("Invalid quote result");
         }
       } catch (error) {
         console.warn(
@@ -289,6 +367,224 @@ export class BitflowSDK {
     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 getSwapParams(
     swapExecutionData: SwapExecutionData,
     senderAddress: string,
@@ -306,42 +602,42 @@ export class BitflowSDK {
             amount:
               route.swapData.parameters.amount ||
               amount ||
-              route.swapData.parameters['amt-in'] ||
-              route.swapData.parameters['amt-in-max'] ||
-              route.swapData.parameters['y-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["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["amt-in"] ||
+              route.swapData.parameters["amt-in-max"] ||
+              route.swapData.parameters["y-amount"] ||
               route.swapData.parameters.dy,
-            'amt-in-max':
+            "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["amt-in"] ||
+              route.swapData.parameters["amt-in-max"] ||
+              route.swapData.parameters["y-amount"] ||
               route.swapData.parameters.dy,
-            'y-amount':
+            "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["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["amt-in"] ||
+              route.swapData.parameters["amt-in-max"] ||
+              route.swapData.parameters["y-amount"] ||
               route.swapData.parameters.dy,
           },
         },
@@ -373,13 +669,295 @@ export class BitflowSDK {
       slippageTolerance
     );
 
-    await executeSwapHelper(
-      swapParams,
+    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,
-      this.context,
-      stacksProvider,
-      onFinish,
-      onCancel
+      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 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(", ")}`);
+  }
+
+  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"
+      );
+    }
+
+    const availableTokens = await this.getAvailableTokens();
+    const tokenPath = route.tokenPath;
+    const expandedTokenPath: string[] = [];
+
+    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]);
+
+    const tokenList: Record<string, string> = {};
+    expandedTokenPath.forEach((tokenId, 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;
+
+    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 {};
+    };
+
+    if (swapData.parameters["xyk-pools"]) {
+      actionFunctionArgs.xykPoolList = transformPoolList(
+        swapData.parameters["xyk-pools"]
+      );
+    } else if (swapData.parameters["pool-trait"]) {
+      actionFunctionArgs.xykPoolList = transformPoolList(
+        swapData.parameters["pool-trait"]
+      );
+    }
+
+    if (swapData.parameters["stableswap-pools"]) {
+      actionFunctionArgs.stableswapPoolList =
+        swapData.parameters["stableswap-pools"];
+    }
+
+    if ("swaps-reversed" in swapData.parameters) {
+      actionFunctionArgs.boolList = {
+        a: swapData.parameters["swaps-reversed"].toString(),
+      };
+    } else {
+      delete actionFunctionArgs.boolList;
+    }
+
+    const dexPath = route.dexPath;
+    const trait = this.mapDexPathToActionTrait(dexPath);
+    actionFunctionArgs.actionTrait = trait;
+
+    return actionFunctionArgs;
+  }
+
+  public async getKeeperAggregatorRouteData(
+    tokenX: string,
+    tokenY: string,
+    amountX: number
+  ): Promise<ActionFunctionArgs> {
+    const quoteResult = await this.getKeeperQuoteForRoute(
+      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 = this.transformRouteToActionArgs(bestRoute);
+
+    return actionFunctionArgs;
+  }
+
+  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;
+    }
+  }
 }