@xswap-link/sdk 0.7.0 → 0.8.1

package/src/models/index.ts

@@ -1,7 +1,6 @@
 export * from "./Addresses";
-export * from "./XSwapConfig";
 export * from "./BridgeToken";
-export * from "./TokenData";
+export * from "./BridgeTokensDictionary";
 export * from "./CoinTypeAddress";
 export * from "./CollectFees";
 export * from "./ContractCall";
@@ -11,9 +10,11 @@ export * from "./forms";
 export * from "./integrations";
 export * from "./payloads";
 export * from "./Protocol";
-export * from "./Route";
-export * from "./Web3Environment";
-export * from "./XSwapCallType";
 export * from "./Referral";
+export * from "./Route";
+export * from "./TokenData";
 export * from "./TransactionHistory";
 export * from "./TxUIWrapper";
+export * from "./Web3Environment";
+export * from "./XSwapCallType";
+export * from "./XSwapConfig";

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;
@@ -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,6 +53,16 @@ export const openTransactionModal = async ({
     lightTheme,
     defaultWalletPicker,
     styles,
+    onPendingTransactionsChange,
+    dstTokenLocked,
+    dstChainLocked,
+    srcTokenLocked,
+    srcChainLocked,
+    onDstTokenChange,
+    onDstChainChange,
+    onSrcTokenChange,
+    onSrcChainChange,
+    bridge,
   });
 };
 

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,383 @@
+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,
+  sameChain?: boolean,
+  sourceTokenId?: string,
+) => {
+  const xswapToken = chain.tokens.find((token) => token.tokenId === "XSWAP");
+
+  if (xswapToken) {
+    return xswapToken;
+  }
+
+  const fallbackToken = chain.tokens.find((token) =>
+    sameChain
+      ? token.supported && token.tokenId !== sourceTokenId
+      : 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,
+          newSourceChain.chainId === newTargetChain.chainId,
+          newSourceToken?.tokenId,
+        )
+      : 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,
+        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;
+        }
+      } 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"]
 }