@0xsquid/react-hooks 6.7.0-rollup-beta.1 → 6.7.0

package/dist/tests/configService.test.js

@@ -0,0 +1,673 @@
+import { nativeEvmTokenAddress } from "../core/constants";
+import { filterTokensForDestination, getFirstAvailableChainId, getInitialChainIdFromConfig, getInitialOrDefaultTokenAddressForChain, getInitialTokenAddressForChain, getUnavailableChainIdsForDirection, } from "../services/internal/configService";
+import { fetchSquidData } from "./fetchSquidData";
+let squid = undefined;
+let CHAINS = {};
+let TOKENS = {};
+describe("config service", () => {
+    beforeAll(async () => {
+        squid = await fetchSquidData();
+        CHAINS = squid?.chains;
+        TOKENS = squid?.tokens;
+    });
+    describe("getFirstAvailableChainId", () => {
+        test("returns chain id of first chain when no initialAssets are specified", () => {
+            expect(getFirstAvailableChainId({}, "from", [
+                CHAINS.ETHEREUM,
+                CHAINS.ARBITRUM,
+                CHAINS.POLYGON,
+            ])).toBe(CHAINS.ETHEREUM.chainId);
+            expect(getFirstAvailableChainId({
+                initialAssets: {},
+            }, "from", [CHAINS.ETHEREUM, CHAINS.ARBITRUM, CHAINS.POLYGON])).toBe(CHAINS.ETHEREUM.chainId);
+        });
+        test("returns undefined when no chains are provided", () => {
+            expect(getFirstAvailableChainId({}, "from", [])).toBe(undefined);
+            expect(getFirstAvailableChainId({}, "from", undefined)).toBe(undefined);
+        });
+        test("returns undefined if all chain ids are also disabled chains", () => {
+            const allChains = Object.values(CHAINS);
+            const disabledSourceChains = allChains.map((chain) => chain.chainId);
+            expect(getFirstAvailableChainId({
+                disabledChains: {
+                    source: disabledSourceChains,
+                },
+            }, "from", allChains)).toBe(undefined);
+        });
+        test("returns chain id of initialAssets when its ids are present in chains provided", () => {
+            expect(getFirstAvailableChainId({
+                initialAssets: {
+                    from: {
+                        address: nativeEvmTokenAddress,
+                        chainId: CHAINS.POLYGON.chainId,
+                    },
+                },
+            }, "from", [CHAINS.OPTIMISM, CHAINS.BINANCE, CHAINS.POLYGON, CHAINS.ETHEREUM])).toBe(CHAINS.POLYGON.chainId);
+            expect(getFirstAvailableChainId({
+                initialAssets: {
+                    to: {
+                        address: nativeEvmTokenAddress,
+                        chainId: CHAINS.AVALANCHE.chainId,
+                    },
+                },
+            }, "to", [CHAINS.MANTLE, CHAINS.BASE, CHAINS.AVALANCHE, CHAINS.MOONBEAM])).toBe(CHAINS.AVALANCHE.chainId);
+        });
+        test("returns chain id of first chain when initialAssets chain ids are not present in chains provided", () => {
+            expect(getFirstAvailableChainId({
+                initialAssets: {
+                    from: {
+                        address: nativeEvmTokenAddress,
+                        chainId: CHAINS.ARBITRUM.chainId,
+                    },
+                },
+            }, "from", [CHAINS.BINANCE, CHAINS.ETHEREUM, CHAINS.POLYGON])).toBe(CHAINS.BINANCE.chainId);
+            expect(getFirstAvailableChainId({
+                initialAssets: {
+                    to: {
+                        address: nativeEvmTokenAddress,
+                        chainId: CHAINS.MOONBEAM.chainId,
+                    },
+                },
+            }, "to", [CHAINS.ARBITRUM, CHAINS.AVALANCHE, CHAINS.LINEA])).toBe(CHAINS.ARBITRUM.chainId);
+        });
+        test("returns chain id of second chain when initial asset chain is a disabled chain", () => {
+            expect(getFirstAvailableChainId({
+                initialAssets: {
+                    from: {
+                        address: nativeEvmTokenAddress,
+                        chainId: CHAINS.ARBITRUM.chainId,
+                    },
+                },
+                disabledChains: {
+                    source: [CHAINS.ARBITRUM.chainId],
+                },
+            }, "from", [CHAINS.ARBITRUM, CHAINS.FANTOM, CHAINS.MANTLE])).toBe(CHAINS.FANTOM.chainId);
+            expect(getFirstAvailableChainId({
+                initialAssets: {
+                    to: {
+                        address: nativeEvmTokenAddress,
+                        chainId: CHAINS.POLYGON.chainId,
+                    },
+                },
+                disabledChains: {
+                    destination: [CHAINS.POLYGON.chainId],
+                },
+            }, "to", [CHAINS.POLYGON, CHAINS.BASE, CHAINS.AVALANCHE])).toBe(CHAINS.BASE.chainId);
+        });
+        test("returns chain id of second chain when first chain is disabled", () => {
+            expect(getFirstAvailableChainId({
+                disabledChains: {
+                    source: [CHAINS.ARBITRUM.chainId],
+                },
+            }, "from", [CHAINS.ARBITRUM, CHAINS.FANTOM, CHAINS.MANTLE])).toBe(CHAINS.FANTOM.chainId);
+            expect(getFirstAvailableChainId({
+                disabledChains: {
+                    destination: [CHAINS.NOBLE.chainId],
+                },
+            }, "to", [CHAINS.NOBLE, CHAINS.AVALANCHE, CHAINS.SCROLL])).toBe(CHAINS.AVALANCHE.chainId);
+        });
+        test("returns chain id of second chain when initial asset chain is disabled", () => {
+            expect(getFirstAvailableChainId({
+                disabledChains: {
+                    source: [CHAINS.OPTIMISM.chainId],
+                },
+                initialAssets: {
+                    from: {
+                        address: nativeEvmTokenAddress,
+                        chainId: CHAINS.OPTIMISM.chainId,
+                    },
+                },
+            }, "from", [CHAINS.OPTIMISM, CHAINS.MOONBEAM, CHAINS.NOBLE])).toBe(CHAINS.MOONBEAM.chainId);
+            expect(getFirstAvailableChainId({
+                disabledChains: {
+                    destination: [CHAINS.LINEA.chainId],
+                },
+            }, "to", [CHAINS.LINEA, CHAINS.BASE, CHAINS.MANTLE])).toBe(CHAINS.BASE.chainId);
+        });
+    });
+    describe("getUnavailableChainIdsForDirection", () => {
+        test("returns all chains when no config is provided", () => {
+            expect(getUnavailableChainIdsForDirection({
+                config: {},
+                direction: "from",
+            })).toStrictEqual(new Set());
+            expect(getUnavailableChainIdsForDirection({
+                config: {},
+                direction: "to",
+            })).toStrictEqual(new Set());
+        });
+        test("filters by disabledChains", () => {
+            expect(getUnavailableChainIdsForDirection({
+                config: {
+                    disabledChains: {
+                        source: [CHAINS.ETHEREUM.chainId],
+                        destination: [CHAINS.POLYGON.chainId],
+                    },
+                },
+                direction: "from",
+            })).toStrictEqual(new Set([CHAINS.ETHEREUM.chainId]));
+            expect(getUnavailableChainIdsForDirection({
+                config: {
+                    disabledChains: {
+                        source: [CHAINS.POLYGON.chainId],
+                        destination: [CHAINS.AVALANCHE.chainId, CHAINS.MOONBEAM.chainId],
+                    },
+                },
+                direction: "to",
+            })).toStrictEqual(new Set([CHAINS.AVALANCHE.chainId, CHAINS.MOONBEAM.chainId]));
+        });
+    });
+    describe("getInitialOrDefaultTokenAddressForChain", () => {
+        test("returns first token address if no special config is specified", () => {
+            expect(getInitialOrDefaultTokenAddressForChain({
+                tokens: [
+                    TOKENS.ETHEREUM.USDT,
+                    TOKENS.ETHEREUM.ETH,
+                    TOKENS.ETHEREUM.WETH,
+                ],
+                config: {},
+                chainId: CHAINS.ETHEREUM.chainId,
+                direction: "from",
+            })).toBe(TOKENS.ETHEREUM.USDT.address);
+            expect(getInitialOrDefaultTokenAddressForChain({
+                tokens: [
+                    TOKENS.ETHEREUM.WBTC,
+                    TOKENS.ETHEREUM.USDC,
+                    TOKENS.ETHEREUM.ETH,
+                ],
+                config: {
+                    defaultTokensPerChain: [],
+                },
+                chainId: CHAINS.ETHEREUM.chainId,
+                direction: "from",
+            })).toBe(TOKENS.ETHEREUM.WBTC.address);
+        });
+        test("returns undefined if no tokens are found for specified chain id", () => {
+            expect(getInitialOrDefaultTokenAddressForChain({
+                tokens: [
+                    TOKENS.BASE.USDbC,
+                    TOKENS.BASE["USDC.axl"],
+                    TOKENS.BASE.WETH,
+                ],
+                config: {},
+                chainId: CHAINS.ETHEREUM.chainId,
+                direction: "from",
+            })).toBe(undefined);
+        });
+        test("filters by defaultTokensPerChain config", () => {
+            expect(getInitialOrDefaultTokenAddressForChain({
+                tokens: [TOKENS.BASE.USDC, TOKENS.BASE.WETH, TOKENS.ETHEREUM.USDT],
+                config: {
+                    defaultTokensPerChain: [
+                        {
+                            address: TOKENS.ETHEREUM.USDT.address,
+                            chainId: TOKENS.ETHEREUM.USDT.chainId,
+                        },
+                    ],
+                },
+                chainId: CHAINS.ETHEREUM.chainId,
+                direction: "from",
+            })).toBe(TOKENS.ETHEREUM.USDT.address);
+            expect(getInitialOrDefaultTokenAddressForChain({
+                tokens: [
+                    TOKENS.ETHEREUM.WBTC,
+                    TOKENS.BASE["USDC.axl"],
+                    TOKENS.BASE.ETH,
+                ],
+                config: {
+                    defaultTokensPerChain: [
+                        {
+                            address: TOKENS.BASE["USDC.axl"].address,
+                            chainId: TOKENS.BASE["USDC.axl"].chainId,
+                        },
+                    ],
+                },
+                chainId: CHAINS.BASE.chainId,
+                direction: "from",
+            })).toBe(TOKENS.BASE["USDC.axl"].address);
+        });
+        test("filters by unavailableTokenAddress", () => {
+            expect(getInitialOrDefaultTokenAddressForChain({
+                tokens: [
+                    TOKENS.ETHEREUM.WBTC,
+                    TOKENS.BASE["USDC.axl"],
+                    TOKENS.BASE.USDbC,
+                ],
+                config: {},
+                chainId: CHAINS.BASE.chainId,
+                direction: "from",
+                excludeToken: {
+                    address: TOKENS.BASE["USDC.axl"].address,
+                    chainId: CHAINS.BASE.chainId,
+                },
+            })).toBe(TOKENS.BASE.USDbC.address);
+        });
+        test("filters by initialAssets", () => {
+            expect(getInitialOrDefaultTokenAddressForChain({
+                tokens: [
+                    TOKENS.BASE.USDC,
+                    TOKENS.ETHEREUM.WETH,
+                    TOKENS.ETHEREUM.USDT,
+                    TOKENS.ETHEREUM.USDC,
+                ],
+                config: {
+                    initialAssets: {
+                        from: TOKENS.ETHEREUM.USDT,
+                    },
+                },
+                chainId: CHAINS.ETHEREUM.chainId,
+                direction: "from",
+            })).toBe(TOKENS.ETHEREUM.USDT.address);
+        });
+        test("returns correct initial asset for dest even if source is set", () => {
+            expect(getInitialOrDefaultTokenAddressForChain({
+                direction: "to",
+                chainId: CHAINS.BASE.chainId,
+                tokens: [
+                    TOKENS.BASE.ETH,
+                    TOKENS.BASE.USDC,
+                    TOKENS.ETHEREUM.WETH,
+                    TOKENS.ETHEREUM.ETH,
+                    TOKENS.ETHEREUM.USDT,
+                    TOKENS.ETHEREUM.USDC,
+                ],
+                config: {
+                    initialAssets: {
+                        from: {
+                            address: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+                            chainId: "1",
+                        },
+                        to: {
+                            address: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+                            chainId: "8453",
+                        },
+                    },
+                },
+            })).toBe(TOKENS.BASE.ETH.address);
+        });
+        test("returns correct initial asset for source even if dest is set", () => {
+            expect(getInitialOrDefaultTokenAddressForChain({
+                direction: "from",
+                chainId: CHAINS.ETHEREUM.chainId,
+                tokens: [
+                    TOKENS.BASE.ETH,
+                    TOKENS.BASE.USDC,
+                    TOKENS.ETHEREUM.WETH,
+                    TOKENS.ETHEREUM.ETH,
+                    TOKENS.ETHEREUM.USDT,
+                    TOKENS.ETHEREUM.USDC,
+                ],
+                config: {
+                    initialAssets: {
+                        from: TOKENS.ETHEREUM.ETH,
+                        to: TOKENS.BASE.ETH,
+                    },
+                },
+            })).toBe(TOKENS.ETHEREUM.ETH.address);
+        });
+        test("prioritizes defaultTokens over initialAssets when both are provided", () => {
+            expect(getInitialOrDefaultTokenAddressForChain({
+                tokens: [
+                    TOKENS.BASE.USDC,
+                    TOKENS.ETHEREUM.WETH,
+                    TOKENS.ETHEREUM.USDT,
+                    TOKENS.ETHEREUM.USDC,
+                ],
+                config: {
+                    initialAssets: {
+                        from: TOKENS.ETHEREUM.USDT,
+                    },
+                    defaultTokensPerChain: [
+                        {
+                            address: TOKENS.ETHEREUM.WETH.address,
+                            chainId: TOKENS.ETHEREUM.WETH.chainId,
+                        },
+                    ],
+                },
+                chainId: CHAINS.ETHEREUM.chainId,
+                direction: "from",
+            })).toBe(TOKENS.ETHEREUM.WETH.address);
+        });
+        test("filters when unavailableTokenAddress and default token are the same", () => {
+            expect(getInitialOrDefaultTokenAddressForChain({
+                tokens: [
+                    TOKENS.BASE.WETH,
+                    TOKENS.ETHEREUM.ETH,
+                    TOKENS.BASE.USDC,
+                    TOKENS.ETHEREUM.USDT,
+                ],
+                config: {
+                    defaultTokensPerChain: [
+                        {
+                            address: TOKENS.ETHEREUM.ETH.address,
+                            chainId: TOKENS.ETHEREUM.ETH.chainId,
+                        },
+                    ],
+                },
+                chainId: CHAINS.ETHEREUM.chainId,
+                direction: "from",
+                excludeToken: {
+                    address: TOKENS.ETHEREUM.ETH.address,
+                    chainId: CHAINS.ETHEREUM.chainId,
+                },
+            })).toBe(TOKENS.ETHEREUM.USDT.address);
+        });
+        test("returns undefined when chain is disabled", () => {
+            expect(getInitialOrDefaultTokenAddressForChain({
+                tokens: [
+                    TOKENS.BASE["USDC.axl"],
+                    TOKENS.ETHEREUM.WBTC,
+                    TOKENS.BASE.USDbC,
+                    TOKENS.ETHEREUM.USDC,
+                ],
+                config: {
+                    disabledChains: {
+                        source: [CHAINS.ETHEREUM.chainId],
+                    },
+                },
+                chainId: CHAINS.ETHEREUM.chainId,
+                direction: "from",
+                excludeToken: undefined,
+            })).toBe(undefined);
+            expect(getInitialOrDefaultTokenAddressForChain({
+                tokens: [
+                    TOKENS.ETHEREUM.USDC,
+                    TOKENS.AVALANCHE.USDC,
+                    TOKENS.ETHEREUM.WETH,
+                    TOKENS.AVALANCHE.AVAX,
+                ],
+                config: {
+                    disabledChains: { destination: [CHAINS.AVALANCHE.chainId] },
+                },
+                chainId: CHAINS.AVALANCHE.chainId,
+                direction: "to",
+            })).toBe(undefined);
+        });
+        test("ignores case when comparing token address", () => {
+            expect(getInitialOrDefaultTokenAddressForChain({
+                tokens: [TOKENS.SOLANA.SOL, TOKENS.SOLANA.USDC, TOKENS.SOLANA.USDT],
+                config: {
+                    initialAssets: {
+                        from: {
+                            chainId: "42161",
+                            address: "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+                        },
+                        to: {
+                            chainId: "solana-mainnet-beta",
+                            address: "epjfwdd5aufqssqem2qn1xzybapc8g4weggkzwytdt1v",
+                        },
+                    },
+                },
+                chainId: "solana-mainnet-beta",
+                direction: "to",
+                excludeToken: {
+                    address: "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+                    chainId: "42161",
+                },
+            })).toBe("epjfwdd5aufqssqem2qn1xzybapc8g4weggkzwytdt1v");
+        });
+    });
+    describe("filterTokensForDestination", () => {
+        test("returns different tokens than source token when from and to chains are the same", () => {
+            expect(filterTokensForDestination({
+                tokens: [
+                    TOKENS.ETHEREUM.ETH,
+                    TOKENS.ETHEREUM.USDC,
+                    TOKENS.ETHEREUM.WETH,
+                ],
+                selectedDestinationChain: CHAINS.ETHEREUM,
+                selectedSourceToken: TOKENS.ETHEREUM.ETH,
+                removeSourceToken: true,
+            })).toStrictEqual([TOKENS.ETHEREUM.USDC, TOKENS.ETHEREUM.WETH]);
+            expect(filterTokensForDestination({
+                tokens: [
+                    TOKENS.BASE.USDbC,
+                    TOKENS.BASE.WETH,
+                    TOKENS.BASE["USDC.axl"],
+                ],
+                selectedDestinationChain: CHAINS.BASE,
+                selectedSourceToken: TOKENS.BASE["USDC.axl"],
+                removeSourceToken: true,
+            })).toStrictEqual([TOKENS.BASE.USDbC, TOKENS.BASE.WETH]);
+        });
+        test("returns only tokens of same chain as destination chain", () => {
+            expect(filterTokensForDestination({
+                tokens: [
+                    TOKENS.ETHEREUM.USDC,
+                    TOKENS.BASE.USDbC,
+                    TOKENS.ETHEREUM.WETH,
+                    TOKENS.BASE.ETH,
+                ],
+                selectedDestinationChain: CHAINS.ETHEREUM,
+                selectedSourceToken: TOKENS.BASE.USDC,
+                removeSourceToken: false,
+            })).toStrictEqual([TOKENS.ETHEREUM.USDC, TOKENS.ETHEREUM.WETH]);
+        });
+        test("returns all tokens if destination chain is not provided", () => {
+            expect(filterTokensForDestination({
+                tokens: [
+                    TOKENS.AVALANCHE.AVAX,
+                    TOKENS.ETHEREUM.WETH,
+                    TOKENS.CELO["USDC.axl"],
+                    TOKENS.BASE.ETH,
+                    TOKENS.ETHEREUM.USDC,
+                    TOKENS.BASE.USDbC,
+                ],
+                selectedDestinationChain: undefined,
+                selectedSourceToken: TOKENS.BASE.ETH,
+                removeSourceToken: true,
+            })).toStrictEqual([
+                TOKENS.AVALANCHE.AVAX,
+                TOKENS.ETHEREUM.WETH,
+                TOKENS.CELO["USDC.axl"],
+                TOKENS.ETHEREUM.USDC,
+                TOKENS.BASE.USDbC,
+            ]);
+        });
+        test("selecting a non-native Osmosis token on destination should be possible", () => {
+            expect(filterTokensForDestination({
+                tokens: [
+                    TOKENS.OSMOSIS.USDC,
+                    TOKENS.OSMOSIS.ATOM,
+                    TOKENS.OSMOSIS.OSMO,
+                ],
+                selectedDestinationChain: CHAINS.OSMOSIS,
+                selectedSourceToken: TOKENS.OSMOSIS.ATOM,
+                removeSourceToken: true,
+            })).toStrictEqual([TOKENS.OSMOSIS.USDC, TOKENS.OSMOSIS.OSMO]);
+        });
+    });
+    describe("getInitialTokenAddressForChain", () => {
+        test("returns initial assets when chain id matches", () => {
+            const fromInitialAsset = TOKENS.ETHEREUM.WETH;
+            expect(getInitialTokenAddressForChain({
+                chainId: CHAINS.ETHEREUM.chainId,
+                config: {
+                    initialAssets: {
+                        from: fromInitialAsset,
+                    },
+                },
+                direction: "from",
+                tokens: [TOKENS.ETHEREUM.USDT, fromInitialAsset],
+            })).toBe(fromInitialAsset.address);
+            const toInitialAsset = TOKENS.AVALANCHE.MAI;
+            expect(getInitialTokenAddressForChain({
+                chainId: CHAINS.AVALANCHE.chainId,
+                config: {
+                    initialAssets: {
+                        to: toInitialAsset,
+                    },
+                },
+                direction: "to",
+                tokens: [TOKENS.AVALANCHE["USDC.axl"], toInitialAsset],
+            })).toBe(toInitialAsset.address);
+        });
+        test("returns undefined when initial asset does not match chain id", () => {
+            expect(getInitialTokenAddressForChain({
+                chainId: CHAINS.ETHEREUM.chainId,
+                config: {
+                    initialAssets: {
+                        from: TOKENS.BASE.USDbC, // initial asset is a Base token, but we want to get Ethereum tokens
+                    },
+                },
+                direction: "from",
+                tokens: [TOKENS.ETHEREUM.USDT, TOKENS.ETHEREUM.WETH, TOKENS.BASE.ETH],
+            })).toBe(undefined);
+            expect(getInitialTokenAddressForChain({
+                chainId: CHAINS.BASE.chainId,
+                config: {
+                    initialAssets: {
+                        to: TOKENS.AVALANCHE.AVAX, // initial asset is an Avalanche token, but we want to get Base tokens
+                    },
+                },
+                direction: "from",
+                tokens: [
+                    TOKENS.BASE.ETH,
+                    TOKENS.AVALANCHE.USDC,
+                    TOKENS.BASE["USDC.axl"],
+                ],
+            })).toBe(undefined);
+        });
+        test("returns undefined when chain is not available", () => {
+            expect(getInitialTokenAddressForChain({
+                tokens: [
+                    TOKENS.AVALANCHE.AVAX,
+                    TOKENS.ETHEREUM.WETH,
+                    TOKENS.CELO["USDC.axl"],
+                    TOKENS.BASE.ETH,
+                    TOKENS.ETHEREUM.USDC,
+                    TOKENS.BASE.USDbC,
+                ],
+                config: {},
+                chainId: CHAINS.BASE.chainId,
+                direction: "from",
+            })).toBe(undefined);
+        });
+        test("returns undefined when no initialAssets are provided", () => {
+            expect(getInitialTokenAddressForChain({
+                tokens: [
+                    TOKENS.AVALANCHE.AVAX,
+                    TOKENS.ETHEREUM.WETH,
+                    TOKENS.CELO["USDC.axl"],
+                    TOKENS.BASE.ETH,
+                    TOKENS.ETHEREUM.USDC,
+                    TOKENS.BASE.USDbC,
+                ],
+                config: {},
+                direction: "from",
+                chainId: CHAINS.BASE.chainId,
+            })).toBe(undefined);
+        });
+        test("returns undefined when initial asset doesn't exist in tokens array", () => {
+            expect(getInitialTokenAddressForChain({
+                tokens: [
+                    TOKENS.BASE.USDbC,
+                    TOKENS.ETHEREUM.WETH,
+                    TOKENS.BASE["USDC.axl"],
+                    TOKENS.ETHEREUM.USDC,
+                ],
+                config: {
+                    initialAssets: {
+                        from: TOKENS.ETHEREUM.USDT,
+                    },
+                },
+                direction: "from",
+                chainId: CHAINS.ETHEREUM.chainId,
+            })).toBe(undefined);
+        });
+        test("returns undefined when initial asset is unavailable token", () => {
+            expect(getInitialTokenAddressForChain({
+                tokens: [
+                    TOKENS.AVALANCHE.USDC,
+                    TOKENS.ETHEREUM.WETH,
+                    TOKENS.AVALANCHE.AVAX,
+                    TOKENS.ETHEREUM.USDC,
+                ],
+                chainId: CHAINS.AVALANCHE.chainId,
+                config: {
+                    initialAssets: {
+                        from: TOKENS.AVALANCHE.AVAX,
+                    },
+                },
+                direction: "from",
+                unavailableTokenAddress: TOKENS.AVALANCHE.AVAX.address,
+            })).toBe(undefined);
+        });
+    });
+    describe("getInitialChainIdFromConfig", () => {
+        test("returns undefined when no initialAssets are provided", () => {
+            expect(getInitialChainIdFromConfig({
+                config: {},
+                direction: "from",
+                chains: [CHAINS.ETHEREUM, CHAINS.ARBITRUM, CHAINS.POLYGON],
+            })).toBe(undefined);
+        });
+        test("returns the correct initial chain ID when initial assets are provided", () => {
+            expect(getInitialChainIdFromConfig({
+                config: {
+                    initialAssets: {
+                        from: TOKENS.ETHEREUM.USDT,
+                    },
+                },
+                chains: [CHAINS.ARBITRUM, CHAINS.ETHEREUM, CHAINS.POLYGON],
+                direction: "from",
+            })).toBe(CHAINS.ETHEREUM.chainId);
+            expect(getInitialChainIdFromConfig({
+                config: {
+                    initialAssets: {
+                        to: TOKENS.AVALANCHE.USDC,
+                    },
+                },
+                direction: "to",
+                chains: [CHAINS.MOONBEAM, CHAINS.ETHEREUM, CHAINS.AVALANCHE],
+            })).toBe(CHAINS.AVALANCHE.chainId);
+        });
+        test("returns undefined when no chains are provided", () => {
+            expect(getInitialChainIdFromConfig({
+                config: {
+                    initialAssets: {
+                        from: TOKENS.ETHEREUM.USDT,
+                    },
+                },
+                chains: [],
+                direction: "from",
+            })).toBe(undefined);
+            expect(getInitialChainIdFromConfig({
+                config: {
+                    initialAssets: {
+                        to: TOKENS.AVALANCHE.USDC,
+                    },
+                },
+                direction: "to",
+                chains: [],
+            })).toBe(undefined);
+        });
+        test("returns undefined when chains in initial assets are disabled", () => {
+            expect(getInitialChainIdFromConfig({
+                config: {
+                    initialAssets: {
+                        from: TOKENS.ETHEREUM.USDT,
+                    },
+                    disabledChains: {
+                        source: [CHAINS.ETHEREUM.chainId],
+                    },
+                },
+                chains: [CHAINS.ETHEREUM, CHAINS.POLYGON],
+                direction: "from",
+            })).toBe(undefined);
+            expect(getInitialChainIdFromConfig({
+                config: {
+                    initialAssets: {
+                        to: TOKENS.AVALANCHE.USDT,
+                    },
+                    disabledChains: {
+                        destination: [CHAINS.CELO.chainId, CHAINS.AVALANCHE.chainId],
+                    },
+                },
+                chains: [CHAINS.ETHEREUM, CHAINS.AVALANCHE],
+                direction: "to",
+            })).toBe(undefined);
+        });
+    });
+});
+//# sourceMappingURL=configService.test.js.map