@xswap-link/sdk 0.8.5 → 0.8.7

package/src/utils/validation.ts

@@ -70,9 +70,13 @@ 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 +112,8 @@ const isSwapTargetChainValid = ({
   );
 };
 
-const isBridgeSourceValid = (sourceChain: Chain) => sourceChain.bridgeSupported;
+const isBridgeSourceValid = (sourceChain: Chain | undefined) =>
+  !sourceChain || sourceChain.bridgeSupported;
 
 const isBridgeTargetValid = ({
   sourceChain,
@@ -116,71 +121,55 @@ 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 });
   let newTargetChain: Chain | undefined =
     target.chain || getDefaultDestinationChain({ supportedChains });
   let newSourceToken: Token | undefined =
-    source.token ||
-    (type === "SWAP"
-      ? getDefaultSwapTokenForChain(newSourceChain)
-      : getDefaultBridgeTokenForChain({
-          chain: newSourceChain,
-          bridgeTokensDictionary,
-        }));
+    source.token || getDefaultSwapTokenForChain(newSourceChain);
   let newTargetToken: Token | undefined =
     target.token ||
-    (type === "SWAP"
-      ? getDefaultSwapTokenForChain(
-          newTargetChain,
-          newSourceChain.chainId === newTargetChain.chainId,
-          newSourceToken?.tokenId,
-        )
-      : getDefaultBridgeTokenForChain({
-          chain: newTargetChain,
-          bridgeTokensDictionary,
-        }));
+    getDefaultSwapTokenForChain(
+      newTargetChain,
+      newSourceChain.chainId === newTargetChain.chainId,
+      newSourceToken?.tokenId,
+    );
 
   if (
     !newSourceChain ||
@@ -195,28 +184,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 = getDefaultSourceChain({ 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 +221,85 @@ 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
+
+  if (!newSourceToken) {
+    newSourceToken = getDefaultSwapTokenForChain(newSourceChain);
+  }
+  if (!newTargetToken) {
+    newTargetToken = getDefaultSwapTokenForChain(
+      newTargetChain,
+      newSourceChain.chainId === newTargetChain.chainId,
+      newSourceToken?.tokenId,
+    );
+  }
 
-        // Find any chain that is valid.
-        newSourceChain = supportedChains.find((chain) =>
-          isBridgeSourceValid(chain),
+  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 = 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.");
+
+      // 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 = getDefaultDestinationChain({ supportedChains });
+    // We can't have dangling token from a different chain.
+    newTargetToken = undefined;
 
     if (
       !isBridgeTargetValid({
@@ -280,99 +308,73 @@ 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,
-      );
-    }
-  } 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) {
-      newTargetToken = undefined;
-    }
+  if (newSourceToken?.tokenId !== newTargetToken?.tokenId) {
+    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) {
+    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;
     }
   }
 
@@ -381,3 +383,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

@@ -85,7 +85,7 @@ export default {
         x_modal: "var(--modal-width, 360px)",
       },
       width: {
-        x_modal: "var(--modal-width, 480px)",
+        x_modal: "var(--modal-width)",
       },
       maxWidth: {
         x_modal: "var(--modal-width, 480px)",