@xswap-link/sdk 0.9.6 → 0.9.8

package/src/models/TokenData.ts

@@ -19,6 +19,8 @@ export type Chain = {
   scanApiURL?: string;
   defaultDstChain?: string;
   disabledForDestination?: string[];
+  supportedDstForBridge?: string[];
+  supportedDstForSwap?: string[];
 };
 
 export type Token = {

package/src/models/index.ts

@@ -17,4 +17,3 @@ export * from "./TransactionHistory";
 export * from "./TxUIWrapper";
 export * from "./Web3Environment";
 export * from "./XSwapCallType";
-export * from "./XSwapConfig";

package/src/models/payloads/ModalIntegrationPayload.ts

@@ -29,6 +29,7 @@ export type ModalIntegrationThemeStyles = {
   warningLight?: string;
   errorDark?: string;
   errorLight?: string;
+  chainlinkLogo?: string;
 };
 
 export type ModalIntegrationStyles = Pick<
@@ -63,4 +64,7 @@ export type ModalIntegrationPayload = {
   onSrcChainChange?: (chain: string | undefined) => void;
   onConnectWallet?: () => void;
   bridge?: boolean;
+  override?: {
+    apiUrl?: string;
+  };
 };

package/src/models/payloads/WidgetIntegrationPayload.ts

@@ -27,4 +27,7 @@ export type WidgetIntegrationPayload = {
   onSrcChainChange?: (chain: string | undefined) => void;
   onConnectWallet?: () => void;
   bridge?: boolean;
+  override?: {
+    apiUrl?: string;
+  };
 };

package/src/services/api.ts

@@ -13,13 +13,18 @@ import {
   TransactionHistory,
   TransactionStatus,
 } from "@src/models";
-import xSwapConfig from "../../xswap.config";
+
+let XSWAP_API_URL = "https://xswap.link/api";
+
+export const setApiUrl = (url: string) => {
+  XSWAP_API_URL = url;
+};
 
 async function _sendRequest<T>(
   urlPath: string,
   options?: RequestInit,
 ): Promise<T> {
-  const response = await fetch(`${xSwapConfig.apiUrl}${urlPath}`, {
+  const response = await fetch(`${XSWAP_API_URL}${urlPath}`, {
     method: "GET",
     headers: {
       "Content-Type": "application/json",
@@ -59,8 +64,7 @@ export async function getRoute(
  * @param ecosystem optional
  */
 export async function getChains(ecosystem?: Ecosystem): Promise<Chain[]> {
-  return _sendRequest<Chain[]>(`/chains?data=${JSON.stringify({ ecosystem })}
-    `);
+  return _sendRequest<Chain[]>(`/chains?data=${JSON.stringify({ ecosystem })}`);
 }
 
 /**

package/src/utils/index.ts

@@ -3,7 +3,9 @@ export * from "./numbers";
 export * from "./parseWeb3Error";
 export * from "./strings";
 
+import { Chain } from "@src/models";
 import { format } from "date-fns";
+import { ethers } from "ethers";
 
 // eslint-disable-next-line
 export const replaceNull = (values: any[], newValue: any) => {
@@ -58,3 +60,31 @@ export const getDate = (blockTimestamp: number) => {
 };
 
 export const isServer = typeof window === "undefined";
+
+// Helper function to validate and resolve token addresses
+export const resolveTokenAddress = (
+  tokenAddressOrId: string | undefined,
+  chainId: string | undefined,
+  chains: Chain[],
+): string | undefined => {
+  if (!tokenAddressOrId || ethers.utils.isAddress(tokenAddressOrId)) {
+    return tokenAddressOrId;
+  }
+  // try to find the token by the tokenId
+  return chains
+    .find((chain) => chain.chainId === chainId)
+    ?.tokens.find((token) => token.tokenId === tokenAddressOrId)
+    ?.address?.toLowerCase();
+};
+
+export const sortChains = (chains: Chain[], disabledChainIds: string[]) =>
+  [...chains]
+
+    .map((chain) => ({
+      ...chain,
+      disabled: disabledChainIds.includes(chain.chainId),
+    }))
+    .sort((a, b) => {
+      if (a.disabled === b.disabled) return 0;
+      return a.disabled ? 1 : -1;
+    });

package/src/utils/validation.ts

@@ -121,7 +121,7 @@ const isSwapTargetChainValid = ({
 
   return (
     targetChain.swapSupported &&
-    !sourceChain.disabledForDestination?.includes(targetChain.chainId)
+    sourceChain.supportedDstForSwap?.includes(targetChain.chainId)
   );
 };
 
@@ -138,9 +138,16 @@ const isBridgeTargetValid = ({
   sourceToken: Token | undefined;
 }) => {
   // We set it to a valid state initially.
+  let isSupportedDstForBridge = true;
   let isSameToken = true;
   let isSameChain = false;
 
+  if (sourceChain && targetChain) {
+    isSupportedDstForBridge = !!sourceChain.supportedDstForBridge?.includes(
+      targetChain.chainId,
+    );
+  }
+
   if (sourceToken && targetChain) {
     // Bridge target chain is invalid when it doesn't have the same token available as selected in the source.
     isSameToken = !!targetChain.tokens.find(
@@ -154,7 +161,7 @@ const isBridgeTargetValid = ({
     isSameChain = sourceChain.chainId === targetChain.chainId;
   }
 
-  return isSameToken && !isSameChain;
+  return isSameToken && !isSameChain && isSupportedDstForBridge;
 };
 
 type MapToValidPathParams = {
@@ -255,6 +262,13 @@ const mapToValidPathSwap = ({
   }
 
   // Setting tokens
+  // validate if the token is supported in the new source chain
+  newSourceToken = newSourceChain.tokens.find(
+    (token) => token.tokenId === newSourceToken?.tokenId && token.supported,
+  );
+  newTargetToken = newTargetChain.tokens.find(
+    (token) => token.tokenId === newTargetToken?.tokenId && token.supported,
+  );
 
   if (!newSourceToken) {
     newSourceToken = getDefaultSwapTokenForChain(
@@ -262,6 +276,7 @@ const mapToValidPathSwap = ({
       DEFAULT_SOURCE_TOKEN_ADDR,
     );
   }
+
   if (!newTargetToken || newSourceToken === newTargetToken) {
     newTargetToken = getDefaultSwapTokenForChain(
       newTargetChain,
@@ -315,10 +330,8 @@ const mapToValidPathBridge = ({
       sourceToken: newSourceToken,
     })
   ) {
-    newTargetChain = undefined;
     // We can't have dangling token from a different chain.
     newTargetToken = undefined;
-
     if (
       !isBridgeTargetValid({
         sourceChain: newSourceChain,
@@ -326,22 +339,7 @@ const mapToValidPathBridge = ({
         sourceToken: newSourceToken,
       })
     ) {
-      // This should never occur if our app is configured properly.
-      console.error("[WRONG CONFIG] default bridge target chain is invalid.");
-
-      // Find any chain that is valid.
-      newTargetChain = supportedChains.find((chain) =>
-        isBridgeTargetValid({
-          sourceChain: newSourceChain,
-          targetChain: chain,
-          sourceToken: newSourceToken,
-        }),
-      );
-      if (!newTargetChain) {
-        throw new Error(
-          "mapToValidSwap > None of the chains supports bridge. Couldn't set target chain.",
-        );
-      }
+      newTargetChain = undefined;
     }
   }
 
@@ -365,7 +363,6 @@ const mapToValidPathBridge = ({
       chain: newSourceChain,
       bridgeTokensDictionary,
     });
-
     if (defaultToken && newSourceChain && newTargetChain) {
       const isDefaultTokenBridgeable =
         !!bridgeTokensDictionary[newSourceChain.chainId]?.[
@@ -375,9 +372,6 @@ const mapToValidPathBridge = ({
       if (isDefaultTokenBridgeable) {
         newSourceToken = defaultToken;
       } else {
-        // This should never occur if our app is configured properly.
-        console.error("[WRONG CONFIG] default bridge source token is invalid.");
-        // Default is invalid, so let's keep it unset.
         newSourceToken = undefined;
       }
     } else {
@@ -409,7 +403,7 @@ const mapToValidPathBridge = ({
     }
   }
 
-  if (!newTargetToken) {
+  if (!newTargetToken && newSourceToken) {
     newTargetChain = undefined;
   }
 

package/tailwind.config.js

@@ -64,6 +64,8 @@ export default {
           "color-mix(in srgb, var(--error-dark) calc(<alpha-value> * 100%), transparent)",
         t_error_light:
           "color-mix(in srgb, var(--error-light) calc(<alpha-value> * 100%), transparent)",
+        t_chainlink_logo:
+          "color-mix(in srgb, var(--chainlink-logo) calc(<alpha-value> * 100%), transparent)",
 
         x_alert: "rgb(255,183,77)",
         x_alert_light: "rgb(255,226,183)",

package/test/context/SwapProvider.test.tsx

@@ -260,6 +260,110 @@ describe("SwapProvider", () => {
       // Should set a valid token for the new chain
       expect(result.current.srcToken?.address).toBeDefined();
     });
+
+    it("should preserve token when changing to chain with same token", async () => {
+      const { result } = renderHook(() => useSwapContext(), {
+        wrapper: getWrapper(
+          { ...integrationConfig, bridge: false },
+          supportedChains,
+          wagmiConfig,
+        ),
+      });
+
+      await act(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+
+      // First set initial chain and token
+      const initialChain = supportedChains.find(
+        (chain) => chain.chainId === SRC_SWAP_CHAIN_ID,
+      );
+      if (!initialChain) throw new Error("Initial chain not found");
+
+      const initialToken = initialChain.tokens.find(
+        (token) =>
+          token.address.toLowerCase() === SRC_SWAP_TOKEN_ADDR.toLowerCase(),
+      );
+      if (!initialToken) throw new Error("Initial token not found");
+
+      await act(async () => {
+        result.current.setSrcChain(initialChain);
+        result.current.setSrcToken(initialToken);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+
+      // Now change to a different chain that has the same token (by tokenId)
+      const newChain = supportedChains.find(
+        (chain) =>
+          chain.chainId !== initialChain.chainId &&
+          chain.tokens.some(
+            (token) =>
+              token.tokenId === initialToken.tokenId && token.supported,
+          ),
+      );
+      if (!newChain) throw new Error("New chain with same token not found");
+
+      await act(async () => {
+        result.current.setSrcChain(newChain);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+
+      // Should preserve the same tokenId but with new chain's token address
+      expect(result.current.srcToken?.tokenId).toBe(initialToken.tokenId);
+      expect(result.current.srcToken?.address).not.toBe(initialToken.address);
+    });
+
+    it("should reset token when changing to chain without same token", async () => {
+      const { result } = renderHook(() => useSwapContext(), {
+        wrapper: getWrapper(
+          { ...integrationConfig, bridge: false },
+          supportedChains,
+          wagmiConfig,
+        ),
+      });
+
+      await act(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+
+      // First set initial chain and token
+      const initialChain = supportedChains.find(
+        (chain) => chain.chainId === SRC_SWAP_CHAIN_ID,
+      );
+      if (!initialChain) throw new Error("Initial chain not found");
+
+      const initialToken = initialChain.tokens.find(
+        (token) =>
+          token.address.toLowerCase() === SRC_SWAP_TOKEN_ADDR.toLowerCase(),
+      );
+      if (!initialToken) throw new Error("Initial token not found");
+
+      await act(async () => {
+        result.current.setSrcChain(initialChain);
+        result.current.setSrcToken(initialToken);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+
+      // Now change to a chain that doesn't have the same token
+      const newChain = supportedChains.find(
+        (chain) =>
+          chain.chainId !== initialChain.chainId &&
+          !chain.tokens.some((token) => token.tokenId === initialToken.tokenId),
+      );
+      if (!newChain) throw new Error("New chain without same token not found");
+
+      await act(async () => {
+        result.current.setSrcChain(newChain);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+
+      // Should have a different token now
+      expect(result.current.srcToken?.tokenId).not.toBe(initialToken.tokenId);
+      expect(result.current.srcToken?.address).not.toBe(initialToken.address);
+      // But should still have a valid token
+      expect(result.current.srcToken).toBeDefined();
+    });
+
     it("should handle destination chain change", async () => {
       const { result } = renderHook(() => useSwapContext(), {
         wrapper: getWrapper(
@@ -288,7 +392,7 @@ describe("SwapProvider", () => {
       expect(result.current.dstToken?.address).toBeDefined();
     });
 
-    it("should handle source token change", async () => {
+    it("should preserve token when changing destination chain with same token", async () => {
       const { result } = renderHook(() => useSwapContext(), {
         wrapper: getWrapper(
           { ...integrationConfig, bridge: false },
@@ -301,12 +405,119 @@ describe("SwapProvider", () => {
         await new Promise((resolve) => setTimeout(resolve, 0));
       });
 
+      // First set initial chain and token
+      const initialChain = supportedChains.find(
+        (chain) => chain.chainId === DST_SWAP_CHAIN_ID,
+      );
+      if (!initialChain) throw new Error("Initial chain not found");
+
+      const initialToken = initialChain.tokens.find(
+        (token) =>
+          token.address.toLowerCase() === DST_SWAP_TOKEN_ADDR.toLowerCase(),
+      );
+      if (!initialToken) throw new Error("Initial token not found");
+
+      await act(async () => {
+        result.current.setDstChain(initialChain);
+        result.current.setDstToken(initialToken);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+
+      // Now change to a different chain that has the same token (by tokenId)
+      const newChain = supportedChains.find(
+        (chain) =>
+          chain.chainId !== initialChain.chainId &&
+          chain.tokens.some(
+            (token) =>
+              token.tokenId === initialToken.tokenId && token.supported,
+          ),
+      );
+      if (!newChain) throw new Error("New chain with same token not found");
+
+      await act(async () => {
+        result.current.setDstChain(newChain);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+
+      // Should preserve the same tokenId but with new chain's token address
+      expect(result.current.dstToken?.tokenId).toBe(initialToken.tokenId);
+      expect(result.current.dstToken?.address).not.toBe(initialToken.address);
+    });
+
+    it("should reset token when changing destination chain without same token", async () => {
+      const { result } = renderHook(() => useSwapContext(), {
+        wrapper: getWrapper(
+          { ...integrationConfig, bridge: false },
+          supportedChains,
+          wagmiConfig,
+        ),
+      });
+
+      await act(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+
+      // First set initial chain and token
+      const initialChain = supportedChains.find(
+        (chain) => chain.chainId === DST_SWAP_CHAIN_ID,
+      );
+      if (!initialChain) throw new Error("Initial chain not found");
+
+      const initialToken = initialChain.tokens.find(
+        (token) =>
+          token.address.toLowerCase() === DST_SWAP_TOKEN_ADDR.toLowerCase(),
+      );
+      if (!initialToken) throw new Error("Initial token not found");
+
+      await act(async () => {
+        result.current.setDstChain(initialChain);
+        result.current.setDstToken(initialToken);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+
+      // Now change to a chain that doesn't have the same token
       const newChain = supportedChains.find(
+        (chain) =>
+          chain.chainId !== initialChain.chainId &&
+          !chain.tokens.some((token) => token.tokenId === initialToken.tokenId),
+      );
+      if (!newChain) throw new Error("New chain without same token not found");
+
+      await act(async () => {
+        result.current.setDstChain(newChain);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+
+      // Should have a different token now
+      expect(result.current.dstToken?.tokenId).not.toBe(initialToken.tokenId);
+      expect(result.current.dstToken?.address).not.toBe(initialToken.address);
+      // But should still have a valid token
+      expect(result.current.dstToken).toBeDefined();
+    });
+
+    it("should handle source token change", async () => {
+      const { result } = renderHook(() => useSwapContext(), {
+        wrapper: getWrapper(
+          {
+            ...integrationConfig,
+            bridge: false,
+            srcChainId: SRC_SWAP_CHAIN_ID,
+          },
+          supportedChains,
+          wagmiConfig,
+        ),
+      });
+
+      await act(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+
+      const activeSrcChain = supportedChains.find(
         (chain) => chain.chainId === SRC_SWAP_CHAIN_ID,
       );
-      if (!newChain) throw new Error("Source chain not set");
+      if (!activeSrcChain) throw new Error("Source chain not set");
 
-      const newToken = newChain.tokens.find(
+      const newToken = activeSrcChain.tokens.find(
         (token) =>
           token.address.toLowerCase() === SRC_SWAP_TOKEN_ADDR.toLowerCase(),
       );
@@ -322,7 +533,11 @@ describe("SwapProvider", () => {
     it("should handle destination token change", async () => {
       const { result } = renderHook(() => useSwapContext(), {
         wrapper: getWrapper(
-          { ...integrationConfig, bridge: false },
+          {
+            ...integrationConfig,
+            bridge: false,
+            dstChainId: DST_SWAP_CHAIN_ID,
+          },
           supportedChains,
           wagmiConfig,
         ),
@@ -808,6 +1023,7 @@ describe("SwapProvider", () => {
             {
               ...integrationConfig,
               bridge: true,
+              srcChainId: SRC_BRIDGE_CHAIN_ID,
               dstChainId: INVALID_DST_BRIDGE_CHAIN_ID,
             },
             supportedChains,