@multiversx/sdk-dapp-liquidity 2.0.0 → 2.1.0-alpha.0

package/reactjs/hooks/tests/useSignTransaction.spec.mjs

@@ -0,0 +1,194 @@
+import { useAppKitProvider, useAppKitAccount } from "@reown/appkit/react";
+import { r as renderHook } from "../../../react.esm-CU-Iqz8D.mjs";
+import { useSendTransaction } from "wagmi";
+import { useSignTransaction } from "../useSignTransaction.mjs";
+jest.mock("@reown/appkit-adapter-solana/react", () => ({
+  useAppKitConnection: jest.fn(() => ({ connection: null }))
+}));
+jest.mock("@solana/web3.js", () => ({
+  PublicKey: jest.fn(),
+  Transaction: jest.fn(() => ({ add: jest.fn().mockReturnThis() })),
+  TransactionInstruction: jest.fn()
+}));
+const mockUseAppKitProvider = jest.mocked(useAppKitProvider);
+const mockUseAppKitAccount = jest.mocked(useAppKitAccount);
+const mockUseSendTransaction = jest.mocked(useSendTransaction);
+beforeEach(() => {
+  mockUseSendTransaction.mockReturnValue({
+    data: void 0,
+    sendTransactionAsync: jest.fn(),
+    error: null,
+    isError: false,
+    isIdle: true,
+    isPending: false,
+    isSuccess: false,
+    reset: jest.fn(),
+    sendTransaction: jest.fn(),
+    status: "idle",
+    variables: void 0,
+    context: void 0,
+    failureCount: 0,
+    failureReason: null,
+    isPaused: false,
+    submittedAt: 0,
+    mutate: jest.fn(),
+    mutateAsync: jest.fn()
+  });
+});
+const CONNECTED_SUI_ADDRESS = "0xabc123def456aaa000111222333444555666777888999aaabbbcccdddeeefff00";
+function setupSuiMocks(suiRequest) {
+  mockUseAppKitProvider.mockImplementation((namespace) => {
+    if (namespace === "sui") {
+      return { walletProvider: { request: suiRequest } };
+    }
+    return { walletProvider: void 0 };
+  });
+  mockUseAppKitAccount.mockImplementation((opts) => {
+    if ((opts == null ? void 0 : opts.namespace) === "sui") {
+      return {
+        address: CONNECTED_SUI_ADDRESS,
+        isConnected: true,
+        status: "connected"
+      };
+    }
+    return {
+      address: void 0,
+      isConnected: false,
+      status: "disconnected"
+    };
+  });
+}
+describe("useSignTransaction — signSuiTransaction", () => {
+  const validBase64 = btoa("valid transaction bytes");
+  beforeEach(() => {
+    mockUseSendTransaction.mockReturnValue({
+      data: void 0,
+      sendTransactionAsync: jest.fn(),
+      error: null,
+      isError: false,
+      isIdle: true,
+      isPending: false,
+      isSuccess: false,
+      reset: jest.fn(),
+      sendTransaction: jest.fn(),
+      status: "idle",
+      variables: void 0,
+      context: void 0,
+      failureCount: 0,
+      failureReason: null,
+      isPaused: false,
+      submittedAt: 0,
+      mutate: jest.fn(),
+      mutateAsync: jest.fn()
+    });
+  });
+  it("succeeds with valid base64 payload", async () => {
+    const mockRequest = jest.fn().mockResolvedValue({ signature: "sui-sig-ok" });
+    setupSuiMocks(mockRequest);
+    const { result } = renderHook(() => useSignTransaction());
+    const sig = await result.current.sui.signTransaction({
+      transaction: validBase64,
+      address: CONNECTED_SUI_ADDRESS
+    });
+    expect(sig).toBe("sui-sig-ok");
+    expect(mockRequest).toHaveBeenCalledWith(
+      expect.objectContaining({ method: "sui_signTransaction" })
+    );
+  });
+  it("throws when payload is not valid base64", async () => {
+    const mockRequest = jest.fn();
+    setupSuiMocks(mockRequest);
+    const { result } = renderHook(() => useSignTransaction());
+    await expect(
+      result.current.sui.signTransaction({
+        transaction: "not-valid-base64!!!",
+        address: CONNECTED_SUI_ADDRESS
+      })
+    ).rejects.toThrow("not valid base64");
+    expect(mockRequest).not.toHaveBeenCalled();
+  });
+  it("throws when payload exceeds 32 KiB", async () => {
+    const mockRequest = jest.fn();
+    setupSuiMocks(mockRequest);
+    const largeBytes = new Uint8Array(32 * 1024 + 1);
+    const largeBase64 = btoa(String.fromCharCode(...largeBytes));
+    const { result } = renderHook(() => useSignTransaction());
+    await expect(
+      result.current.sui.signTransaction({
+        transaction: largeBase64,
+        address: CONNECTED_SUI_ADDRESS
+      })
+    ).rejects.toThrow("maximum size");
+    expect(mockRequest).not.toHaveBeenCalled();
+  });
+  it("throws when payload is an empty string", async () => {
+    const mockRequest = jest.fn();
+    setupSuiMocks(mockRequest);
+    const { result } = renderHook(() => useSignTransaction());
+    await expect(
+      result.current.sui.signTransaction({
+        transaction: "",
+        address: CONNECTED_SUI_ADDRESS
+      })
+    ).rejects.toThrow("No Sui transaction bytes provided");
+    expect(mockRequest).not.toHaveBeenCalled();
+  });
+});
+describe("useSignTransaction — signPSBT", () => {
+  it("forwards signInputs verbatim to btcWalletProvider.signPSBT", async () => {
+    const mockSignPSBT = jest.fn().mockResolvedValue({ psbt: "signed-psbt" });
+    mockUseAppKitProvider.mockImplementation((namespace) => {
+      if (namespace === "bip122") {
+        return { walletProvider: { signPSBT: mockSignPSBT } };
+      }
+      return { walletProvider: void 0 };
+    });
+    const { result } = renderHook(() => useSignTransaction());
+    const signInputs = [
+      {
+        address: "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh",
+        index: 0,
+        sighashTypes: [1]
+      }
+    ];
+    const params = {
+      psbt: "base64psbt==",
+      signInputs: [...signInputs],
+      broadcast: false
+    };
+    const originalSignInputs = params.signInputs;
+    const psbt = await result.current.bitcoin.signTransaction(params);
+    expect(mockSignPSBT).toHaveBeenCalledWith(
+      expect.objectContaining({
+        signInputs: [
+          {
+            address: "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh",
+            index: 0,
+            sighashTypes: [1]
+          }
+        ]
+      })
+    );
+    expect(mockSignPSBT).not.toHaveBeenCalledWith(
+      expect.objectContaining({ signInputs: [] })
+    );
+    expect(params.signInputs).toBe(originalSignInputs);
+    expect(params.signInputs).toEqual(signInputs);
+    expect(psbt).toBe("signed-psbt");
+  });
+  it("throws when btcWalletProvider is not available", async () => {
+    mockUseAppKitProvider.mockImplementation(
+      () => ({
+        walletProvider: void 0
+      })
+    );
+    const { result } = renderHook(() => useSignTransaction());
+    await expect(
+      result.current.bitcoin.signTransaction({
+        psbt: "base64psbt==",
+        signInputs: [],
+        broadcast: false
+      })
+    ).rejects.toThrow("user is disconnected");
+  });
+});

package/reactjs/hooks/useBridgeFormik.js

@@ -7,6 +7,7 @@ const yup = require("yup");
 const reactjs_hooks_validation_useAmountSchema = require("./validation/useAmountSchema.js");
 const reactjs_hooks_validation_useSecondAmountSchema = require("./validation/useSecondAmountSchema.js");
 const api_confirmRate = require("../../api/confirmRate.js");
+const helpers_assertRateConfirmationMatchesIntent = require("../../helpers/assertRateConfirmationMatchesIntent.js");
 const helpers_getApiURL = require("../../helpers/getApiURL.js");
 const types_providerType = require("../../types/providerType.js");
 const reactjs_context_useWeb3App = require("../context/useWeb3App.js");
@@ -76,6 +77,10 @@ const useBridgeFormik = ({
         pendingSigningRef.current = false;
         return;
       }
+      helpers_assertRateConfirmationMatchesIntent.assertRateConfirmationMatchesIntent(
+        { fromChainId: values.fromChainId ?? "", sender: sender ?? "" },
+        transactions
+      );
       resetSwapForm();
       onSubmit({
         transactions,

package/reactjs/hooks/useBridgeFormik.mjs

@@ -4,6 +4,7 @@ import { object, string } from "yup";
 import { useAmountSchema } from "./validation/useAmountSchema.mjs";
 import { useSecondAmountSchema } from "./validation/useSecondAmountSchema.mjs";
 import { confirmRate } from "../../api/confirmRate.mjs";
+import { assertRateConfirmationMatchesIntent } from "../../helpers/assertRateConfirmationMatchesIntent.mjs";
 import { getApiURL } from "../../helpers/getApiURL.mjs";
 import { ProviderType } from "../../types/providerType.mjs";
 import { useWeb3App } from "../context/useWeb3App.mjs";
@@ -73,6 +74,10 @@ const useBridgeFormik = ({
         pendingSigningRef.current = false;
         return;
       }
+      assertRateConfirmationMatchesIntent(
+        { fromChainId: values.fromChainId ?? "", sender: sender ?? "" },
+        transactions
+      );
       resetSwapForm();
       onSubmit({
         transactions,

package/reactjs/hooks/useFetchTokens.js

@@ -17,6 +17,8 @@ const useFetchTokens = ({
   const bridgeApiChainId = reactjs_hooks_useBridgeApiChainId.useBridgeApiChainId();
   const account = reactjs_hooks_useAccount.useAccount();
   const { nativeAuthToken, bridgeOnly } = reactjs_context_useWeb3App.useWeb3App();
+  const invalidateMvxTokensBalancesQuery = reactjs_queries_useGetMvxTokensBalances_query.useInvalidateMvxTokensBalancesQuery();
+  const invalidateEvmTokensBalances = reactjs_queries_useGetNonMvxTokensBalances_query.useInvalidateEvmTokensBalances();
   const {
     data: tokens,
     isLoading: isTokensLoading,
@@ -90,14 +92,14 @@ const useFetchTokens = ({
   }, [nonMvxTokens, nonMvxTokensBalances]);
   React.useEffect(() => {
     if (mvxAddress) {
-      reactjs_queries_useGetMvxTokensBalances_query.invalidateMvxTokensBalancesQuery();
+      invalidateMvxTokensBalancesQuery();
     }
   }, [refetchTrigger, mvxAddress]);
   React.useEffect(() => {
     if (!account.address) {
       return;
     }
-    reactjs_queries_useGetNonMvxTokensBalances_query.invalidateEvmTokensBalances();
+    invalidateEvmTokensBalances();
   }, [refetchTrigger, bridgeApiChainId, account.address]);
   return {
     isTokensLoading,

package/reactjs/hooks/useFetchTokens.mjs

@@ -4,8 +4,8 @@ import { useBridgeApiChainId } from "./useBridgeApiChainId.mjs";
 import { MVX_CHAIN_IDS } from "../../constants/index.mjs";
 import { useWeb3App } from "../context/useWeb3App.mjs";
 import { useGetAllTokensQuery } from "../queries/useGetAllTokens.query.mjs";
-import { useGetMvxTokensBalancesQuery, invalidateMvxTokensBalancesQuery } from "../queries/useGetMvxTokensBalances.query.mjs";
-import { useGetNonMvxTokensBalancesQuery, invalidateEvmTokensBalances } from "../queries/useGetNonMvxTokensBalances.query.mjs";
+import { useInvalidateMvxTokensBalancesQuery, useGetMvxTokensBalancesQuery } from "../queries/useGetMvxTokensBalances.query.mjs";
+import { useInvalidateEvmTokensBalances, useGetNonMvxTokensBalancesQuery } from "../queries/useGetNonMvxTokensBalances.query.mjs";
 const useFetchTokens = ({
   mvxAddress,
   mvxApiURL,
@@ -14,6 +14,8 @@ const useFetchTokens = ({
   const bridgeApiChainId = useBridgeApiChainId();
   const account = useAccount();
   const { nativeAuthToken, bridgeOnly } = useWeb3App();
+  const invalidateMvxTokensBalancesQuery = useInvalidateMvxTokensBalancesQuery();
+  const invalidateEvmTokensBalances = useInvalidateEvmTokensBalances();
   const {
     data: tokens,
     isLoading: isTokensLoading,

package/reactjs/hooks/useGenericSignMessage.js

@@ -35,11 +35,31 @@ const useGenericSignMessage = () => {
           throw new Error("Sui wallet not connected");
         }
         const encodedMessage = new TextEncoder().encode(message);
+        const params = {
+          message: Buffer.from(encodedMessage).toString("base64")
+        };
+        const MAX_SUI_MESSAGE_BYTES = 32 * 1024;
+        if (!params.message || typeof params.message !== "string") {
+          throw new Error(
+            "Invalid Sui message: payload must be a non-empty string"
+          );
+        }
+        try {
+          const decoded = atob(params.message);
+          if (decoded.length > MAX_SUI_MESSAGE_BYTES) {
+            throw new Error(
+              `Sui message payload exceeds maximum size of ${MAX_SUI_MESSAGE_BYTES} bytes`
+            );
+          }
+        } catch (e) {
+          if (e instanceof Error && e.message.includes("maximum size")) {
+            throw e;
+          }
+          throw new Error("Invalid Sui message: payload is not valid base64");
+        }
         const result = await suiWalletProvider.request({
           method: "sui_signPersonalMessage",
-          params: {
-            message: Buffer.from(encodedMessage).toString("base64")
-          }
+          params
         });
         return result.signature;
       }

package/reactjs/hooks/useGenericSignMessage.mjs

@@ -32,11 +32,31 @@ const useGenericSignMessage = () => {
           throw new Error("Sui wallet not connected");
         }
         const encodedMessage = new TextEncoder().encode(message);
+        const params = {
+          message: Buffer.from(encodedMessage).toString("base64")
+        };
+        const MAX_SUI_MESSAGE_BYTES = 32 * 1024;
+        if (!params.message || typeof params.message !== "string") {
+          throw new Error(
+            "Invalid Sui message: payload must be a non-empty string"
+          );
+        }
+        try {
+          const decoded = atob(params.message);
+          if (decoded.length > MAX_SUI_MESSAGE_BYTES) {
+            throw new Error(
+              `Sui message payload exceeds maximum size of ${MAX_SUI_MESSAGE_BYTES} bytes`
+            );
+          }
+        } catch (e) {
+          if (e instanceof Error && e.message.includes("maximum size")) {
+            throw e;
+          }
+          throw new Error("Invalid Sui message: payload is not valid base64");
+        }
         const result = await suiWalletProvider.request({
           method: "sui_signPersonalMessage",
-          params: {
-            message: Buffer.from(encodedMessage).toString("base64")
-          }
+          params
         });
         return result.signature;
       }

package/reactjs/hooks/useSignTransaction.js

@@ -15,6 +15,9 @@ const useSignTransaction = () => {
   const { walletProvider: solWalletProvider } = react$1.useAppKitProvider("solana");
   const { walletProvider: btcWalletProvider } = react$1.useAppKitProvider("bip122");
   const { walletProvider: suiWalletProvider } = react$1.useAppKitProvider("sui");
+  const { address: suiAddress } = react$1.useAppKitAccount({
+    namespace: "sui"
+  });
   const signTransactionSolanaTransaction = async ({
     feePayer,
     instructions,
@@ -36,7 +39,6 @@ const useSignTransaction = () => {
     if (!btcWalletProvider) {
       throw Error("user is disconnected");
     }
-    params.signInputs = [];
     const signature = await btcWalletProvider.signPSBT(params);
     return signature.psbt;
   };
@@ -51,6 +53,30 @@ const useSignTransaction = () => {
     if (!suiWalletProvider) {
       throw new Error("Sui wallet not connected");
     }
+    const MAX_SUI_PAYLOAD_BYTES = 32 * 1024;
+    if (!transaction || typeof transaction !== "string") {
+      throw new Error(
+        "Invalid Sui transaction: payload must be a non-empty string"
+      );
+    }
+    try {
+      const decoded = atob(transaction);
+      if (decoded.length > MAX_SUI_PAYLOAD_BYTES) {
+        throw new Error(
+          `Sui transaction payload exceeds maximum size of ${MAX_SUI_PAYLOAD_BYTES} bytes`
+        );
+      }
+    } catch (e) {
+      if (e instanceof Error && e.message.includes("maximum size")) {
+        throw e;
+      }
+      throw new Error("Invalid Sui transaction: payload is not valid base64");
+    }
+    if (suiParams.address && suiAddress && suiParams.address !== suiAddress) {
+      throw new Error(
+        `Sui address mismatch: expected ${suiAddress}, got ${suiParams.address}`
+      );
+    }
     const result = await suiWalletProvider.request({
       method: "sui_signTransaction",
       params: {

package/reactjs/hooks/useSignTransaction.mjs

@@ -1,4 +1,4 @@
-import { useAppKitProvider } from "@reown/appkit/react";
+import { useAppKitProvider, useAppKitAccount } from "@reown/appkit/react";
 import { useAppKitConnection } from "@reown/appkit-adapter-solana/react";
 import { TransactionInstruction, Transaction, PublicKey } from "@solana/web3.js";
 import { useSendTransaction } from "wagmi";
@@ -12,6 +12,9 @@ const useSignTransaction = () => {
   const { walletProvider: solWalletProvider } = useAppKitProvider("solana");
   const { walletProvider: btcWalletProvider } = useAppKitProvider("bip122");
   const { walletProvider: suiWalletProvider } = useAppKitProvider("sui");
+  const { address: suiAddress } = useAppKitAccount({
+    namespace: "sui"
+  });
   const signTransactionSolanaTransaction = async ({
     feePayer,
     instructions,
@@ -33,7 +36,6 @@ const useSignTransaction = () => {
     if (!btcWalletProvider) {
       throw Error("user is disconnected");
     }
-    params.signInputs = [];
     const signature = await btcWalletProvider.signPSBT(params);
     return signature.psbt;
   };
@@ -48,6 +50,30 @@ const useSignTransaction = () => {
     if (!suiWalletProvider) {
       throw new Error("Sui wallet not connected");
     }
+    const MAX_SUI_PAYLOAD_BYTES = 32 * 1024;
+    if (!transaction || typeof transaction !== "string") {
+      throw new Error(
+        "Invalid Sui transaction: payload must be a non-empty string"
+      );
+    }
+    try {
+      const decoded = atob(transaction);
+      if (decoded.length > MAX_SUI_PAYLOAD_BYTES) {
+        throw new Error(
+          `Sui transaction payload exceeds maximum size of ${MAX_SUI_PAYLOAD_BYTES} bytes`
+        );
+      }
+    } catch (e) {
+      if (e instanceof Error && e.message.includes("maximum size")) {
+        throw e;
+      }
+      throw new Error("Invalid Sui transaction: payload is not valid base64");
+    }
+    if (suiParams.address && suiAddress && suiParams.address !== suiAddress) {
+      throw new Error(
+        `Sui address mismatch: expected ${suiAddress}, got ${suiParams.address}`
+      );
+    }
     const result = await suiWalletProvider.request({
       method: "sui_signTransaction",
       params: {

package/reactjs/index.js

@@ -123,12 +123,12 @@ exports.SuiMethods = reactjs_init_init.SuiMethods;
 exports.init = reactjs_init_init.init;
 exports.useGetAllTokensQuery = reactjs_queries_useGetAllTokens_query.useGetAllTokensQuery;
 exports.useGetChainsQuery = reactjs_queries_useGetChains_query.useGetChainsQuery;
-exports.invalidateEvmTokensBalances = reactjs_queries_useGetNonMvxTokensBalances_query.invalidateEvmTokensBalances;
 exports.useGetNonMvxTokensBalancesQuery = reactjs_queries_useGetNonMvxTokensBalances_query.useGetNonMvxTokensBalancesQuery;
-exports.invalidateHistoryQuery = reactjs_queries_useGetHistory_query.invalidateHistoryQuery;
+exports.useInvalidateEvmTokensBalances = reactjs_queries_useGetNonMvxTokensBalances_query.useInvalidateEvmTokensBalances;
 exports.useGetHistoryQuery = reactjs_queries_useGetHistory_query.useGetHistoryQuery;
-exports.invalidateMvxTokensBalancesQuery = reactjs_queries_useGetMvxTokensBalances_query.invalidateMvxTokensBalancesQuery;
+exports.useInvalidateHistoryQuery = reactjs_queries_useGetHistory_query.useInvalidateHistoryQuery;
 exports.useGetMvxTokensBalancesQuery = reactjs_queries_useGetMvxTokensBalances_query.useGetMvxTokensBalancesQuery;
+exports.useInvalidateMvxTokensBalancesQuery = reactjs_queries_useGetMvxTokensBalances_query.useInvalidateMvxTokensBalancesQuery;
 exports.useGetRateMutation = reactjs_queries_useGetRate_mutation.useGetRateMutation;
 exports.delay = reactjs_utils_delay.delay;
 exports.formatAmount = reactjs_utils_formatAmount.formatAmount;

package/reactjs/index.mjs

@@ -48,9 +48,9 @@ import { useSuiConnect } from "./hooks/useSuiConnect.mjs";
 import { SuiMethods, init } from "./init/init.mjs";
 import { useGetAllTokensQuery } from "./queries/useGetAllTokens.query.mjs";
 import { useGetChainsQuery } from "./queries/useGetChains.query.mjs";
-import { invalidateEvmTokensBalances, useGetNonMvxTokensBalancesQuery } from "./queries/useGetNonMvxTokensBalances.query.mjs";
-import { invalidateHistoryQuery, useGetHistoryQuery } from "./queries/useGetHistory.query.mjs";
-import { invalidateMvxTokensBalancesQuery, useGetMvxTokensBalancesQuery } from "./queries/useGetMvxTokensBalances.query.mjs";
+import { useGetNonMvxTokensBalancesQuery, useInvalidateEvmTokensBalances } from "./queries/useGetNonMvxTokensBalances.query.mjs";
+import { useGetHistoryQuery, useInvalidateHistoryQuery } from "./queries/useGetHistory.query.mjs";
+import { useGetMvxTokensBalancesQuery, useInvalidateMvxTokensBalancesQuery } from "./queries/useGetMvxTokensBalances.query.mjs";
 import { useGetRateMutation } from "./queries/useGetRate.mutation.mjs";
 import { delay } from "./utils/delay.mjs";
 import { formatAmount } from "./utils/formatAmount.mjs";
@@ -109,9 +109,6 @@ export {
   getQueryClient,
   hasEnoughFunds,
   init,
-  invalidateEvmTokensBalances,
-  invalidateHistoryQuery,
-  invalidateMvxTokensBalancesQuery,
   isStringFloat,
   mxClsx,
   pipe,
@@ -144,6 +141,9 @@ export {
   useGetMvxTokensBalancesQuery,
   useGetNonMvxTokensBalancesQuery,
   useGetRateMutation,
+  useInvalidateEvmTokensBalances,
+  useInvalidateHistoryQuery,
+  useInvalidateMvxTokensBalancesQuery,
   useResolveTokenChain,
   useSecondAmountSchema,
   useSendTransactions,

package/reactjs/init/init.d.ts

@@ -14,6 +14,7 @@ export type InitOptions = {
     mvxChainId: '31' | '44' | '54';
     suiEnvironment?: 'mainnet' | 'testnet' | 'devnet';
     suiFeaturedWalletIds?: string[];
+    expectedSuiAddress?: string;
 };
 export declare enum SuiMethods {
     SIGN_TRANSACTION = "sui_signTransaction",

package/reactjs/init/init.js

@@ -82,7 +82,7 @@ var SuiMethods = /* @__PURE__ */ ((SuiMethods2) => {
   return SuiMethods2;
 })(SuiMethods || {});
 async function init(options) {
-  var _a, _b, _c, _d;
+  var _a, _b, _c, _d, _e;
   const store = store_inMemoryStore.InMemoryStore.getInstance();
   store.setItem("apiURL", options.apiURL);
   store.setItem("bridgeURL", options.bridgeURL);
@@ -114,7 +114,12 @@ async function init(options) {
   if (options.suiEnvironment) {
     const suiNetwork = suiNetworkDefinitions[options.suiEnvironment];
     const explicitSuiCaip = suiNetwork.caipNetworkId ?? `sui:${suiNetwork.id}`;
-    adapters.push(new reactjs_adapters_SuiAdapter.SuiAdapter({ explicitCaipChains: [explicitSuiCaip] }));
+    adapters.push(
+      new reactjs_adapters_SuiAdapter.SuiAdapter({
+        explicitCaipChains: [explicitSuiCaip],
+        expectedSuiAddress: options.expectedSuiAddress
+      })
+    );
   }
   const appKit = react.createAppKit({
     ...options.appKitOptions,
@@ -126,7 +131,10 @@ async function init(options) {
     const wc = await appKit.getUniversalProvider();
     const suiNs = (_b = (_a = wc == null ? void 0 : wc.session) == null ? void 0 : _a.namespaces) == null ? void 0 : _b["sui"];
     if (((_c = suiNs == null ? void 0 : suiNs.accounts) == null ? void 0 : _c.length) && !appKit.getCaipAddress("sui")) {
-      await ((_d = appKit.syncWalletConnectAccount) == null ? void 0 : _d.call(appKit));
+      const firstSuiAddress = (_d = suiNs.accounts[0]) == null ? void 0 : _d.split(":").pop();
+      if (!options.expectedSuiAddress || firstSuiAddress === options.expectedSuiAddress) {
+        await ((_e = appKit.syncWalletConnectAccount) == null ? void 0 : _e.call(appKit));
+      }
     }
   }
   return {

package/reactjs/init/init.mjs

@@ -62,7 +62,7 @@ var SuiMethods = /* @__PURE__ */ ((SuiMethods2) => {
   return SuiMethods2;
 })(SuiMethods || {});
 async function init(options) {
-  var _a, _b, _c, _d;
+  var _a, _b, _c, _d, _e;
   const store = InMemoryStore.getInstance();
   store.setItem("apiURL", options.apiURL);
   store.setItem("bridgeURL", options.bridgeURL);
@@ -94,7 +94,12 @@ async function init(options) {
   if (options.suiEnvironment) {
     const suiNetwork = suiNetworkDefinitions[options.suiEnvironment];
     const explicitSuiCaip = suiNetwork.caipNetworkId ?? `sui:${suiNetwork.id}`;
-    adapters.push(new SuiAdapter({ explicitCaipChains: [explicitSuiCaip] }));
+    adapters.push(
+      new SuiAdapter({
+        explicitCaipChains: [explicitSuiCaip],
+        expectedSuiAddress: options.expectedSuiAddress
+      })
+    );
   }
   const appKit = createAppKit({
     ...options.appKitOptions,
@@ -106,7 +111,10 @@ async function init(options) {
     const wc = await appKit.getUniversalProvider();
     const suiNs = (_b = (_a = wc == null ? void 0 : wc.session) == null ? void 0 : _a.namespaces) == null ? void 0 : _b["sui"];
     if (((_c = suiNs == null ? void 0 : suiNs.accounts) == null ? void 0 : _c.length) && !appKit.getCaipAddress("sui")) {
-      await ((_d = appKit.syncWalletConnectAccount) == null ? void 0 : _d.call(appKit));
+      const firstSuiAddress = (_d = suiNs.accounts[0]) == null ? void 0 : _d.split(":").pop();
+      if (!options.expectedSuiAddress || firstSuiAddress === options.expectedSuiAddress) {
+        await ((_e = appKit.syncWalletConnectAccount) == null ? void 0 : _e.call(appKit));
+      }
     }
   }
   return {

package/reactjs/queries/index.js

@@ -9,10 +9,10 @@ const reactjs_queries_useGetMvxTokensBalances_query = require("./useGetMvxTokens
 const reactjs_queries_useGetRate_mutation = require("./useGetRate.mutation.js");
 exports.useGetAllTokensQuery = reactjs_queries_useGetAllTokens_query.useGetAllTokensQuery;
 exports.useGetChainsQuery = reactjs_queries_useGetChains_query.useGetChainsQuery;
-exports.invalidateEvmTokensBalances = reactjs_queries_useGetNonMvxTokensBalances_query.invalidateEvmTokensBalances;
 exports.useGetNonMvxTokensBalancesQuery = reactjs_queries_useGetNonMvxTokensBalances_query.useGetNonMvxTokensBalancesQuery;
-exports.invalidateHistoryQuery = reactjs_queries_useGetHistory_query.invalidateHistoryQuery;
+exports.useInvalidateEvmTokensBalances = reactjs_queries_useGetNonMvxTokensBalances_query.useInvalidateEvmTokensBalances;
 exports.useGetHistoryQuery = reactjs_queries_useGetHistory_query.useGetHistoryQuery;
-exports.invalidateMvxTokensBalancesQuery = reactjs_queries_useGetMvxTokensBalances_query.invalidateMvxTokensBalancesQuery;
+exports.useInvalidateHistoryQuery = reactjs_queries_useGetHistory_query.useInvalidateHistoryQuery;
 exports.useGetMvxTokensBalancesQuery = reactjs_queries_useGetMvxTokensBalances_query.useGetMvxTokensBalancesQuery;
+exports.useInvalidateMvxTokensBalancesQuery = reactjs_queries_useGetMvxTokensBalances_query.useInvalidateMvxTokensBalancesQuery;
 exports.useGetRateMutation = reactjs_queries_useGetRate_mutation.useGetRateMutation;

package/reactjs/queries/index.mjs

@@ -1,17 +1,17 @@
 import { useGetAllTokensQuery } from "./useGetAllTokens.query.mjs";
 import { useGetChainsQuery } from "./useGetChains.query.mjs";
-import { invalidateEvmTokensBalances, useGetNonMvxTokensBalancesQuery } from "./useGetNonMvxTokensBalances.query.mjs";
-import { invalidateHistoryQuery, useGetHistoryQuery } from "./useGetHistory.query.mjs";
-import { invalidateMvxTokensBalancesQuery, useGetMvxTokensBalancesQuery } from "./useGetMvxTokensBalances.query.mjs";
+import { useGetNonMvxTokensBalancesQuery, useInvalidateEvmTokensBalances } from "./useGetNonMvxTokensBalances.query.mjs";
+import { useGetHistoryQuery, useInvalidateHistoryQuery } from "./useGetHistory.query.mjs";
+import { useGetMvxTokensBalancesQuery, useInvalidateMvxTokensBalancesQuery } from "./useGetMvxTokensBalances.query.mjs";
 import { useGetRateMutation } from "./useGetRate.mutation.mjs";
 export {
-  invalidateEvmTokensBalances,
-  invalidateHistoryQuery,
-  invalidateMvxTokensBalancesQuery,
   useGetAllTokensQuery,
   useGetChainsQuery,
   useGetHistoryQuery,
   useGetMvxTokensBalancesQuery,
   useGetNonMvxTokensBalancesQuery,
-  useGetRateMutation
+  useGetRateMutation,
+  useInvalidateEvmTokensBalances,
+  useInvalidateHistoryQuery,
+  useInvalidateMvxTokensBalancesQuery
 };

package/reactjs/queries/useCheckAccount.query.js

@@ -29,7 +29,7 @@ const useCheckAccountQuery = () => {
     return ((_a = error.response) == null ? void 0 : _a.status) === 404;
   };
   return reactQuery.useQuery({
-    queryKey: ["check-account", address, bridgeApiChainId, nativeAuthToken],
+    queryKey: ["check-account", address, bridgeApiChainId],
     queryFn,
     retry,
     refetchOnWindowFocus: false,

package/reactjs/queries/useCheckAccount.query.mjs

@@ -26,7 +26,7 @@ const useCheckAccountQuery = () => {
     return ((_a = error.response) == null ? void 0 : _a.status) === 404;
   };
   return useQuery({
-    queryKey: ["check-account", address, bridgeApiChainId, nativeAuthToken],
+    queryKey: ["check-account", address, bridgeApiChainId],
     queryFn,
     retry,
     refetchOnWindowFocus: false,

package/reactjs/queries/useGetAllTokens.query.js

@@ -25,7 +25,7 @@ const useGetAllTokensQuery = ({
     return ((_a = error.response) == null ? void 0 : _a.status) === 404;
   };
   return reactQuery.useQuery({
-    queryKey: ["all-tokens", nativeAuthToken],
+    queryKey: ["all-tokens", bridgeOnly],
     queryFn,
     retry,
     refetchOnWindowFocus: false,

package/reactjs/queries/useGetAllTokens.query.mjs

@@ -22,7 +22,7 @@ const useGetAllTokensQuery = ({
     return ((_a = error.response) == null ? void 0 : _a.status) === 404;
   };
   return useQuery({
-    queryKey: ["all-tokens", nativeAuthToken],
+    queryKey: ["all-tokens", bridgeOnly],
     queryFn,
     retry,
     refetchOnWindowFocus: false,