@xswap-link/sdk 0.10.6 → 0.10.8

package/src/context/SwapProvider.tsx

@@ -3,16 +3,21 @@ import {
   DEFAULT_DESTINATION_CHAIN_ID,
   DEFAULT_REQUEST_ABORT_MSG,
   DEFAULT_SOURCE_CHAIN_ID,
+  SOLANA_NATIVE_TOKEN_ADDRESS,
+  SOLANA_TOKEN_PROGRAM_ID,
 } from "@src/constants";
 import { ADDRESSES } from "@src/contracts";
 import {
   BridgeToken,
   BridgeTokensDictionary,
   Chain,
-  Route,
+  Ecosystem,
+  EVMRoute,
+  SolanaRoute,
   Token,
   TokenOption,
   TokenPrices,
+  UnifiedRoute,
   Web3Environment,
 } from "@src/models";
 import {
@@ -20,6 +25,7 @@ import {
   getBridgeTokens,
   getPrices,
   getRoute,
+  getSolanaRoute,
 } from "@src/services";
 import {
   deepMergeObjects,
@@ -45,8 +51,9 @@ import {
   useRef,
   useState,
 } from "react";
-import { Config, useAccount } from "wagmi";
 import { mapToValidPath } from "@src/utils/validation";
+import { useWallet } from "./WalletProvider";
+import { Connection, PublicKey } from "@solana/web3.js";
 
 type Tab = "Swap" | "History" | "Settings";
 
@@ -57,7 +64,6 @@ type ChainOption = Chain & {
 type SwapContext = {
   bridgeUI: boolean;
   integrationConfig: Partial<TxConfigFormPayload>;
-  wagmiConfig: Config;
   supportedChains: Chain[];
   tab: Tab;
   setTab: Dispatch<SetStateAction<Tab>>;
@@ -98,8 +104,8 @@ type SwapContext = {
   setInfiniteApproval: Dispatch<SetStateAction<boolean>>;
   slippage: string;
   setSlippage: Dispatch<SetStateAction<string>>;
-  route: Route | undefined;
-  setRoute: Dispatch<SetStateAction<Route | undefined>>;
+  route: UnifiedRoute | undefined;
+  setRoute: Dispatch<SetStateAction<UnifiedRoute | undefined>>;
   isAsyncDataLoaded: boolean;
   srcTokenBalanceWei: string;
   setSrcTokenBalanceWei: Dispatch<SetStateAction<string>>;
@@ -130,7 +136,6 @@ const functionNotImplemented = () => {
 const init: SwapContext = {
   bridgeUI: false,
   integrationConfig: {},
-  wagmiConfig: {} as Config,
   supportedChains: [],
   tab: "Swap",
   overlay: false,
@@ -196,21 +201,20 @@ type Props = {
   children: ReactNode;
   integrationConfig: Partial<TxConfigFormPayload>;
   supportedChains: Chain[];
-  wagmiConfig: Config;
   overlay: boolean;
 };
 export const SwapProvider = ({
   children,
   integrationConfig,
   supportedChains,
-  wagmiConfig,
   overlay,
 }: Props) => {
   // =============================================================================
   // Hooks
   // =============================================================================
-  const { address, chainId: walletChainId } = useAccount();
-
+  const { evm, solana } = useWallet();
+  const { address: evmAddress, chainId: walletChainId } = evm;
+  const { address: solanaAddress } = solana;
   // =============================================================================
   // State
   // =============================================================================
@@ -472,7 +476,7 @@ export const SwapProvider = ({
   );
   // useMemo: computes a formatted balance string for the source token based on its balance in Wei.
   const srcTokenBalanceInfo = useMemo(() => {
-    if (!srcToken || !srcTokenBalanceWei || !address) {
+    if (!srcToken || !srcTokenBalanceWei || (!evmAddress && !solanaAddress)) {
       return "";
     }
 
@@ -496,7 +500,7 @@ export const SwapProvider = ({
       decimals: srcToken.decimals,
       precisionFractionalPlaces: 5,
     });
-  }, [srcToken, srcTokenBalanceWei]);
+  }, [evmAddress, solanaAddress, srcToken, srcTokenBalanceWei]);
 
   // =============================================================================
   // Callbacks
@@ -572,30 +576,54 @@ export const SwapProvider = ({
         routeAbortController.current.abort(DEFAULT_REQUEST_ABORT_MSG);
       }
       routeAbortController.current = new AbortController();
-      const route = await getRoute(
-        {
+      if (srcChain.ecosystem === Ecosystem.SOLANA) {
+        const solanaRouteData = await getSolanaRoute({
           integratorId: integrationConfig.integratorId!,
-          fromChain: srcChain.chainId,
-          toChain: dstChain.chainId,
-          fromAddress:
-            address || ADDRESSES[srcChain.chainId]?.FeeCollector || "",
-          toAddress: address || ADDRESSES[dstChain.chainId]?.FeeCollector || "",
           fromToken: srcToken.address,
           toToken: dstToken.address,
           fromAmount: srcValueWei,
+          fromAddress:
+            solanaAddress || ADDRESSES[srcChain.chainId]?.FeeCollector || "",
           slippage: Number(slippage),
-          customContractCalls: integrationConfig.customContractCalls,
-          paymentToken: constants.AddressZero,
-          expressDelivery: expressDelivery,
-          infiniteApproval: infiniteApproval,
-          integratorFee: integrationConfig.integratorFee,
-          integratorFeeReceiverAddress:
-            integrationConfig.integratorFeeReceiverAddress,
-        },
-        routeAbortController.current.signal,
-      );
+        });
+
+        const unifiedRoute: SolanaRoute = {
+          ...solanaRouteData,
+          ecosystem: "solana",
+        };
+        setRoute(unifiedRoute);
+      } else {
+        const evmRouteData = await getRoute(
+          {
+            integratorId: integrationConfig.integratorId!,
+            fromChain: srcChain.chainId,
+            toChain: dstChain.chainId,
+            fromAddress:
+              evmAddress || ADDRESSES[srcChain.chainId]?.FeeCollector || "",
+            toAddress:
+              evmAddress || ADDRESSES[dstChain.chainId]?.FeeCollector || "",
+            fromToken: srcToken.address,
+            toToken: dstToken.address,
+            fromAmount: srcValueWei,
+            slippage: Number(slippage),
+            customContractCalls: integrationConfig.customContractCalls,
+            paymentToken: constants.AddressZero,
+            expressDelivery: expressDelivery,
+            infiniteApproval: infiniteApproval,
+            integratorFee: integrationConfig.integratorFee,
+            integratorFeeReceiverAddress:
+              integrationConfig.integratorFeeReceiverAddress,
+          },
+          routeAbortController.current.signal,
+        );
+
+        const unifiedRoute: EVMRoute = {
+          ...evmRouteData,
+          ecosystem: "evm",
+        };
+        setRoute(unifiedRoute);
+      }
 
-      setRoute(route);
       routeAbortController.current = null;
     } catch (error) {
       if (error !== DEFAULT_REQUEST_ABORT_MSG) {
@@ -611,7 +639,7 @@ export const SwapProvider = ({
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [
-    address,
+    evmAddress,
     bridgeUI,
     dstChain,
     dstToken,
@@ -625,7 +653,7 @@ export const SwapProvider = ({
   // refreshes and updates the balance of the source token using its RPC URL.
   const refreshBalance = useCallback(async () => {
     if (
-      !address ||
+      (!evmAddress && !solanaAddress) ||
       !srcChain?.publicRpcUrls[0] ||
       !srcToken ||
       !srcToken?.address
@@ -637,26 +665,52 @@ export const SwapProvider = ({
     refreshSelectedTokenBalanceNonce.current = nonce;
 
     setIsFetchingBalance(true);
+    let balance = "0";
+    if (srcChain?.ecosystem === Ecosystem.EVM && evmAddress) {
+      const balanceUI = await getBalanceOf(
+        evmAddress,
+        srcToken.address,
+        srcChain?.publicRpcUrls[0],
+      );
+      balance = humanReadableToWei({
+        amount: balanceUI,
+        decimals: srcToken.decimals,
+      });
+    } else if (srcChain?.ecosystem === Ecosystem.SOLANA && solanaAddress) {
+      const solanaPublicKey = new PublicKey(solanaAddress);
+      const connection = new Connection(srcChain.publicRpcUrls[0]!);
+      if (srcToken.address === SOLANA_NATIVE_TOKEN_ADDRESS.toBase58()) {
+        balance = new BigNumberJS(
+          await connection.getBalance(solanaPublicKey),
+        ).toString();
+      } else {
+        const tokenAccounts = await connection.getParsedTokenAccountsByOwner(
+          solanaPublicKey,
+          {
+            programId: SOLANA_TOKEN_PROGRAM_ID,
+          },
+        );
+        const tokenAccount = tokenAccounts.value.find(
+          (account) =>
+            account.account.data.parsed.info.mint === srcToken.address,
+        );
 
-    const balance = await getBalanceOf(
-      address,
-      srcToken.address,
-      srcChain?.publicRpcUrls[0],
-    );
+        if (!tokenAccount) {
+          balance = "0";
+        } else {
+          balance = tokenAccount.account.data.parsed.info.tokenAmount.amount;
+        }
+      }
+    }
 
     if (nonce !== refreshSelectedTokenBalanceNonce.current) {
       return;
     }
 
-    setSrcTokenBalanceWei(
-      humanReadableToWei({
-        amount: balance,
-        decimals: srcToken.decimals,
-      }),
-    );
+    setSrcTokenBalanceWei(balance);
 
     setIsFetchingBalance(false);
-  }, [address, srcChain, srcToken]);
+  }, [evmAddress, solanaAddress, srcChain, srcToken]);
   // retrieves token details for a given token address and chain from supported tokens mapping. (including imported tokens)
   const findTokenDataByAddressAndChain = useCallback(
     (tokenAddress: string, chainId: string): Token | undefined => {
@@ -724,14 +778,17 @@ export const SwapProvider = ({
   }, [refreshBalance]);
   // fetches user all token balances when a wallet address is available and supported chains are loaded.
   useEffect(() => {
-    if (address && supportedChains.length > 0) {
+    if ((evmAddress || solanaAddress) && supportedChains.length > 0) {
       setIsFetchingBalances(true);
-      getBalances({ walletAddress: address }).then((balances) => {
+      getBalances({
+        walletAddress: evmAddress,
+        solanaWalletAddress: solanaAddress,
+      }).then((balances) => {
         setTokenBalances(balances);
         setIsFetchingBalances(false);
       });
     }
-  }, [address, supportedChains.length]);
+  }, [evmAddress, solanaAddress, supportedChains.length]);
   // sets the fee token from the source chain's tokens by selecting the native token (AddressZero).
   useEffect(() => {
     setFeeToken(
@@ -1152,7 +1209,6 @@ export const SwapProvider = ({
       value={{
         bridgeUI,
         integrationConfig,
-        wagmiConfig,
         supportedChains,
         tab,
         setTab,

package/src/context/TransactionProvider.tsx

@@ -1,3 +1,5 @@
+import { Connection } from "@solana/web3.js";
+import { SOLANA_MAINNET_RPC_URL } from "@src/constants";
 import { Ecosystem, EnqueueTxProps } from "@src/models";
 import { ContractReceipt, ContractTransaction } from "ethers";
 import {
@@ -26,6 +28,12 @@ export interface EvmHandlers {
   onConfirm?: (data?: ContractTransaction) => void;
 }
 
+export interface SolanaHandlers {
+  onSuccess?: (data: string) => void;
+  onError?: <T>(data: T) => void;
+  onConfirm?: (txHash?: string) => void;
+}
+
 export const TransactionProvider = ({ children }: TransactionProviderProps) => {
   const evmTransactionExecutor = useCallback(
     async ({ executeTransaction, handlers }) => {
@@ -48,6 +56,52 @@ export const TransactionProvider = ({ children }: TransactionProviderProps) => {
     },
     [],
   );
+  const customConnection = useMemo(
+    () => new Connection(SOLANA_MAINNET_RPC_URL, "confirmed"),
+    [],
+  );
+  const solanaTransactionExecutor = useCallback(
+    async ({ executeTransaction, handlers }) => {
+      try {
+        const signedTransaction = await executeTransaction();
+
+        if (!signedTransaction) {
+          throw new Error("Transaction is undefined");
+        }
+        handlers?.onConfirm?.(signedTransaction);
+
+        const txHash = await customConnection.sendTransaction(
+          signedTransaction,
+          {
+            skipPreflight: false, // Set to `true` to bypass simulation checks
+            preflightCommitment: "confirmed",
+          },
+        );
+
+        const latestBlockhash = await customConnection.getLatestBlockhash();
+
+        const confirmation = await customConnection.confirmTransaction(
+          {
+            signature: txHash,
+            blockhash: latestBlockhash.blockhash,
+            lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+          },
+          "confirmed", // or "finalized" for stricter confirmation
+        );
+        if (confirmation.value.err) {
+          throw new Error(
+            `Transaction failed: ${JSON.stringify(confirmation.value.err)}`,
+          );
+        }
+        handlers?.onSuccess?.(txHash);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } catch (err: any) {
+        console.error(err);
+        handlers?.onError?.(err);
+      }
+    },
+    [customConnection],
+  );
 
   const enqueueTransaction = useCallback(
     ({
@@ -61,10 +115,15 @@ export const TransactionProvider = ({ children }: TransactionProviderProps) => {
           executeTransaction,
           handlers,
         });
+      } else if (network === Ecosystem.SOLANA) {
+        solanaTransactionExecutor({
+          executeTransaction,
+          handlers,
+        });
       }
       return currentKey;
     },
-    [evmTransactionExecutor],
+    [evmTransactionExecutor, solanaTransactionExecutor],
   );
 
   const state = useMemo<TransactionState>(

package/src/context/TxUIWrapper.tsx

@@ -28,9 +28,13 @@ import {
   useRef,
   useState,
 } from "react";
-import { useAccount } from "wagmi";
 import { useSwapContext } from "./SwapProvider";
-import { EvmHandlers, useTransaction } from "./TransactionProvider";
+import {
+  EvmHandlers,
+  SolanaHandlers,
+  useTransaction,
+} from "./TransactionProvider";
+import { useWallet } from "./WalletProvider";
 
 const TxUIWrapperContext: Context<TxUIWrapperState> =
   createContext<TxUIWrapperState>({} as TxUIWrapperState);
@@ -39,7 +43,9 @@ type Props = {
   children: ReactNode;
 };
 export const TxUIWrapper = ({ children }: Props) => {
-  const { chainId } = useAccount();
+  const { evm, solana } = useWallet();
+  const { chainId } = evm;
+  const { chainId: solanaChainId } = solana;
   const { enqueueTransaction: nativeEnqueueTransaction } = useTransaction();
   const { enqueueSnackbar, closeSnackbar } = useSnackbar();
   const [currentNetwork, setCurrentNetwork] = useState(Ecosystem.EVM);
@@ -175,59 +181,159 @@ export const TxUIWrapper = ({ children }: Props) => {
 
       newHandlers.onSuccess = (result) => {
         closeSnackbar(result?.transactionHash);
+
+        if (txKey.current !== currentKey) {
+          return;
+        }
+
+        setTxReceipt(result);
+        setTxError("");
+        setLoading(false);
+
+        if (handlers?.onSuccess) {
+          handlers.onSuccess(result);
+        }
+
+        if (isTxModalOpenRef.current || !showDefaultSuccessMessage) {
+          return;
+        }
+
+        const snackbarKey = `${txHash}-success`;
+        enqueueSnackbar(
+          <SnackMessage
+            message={{
+              text: `Transaction mined successfully!`,
+              variant: "success",
+              action: () => (
+                <div className="flex items-center flex-nowrap">
+                  <Button
+                    type="button"
+                    onClick={() => {
+                      window.open(
+                        getTxExplorerUrl(
+                          txHash,
+                          supportedChains.find(
+                            (chain) =>
+                              chain.chainId === chainId?.toString() &&
+                              chain.ecosystem === currentNetwork,
+                          )?.transactionExplorer || "",
+                          result,
+                        ),
+                      );
+                    }}
+                  >
+                    View
+                  </Button>
+                  <div
+                    className="fill-t_text_primary w-[14px] h-[14px] cursor-pointer p-[14px] leading-[0px]"
+                    onClick={() => closeSnackbar(snackbarKey)}
+                  >
+                    <CloseIcon />
+                  </div>
+                </div>
+              ),
+            }}
+          />,
+          { persist: false, key: snackbarKey },
+        );
+      };
+
+      newHandlers.onError = (err) => {
         if (txKey.current === currentKey) {
-          setTxReceipt(result);
-          if (!isTxModalOpenRef.current) {
-            if (showDefaultSuccessMessage) {
-              const snackbarKey = `${txHash}-success`;
-              enqueueSnackbar(
-                <SnackMessage
-                  message={{
-                    text: `Transaction mined successfully!`,
-                    variant: "success",
-                    action: () => (
-                      <div className="flex items-center flex-nowrap">
-                        <Button
-                          type="button"
-                          onClick={() => {
-                            window.open(
-                              getTxExplorerUrl(
-                                txHash,
-                                supportedChains.find(
-                                  (chain) =>
-                                    chain.chainId === chainId?.toString() &&
-                                    chain.ecosystem === currentNetwork,
-                                )?.transactionExplorer || "",
-                                result,
-                              ),
-                            );
-                          }}
-                        >
-                          View
-                        </Button>
-
-                        <div
-                          className="fill-t_text_primary w-[14px] h-[14px] cursor-pointer p-[14px] leading-[0px]"
-                          onClick={() => closeSnackbar(snackbarKey)}
-                        >
-                          <CloseIcon />
-                        </div>
-                      </div>
-                    ),
-                  }}
-                />,
-                { persist: false, key: snackbarKey },
-              );
-            }
-          }
-          if (handlers?.onSuccess) {
-            handlers?.onSuccess(result);
-          }
-          setTxError("");
+          setTxError(parseWeb3Error(err));
+          handlers?.onError?.(err);
           setLoading(false);
         }
       };
 
+      return newHandlers;
+    },
+    [
+      closeSnackbar,
+      txHash,
+      enqueueSnackbar,
+      getTxExplorerUrl,
+      supportedChains,
+      chainId,
+      currentNetwork,
+    ],
+  );
+
+  const addUILogicToHandlersSolana = useCallback(
+    (
+      currentKey: number,
+      handlers?: SolanaHandlers,
+      showDefaultSuccessMessage = true,
+    ): SolanaHandlers => {
+      const newHandlers: SolanaHandlers = { ...handlers };
+
+      newHandlers.onConfirm = (signedTransaction) => {
+        if (txKey.current === currentKey) {
+          if (handlers?.onConfirm) {
+            handlers?.onConfirm(signedTransaction);
+          }
+          setTxStatus((prevStatus) => prevStatus + 1);
+        }
+      };
+
+      newHandlers.onSuccess = (transactionHash) => {
+        closeSnackbar(transactionHash);
+
+        if (txKey.current !== currentKey) {
+          return;
+        }
+
+        if (handlers?.onSuccess) {
+          handlers?.onSuccess(transactionHash);
+        }
+        setTxHash(transactionHash || "");
+        setTxError("");
+        setLoading(false);
+
+        if (isTxModalOpenRef.current || !showDefaultSuccessMessage) {
+          return;
+        }
+
+        const snackbarKey = `${txHash}-success`;
+        enqueueSnackbar(
+          <SnackMessage
+            message={{
+              text: `Transaction mined successfully!`,
+              variant: "success",
+              action: () => (
+                <div className="flex items-center flex-nowrap">
+                  <Button
+                    type="button"
+                    onClick={() => {
+                      window.open(
+                        getTxExplorerUrl(
+                          txHash,
+                          supportedChains.find(
+                            (chain) =>
+                              chain.chainId === solanaChainId?.toString() &&
+                              chain.ecosystem === currentNetwork,
+                          )?.transactionExplorer || "",
+                        ),
+                      );
+                    }}
+                  >
+                    View
+                  </Button>
+
+                  <div
+                    className="fill-t_text_primary w-[14px] h-[14px] cursor-pointer p-[14px] leading-[0px]"
+                    onClick={() => closeSnackbar(snackbarKey)}
+                  >
+                    <CloseIcon />
+                  </div>
+                </div>
+              ),
+            }}
+          />,
+          { persist: false, key: snackbarKey },
+        );
+      };
+
       newHandlers.onError = (err) => {
         if (txKey.current === currentKey) {
           setTxError(parseWeb3Error(err));
@@ -244,7 +350,7 @@ export const TxUIWrapper = ({ children }: Props) => {
       enqueueSnackbar,
       getTxExplorerUrl,
       supportedChains,
-      chainId,
+      solanaChainId,
       currentNetwork,
     ],
   );
@@ -267,6 +373,12 @@ export const TxUIWrapper = ({ children }: Props) => {
           handlers as EvmHandlers,
           showDefaultSuccessMessage,
         );
+      } else if (network === Ecosystem.SOLANA) {
+        newHandlers = addUILogicToHandlersSolana(
+          currentKey,
+          handlers as SolanaHandlers,
+          showDefaultSuccessMessage,
+        );
       }
 
       // extracted tx logic
@@ -290,29 +402,33 @@ export const TxUIWrapper = ({ children }: Props) => {
 
       return currentKey;
     },
-    [addUILogicToHandlersEVM, nativeEnqueueTransaction],
+    [
+      addUILogicToHandlersEVM,
+      addUILogicToHandlersSolana,
+      nativeEnqueueTransaction,
+    ],
   );
 
-  const txExplorerUrl = useMemo(
-    () =>
-      getTxExplorerUrl(
-        txHash,
-        supportedChains.find(
-          (chain) =>
-            chain.chainId === chainId?.toString() &&
-            chain.ecosystem === currentNetwork,
-        )?.transactionExplorer || "",
-        txReceipt,
-      ),
-    [
-      chainId,
-      currentNetwork,
-      getTxExplorerUrl,
-      supportedChains,
+  const txExplorerUrl = useMemo(() => {
+    return getTxExplorerUrl(
       txHash,
+      supportedChains.find(
+        (chain) =>
+          (chain.chainId === chainId?.toString() ||
+            chain.chainId === solanaChainId?.toString()) &&
+          chain.ecosystem === currentNetwork,
+      )?.transactionExplorer || "",
       txReceipt,
-    ],
-  );
+    );
+  }, [
+    chainId,
+    solanaChainId,
+    currentNetwork,
+    getTxExplorerUrl,
+    supportedChains,
+    txHash,
+    txReceipt,
+  ]);
 
   const setModalOpen = useCallback((flag: boolean) => {
     setTxModalOpen(flag);