@xswap-link/sdk 0.12.2 → 0.13.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xswap-link/sdk",
-  "version": "0.12.2",
+  "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

@@ -11,11 +11,7 @@ import {
   crosschainEstimationTimes,
 } from "@src/constants";
 import { useHistory, useSwapContext, useTxUIWrapper } from "@src/context";
-import {
-  ADDRESSES,
-  CustomXSwapRouterAbi,
-  XSwapRouterAbi,
-} from "@src/contracts";
+import { ADDRESSES, XSwapRouterAbi } from "@src/contracts";
 import { useEvmContractApi } from "@src/hooks";
 import useNetworks from "@src/hooks/networkManagement/useNetworks";
 import {
@@ -131,11 +127,6 @@ export const TxOverview = ({ onCloseClick }: Props) => {
           "MessageSent(bytes32,uint64,address,bytes,address,uint256,uint256,address,uint256)"; // TODO think of getting this signature in a different way becase its easy to forgot about it when we will change event on smartcontract
         const messageReceivedEventSignature =
           "MessageReceived(bytes32,uint64,address,bytes,address,uint256)"; // TODO think of getting this signature in a different way because its easy to forgot about it when we will change event on smartcontract
-        // cross-chain bridge via custom xswap router
-        const messageSentXSwapCustomRouterEventSignature =
-          "MessageSent(bytes32,uint64,address,address,address,address,uint256)"; // TODO think of getting this signature in a different way becase its easy to forgot about it when we will change event on smartcontract
-        const messageReceivedXSwapCustomRouterEventSignature =
-          "MessageReceived(bytes32,uint64,address,bytes)"; // TODO think of getting this signature in a different way because its easy to forgot about it when we will change event on smartcontract
 
         const destinationChainProvider = ethers.getDefaultProvider(
           supportedChains.find(
@@ -146,7 +137,6 @@ export const TxOverview = ({ onCloseClick }: Props) => {
         );
 
         const handleMessageEvent = async (
-          contractKey: "XSwapRouter" | "CustomXSwapRouter",
           messageSentEventSignature: string,
           messageReceivedEventSignature: string,
         ) => {
@@ -159,15 +149,13 @@ export const TxOverview = ({ onCloseClick }: Props) => {
             transactionData.messageId = messageId;
 
             const xSwapRouterOnDestination = new ethers.Contract(
-              ADDRESSES[dstChain!.chainId]![contractKey]!,
-              contractKey === "XSwapRouter"
-                ? XSwapRouterAbi
-                : CustomXSwapRouterAbi,
+              ADDRESSES[dstChain!.chainId]!.XSwapRouter!,
+              XSwapRouterAbi,
               destinationChainProvider,
             );
 
             const eventFilter = {
-              address: ADDRESSES[dstChain.chainId]?.[contractKey],
+              address: ADDRESSES[dstChain.chainId]?.XSwapRouter,
               topics: [
                 ethers.utils.id(messageReceivedEventSignature),
                 messageId,
@@ -194,16 +182,9 @@ export const TxOverview = ({ onCloseClick }: Props) => {
         };
 
         await handleMessageEvent(
-          "XSwapRouter",
           messageSentEventSignature,
           messageReceivedEventSignature,
         );
-
-        await handleMessageEvent(
-          "CustomXSwapRouter",
-          messageSentXSwapCustomRouterEventSignature,
-          messageReceivedXSwapCustomRouterEventSignature,
-        );
       }
 
       addTransactionToLocalHistory(transactionData, txReceipt.from);
@@ -241,7 +222,7 @@ export const TxOverview = ({ onCloseClick }: Props) => {
             handlers: {
               onSuccess: (data) => {
                 setTxStatus(TxStatus.COMPLETED);
-                refreshBalance();
+                refreshBalance({ forceRpc: true });
                 trackTransaction(data);
                 if (
                   srcChain?.chainId &&
@@ -419,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

@@ -8,7 +8,7 @@ import {
   SOLANA_TOKEN_2022_PROGRAM_ID,
   SOLANA_TOKEN_PROGRAM_ID,
 } from "@src/constants";
-import { ADDRESSES } from "@src/contracts";
+import { ADDRESSES, resolveBridgeDisplayToken } from "@src/contracts";
 import {
   BridgeToken,
   BridgeTokensDictionary,
@@ -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
@@ -383,8 +384,15 @@ export const SwapProvider = ({
         // Skip invalid token pairs.
         continue;
       }
-      const [chainId0, address0] = entries[0]!;
-      const [chainId1, address1] = entries[1]!;
+      const [chainId0, rawAddress0] = entries[0]!;
+      const [chainId1, rawAddress1] = entries[1]!;
+
+      // Some pairs use an internal, CCIP-connected token (e.g. a wrapped
+      // variant) that the backend relies on for routing. In the bridge UI we
+      // display/select the user-facing token instead; the backend wraps it into
+      // the CCIP token when building the route.
+      const address0 = resolveBridgeDisplayToken(chainId0, rawAddress0);
+      const address1 = resolveBridgeDisplayToken(chainId1, rawAddress1);
 
       addMapping(chainId0, address0, chainId1, address1);
       addMapping(chainId1, address1, chainId0, address0);
@@ -661,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 => {
@@ -794,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;

package/src/contracts/abi/index.ts

@@ -2,12 +2,10 @@ import BatchQuery from "./BatchQuery.json";
 import ERC20 from "./ERC20.json";
 import XSwapRouter from "./XSwapRouter.json";
 import XSwapTokenFeeDistributor from "./XSwapTokenFeeDistributor.json";
-import CustomXSwapRouter from "./CustomXSwapRouter.json";
 import StakingStableAPR from "./StakingStableAPR.json";
 
 export const BatchQueryAbi = BatchQuery;
 export const ERC20Abi = ERC20;
 export const XSwapRouterAbi = XSwapRouter;
 export const XSwapTokenFeeDistributorAbi = XSwapTokenFeeDistributor;
-export const CustomXSwapRouterAbi = CustomXSwapRouter;
 export const StakingStableAPRAbi = StakingStableAPR;

package/src/contracts/addresses.ts

@@ -23,8 +23,6 @@ export const ADDRESSES: Addresses = {
   "8453": {
     [ContractName.USDC]: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
     [ContractName.BatchQuery]: "0xb5f9934ea0810ef5faa677e8c68c6983b88664b1",
-    [ContractName.CustomXSwapRouter]:
-      "0x9B64aC0aD647768838a3957Bc12c40E1C539cb93",
     [ContractName.FeeCollector]: "0xb37275558f02f05104c2ba35199d16adeb43432f",
     [ContractName.StakingCosmicCadets]:
       "0x67798736bFb7d9A1F143215E258fe15Da68c85F0",
@@ -41,8 +39,6 @@ export const ADDRESSES: Addresses = {
   "1": {
     [ContractName.USDC]: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
     [ContractName.BatchQuery]: "0xb5f9934ea0810ef5faa677e8c68c6983b88664b1",
-    [ContractName.CustomXSwapRouter]:
-      "0x9B64aC0aD647768838a3957Bc12c40E1C539cb93",
     [ContractName.FeeCollector]: "0xb37275558f02f05104c2ba35199d16adeb43432f",
     [ContractName.XSwapRouter]: "0xe1c14b9f065dead2e89ee35382f8bd42bdb87a04",
     [ContractName.XSwapToken]: "0x8fe815417913a93ea99049fc0718ee1647a2a07c",

package/src/contracts/bridgeDisplayTokens.ts

@@ -0,0 +1,46 @@
+/**
+ * Bridge UI display overrides.
+ *
+ * Some tokens returned by the `/bridgeTokens` endpoint are internal,
+ * directly-CCIP-connected tokens (e.g. a wrapped variant) that the backend
+ * relies on for routing, but that we do NOT want users to see or pick in the
+ * bridge UI. This map replaces such a CCIP token with the user-facing token we
+ * display and let users select / hold instead.
+ *
+ * The backend accepts the user-facing token in `/route` and wraps it into the
+ * CCIP token under the hood (e.g. real USDC -> XSwapUSDC via the wrapper), so
+ * the selected token is what flows through balances, approval and the route
+ * request, while the actual cross-chain hop still uses the CCIP token.
+ *
+ * Shape: { [chainId]: { [ccipTokenAddressLowercased]: displayTokenAddressLowercased } }
+ *
+ * IMPORTANT: addresses must be lowercased on both sides — the bridge dictionary
+ * and its consumers compare EVM addresses lowercased.
+ */
+export const bridgeDisplayTokenOverrides: Record<
+  string,
+  Record<string, string>
+> = {
+  // base: XSwapUSDC -> real USDC
+  "8453": {
+    "0x5426188a207fd0365dca5cff345059ff531d1aa7":
+      "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+  },
+};
+
+/**
+ * Returns the user-facing token address to display in the bridge UI for a given
+ * `/bridgeTokens` entry, or the original address when there is no override.
+ *
+ * EVM addresses are matched case-insensitively; non-EVM addresses (e.g. Solana)
+ * are returned untouched.
+ */
+export const resolveBridgeDisplayToken = (
+  chainId: string,
+  tokenAddress: string,
+): string => {
+  return (
+    bridgeDisplayTokenOverrides[chainId]?.[tokenAddress.toLowerCase()] ??
+    tokenAddress
+  );
+};

package/src/contracts/index.ts

@@ -1,2 +1,3 @@
 export * from "./abi";
 export * from "./addresses";
+export * from "./bridgeDisplayTokens";

package/src/models/Addresses.ts

@@ -9,7 +9,6 @@ export type Contracts = Partial<{
 export enum ContractName {
   USDC = "USDC",
   BatchQuery = "BatchQuery",
-  CustomXSwapRouter = "CustomXSwapRouter",
   FeeCollector = "FeeCollector",
   StakingCosmicCadets = "StakingCosmicCadets",
   StakingSolarDivision = "StakingSolarDivision",