@xswap-link/sdk 0.10.5 → 0.10.7

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);

package/src/context/WalletProvider.tsx

@@ -0,0 +1,108 @@
+import React, {
+  Context,
+  createContext,
+  Dispatch,
+  useCallback,
+  useContext,
+  useMemo,
+  useState,
+} from "react";
+import { useAccount, useConnect, useDisconnect } from "wagmi";
+import { useWallet as useSolanaWallet } from "@solana/wallet-adapter-react";
+import { SolanaWeb3Network } from "@src/models";
+
+interface WalletInfo {
+  address: string | undefined;
+  isConnected: boolean;
+  chainId: string | undefined;
+  connectWallet: () => Promise<void>;
+  disconnectWallet: () => Promise<void>;
+}
+export interface WalletState {
+  openEVMWalletModal: boolean;
+  setOpenEVMWalletModal: Dispatch<React.SetStateAction<boolean>>;
+  openSolanaWalletModal: boolean;
+  setOpenSolanaWalletModal: Dispatch<React.SetStateAction<boolean>>;
+  evm: WalletInfo;
+  solana: WalletInfo;
+}
+
+// Wallet Context
+const WalletContext: Context<WalletState> = createContext<WalletState>(
+  {} as WalletState,
+);
+
+export const WalletProvider = ({ children }) => {
+  const [openEVMWalletModal, setOpenEVMWalletModal] = useState(false);
+  const [openSolanaWalletModal, setOpenSolanaWalletModal] = useState(false);
+
+  const {
+    address: evmAddress,
+    isConnected: isEvmConnected,
+    chainId: evmChainId,
+  } = useAccount();
+  const { connect, connectors } = useConnect();
+  const { disconnect: evmDisconnect } = useDisconnect();
+
+  const solanaWallet = useSolanaWallet();
+
+  const connectEvmWallet = useCallback(async () => {
+    connect({ connector: connectors[0]! }); // Default to MetaMask
+  }, [connect, connectors]);
+
+  const connectSolanaWallet = useCallback(async () => {
+    await solanaWallet.connect();
+  }, [solanaWallet]);
+
+  const disconnectEvmWallet = useCallback(
+    () => new Promise<void>((resolve) => resolve(evmDisconnect())),
+    [evmDisconnect],
+  );
+  const disconnectSolanaWallet = useCallback(
+    () => solanaWallet.disconnect(),
+    [solanaWallet],
+  );
+  const state = useMemo(() => {
+    return {
+      evm: {
+        address: evmAddress?.toString(),
+        isConnected: isEvmConnected,
+        chainId: evmChainId?.toString(),
+        connectWallet: connectEvmWallet,
+        disconnectWallet: disconnectEvmWallet,
+      },
+      solana: {
+        address: solanaWallet.publicKey?.toBase58(),
+        isConnected: !!solanaWallet.publicKey,
+        chainId: SolanaWeb3Network.MAINNET,
+        connectWallet: connectSolanaWallet,
+        disconnectWallet: disconnectSolanaWallet,
+      },
+    };
+  }, [
+    evmAddress,
+    isEvmConnected,
+    evmChainId,
+    connectEvmWallet,
+    disconnectEvmWallet,
+    solanaWallet.publicKey,
+    connectSolanaWallet,
+    disconnectSolanaWallet,
+  ]);
+  return (
+    <WalletContext.Provider
+      value={{
+        openEVMWalletModal,
+        setOpenEVMWalletModal,
+        openSolanaWalletModal,
+        setOpenSolanaWalletModal,
+        ...state,
+      }}
+    >
+      {children}
+    </WalletContext.Provider>
+  );
+};
+
+// Custom Hook
+export const useWallet = () => useContext(WalletContext);

package/src/contracts/addresses.ts

@@ -179,4 +179,8 @@ export const ADDRESSES: Addresses = {
     [ContractName.XSwapRouterSingleChain]:
       "0x0bb24c4302889ea0fb22dfacbb845e5602f35972",
   },
+  // solana
+  "mainnet-beta": {
+    [ContractName.FeeCollector]: "XSwapfFzSz84kkGk5PCYzLrntPfLubFRJGbJRQjC7th",
+  },
 };