@0xsquid/react-hooks 1.0.3 → 1.0.5

package/src/tests/configService.test.ts

@@ -1,486 +0,0 @@
-import { nativeEvmTokenAddress } from "@/core/constants";
-import {
-  filterTokensForDestination,
-  getDefaultTokenAddressForChain,
-  getFirstAvailableChainId,
-  getInitialOrDefaultTokenAddressForChain,
-} from "../services/internal/configService";
-import { OnlineSquidData, fetchSquidData } from "./fetchSquidData";
-
-let squid: OnlineSquidData | undefined = undefined;
-let CHAINS: OnlineSquidData["chains"] = {};
-let TOKENS: OnlineSquidData["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 or comingSoonChainIds are specified", () => {
-      expect(
-        getFirstAvailableChainId({ integratorId: "" }, "from", [
-          CHAINS.ETHEREUM,
-          CHAINS.ARBITRUM,
-          CHAINS.POLYGON,
-        ])
-      ).toBe(CHAINS.ETHEREUM.chainId);
-
-      expect(
-        getFirstAvailableChainId(
-          {
-            integratorId: "",
-            comingSoonChainIds: [],
-            initialAssets: {},
-          },
-          "from",
-          [CHAINS.ETHEREUM, CHAINS.ARBITRUM, CHAINS.POLYGON]
-        )
-      ).toBe(CHAINS.ETHEREUM.chainId);
-    });
-
-    test("returns undefined when no chains are provided", () => {
-      expect(getFirstAvailableChainId({ integratorId: "" }, "from", [])).toBe(
-        undefined
-      );
-
-      expect(
-        getFirstAvailableChainId({ integratorId: "" }, "from", undefined)
-      ).toBe(undefined);
-    });
-
-    test("filters by a single comingSoonChainId", () => {
-      expect(
-        getFirstAvailableChainId(
-          {
-            integratorId: "",
-            comingSoonChainIds: [CHAINS.CELO.chainId],
-          },
-          "from",
-          [CHAINS.CELO, CHAINS.BASE, CHAINS.AVALANCHE]
-        )
-      ).toBe(CHAINS.BASE.chainId);
-    });
-
-    test("filters by multiple comingSoonChainIds", () => {
-      expect(
-        getFirstAvailableChainId(
-          {
-            integratorId: "",
-            comingSoonChainIds: [
-              CHAINS.AVALANCHE.chainId,
-              CHAINS.POLYGON.chainId,
-            ],
-          },
-          "from",
-          [
-            CHAINS.POLYGON,
-            CHAINS.ARBITRUM,
-            CHAINS.AVALANCHE,
-            CHAINS.OPTIMISM,
-            CHAINS.ETHEREUM,
-          ]
-        )
-      ).toBe(CHAINS.ARBITRUM.chainId);
-    });
-
-    test("returns undefined if all chain ids are also comingSoonChainIds", () => {
-      const allChains = Object.values(CHAINS);
-      const comingSoonChainIds = allChains.map((chain) => chain.chainId);
-
-      expect(
-        getFirstAvailableChainId(
-          {
-            integratorId: "",
-            comingSoonChainIds,
-          },
-          "from",
-          allChains
-        )
-      ).toBe(undefined);
-    });
-
-    test("returns chain id of initialAssets when its ids are present in chains provided", () => {
-      expect(
-        getFirstAvailableChainId(
-          {
-            integratorId: "",
-            initialAssets: {
-              from: {
-                address: nativeEvmTokenAddress,
-                chainId: CHAINS.POLYGON.chainId,
-              },
-            },
-          },
-          "from",
-          [CHAINS.OPTIMISM, CHAINS.BINANCE, CHAINS.POLYGON, CHAINS.ETHEREUM]
-        )
-      ).toBe(CHAINS.POLYGON.chainId);
-
-      expect(
-        getFirstAvailableChainId(
-          {
-            integratorId: "",
-            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(
-          {
-            integratorId: "",
-            initialAssets: {
-              from: {
-                address: nativeEvmTokenAddress,
-                chainId: CHAINS.ARBITRUM.chainId,
-              },
-            },
-          },
-          "from",
-          [CHAINS.BINANCE, CHAINS.ETHEREUM, CHAINS.POLYGON]
-        )
-      ).toBe(CHAINS.BINANCE.chainId);
-
-      expect(
-        getFirstAvailableChainId(
-          {
-            integratorId: "",
-            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 coming soon chain", () => {
-      expect(
-        getFirstAvailableChainId(
-          {
-            integratorId: "",
-            comingSoonChainIds: [CHAINS.ARBITRUM.chainId],
-            initialAssets: {
-              from: {
-                address: nativeEvmTokenAddress,
-                chainId: CHAINS.ARBITRUM.chainId,
-              },
-            },
-          },
-          "from",
-          [CHAINS.ARBITRUM, CHAINS.FANTOM, CHAINS.MANTLE]
-        )
-      ).toBe(CHAINS.FANTOM.chainId);
-
-      expect(
-        getFirstAvailableChainId(
-          {
-            integratorId: "",
-            comingSoonChainIds: [CHAINS.POLYGON.chainId],
-            initialAssets: {
-              to: {
-                address: nativeEvmTokenAddress,
-                chainId: 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(
-          {
-            integratorId: "",
-            disabledChains: {
-              source: [CHAINS.ARBITRUM.chainId],
-            },
-          },
-          "from",
-          [CHAINS.ARBITRUM, CHAINS.FANTOM, CHAINS.MANTLE]
-        )
-      ).toBe(CHAINS.FANTOM.chainId);
-
-      expect(
-        getFirstAvailableChainId(
-          {
-            integratorId: "",
-            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(
-          {
-            integratorId: "",
-            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(
-          {
-            integratorId: "",
-            disabledChains: {
-              destination: [CHAINS.LINEA.chainId],
-            },
-            initialAssets: {
-              to: {
-                address: nativeEvmTokenAddress,
-                chainId: CHAINS.LINEA.chainId,
-              },
-            },
-          },
-          "to",
-          [CHAINS.LINEA, CHAINS.BASE, CHAINS.MANTLE]
-        )
-      ).toBe(CHAINS.BASE.chainId);
-    });
-  });
-
-  describe("getDefaultTokenAddressForChain", () => {
-    test("returns first token address if no special config is specified", () => {
-      expect(
-        getDefaultTokenAddressForChain(
-          [TOKENS.ETHEREUM.USDT, TOKENS.ETHEREUM.ETH, TOKENS.ETHEREUM.WETH],
-          {
-            integratorId: "",
-          },
-          CHAINS.ETHEREUM.chainId
-        )
-      ).toBe(TOKENS.ETHEREUM.USDT.address);
-
-      expect(
-        getDefaultTokenAddressForChain(
-          [TOKENS.ETHEREUM.WBTC, TOKENS.ETHEREUM.USDC, TOKENS.ETHEREUM.ETH],
-          {
-            defaultTokensPerChain: [],
-            integratorId: "",
-          },
-          CHAINS.ETHEREUM.chainId
-        )
-      ).toBe(TOKENS.ETHEREUM.WBTC.address);
-    });
-
-    test("returns undefined if no tokens are found for specified chain id", () => {
-      expect(
-        getDefaultTokenAddressForChain(
-          [TOKENS.BASE.USDbC, TOKENS.BASE.axlUSDC, TOKENS.BASE.WETH],
-          {
-            integratorId: "",
-          },
-          CHAINS.ETHEREUM.chainId
-        )
-      ).toBe(undefined);
-    });
-
-    test("filters by defaultTokensPerChain config", () => {
-      expect(
-        getDefaultTokenAddressForChain(
-          [TOKENS.BASE.USDC, TOKENS.BASE.WETH, TOKENS.ETHEREUM.USDT],
-          {
-            defaultTokensPerChain: [
-              {
-                address: TOKENS.ETHEREUM.USDT.address,
-                chainId: TOKENS.ETHEREUM.USDT.chainId,
-              },
-            ],
-            integratorId: "",
-          },
-          CHAINS.ETHEREUM.chainId
-        )
-      ).toBe(TOKENS.ETHEREUM.USDT.address);
-
-      expect(
-        getDefaultTokenAddressForChain(
-          [TOKENS.ETHEREUM.WBTC, TOKENS.BASE.axlUSDC, TOKENS.BASE.ETH],
-          {
-            defaultTokensPerChain: [
-              {
-                address: TOKENS.BASE.axlUSDC.address,
-                chainId: TOKENS.BASE.axlUSDC.chainId,
-              },
-            ],
-            integratorId: "",
-          },
-          CHAINS.BASE.chainId
-        )
-      ).toBe(TOKENS.BASE.axlUSDC.address);
-    });
-
-    test("filters by unavailableTokenAddress", () => {
-      expect(
-        getDefaultTokenAddressForChain(
-          [TOKENS.ETHEREUM.WBTC, TOKENS.BASE.axlUSDC, TOKENS.BASE.USDbC],
-          {
-            integratorId: "",
-          },
-          CHAINS.BASE.chainId,
-          TOKENS.BASE.axlUSDC.address // unavailableTokenAddress
-        )
-      ).toBe(TOKENS.BASE.USDbC.address);
-    });
-
-    test("filters when unavailableTokenAddress and default token are the same", () => {
-      expect(
-        getDefaultTokenAddressForChain(
-          [
-            TOKENS.BASE.WETH,
-            TOKENS.ETHEREUM.ETH,
-            TOKENS.BASE.USDC,
-            TOKENS.ETHEREUM.USDT,
-          ],
-          {
-            integratorId: "",
-            defaultTokensPerChain: [
-              {
-                address: TOKENS.ETHEREUM.ETH.address,
-                chainId: TOKENS.ETHEREUM.ETH.chainId,
-              },
-            ],
-          },
-          CHAINS.ETHEREUM.chainId,
-          TOKENS.ETHEREUM.ETH.address // unavailableTokenAddress
-        )
-      ).toBe(TOKENS.ETHEREUM.USDT.address);
-    });
-  });
-
-  describe("filterTokensForDestination", () => {
-    test("returns different tokens than source token when from and to chains are the same", () => {
-      expect(
-        filterTokensForDestination(
-          [TOKENS.ETHEREUM.ETH, TOKENS.ETHEREUM.USDC, TOKENS.ETHEREUM.WETH],
-          CHAINS.ETHEREUM, // destination chain
-          TOKENS.ETHEREUM.ETH // source token
-        )
-      ).toStrictEqual([TOKENS.ETHEREUM.USDC, TOKENS.ETHEREUM.WETH]);
-
-      expect(
-        filterTokensForDestination(
-          [TOKENS.BASE.USDbC, TOKENS.BASE.WETH, TOKENS.BASE.axlUSDC],
-          CHAINS.BASE, // destination chain
-          TOKENS.BASE.axlUSDC // source token
-        )
-      ).toStrictEqual([TOKENS.BASE.USDbC, TOKENS.BASE.WETH]);
-    });
-
-    test("returns only tokens of same chain as destination chain", () => {
-      expect(
-        filterTokensForDestination(
-          [
-            TOKENS.ETHEREUM.USDC,
-            TOKENS.BASE.USDbC,
-            TOKENS.ETHEREUM.WETH,
-            TOKENS.BASE.ETH,
-          ],
-          CHAINS.ETHEREUM, // destination chain
-          TOKENS.BASE.USDC // source token
-        )
-      ).toStrictEqual([TOKENS.ETHEREUM.USDC, TOKENS.ETHEREUM.WETH]);
-    });
-  });
-
-  // we only test initialAssets here, as the rest of the logic is tested in getDefaultTokenAddressForChain
-  describe("getInitialOrDefaultTokenAddressForChain", () => {
-    test("returns initial assets when chain id matches", () => {
-      const fromInitialAsset = TOKENS.ETHEREUM.WETH;
-
-      expect(
-        getInitialOrDefaultTokenAddressForChain({
-          chainId: CHAINS.ETHEREUM.chainId,
-          config: {
-            integratorId: "",
-            initialAssets: {
-              from: fromInitialAsset,
-            },
-          },
-          direction: "from",
-          tokens: [TOKENS.ETHEREUM.USDT, fromInitialAsset],
-        })
-      ).toBe(fromInitialAsset.address);
-
-      const toInitialAsset = TOKENS.AVALANCHE.MAI;
-
-      expect(
-        getInitialOrDefaultTokenAddressForChain({
-          chainId: CHAINS.AVALANCHE.chainId,
-          config: {
-            integratorId: "",
-            initialAssets: {
-              to: toInitialAsset,
-            },
-          },
-          direction: "to",
-          tokens: [TOKENS.AVALANCHE.axlUSDC, toInitialAsset],
-        })
-      ).toBe(toInitialAsset.address);
-    });
-
-    test("returns first token when initial asset does not match chain id", () => {
-      expect(
-        getInitialOrDefaultTokenAddressForChain({
-          chainId: CHAINS.ETHEREUM.chainId, // we want to get Ethereum tokens
-          config: {
-            integratorId: "",
-            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],
-        })
-      ).toBe(TOKENS.ETHEREUM.USDT.address);
-
-      expect(
-        getInitialOrDefaultTokenAddressForChain({
-          chainId: CHAINS.BASE.chainId, // we want to get Base tokens
-          config: {
-            integratorId: "",
-            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.BASE.axlUSDC],
-        })
-      ).toBe(TOKENS.BASE.ETH.address);
-    });
-  });
-});

package/src/tests/fetchSquidData.ts

@@ -1,43 +0,0 @@
-import { Squid } from "@0xsquid/sdk";
-import { ChainData, Token } from "@0xsquid/squid-types";
-
-const INTEGRATOR_ID = "squid-react-hooks";
-
-export interface OnlineSquidData {
-  tokens: Record<string, Record<string, Token>>;
-  chains: Record<string, ChainData>;
-}
-
-const remapSquidData = (squidData: Squid) => {
-  const tokens: Record<string, Record<string, Token>> = {};
-  const chains: Record<string, ChainData> = {};
-
-  squidData.chains.forEach((chain) => {
-    const chainName = chain.networkIdentifier.toUpperCase();
-
-    tokens[chainName] = squidData.tokens
-      .filter((token) => token.chainId === chain.chainId)
-      .reduce(
-        (acc, token) => {
-          const tokenSymbol = token.symbol;
-          acc[tokenSymbol] = token;
-          return acc;
-        },
-        {} as Record<string, Token>
-      );
-
-    chains[chainName] = chain;
-  });
-
-  return { tokens, chains };
-};
-
-export const fetchSquidData = async (): Promise<OnlineSquidData> => {
-  const squid = new Squid({
-    integratorId: INTEGRATOR_ID,
-    baseUrl: "https://v2.api.squidrouter.com",
-  });
-  await squid.init();
-
-  return remapSquidData(squid);
-};

package/src/tests/walletService.test.ts

@@ -1,178 +0,0 @@
-import {
-  isWalletAddressValid,
-  formatWalletAddress,
-} from "@/services/internal/walletService";
-import { OnlineSquidData, fetchSquidData } from "./fetchSquidData";
-
-let squid: OnlineSquidData | undefined = undefined;
-let CHAINS: OnlineSquidData["chains"] = {};
-
-describe("walletService", () => {
-  beforeAll(async () => {
-    squid = await fetchSquidData();
-    CHAINS = squid?.chains;
-  });
-  describe("isWalletAddressValid", () => {
-    test("returns true when address is a valid EVM address for an EVM chain", () => {
-      expect(
-        isWalletAddressValid(
-          CHAINS.BASE,
-          "0xA7D7079b0FEaD91F3e65f86E8915Cb59c1a4C664"
-        )
-      ).toBe(true);
-
-      expect(
-        isWalletAddressValid(
-          CHAINS.BINANCE,
-          "0x6f1c3f578ef3f0d2cf9b1ec712d9654f143ea4d1"
-        )
-      ).toBe(true);
-
-      expect(
-        isWalletAddressValid(
-          CHAINS.POLYGON,
-          "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d"
-        )
-      ).toBe(true);
-    });
-
-    test("returns false when address is not a valid EVM address for an EVM chain", () => {
-      expect(
-        isWalletAddressValid(
-          CHAINS.BASE,
-          "0xA7D7079b0FEaD91F3e65f86E8915Cb59c1a4C66" // missing last character
-        )
-      ).toBe(false);
-
-      expect(
-        isWalletAddressValid(
-          CHAINS.BINANCE,
-          "e43f1c3f578ef3f0d2cf9b1ec712d9654f143ea4d1" // missing 0x prefix
-        )
-      ).toBe(false);
-
-      expect(
-        isWalletAddressValid(
-          CHAINS.POLYGON,
-          "cosmos1w3jhx7w3jhx7w3jhx7w3jhx7w3jhx7w3jhx7w3j" // cosmos address
-        )
-      ).toBe(false);
-    });
-
-    test("returns true when address is a valid Cosmos address for a Cosmos chain", () => {
-      expect(
-        isWalletAddressValid(
-          CHAINS.NOBLE,
-          "noble1awrua7e2kj69d7vn5qt5tccrhavmj9xa6up0eq"
-        )
-      ).toBe(true);
-
-      expect(
-        isWalletAddressValid(
-          CHAINS.NOBLE,
-          "noble1qe8uuf5x69c526h4nzxwv4ltftr73v7qgk33qz"
-        )
-      ).toBe(true);
-
-      expect(
-        isWalletAddressValid(
-          CHAINS.NOBLE,
-          "noble1zttnm2cl60m5ffsrfeqtzkmtvepl4hwnsqg9fd"
-        )
-      ).toBe(true);
-    });
-
-    test("returns false when address is not a valid Cosmos address for a Cosmos chain", () => {
-      expect(
-        isWalletAddressValid(
-          CHAINS.NOBLE,
-          "noble1qe8uuf5x69c526h4nzxwv4ltftr73v7qgk33" // missing last character
-        )
-      ).toBe(false);
-
-      expect(
-        isWalletAddressValid(
-          CHAINS.NOBLE,
-          "1qe8uuf5x69c526h4nzxwv4ltftr73v7qgk33q" // missing chain prefix
-        )
-      ).toBe(false);
-
-      expect(
-        isWalletAddressValid(
-          CHAINS.NOBLE,
-          "0xA7D7079b0FEaD91F3e65f86E8915Cb59c1a4C664" // EVM address
-        )
-      ).toBe(false);
-    });
-  });
-
-  describe("formatWalletAddress", () => {
-    test("formats EVM addresses correctly", () => {
-      expect(
-        formatWalletAddress("0x6f1c3f578ef3f0d2cf9b1ec712d9654f143ea4d1", 5)
-      ).toBe("0x6f1...4d1");
-
-      expect(
-        formatWalletAddress("0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d", 8)
-      ).toBe("0xbc4ca0...36f13d");
-
-      expect(
-        formatWalletAddress("0xA7D7079b0FEaD91F3e65f86E8915Cb59c1a4C664", 3)
-      ).toBe("0xa...4");
-    });
-
-    test("formats Cosmos addresses correctly", () => {
-      expect(
-        formatWalletAddress("noble1awrua7e2kj69d7vn5qt5tccrhavmj9xa6up0eq", 5)
-      ).toBe("noble...0eq");
-
-      expect(
-        formatWalletAddress("noble1qe8uuf5x69c526h4nzxwv4ltftr73v7qgk33qz", 8)
-      ).toBe("noble1qe...gk33qz");
-
-      expect(
-        formatWalletAddress("noble1zttnm2cl60m5ffsrfeqtzkmtvepl4hwnsqg9fd", 3)
-      ).toBe("nob...d");
-    });
-
-    test("returns empty string when address is undefined or empty string", () => {
-      expect(formatWalletAddress(undefined)).toBe("");
-
-      expect(formatWalletAddress("")).toBe("");
-
-      expect(formatWalletAddress("", 0)).toBe("");
-
-      expect(formatWalletAddress(undefined, 0)).toBe("");
-    });
-
-    test("handles trim length smaller than or equal to 2", () => {
-      expect(formatWalletAddress("0x123", 1)).toBe("0...");
-
-      expect(formatWalletAddress("0x123", 2)).toBe("0x...");
-    });
-
-    test("for negative trim length, removes its absolute value and adds three dots at the end", () => {
-      expect(formatWalletAddress("0x123", -1)).toBe("0x12..."); // trims 1 characters and adds three dots
-
-      expect(
-        formatWalletAddress("0x6f1c3f578ef3f0d2cf9b1ec712d9654f143ea4d1", -5)
-      ).toBe(
-        "0x6f1c3f578ef3f0d2cf9b1ec712d9654f143..." // trims 5 characters and adds three dots
-      );
-
-      expect(
-        formatWalletAddress("noble1awrua7e2kj69d7vn5qt5tccrhavmj9xa6up0eq", -9)
-      ).toBe(
-        "noble1awrua7e2kj69d7vn5qt5tccrhavmj..." // trims 9 characters and adds three dots
-      );
-    });
-
-    test("returns full address when its length is smaller than trim length", () => {
-      const evmAddress = "0x6f1c3f578ef3f0d2cf9b1ec712d9654f143ea4d1";
-      expect(formatWalletAddress(evmAddress, 100)).toBe(evmAddress);
-
-      const cosmosAddress = "noble1awrua7e2kj69d7vn5qt5tccrhavmj9xa6up0eq";
-      expect(formatWalletAddress(cosmosAddress, 100)).toBe(cosmosAddress);
-    });
-  });
-});