@xswap-link/sdk 0.9.8 → 0.9.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xswap-link/sdk",
-  "version": "0.9.8",
+  "version": "0.9.10",
   "description": "JavaScript SDK for XSwap platform",
   "homepage": "https://github.com/xswap-link/xswap-sdk",
   "repository": {

package/src/components/Swap/SwapView/SwapPanel/TokenPanel/TokenPicker/index.tsx

@@ -236,37 +236,43 @@ export const TokenPicker = ({
     // Create groups based on chain and wallet connection status
     const groups = chain
       ? [
-          ...(!!address && ownedFilteredTokens.length
+          ...(!!address && ownedFilteredTokens.length && type === "source"
             ? [ownedFilteredTokens]
             : []),
           currentChainTokens,
           otherChainTokens,
         ]
       : [
-          ...(!!address && ownedFilteredTokens.length
+          ...(!!address && ownedFilteredTokens.length && type === "source"
             ? [ownedFilteredTokens]
             : []),
           [...currentChainTokens, ...otherChainTokens],
         ];
 
     return groups.flat();
-  }, [filteredTokens, otherFilteredTokens, chain, address, tokenPrices]);
+  }, [filteredTokens, otherFilteredTokens, chain, address, type, tokenPrices]);
 
   const ownedTokens = useMemo(
     () => allTokens.filter((token) => token.balance?.gt(0)),
     [allTokens],
   );
 
-  const tokenGroups = chain
-    ? [
-        ...(!!address && ownedTokens.length ? [ownedTokens] : []),
-        filteredTokens,
-        otherFilteredTokens,
-      ]
-    : [
-        ...(!!address && ownedTokens.length ? [ownedTokens] : []),
-        otherFilteredTokens,
-      ];
+  const tokenGroups = useMemo(() => {
+    return chain
+      ? [
+          ...(type === "source" && !!address && ownedTokens.length
+            ? [ownedTokens]
+            : []),
+          filteredTokens,
+          otherFilteredTokens,
+        ]
+      : [
+          ...(type === "source" && !!address && ownedTokens.length
+            ? [ownedTokens]
+            : []),
+          otherFilteredTokens,
+        ];
+  }, [chain, type, address, ownedTokens, filteredTokens, otherFilteredTokens]);
 
   return showImportWarning ? (
     <>
@@ -459,7 +465,7 @@ export const TokenPicker = ({
                                 if (!address) {
                                   return `${chain.displayName} network`;
                                 }
-                                return ownedTokens.length
+                                return ownedTokens.length && type === "source"
                                   ? "My tokens"
                                   : `${chain.displayName} network`;
                               }
@@ -483,7 +489,7 @@ export const TokenPicker = ({
                                 if (!address) {
                                   return "All networks";
                                 }
-                                return ownedTokens.length
+                                return ownedTokens.length && type === "source"
                                   ? "My tokens"
                                   : "All networks";
                               }

package/src/context/SwapProvider.tsx

@@ -533,11 +533,32 @@ export const SwapProvider = ({
       !srcToken ||
       !dstToken ||
       !srcValueWei ||
-      safeBigNumberFrom(srcValueWei).eq(0)
+      safeBigNumberFrom(srcValueWei).eq(0) ||
+      (bridgeUI && !bridgeTokensDictionary)
     ) {
       setRoute(undefined);
       return;
     }
+
+    // Validate the current path before requesting a route
+    const { source, target } = mapToValidPath({
+      source: { chain: srcChain, token: srcToken },
+      target: { chain: dstChain, token: dstToken },
+      type: bridgeUI ? "BRIDGE" : "SWAP",
+      supportedChains,
+      bridgeTokensDictionary: bridgeTokensDictionary || {},
+    });
+
+    // If any of the chains or tokens would be changed by validation, don't request a route
+    if (
+      source.chain?.chainId !== srcChain?.chainId ||
+      target.chain?.chainId !== dstChain?.chainId ||
+      source.token?.address !== srcToken?.address ||
+      target.token?.address !== dstToken?.address
+    ) {
+      return;
+    }
+
     try {
       setError("");
       setFetchingRoute(true);
@@ -570,16 +591,20 @@ export const SwapProvider = ({
       routeAbortController.current = null;
     } catch (error) {
       if (error !== DEFAULT_REQUEST_ABORT_MSG) {
+        routeAbortController.current = null;
         console.error(error);
         setError("Could not find route!");
         setRoute(undefined);
       }
     } finally {
-      setFetchingRoute(false);
+      if (!routeAbortController.current) {
+        setFetchingRoute(false);
+      }
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [
     address,
+    bridgeUI,
     dstChain,
     dstToken,
     getRoute,

package/src/utils/validation.ts

@@ -346,18 +346,32 @@ const mapToValidPathBridge = ({
   // Setting tokens
   // check if the source token is bridgeable anywhere
   if (newSourceToken && newSourceChain) {
-    const isBridgeable =
-      Object.keys(
-        bridgeTokensDictionary[newSourceChain.chainId]?.[
-          newSourceToken.address.toLowerCase()
-        ] || {},
-      ).length > 0;
+    // First validate if the token is supported in the source chain
+    newSourceToken = newSourceChain.tokens.find(
+      (token) => token.tokenId === newSourceToken?.tokenId && token.supported,
+    );
 
-    if (!isBridgeable) {
-      newSourceToken = undefined;
+    if (newSourceToken) {
+      const isBridgeable =
+        Object.keys(
+          bridgeTokensDictionary[newSourceChain.chainId]?.[
+            newSourceToken.address.toLowerCase()
+          ] || {},
+        ).length > 0;
+
+      if (!isBridgeable) {
+        newSourceToken = undefined;
+      }
     }
   }
 
+  // Validate if target token is supported in the target chain
+  if (newTargetToken && newTargetChain) {
+    newTargetToken = newTargetChain.tokens.find(
+      (token) => token.tokenId === newTargetToken?.tokenId && token.supported,
+    );
+  }
+
   if (!newSourceToken) {
     const defaultToken = getDefaultBridgeTokenForChain({
       chain: newSourceChain,

package/test/context/SwapProvider.test.tsx

@@ -759,6 +759,61 @@ describe("SwapProvider", () => {
         result.current.dstChain?.chainId,
       );
     });
+
+    it("should preserve token when changing destination chain if token exists on both chains", async () => {
+      // Set up initial state with Arbitrum as source chain
+      const arbitrumChain = supportedChains.find(
+        (chain) => chain.chainId === "42161", // Arbitrum One
+      );
+      if (!arbitrumChain) throw new Error("Arbitrum chain not found");
+
+      // Find WETH token on Base
+      const arbitrumWethToken = arbitrumChain.tokens.find(
+        (token) => token.tokenId === "WETH",
+      );
+      if (!arbitrumWethToken)
+        throw new Error("WETH token not found on arbitrum");
+
+      // Set Base as initial destination chain
+      const baseChain = supportedChains.find(
+        (chain) => chain.chainId === "8453", // Base
+      );
+      if (!baseChain) throw new Error("Base chain not found");
+
+      const { result } = renderHook(() => useSwapContext(), {
+        wrapper: getWrapper(
+          {
+            ...integrationConfig,
+            bridge: true,
+            srcChainId: arbitrumChain.chainId,
+            dstChainId: baseChain.chainId,
+            srcTokenAddr: arbitrumWethToken.address,
+          },
+          supportedChains,
+          wagmiConfig,
+        ),
+      });
+
+      await act(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+
+      // Find Ethereum chain
+      const ethereumChain = supportedChains.find(
+        (chain) => chain.chainId === "1", // Ethereum
+      );
+      if (!ethereumChain) throw new Error("Ethereum chain not found");
+
+      // Change destination chain to Ethereum
+      await act(async () => {
+        result.current.setDstChain(ethereumChain);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+
+      // Verify that WETH is still selected but with Ethereum's address
+      expect(result.current.dstToken?.tokenId).toBe("WETH");
+      expect(result.current.dstChain?.chainId).toBe("1");
+    });
   });
 
   describe("Swap mode validation", () => {