@bitflowlabs/core-sdk 2.3.2 → 2.4.1

package/dist/test/BitflowSDK.test.js

@@ -0,0 +1,1143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const BitflowSDK_1 = require("../src/BitflowSDK");
+const config_1 = require("../src/config");
+const callReadOnlyHelper = tslib_1.__importStar(require("../src/helpers/callReadOnlyHelper"));
+const fetchDataHelper = tslib_1.__importStar(require("../src/helpers/fetchDataHelper"));
+const fetchPossibleSwap = tslib_1.__importStar(require("../src/helpers/fetchPossibleSwap"));
+const getContractInterfaceAndFunctionHelper = tslib_1.__importStar(require("../src/helpers/getContractInterfaceAndFunction"));
+const types_1 = require("../src/keeper/types");
+const callSwapHelper = tslib_1.__importStar(require("../src/helpers/callSwapHelper"));
+const keeperAPI = tslib_1.__importStar(require("../src/keeper/keeperAPI"));
+const callGetSwapParams = tslib_1.__importStar(require("../src/helpers/callGetSwapParams"));
+// Mock entire modules to control their behavior for our tests
+jest.mock('../src/config');
+jest.mock('../src/helpers/fetchDataHelper');
+jest.mock('../src/helpers/fetchPossibleSwap');
+jest.mock('../src/helpers/callReadOnlyHelper');
+jest.mock('../src/helpers/getContractInterfaceAndFunction');
+jest.mock('@stacks/transactions', () => ({
+    ...jest.requireActual('@stacks/transactions'), // Keep original module behavior
+    validateStacksAddress: jest.fn(() => true), // but mock this one function
+}));
+jest.mock('../src/helpers/callSwapHelper');
+jest.mock('../src/keeper/keeperAPI');
+jest.mock('../src/helpers/callGetSwapParams');
+const MOCK_PROVIDER_ADDRESS = 'SP2J6S063B42M61D5T1G295SA4238A7147A4N17X';
+// This is a helper to create fake API route data for our tests.
+// We can control exactly what the 'provider' field looks like.
+const createMockRoute = (providerValue) => {
+    const route = {
+        dex_path: ['DEX1'],
+        token_path: ['token-x', 'token-y'],
+        quoteData: {
+            contract: 'SP...contract',
+            function: 'get-quote',
+            parameters: {
+            // This is the key part: we will test what happens when
+            // the provider field is null, undefined, or a real address.
+            },
+        },
+        swapData: { contract: 'SP...swap-contract', function: 'swap', parameters: {} },
+        postConditions: {},
+        tokenXDecimals: 6,
+        tokenYDecimals: 6,
+    };
+    // If we pass 'undefined' to this helper, the 'provider' key won't even exist.
+    // This simulates an API response where the key is missing.
+    if (providerValue !== undefined) {
+        route.quoteData.parameters.provider = providerValue;
+    }
+    return route;
+};
+describe('BitflowSDK - Provider Logic in getQuoteForRoute', () => {
+    let sdk;
+    // Create mock functions that we can spy on
+    const mockedFetchAllTokens = fetchDataHelper.fetchAllTokensFromAPI;
+    const mockedFetchPossibleSwaps = fetchPossibleSwap.fetchPossibleSwapsFromAPI;
+    const mockedCallReadOnly = callReadOnlyHelper.callReadOnlyFunctionHelper;
+    const mockedGetInterface = getContractInterfaceAndFunctionHelper.getContractInterfaceAndFunction;
+    beforeEach(() => {
+        // Reset mocks and configurations before each test to ensure a clean slate
+        jest.clearAllMocks();
+        // Mock functions that are called during SDK initialization or the test itself
+        mockedFetchAllTokens.mockResolvedValue([]);
+        // This is the key change: we now simulate a contract function that expects a 'provider'.
+        mockedGetInterface.mockResolvedValue({
+            contractInterface: {},
+            functionArgs: [{ name: 'provider', type: '{optional: principal}' }]
+        });
+        mockedCallReadOnly.mockResolvedValue({ convertedResult: 100, rawResult: 1000, tokenXDecimals: 6, tokenYDecimals: 6 });
+        // Set up the default provider address for the SDK instance
+        config_1.configs.BITFLOW_PROVIDER_ADDRESS = MOCK_PROVIDER_ADDRESS;
+        // Initialize the SDK for each test
+        sdk = new BitflowSDK_1.BitflowSDK();
+    });
+    it('Scenario 1: Should use default provider when the route provider is null', async () => {
+        // ARRANGE: Create a fake route where the provider is explicitly `null`
+        const mockRouteWithNullProvider = createMockRoute(null);
+        mockedFetchPossibleSwaps.mockResolvedValue({ 'token-y': [mockRouteWithNullProvider] });
+        // ACT: Run the function we want to test
+        await sdk.getQuoteForRoute('token-x', 'token-y', 100);
+        // ASSERT: Check if our logic worked correctly
+        expect(mockedCallReadOnly).toHaveBeenCalledTimes(1);
+        const actualParams = mockedCallReadOnly.mock.calls[0][3]; // Get the 'params' argument
+        expect(actualParams.provider).toBe(MOCK_PROVIDER_ADDRESS); // It should have been added
+    });
+    it('Scenario 2: Should use default provider when the route provider is missing (undefined)', async () => {
+        // ARRANGE: Create a fake route where the 'provider' key doesn't exist
+        const mockRouteWithUndefinedProvider = createMockRoute(undefined);
+        mockedFetchPossibleSwaps.mockResolvedValue({ 'token-y': [mockRouteWithUndefinedProvider] });
+        // ACT
+        await sdk.getQuoteForRoute('token-x', 'token-y', 100);
+        // ASSERT
+        expect(mockedCallReadOnly).toHaveBeenCalledTimes(1);
+        const actualParams = mockedCallReadOnly.mock.calls[0][3];
+        expect(actualParams.provider).toBe(MOCK_PROVIDER_ADDRESS); // It should have been added
+    });
+    it('Scenario 3: Should NOT override the provider if a valid one is already present', async () => {
+        // ARRANGE: Create a fake route that already has a valid provider address
+        const routeSpecificProvider = 'SP3B15B6STM80A752A80W3P7J53KSAQ7J01PJ80B9';
+        const mockRouteWithSpecificProvider = createMockRoute(routeSpecificProvider);
+        mockedFetchPossibleSwaps.mockResolvedValue({ 'token-y': [mockRouteWithSpecificProvider] });
+        // ACT
+        await sdk.getQuoteForRoute('token-x', 'token-y', 100);
+        // ASSERT
+        expect(mockedCallReadOnly).toHaveBeenCalledTimes(1);
+        const actualParams = mockedCallReadOnly.mock.calls[0][3];
+        expect(actualParams.provider).toBe(routeSpecificProvider); // Should be the one from the route
+        expect(actualParams.provider).not.toBe(MOCK_PROVIDER_ADDRESS); // And NOT our default
+    });
+    it('Scenario 4: Should NOT add a provider if the function does not expect one', async () => {
+        // ARRANGE: For this test only, override the mock to simulate a function WITHOUT a provider.
+        mockedGetInterface.mockResolvedValue({ contractInterface: {}, functionArgs: [{ name: 'amount', type: 'uint' }] });
+        const mockRouteWithoutProvider = createMockRoute(undefined); // Provider is missing
+        mockedFetchPossibleSwaps.mockResolvedValue({ 'token-y': [mockRouteWithoutProvider] });
+        // ACT
+        await sdk.getQuoteForRoute('token-x', 'token-y', 100);
+        // ASSERT
+        expect(mockedCallReadOnly).toHaveBeenCalledTimes(1);
+        const actualParams = mockedCallReadOnly.mock.calls[0][3];
+        expect(actualParams.provider).toBeUndefined(); // Provider should NOT have been added
+    });
+});
+describe('BitflowSDK - Token and Swap Retrieval Methods', () => {
+    let sdk;
+    const mockedFetchAllTokens = fetchDataHelper.fetchAllTokensFromAPI;
+    const mockedFetchPossibleSwaps = fetchPossibleSwap.fetchPossibleSwapsFromAPI;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockedFetchAllTokens.mockResolvedValue([
+            { tokenId: 'token-x', isKeeperToken: false },
+            { tokenId: 'token-keeper', isKeeperToken: true },
+        ]);
+        mockedFetchPossibleSwaps.mockResolvedValue({ 'token-keeper': ['swap1', 'swap2'] });
+        sdk = new BitflowSDK_1.BitflowSDK();
+    });
+    it('should return all available tokens', async () => {
+        const tokens = await sdk.getAvailableTokens();
+        expect(tokens).toEqual([
+            { tokenId: 'token-x', isKeeperToken: false },
+            { tokenId: 'token-keeper', isKeeperToken: true },
+        ]);
+        expect(mockedFetchAllTokens).toHaveBeenCalled();
+    });
+    it('should return only keeper tokens', async () => {
+        const tokens = await sdk.getKeeperTokens();
+        expect(tokens).toEqual([
+            { tokenId: 'token-keeper', isKeeperToken: true }
+        ]);
+    });
+    it('should return possible swaps for a token', async () => {
+        const swaps = await sdk.getPossibleSwaps('token-keeper');
+        expect(swaps).toEqual({ 'token-keeper': ['swap1', 'swap2'] });
+        expect(mockedFetchPossibleSwaps).toHaveBeenCalledWith('token-keeper');
+    });
+});
+describe('BitflowSDK - Token Y and Route Methods', () => {
+    let sdk;
+    const mockedFetchAllTokens = fetchDataHelper.fetchAllTokensFromAPI;
+    const mockedFetchPossibleSwaps = fetchPossibleSwap.fetchPossibleSwapsFromAPI;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockedFetchAllTokens.mockResolvedValue([
+            { tokenId: 'token-x', isKeeperToken: false },
+            { tokenId: 'token-y', isKeeperToken: true },
+        ]);
+        mockedFetchPossibleSwaps.mockResolvedValue({ 'token-y': [{ foo: 'bar' }], 'token-z': [{ baz: 'qux' }] });
+        sdk = new BitflowSDK_1.BitflowSDK();
+        // Pre-populate swapOptions for keeper methods
+        sdk.context.swapOptions = {
+            'token-x': { 'token-y': [{ foo: 'bar' }], 'token-z': [{ baz: 'qux' }] },
+        };
+    });
+    it('should return all possible token Y for a given token X', async () => {
+        sdk.context.swapOptions['token-x'] = { 'token-y': [], 'token-z': [] };
+        const result = await sdk.getAllPossibleTokenY('token-x');
+        expect(result).toEqual(['token-y', 'token-z']);
+    });
+    it('should return all keeper possible token Y for a given token X', async () => {
+        // Simulate getKeeperPossibleSwaps returns a similar structure
+        sdk.getKeeperPossibleSwaps = jest.fn().mockResolvedValue({ 'token-y': [], 'token-z': [] });
+        const result = await sdk.getAllKeeperPossibleTokenY('token-x');
+        expect(result).toEqual(['token-y', 'token-z']);
+    });
+    it('should return all possible token Y routes for a given token X and Y', async () => {
+        sdk.context.swapOptions['token-x'] = { 'token-y': [{ foo: 'bar' }], 'token-z': [{ baz: 'qux' }] };
+        const result = await sdk.getAllPossibleTokenYRoutes('token-x', 'token-y');
+        expect(result).toEqual([{ foo: 'bar' }]);
+    });
+    it('should return all keeper possible token Y routes for a given token X and Y', async () => {
+        sdk.getKeeperPossibleSwaps = jest.fn().mockResolvedValue({ 'token-y': [{ foo: 'bar' }], 'token-z': [{ baz: 'qux' }] });
+        const result = await sdk.getAllKeeperPossibleTokenYRoutes('token-x', 'token-y');
+        expect(result).toEqual([{ foo: 'bar' }]);
+    });
+});
+describe('BitflowSDK - Route Quote Methods', () => {
+    let sdk;
+    const mockedFetchAllTokens = fetchDataHelper.fetchAllTokensFromAPI;
+    const mockedFetchPossibleSwaps = fetchPossibleSwap.fetchPossibleSwapsFromAPI;
+    const mockedCallReadOnly = callReadOnlyHelper.callReadOnlyFunctionHelper;
+    const mockedCallReadOnlyNoScale = callReadOnlyHelper.callReadOnlyFunctionHelperWithoutScaling;
+    const mockedGetInterface = getContractInterfaceAndFunctionHelper.getContractInterfaceAndFunction;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockedFetchAllTokens.mockResolvedValue([
+            { tokenId: 'token-x', isKeeperToken: false },
+            { tokenId: 'token-y', isKeeperToken: true },
+        ]);
+        mockedFetchPossibleSwaps.mockResolvedValue({ 'token-y': [{
+                    quoteData: {
+                        contract: 'SP...contract',
+                        function: 'get-quote',
+                        parameters: { amount: null },
+                    },
+                    swapData: { contract: 'SP...swap-contract', function: 'swap', parameters: {} },
+                    dex_path: ['BITFLOW_STABLE_XY_2'],
+                    tokenPath: ['token-x', 'token-y'],
+                }] });
+        mockedGetInterface.mockResolvedValue({ contractInterface: {}, functionArgs: [{ name: 'amount', type: 'uint' }] });
+        mockedCallReadOnly.mockResolvedValue({ convertedResult: 100, rawResult: 1000, tokenXDecimals: 6, tokenYDecimals: 6, allRoutes: [], bestRoute: null });
+        mockedCallReadOnlyNoScale.mockResolvedValue({ convertedResult: 100, rawResult: 1000, tokenXDecimals: 6, tokenYDecimals: 6, allRoutes: [], bestRoute: null });
+        sdk = new BitflowSDK_1.BitflowSDK();
+        sdk.context.swapOptions = {
+            'token-x': { 'token-y': [{
+                        quoteData: {
+                            contract: 'SP...contract',
+                            function: 'get-quote',
+                            parameters: { amount: null },
+                        },
+                        swapData: { contract: 'SP...swap-contract', function: 'swap', parameters: {} },
+                        dex_path: ['BITFLOW_STABLE_XY_2'],
+                        tokenPath: ['token-x', 'token-y'],
+                    }] },
+        };
+    });
+    it('should get a quote for a route', async () => {
+        const result = await sdk.getQuoteForRoute('token-x', 'token-y', 100);
+        expect(result.bestRoute).toBeDefined();
+        expect(result.allRoutes.length).toBeGreaterThan(0);
+        expect(result.inputData.tokenX).toBe('token-x');
+        expect(mockedCallReadOnly).toHaveBeenCalled();
+    });
+    it('should get a keeper quote for a route', async () => {
+        // The keeper method filters for compatible DEX paths
+        const result = await sdk.getKeeperQuoteForRoute('token-x', 'token-y', 100);
+        expect(result.bestRoute).toBeDefined();
+        expect(result.allRoutes.length).toBeGreaterThan(0);
+        expect(result.inputData.tokenX).toBe('token-x');
+        expect(mockedCallReadOnly).toHaveBeenCalled();
+    });
+    it('should get a keeper quote for a route without scaling', async () => {
+        const result = await sdk.getKeeperQuoteForRouteWithoutScaling('token-x', 'token-y', 100);
+        expect(result.bestRoute).toBeDefined();
+        expect(result.allRoutes.length).toBeGreaterThan(0);
+        expect(result.inputData.tokenX).toBe('token-x');
+        expect(mockedCallReadOnlyNoScale).toHaveBeenCalled();
+    });
+});
+describe('BitflowSDK - Execution and Keeper Methods', () => {
+    let sdk;
+    const mockedFetchAllTokens = fetchDataHelper.fetchAllTokensFromAPI;
+    const mockedExecuteSwapHelper = callSwapHelper.executeSwapHelper;
+    const mockedGetOrCreateKeeperContractAPI = keeperAPI.getOrCreateKeeperContractAPI;
+    const mockedGetUserAPI = keeperAPI.getUserAPI;
+    const mockedGetQuoteAPI = keeperAPI.getQuoteAPI;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockedFetchAllTokens.mockResolvedValue([
+            { tokenId: 'token-x', isKeeperToken: false },
+            { tokenId: 'token-y', isKeeperToken: true },
+        ]);
+        sdk = new BitflowSDK_1.BitflowSDK();
+    });
+    it('should call executeSwapHelper in executeSwap', async () => {
+        mockedExecuteSwapHelper.mockResolvedValue(undefined);
+        const swapExecutionData = {
+            route: {
+                dex_path: [],
+                postConditions: {},
+                quoteData: { contract: '', function: '', parameters: {} },
+                swapData: { contract: '', function: '', parameters: {} },
+                token_path: [],
+                tokenXDecimals: 6,
+                tokenYDecimals: 6,
+            },
+            amount: 1,
+            tokenXDecimals: 6,
+            tokenYDecimals: 6,
+        };
+        const senderAddress = 'SENDER';
+        sdk.getSwapParams = jest.fn().mockResolvedValue({});
+        sdk.loadConnectDependencies = jest.fn().mockResolvedValue({});
+        global.window = {};
+        await expect(sdk.executeSwap(swapExecutionData, senderAddress)).resolves.toBeUndefined();
+        expect(mockedExecuteSwapHelper).toHaveBeenCalled();
+        delete global.window;
+    });
+    it('should throw if executeSwap is called in Node.js', async () => {
+        const swapExecutionData = {
+            route: {
+                dex_path: [],
+                postConditions: {},
+                quoteData: { contract: '', function: '', parameters: {} },
+                swapData: { contract: '', function: '', parameters: {} },
+                token_path: [],
+                tokenXDecimals: 6,
+                tokenYDecimals: 6,
+            },
+            amount: 1,
+            tokenXDecimals: 6,
+            tokenYDecimals: 6,
+        };
+        const senderAddress = 'SENDER';
+        sdk.getSwapParams = jest.fn().mockResolvedValue({});
+        sdk.loadConnectDependencies = undefined; // Remove the mock to trigger the Node.js error path
+        delete global.window;
+        await expect(sdk.executeSwap(swapExecutionData, senderAddress)).rejects.toThrow('only available in browser environments');
+    });
+    it('should get or create keeper contract', async () => {
+        mockedGetOrCreateKeeperContractAPI.mockResolvedValue({ contract: 'keeper-contract' });
+        const params = { stacksAddress: 'SOMEADDR', keeperType: types_1.KeeperType.SWAP_BTC_TO_STX };
+        const result = await sdk.getOrCreateKeeperContract(params);
+        expect(result).toEqual({ contract: 'keeper-contract' });
+        expect(mockedGetOrCreateKeeperContractAPI).toHaveBeenCalled();
+    });
+    it('should get user', async () => {
+        mockedGetUserAPI.mockResolvedValue({ user: 'user-data' });
+        const result = await sdk.getUser('SOMEADDR');
+        expect(result).toEqual({ user: 'user-data' });
+        expect(mockedGetUserAPI).toHaveBeenCalled();
+    });
+    it('should get quote', async () => {
+        mockedGetQuoteAPI.mockResolvedValue({ quote: 'quote-data' });
+        const params = { stacksAddress: 'SOMEADDR', actionAmount: '1', keeperType: types_1.KeeperType.SWAP_BTC_TO_STX };
+        const result = await sdk.getQuote(params);
+        expect(result).toEqual({ quote: 'quote-data' });
+        expect(mockedGetQuoteAPI).toHaveBeenCalled();
+    });
+    it('should handle errors in getOrCreateKeeperContract', async () => {
+        mockedGetOrCreateKeeperContractAPI.mockRejectedValue(new Error('fail'));
+        const params = { stacksAddress: 'SOMEADDR', keeperType: types_1.KeeperType.SWAP_BTC_TO_STX };
+        await expect(sdk.getOrCreateKeeperContract(params)).rejects.toThrow('fail');
+    });
+    it('should handle errors in getUser', async () => {
+        mockedGetUserAPI.mockRejectedValue(new Error('fail'));
+        await expect(sdk.getUser('SOMEADDR')).rejects.toThrow('fail');
+    });
+    it('should handle errors in getQuote', async () => {
+        mockedGetQuoteAPI.mockRejectedValue(new Error('fail'));
+        const params = { stacksAddress: 'SOMEADDR', actionAmount: '1', keeperType: types_1.KeeperType.SWAP_BTC_TO_STX };
+        await expect(sdk.getQuote(params)).rejects.toThrow('fail');
+    });
+});
+describe('BitflowSDK - Additional Keeper Methods', () => {
+    let sdk;
+    const mockedGetOrderAPI = keeperAPI.getOrderAPI;
+    const mockedCreateOrderAPI = keeperAPI.createOrderAPI;
+    const mockedCreateGroupOrderAPI = keeperAPI.createGroupOrderAPI;
+    const mockedGetGroupOrderAPI = keeperAPI.getGroupOrderAPI;
+    const mockedCancelOrderAPI = keeperAPI.cancelOrderAPI;
+    const mockedCancelGroupOrderAPI = keeperAPI.cancelGroupOrderAPI;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        sdk = new BitflowSDK_1.BitflowSDK();
+    });
+    it('should get order', async () => {
+        mockedGetOrderAPI.mockResolvedValue({ order: 'order-data' });
+        const result = await sdk.getOrder('order123');
+        expect(result).toEqual({ order: 'order-data' });
+        expect(mockedGetOrderAPI).toHaveBeenCalledWith('order123');
+    });
+    it('should handle errors in getOrder', async () => {
+        mockedGetOrderAPI.mockRejectedValue(new Error('fail'));
+        await expect(sdk.getOrder('order123')).rejects.toThrow('fail');
+    });
+    it('should create order', async () => {
+        mockedCreateOrderAPI.mockResolvedValue({ order: 'created' });
+        const params = {
+            stacksAddress: 'ST123',
+            keeperType: types_1.KeeperType.SWAP_BTC_TO_STX,
+            contractIdentifier: 'contract',
+            bitcoinAddress: 'btc123',
+            actionAmount: '100',
+            minReceived: { amount: '50', autoAdjust: true },
+            feeRecipient: 'fee',
+            tokenOrder: ['token1', 'token2'],
+            actionType: 'swap',
+            bitcoinTxId: 'txid',
+            fundingTokens: { token1: '10' },
+            actionAggregatorTokens: { tokenXId: 'token1', tokenYId: 'token2' },
+        };
+        const result = await sdk.createOrder(params);
+        expect(result).toEqual({ order: 'created' });
+        expect(mockedCreateOrderAPI).toHaveBeenCalledWith(params);
+    });
+    it('should handle errors in createOrder', async () => {
+        mockedCreateOrderAPI.mockRejectedValue(new Error('fail'));
+        const params = {
+            stacksAddress: 'ST123',
+            keeperType: types_1.KeeperType.SWAP_BTC_TO_STX,
+            contractIdentifier: 'contract',
+            bitcoinAddress: 'btc123',
+            actionAmount: '100',
+            minReceived: { amount: '50', autoAdjust: true },
+            feeRecipient: 'fee',
+            tokenOrder: ['token1', 'token2'],
+            actionType: 'swap',
+            bitcoinTxId: 'txid',
+            fundingTokens: { token1: '10' },
+            actionAggregatorTokens: { tokenXId: 'token1', tokenYId: 'token2' },
+        };
+        await expect(sdk.createOrder(params)).rejects.toThrow('fail');
+    });
+    it('should create group order', async () => {
+        mockedCreateGroupOrderAPI.mockResolvedValue({ groupOrder: 'created' });
+        const params = {
+            stacksAddress: 'ST123',
+            amountPerOrder: 10,
+            numberOfOrders: 2,
+            executionFrequency: 60,
+            feeRecipient: 'fee',
+            fundingTokens: { token1: '10' },
+            keeperType: types_1.KeeperType.SWAP_BTC_TO_STX,
+            minReceived: { amount: '50', autoAdjust: true },
+            groupId: 'group1',
+            orders: [],
+        };
+        const result = await sdk.createGroupOrder(params);
+        expect(result).toEqual({ groupOrder: 'created' });
+        expect(mockedCreateGroupOrderAPI).toHaveBeenCalledWith(params);
+    });
+    it('should handle errors in createGroupOrder', async () => {
+        mockedCreateGroupOrderAPI.mockRejectedValue(new Error('fail'));
+        const params = {
+            stacksAddress: 'ST123',
+            amountPerOrder: 10,
+            numberOfOrders: 2,
+            executionFrequency: 60,
+            feeRecipient: 'fee',
+            fundingTokens: { token1: '10' },
+            keeperType: types_1.KeeperType.SWAP_BTC_TO_STX,
+            minReceived: { amount: '50', autoAdjust: true },
+            groupId: 'group1',
+            orders: [],
+        };
+        await expect(sdk.createGroupOrder(params)).rejects.toThrow('fail');
+    });
+    it('should get group order', async () => {
+        mockedGetGroupOrderAPI.mockResolvedValue({ groupOrder: 'data' });
+        const result = await sdk.getGroupOrder('group1', true);
+        expect(result).toEqual({ groupOrder: 'data' });
+        expect(mockedGetGroupOrderAPI).toHaveBeenCalledWith('group1', true);
+    });
+    it('should handle errors in getGroupOrder', async () => {
+        mockedGetGroupOrderAPI.mockRejectedValue(new Error('fail'));
+        await expect(sdk.getGroupOrder('group1', true)).rejects.toThrow('fail');
+    });
+    it('should cancel order', async () => {
+        mockedCancelOrderAPI.mockResolvedValue({ cancel: 'ok' });
+        const result = await sdk.cancelOrder('order123');
+        expect(result).toEqual({ cancel: 'ok' });
+        expect(mockedCancelOrderAPI).toHaveBeenCalledWith('order123');
+    });
+    it('should handle errors in cancelOrder', async () => {
+        mockedCancelOrderAPI.mockRejectedValue(new Error('fail'));
+        await expect(sdk.cancelOrder('order123')).rejects.toThrow('fail');
+    });
+    it('should cancel group order', async () => {
+        mockedCancelGroupOrderAPI.mockResolvedValue({ cancel: 'ok' });
+        const result = await sdk.cancelGroupOrder('group1');
+        expect(result).toEqual({ cancel: 'ok' });
+        expect(mockedCancelGroupOrderAPI).toHaveBeenCalledWith('group1');
+    });
+    it('should handle errors in cancelGroupOrder', async () => {
+        mockedCancelGroupOrderAPI.mockRejectedValue(new Error('fail'));
+        await expect(sdk.cancelGroupOrder('group1')).rejects.toThrow('fail');
+    });
+});
+describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
+    let sdk;
+    const mockedCallGetSwapParams = callGetSwapParams.executeGetParams;
+    const mockedCallReadOnlyNoScale = callReadOnlyHelper.callReadOnlyFunctionHelperWithoutScaling;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockedCallGetSwapParams.mockResolvedValue({
+            swapData: { data: 'swap-data' },
+            parameters: { params: 'params' },
+            postConditions: { conditions: 'conditions' }
+        });
+        // Mock the getKeeperQuoteForRouteWithoutScaling method
+        jest.spyOn(BitflowSDK_1.BitflowSDK.prototype, 'getKeeperQuoteForRouteWithoutScaling').mockResolvedValue({
+            bestRoute: {
+                route: {
+                    dex_path: ['BITFLOW_XY_2_xyk'],
+                    token_path: ['token-x', 'token-y'],
+                    postConditions: {},
+                    tokenXDecimals: 6,
+                    tokenYDecimals: 6,
+                    quoteData: {
+                        contract: 'SP...contract',
+                        function: 'get-quote',
+                        parameters: { amount: 100 },
+                    },
+                    swapData: {
+                        contract: 'SP...swap-contract',
+                        function: 'swap',
+                        parameters: {
+                            'pool-trait': 'SP1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.xyk-pool-v-1-2',
+                        },
+                    },
+                },
+                quote: 100,
+                params: {},
+                quoteData: {
+                    contract: 'SP...contract',
+                    function: 'get-quote',
+                    parameters: { amount: 100 },
+                },
+                swapData: {
+                    contract: 'SP...swap-contract',
+                    function: 'swap',
+                    parameters: {
+                        'pool-trait': 'SP1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.xyk-pool-v-1-2',
+                    },
+                },
+                dexPath: ['BITFLOW_XY_2_xyk'],
+                tokenPath: ['token-x', 'token-y'],
+                tokenXDecimals: 6,
+                tokenYDecimals: 6,
+            },
+            allRoutes: [{
+                    route: {
+                        dex_path: ['BITFLOW_XY_2_xyk'],
+                        token_path: ['token-x', 'token-y'],
+                        postConditions: {},
+                        tokenXDecimals: 6,
+                        tokenYDecimals: 6,
+                        quoteData: {
+                            contract: 'SP...contract',
+                            function: 'get-quote',
+                            parameters: { amount: 100 },
+                        },
+                        swapData: {
+                            contract: 'SP...swap-contract',
+                            function: 'swap',
+                            parameters: {
+                                'pool-trait': 'SP1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.xyk-pool-v-1-2',
+                            },
+                        },
+                    },
+                    quote: 100,
+                    params: {},
+                    quoteData: {
+                        contract: 'SP...contract',
+                        function: 'get-quote',
+                        parameters: { amount: 100 },
+                    },
+                    swapData: {
+                        contract: 'SP...swap-contract',
+                        function: 'swap',
+                        parameters: {
+                            'pool-trait': 'SP1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.xyk-pool-v-1-2',
+                        },
+                    },
+                    dexPath: ['BITFLOW_XY_2_xyk'],
+                    tokenPath: ['token-x', 'token-y'],
+                    tokenXDecimals: 6,
+                    tokenYDecimals: 6,
+                }],
+            inputData: {
+                tokenX: 'token-x',
+                tokenY: 'token-y',
+                amountInput: 100,
+            },
+        });
+        sdk = new BitflowSDK_1.BitflowSDK();
+    });
+    it('should get swap params', async () => {
+        const swapExecutionData = {
+            route: {
+                dex_path: ['BITFLOW_XY_2'],
+                postConditions: {},
+                quoteData: { contract: 'SP...contract', function: 'get-quote', parameters: { amount: null } },
+                swapData: {
+                    contract: 'SP...swap-contract',
+                    function: 'swap',
+                    parameters: {
+                        'pool-trait': 'SP1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.xyk-pool-v-1-2'
+                    }
+                },
+                token_path: ['token-x', 'token-y'],
+                tokenXDecimals: 6,
+                tokenYDecimals: 6,
+            },
+            amount: 100,
+            tokenXDecimals: 6,
+            tokenYDecimals: 6,
+        };
+        const senderAddress = 'SENDER';
+        const result = await sdk.getSwapParams(swapExecutionData, senderAddress, 0.015);
+        expect(result).toEqual({
+            swapData: { data: 'swap-data' },
+            parameters: { params: 'params' },
+            postConditions: { conditions: 'conditions' }
+        });
+        expect(mockedCallGetSwapParams).toHaveBeenCalled();
+    });
+    it('should prepare swap', async () => {
+        const swapExecutionData = {
+            route: {
+                dex_path: ['BITFLOW_XY_2'],
+                postConditions: {},
+                quoteData: { contract: 'SP...contract', function: 'get-quote', parameters: { amount: null } },
+                swapData: {
+                    contract: 'SP...swap-contract',
+                    function: 'swap',
+                    parameters: {
+                        'pool-trait': 'SP1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.xyk-pool-v-1-2'
+                    }
+                },
+                token_path: ['token-x', 'token-y'],
+                tokenXDecimals: 6,
+                tokenYDecimals: 6,
+            },
+            amount: 100,
+            tokenXDecimals: 6,
+            tokenYDecimals: 6,
+        };
+        const senderAddress = 'SENDER';
+        const result = await sdk.prepareSwap(swapExecutionData, senderAddress, 0.015);
+        expect(result).toEqual({
+            swapData: { data: 'swap-data' },
+            parameters: { params: 'params' },
+            postConditions: { conditions: 'conditions' }
+        });
+        expect(mockedCallGetSwapParams).toHaveBeenCalled();
+    });
+    it('should get keeper aggregator route data', async () => {
+        sdk["context"].availableTokens = [
+            {
+                base: 'base-x',
+                type: 'type-x',
+                icon: '',
+                name: 'Token X',
+                status: 'active',
+                symbol: 'TKX',
+                tokenId: 'token-x',
+                "token-id": 'token-x',
+                tokenContract: 'contract-x',
+                tokenDecimals: 6,
+                tokenName: 'Token X',
+                wrapTokens: null,
+                isKeeperToken: false,
+                bridge: 'FALSE',
+                layerOneAsset: null,
+                priceData: {
+                    "1h_change": null,
+                    "1yr_change": null,
+                    "24h_change": null,
+                    "30d_change": null,
+                    "7d_change": null,
+                    last_price: null,
+                    last_updated: null,
+                },
+            },
+            {
+                base: 'base-y',
+                type: 'type-y',
+                icon: '',
+                name: 'Token Y',
+                status: 'active',
+                symbol: 'TKY',
+                tokenId: 'token-y',
+                "token-id": 'token-y',
+                tokenContract: 'contract-y',
+                tokenDecimals: 8,
+                tokenName: 'Token Y',
+                wrapTokens: null,
+                isKeeperToken: false,
+                bridge: 'FALSE',
+                layerOneAsset: null,
+                priceData: {
+                    "1h_change": null,
+                    "1yr_change": null,
+                    "24h_change": null,
+                    "30d_change": null,
+                    "7d_change": null,
+                    last_price: null,
+                    last_updated: null,
+                },
+            },
+        ];
+        const result = await sdk.getKeeperAggregatorRouteData('token-x', 'token-y', 100);
+        expect(result.xykPoolList).toBeDefined();
+        expect(result.actionTrait).toBeDefined();
+    });
+    it('should handle mixed XYK and stableswap route', async () => {
+        sdk["context"].availableTokens = [
+            {
+                base: 'base-x',
+                type: 'type-x',
+                icon: '',
+                name: 'Token X',
+                status: 'active',
+                symbol: 'TKX',
+                tokenId: 'token-x',
+                "token-id": 'token-x',
+                tokenContract: 'contract-x',
+                tokenDecimals: 6,
+                tokenName: 'Token X',
+                wrapTokens: null,
+                isKeeperToken: false,
+                bridge: 'FALSE',
+                layerOneAsset: null,
+                priceData: {
+                    "1h_change": null,
+                    "1yr_change": null,
+                    "24h_change": null,
+                    "30d_change": null,
+                    "7d_change": null,
+                    last_price: null,
+                    last_updated: null,
+                },
+            },
+            {
+                base: 'base-y',
+                type: 'type-y',
+                icon: '',
+                name: 'Token Y',
+                status: 'active',
+                symbol: 'TKY',
+                tokenId: 'token-y',
+                "token-id": 'token-y',
+                tokenContract: 'contract-y',
+                tokenDecimals: 8,
+                tokenName: 'Token Y',
+                wrapTokens: null,
+                isKeeperToken: false,
+                bridge: 'FALSE',
+                layerOneAsset: null,
+                priceData: {
+                    "1h_change": null,
+                    "1yr_change": null,
+                    "24h_change": null,
+                    "30d_change": null,
+                    "7d_change": null,
+                    last_price: null,
+                    last_updated: null,
+                },
+            },
+        ];
+        // Override the mock for this specific test
+        jest.spyOn(BitflowSDK_1.BitflowSDK.prototype, 'getKeeperQuoteForRouteWithoutScaling').mockResolvedValue({
+            bestRoute: {
+                route: {
+                    dex_path: ['BITFLOW_XY_2_xyk', 'BITFLOW_STABLE_XY_2_stable'],
+                    token_path: ['token-x', 'token-y'],
+                    postConditions: {},
+                    tokenXDecimals: 6,
+                    tokenYDecimals: 6,
+                    quoteData: {
+                        contract: 'SP...contract',
+                        function: 'get-quote',
+                        parameters: { amount: 100 },
+                    },
+                    swapData: {
+                        contract: 'SP...swap-contract',
+                        function: 'swap',
+                        parameters: {
+                            'xyk-pools': ['pool1', 'pool2'],
+                            'stableswap-pools': ['stable-pool1'],
+                        },
+                    },
+                },
+                quote: 100,
+                params: {},
+                quoteData: {
+                    contract: 'SP...contract',
+                    function: 'get-quote',
+                    parameters: { amount: 100 },
+                },
+                swapData: {
+                    contract: 'SP...swap-contract',
+                    function: 'swap',
+                    parameters: {
+                        'xyk-pools': ['pool1', 'pool2'],
+                        'stableswap-pools': ['stable-pool1'],
+                    },
+                },
+                dexPath: ['BITFLOW_XY_2_xyk', 'BITFLOW_STABLE_XY_2_stable'],
+                tokenPath: ['token-x', 'token-y'],
+                tokenXDecimals: 6,
+                tokenYDecimals: 6,
+            },
+            allRoutes: [{
+                    route: {
+                        dex_path: ['BITFLOW_XY_2_xyk', 'BITFLOW_STABLE_XY_2_stable'],
+                        token_path: ['token-x', 'token-y'],
+                        postConditions: {},
+                        tokenXDecimals: 6,
+                        tokenYDecimals: 6,
+                        quoteData: {
+                            contract: 'SP...contract',
+                            function: 'get-quote',
+                            parameters: { amount: 100 },
+                        },
+                        swapData: {
+                            contract: 'SP...swap-contract',
+                            function: 'swap',
+                            parameters: {
+                                'xyk-pools': ['pool1', 'pool2'],
+                                'stableswap-pools': ['stable-pool1'],
+                            },
+                        },
+                    },
+                    quote: 100,
+                    params: {},
+                    quoteData: {
+                        contract: 'SP...contract',
+                        function: 'get-quote',
+                        parameters: { amount: 100 },
+                    },
+                    swapData: {
+                        contract: 'SP...swap-contract',
+                        function: 'swap',
+                        parameters: {
+                            'xyk-pools': ['pool1', 'pool2'],
+                            'stableswap-pools': ['stable-pool1'],
+                        },
+                    },
+                    dexPath: ['BITFLOW_XY_2_xyk', 'BITFLOW_STABLE_XY_2_stable'],
+                    tokenPath: ['token-x', 'token-y'],
+                    tokenXDecimals: 6,
+                    tokenYDecimals: 6,
+                }],
+            inputData: {
+                tokenX: 'token-x',
+                tokenY: 'token-y',
+                amountInput: 100,
+            },
+        });
+        const result = await sdk.getKeeperAggregatorRouteData('token-x', 'token-y', 100);
+        expect(result.xykPoolList).toBeDefined();
+        expect(result.stableswapPoolList).toBeDefined();
+    });
+    it('should handle swaps-reversed parameter', async () => {
+        sdk["context"].availableTokens = [
+            {
+                base: 'base-x',
+                type: 'type-x',
+                icon: '',
+                name: 'Token X',
+                status: 'active',
+                symbol: 'TKX',
+                tokenId: 'token-x',
+                "token-id": 'token-x',
+                tokenContract: 'contract-x',
+                tokenDecimals: 6,
+                tokenName: 'Token X',
+                wrapTokens: null,
+                isKeeperToken: false,
+                bridge: 'FALSE',
+                layerOneAsset: null,
+                priceData: {
+                    "1h_change": null,
+                    "1yr_change": null,
+                    "24h_change": null,
+                    "30d_change": null,
+                    "7d_change": null,
+                    last_price: null,
+                    last_updated: null,
+                },
+            },
+            {
+                base: 'base-y',
+                type: 'type-y',
+                icon: '',
+                name: 'Token Y',
+                status: 'active',
+                symbol: 'TKY',
+                tokenId: 'token-y',
+                "token-id": 'token-y',
+                tokenContract: 'contract-y',
+                tokenDecimals: 8,
+                tokenName: 'Token Y',
+                wrapTokens: null,
+                isKeeperToken: false,
+                bridge: 'FALSE',
+                layerOneAsset: null,
+                priceData: {
+                    "1h_change": null,
+                    "1yr_change": null,
+                    "24h_change": null,
+                    "30d_change": null,
+                    "7d_change": null,
+                    last_price: null,
+                    last_updated: null,
+                },
+            },
+        ];
+        // Override the mock for this specific test
+        jest.spyOn(BitflowSDK_1.BitflowSDK.prototype, 'getKeeperQuoteForRouteWithoutScaling').mockResolvedValue({
+            bestRoute: {
+                route: {
+                    dex_path: ['BITFLOW_XY_2_xyk'],
+                    token_path: ['token-x', 'token-y'],
+                    postConditions: {},
+                    tokenXDecimals: 6,
+                    tokenYDecimals: 6,
+                    quoteData: {
+                        contract: 'SP...contract',
+                        function: 'get-quote',
+                        parameters: { amount: 100 },
+                    },
+                    swapData: {
+                        contract: 'SP...swap-contract',
+                        function: 'swap',
+                        parameters: {
+                            'pool-trait': 'SP1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.xyk-pool-v-1-2',
+                            'swaps-reversed': true,
+                        },
+                    },
+                },
+                quote: 100,
+                params: {},
+                quoteData: {
+                    contract: 'SP...contract',
+                    function: 'get-quote',
+                    parameters: { amount: 100 },
+                },
+                swapData: {
+                    contract: 'SP...swap-contract',
+                    function: 'swap',
+                    parameters: {
+                        'pool-trait': 'SP1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.xyk-pool-v-1-2',
+                        'swaps-reversed': true,
+                    },
+                },
+                dexPath: ['BITFLOW_XY_2_xyk'],
+                tokenPath: ['token-x', 'token-y'],
+                tokenXDecimals: 6,
+                tokenYDecimals: 6,
+            },
+            allRoutes: [{
+                    route: {
+                        dex_path: ['BITFLOW_XY_2_xyk'],
+                        token_path: ['token-x', 'token-y'],
+                        postConditions: {},
+                        tokenXDecimals: 6,
+                        tokenYDecimals: 6,
+                        quoteData: {
+                            contract: 'SP...contract',
+                            function: 'get-quote',
+                            parameters: { amount: 100 },
+                        },
+                        swapData: {
+                            contract: 'SP...swap-contract',
+                            function: 'swap',
+                            parameters: {
+                                'pool-trait': 'SP1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.xyk-pool-v-1-2',
+                                'swaps-reversed': true,
+                            },
+                        },
+                    },
+                    quote: 100,
+                    params: {},
+                    quoteData: {
+                        contract: 'SP...contract',
+                        function: 'get-quote',
+                        parameters: { amount: 100 },
+                    },
+                    swapData: {
+                        contract: 'SP...swap-contract',
+                        function: 'swap',
+                        parameters: {
+                            'pool-trait': 'SP1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.xyk-pool-v-1-2',
+                            'swaps-reversed': true,
+                        },
+                    },
+                    dexPath: ['BITFLOW_XY_2_xyk'],
+                    tokenPath: ['token-x', 'token-y'],
+                    tokenXDecimals: 6,
+                    tokenYDecimals: 6,
+                }],
+            inputData: {
+                tokenX: 'token-x',
+                tokenY: 'token-y',
+                amountInput: 100,
+            },
+        });
+        const result = await sdk.getKeeperAggregatorRouteData('token-x', 'token-y', 100);
+        expect(result.xykPoolList).toBeDefined();
+        expect(result.actionTrait).toBeDefined();
+        expect(result.boolList).toBeDefined();
+    });
+    it('should handle unsupported DEX path in mapDexPathToActionTrait', async () => {
+        // Patch availableTokens so contract identifier lookup does not fail
+        sdk["context"].availableTokens = [
+            {
+                base: 'base-x',
+                type: 'type-x',
+                icon: '',
+                name: 'Token X',
+                status: 'active',
+                symbol: 'TKX',
+                tokenId: 'token-x',
+                "token-id": 'token-x',
+                tokenContract: 'contract-x',
+                tokenDecimals: 6,
+                tokenName: 'Token X',
+                wrapTokens: null,
+                isKeeperToken: false,
+                bridge: 'FALSE',
+                layerOneAsset: null,
+                priceData: {
+                    "1h_change": null,
+                    "1yr_change": null,
+                    "24h_change": null,
+                    "30d_change": null,
+                    "7d_change": null,
+                    last_price: null,
+                    last_updated: null,
+                },
+            },
+            {
+                base: 'base-y',
+                type: 'type-y',
+                icon: '',
+                name: 'Token Y',
+                status: 'active',
+                symbol: 'TKY',
+                tokenId: 'token-y',
+                "token-id": 'token-y',
+                tokenContract: 'contract-y',
+                tokenDecimals: 8,
+                tokenName: 'Token Y',
+                wrapTokens: null,
+                isKeeperToken: false,
+                bridge: 'FALSE',
+                layerOneAsset: null,
+                priceData: {
+                    "1h_change": null,
+                    "1yr_change": null,
+                    "24h_change": null,
+                    "30d_change": null,
+                    "7d_change": null,
+                    last_price: null,
+                    last_updated: null,
+                },
+            },
+        ];
+        // Mock getKeeperQuoteForRouteWithoutScaling to return a route with unsupported DEX path
+        jest.spyOn(sdk, 'getKeeperQuoteForRouteWithoutScaling').mockResolvedValue({
+            bestRoute: {
+                route: {
+                    dex_path: ['unsupported-dex'],
+                    token_path: ['token-x', 'token-y'],
+                    postConditions: {},
+                    quoteData: { contract: 'test', function: 'test', parameters: {} },
+                    swapData: { contract: 'test', function: 'test', parameters: {} },
+                    tokenXDecimals: 6,
+                    tokenYDecimals: 8,
+                },
+                quote: 100,
+                params: {},
+                quoteData: { contract: 'test', function: 'test', parameters: {} },
+                swapData: { contract: 'test', function: 'test', parameters: {} },
+                dexPath: ['unsupported-dex'],
+                tokenPath: ['token-x', 'token-y'],
+                tokenXDecimals: 6,
+                tokenYDecimals: 8,
+            },
+            allRoutes: [
+                {
+                    route: {
+                        dex_path: ['unsupported-dex'],
+                        token_path: ['token-x', 'token-y'],
+                        postConditions: {},
+                        quoteData: { contract: 'test', function: 'test', parameters: {} },
+                        swapData: { contract: 'test', function: 'test', parameters: {} },
+                        tokenXDecimals: 6,
+                        tokenYDecimals: 8,
+                    },
+                    quote: 100,
+                    params: {},
+                    quoteData: { contract: 'test', function: 'test', parameters: {} },
+                    swapData: { contract: 'test', function: 'test', parameters: {} },
+                    dexPath: ['unsupported-dex'],
+                    tokenPath: ['token-x', 'token-y'],
+                    tokenXDecimals: 6,
+                    tokenYDecimals: 8,
+                },
+            ],
+            inputData: { tokenX: 'token-x', tokenY: 'token-y', amountInput: 100 },
+        });
+        await expect(sdk.getKeeperAggregatorRouteData('token-x', 'token-y', 100)).rejects.toThrow('Unsupported DEX path: unsupported-dex');
+    });
+    it('should handle no routes found in getKeeperAggregatorRouteData', async () => {
+        // Mock getKeeperQuoteForRouteWithoutScaling to return no routes
+        jest.spyOn(sdk, 'getKeeperQuoteForRouteWithoutScaling').mockResolvedValue({
+            bestRoute: null,
+            allRoutes: [],
+            inputData: { tokenX: 'token-x', tokenY: 'token-y', amountInput: 100 },
+        });
+        await expect(sdk.getKeeperAggregatorRouteData('token-x', 'token-y', 100)).rejects.toThrow('No routes found');
+    });
+    it('should handle no best route found in getKeeperAggregatorRouteData', async () => {
+        // Mock getKeeperQuoteForRouteWithoutScaling to return routes but no best route
+        jest.spyOn(sdk, 'getKeeperQuoteForRouteWithoutScaling').mockResolvedValue({
+            bestRoute: null,
+            allRoutes: [
+                {
+                    route: {
+                        dex_path: ['xyk'],
+                        token_path: ['token-x', 'token-y'],
+                        postConditions: {},
+                        quoteData: { contract: 'test', function: 'test', parameters: {} },
+                        swapData: { contract: 'test', function: 'test', parameters: {} },
+                        tokenXDecimals: 6,
+                        tokenYDecimals: 8,
+                    },
+                    quote: 100,
+                    params: {},
+                    quoteData: { contract: 'test', function: 'test', parameters: {} },
+                    swapData: { contract: 'test', function: 'test', parameters: {} },
+                    dexPath: ['xyk'],
+                    tokenPath: ['token-x', 'token-y'],
+                    tokenXDecimals: 6,
+                    tokenYDecimals: 8,
+                },
+            ],
+            inputData: { tokenX: 'token-x', tokenY: 'token-y', amountInput: 100 },
+        });
+        await expect(sdk.getKeeperAggregatorRouteData('token-x', 'token-y', 100)).rejects.toThrow('No best route found for keeper-compatible DEX paths');
+    });
+    it('should handle error in getKeeperAggregatorRouteData', async () => {
+        // Mock getKeeperQuoteForRouteWithoutScaling to throw an error
+        jest.spyOn(sdk, 'getKeeperQuoteForRouteWithoutScaling').mockRejectedValue(new Error('API Error'));
+        await expect(sdk.getKeeperAggregatorRouteData('token-x', 'token-y', 100)).rejects.toThrow('API Error');
+    });
+});
+//# sourceMappingURL=BitflowSDK.test.js.map