@xswap-link/sdk 0.6.10 → 0.8.0

package/src/models/payloads/ModalIntegrationPayload.ts

@@ -1,4 +1,4 @@
-import { ContractCall } from "@src/models";
+import { ContractCall, Transaction } from "@src/models";
 
 export type ModalIntegrationThemeStyles = {
   mainAccentLight?: string;
@@ -38,8 +38,8 @@ export type ModalIntegrationStyles = Pick<
 
 export type ModalIntegrationPayload = {
   integratorId: string;
-  dstChain: string;
-  dstToken: string;
+  dstChain?: string;
+  dstToken?: string;
   srcChain?: string;
   srcToken?: string;
   customContractCalls?: ContractCall[];
@@ -48,4 +48,18 @@ export type ModalIntegrationPayload = {
   lightTheme?: boolean;
   defaultWalletPicker?: boolean;
   styles?: ModalIntegrationStyles;
+  onPendingTransactionsChange?: (transactions: Transaction[]) => void;
+  dstTokenLocked?: boolean;
+  dstChainLocked?: boolean;
+  srcTokenLocked?: boolean;
+  srcChainLocked?: boolean;
+  onDstTokenChange?: (
+    token: { address: string; symbol: string } | undefined,
+  ) => void;
+  onDstChainChange?: (chain: string | undefined) => void;
+  onSrcTokenChange?: (
+    token: { address: string; symbol: string } | undefined,
+  ) => void;
+  onSrcChainChange?: (chain: string | undefined) => void;
+  bridge?: boolean;
 };

package/src/models/payloads/WidgetIntegrationPayload.ts

@@ -1,4 +1,4 @@
-import { ContractCall, ModalIntegrationStyles } from "@src/models";
+import { ContractCall, ModalIntegrationStyles, Transaction } from "@src/models";
 
 export type WidgetIntegrationPayload = {
   integratorId: string;
@@ -12,4 +12,18 @@ export type WidgetIntegrationPayload = {
   lightTheme?: boolean;
   defaultWalletPicker?: boolean;
   styles?: ModalIntegrationStyles | string;
+  onPendingTransactionsChange?: (transactions: Transaction[]) => void;
+  dstTokenLocked?: boolean;
+  dstChainLocked?: boolean;
+  srcTokenLocked?: boolean;
+  srcChainLocked?: boolean;
+  onDstTokenChange?: (
+    token: { address: string; symbol: string } | undefined,
+  ) => void;
+  onDstChainChange?: (chain: string | undefined) => void;
+  onSrcTokenChange?: (
+    token: { address: string; symbol: string } | undefined,
+  ) => void;
+  onSrcChainChange?: (chain: string | undefined) => void;
+  bridge?: boolean;
 };

package/src/services/api.ts

@@ -1,5 +1,5 @@
-import xSwapConfig from "../../xswap.config";
 import {
+  BridgeToken,
   Chain,
   Ecosystem,
   GetFinishedLeaderboardQuestsPayload,
@@ -13,6 +13,7 @@ import {
   TransactionHistory,
   TransactionStatus,
 } from "@src/models";
+import xSwapConfig from "../../xswap.config";
 
 async function _sendRequest<T>(
   urlPath: string,
@@ -153,3 +154,7 @@ export async function getFinishedLeaderboardQuests(
     })}`,
   );
 }
+
+export async function getBridgeTokens(): Promise<BridgeToken[]> {
+  return _sendRequest<BridgeToken[]>(`/bridgeTokens`);
+}

package/src/services/integrations/transactions.ts

@@ -15,6 +15,16 @@ export const openTransactionModal = async ({
   lightTheme,
   defaultWalletPicker,
   styles,
+  onPendingTransactionsChange,
+  dstTokenLocked,
+  dstChainLocked,
+  srcTokenLocked,
+  srcChainLocked,
+  onDstTokenChange,
+  onDstChainChange,
+  onSrcTokenChange,
+  onSrcChainChange,
+  bridge,
 }: ModalIntegrationPayload) => {
   const supportedChains: Chain[] = (await getChains()).filter(
     ({ web3Environment, swapSupported }) =>
@@ -43,14 +53,24 @@ export const openTransactionModal = async ({
     lightTheme,
     defaultWalletPicker,
     styles,
+    onPendingTransactionsChange,
+    dstTokenLocked,
+    dstChainLocked,
+    srcTokenLocked,
+    srcChainLocked,
+    onDstTokenChange,
+    onDstChainChange,
+    onSrcTokenChange,
+    onSrcChainChange,
+    bridge,
   });
 };
 
 const validateSwapTxData = (
   integratorId: string,
   supportedChains: Chain[],
-  dstChain: string,
-  dstToken: string,
+  dstChain?: string,
+  dstToken?: string,
   srcChain?: string,
   srcToken?: string,
 ) => {
@@ -60,21 +80,24 @@ const validateSwapTxData = (
     );
   }
 
-  const supportedDstChain = supportedChains.find(
-    ({ chainId }) => chainId === dstChain,
-  );
-  if (!supportedDstChain) {
-    throw new Error(`Provided chain '${dstChain}' is not supported`);
-  }
-  if (
-    !isETHAddressValid(dstToken) ||
-    supportedDstChain.tokens.findIndex(
-      ({ address }) => address.toLowerCase() === dstToken.toLowerCase(),
-    ) === -1
-  ) {
-    throw new Error(
-      `Provided token address ${dstToken} on chain ${dstChain} is invalid`,
+  if (dstChain) {
+    const supportedDstChain = supportedChains.find(
+      ({ chainId }) => chainId === dstChain,
     );
+    if (!supportedDstChain) {
+      throw new Error(`Provided chain '${dstChain}' is not supported`);
+    }
+    if (
+      dstToken &&
+      (!isETHAddressValid(dstToken) ||
+        supportedDstChain.tokens.findIndex(
+          ({ address }) => address.toLowerCase() === dstToken.toLowerCase(),
+        ) === -1)
+    ) {
+      throw new Error(
+        `Provided token address ${dstToken} on chain ${dstChain} is invalid`,
+      );
+    }
   }
 
   if (srcChain) {
@@ -86,7 +109,7 @@ const validateSwapTxData = (
     }
     if (
       srcToken &&
-      (!isETHAddressValid(dstToken) ||
+      (!isETHAddressValid(srcToken) ||
         supportedSrcChain.tokens.findIndex(
           ({ address }) => address.toLowerCase() === srcToken.toLowerCase(),
         ) === -1)

package/src/types/global.d.ts

@@ -0,0 +1,15 @@
+import { Transaction } from "@src/models";
+
+declare global {
+  interface Window {
+    xPayOnPendingTransactionsChange?: (transactions: Transaction[]) => void;
+    xPayOnDstTokenChange?: (
+      token: { address: string; symbol: string } | undefined,
+    ) => void;
+    xPayOnDstChainChange?: (chain: string | undefined) => void;
+    xPayOnSrcTokenChange?: (
+      token: { address: string; symbol: string } | undefined,
+    ) => void;
+    xPayOnSrcChainChange?: (chain: string | undefined) => void;
+  }
+}

package/src/utils/validation.ts

@@ -0,0 +1,367 @@
+import {
+  DEFAULT_DESTINATION_CHAIN_ID,
+  DEFAULT_SOURCE_CHAIN_ID,
+} from "@src/constants";
+import { BridgeTokensDictionary, Chain, Token } from "@src/models";
+
+const getDefaultSourceChain = ({
+  supportedChains,
+}: {
+  supportedChains: Chain[];
+}): Chain => {
+  const defaultSourceChain =
+    supportedChains.find(
+      (chain) => chain.chainId === DEFAULT_SOURCE_CHAIN_ID,
+    ) || supportedChains[0];
+
+  if (!defaultSourceChain) {
+    throw new Error(
+      `getDefaultSourceChain > couldn't find default source chain`,
+    );
+  }
+
+  return defaultSourceChain;
+};
+
+const getDefaultDestinationChain = ({
+  supportedChains,
+}: {
+  supportedChains: Chain[];
+}): Chain => {
+  const defaultTargetChain =
+    supportedChains.find(
+      (chain) => chain.chainId === DEFAULT_DESTINATION_CHAIN_ID,
+    ) || supportedChains[0];
+
+  if (!defaultTargetChain) {
+    throw new Error(
+      `getDefaultDestinationChain > couldn't find default destination chain`,
+    );
+  }
+
+  return defaultTargetChain;
+};
+
+const getDefaultSwapTokenForChain = (chain: Chain) => {
+  const xswapToken = chain.tokens.find((token) => token.tokenId === "XSWAP");
+
+  if (xswapToken) {
+    return xswapToken;
+  }
+
+  const fallbackToken = chain.tokens.find((token) => token.supported);
+
+  if (fallbackToken) {
+    return fallbackToken;
+  }
+
+  return chain.tokens[0];
+};
+
+const getDefaultBridgeTokenForChain = ({
+  chain,
+  bridgeTokensDictionary,
+}: {
+  chain: Chain;
+  bridgeTokensDictionary: BridgeTokensDictionary;
+}) => {
+  const xswapToken = chain.tokens.find((token) => token.tokenId === "XSWAP");
+
+  if (xswapToken) {
+    return xswapToken;
+  }
+
+  const fallbackTokenAddress = Object.keys(
+    bridgeTokensDictionary[chain.chainId] || {},
+  )[0];
+
+  return chain.tokens.find(
+    (token) =>
+      token.address.toLowerCase() === fallbackTokenAddress?.toLowerCase(),
+  );
+};
+
+const isSwapSourceValid = (sourceChain: Chain) => sourceChain.swapSupported;
+
+const isSwapTargetChainValid = ({
+  sourceChain,
+  targetChain,
+}: {
+  sourceChain: Chain | undefined;
+  targetChain: Chain;
+}) => {
+  if (!sourceChain) {
+    throw new Error(`isSwapTargetChainValid > sourceChain should be defined.`);
+  }
+
+  return (
+    targetChain.swapSupported &&
+    !sourceChain.disabledForDestination?.includes(targetChain.chainId)
+  );
+};
+
+const isBridgeSourceValid = (sourceChain: Chain) => sourceChain.bridgeSupported;
+
+const isBridgeTargetValid = ({
+  sourceChain,
+  targetChain,
+  sourceToken,
+}: {
+  sourceChain: Chain | undefined;
+  targetChain: Chain;
+  sourceToken: Token | undefined;
+}) => {
+  if (!sourceChain) {
+    throw new Error(`isBridgeTargetValid > sourceChain should be defined.`);
+  }
+
+  if (
+    sourceToken &&
+    !targetChain.tokens.find((token) => token.tokenId === sourceToken!.tokenId)
+  ) {
+    // Bridge target chain is invalid when it doesn't have the same token available as selected in the source.
+    return false;
+  }
+
+  return (
+    targetChain.bridgeSupported &&
+    // Source and target chains must be different for bridging.
+    sourceChain.chainId !== targetChain.chainId
+  );
+};
+
+// 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,
+}: {
+  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 };
+} => {
+  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,
+        }));
+  let newTargetToken: Token | undefined =
+    target.token ||
+    (type === "SWAP"
+      ? getDefaultSwapTokenForChain(newTargetChain)
+      : getDefaultBridgeTokenForChain({
+          chain: newTargetChain,
+          bridgeTokensDictionary,
+        }));
+
+  if (
+    !newSourceChain ||
+    !newTargetChain ||
+    !newSourceToken ||
+    !newTargetToken
+  ) {
+    // This should never occur if our app is configured properly.
+    return {
+      source: { chain: undefined, token: undefined },
+      target: { chain: undefined, token: undefined },
+    };
+  }
+
+  // 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)) {
+        // 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),
+        );
+        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({
+          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,
+          }),
+        );
+        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.");
+
+        // 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 (
+      !isBridgeTargetValid({
+        sourceChain: newSourceChain,
+        targetChain: newTargetChain,
+        sourceToken: newSourceToken,
+      })
+    ) {
+      newTargetChain = getDefaultDestinationChain({ supportedChains });
+      // We can't have dangling token from a different chain.
+      newTargetToken = undefined;
+
+      if (
+        !isBridgeTargetValid({
+          sourceChain: newSourceChain,
+          targetChain: newTargetChain,
+          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 swap. Couldn't set target chain.",
+          );
+        }
+      }
+    }
+  }
+
+  // Setting tokens
+  if (type === "SWAP") {
+    if (!newSourceToken) {
+      newSourceToken = getDefaultSwapTokenForChain(newSourceChain);
+    }
+    if (!newTargetToken) {
+      newTargetToken = getDefaultSwapTokenForChain(newTargetChain);
+    }
+  } 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;
+        }
+      } else {
+        // Default was not found, so let's keep it unset.
+        newSourceToken = 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;
+      }
+    }
+  }
+
+  return {
+    source: { chain: newSourceChain, token: newSourceToken },
+    target: { chain: newTargetChain, token: newTargetToken },
+  };
+};

package/tsconfig.json

@@ -15,7 +15,8 @@
     "noImplicitAny": false,
     "noEmit": true,
     "paths": {
-      "@src/*": ["./src/*"],
+      "@src/*": ["./src/*"]
     }
-  }
+  },
+  "include": ["src"]
 }

package/src/context/ModalProvider.tsx

@@ -1,63 +0,0 @@
-import { createContext, FC, ReactNode, useContext, useState } from "react";
-import { useSwapContext } from "./SwapProvider";
-
-interface ModalState {
-  openModal: (modalContent: ReactNode) => void;
-  closeModal: () => void;
-}
-
-const ModalContext = createContext<ModalState>({
-  openModal: () => {
-    throw new Error(`openModal is not implemented`);
-  },
-  closeModal: () => {
-    throw new Error(`closeModal is not implemented`);
-  },
-});
-
-export const ModalProvider: FC<{ children: ReactNode }> = ({ children }) => {
-  const { overlay } = useSwapContext();
-  const [content, setContent] = useState<ReactNode | null>(null);
-
-  const openModal = (modalContent: ReactNode) => {
-    setContent(modalContent);
-  };
-
-  const closeModal = () => {
-    setContent(null);
-  };
-
-  return (
-    <ModalContext.Provider value={{ openModal, closeModal }}>
-      <div
-        className={`${
-          overlay ? "" : "relative min-w-x_modal w-x_modal max-w-x_modal"
-        }`}
-      >
-        {children}
-        {content && (
-          <div
-            className={`${
-              overlay ? "fixed bg-[rgba(0,0,0,0.8)]" : "absolute"
-            } top-0 left-0 right-0 bottom-0 flex items-center justify-center z-10`}
-          >
-            <div
-              className="flex flex-col bg-t_bg_primary x-border rounded-3xl p-4 w-full min-w-[340px]"
-              style={{
-                height: overlay ? "600px" : "100%",
-                maxWidth: "480px",
-                maxHeight: "100%",
-              }}
-            >
-              {content}
-            </div>
-          </div>
-        )}
-      </div>
-    </ModalContext.Provider>
-  );
-};
-
-export const useModal = () => {
-  return useContext(ModalContext);
-};