@bitflowlabs/core-sdk 2.0.2 → 2.1.3

package/src/BitflowSDK.ts

@@ -1,5 +1,5 @@
-import { STACKS_MAINNET } from "@stacks/network";
-import type { StacksProvider } from "@stacks/connect";
+import { STACKS_MAINNET } from '@stacks/network';
+import type { StacksProvider } from '@stacks/connect';
 import {
   SwapContext,
   Token,
@@ -10,14 +10,17 @@ 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,
+  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,
@@ -36,7 +39,7 @@ import {
   GetQuoteResponse,
   GetUserResponse,
   KeeperOrderRouteData,
-} from "./keeper/types";
+} from './keeper/types';
 import {
   cancelGroupOrderAPI,
   cancelOrderAPI,
@@ -47,7 +50,15 @@ import {
   getOrderAPI,
   getQuoteAPI,
   getUserAPI,
-} from "./keeper/keeperAPI";
+} 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;
@@ -69,21 +80,21 @@ export class BitflowSDK {
     this.initializeContext();
   }
   private async loadConnectDependencies() {
-    if (typeof window === "undefined") {
+    if (typeof window === 'undefined') {
       throw new Error(
-        "Connect features are only available in browser environments"
+        'Connect features are only available in browser environments'
       );
     }
 
     try {
-      const { getStacksProvider } = await import("@stacks/connect");
+      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");
+      console.error('Error loading Stacks Connect:', error);
+      throw new Error('Failed to load Stacks Connect dependencies');
     }
   }
   private async initializeContext(): Promise<void> {
@@ -119,7 +130,7 @@ export class BitflowSDK {
     if (!this.context.swapOptions[cacheKey]) {
       this.context.swapOptions[cacheKey] = await fetchPossibleSwapsFromAPI(
         tokenX,
-        "KEEPER"
+        'KEEPER'
       );
     }
     return this.context.swapOptions[cacheKey];
@@ -186,7 +197,7 @@ export class BitflowSDK {
           continue;
         }
 
-        const [contractDeployer, contractName] = contract.split(".");
+        const [contractDeployer, contractName] = contract.split('.');
 
         if (!this.context.contractInterfaces[contract]) {
           this.context.contractInterfaces[contract] =
@@ -201,21 +212,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;
         }
@@ -233,7 +244,7 @@ export class BitflowSDK {
             this.context
           );
 
-        if (typeof convertedResult === "number" && convertedResult > 0) {
+        if (typeof convertedResult === 'number' && convertedResult > 0) {
           const updatedQuoteData = {
             ...route.quoteData,
             parameters: { ...params },
@@ -246,70 +257,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,
             },
           };
 
@@ -331,7 +342,7 @@ export class BitflowSDK {
 
           allRoutes.push(quoteResult);
         } else {
-          throw new Error("Invalid quote result");
+          throw new Error('Invalid quote result');
         }
       } catch (error) {
         console.warn(
@@ -373,8 +384,8 @@ export class BitflowSDK {
     amountInput: number
   ): Promise<QuoteResult> {
     const COMPATIBLE_DEX_PATHS = new Set([
-      "BITFLOW_STABLE_XY_2",
-      "BITFLOW_XYK_XY_2",
+      'BITFLOW_STABLE_XY_2',
+      'BITFLOW_XYK_XY_2',
     ]);
 
     const isCompatibleRoute = (dexPath: string[]): boolean => {
@@ -414,7 +425,7 @@ export class BitflowSDK {
           continue;
         }
 
-        const [contractDeployer, contractName] = contract.split(".");
+        const [contractDeployer, contractName] = contract.split('.');
 
         if (!this.context.contractInterfaces[contract]) {
           this.context.contractInterfaces[contract] =
@@ -429,21 +440,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;
         }
@@ -461,7 +472,7 @@ export class BitflowSDK {
             this.context
           );
 
-        if (typeof convertedResult === "number" && convertedResult > 0) {
+        if (typeof convertedResult === 'number' && convertedResult > 0) {
           const updatedQuoteData = {
             ...route.quoteData,
             parameters: { ...params },
@@ -474,61 +485,61 @@ 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,
-              "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,
             },
           };
 
@@ -550,7 +561,7 @@ export class BitflowSDK {
 
           allRoutes.push(quoteResult);
         } else {
-          throw new Error("Invalid quote result");
+          throw new Error('Invalid quote result');
         }
       } catch (error) {
         console.warn(
@@ -585,6 +596,223 @@ export class BitflowSDK {
     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,
@@ -602,42 +830,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,
           },
         },
@@ -669,11 +897,11 @@ export class BitflowSDK {
       slippageTolerance
     );
 
-    if (typeof window === "undefined") {
+    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."
+        'executeSwap is only available in browser environments. ' +
+          'For Node.js environments, use getSwapParams to get the transaction parameters ' +
+          'and handle the transaction execution separately.'
       );
     }
 
@@ -684,7 +912,7 @@ export class BitflowSDK {
       } else {
         const loadedProvider = await this.loadConnectDependencies();
         if (!loadedProvider) {
-          throw new Error("Failed to initialize Stacks provider");
+          throw new Error('Failed to initialize Stacks provider');
         }
         provider = loadedProvider;
       }
@@ -700,14 +928,14 @@ export class BitflowSDK {
     } catch (error) {
       if (
         error instanceof Error &&
-        error.message.includes("only available in browser environments")
+        error.message.includes('only available in browser environments')
       ) {
         throw error;
       }
-      console.error("Error executing swap:", error);
+      console.error('Error executing swap:', error);
       throw new Error(
         `Failed to execute swap: ${
-          error instanceof Error ? error.message : "Unknown error"
+          error instanceof Error ? error.message : 'Unknown error'
         }`
       );
     }
@@ -731,7 +959,7 @@ export class BitflowSDK {
     try {
       return await getOrCreateKeeperContractAPI(params);
     } catch (error) {
-      console.error("Error in BitflowSDK.getOrCreateKeeperContract:", error);
+      console.error('Error in BitflowSDK.getOrCreateKeeperContract:', error);
       throw error;
     }
   }
@@ -740,7 +968,7 @@ export class BitflowSDK {
     try {
       return await getOrderAPI(orderId);
     } catch (error) {
-      console.error("Error in BitflowSDK.getOrder:", error);
+      console.error('Error in BitflowSDK.getOrder:', error);
       throw error;
     }
   }
@@ -749,7 +977,7 @@ export class BitflowSDK {
     try {
       return await getUserAPI(stacksAddress);
     } catch (error) {
-      console.error("Error in BitflowSDK.getUser:", error);
+      console.error('Error in BitflowSDK.getUser:', error);
       throw error;
     }
   }
@@ -760,7 +988,7 @@ export class BitflowSDK {
     try {
       return await createOrderAPI(params);
     } catch (error) {
-      console.error("Error in BitflowSDK.createOrder:", error);
+      console.error('Error in BitflowSDK.createOrder:', error);
       throw error;
     }
   }
@@ -769,28 +997,11 @@ export class BitflowSDK {
     try {
       return await getQuoteAPI(params);
     } catch (error) {
-      console.error("Error in BitflowSDK.getQuote:", 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> {
@@ -804,89 +1015,136 @@ export class BitflowSDK {
     const swapData = route.swapData;
     if (!swapData || !swapData.parameters) {
       throw new Error(
-        "Invalid route data - missing swapData or swapData.parameters"
+        'Invalid route data - missing swapData or swapData.parameters'
       );
     }
 
-    const availableTokens = await this.getAvailableTokens();
-    const tokenPath = route.tokenPath;
-    const expandedTokenPath: string[] = [];
+    try {
+      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) {
+      // Expand token path
+      for (let i = 0; i < tokenPath.length - 1; i++) {
         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}`
-          );
+        if (i > 0 && i < tokenPath.length - 1) {
+          expandedTokenPath.push(tokenPath[i]);
         }
-        contractIdentifier = token.tokenContract;
       }
-      const key = String.fromCharCode(97 + index); // 97 = 'a'
-      tokenList[key] = contractIdentifier;
-    });
+      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;
 
-    actionFunctionArgs.tokenList = tokenList;
+        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 transformPoolList = (pools: any): Record<string, string> => {
-      if (typeof pools === "string") {
-        return { a: pools };
+        const key = String.fromCharCode(97 + index); // 97 = 'a'
+        tokenList[key] = contractIdentifier;
       }
-      if (Array.isArray(pools)) {
-        const poolObject: Record<string, string> = {};
-        const letters = "abcdefghijklmnopqrstuvwxyz";
-        pools.forEach((pool, index) => {
-          poolObject[letters[index]] = pool;
-        });
-        return poolObject;
+
+      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 (typeof pools === "object" && pools !== null) {
-        return pools;
+
+      if ('swaps-reversed' in swapData.parameters) {
+        actionFunctionArgs.boolList = {
+          a: swapData.parameters['swaps-reversed'].toString(),
+        };
+      } else {
+        delete actionFunctionArgs.boolList;
       }
-      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"]
-      );
-    }
+      const trait = this.mapDexPathToActionTrait(dexPath);
+      actionFunctionArgs.actionTrait = trait;
 
-    if (swapData.parameters["stableswap-pools"]) {
-      actionFunctionArgs.stableswapPoolList =
-        swapData.parameters["stableswap-pools"];
+      return actionFunctionArgs;
+    } catch (error) {
+      throw error;
     }
+  }
 
-    if ("swaps-reversed" in swapData.parameters) {
-      actionFunctionArgs.boolList = {
-        a: swapData.parameters["swaps-reversed"].toString(),
-      };
-    } else {
-      delete actionFunctionArgs.boolList;
-    }
+  private mapDexPathToActionTrait(dexPath: string[]): string {
+    const isXYK = dexPath.some((d) => d.toLowerCase().includes('xyk'));
+    const isStable = dexPath.some((d) => d.toLowerCase().includes('stable'));
 
-    const dexPath = route.dexPath;
-    const trait = this.mapDexPathToActionTrait(dexPath);
-    actionFunctionArgs.actionTrait = trait;
+    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';
+    }
 
-    return actionFunctionArgs;
+    throw new Error(`Unsupported DEX path: ${dexPath.join(', ')}`);
   }
 
   public async getKeeperAggregatorRouteData(
@@ -894,28 +1152,33 @@ export class BitflowSDK {
     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");
-    }
+    try {
+      const quoteResult = await this.getKeeperQuoteForRouteWithoutScaling(
+        tokenX,
+        tokenY,
+        amountX
+      );
 
-    const { bestRoute } = quoteResult;
-    if (!bestRoute) {
-      throw new Error("No best route found for keeper-compatible DEX paths");
-    }
+      if (
+        !quoteResult ||
+        !quoteResult.allRoutes ||
+        quoteResult.allRoutes.length === 0
+      ) {
+        throw new Error('No routes found');
+      }
 
-    const actionFunctionArgs = this.transformRouteToActionArgs(bestRoute);
+      const { bestRoute } = quoteResult;
+      if (!bestRoute) {
+        throw new Error('No best route found for keeper-compatible DEX paths');
+      }
 
-    return actionFunctionArgs;
+      const actionFunctionArgs = await this.transformRouteToActionArgs(
+        bestRoute
+      );
+      return actionFunctionArgs;
+    } catch (error) {
+      throw error;
+    }
   }
 
   public async createGroupOrder(
@@ -924,7 +1187,7 @@ export class BitflowSDK {
     try {
       return await createGroupOrderAPI(params);
     } catch (error) {
-      console.error("Error in BitflowSDK.createGroupOrder:", error);
+      console.error('Error in BitflowSDK.createGroupOrder:', error);
       throw error;
     }
   }
@@ -936,7 +1199,7 @@ export class BitflowSDK {
     try {
       return await getGroupOrderAPI(groupId, includeOrders);
     } catch (error) {
-      console.error("Error in BitflowSDK.getGroupOrder:", error);
+      console.error('Error in BitflowSDK.getGroupOrder:', error);
       throw error;
     }
   }
@@ -945,7 +1208,7 @@ export class BitflowSDK {
     try {
       return await cancelOrderAPI(orderId);
     } catch (error) {
-      console.error("Error in BitflowSDK.cancelOrder:", error);
+      console.error('Error in BitflowSDK.cancelOrder:', error);
       throw error;
     }
   }
@@ -956,7 +1219,7 @@ export class BitflowSDK {
     try {
       return await cancelGroupOrderAPI(groupId);
     } catch (error) {
-      console.error("Error in BitflowSDK.cancelGroupOrder:", error);
+      console.error('Error in BitflowSDK.cancelGroupOrder:', error);
       throw error;
     }
   }