@bitflowlabs/core-sdk 2.5.1-beta.0 → 3.0.0

package/dist/test/BitflowSDK.test.js

@@ -39,7 +39,11 @@ const createMockRoute = (providerValue) => {
             // the provider field is null, undefined, or a real address.
             },
         },
-        swapData: { contract: 'SP...swap-contract', function: 'swap', parameters: {} },
+        swapData: {
+            contract: 'SP...swap-contract',
+            function: 'swap',
+            parameters: {},
+        },
         postConditions: {},
         tokenXDecimals: 6,
         tokenYDecimals: 6,
@@ -66,9 +70,14 @@ describe('BitflowSDK - Provider Logic in getQuoteForRoute', () => {
         // This is the key change: we now simulate a contract function that expects a 'provider'.
         mockedGetInterface.mockResolvedValue({
             contractInterface: {},
-            functionArgs: [{ name: 'provider', type: '{optional: principal}' }]
+            functionArgs: [{ name: 'provider', type: '{optional: principal}' }],
+        });
+        mockedCallReadOnly.mockResolvedValue({
+            convertedResult: 100,
+            rawResult: 1000,
+            tokenXDecimals: 6,
+            tokenYDecimals: 6,
         });
-        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
@@ -77,7 +86,9 @@ describe('BitflowSDK - Provider Logic in getQuoteForRoute', () => {
     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] });
+        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
@@ -88,7 +99,9 @@ describe('BitflowSDK - Provider Logic in getQuoteForRoute', () => {
     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] });
+        mockedFetchPossibleSwaps.mockResolvedValue({
+            'token-y': [mockRouteWithUndefinedProvider],
+        });
         // ACT
         await sdk.getQuoteForRoute('token-x', 'token-y', 100);
         // ASSERT
@@ -100,7 +113,9 @@ describe('BitflowSDK - Provider Logic in getQuoteForRoute', () => {
         // ARRANGE: Create a fake route that already has a valid provider address
         const routeSpecificProvider = 'SP3B15B6STM80A752A80W3P7J53KSAQ7J01PJ80B9';
         const mockRouteWithSpecificProvider = createMockRoute(routeSpecificProvider);
-        mockedFetchPossibleSwaps.mockResolvedValue({ 'token-y': [mockRouteWithSpecificProvider] });
+        mockedFetchPossibleSwaps.mockResolvedValue({
+            'token-y': [mockRouteWithSpecificProvider],
+        });
         // ACT
         await sdk.getQuoteForRoute('token-x', 'token-y', 100);
         // ASSERT
@@ -111,9 +126,14 @@ describe('BitflowSDK - Provider Logic in getQuoteForRoute', () => {
     });
     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' }] });
+        mockedGetInterface.mockResolvedValue({
+            contractInterface: {},
+            functionArgs: [{ name: 'amount', type: 'uint' }],
+        });
         const mockRouteWithoutProvider = createMockRoute(undefined); // Provider is missing
-        mockedFetchPossibleSwaps.mockResolvedValue({ 'token-y': [mockRouteWithoutProvider] });
+        mockedFetchPossibleSwaps.mockResolvedValue({
+            'token-y': [mockRouteWithoutProvider],
+        });
         // ACT
         await sdk.getQuoteForRoute('token-x', 'token-y', 100);
         // ASSERT
@@ -132,7 +152,9 @@ describe('BitflowSDK - Token and Swap Retrieval Methods', () => {
             { tokenId: 'token-x', isKeeperToken: false },
             { tokenId: 'token-keeper', isKeeperToken: true },
         ]);
-        mockedFetchPossibleSwaps.mockResolvedValue({ 'token-keeper': ['swap1', 'swap2'] });
+        mockedFetchPossibleSwaps.mockResolvedValue({
+            'token-keeper': ['swap1', 'swap2'],
+        });
         sdk = new BitflowSDK_1.BitflowSDK();
     });
     it('should return all available tokens', async () => {
@@ -145,9 +167,7 @@ describe('BitflowSDK - Token and Swap Retrieval Methods', () => {
     });
     it('should return only keeper tokens', async () => {
         const tokens = await sdk.getKeeperTokens();
-        expect(tokens).toEqual([
-            { tokenId: 'token-keeper', isKeeperToken: true }
-        ]);
+        expect(tokens).toEqual([{ tokenId: 'token-keeper', isKeeperToken: true }]);
     });
     it('should return possible swaps for a token', async () => {
         const swaps = await sdk.getPossibleSwaps('token-keeper');
@@ -165,7 +185,10 @@ describe('BitflowSDK - Token Y and Route Methods', () => {
             { tokenId: 'token-x', isKeeperToken: false },
             { tokenId: 'token-y', isKeeperToken: true },
         ]);
-        mockedFetchPossibleSwaps.mockResolvedValue({ 'token-y': [{ foo: 'bar' }], 'token-z': [{ baz: 'qux' }] });
+        mockedFetchPossibleSwaps.mockResolvedValue({
+            'token-y': [{ foo: 'bar' }],
+            'token-z': [{ baz: 'qux' }],
+        });
         sdk = new BitflowSDK_1.BitflowSDK();
         // Pre-populate swapOptions for keeper methods
         sdk.context.swapOptions = {
@@ -173,23 +196,34 @@ describe('BitflowSDK - Token Y and Route Methods', () => {
         };
     });
     it('should return all possible token Y for a given token X', async () => {
-        sdk.context.swapOptions['token-x'] = { 'token-y': [], 'token-z': [] };
+        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': [] });
+        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' }] };
+        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' }] });
+        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' }]);
     });
@@ -207,31 +241,64 @@ describe('BitflowSDK - Route Quote Methods', () => {
             { tokenId: 'token-x', isKeeperToken: false },
             { tokenId: 'token-y', isKeeperToken: true },
         ]);
-        mockedFetchPossibleSwaps.mockResolvedValue({ 'token-y': [{
+        mockedFetchPossibleSwaps.mockResolvedValue({
+            'token-y': [
+                {
                     quoteData: {
                         contract: 'SP...contract',
                         function: 'get-quote',
                         parameters: { amount: null },
                     },
-                    swapData: { contract: 'SP...swap-contract', function: 'swap', parameters: {} },
+                    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 });
+                },
+            ],
+        });
+        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': [{
+            'token-x': {
+                'token-y': [
+                    {
                         quoteData: {
                             contract: 'SP...contract',
                             function: 'get-quote',
                             parameters: { amount: null },
                         },
-                        swapData: { contract: 'SP...swap-contract', function: 'swap', parameters: {} },
+                        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 () => {
@@ -318,8 +385,13 @@ describe('BitflowSDK - Execution and Keeper Methods', () => {
         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 };
+        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();
@@ -332,14 +404,21 @@ describe('BitflowSDK - Execution and Keeper Methods', () => {
     });
     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 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 };
+        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 () => {
@@ -348,7 +427,11 @@ describe('BitflowSDK - Execution and Keeper Methods', () => {
     });
     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 };
+        const params = {
+            stacksAddress: 'SOMEADDR',
+            actionAmount: '1',
+            keeperType: types_1.KeeperType.SWAP_BTC_TO_STX,
+        };
         await expect(sdk.getQuote(params)).rejects.toThrow('fail');
     });
 });
@@ -486,10 +569,12 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
         mockedCallGetSwapParams.mockResolvedValue({
             swapData: { data: 'swap-data' },
             parameters: { params: 'params' },
-            postConditions: { conditions: 'conditions' }
+            postConditions: { conditions: 'conditions' },
         });
         // Mock the getKeeperQuoteForRouteWithoutScaling method
-        jest.spyOn(BitflowSDK_1.BitflowSDK.prototype, 'getKeeperQuoteForRouteWithoutScaling').mockResolvedValue({
+        jest
+            .spyOn(BitflowSDK_1.BitflowSDK.prototype, 'getKeeperQuoteForRouteWithoutScaling')
+            .mockResolvedValue({
             bestRoute: {
                 route: {
                     dex_path: ['BITFLOW_XY_2_xyk'],
@@ -529,7 +614,8 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 tokenXDecimals: 6,
                 tokenYDecimals: 6,
             },
-            allRoutes: [{
+            allRoutes: [
+                {
                     route: {
                         dex_path: ['BITFLOW_XY_2_xyk'],
                         token_path: ['token-x', 'token-y'],
@@ -567,7 +653,8 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                     tokenPath: ['token-x', 'token-y'],
                     tokenXDecimals: 6,
                     tokenYDecimals: 6,
-                }],
+                },
+            ],
             inputData: {
                 tokenX: 'token-x',
                 tokenY: 'token-y',
@@ -581,13 +668,17 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
             route: {
                 dex_path: ['BITFLOW_XY_2'],
                 postConditions: {},
-                quoteData: { contract: 'SP...contract', function: 'get-quote', parameters: { amount: null } },
+                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'
-                    }
+                        'pool-trait': 'SP1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.xyk-pool-v-1-2',
+                    },
                 },
                 token_path: ['token-x', 'token-y'],
                 tokenXDecimals: 6,
@@ -602,7 +693,7 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
         expect(result).toEqual({
             swapData: { data: 'swap-data' },
             parameters: { params: 'params' },
-            postConditions: { conditions: 'conditions' }
+            postConditions: { conditions: 'conditions' },
         });
         expect(mockedCallGetSwapParams).toHaveBeenCalled();
     });
@@ -611,13 +702,17 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
             route: {
                 dex_path: ['BITFLOW_XY_2'],
                 postConditions: {},
-                quoteData: { contract: 'SP...contract', function: 'get-quote', parameters: { amount: null } },
+                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'
-                    }
+                        'pool-trait': 'SP1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.xyk-pool-v-1-2',
+                    },
                 },
                 token_path: ['token-x', 'token-y'],
                 tokenXDecimals: 6,
@@ -632,12 +727,12 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
         expect(result).toEqual({
             swapData: { data: 'swap-data' },
             parameters: { params: 'params' },
-            postConditions: { conditions: 'conditions' }
+            postConditions: { conditions: 'conditions' },
         });
         expect(mockedCallGetSwapParams).toHaveBeenCalled();
     });
     it('should get keeper aggregator route data', async () => {
-        sdk["context"].availableTokens = [
+        sdk['context'].availableTokens = [
             {
                 base: 'base-x',
                 type: 'type-x',
@@ -646,7 +741,7 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 status: 'active',
                 symbol: 'TKX',
                 tokenId: 'token-x',
-                "token-id": 'token-x',
+                'token-id': 'token-x',
                 tokenContract: 'contract-x',
                 tokenDecimals: 6,
                 tokenName: 'Token X',
@@ -655,11 +750,11 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 bridge: 'FALSE',
                 layerOneAsset: null,
                 priceData: {
-                    "1h_change": null,
-                    "1yr_change": null,
-                    "24h_change": null,
-                    "30d_change": null,
-                    "7d_change": null,
+                    '1h_change': null,
+                    '1yr_change': null,
+                    '24h_change': null,
+                    '30d_change': null,
+                    '7d_change': null,
                     last_price: null,
                     last_updated: null,
                 },
@@ -672,7 +767,7 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 status: 'active',
                 symbol: 'TKY',
                 tokenId: 'token-y',
-                "token-id": 'token-y',
+                'token-id': 'token-y',
                 tokenContract: 'contract-y',
                 tokenDecimals: 8,
                 tokenName: 'Token Y',
@@ -681,11 +776,11 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 bridge: 'FALSE',
                 layerOneAsset: null,
                 priceData: {
-                    "1h_change": null,
-                    "1yr_change": null,
-                    "24h_change": null,
-                    "30d_change": null,
-                    "7d_change": null,
+                    '1h_change': null,
+                    '1yr_change': null,
+                    '24h_change': null,
+                    '30d_change': null,
+                    '7d_change': null,
                     last_price: null,
                     last_updated: null,
                 },
@@ -696,7 +791,7 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
         expect(result.actionTrait).toBeDefined();
     });
     it('should handle mixed XYK and stableswap route', async () => {
-        sdk["context"].availableTokens = [
+        sdk['context'].availableTokens = [
             {
                 base: 'base-x',
                 type: 'type-x',
@@ -705,7 +800,7 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 status: 'active',
                 symbol: 'TKX',
                 tokenId: 'token-x',
-                "token-id": 'token-x',
+                'token-id': 'token-x',
                 tokenContract: 'contract-x',
                 tokenDecimals: 6,
                 tokenName: 'Token X',
@@ -714,11 +809,11 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 bridge: 'FALSE',
                 layerOneAsset: null,
                 priceData: {
-                    "1h_change": null,
-                    "1yr_change": null,
-                    "24h_change": null,
-                    "30d_change": null,
-                    "7d_change": null,
+                    '1h_change': null,
+                    '1yr_change': null,
+                    '24h_change': null,
+                    '30d_change': null,
+                    '7d_change': null,
                     last_price: null,
                     last_updated: null,
                 },
@@ -731,7 +826,7 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 status: 'active',
                 symbol: 'TKY',
                 tokenId: 'token-y',
-                "token-id": 'token-y',
+                'token-id': 'token-y',
                 tokenContract: 'contract-y',
                 tokenDecimals: 8,
                 tokenName: 'Token Y',
@@ -740,18 +835,20 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 bridge: 'FALSE',
                 layerOneAsset: null,
                 priceData: {
-                    "1h_change": null,
-                    "1yr_change": null,
-                    "24h_change": null,
-                    "30d_change": null,
-                    "7d_change": null,
+                    '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({
+        jest
+            .spyOn(BitflowSDK_1.BitflowSDK.prototype, 'getKeeperQuoteForRouteWithoutScaling')
+            .mockResolvedValue({
             bestRoute: {
                 route: {
                     dex_path: ['BITFLOW_XY_2_xyk', 'BITFLOW_STABLE_XY_2_stable'],
@@ -793,7 +890,8 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 tokenXDecimals: 6,
                 tokenYDecimals: 6,
             },
-            allRoutes: [{
+            allRoutes: [
+                {
                     route: {
                         dex_path: ['BITFLOW_XY_2_xyk', 'BITFLOW_STABLE_XY_2_stable'],
                         token_path: ['token-x', 'token-y'],
@@ -833,7 +931,8 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                     tokenPath: ['token-x', 'token-y'],
                     tokenXDecimals: 6,
                     tokenYDecimals: 6,
-                }],
+                },
+            ],
             inputData: {
                 tokenX: 'token-x',
                 tokenY: 'token-y',
@@ -845,7 +944,7 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
         expect(result.stableswapPoolList).toBeDefined();
     });
     it('should handle swaps-reversed parameter', async () => {
-        sdk["context"].availableTokens = [
+        sdk['context'].availableTokens = [
             {
                 base: 'base-x',
                 type: 'type-x',
@@ -854,7 +953,7 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 status: 'active',
                 symbol: 'TKX',
                 tokenId: 'token-x',
-                "token-id": 'token-x',
+                'token-id': 'token-x',
                 tokenContract: 'contract-x',
                 tokenDecimals: 6,
                 tokenName: 'Token X',
@@ -863,11 +962,11 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 bridge: 'FALSE',
                 layerOneAsset: null,
                 priceData: {
-                    "1h_change": null,
-                    "1yr_change": null,
-                    "24h_change": null,
-                    "30d_change": null,
-                    "7d_change": null,
+                    '1h_change': null,
+                    '1yr_change': null,
+                    '24h_change': null,
+                    '30d_change': null,
+                    '7d_change': null,
                     last_price: null,
                     last_updated: null,
                 },
@@ -880,7 +979,7 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 status: 'active',
                 symbol: 'TKY',
                 tokenId: 'token-y',
-                "token-id": 'token-y',
+                'token-id': 'token-y',
                 tokenContract: 'contract-y',
                 tokenDecimals: 8,
                 tokenName: 'Token Y',
@@ -889,18 +988,20 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 bridge: 'FALSE',
                 layerOneAsset: null,
                 priceData: {
-                    "1h_change": null,
-                    "1yr_change": null,
-                    "24h_change": null,
-                    "30d_change": null,
-                    "7d_change": null,
+                    '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({
+        jest
+            .spyOn(BitflowSDK_1.BitflowSDK.prototype, 'getKeeperQuoteForRouteWithoutScaling')
+            .mockResolvedValue({
             bestRoute: {
                 route: {
                     dex_path: ['BITFLOW_XY_2_xyk'],
@@ -942,7 +1043,8 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 tokenXDecimals: 6,
                 tokenYDecimals: 6,
             },
-            allRoutes: [{
+            allRoutes: [
+                {
                     route: {
                         dex_path: ['BITFLOW_XY_2_xyk'],
                         token_path: ['token-x', 'token-y'],
@@ -982,7 +1084,8 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                     tokenPath: ['token-x', 'token-y'],
                     tokenXDecimals: 6,
                     tokenYDecimals: 6,
-                }],
+                },
+            ],
             inputData: {
                 tokenX: 'token-x',
                 tokenY: 'token-y',
@@ -996,7 +1099,7 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
     });
     it('should handle unsupported DEX path in mapDexPathToActionTrait', async () => {
         // Patch availableTokens so contract identifier lookup does not fail
-        sdk["context"].availableTokens = [
+        sdk['context'].availableTokens = [
             {
                 base: 'base-x',
                 type: 'type-x',
@@ -1005,7 +1108,7 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 status: 'active',
                 symbol: 'TKX',
                 tokenId: 'token-x',
-                "token-id": 'token-x',
+                'token-id': 'token-x',
                 tokenContract: 'contract-x',
                 tokenDecimals: 6,
                 tokenName: 'Token X',
@@ -1014,11 +1117,11 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 bridge: 'FALSE',
                 layerOneAsset: null,
                 priceData: {
-                    "1h_change": null,
-                    "1yr_change": null,
-                    "24h_change": null,
-                    "30d_change": null,
-                    "7d_change": null,
+                    '1h_change': null,
+                    '1yr_change': null,
+                    '24h_change': null,
+                    '30d_change': null,
+                    '7d_change': null,
                     last_price: null,
                     last_updated: null,
                 },
@@ -1031,7 +1134,7 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 status: 'active',
                 symbol: 'TKY',
                 tokenId: 'token-y',
-                "token-id": 'token-y',
+                'token-id': 'token-y',
                 tokenContract: 'contract-y',
                 tokenDecimals: 8,
                 tokenName: 'Token Y',
@@ -1040,11 +1143,11 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
                 bridge: 'FALSE',
                 layerOneAsset: null,
                 priceData: {
-                    "1h_change": null,
-                    "1yr_change": null,
-                    "24h_change": null,
-                    "30d_change": null,
-                    "7d_change": null,
+                    '1h_change': null,
+                    '1yr_change': null,
+                    '24h_change': null,
+                    '30d_change': null,
+                    '7d_change': null,
                     last_price: null,
                     last_updated: null,
                 },
@@ -1136,8 +1239,86 @@ describe('BitflowSDK - Swap Parameter and Preparation Methods', () => {
     });
     it('should handle error in getKeeperAggregatorRouteData', async () => {
         // Mock getKeeperQuoteForRouteWithoutScaling to throw an error
-        jest.spyOn(sdk, 'getKeeperQuoteForRouteWithoutScaling').mockRejectedValue(new Error('API Error'));
+        jest
+            .spyOn(sdk, 'getKeeperQuoteForRouteWithoutScaling')
+            .mockRejectedValue(new Error('API Error'));
         await expect(sdk.getKeeperAggregatorRouteData('token-x', 'token-y', 100)).rejects.toThrow('API Error');
     });
 });
+describe('BitflowSDK - Class Initialization', () => {
+    const mockedFetchAllTokens = fetchDataHelper.fetchAllTokensFromAPI;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockedFetchAllTokens.mockResolvedValue([
+            { tokenId: 'token-x', isKeeperToken: false },
+            { tokenId: 'token-y', isKeeperToken: true },
+        ]);
+    });
+    it('can be instantiated with no arguments', () => {
+        expect(() => new BitflowSDK_1.BitflowSDK()).not.toThrow();
+    });
+    it('can be instantiated with an empty config object', () => {
+        expect(() => new BitflowSDK_1.BitflowSDK({})).not.toThrow();
+    });
+    it('initializes context with empty collections', () => {
+        const sdk = new BitflowSDK_1.BitflowSDK();
+        const ctx = sdk.context;
+        expect(ctx.availableTokens).toEqual([]);
+        expect(ctx.contractInterfaces).toEqual({});
+        expect(ctx.functionArgs).toEqual({});
+        expect(ctx.swapOptions).toEqual({});
+    });
+    it('initializes context with STACKS_MAINNET network', () => {
+        const { STACKS_MAINNET } = require('@stacks/network');
+        const sdk = new BitflowSDK_1.BitflowSDK();
+        expect(sdk.context.network).toBe(STACKS_MAINNET);
+    });
+    it('calls fetchAllTokensFromAPI during initialization', async () => {
+        const sdk = new BitflowSDK_1.BitflowSDK();
+        await sdk.getAvailableTokens();
+        expect(mockedFetchAllTokens).toHaveBeenCalled();
+    });
+    it('merges a single config override into the shared configs object', () => {
+        const providerAddress = 'SP2J6S063B42M61D5T1G295SA4238A7147A4N17X';
+        new BitflowSDK_1.BitflowSDK({ BITFLOW_PROVIDER_ADDRESS: providerAddress });
+        expect(config_1.configs.BITFLOW_PROVIDER_ADDRESS).toBe(providerAddress);
+    });
+    it('merges multiple config overrides into the shared configs object', () => {
+        const customHost = 'https://custom-api.example.com';
+        const providerAddress = 'SP2J6S063B42M61D5T1G295SA4238A7147A4N17X';
+        new BitflowSDK_1.BitflowSDK({
+            BITFLOW_API_HOST: customHost,
+            BITFLOW_PROVIDER_ADDRESS: providerAddress,
+        });
+        expect(config_1.configs.BITFLOW_API_HOST).toBe(customHost);
+        expect(config_1.configs.BITFLOW_PROVIDER_ADDRESS).toBe(providerAddress);
+    });
+    it('does not apply config overrides when constructed with no arguments', () => {
+        const originalHost = config_1.configs.BITFLOW_API_HOST;
+        new BitflowSDK_1.BitflowSDK();
+        expect(config_1.configs.BITFLOW_API_HOST).toBe(originalHost);
+    });
+    it('does not re-fetch tokens when availableTokens is already populated', async () => {
+        const sdk = new BitflowSDK_1.BitflowSDK();
+        // Manually populate tokens to simulate a completed async init
+        sdk.context.availableTokens = [
+            { tokenId: 'cached', isKeeperToken: false },
+        ];
+        jest.clearAllMocks();
+        const tokens = await sdk.getAvailableTokens();
+        expect(tokens).toEqual([{ tokenId: 'cached', isKeeperToken: false }]);
+        expect(mockedFetchAllTokens).not.toHaveBeenCalled();
+    });
+    it('re-fetches tokens in getAvailableTokens when availableTokens is empty', async () => {
+        mockedFetchAllTokens.mockResolvedValue([
+            { tokenId: 'fetched-late', isKeeperToken: false },
+        ]);
+        const sdk = new BitflowSDK_1.BitflowSDK();
+        // Force context back to empty to simulate the async init not yet resolved
+        sdk.context.availableTokens = [];
+        const tokens = await sdk.getAvailableTokens();
+        expect(tokens).toEqual([{ tokenId: 'fetched-late', isKeeperToken: false }]);
+        expect(mockedFetchAllTokens).toHaveBeenCalled();
+    });
+});
 //# sourceMappingURL=BitflowSDK.test.js.map