@xswap-link/sdk 0.13.0 → 0.13.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xswap-link/sdk",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "description": "JavaScript SDK for XSwap platform",
   "homepage": "https://github.com/xswap-link/xswap-sdk",
   "repository": {

package/src/components/Swap/SwapView/ConfirmationView/TxOverview/index.tsx

@@ -222,7 +222,7 @@ export const TxOverview = ({ onCloseClick }: Props) => {
             handlers: {
               onSuccess: (data) => {
                 setTxStatus(TxStatus.COMPLETED);
-                refreshBalance();
+                refreshBalance({ forceRpc: true });
                 trackTransaction(data);
                 if (
                   srcChain?.chainId &&
@@ -400,7 +400,7 @@ export const TxOverview = ({ onCloseClick }: Props) => {
           handlers: {
             onSuccess: () => {
               setTxStatus(TxStatus.COMPLETED);
-              refreshBalance();
+              refreshBalance({ forceRpc: true });
             },
           },
           network: Ecosystem.SOLANA,

package/src/context/SwapProvider.tsx

@@ -117,7 +117,7 @@ type SwapContext = {
   isFetchingBalances: boolean;
   isExpressDeliveryActive: boolean;
   quoteRoute: () => Promise<void>;
-  refreshBalance: () => void;
+  refreshBalance: (options?: { forceRpc?: boolean }) => void;
   findTokenDataByAddressAndChain: (
     tokenAddress: string,
     chainId: string,
@@ -279,6 +279,7 @@ export const SwapProvider = ({
 
   const routeAbortController = useRef<AbortController | null>(null);
   const refreshSelectedTokenBalanceNonce = useRef(crypto.randomUUID());
+  const prevWalletAddresses = useRef<string | undefined>(undefined);
 
   // =============================================================================
   // Memoized Values
@@ -668,77 +669,96 @@ export const SwapProvider = ({
     srcValueWei,
   ]);
   // refreshes and updates the balance of the source token using its RPC URL.
-  const refreshBalance = useCallback(async () => {
-    if (
-      (!evmAddress && !solanaAddress) ||
-      !srcChain?.publicRpcUrls[0] ||
-      !srcToken ||
-      !srcToken?.address
-    ) {
-      return;
-    }
-
-    const nonce = crypto.randomUUID();
-    refreshSelectedTokenBalanceNonce.current = nonce;
-    setIsFetchingBalance(true);
-    let balance = "0";
-    if (srcChain?.ecosystem === Ecosystem.EVM && evmAddress) {
-      const balanceFromBackend =
-        tokenBalances[srcChain?.chainId]?.[srcToken.address];
-      if (balanceFromBackend === undefined) {
-        const balanceUI = await getBalanceOf(
-          evmAddress,
-          srcToken.address,
-          srcChain?.publicRpcUrls[0],
-        );
-        balance = humanReadableToWei({
-          amount: balanceUI,
-          decimals: srcToken.decimals,
-        });
-      } else {
-        balance = balanceFromBackend;
+  // pass { forceRpc: true } to skip the backend balances cache (e.g. right
+  // after a transaction, when the cached value is already stale).
+  const refreshBalance = useCallback(
+    async (options?: { forceRpc?: boolean }) => {
+      if (
+        (!evmAddress && !solanaAddress) ||
+        !srcChain?.publicRpcUrls[0] ||
+        !srcToken ||
+        !srcToken?.address
+      ) {
+        return;
       }
-    } 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 token2022Accounts =
-          await connection.getParsedTokenAccountsByOwner(solanaPublicKey, {
-            programId: SOLANA_TOKEN_2022_PROGRAM_ID,
+
+      const nonce = crypto.randomUUID();
+      refreshSelectedTokenBalanceNonce.current = nonce;
+      setIsFetchingBalance(true);
+      let balance = "0";
+      if (srcChain?.ecosystem === Ecosystem.EVM && evmAddress) {
+        const balanceFromBackend =
+          tokenBalances[srcChain?.chainId]?.[srcToken.address];
+        if (options?.forceRpc || balanceFromBackend === undefined) {
+          const balanceUI = await getBalanceOf(
+            evmAddress,
+            srcToken.address,
+            srcChain?.publicRpcUrls[0],
+          );
+          balance = humanReadableToWei({
+            amount: balanceUI,
+            decimals: srcToken.decimals,
           });
-        const allTokenAccount = [
-          ...tokenAccounts.value,
-          ...token2022Accounts.value,
-        ];
-        const tokenAccount = allTokenAccount.find(
-          (account) =>
-            account.account.data.parsed.info.mint === srcToken.address,
-        );
-        if (!tokenAccount) {
-          balance = "0";
+          if (options?.forceRpc && balanceFromBackend !== undefined) {
+            // keep the backend cache in sync so token pickers and future
+            // non-forced refreshes see the fresh value
+            const chainId = srcChain.chainId;
+            const tokenAddress = srcToken.address;
+            const freshBalance = balance;
+            setTokenBalances((prev) => ({
+              ...prev,
+              [chainId]: {
+                ...prev[chainId],
+                [tokenAddress]: freshBalance,
+              },
+            }));
+          }
         } else {
-          balance = tokenAccount.account.data.parsed.info.tokenAmount.amount;
+          balance = balanceFromBackend;
+        }
+      } 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 token2022Accounts =
+            await connection.getParsedTokenAccountsByOwner(solanaPublicKey, {
+              programId: SOLANA_TOKEN_2022_PROGRAM_ID,
+            });
+          const allTokenAccount = [
+            ...tokenAccounts.value,
+            ...token2022Accounts.value,
+          ];
+          const tokenAccount = allTokenAccount.find(
+            (account) =>
+              account.account.data.parsed.info.mint === srcToken.address,
+          );
+          if (!tokenAccount) {
+            balance = "0";
+          } else {
+            balance = tokenAccount.account.data.parsed.info.tokenAmount.amount;
+          }
         }
       }
-    }
-    if (nonce !== refreshSelectedTokenBalanceNonce.current) {
-      return;
-    }
+      if (nonce !== refreshSelectedTokenBalanceNonce.current) {
+        return;
+      }
 
-    setSrcTokenBalanceWei(balance);
+      setSrcTokenBalanceWei(balance);
 
-    setIsFetchingBalance(false);
-  }, [evmAddress, solanaAddress, srcChain, srcToken, tokenBalances]);
+      setIsFetchingBalance(false);
+    },
+    [evmAddress, solanaAddress, srcChain, srcToken, tokenBalances],
+  );
   // 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 => {
@@ -801,9 +821,16 @@ export const SwapProvider = ({
     quoteRoute();
   }, [quoteRoute]);
   // calls refreshBalance to update source token balance on mount or when refreshBalance changes.
+  // when the connected wallet changed, force an RPC read — the cached backend
+  // balances still belong to the previous wallet until getBalances resolves.
   useEffect(() => {
-    refreshBalance();
-  }, [refreshBalance]);
+    const walletAddresses = `${evmAddress ?? ""}:${solanaAddress ?? ""}`;
+    const walletChanged =
+      prevWalletAddresses.current !== undefined &&
+      prevWalletAddresses.current !== walletAddresses;
+    prevWalletAddresses.current = walletAddresses;
+    refreshBalance(walletChanged ? { forceRpc: true } : undefined);
+  }, [refreshBalance, evmAddress, solanaAddress]);
   // fetches user all token balances when a wallet address is available and supported chains are loaded.
   useEffect(() => {
     let isCancelled = false;