@xswap-link/sdk 0.10.5 → 0.10.7

package/src/context/HistoryProvider.tsx

@@ -1,13 +1,19 @@
+import { Connection, PublicKey } from "@solana/web3.js";
 import { CloseIcon } from "@src/assets/icons";
 import { Button, SnackMessage } from "@src/components";
 import {
   CCIP_EXPLORER,
   FALLBACK_CROSSCHAIN_ESTIMATION_TIME,
+  SOLANA_MAINNET_RPC_URL,
   crosschainEstimationTimes,
 } from "@src/constants";
+import { useWallet } from "@src/context/WalletProvider";
 import { useDebounce } from "@src/hooks";
 import { Transaction, TransactionStatus } from "@src/models";
+import { TransactionWithMeta } from "@src/models/SolanaTransaction";
 import { getHistory } from "@src/services";
+import { extractSolanaSwapData } from "@src/services/solana/jupiter/extract-swap-data";
+import { isJupiterTransaction } from "@src/services/solana/jupiter/utils";
 import { isServer } from "@src/utils";
 import BigNumberJS from "bignumber.js";
 import { useSnackbar } from "notistack";
@@ -21,7 +27,6 @@ import {
   useMemo,
   useState,
 } from "react";
-import { useAccount } from "wagmi";
 
 export interface HistoryState {
   history: Transaction[];
@@ -34,6 +39,8 @@ export interface HistoryState {
     userAddress: string,
   ) => void;
   historyLoadedOnce: boolean;
+  solanaHistory: Transaction[];
+  solanaHistoryLoadedOnce: boolean;
 }
 
 const HistoryContext: Context<HistoryState> = createContext<HistoryState>(
@@ -63,11 +70,48 @@ const setLocalHistory = (data: LocalHistory) => {
   }
 };
 
+async function processSolanaTransactions(
+  transactions: (TransactionWithMeta | null)[],
+): Promise<Transaction[]> {
+  const results: Transaction[] = [];
+
+  for (let i = 0; i < transactions.length; i++) {
+    try {
+      const tx = transactions[i];
+      if (!tx) continue;
+
+      const signature = tx.transaction.signatures[0];
+
+      if (!signature) continue;
+
+      const connection = new Connection(SOLANA_MAINNET_RPC_URL, "confirmed");
+
+      const swapDetails = await extractSolanaSwapData(
+        signature,
+        connection,
+        tx,
+      );
+
+      if (swapDetails) {
+        results.push(swapDetails);
+      }
+    } catch (error) {
+      console.error(`Error processing transaction:`, error);
+    }
+  }
+
+  return results;
+}
+
 export const HistoryProvider = ({ children }: HistoryProviderProps) => {
-  const { address } = useAccount();
+  const { evm, solana } = useWallet();
+  const { address: address } = evm;
+  const { address: solanaAddress } = solana;
 
+  const [solanaHistory, setSolanaHistory] = useState<Transaction[]>([]);
   const [history, setHistory] = useState<Transaction[]>([]);
   const [historyLoadedOnce, setHistoryLoadedOnce] = useState(false);
+  const [solanaHistoryLoadedOnce, setSolanaHistoryLoadedOnce] = useState(false);
 
   const { enqueueSnackbar, closeSnackbar } = useSnackbar();
   const { debounce: getHistoryDebounce } = useDebounce({
@@ -82,16 +126,70 @@ export const HistoryProvider = ({ children }: HistoryProviderProps) => {
     }
   }, []);
 
+  const fetchLastSignatures = async (senderAddress: string, limit = 50) => {
+    const connection = new Connection(SOLANA_MAINNET_RPC_URL, "confirmed");
+    const userPubkey = new PublicKey(senderAddress);
+
+    try {
+      const signatures = await connection.getSignaturesForAddress(userPubkey, {
+        limit,
+      });
+
+      const transactions = await connection.getParsedTransactions(
+        signatures.map((s) => s.signature),
+        {
+          maxSupportedTransactionVersion: 0,
+        },
+      );
+
+      const jupiterTransactions = transactions
+        .filter((val) => !!val)
+        .filter((tx) => isJupiterTransaction(tx));
+
+      const swapDetails = await processSolanaTransactions(
+        jupiterTransactions as TransactionWithMeta[],
+      );
+      return swapDetails;
+    } catch (error) {
+      console.error("Error fetching transactions:", error);
+      return [];
+    }
+  };
+
+  const fetchSolanaHistory = async () => {
+    if (!solanaAddress) {
+      setSolanaHistoryLoadedOnce(true);
+      return;
+    }
+
+    try {
+      const lastSignatures = await fetchLastSignatures(solanaAddress);
+      setSolanaHistory(lastSignatures);
+    } finally {
+      setSolanaHistoryLoadedOnce(true);
+    }
+  };
+
+  useEffect(() => {
+    if (solanaAddress) {
+      fetchSolanaHistory();
+    } else {
+      setSolanaHistory([]);
+      setSolanaHistoryLoadedOnce(true);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [solanaAddress]);
+
   const fetchHistory = useCallback(async () => {
     try {
       if (!address) {
         return;
       }
 
+      const fetchedTransactions: Transaction[] = [];
       const fetchedHistory = await getHistory({
         walletAddress: address,
       });
-      const fetchedTransactions: Transaction[] = [];
 
       for (const entry of fetchedHistory.history) {
         if (!entry.source) {
@@ -158,15 +256,16 @@ export const HistoryProvider = ({ children }: HistoryProviderProps) => {
       for (const [walletAddress, transactions] of Object.entries(
         localHistory,
       )) {
-        if (
-          walletAddress.toLowerCase().toLowerCase() !== address.toLowerCase()
-        ) {
+        if (walletAddress.toLowerCase() !== address.toLowerCase()) {
           continue;
         }
         const newLocalHistoryForWallet: Transaction[] = [];
 
         for (const transaction of transactions) {
-          if (!txHashToTxFromAPI[transaction.hash]) {
+          const txHash = transaction.hash;
+          const apiTransaction = txHashToTxFromAPI[txHash];
+
+          if (!apiTransaction) {
             // localStorage has fresher data.
             fetchedTransactions.push(transaction);
             newLocalHistoryForWallet.push(transaction);
@@ -174,20 +273,17 @@ export const HistoryProvider = ({ children }: HistoryProviderProps) => {
           }
 
           if (
-            txHashToTxFromAPI[transaction.hash] &&
+            apiTransaction &&
             transaction.status === "DONE" &&
-            txHashToTxFromAPI[transaction.hash]?.status === "IN_PROGRESS"
+            apiTransaction?.status === "IN_PROGRESS"
           ) {
             // If we know on the frontend that the tx is done we should update backend result
-            // @ts-ignore
-            txHashToTxFromAPI[transaction.hash].status = "DONE";
+            apiTransaction.status = "DONE";
           }
 
           if (
-            // @ts-ignore
-            txHashToTxFromAPI[transaction.hash].status === "DONE" ||
-            // @ts-ignore
-            txHashToTxFromAPI[transaction.hash].status === "REVERTED"
+            apiTransaction.status === "DONE" ||
+            apiTransaction.status === "REVERTED"
           ) {
             // API has the same or newer data.
             continue;
@@ -212,7 +308,7 @@ export const HistoryProvider = ({ children }: HistoryProviderProps) => {
     } finally {
       setHistoryLoadedOnce(true);
     }
-  }, [address, getHistory, enqueueSnackbar]);
+  }, [address, enqueueSnackbar]);
 
   useEffect(() => {
     if (!historyLoadedOnce) {
@@ -222,13 +318,7 @@ export const HistoryProvider = ({ children }: HistoryProviderProps) => {
       getHistoryDebounce(fetchHistory);
     }, 60000);
     return () => clearInterval(timer);
-  }, [
-    address,
-    fetchHistory,
-    getHistory,
-    getHistoryDebounce,
-    historyLoadedOnce,
-  ]);
+  }, [address, fetchHistory, getHistoryDebounce, historyLoadedOnce]);
 
   const addTransactionToLocalHistory = useCallback(
     (transaction: Transaction, userAddress: string) => {
@@ -281,7 +371,7 @@ export const HistoryProvider = ({ children }: HistoryProviderProps) => {
         { persist: false, key: messageId },
       );
     },
-    [enqueueSnackbar],
+    [closeSnackbar, enqueueSnackbar],
   );
 
   const updateTransactionInLocalHistory = useCallback(
@@ -319,8 +409,10 @@ export const HistoryProvider = ({ children }: HistoryProviderProps) => {
 
   useEffect(() => {
     setHistoryLoadedOnce(false);
+    setSolanaHistoryLoadedOnce(false);
     setHistory([]);
-  }, [address]);
+    setSolanaHistory([]);
+  }, [address, solanaAddress]);
 
   const state = useMemo<HistoryState>(
     () => ({
@@ -328,12 +420,16 @@ export const HistoryProvider = ({ children }: HistoryProviderProps) => {
       addTransactionToLocalHistory,
       updateTransactionInLocalHistory,
       historyLoadedOnce,
+      solanaHistory,
+      solanaHistoryLoadedOnce,
     }),
     [
       history,
       addTransactionToLocalHistory,
       updateTransactionInLocalHistory,
       historyLoadedOnce,
+      solanaHistory,
+      solanaHistoryLoadedOnce,
     ],
   );
 

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>(