@xswap-link/sdk 0.8.6 → 0.9.0

package/src/utils/validation.ts

@@ -1,10 +1,12 @@
 import {
   DEFAULT_DESTINATION_CHAIN_ID,
+  DEFAULT_DESTINATION_TOKEN_ADDR,
   DEFAULT_SOURCE_CHAIN_ID,
+  DEFAULT_SOURCE_TOKEN_ADDR,
 } from "@src/constants";
 import { BridgeTokensDictionary, Chain, Token } from "@src/models";
 
-const getDefaultSourceChain = ({
+export const getDefaultSwapSourceChain = ({
   supportedChains,
 }: {
   supportedChains: Chain[];
@@ -23,7 +25,7 @@ const getDefaultSourceChain = ({
   return defaultSourceChain;
 };
 
-const getDefaultDestinationChain = ({
+export const getDefaultDestinationChain = ({
   supportedChains,
 }: {
   supportedChains: Chain[];
@@ -42,15 +44,26 @@ const getDefaultDestinationChain = ({
   return defaultTargetChain;
 };
 
-const getDefaultSwapTokenForChain = (
+export const getDefaultSwapTokenForChain = (
   chain: Chain,
+  defaultTokenAddress: string,
   sameChain?: boolean,
   sourceTokenId?: string,
 ) => {
-  const xswapToken = chain.tokens.find((token) => token.tokenId === "XSWAP");
+  // First check if there are any supported tokens at all
+  const hasAnySupportedTokens = chain.tokens.some((token) => token.supported);
+  if (!hasAnySupportedTokens) {
+    return undefined;
+  }
 
-  if (xswapToken) {
-    return xswapToken;
+  const defaultToken = chain.tokens.find(
+    (token) =>
+      token.address.toLowerCase() === defaultTokenAddress.toLowerCase() &&
+      token.supported,
+  );
+
+  if (defaultToken) {
+    return defaultToken;
   }
 
   const fallbackToken = chain.tokens.find((token) =>
@@ -63,16 +76,20 @@ const getDefaultSwapTokenForChain = (
     return fallbackToken;
   }
 
-  return chain.tokens[0];
+  return undefined;
 };
 
-const getDefaultBridgeTokenForChain = ({
+export const getDefaultBridgeTokenForChain = ({
   chain,
   bridgeTokensDictionary,
 }: {
-  chain: Chain;
+  chain: Chain | undefined;
   bridgeTokensDictionary: BridgeTokensDictionary;
 }) => {
+  if (!chain) {
+    return undefined;
+  }
+
   const xswapToken = chain.tokens.find((token) => token.tokenId === "XSWAP");
 
   if (xswapToken) {
@@ -108,7 +125,8 @@ const isSwapTargetChainValid = ({
   );
 };
 
-const isBridgeSourceValid = (sourceChain: Chain) => sourceChain.bridgeSupported;
+const isBridgeSourceValid = (sourceChain: Chain | undefined) =>
+  !sourceChain || sourceChain.bridgeSupported;
 
 const isBridgeTargetValid = ({
   sourceChain,
@@ -116,71 +134,57 @@ const isBridgeTargetValid = ({
   sourceToken,
 }: {
   sourceChain: Chain | undefined;
-  targetChain: Chain;
+  targetChain: Chain | undefined;
   sourceToken: Token | undefined;
 }) => {
-  if (!sourceChain) {
-    throw new Error(`isBridgeTargetValid > sourceChain should be defined.`);
-  }
+  // We set it to a valid state initially.
+  let isSameToken = true;
+  let isSameChain = false;
 
-  if (
-    sourceToken &&
-    !targetChain.tokens.find((token) => token.tokenId === sourceToken!.tokenId)
-  ) {
+  if (sourceToken && targetChain) {
     // Bridge target chain is invalid when it doesn't have the same token available as selected in the source.
-    return false;
+    isSameToken = !!targetChain.tokens.find(
+      (token) => token.tokenId === sourceToken.tokenId,
+    );
   }
 
-  return (
-    targetChain.bridgeSupported &&
-    // Source and target chains must be different for bridging.
-    sourceChain.chainId !== targetChain.chainId
-  );
+  if (sourceChain && targetChain) {
+    // @TODO use bridge_tokens collection
+    // See: https://github.com/xswap-link/xswap-sdk/pull/200#discussion_r1905586346
+    isSameChain = sourceChain.chainId === targetChain.chainId;
+  }
+
+  return isSameToken && !isSameChain;
 };
 
-// It takes chain and token for source and target and returns them.
-// If provided data is valid, it returns the same.
-// If data is not valid, it returns other available chain/token.
-export const mapToValidPath = ({
-  source,
-  target,
-  type,
-  supportedChains,
-  bridgeTokensDictionary,
-}: {
+type MapToValidPathParams = {
   source: { chain: Chain | undefined; token: Token | undefined };
   target: { chain: Chain | undefined; token: Token | undefined };
   type: "SWAP" | "BRIDGE";
   supportedChains: Chain[];
   bridgeTokensDictionary: BridgeTokensDictionary;
-}): {
-  source: { chain: Chain | undefined; token: Token | undefined };
-  target: { chain: Chain | undefined; token: Token | undefined };
-} => {
+};
+
+const mapToValidPathSwap = ({
+  source,
+  target,
+  supportedChains,
+}: Omit<MapToValidPathParams, "type">) => {
   let newSourceChain: Chain | undefined =
-    source.chain || getDefaultSourceChain({ supportedChains });
+    source.chain || getDefaultSwapSourceChain({ supportedChains });
   let newTargetChain: Chain | undefined =
     target.chain || getDefaultDestinationChain({ supportedChains });
   let newSourceToken: Token | undefined =
     source.token ||
-    (type === "SWAP"
-      ? getDefaultSwapTokenForChain(newSourceChain)
-      : getDefaultBridgeTokenForChain({
-          chain: newSourceChain,
-          bridgeTokensDictionary,
-        }));
+    getDefaultSwapTokenForChain(newSourceChain, DEFAULT_SOURCE_TOKEN_ADDR);
   let newTargetToken: Token | undefined =
     target.token ||
-    (type === "SWAP"
-      ? getDefaultSwapTokenForChain(
-          newTargetChain,
-          newSourceChain.chainId === newTargetChain.chainId,
-          newSourceToken?.tokenId,
-        )
-      : getDefaultBridgeTokenForChain({
-          chain: newTargetChain,
-          bridgeTokensDictionary,
-        }));
+    getDefaultSwapTokenForChain(
+      newTargetChain,
+      DEFAULT_DESTINATION_TOKEN_ADDR,
+      newSourceChain.chainId === newTargetChain.chainId,
+      newSourceToken?.tokenId,
+    );
 
   if (
     !newSourceChain ||
@@ -195,28 +199,36 @@ export const mapToValidPath = ({
     };
   }
 
-  // Setting chains
-  if (type === "SWAP") {
-    if (!isSwapSourceValid(newSourceChain)) {
-      newSourceChain = getDefaultSourceChain({ supportedChains });
-      // We can't have dangling token from a different chain.
-      newSourceToken = undefined;
+  if (!isSwapSourceValid(newSourceChain)) {
+    newSourceChain = getDefaultSwapSourceChain({ supportedChains });
+    // We can't have dangling token from a different chain.
+    newSourceToken = undefined;
 
-      if (!isSwapSourceValid(newSourceChain)) {
-        // This should never occur if our app is configured properly.
-        console.error("[WRONG CONFIG] default swap source chain is invalid.");
+    if (!isSwapSourceValid(newSourceChain)) {
+      // This should never occur if our app is configured properly.
+      console.error("[WRONG CONFIG] default swap source chain is invalid.");
 
-        // Find any chain that is valid.
-        newSourceChain = supportedChains.find((chain) =>
-          isSwapSourceValid(chain),
+      // Find any chain that is valid.
+      newSourceChain = supportedChains.find((chain) =>
+        isSwapSourceValid(chain),
+      );
+      if (!newSourceChain) {
+        throw new Error(
+          "mapToValidSwap > None of the chains supports swap. Couldn't set source chain.",
         );
-        if (!newSourceChain) {
-          throw new Error(
-            "mapToValidSwap > None of the chains supports swap. Couldn't set source chain.",
-          );
-        }
       }
     }
+  }
+
+  if (
+    !isSwapTargetChainValid({
+      sourceChain: newSourceChain,
+      targetChain: newTargetChain,
+    })
+  ) {
+    newTargetChain = getDefaultDestinationChain({ supportedChains });
+    // We can't have dangling token from a different chain.
+    newTargetToken = undefined;
 
     if (
       !isSwapTargetChainValid({
@@ -224,54 +236,88 @@ export const mapToValidPath = ({
         targetChain: newTargetChain,
       })
     ) {
-      newTargetChain = getDefaultDestinationChain({ supportedChains });
-      // We can't have dangling token from a different chain.
-      newTargetToken = undefined;
+      // This should never occur if our app is configured properly.
+      console.error("[WRONG CONFIG] default swap target chain is invalid.");
 
-      if (
-        !isSwapTargetChainValid({
+      // Find any chain that is valid.
+      newTargetChain = supportedChains.find((chain) =>
+        isSwapTargetChainValid({
           sourceChain: newSourceChain,
-          targetChain: newTargetChain,
-        })
-      ) {
-        // This should never occur if our app is configured properly.
-        console.error("[WRONG CONFIG] default swap target chain is invalid.");
-
-        // Find any chain that is valid.
-        newTargetChain = supportedChains.find((chain) =>
-          isSwapTargetChainValid({
-            sourceChain: newSourceChain,
-            targetChain: chain,
-          }),
+          targetChain: chain,
+        }),
+      );
+      if (!newTargetChain) {
+        throw new Error(
+          "mapToValidSwap > None of the chains supports swap. Couldn't set target chain.",
         );
-        if (!newTargetChain) {
-          throw new Error(
-            "mapToValidSwap > None of the chains supports swap. Couldn't set target chain.",
-          );
-        }
       }
     }
-  } else {
-    if (!isBridgeSourceValid(newSourceChain)) {
-      newSourceChain = getDefaultSourceChain({ supportedChains });
-      // We can't have dangling token from a different chain.
-      newSourceToken = undefined;
+  }
 
-      if (!isBridgeSourceValid(newSourceChain)) {
-        // This should never occur if our app is configured properly.
-        console.error("[WRONG CONFIG] default bridge source chain is invalid.");
+  // Setting tokens
 
-        // Find any chain that is valid.
-        newSourceChain = supportedChains.find((chain) =>
-          isBridgeSourceValid(chain),
+  if (!newSourceToken) {
+    newSourceToken = getDefaultSwapTokenForChain(
+      newSourceChain,
+      DEFAULT_SOURCE_TOKEN_ADDR,
+    );
+  }
+  if (!newTargetToken || newSourceToken === newTargetToken) {
+    newTargetToken = getDefaultSwapTokenForChain(
+      newTargetChain,
+      DEFAULT_DESTINATION_TOKEN_ADDR,
+      newSourceChain.chainId === newTargetChain.chainId,
+      newSourceToken?.tokenId,
+    );
+  }
+
+  return {
+    source: { chain: newSourceChain, token: newSourceToken },
+    target: { chain: newTargetChain, token: newTargetToken },
+  };
+};
+
+const mapToValidPathBridge = ({
+  source,
+  target,
+  supportedChains,
+  bridgeTokensDictionary,
+}: Omit<MapToValidPathParams, "type">) => {
+  let newSourceChain = source.chain;
+  let newTargetChain = target.chain;
+  let newSourceToken = source.token;
+  let newTargetToken = target.token;
+
+  if (!isBridgeSourceValid(newSourceChain)) {
+    newSourceChain = undefined;
+    newSourceToken = undefined;
+
+    if (!isBridgeSourceValid(newSourceChain)) {
+      // This should never occur if our app is configured properly.
+      console.error("[WRONG CONFIG] default bridge source chain is invalid.");
+
+      // Find any chain that is valid.
+      newSourceChain = supportedChains.find((chain) =>
+        isBridgeSourceValid(chain),
+      );
+      if (!newSourceChain) {
+        throw new Error(
+          "mapToValidSwap > None of the chains supports bridge. Couldn't set source chain.",
         );
-        if (!newSourceChain) {
-          throw new Error(
-            "mapToValidSwap > None of the chains supports bridge. Couldn't set source chain.",
-          );
-        }
       }
     }
+  }
+
+  if (
+    !isBridgeTargetValid({
+      sourceChain: newSourceChain,
+      targetChain: newTargetChain,
+      sourceToken: newSourceToken,
+    })
+  ) {
+    newTargetChain = undefined;
+    // We can't have dangling token from a different chain.
+    newTargetToken = undefined;
 
     if (
       !isBridgeTargetValid({
@@ -280,100 +326,90 @@ export const mapToValidPath = ({
         sourceToken: newSourceToken,
       })
     ) {
-      newTargetChain = getDefaultDestinationChain({ supportedChains });
-      // We can't have dangling token from a different chain.
-      newTargetToken = undefined;
+      // This should never occur if our app is configured properly.
+      console.error("[WRONG CONFIG] default bridge target chain is invalid.");
 
-      if (
-        !isBridgeTargetValid({
+      // Find any chain that is valid.
+      newTargetChain = supportedChains.find((chain) =>
+        isBridgeTargetValid({
           sourceChain: newSourceChain,
-          targetChain: newTargetChain,
+          targetChain: chain,
           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.",
         );
-        if (!newTargetChain) {
-          throw new Error(
-            "mapToValidSwap > None of the chains supports swap. Couldn't set target chain.",
-          );
-        }
       }
     }
   }
 
   // Setting tokens
-  if (type === "SWAP") {
-    if (!newSourceToken) {
-      newSourceToken = getDefaultSwapTokenForChain(newSourceChain);
-    }
-    if (!newTargetToken) {
-      newTargetToken = getDefaultSwapTokenForChain(
-        newTargetChain,
-        newSourceChain.chainId === newTargetChain.chainId,
-        newSourceToken?.tokenId,
-      );
+
+  // check if the source token is bridgeable
+  if (newSourceToken && newSourceChain && newTargetChain) {
+    const isBridgeable =
+      !!bridgeTokensDictionary[newSourceChain.chainId]?.[
+        newSourceToken.address.toLowerCase()
+      ]?.[newTargetChain.chainId];
+
+    if (!isBridgeable) {
+      newSourceToken = undefined;
     }
-  } else {
-    if (!newSourceToken) {
-      const defaultToken = getDefaultBridgeTokenForChain({
-        chain: newSourceChain,
-        bridgeTokensDictionary,
-      });
-
-      if (defaultToken) {
-        const isDefaultTokenBridgeable =
-          !!bridgeTokensDictionary[newSourceChain.chainId]?.[
-            defaultToken.address.toLowerCase()
-          ]?.[newTargetChain.chainId];
-
-        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;
-        }
+  }
+
+  if (!newSourceToken) {
+    const defaultToken = getDefaultBridgeTokenForChain({
+      chain: newSourceChain,
+      bridgeTokensDictionary,
+    });
+
+    if (defaultToken && newSourceChain && newTargetChain) {
+      const isDefaultTokenBridgeable =
+        !!bridgeTokensDictionary[newSourceChain.chainId]?.[
+          defaultToken.address.toLowerCase()
+        ]?.[newTargetChain.chainId];
+
+      if (isDefaultTokenBridgeable) {
+        newSourceToken = defaultToken;
       } else {
-        // Default was not found, so let's keep it unset.
+        // 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 {
+      // Default was not found, so let's keep it unset.
+      newSourceToken = undefined;
     }
+  }
 
-    if (newSourceToken?.tokenId !== newTargetToken?.tokenId) {
+  if (newSourceToken?.tokenId !== newTargetToken?.tokenId) {
+    newTargetToken = undefined;
+  }
+
+  if (!newTargetToken) {
+    if (newSourceToken && newSourceChain && newTargetChain) {
+      const correspondingTokenAddress =
+        bridgeTokensDictionary[newSourceChain.chainId]?.[
+          newSourceToken.address.toLowerCase()
+        ]?.[newTargetChain.chainId];
+
+      const correspondingToken = newTargetChain.tokens.find(
+        (token) =>
+          token.address.toLowerCase() ===
+          correspondingTokenAddress?.toLowerCase(),
+      );
+      newTargetToken = correspondingToken;
+    } else {
+      // If source token is not defined, destination token can't be defined as well.
       newTargetToken = undefined;
     }
+  }
 
-    if (!newTargetToken) {
-      if (newSourceToken) {
-        const correspondingTokenAddress =
-          bridgeTokensDictionary[newSourceChain.chainId]?.[
-            newSourceToken.address.toLowerCase()
-          ]?.[newTargetChain.chainId];
-
-        const correspondingToken = newTargetChain.tokens.find(
-          (token) =>
-            token.address.toLowerCase() ===
-            correspondingTokenAddress?.toLowerCase(),
-        );
-        newTargetToken = correspondingToken;
-      } else {
-        // If source token is not defined, destination token can't be defined as well.
-        newTargetToken = undefined;
-      }
-    }
+  if (!newTargetToken) {
+    newTargetChain = undefined;
   }
 
   return {
@@ -381,3 +417,20 @@ export const mapToValidPath = ({
     target: { chain: newTargetChain, token: newTargetToken },
   };
 };
+
+// It takes chain and token for source and target and returns them.
+// If provided data is valid, it returns the same.
+// If data is not valid, it returns other available chain/token.
+export const mapToValidPath = ({
+  type,
+  ...params
+}: MapToValidPathParams): {
+  source: { chain: Chain | undefined; token: Token | undefined };
+  target: { chain: Chain | undefined; token: Token | undefined };
+} => {
+  if (type === "SWAP") {
+    return mapToValidPathSwap(params);
+  } else {
+    return mapToValidPathBridge(params);
+  }
+};

package/tailwind.config.js

@@ -6,6 +6,7 @@ export default {
     fontFamily: {
       body: ["'Satoshi-Medium'", "Tahoma", "Verdana", "ui-sans-serif"],
       sans: ["Satoshi-Medium", "Tahoma", "Verdana", "ui-sans-serif"],
+      "sans-bold": ["Satoshi-Bold", "Tahoma", "Verdana", "ui-sans-serif"],
     },
     extend: {
       colors: {