@0xsquid/react-hooks 1.0.0

package/src/tests/assetsService.test.ts

@@ -0,0 +1,176 @@
+import {
+  shareSubgraphId,
+  sortTokensBySharedSubgraphIds,
+  filterChains,
+} from "@/services/internal/assetsService";
+import { OnlineSquidData, fetchSquidData } from "./fetchSquidData";
+
+let squid: OnlineSquidData | undefined = undefined;
+let CHAINS: OnlineSquidData["chains"] = {};
+let TOKENS: OnlineSquidData["tokens"] = {};
+
+describe("assetsService", () => {
+  beforeAll(async () => {
+    squid = await fetchSquidData();
+    CHAINS = squid?.chains;
+    TOKENS = squid?.tokens;
+  });
+
+  describe("shareSubgraphId", () => {
+    test("should return false when no token has subgraph ids", () => {
+      expect(shareSubgraphId(TOKENS.BASE.USDBC, TOKENS.AVALANCHE.MAI)).toBe(
+        false
+      );
+    });
+
+    test("should return true when tokens share subgraph ids", () => {
+      expect(shareSubgraphId(TOKENS.AVALANCHE.USDC, TOKENS.ETHEREUM.USDC)).toBe(
+        true
+      );
+    });
+
+    test("should return false when tokens do not share subgraph ids", () => {
+      expect(shareSubgraphId(TOKENS.AVALANCHE.AVAX, TOKENS.ETHEREUM.ETH)).toBe(
+        false
+      );
+    });
+  });
+
+  describe("sortTokensBySharedSubgraphIds", () => {
+    test("should sort 'a' token first when it shares subgraph ids with the token to check", () => {
+      expect(
+        sortTokensBySharedSubgraphIds({
+          a: TOKENS.AVALANCHE.USDC,
+          b: TOKENS.ETHEREUM.WBTC,
+          tokenToCheck: TOKENS.ETHEREUM.USDC,
+        })
+      ).toBe(-1);
+    });
+
+    test("should sort 'b' token first when it shares subgraph ids with the token to check", () => {
+      expect(
+        sortTokensBySharedSubgraphIds({
+          a: TOKENS.AVALANCHE.USDC,
+          b: TOKENS.ETHEREUM.ETH,
+          tokenToCheck: TOKENS.ETHEREUM.WETH,
+        })
+      ).toBe(1);
+    });
+
+    test("should not change order when tokens do not share subgraph ids with the token to check", () => {
+      expect(
+        sortTokensBySharedSubgraphIds({
+          a: TOKENS.AVALANCHE.AVAX,
+          b: TOKENS.ETHEREUM.ETH,
+          tokenToCheck: TOKENS.ETHEREUM.USDC,
+        })
+      ).toBe(0);
+    });
+
+    test("should not change the order when both tokens share subgraph ids with the token to check", () => {
+      expect(
+        sortTokensBySharedSubgraphIds({
+          a: TOKENS.ETHEREUM.USDC,
+          b: TOKENS.AVALANCHE.axlUSDC,
+          tokenToCheck: TOKENS.AVALANCHE.USDC,
+        })
+      ).toBe(0);
+    });
+  });
+
+  describe("filterChains", () => {
+    test("return chains without changes when no chain is disabled or coming soon", () => {
+      const chains = [CHAINS.AVALANCHE, CHAINS.ETHEREUM, CHAINS.NOBLE];
+
+      expect(
+        filterChains({
+          chains,
+          config: {
+            comingSoonChainIds: undefined,
+            disabledChains: undefined,
+          },
+          direction: "from",
+        })
+      ).toEqual(chains);
+    });
+
+    test("sorts disabled chains to the end", () => {
+      expect(
+        filterChains({
+          chains: [CHAINS.MOONBEAM, CHAINS.POLYGON, CHAINS.BINANCE],
+          config: {
+            comingSoonChainIds: undefined,
+            disabledChains: { source: [CHAINS.POLYGON.chainId] },
+          },
+          direction: "from",
+        })
+      ).toEqual([CHAINS.MOONBEAM, CHAINS.BINANCE, CHAINS.POLYGON]);
+
+      expect(
+        filterChains({
+          chains: [CHAINS.POLYGON, CHAINS.CELO, CHAINS.BINANCE],
+          config: {
+            comingSoonChainIds: undefined,
+            disabledChains: { destination: [CHAINS.CELO.chainId] },
+          },
+          direction: "to",
+        })
+      ).toEqual([CHAINS.POLYGON, CHAINS.BINANCE, CHAINS.CELO]);
+    });
+
+    test("sorts coming soon chains to the end", () => {
+      expect(
+        filterChains({
+          chains: [CHAINS.LINEA, CHAINS.FANTOM, CHAINS.CELO],
+          config: {
+            disabledChains: undefined,
+            comingSoonChainIds: [CHAINS.LINEA.chainId],
+          },
+          direction: "from",
+        })
+      ).toEqual([CHAINS.FANTOM, CHAINS.CELO, CHAINS.LINEA]);
+
+      expect(
+        filterChains({
+          chains: [CHAINS.NOBLE, CHAINS.OPTIMISM, CHAINS.MANTLE],
+          config: {
+            disabledChains: undefined,
+            comingSoonChainIds: [CHAINS.NOBLE.chainId],
+          },
+          direction: "to",
+        })
+      ).toEqual([CHAINS.OPTIMISM, CHAINS.MANTLE, CHAINS.NOBLE]);
+    });
+
+    test("sorts available chains first, then disabled chains, and finally coming soon chains", () => {
+      const chains = [
+        CHAINS.MOONBEAM,
+        CHAINS.POLYGON,
+        CHAINS.BINANCE,
+        CHAINS.LINEA,
+        CHAINS.FANTOM,
+        CHAINS.CELO,
+      ];
+
+      expect(
+        filterChains({
+          chains,
+          config: {
+            disabledChains: {
+              source: [CHAINS.MOONBEAM.chainId, CHAINS.LINEA.chainId],
+            },
+            comingSoonChainIds: [CHAINS.POLYGON.chainId],
+          },
+          direction: "from",
+        })
+      ).toEqual([
+        CHAINS.BINANCE,
+        CHAINS.FANTOM,
+        CHAINS.CELO,
+        CHAINS.MOONBEAM,
+        CHAINS.LINEA,
+        CHAINS.POLYGON,
+      ]);
+    });
+  });
+});

package/src/tests/configService.test.ts

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

@@ -0,0 +1,43 @@
+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);
+};