@orderly.network/hooks 2.9.1 → 2.10.0-alpha.1

package/dist/index.js

@@ -1,7 +1,7 @@
 'use strict';
 
 var net = require('@orderly.network/net');
-var useSWR = require('swr');
+var useSWR5 = require('swr');
 var types = require('@orderly.network/types');
 var React2 = require('react');
 var utils = require('@orderly.network/utils');
@@ -46,7 +46,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var useSWR__namespace = /*#__PURE__*/_interopNamespace(useSWR);
+var useSWR5__namespace = /*#__PURE__*/_interopNamespace(useSWR5);
 var React2__default = /*#__PURE__*/_interopDefault(React2);
 var useSWRMutation__default = /*#__PURE__*/_interopDefault(useSWRMutation);
 var useConstant__default = /*#__PURE__*/_interopDefault(useConstant);
@@ -64,9 +64,9 @@ var __export = (target, all) => {
 // src/version.ts
 if (typeof window !== "undefined") {
   window.__ORDERLY_VERSION__ = window.__ORDERLY_VERSION__ || {};
-  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.9.1";
+  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.10.0-alpha.1";
 }
-var version_default = "2.9.1";
+var version_default = "2.10.0-alpha.1";
 var fetcher = (url, init2 = {}, queryOptions) => net.get(url, init2, queryOptions?.formatter);
 var noCacheConfig = {
   dedupingInterval: 0,
@@ -105,7 +105,7 @@ var useQuery = (query, options) => {
   if (typeof apiBaseUrl === "undefined") {
     throw new types.SDKError("please add OrderlyConfigProvider to your app");
   }
-  return useSWR__namespace.default(
+  return useSWR5__namespace.default(
     query,
     (url, init2) => fetcher(url.startsWith("http") ? url : `${apiBaseUrl}${url}`, init2, {
       formatter
@@ -491,7 +491,7 @@ var usePrivateQuery = (query, options) => {
   const { formatter, ...swrOptions } = options || {};
   const { state } = useAccount();
   const middleware = Array.isArray(options?.use) ? options?.use ?? [] : [];
-  return useSWR__namespace.default(
+  return useSWR5__namespace.default(
     () => query && (state.status >= types.AccountStatusEnum.EnableTrading || state.status === types.AccountStatusEnum.EnableTradingWithoutConnected) ? [query, state.accountId] : null,
     (url, init2) => {
       return fetcher(url, init2, { formatter });
@@ -960,7 +960,7 @@ function useSubAccountQuery(query, options) {
   const { formatter, accountId, ...swrOptions } = options || {};
   const { state, account: account9 } = useAccount();
   const middleware = Array.isArray(options?.use) ? options?.use ?? [] : [];
-  return useSWR__namespace.default(
+  return useSWR5__namespace.default(
     () => accountId && (state.status >= types.AccountStatusEnum.EnableTrading || state.status === types.AccountStatusEnum.EnableTradingWithoutConnected) ? [query, accountId] : null,
     (url, init2) => {
       return fetcher(url, init2, { formatter });
@@ -2788,7 +2788,7 @@ var usePreLoadData = () => {
     if (swapSupportInfo || !enableSwapDeposit) return;
     fetchSwapSupport();
   }, [swapSupportInfo, enableSwapDeposit]);
-  const { data: systemInfo } = useSWR__namespace.default(
+  const { data: systemInfo } = useSWR5__namespace.default(
     "/v1/public/system_info",
     async (url, init2) => {
       const data = await fetch(
@@ -4087,6 +4087,29 @@ var useOpenInterest = (symbol) => {
     };
   });
 };
+var useMarkPriceStore = zustand.create((set, get3) => ({
+  markPrices: {},
+  // orderBook: {},
+  // ask_bid: [],
+  actions: {
+    updateMarkPrice: (markPrice) => {
+      set({
+        markPrices: markPrice
+      });
+    },
+    getMarkPriceBySymbol: (symbol) => {
+      return get3().markPrices[symbol];
+    }
+  }
+}));
+var useMarkPriceBySymbol = (symbol) => useMarkPriceStore((state) => state.actions.getMarkPriceBySymbol(symbol));
+var useMarkPriceActions = () => useMarkPriceStore((state) => state.actions);
+
+// src/orderly/useMarkPricesStream.ts
+var useMarkPricesStream = () => {
+  const data = useMarkPriceStore((state) => state.markPrices);
+  return { data };
+};
 
 // src/orderly/useTickerStream.ts
 var useTickerStream = (symbol) => {
@@ -4122,10 +4145,13 @@ var useTickerStream = (symbol) => {
       unsubscribe?.();
     };
   }, [symbol]);
-  const { data: markPrice } = useMarkPrice(symbol);
+  const { data: markPrices } = useMarkPricesStream();
   const { data: indexPrice } = useIndexPrice(symbol);
   const { data: openInterest } = useOpenInterest(symbol);
   const marketMap = useMarketMap();
+  const markPrice = React2.useMemo(() => {
+    return markPrices?.[symbol];
+  }, [markPrices, symbol]);
   const value = React2.useMemo(() => {
     if (!info) return null;
     if (!ticker || ticker.symbol !== symbol) return info;
@@ -4694,29 +4720,6 @@ function get24hChange2(close, open) {
     return new utils.Decimal(close).minus(open).div(open).toNumber();
   }
 }
-var useMarkPriceStore = zustand.create((set, get3) => ({
-  markPrices: {},
-  // orderBook: {},
-  // ask_bid: [],
-  actions: {
-    updateMarkPrice: (markPrice) => {
-      set({
-        markPrices: markPrice
-      });
-    },
-    getMarkPriceBySymbol: (symbol) => {
-      return get3().markPrices[symbol];
-    }
-  }
-}));
-var useMarkPriceBySymbol = (symbol) => useMarkPriceStore((state) => state.actions.getMarkPriceBySymbol(symbol));
-var useMarkPriceActions = () => useMarkPriceStore((state) => state.actions);
-
-// src/orderly/useMarkPricesStream.ts
-var useMarkPricesStream = () => {
-  const data = useMarkPriceStore((state) => state.markPrices);
-  return { data };
-};
 var useIndexPriceStore = zustand.create((set) => ({
   indexPrices: {},
   actions: {
@@ -6619,7 +6622,7 @@ var useSubAccountDataObserver = (accountId) => {
     const unsubscribe = ws.privateSubscribe("position", {
       onMessage: (data) => {
         const { positions: nextPositions } = data;
-        useSWR.mutate(
+        useSWR5.mutate(
           key,
           (prevPositions) => {
             if (!!prevPositions) {
@@ -7104,7 +7107,7 @@ var useLeverageBySymbol = (symbol) => {
         const res = data2?.accountDetail?.symbolLeverage || {};
         if (res.symbol === symbol) {
           const key = [`/v1/client/leverage?symbol=${symbol}`, state.accountId];
-          useSWR.mutate(
+          useSWR5.mutate(
             key,
             (prevData) => {
               return {
@@ -7251,20 +7254,22 @@ var useMarginRatio = () => {
   }, [rows, notional]);
   return { marginRatio, currentLeverage, mmr, maintenanceMargin };
 };
-var TestNetWhiteList = [
+var TESTNET_WHITE_LIST = [
   types.ARBITRUM_TESTNET_CHAINID,
   types.SOLANA_TESTNET_CHAINID,
   types.MONAD_TESTNET_CHAINID,
   types.ABSTRACT_TESTNET_CHAINID,
   types.BSC_TESTNET_CHAINID
 ];
+var TESTNET_WHITE_CHAINS = TESTNET_WHITE_LIST.map((id) => ({
+  id
+}));
 function useChains(networkId, options = {}) {
-  const { pick: pickField, ...swrOptions } = options;
+  const { pick: pickField } = options;
   const {
     filteredChains: allowedChains,
-    configStore,
     customChains,
-    chainTransformer
+    dataAdapter
   } = React2.useContext(OrderlyContext);
   const filterFun = React2.useRef(options?.filter);
   filterFun.current = options?.filter;
@@ -7274,7 +7279,6 @@ function useChains(networkId, options = {}) {
   const testTokenChainsRes = useTestTokenStore((state) => state.data);
   const chainInfos = useMainnetChainsStore((state) => state.data);
   const testChainInfos = useTestnetChainsStore((state) => state.data);
-  const { swapChains, swapChainsError } = useSwapChains();
   const chains = React2.useMemo(() => {
     if (!tokenChainsRes || !testTokenChainsRes || !chainInfos || !testChainInfos) {
       return [];
@@ -7282,17 +7286,15 @@ function useChains(networkId, options = {}) {
     const mainnetChains = formatChains({
       tokenChains: tokenChainsRes,
       chainInfos,
-      swapChains,
       filter: filterFun.current,
       mainnet: true,
-      chainTransformer
+      resolveChains: dataAdapter?.chainsList
     });
     const testnetChains = formatChains({
       tokenChains: testTokenChainsRes,
       chainInfos: testChainInfos,
-      swapChains,
       mainnet: false,
-      chainTransformer
+      resolveChains: dataAdapter?.chainsList
     });
     let mainnetArr = needFetchFromAPI ? mainnetChains : customChains?.mainnet;
     let testnetArr = needFetchFromAPI ? testnetChains : customChains?.testnet;
@@ -7305,7 +7307,7 @@ function useChains(networkId, options = {}) {
     mainnetArr = filterByAllowedChains(mainnetArr, allowedChains?.mainnet);
     testnetArr = filterByAllowedChains(
       testnetArr,
-      allowedChains?.testnet ?? TestNetWhiteList.map((id) => ({ id }))
+      allowedChains?.testnet ?? TESTNET_WHITE_CHAINS
     );
     if (!!pickField) {
       testnetArr = testnetArr.map((item) => item[pickField]);
@@ -7330,15 +7332,14 @@ function useChains(networkId, options = {}) {
     customChains,
     pickField,
     allowedChains,
-    swapChains,
-    chainTransformer
+    dataAdapter
   ]);
   const findByChainId = React2.useCallback(
     (chainId, field) => {
       const chain = chainsMap.current.get(chainId);
       if (chain) {
         chain.nativeToken = chain.token_infos?.find(
-          (item) => item.address === types.nativeTokenAddress
+          (item) => types.isNativeTokenChecker(item.address)
         ) || {
           symbol: chain.network_infos?.currency_symbol
         };
@@ -7362,7 +7363,7 @@ function useChains(networkId, options = {}) {
     {
       findByChainId,
       checkChainSupport,
-      error: tokenError || swapChainsError
+      error: tokenError
     }
   ];
 }
@@ -7378,70 +7379,23 @@ function filterByAllowedChains(chains, allowedChains) {
   if (!allowedChains) {
     return chains;
   }
-  return chains.filter(
-    (chain) => allowedChains.some(
-      (allowedChain) => allowedChain.id === parseInt(chain?.network_infos?.chain_id)
-    )
-  );
-}
-function useSwapChains() {
-  const { enableSwapDeposit } = React2.useContext(OrderlyContext);
-  const { data: swapChainsRes, error: swapChainsError } = useSwapSupportStore();
-  const swapChains = React2.useMemo(() => {
-    if (!enableSwapDeposit || !swapChainsRes || !swapChainsRes.data) {
-      return [];
-    }
-    const data = swapChainsRes.data;
-    return Object.keys(data).map((key) => {
-      const chain = data[key];
-      const { network_infos, token_infos } = chain;
-      const networkInfos = {
-        ...network_infos,
-        // swap deposit will use shortName to get swap info
-        shortName: key,
-        cross_chain_router: network_infos?.woofi_dex_cross_chain_router,
-        depositor: network_infos?.woofi_dex_depositor,
-        est_txn_mins: network_infos?.est_txn_mins
-      };
-      const nativeToken = token_infos.find(
-        (item) => item.symbol === network_infos.currency_symbol
-      );
-      if (nativeToken) {
-        networkInfos.currency_decimal = nativeToken.decimals;
-      } else {
-        networkInfos.currency_decimal = 18;
-      }
-      const tokenInfos = token_infos?.filter((item) => item.swap_enable).map((item) => {
-        const { woofi_dex_precision, ...rest } = item;
-        return {
-          ...rest,
-          precision: woofi_dex_precision
-        };
-      });
-      return {
-        network_infos: networkInfos,
-        token_infos: tokenInfos || []
-      };
-    });
-  }, [enableSwapDeposit, swapChainsRes]);
-  return { swapChains, swapChainsError };
+  return allowedChains.map((allowedChain) => {
+    return chains.find(
+      (chain) => parseInt(chain.network_infos?.chain_id) === allowedChain.id
+    );
+  }).filter((chain) => !!chain);
 }
-function formatChains({
-  chainInfos = [],
-  tokenChains = [],
-  swapChains = [],
-  filter,
-  mainnet,
-  chainTransformer
-}) {
+function formatChains(options) {
+  const {
+    chainInfos = [],
+    tokenChains = [],
+    filter,
+    mainnet,
+    resolveChains
+  } = options;
   const chains = [];
   for (const chainInfo of chainInfos) {
     const chainId = Number(chainInfo.chain_id);
-    const swapChainInfo = swapChains.find(
-      (item) => item.network_infos.chain_id === chainId
-    );
-    const swapNetworkInfo = swapChainInfo?.network_infos;
-    const swapTokenInfos = swapChainInfo?.token_infos || [];
     const {
       name,
       public_rpc_url,
@@ -7450,7 +7404,6 @@ function formatChains({
       explorer_base_url,
       vault_address
     } = chainInfo;
-    const { shortName, cross_chain_router, depositor, est_txn_mins } = swapNetworkInfo || {};
     const network_infos = {
       name,
       chain_id: chainId,
@@ -7461,32 +7414,21 @@ function formatChains({
       currency_decimal,
       bridge_enable: true,
       explorer_base_url,
-      // swap field
-      shortName: shortName ?? name,
-      cross_chain_router,
-      depositor,
-      est_txn_mins,
+      shortName: name,
       vault_address
     };
-    const usdcSwapToken = swapTokenInfos.find(
-      (item) => item.symbol === "USDC"
-    );
     const tokenInfos = tokenChains.filter(
       (item) => item.chain_details.some((item2) => Number(item2.chain_id) === chainId)
     ).map((item) => {
       const chain = item.chain_details.find(
         (item2) => Number(item2.chain_id) === chainId
       );
-      const swapToken = swapTokenInfos.find(
-        (swapItem) => swapItem.symbol === item.token
-      );
       return {
         symbol: item.token,
         // if contract_address is not exist, use nativeTokenAddress to place holder
         address: chain?.contract_address || types.nativeTokenAddress,
         /** chain decimals */
         decimals: chain?.decimals,
-        // chain_decimals: chain?.decimals,
         /** token decimals */
         token_decimal: item?.decimals,
         precision: item.decimals,
@@ -7498,31 +7440,20 @@ function formatChains({
         discount_factor: item.discount_factor,
         haircut: item.haircut,
         user_max_qty: item.user_max_qty,
-        is_collateral: item.is_collateral,
-        // if source token is swap token, and usdc is swap token, set swap_enable to true
-        swap_enable: !!swapToken?.swap_enable && usdcSwapToken?.swap_enable
+        is_collateral: item.is_collateral
       };
     });
-    const swapTokens = usdcSwapToken?.swap_enable ? swapTokenInfos?.filter((item) => {
-      return !tokenInfos?.some((token) => token.symbol === item.symbol);
-    }) : [];
     const _chain = {
       network_infos,
-      token_infos: [...tokenInfos, ...swapTokens]
+      token_infos: tokenInfos
     };
     if (typeof filter === "function") {
       if (!filter(_chain)) continue;
     }
     chains.push(_chain);
   }
-  if (typeof chainTransformer === "function") {
-    return chainTransformer({
-      chains,
-      chainInfos,
-      tokenChains,
-      swapChains,
-      mainnet
-    });
+  if (typeof resolveChains === "function") {
+    return resolveChains(chains);
   }
   return chains;
 }
@@ -7770,128 +7701,32 @@ var useWithdraw = (options) => {
   };
 };
 var useDeposit = (options) => {
-  const networkId = useConfig("networkId");
-  const [balanceRevalidating, setBalanceRevalidating] = React2.useState(false);
-  const [allowanceRevalidating, setAllowanceRevalidating] = React2.useState(false);
-  const [_, { findByChainId }] = useChains(void 0);
   const [quantity, setQuantity] = React2.useState("");
-  const [depositFee, setDepositFee] = React2.useState(0n);
-  const [depositFeeRevalidating, setDepositFeeRevalidating] = React2.useState(false);
-  const [balance, setBalance] = React2.useState("0");
-  const [allowance, setAllowance] = React2.useState("0");
-  const balanceRef = React2.useRef("");
-  const currentAddressRef = React2.useRef();
   const { account: account9, state } = useAccount();
   const { track: track2 } = useTrack();
-  const prevAddress = React2.useRef();
-  const getBalanceListener = React2.useRef();
-  const targetChain = React2.useMemo(() => {
-    let chain;
-    if (networkId === "testnet") {
-      chain = findByChainId(
-        utils.isTestnet(options.srcChainId) ? options.srcChainId : types.ARBITRUM_TESTNET_CHAINID
-      );
-    } else {
-      chain = findByChainId(options.srcChainId);
-      if (!chain?.network_infos?.bridgeless) {
-        chain = findByChainId(types.ARBITRUM_MAINNET_CHAINID);
-      }
-    }
-    return chain;
-  }, [networkId, findByChainId, options.srcChainId]);
+  const targetChain = useTargetChain(options.srcChainId);
   const dst = React2.useMemo(() => {
-    const USDC = targetChain?.token_infos.find(
-      (token) => token.symbol === "USDC"
+    const symbol = options.dstToken || "USDC";
+    const targetToken = targetChain?.token_infos.find(
+      (token) => token.symbol === symbol
     );
     return {
-      symbol: "USDC",
-      address: USDC?.address,
-      decimals: USDC?.decimals,
+      symbol,
+      address: targetToken?.address,
+      decimals: targetToken?.decimals,
       chainId: targetChain?.network_infos.chain_id,
       network: targetChain?.network_infos.shortName
     };
-  }, [targetChain]);
+  }, [targetChain, options.dstToken]);
   const isNativeToken = React2.useMemo(
-    () => types.isNativeTokenChecker(options.address || ""),
+    () => types.isNativeTokenChecker(options.address),
     [options.address]
   );
-  const fetchBalanceHandler = React2.useCallback(
-    async (address, decimals, token) => {
-      let balance2;
-      try {
-        if (address && types.isNativeTokenChecker(address)) {
-          balance2 = await account9.assetsManager.getNativeBalance({
-            decimals
-          });
-        } else {
-          balance2 = await account9.assetsManager.getBalance(address, {
-            decimals
-          });
-        }
-      } catch (err) {
-        if (ignoreBalanceError({
-          // TODO: use token params instead of options.srcToken
-          token: token || options.srcToken,
-          chainNamespace: account9.walletAdapter?.chainNamespace,
-          err
-        })) {
-          return "0";
-        }
-        throw err;
-      }
-      return balance2;
-    },
-    [options.srcToken, account9]
-  );
-  const fetchBalances = React2.useCallback(async (tokens) => {
-    const tasks = [];
-    for (const token of tokens) {
-      tasks.push(
-        fetchBalanceHandler(token.address, token?.decimals, token.symbol)
-      );
-    }
-    const results = await Promise.allSettled(tasks);
-    const balances = {};
-    for (const [index, balance2] of results.entries()) {
-      if (balance2.status === "fulfilled") {
-        balances[tokens[index].symbol] = balance2.value;
-      }
-    }
-    return balances;
-  }, []);
-  const getAllowance = async (inputs) => {
-    const { address, vaultAddress: vaultAddress2, decimals } = inputs;
-    const key = `${address}-${vaultAddress2}`;
-    if (prevAddress.current === key) return;
-    if (!address || !vaultAddress2) return;
-    if (types.isNativeTokenChecker(address)) return;
-    prevAddress.current = key;
-    const allowance2 = await account9.assetsManager.getAllowance({
-      address,
-      vaultAddress: vaultAddress2,
-      decimals
-    });
-    setAllowance(allowance2);
-    return allowance2;
-  };
-  const getAllowanceByDefaultAddress = async (inputs) => {
-    const { address, decimals } = inputs;
-    if (prevAddress.current === address) return;
-    if (!address || types.isNativeTokenChecker(address)) return;
-    prevAddress.current = address;
-    const allowance2 = await account9.assetsManager.getAllowance({
-      address,
-      decimals,
-      vaultAddress
-    });
-    setAllowance(allowance2);
-    return allowance2;
-  };
   const vaultAddress = React2.useMemo(() => {
-    if (dst.chainId !== options.srcChainId) {
+    if (dst?.chainId !== options.srcChainId) {
       return options.crossChainRouteAddress;
     }
-    if (options.srcToken !== (options.dstToken || dst.symbol)) {
+    if (options.srcToken !== options.dstToken) {
       return options.depositorAddress;
     }
     return targetChain?.network_infos.vault_address;
@@ -7904,103 +7739,43 @@ var useDeposit = (options) => {
     options.depositorAddress,
     targetChain
   ]);
-  const queryBalance = useDebounce.useDebouncedCallback(
-    (address, decimals) => {
-      fetchBalanceHandler(address, decimals).then((balance2) => {
-        setBalance(balance2);
-        setBalanceRevalidating(false);
-      });
-    },
-    100
-  );
-  const queryAllowance = useDebounce.useDebouncedCallback(
-    (inputs) => {
-      getAllowance(inputs);
-    },
-    100
-  );
-  React2.useEffect(() => {
-    if (state.status < types.AccountStatusEnum.Connected) return;
-    setBalanceRevalidating(true);
-    queryBalance(options.address, options.decimals);
-    if (account9.walletAdapter?.chainNamespace === types.ChainNamespace.solana) {
-      setAllowance(
-        account9.walletAdapter.formatUnits(types.MaxUint256, options.decimals)
-      );
-      return;
-    }
-    if (vaultAddress && options.address) {
-      queryAllowance({
-        address: options.address,
-        decimals: options.decimals,
-        vaultAddress
-      });
-    } else {
-      getAllowanceByDefaultAddress({
-        address: options.address,
-        decimals: options.decimals
-      });
-    }
-  }, [
-    state.status,
-    options.address,
-    options.decimals,
-    account9.address,
-    vaultAddress
-  ]);
-  const updateAllowanceWhenTxSuccess = React2.useCallback(
-    (txHash) => {
-      return account9.walletAdapter?.pollTransactionReceiptWithBackoff(txHash).then((receipt) => {
-        if (receipt.status === 1) {
-          account9.assetsManager.getAllowance({
-            address: options.address,
-            decimals: options.decimals,
-            vaultAddress
-          }).then((allowance2) => {
-            setAllowance(allowance2);
-          });
-        }
-      });
-    },
-    [account9, options.address, options.decimals, vaultAddress]
-  );
-  const enquireAllowance = React2.useCallback(async () => {
-    if (isNativeToken) {
-      return;
-    }
-    if (!options.address) {
-      throw new Error("address is required");
-    }
-    const _allowance = await account9.assetsManager.getAllowance({
-      address: options.address,
-      vaultAddress,
-      decimals: options.decimals
-    });
-    setAllowance(_allowance);
-    if (new utils.Decimal(quantity).greaterThan(_allowance)) {
-      throw new types.SDKError("Insufficient allowance");
-    }
-    return _allowance;
-  }, [
-    account9,
-    options.address,
-    options.decimals,
+  const {
+    balance,
+    balanceRevalidating,
+    fetchBalance,
+    fetchBalances,
+    setBalance
+  } = useBalance({
+    address: options.address,
+    decimals: options.decimals,
+    srcToken: options.srcToken,
+    account: account9,
+    status: state.status
+  });
+  const {
+    allowance,
+    allowanceRevalidating,
+    updateAllowanceWhenTxSuccess,
+    enquireAllowance
+  } = useAllowance({
+    address: options.address,
+    decimals: options.decimals,
     vaultAddress,
+    account: account9,
+    status: state.status,
     quantity,
-    isNativeToken
-  ]);
-  const checkIfChainTokenNeedRestApprove = React2.useCallback(
-    (chainId, token) => {
-      if (chainId !== types.ETHEREUM_MAINNET_CHAINID) {
-        return false;
-      }
-      if (token !== "USDT") {
-        return false;
-      }
-      return true;
-    },
-    []
-  );
+    chainId: dst?.chainId
+  });
+  const { depositFee, depositFeeRevalidating } = useDepositFee({
+    quantity,
+    account: account9,
+    targetChain,
+    decimals: options.decimals,
+    dstToken: options.dstToken,
+    vaultAddress,
+    isNativeToken,
+    dst
+  });
   const resetApprove = React2.useCallback(
     async (tokenAddress, decimal, vaultAddress2) => {
       const result = await account9.assetsManager.approve({
@@ -8009,20 +7784,9 @@ var useDeposit = (options) => {
         vaultAddress: vaultAddress2,
         decimals: decimal
       });
-      const txResult = await account9.walletAdapter?.pollTransactionReceiptWithBackoff(
-        result.hash
-      );
-      if (txResult && txResult.status === 1) {
-        account9.assetsManager.getAllowance({
-          address: tokenAddress,
-          decimals: decimal,
-          vaultAddress: vaultAddress2
-        }).then((allowance2) => {
-          setAllowance(allowance2);
-        });
-      }
+      await updateAllowanceWhenTxSuccess(result.hash);
     },
-    []
+    [account9, updateAllowanceWhenTxSuccess]
   );
   const approve = React2.useCallback(
     async (amount) => {
@@ -8059,7 +7823,6 @@ var useDeposit = (options) => {
       options.decimals,
       vaultAddress,
       updateAllowanceWhenTxSuccess,
-      checkIfChainTokenNeedRestApprove,
       resetApprove
     ]
   );
@@ -8105,104 +7868,287 @@ var useDeposit = (options) => {
     isNativeToken,
     vaultAddress
   ]);
-  const loopGetBalance = async (timeout) => {
-    if (getBalanceListener.current) {
-      clearTimeout(getBalanceListener.current);
-    }
-    const time = timeout ?? (account9.walletAdapter?.chainNamespace === types.ChainNamespace.solana ? 1e4 : 3e3);
-    if (balanceRef.current === "") {
-      setBalanceRevalidating(true);
-    }
-    currentAddressRef.current = options.address;
-    getBalanceListener.current = setTimeout(async () => {
+  return {
+    balance,
+    allowance,
+    /** deposit fee, unit: wei */
+    depositFee,
+    balanceRevalidating,
+    allowanceRevalidating,
+    depositFeeRevalidating,
+    isNativeToken,
+    dst,
+    targetChain,
+    /** input quantiy */
+    quantity,
+    /** set input quantity */
+    setQuantity,
+    approve,
+    deposit,
+    fetchBalance,
+    fetchBalances
+  };
+};
+function useBalance(options) {
+  const { srcToken, address, decimals, account: account9, status } = options;
+  const [balance, setBalance] = React2.useState("0");
+  const fetchBalance = React2.useCallback(
+    async (address2, decimals2) => {
       try {
-        const balance2 = await fetchBalanceHandler(
-          options.address,
-          options.decimals
-        );
-        setBalance(balance2);
-        balanceRef.current = balance2;
-        loopGetBalance();
+        if (types.isNativeTokenChecker(address2)) {
+          return account9.assetsManager.getNativeBalance({
+            decimals: decimals2
+          });
+        }
+        return account9.assetsManager.getBalance(address2, {
+          decimals: decimals2
+        });
       } catch (err) {
-        if (currentAddressRef.current !== options.address) return;
-        loopGetBalance(1e3);
-      } finally {
-        if (balanceRef.current !== "" && currentAddressRef.current === options.address) {
-          setBalanceRevalidating(false);
+        if (ignoreBalanceError({
+          chainNamespace: account9.walletAdapter?.chainNamespace,
+          err
+        })) {
+          return "0";
         }
+        throw err;
       }
-    }, time);
+    },
+    [srcToken, account9]
+  );
+  const fetchBalances = React2.useCallback(
+    async (tokens) => {
+      return account9.assetsManager.getBalances(tokens);
+    },
+    [account9]
+  );
+  const key = React2.useMemo(() => {
+    if (!address || status < types.AccountStatusEnum.Connected) {
+      return null;
+    }
+    return ["balance", address, decimals];
+  }, [status, address, decimals]);
+  const fetcher4 = React2.useCallback(async () => {
+    if (!address) {
+      return "0";
+    }
+    const balance2 = await fetchBalance(address, decimals);
+    return balance2;
+  }, [address, decimals, fetchBalance]);
+  const refreshInterval = React2.useMemo(() => {
+    return account9.walletAdapter?.chainNamespace === types.ChainNamespace.solana ? 1e4 : 3e3;
+  }, [account9]);
+  const { data: swrBalance, isLoading: balanceRevalidating } = useSWR5__namespace.default(
+    key,
+    fetcher4,
+    {
+      revalidateOnFocus: true,
+      refreshInterval,
+      errorRetryCount: 10
+    }
+  );
+  React2.useEffect(() => {
+    if (swrBalance !== void 0) {
+      setBalance(swrBalance || "0");
+    }
+  }, [swrBalance]);
+  return {
+    balance,
+    balanceRevalidating,
+    setBalance,
+    fetchBalance,
+    fetchBalances
   };
-  const getDepositFee = React2.useCallback(
-    async (quantity2) => {
-      return account9.assetsManager.getDepositFee({
-        amount: quantity2,
-        chain: targetChain?.network_infos,
-        decimals: options.decimals,
-        token: options.srcToken,
-        address: options.address
+}
+function useAllowance(options) {
+  const {
+    address,
+    decimals,
+    vaultAddress,
+    account: account9,
+    status,
+    quantity,
+    chainId
+  } = options;
+  const [allowance, setAllowance] = React2.useState("0");
+  const fetchAllowance = React2.useCallback(
+    async (options2) => {
+      const { address: address2, decimals: decimals2, vaultAddress: vaultAddress2 } = options2;
+      if (!address2 || !decimals2 || !vaultAddress2) {
+        return "0";
+      }
+      if (types.isNativeTokenChecker(address2) || account9.walletAdapter?.chainNamespace === types.ChainNamespace.solana) {
+        return account9.walletAdapter?.formatUnits(types.MaxUint256, decimals2);
+      }
+      const allowance2 = await account9.assetsManager.getAllowance({
+        address: address2,
+        vaultAddress: vaultAddress2,
+        decimals: decimals2
       });
+      return allowance2;
     },
-    [account9, targetChain, options.decimals, options.srcToken, options.address]
+    [account9]
   );
-  const enquiryDepositFee = React2.useCallback(() => {
-    if (isNaN(Number(quantity)) || !quantity || Number(quantity) === 0) {
-      setDepositFee(0n);
-      setDepositFeeRevalidating(false);
-      return;
+  const key = React2.useMemo(() => {
+    if (!address || !decimals || !vaultAddress || status < types.AccountStatusEnum.Connected) {
+      return null;
     }
-    setDepositFeeRevalidating(true);
-    getDepositFee(quantity).then((res = 0n) => {
-      const fee = BigInt(
-        new utils.Decimal(res.toString()).mul(types.DEPOSIT_FEE_RATE).toFixed(0, utils.Decimal.ROUND_UP).toString()
-      );
-      setDepositFee(fee);
-    }).catch((error) => {
-    }).finally(() => {
-      setDepositFeeRevalidating(false);
-    });
-  }, [quantity]);
-  React2.useEffect(() => {
-    enquiryDepositFee();
-  }, [quantity]);
+    return ["allowance", address, vaultAddress, decimals];
+  }, [status, address, vaultAddress, decimals, account9]);
+  const refreshInterval = React2.useMemo(() => {
+    return account9.walletAdapter?.chainNamespace === types.ChainNamespace.solana ? 1e4 : 3e3;
+  }, [account9, chainId]);
+  const fetcher4 = React2.useCallback(async () => {
+    return fetchAllowance({ address, decimals, vaultAddress });
+  }, [address, decimals, vaultAddress, fetchAllowance]);
+  const {
+    data: swrAllowance,
+    isLoading: allowanceRevalidating,
+    mutate: mutateAllowance
+  } = useSWR5__namespace.default(key, fetcher4, {
+    revalidateOnFocus: true,
+    refreshInterval,
+    errorRetryCount: 10
+  });
   React2.useEffect(() => {
-    if (!options.address) {
-      return;
+    if (swrAllowance !== void 0) {
+      setAllowance(swrAllowance || "0");
     }
-    currentAddressRef.current = options.address;
-    setBalance("0");
-    balanceRef.current = "";
-    setBalanceRevalidating(false);
-    loopGetBalance(0);
-    return () => {
-      if (getBalanceListener.current) {
-        clearTimeout(getBalanceListener.current);
-      }
-    };
-  }, [options.address, options.decimals]);
+  }, [swrAllowance]);
+  const updateAllowanceWhenTxSuccess = React2.useCallback(
+    (txHash) => {
+      return account9.walletAdapter?.pollTransactionReceiptWithBackoff(txHash).then((receipt) => {
+        if (receipt.status === 1) {
+          mutateAllowance();
+        }
+      });
+    },
+    [account9]
+  );
+  const enquireAllowance = React2.useCallback(async () => {
+    const _allowance = await fetchAllowance({
+      address,
+      decimals,
+      vaultAddress
+    });
+    setAllowance(_allowance);
+    if (new utils.Decimal(quantity).greaterThan(_allowance)) {
+      throw new types.SDKError("Insufficient allowance");
+    }
+    return _allowance;
+  }, [account9, address, decimals, vaultAddress, quantity]);
   return {
-    /** orderly support chain dst */
-    dst,
-    balance,
     allowance,
-    isNativeToken,
-    balanceRevalidating,
     allowanceRevalidating,
-    /** input quantiy */
-    quantity,
-    /** orderly deposit fee, unit: wei */
-    depositFee,
-    /** enquiring depositFee status on chain */
-    depositFeeRevalidating,
-    approve,
-    deposit,
-    fetchBalance: fetchBalanceHandler,
-    fetchBalances,
-    /** set input quantity */
-    setQuantity,
-    targetChain
+    updateAllowanceWhenTxSuccess,
+    enquireAllowance
   };
-};
+}
+function useDepositFee(options) {
+  const {
+    quantity,
+    account: account9,
+    targetChain,
+    decimals,
+    dstToken,
+    vaultAddress,
+    isNativeToken,
+    dst
+  } = options;
+  const getDepositFee = React2.useCallback(
+    async (quantity2) => {
+      if (!quantity2 || Number(quantity2) === 0 || isNaN(Number(quantity2))) {
+        return 0n;
+      }
+      const depositFee2 = await account9.assetsManager.getDepositFee({
+        amount: quantity2,
+        chain: targetChain?.network_infos,
+        decimals,
+        token: dstToken,
+        // TODO: when swap deposit, dstToken address is not same as src token address
+        address: dst?.address
+      });
+      let estimatedGasFee = 0n;
+      try {
+        const inputs = {
+          amount: quantity2,
+          fee: depositFee2,
+          decimals,
+          token: dstToken,
+          address: dst?.address,
+          vaultAddress
+        };
+        estimatedGasFee = isNativeToken ? await account9.assetsManager.estimateNativeDepositGasFee(inputs) : await account9.assetsManager.estimateDepositGasFee(inputs);
+      } catch (error) {
+        estimatedGasFee = 0n;
+      }
+      return depositFee2 + estimatedGasFee;
+    },
+    [
+      account9,
+      targetChain,
+      decimals,
+      dstToken,
+      dst?.address,
+      vaultAddress,
+      isNativeToken,
+      dst
+    ]
+  );
+  const key = React2.useMemo(() => {
+    if (!dst?.address || !decimals || !vaultAddress || !dstToken || !quantity || !targetChain?.network_infos?.chain_id) {
+      return null;
+    }
+    return [
+      "depositFee",
+      dst?.address,
+      vaultAddress,
+      dstToken,
+      decimals,
+      targetChain?.network_infos?.chain_id,
+      quantity
+    ];
+  }, [quantity, targetChain, decimals, dstToken, dst, vaultAddress]);
+  const fetcher4 = React2.useCallback(async () => {
+    const res = await getDepositFee(quantity);
+    return res;
+  }, [getDepositFee, quantity]);
+  const {
+    data,
+    isValidating: depositFeeRevalidating,
+    mutate: mutateDepositFee
+  } = useSWR5__namespace.default(key, fetcher4, {
+    revalidateOnFocus: true
+  });
+  const depositFee = React2.useMemo(() => {
+    const fee = data ?? 0n;
+    return BigInt(
+      new utils.Decimal(fee.toString()).mul(types.DEPOSIT_FEE_RATE).toFixed(0, utils.Decimal.ROUND_UP).toString()
+    );
+  }, [data]);
+  return { depositFee, depositFeeRevalidating, mutateDepositFee };
+}
+function useTargetChain(srcChainId) {
+  const networkId = useConfig("networkId");
+  const [_, { findByChainId }] = useChains(void 0);
+  const targetChain = React2.useMemo(() => {
+    let chain;
+    if (networkId === "testnet") {
+      chain = findByChainId(
+        utils.isTestnet(srcChainId) ? srcChainId : types.ARBITRUM_TESTNET_CHAINID
+      );
+    } else {
+      chain = findByChainId(srcChainId);
+      if (!chain?.network_infos?.bridgeless) {
+        chain = findByChainId(types.ARBITRUM_MAINNET_CHAINID);
+      }
+    }
+    return chain;
+  }, [networkId, findByChainId, srcChainId]);
+  return targetChain;
+}
+function checkIfChainTokenNeedRestApprove(chainId, token) {
+  return chainId === types.ETHEREUM_MAINNET_CHAINID && token === "USDT";
+}
 function ignoreBalanceError(options) {
   const { chainNamespace, err } = options;
   return chainNamespace === types.ChainNamespace.solana && err?.name === "TokenAccountNotFoundError";
@@ -8500,7 +8446,7 @@ var usePrivateDataObserver = (options) => {
     }
     let fieldChanges = {};
     filteredKeys.forEach((getKey, key) => {
-      useSWR.mutate(
+      useSWR5.mutate(
         useSWRInfinite.unstable_serialize((index, prevData) => [
           getKey(index, prevData),
           state.accountId
@@ -8565,7 +8511,7 @@ var usePrivateDataObserver = (options) => {
       onMessage: (data) => {
         const { symbol, leverage } = data?.accountDetail?.symbolLeverage || {};
         if (symbol && leverage) {
-          useSWR.mutate(
+          useSWR5.mutate(
             key,
             (prevPositions) => {
               if (prevPositions?.rows?.length) {
@@ -8595,7 +8541,7 @@ var usePrivateDataObserver = (options) => {
     const unsubscribe = ws.privateSubscribe("position", {
       onMessage: (data) => {
         const { positions: nextPositions } = data;
-        useSWR.mutate(
+        useSWR5.mutate(
           key,
           (prevPositions) => {
             if (!!prevPositions) {
@@ -11444,7 +11390,6 @@ var OrderlyConfigProvider = (props) => {
   const {
     configStore,
     keyStore,
-    // getWalletAdapter,
     walletAdapters,
     brokerId,
     brokerName,
@@ -11453,7 +11398,6 @@ var OrderlyConfigProvider = (props) => {
     chainFilter,
     customChains,
     enableSwapDeposit = false,
-    chainTransformer,
     dataAdapter,
     notification,
     amplitudeConfig,
@@ -11529,7 +11473,6 @@ var OrderlyConfigProvider = (props) => {
       enableSwapDeposit,
       defaultOrderbookTickSizes,
       defaultOrderbookSymbolDepths,
-      chainTransformer,
       dataAdapter,
       notification,
       amplitudeConfig,
@@ -11547,7 +11490,6 @@ var OrderlyConfigProvider = (props) => {
     defaultOrderbookSymbolDepths,
     dataAdapter,
     notification,
-    chainTransformer,
     amplitudeConfig,
     orderMetadata
   ]);
@@ -19042,18 +18984,18 @@ var useGetEstLiqPrice = (props) => {
   }, [estLiqPrice, markPrice, side]);
 };
 
-exports.swr = useSWR__namespace;
+exports.swr = useSWR5__namespace;
 Object.defineProperty(exports, "unstable_serialize", {
   enumerable: true,
-  get: function () { return useSWR.unstable_serialize; }
+  get: function () { return useSWR5.unstable_serialize; }
 });
 Object.defineProperty(exports, "useSWR", {
   enumerable: true,
-  get: function () { return useSWR__namespace.default; }
+  get: function () { return useSWR5__namespace.default; }
 });
 Object.defineProperty(exports, "useSWRConfig", {
   enumerable: true,
-  get: function () { return useSWR.useSWRConfig; }
+  get: function () { return useSWR5.useSWRConfig; }
 });
 Object.defineProperty(exports, "useConstant", {
   enumerable: true,