@bitflowlabs/core-sdk 1.0.1 → 2.0.0

package/dist/src/BitflowSDK.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BitflowSDK = void 0;
 const network_1 = require("@stacks/network");
@@ -9,6 +42,7 @@ const fetchPossibleSwap_1 = require("./helpers/fetchPossibleSwap");
 const getContractInterfaceAndFunction_1 = require("./helpers/getContractInterfaceAndFunction");
 const config_1 = require("./config");
 const callGetSwapParams_1 = require("./helpers/callGetSwapParams");
+const keeperAPI_1 = require("./keeper/keeperAPI");
 class BitflowSDK {
     constructor(config) {
         if (config)
@@ -18,11 +52,27 @@ class BitflowSDK {
             availableTokens: [],
             contractInterfaces: {},
             functionArgs: {},
-            network: new network_1.StacksMainnet(),
+            network: network_1.STACKS_MAINNET,
             swapOptions: {},
         };
         this.initializeContext();
     }
+    async loadConnectDependencies() {
+        if (typeof window === "undefined") {
+            throw new Error("Connect features are only available in browser environments");
+        }
+        try {
+            const { getStacksProvider } = await Promise.resolve().then(() => __importStar(require("@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");
+        }
+    }
     async initializeContext() {
         this.context.availableTokens = await (0, fetchDataHelper_1.fetchAllTokensFromAPI)();
     }
@@ -32,20 +82,42 @@ class BitflowSDK {
         }
         return this.context.availableTokens;
     }
+    async getKeeperTokens() {
+        if (this.context.availableTokens.length === 0) {
+            await this.initializeContext();
+        }
+        return this.context.availableTokens.filter((token) => token.isKeeperToken);
+    }
     async getPossibleSwaps(tokenX) {
         if (!this.context.swapOptions[tokenX]) {
             this.context.swapOptions[tokenX] = await (0, fetchPossibleSwap_1.fetchPossibleSwapsFromAPI)(tokenX);
         }
         return this.context.swapOptions[tokenX];
     }
+    async getKeeperPossibleSwaps(tokenX) {
+        // Use a separate cache key for keeper routes
+        const cacheKey = `keeper_${tokenX}`;
+        if (!this.context.swapOptions[cacheKey]) {
+            this.context.swapOptions[cacheKey] = await (0, fetchPossibleSwap_1.fetchPossibleSwapsFromAPI)(tokenX, "KEEPER");
+        }
+        return this.context.swapOptions[cacheKey];
+    }
     async getAllPossibleTokenY(tokenX) {
         const swapOptions = await this.getPossibleSwaps(tokenX);
         return Object.keys(swapOptions);
     }
+    async getAllKeeperPossibleTokenY(tokenX) {
+        const swapOptions = await this.getKeeperPossibleSwaps(tokenX);
+        return Object.keys(swapOptions);
+    }
     async getAllPossibleTokenYRoutes(tokenX, tokenY) {
         const swapOptions = await this.getPossibleSwaps(tokenX);
         return swapOptions[tokenY] || [];
     }
+    async getAllKeeperPossibleTokenYRoutes(tokenX, tokenY) {
+        const swapOptions = await this.getKeeperPossibleSwaps(tokenX);
+        return swapOptions[tokenY] || [];
+    }
     async getQuoteForRoute(tokenX, tokenY, amountInput) {
         var _a;
         const routes = await this.getAllPossibleTokenYRoutes(tokenX, tokenY);
@@ -53,51 +125,49 @@ 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:`, route);
                     continue;
                 }
                 const { contract, function: functionName, parameters, } = route.quoteData;
-                // Check if any required property is missing
                 if (!contract || !functionName || !parameters) {
                     console.warn(`Skipping route ${routeIndex + 1} due to missing required properties:`, route.quoteData);
                     continue;
                 }
-                const [contractDeployer, contractName] = contract.split('.');
+                const [contractDeployer, contractName] = contract.split(".");
                 if (!this.context.contractInterfaces[contract]) {
                     this.context.contractInterfaces[contract] =
                         await (0, getContractInterfaceAndFunction_1.getContractInterfaceAndFunction)(contractDeployer, contractName, functionName);
                 }
                 const { interface: contractInterface, functionArgs } = this.context.contractInterfaces[contract];
                 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" 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 ("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 ("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 ("x-amount" in params && params["x-amount"] === null) {
+                    params["x-amount"] = amountInput;
                 }
                 else {
                     params.dx = amountInput;
                 }
                 const { convertedResult, rawResult, tokenXDecimals, tokenYDecimals } = await (0, callReadOnlyHelper_1.callReadOnlyFunctionHelper)(contractDeployer, contractName, functionName, params, contractDeployer, tokenX, tokenY, route.swapData, this.context);
-                if (typeof convertedResult === 'number' && convertedResult > 0) {
+                if (typeof convertedResult === "number" && convertedResult > 0) {
                     const updatedQuoteData = {
                         ...route.quoteData,
                         parameters: { ...params },
@@ -108,63 +178,63 @@ class BitflowSDK {
                             ...route.swapData.parameters,
                             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': params.amount ||
+                            "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': params.amount ||
+                            "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': params.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': params.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,
                         },
                     };
                     const quoteResult = {
@@ -185,7 +255,174 @@ class BitflowSDK {
                     allRoutes.push(quoteResult);
                 }
                 else {
-                    throw new Error('Invalid quote result');
+                    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.message,
+                });
+            }
+        }
+        allRoutes.sort((a, b) => (b.quote || 0) - (a.quote || 0));
+        const result = {
+            bestRoute: ((_a = allRoutes[0]) === null || _a === void 0 ? void 0 : _a.quote) !== null ? allRoutes[0] : null,
+            allRoutes,
+            inputData: { tokenX, tokenY, amountInput },
+        };
+        return result;
+    }
+    async getKeeperQuoteForRoute(tokenX, tokenY, amountInput) {
+        var _a;
+        const COMPATIBLE_DEX_PATHS = new Set([
+            "BITFLOW_STABLE_XY_2",
+            "BITFLOW_XYK_XY_2",
+        ]);
+        const isCompatibleRoute = (dexPath) => {
+            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 = [];
+        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 (0, getContractInterfaceAndFunction_1.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 (0, callReadOnlyHelper_1.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 = {
+                        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) {
@@ -225,37 +462,37 @@ class BitflowSDK {
                         ...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'],
+                            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 ||
+                            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': route.swapData.parameters.dx ||
+                        "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': route.swapData.parameters.dx ||
+                        "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,
                     },
                 },
@@ -268,7 +505,224 @@ class BitflowSDK {
     }
     async executeSwap(swapExecutionData, senderAddress, slippageTolerance = 0.015, stacksProvider, onFinish, onCancel) {
         const swapParams = await this.getSwapParams(swapExecutionData, senderAddress, slippageTolerance);
-        await (0, callSwapHelper_1.executeSwapHelper)(swapParams, senderAddress, this.context, stacksProvider, onFinish, onCancel);
+        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;
+            if (stacksProvider) {
+                provider = stacksProvider;
+            }
+            else {
+                const loadedProvider = await this.loadConnectDependencies();
+                if (!loadedProvider) {
+                    throw new Error("Failed to initialize Stacks provider");
+                }
+                provider = loadedProvider;
+            }
+            await (0, callSwapHelper_1.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"}`);
+        }
+    }
+    async prepareSwap(swapExecutionData, senderAddress, slippageTolerance = 0.015) {
+        return await this.getSwapParams(swapExecutionData, senderAddress, slippageTolerance);
+    }
+    async getOrCreateKeeperContract(params) {
+        try {
+            return await (0, keeperAPI_1.getOrCreateKeeperContractAPI)(params);
+        }
+        catch (error) {
+            console.error("Error in BitflowSDK.getOrCreateKeeperContract:", error);
+            throw error;
+        }
+    }
+    async getOrder(orderId) {
+        try {
+            return await (0, keeperAPI_1.getOrderAPI)(orderId);
+        }
+        catch (error) {
+            console.error("Error in BitflowSDK.getOrder:", error);
+            throw error;
+        }
+    }
+    async getUser(stacksAddress) {
+        try {
+            return await (0, keeperAPI_1.getUserAPI)(stacksAddress);
+        }
+        catch (error) {
+            console.error("Error in BitflowSDK.getUser:", error);
+            throw error;
+        }
+    }
+    async createOrder(params) {
+        try {
+            return await (0, keeperAPI_1.createOrderAPI)(params);
+        }
+        catch (error) {
+            console.error("Error in BitflowSDK.createOrder:", error);
+            throw error;
+        }
+    }
+    async getQuote(params) {
+        try {
+            return await (0, keeperAPI_1.getQuoteAPI)(params);
+        }
+        catch (error) {
+            console.error("Error in BitflowSDK.getQuote:", error);
+            throw error;
+        }
+    }
+    mapDexPathToActionTrait(dexPath) {
+        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(", ")}`);
+    }
+    async transformRouteToActionArgs(route) {
+        const 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 = [];
+        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 = {};
+        expandedTokenPath.forEach((tokenId, index) => {
+            let contractIdentifier;
+            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) => {
+            if (typeof pools === "string") {
+                return { a: pools };
+            }
+            if (Array.isArray(pools)) {
+                const poolObject = {};
+                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;
+    }
+    async getKeeperAggregatorRouteData(tokenX, tokenY, amountX) {
+        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;
+    }
+    async createGroupOrder(params) {
+        try {
+            return await (0, keeperAPI_1.createGroupOrderAPI)(params);
+        }
+        catch (error) {
+            console.error("Error in BitflowSDK.createGroupOrder:", error);
+            throw error;
+        }
+    }
+    async getGroupOrder(groupId, includeOrders) {
+        try {
+            return await (0, keeperAPI_1.getGroupOrderAPI)(groupId, includeOrders);
+        }
+        catch (error) {
+            console.error("Error in BitflowSDK.getGroupOrder:", error);
+            throw error;
+        }
+    }
+    async cancelOrder(orderId) {
+        try {
+            return await (0, keeperAPI_1.cancelOrderAPI)(orderId);
+        }
+        catch (error) {
+            console.error("Error in BitflowSDK.cancelOrder:", error);
+            throw error;
+        }
+    }
+    async cancelGroupOrder(groupId) {
+        try {
+            return await (0, keeperAPI_1.cancelGroupOrderAPI)(groupId);
+        }
+        catch (error) {
+            console.error("Error in BitflowSDK.cancelGroupOrder:", error);
+            throw error;
+        }
     }
 }
 exports.BitflowSDK = BitflowSDK;