@0xsquid/react-hooks 7.7.0 → 8.0.0-beta.0

package/dist/tests/configService.test.js

@@ -1,673 +0,0 @@
-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