@orderly.network/hooks 2.4.2-alpha.0 → 2.5.0-alpha.1

package/dist/index.js

@@ -61,9 +61,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.4.2-alpha.0";
+  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.5.0-alpha.1";
 }
-var version_default = "2.4.2-alpha.0";
+var version_default = "2.5.0-alpha.1";
 var fetcher = (url, init2 = {}, queryOptions) => net.get(url, init2, queryOptions?.formatter);
 var OrderlyContext = React.createContext({
   // configStore: new MemoryConfigStore(),
@@ -130,20 +130,20 @@ var useAccountInstance = () => {
       "keyStore is not defined, please use OrderlyProvider and provide keyStore"
     );
   }
-  const account7 = useConstant__default.default(() => {
-    let account8 = core.SimpleDI.get("account");
-    if (!account8) {
-      account8 = new core.Account(
+  const account9 = useConstant__default.default(() => {
+    let account10 = core.SimpleDI.get("account");
+    if (!account10) {
+      account10 = new core.Account(
         configStore,
         keyStore,
         // getWalletAdapter,
         walletAdapters
       );
-      core.SimpleDI.registerByName("account", account8);
+      core.SimpleDI.registerByName("account", account10);
     }
-    return account8;
+    return account10;
   });
-  return account7;
+  return account9;
 };
 var fetcher2 = (url, options) => {
   const init2 = {
@@ -167,7 +167,7 @@ var useMutation = (url, method = "POST", options) => {
   if (!url.startsWith("http")) {
     fullUrl = `${apiBaseUrl}${url}`;
   }
-  const account7 = useAccountInstance();
+  const account9 = useAccountInstance();
   const { trigger, data, error, reset, isMutating } = useSWRMutation__default.default(
     fullUrl,
     // method === "POST" ? fetcher : deleteFetcher,
@@ -185,7 +185,7 @@ var useMutation = (url, method = "POST", options) => {
       url: newUrl,
       data: data2
     };
-    const signer = account7.signer;
+    const signer = account9.signer;
     const signature = await signer.sign(payload, utils.getTimestamp());
     return trigger(
       {
@@ -194,7 +194,7 @@ var useMutation = (url, method = "POST", options) => {
         method,
         signature: {
           ...signature,
-          "orderly-account-id": account7.accountId
+          "orderly-account-id": account9.accountId
         }
       },
       options2
@@ -216,9 +216,9 @@ var signatureMiddleware = (useSWRNext) => {
     try {
       const extendedFetcher = async (args) => {
         const url = Array.isArray(args) ? args[0] : args;
-        const account7 = core.SimpleDI.get("account");
+        const account9 = core.SimpleDI.get("account");
         const fullUrl = `${apiBaseUrl}${url}`;
-        const signer = account7.signer;
+        const signer = account9.signer;
         const payload = {
           method: "GET",
           url
@@ -227,7 +227,7 @@ var signatureMiddleware = (useSWRNext) => {
         return fetcher4(fullUrl, {
           headers: {
             ...signature,
-            "orderly-account-id": account7.accountId
+            "orderly-account-id": account9.accountId
           }
         });
       };
@@ -300,25 +300,25 @@ var useWS = () => {
   const { configStore } = React.useContext(OrderlyContext);
   const ws = useConstant__default.default(() => {
     let websocketClient = core.SimpleDI.get(WS_NAME);
-    const account7 = core.SimpleDI.get(core.Account.instanceName);
+    const account9 = core.SimpleDI.get(core.Account.instanceName);
     if (!websocketClient) {
       websocketClient = new net.WS({
         networkId: configStore.get("networkId"),
         publicUrl: configStore.get("publicWsUrl"),
         privateUrl: configStore.get("privateWsUrl"),
         onSigntureRequest: async (accountId) => {
-          const signer = account7.signer;
+          const signer = account9.signer;
           const timestamp = utils.getTimestamp();
           const result = await signer.signText(timestamp.toString());
           return { ...result, timestamp };
         }
       });
-      if ((account7.stateValue.status === types.AccountStatusEnum.EnableTrading || account7.stateValue.status === types.AccountStatusEnum.EnableTradingWithoutConnected) && account7.accountId) {
-        websocketClient.openPrivate(account7.accountId);
+      if ((account9.stateValue.status === types.AccountStatusEnum.EnableTrading || account9.stateValue.status === types.AccountStatusEnum.EnableTradingWithoutConnected) && account9.accountId) {
+        websocketClient.openPrivate(account9.accountId);
       }
-      account7.on("change:status", (nextState) => {
-        if ((nextState.status === types.AccountStatusEnum.EnableTrading || nextState.status === types.AccountStatusEnum.EnableTradingWithoutConnected) && account7.accountId) {
-          websocketClient.openPrivate(account7.accountId);
+      account9.on("change:status", (nextState) => {
+        if ((nextState.status === types.AccountStatusEnum.EnableTrading || nextState.status === types.AccountStatusEnum.EnableTradingWithoutConnected) && account9.accountId) {
+          websocketClient.openPrivate(account9.accountId);
         } else {
           websocketClient.closePrivate(1e3, "switch account");
         }
@@ -345,63 +345,63 @@ var useAccount = () => {
       "keyStore is not defined, please use OrderlyProvider and provide keyStore"
     );
   }
-  const account7 = useAccountInstance();
-  const [state, setState] = React.useState(account7.stateValue);
+  const account9 = useAccountInstance();
+  const [state, setState] = React.useState(account9.stateValue);
   const { track: track2 } = useTrack();
   const statusChangeHandler = (nextState) => {
     setState(() => nextState);
   };
   React.useEffect(() => {
-    account7.on("change:status", statusChangeHandler);
+    account9.on("change:status", statusChangeHandler);
     return () => {
-      account7.off("change:status", statusChangeHandler);
+      account9.off("change:status", statusChangeHandler);
     };
-  }, [account7]);
+  }, [account9]);
   const createOrderlyKey = React.useCallback(
     async (remember) => {
       track2(types.TrackerEventName.signinSuccess, {
-        network: account7.chainId,
+        network: account9.chainId,
         wallet: state.connectWallet?.name
       });
-      return account7.createOrderlyKey(remember ? 365 : 30).then((res) => {
-        return account7.restoreSubAccount().then((_) => {
+      return account9.createOrderlyKey(remember ? 365 : 30).then((res) => {
+        return account9.restoreSubAccount().then((_) => {
           return res;
         });
       });
     },
-    [account7, state]
+    [account9, state]
   );
   const ws = useWS();
   const switchAccount = React.useCallback(
     async (accountId) => {
       ws.closePrivate(1e3, "switch account");
-      return account7.switchAccount(accountId);
+      return account9.switchAccount(accountId);
     },
-    [account7]
+    [account9]
   );
   const createAccount = React.useCallback(async () => {
-    return account7.createAccount();
-  }, [account7]);
+    return account9.createAccount();
+  }, [account9]);
   const createSubAccount = React.useCallback(
     async (description) => {
-      return account7.createSubAccount(description);
+      return account9.createSubAccount(description);
     },
-    [account7]
+    [account9]
   );
   const updateSubAccount = React.useCallback(
     async (value) => {
-      return account7.updateSubAccount(value);
+      return account9.updateSubAccount(value);
     },
-    [account7]
+    [account9]
   );
   const refreshSubAccountBalances = React.useCallback(() => {
-    return account7.refreshSubAccountBalances();
-  }, [account7]);
+    return account9.refreshSubAccountBalances();
+  }, [account9]);
   const isSubAccount = React.useMemo(() => {
     return state.accountId !== state.mainAccountId;
   }, [state]);
   return {
-    account: account7,
+    account: account9,
     state,
     isSubAccount,
     isMainAccount: !isSubAccount,
@@ -1187,6 +1187,24 @@ var useAppStore = zustand.create()(
   }))
 );
 var useAccountInfo = () => useAppStore((state) => state.accountInfo);
+var useTokensInfoStore = zustand.create(
+  (set) => ({
+    tokensInfo: [],
+    setTokensInfo(data) {
+      set({ tokensInfo: data });
+    }
+  })
+);
+var useTokensInfo = () => {
+  const tokensInfo = useTokensInfoStore((state) => state.tokensInfo);
+  return tokensInfo;
+};
+var useTokenInfo = (token) => {
+  const tokensInfo = useTokensInfo();
+  return React.useMemo(() => {
+    return tokensInfo?.find((item) => item.token === token);
+  }, [tokensInfo, token]);
+};
 
 // src/orderly/calculator/baseCalculator.ts
 var BaseCalculator = class {
@@ -1254,6 +1272,7 @@ var CalculatorContext = class _CalculatorContext {
     this.accountInfo = useAppStore.getState().accountInfo;
     this.symbolsInfo = useAppStore.getState().symbolsInfo;
     this.fundingRates = useAppStore.getState().fundingRates;
+    this.tokensInfo = useTokensInfoStore.getState().tokensInfo;
   }
   get(fn) {
     return fn(this.output);
@@ -1770,25 +1789,68 @@ function createGetter(data, depth = 2) {
     }
   });
 }
-
-// src/utils/parseHolding.ts
-var parseHolding = (holding, markPrices) => {
+var parseHolding = (holding, indexPrices, tokensInfo) => {
   const nonUSDC = [];
   let USDC_holding = 0;
   holding.forEach((item) => {
     if (item.token === "USDC") {
       USDC_holding = item.holding;
     } else {
+      const tokenInfo = tokensInfo.find(({ token }) => token === item.token);
+      const {
+        base_weight = 0,
+        discount_factor = 0,
+        user_max_qty = 0
+      } = tokenInfo || {};
+      const holdingQty = item?.holding ?? 0;
+      const indexPrice = indexPrices[`PERP_${item.token}_USDC`] ?? 0;
+      const collateralRatio4 = perp.account.collateralRatio({
+        baseWeight: base_weight,
+        discountFactor: discount_factor,
+        collateralQty: holdingQty,
+        collateralCap: user_max_qty,
+        indexPrice
+      });
       nonUSDC.push({
-        holding: item.holding,
-        markPrice: markPrices[item.token] ?? 0,
-        // markPrice: 0,
-        discount: 0
+        holding: holdingQty,
+        indexPrice,
+        collateralCap: user_max_qty,
+        collateralRatio: collateralRatio4
       });
     }
   });
   return [USDC_holding, nonUSDC];
 };
+var useIndexPriceStore = zustand.create((set) => ({
+  indexPrices: {},
+  actions: {
+    updateIndexPrice: (indexPrice) => {
+      set({
+        indexPrices: indexPrice
+      });
+    }
+  }
+}));
+
+// src/orderly/calculator/indexPrice.ts
+var IndexPriceCalculatorName = "indexPriceCalculator";
+var IndexPriceCalculator = class extends BaseCalculator {
+  constructor() {
+    super(...arguments);
+    this.name = IndexPriceCalculatorName;
+  }
+  calc(scope, data, ctx) {
+    return data;
+  }
+  update(data) {
+    if (!data)
+      return;
+    useIndexPriceStore.getState().actions.updateIndexPrice(data);
+  }
+  static getValue() {
+    return useIndexPriceStore.getState().indexPrices;
+  }
+};
 
 // src/orderly/calculator/portfolio.ts
 var PortfolioCalculatorName = "portfolio";
@@ -1798,7 +1860,8 @@ var PortfolioCalculator = class extends BaseCalculator {
     this.name = PortfolioCalculatorName;
   }
   calc(scope, data, ctx) {
-    let markPrices, positions3;
+    let markPrices;
+    let indexPrices;
     const portfolio = this.getPortfolio(ctx);
     if (scope === "markPrice" /* MARK_PRICE */) {
       markPrices = data;
@@ -1807,7 +1870,14 @@ var PortfolioCalculator = class extends BaseCalculator {
         (cache) => cache[MarketCalculatorName]
       );
     }
-    positions3 = ctx.get(
+    if (scope === "indexPrice" /* INDEX_PRICE */) {
+      indexPrices = data;
+    } else {
+      indexPrices = ctx.get(
+        (cache) => cache[IndexPriceCalculatorName]
+      );
+    }
+    const positions3 = ctx.get(
       (output) => output.positionCalculator_all
     );
     let holding = portfolio.holding;
@@ -1829,25 +1899,40 @@ var PortfolioCalculator = class extends BaseCalculator {
     }
     const accountInfo = ctx.accountInfo;
     const symbolsInfo = ctx.symbolsInfo;
+    const tokensInfo = ctx.tokensInfo;
     return this.format({
       holding,
       positions: positions3,
       markPrices,
       accountInfo,
-      symbolsInfo
+      symbolsInfo,
+      indexPrices,
+      tokensInfo: tokensInfo ?? []
     });
   }
   getPortfolio(ctx) {
     return ctx.get((output) => output[this.name]) || useAppStore.getState().portfolio;
   }
   format(inputs) {
-    const { holding, positions: positions3, markPrices, accountInfo, symbolsInfo } = inputs;
-    if (!holding || !positions3 || !Array.isArray(positions3.rows) || !markPrices || !accountInfo) {
+    const {
+      holding,
+      positions: positions3,
+      markPrices,
+      indexPrices,
+      accountInfo,
+      symbolsInfo,
+      tokensInfo
+    } = inputs;
+    if (!holding || !positions3 || !Array.isArray(positions3.rows) || !markPrices || !indexPrices || !accountInfo) {
       return null;
     }
     const unsettledPnL = ramda.pathOr(0, ["total_unsettled_pnl"])(positions3);
     const unrealizedPnL = ramda.pathOr(0, ["total_unreal_pnl"])(positions3);
-    const [USDC_holding, nonUSDC] = parseHolding(holding, markPrices);
+    const [USDC_holding, nonUSDC] = parseHolding(
+      holding,
+      indexPrices,
+      tokensInfo
+    );
     const usdc = holding.find((item) => item.token === "USDC");
     const totalCollateral = perp.account.totalCollateral({
       USDCHolding: USDC_holding,
@@ -1902,36 +1987,6 @@ var PortfolioCalculator = class extends BaseCalculator {
     }
   }
 };
-var useIndexPriceStore = zustand.create((set) => ({
-  indexPrices: {},
-  actions: {
-    updateIndexPrice: (indexPrice) => {
-      set({
-        indexPrices: indexPrice
-      });
-    }
-  }
-}));
-
-// src/orderly/calculator/indexPrice.ts
-var IndexPriceCalculatorName = "indexPriceCalculator";
-var IndexPriceCalculator = class extends BaseCalculator {
-  constructor() {
-    super(...arguments);
-    this.name = IndexPriceCalculatorName;
-  }
-  calc(scope, data, ctx) {
-    return data;
-  }
-  update(data) {
-    if (!data)
-      return;
-    useIndexPriceStore.getState().actions.updateIndexPrice(data);
-  }
-  static getValue() {
-    return useIndexPriceStore.getState().indexPrices;
-  }
-};
 
 // src/useCalculatorService.ts
 var useCalculatorService = () => {
@@ -3272,6 +3327,68 @@ var useLeverage = () => {
     maxLeverage: memoizedMaxLeverage
   };
 };
+
+// src/orderly/useOdosQuote.ts
+var useOdosQuote = () => {
+  return useMutation(`https://api.odos.xyz/sor/quote/v2`);
+};
+var { LTV, collateralRatio } = perp.account;
+var useComputedLTV = (options = {}) => {
+  const { input, token } = options;
+  const isUSDC = token?.toUpperCase() === "USDC";
+  const tokensInfo = useTokensInfo();
+  const { usdc, data: holdingList = [] } = useHoldingStream();
+  const { data: indexPrices } = useIndexPricesStream();
+  const { unsettledPnL } = useCollateral();
+  const usdcBalance = React.useMemo(() => {
+    if (isUSDC && input) {
+      return new utils.Decimal(usdc?.holding ?? 0).add(input).toNumber();
+    }
+    return usdc?.holding ?? 0;
+  }, [usdc?.holding, input, token, isUSDC]);
+  const getAdjustedQty = React.useCallback(
+    (item) => {
+      if (input && item.token === token) {
+        return new utils.Decimal(item?.holding ?? 0).add(input).toNumber();
+      }
+      return item?.holding ?? 0;
+    },
+    [input, token]
+  );
+  const memoizedLTV = React.useMemo(() => {
+    return LTV({
+      usdcBalance,
+      upnl: unsettledPnL,
+      assets: holdingList.filter((h) => h.token.toUpperCase() !== "USDC").map((item) => {
+        const indexPrice = indexPrices[`PERP_${item.token}_USDC`] ?? 0;
+        const findToken = tokensInfo?.find((i) => i.token === item.token);
+        const qty = getAdjustedQty(item);
+        return {
+          qty,
+          indexPrice,
+          weight: collateralRatio({
+            baseWeight: findToken?.base_weight ?? 0,
+            discountFactor: findToken?.discount_factor ?? 0,
+            collateralCap: findToken?.user_max_qty ?? qty,
+            collateralQty: qty,
+            indexPrice
+          })
+        };
+      })
+    });
+  }, [
+    usdcBalance,
+    unsettledPnL,
+    holdingList,
+    indexPrices,
+    tokensInfo,
+    getAdjustedQty
+  ]);
+  if (new utils.Decimal(usdcBalance).add(new utils.Decimal(unsettledPnL)).gte(utils.zero)) {
+    return 0;
+  }
+  return new utils.Decimal(memoizedLTV).mul(100).toDecimalPlaces(2, utils.Decimal.ROUND_DOWN).toNumber();
+};
 var useFundingRate = (symbol) => {
   if (!symbol) {
     throw new types.SDKError("Symbol is required");
@@ -4028,7 +4145,8 @@ function useChains(networkId, options = {}) {
   const {
     filteredChains: allowedChains,
     configStore,
-    customChains
+    customChains,
+    chainTransformer
   } = React.useContext(OrderlyContext);
   const filterFun = React.useRef(options?.filter);
   filterFun.current = options?.filter;
@@ -4039,7 +4157,7 @@ function useChains(networkId, options = {}) {
     revalidateOnReconnect: false,
     // If false, undefined data gets cached against the key.
     revalidateOnMount: true,
-    // dont duplicate a request w/ same key for 1hr
+    // don't duplicate a request with the same key for 1hr
     dedupingInterval: 36e5,
     ...swrOptions
   };
@@ -4055,13 +4173,15 @@ function useChains(networkId, options = {}) {
     }
   );
   const brokerId = configStore.get("brokerId");
+  const env = configStore.get("env");
+  const brokerIdQuery = brokerId !== "orderly" ? `?broker_id=${brokerId}` : "";
   const needFetchFromAPI = options.forceAPI || !customChains;
   const { data: chainInfos, error: chainInfoErr } = useQuery(
-    needFetchFromAPI ? `https://api.orderly.org/v1/public/chain_info${brokerId !== "orderly" ? `?broker_id=${brokerId}` : ""}` : null,
+    needFetchFromAPI ? `https://api.orderly.org/v1/public/chain_info${brokerIdQuery}` : null,
     { ...commonSwrOpts }
   );
   const { data: testChainInfos, error: testChainInfoError } = useQuery(
-    needFetchFromAPI ? `https://testnet-api.orderly.org/v1/public/chain_info${brokerId !== "orderly" ? `?broker_id=${brokerId}` : ""}` : null,
+    needFetchFromAPI ? `https://testnet-api.orderly.org/v1/public/chain_info${brokerIdQuery}` : null,
     {
       ...commonSwrOpts,
       fallbackData: testnetChainFallback,
@@ -4069,35 +4189,34 @@ function useChains(networkId, options = {}) {
       }
     }
   );
+  const { data: envChainInfos, error: envChainInfoError } = useQuery(
+    needFetchFromAPI && env !== "prod" ? `/v1/public/chain_info${brokerIdQuery}` : null,
+    commonSwrOpts
+  );
+  const { swapChains, swapChainsError } = useSwapChains();
   const chains = React.useMemo(() => {
-    const tokenChains = fillChainsInfo(
-      tokenChainsRes,
-      filterFun.current,
-      chainInfos
-    );
-    const testTokenChains = fillChainsInfo(
-      testTokenChainsRes,
-      void 0,
-      testChainInfos
-    );
-    let testnetArr = needFetchFromAPI ? filterAndUpdateChains(testTokenChains, testChainInfos, void 0, true) : customChains?.testnet;
-    tokenChains?.forEach((item) => {
-      const chainId = item.network_infos?.chain_id;
-      chainsMap.current.set(chainId, item);
+    const mainnetChains = formatChains({
+      tokenChains: tokenChainsRes,
+      chainInfos,
+      swapChains,
+      filter: filterFun.current,
+      mainnet: true,
+      chainTransformer
     });
-    testnetArr.forEach((chain) => {
+    const testnetChains = formatChains({
+      tokenChains: testTokenChainsRes,
+      chainInfos: formatTestnetChainInfos(testChainInfos, envChainInfos),
+      swapChains,
+      mainnet: false,
+      chainTransformer
+    });
+    let mainnetArr = needFetchFromAPI ? mainnetChains : customChains?.mainnet;
+    let testnetArr = needFetchFromAPI ? testnetChains : customChains?.testnet;
+    testnetArr?.forEach((chain) => {
       chainsMap.current.set(chain.network_infos?.chain_id, chain);
     });
-    let mainnetArr = [];
-    mainnetArr = filterAndUpdateChains(
-      tokenChains,
-      chainInfos,
-      filterFun.current
-    );
-    mainnetArr = needFetchFromAPI ? mainnetArr : customChains?.mainnet;
-    mainnetArr.forEach((item) => {
-      const chainId = item.network_infos?.chain_id;
-      chainsMap.current.set(chainId, item);
+    mainnetArr?.forEach((chain) => {
+      chainsMap.current.set(chain.network_infos?.chain_id, chain);
     });
     mainnetArr = filterByAllowedChains(mainnetArr, allowedChains?.mainnet);
     testnetArr = filterByAllowedChains(
@@ -4126,7 +4245,10 @@ function useChains(networkId, options = {}) {
     testTokenChainsRes,
     customChains,
     pickField,
-    allowedChains
+    allowedChains,
+    swapChains,
+    chainTransformer,
+    envChainInfos
   ]);
   const findByChainId = React.useCallback(
     (chainId, field) => {
@@ -4157,7 +4279,7 @@ function useChains(networkId, options = {}) {
     {
       findByChainId,
       checkChainSupport,
-      error: tokenError
+      error: tokenError || swapChainsError
     }
   ];
 }
@@ -4169,80 +4291,173 @@ function _checkChainSupport(chainId, chains) {
     return chain.network_infos.chain_id === chainId;
   });
 }
-function fillChainsInfo(chains, filter, chainInfos) {
-  const _chains = [];
-  chains?.forEach((item) => {
-    item.chain_details.forEach((chain) => {
-      const chainId = Number(chain.chain_id);
-      const chainInfo = chainInfos?.find(
-        (item2) => item2.chain_id == chainId
-      );
-      const _chain = {
-        network_infos: {
-          name: chain.chain_name ?? chainInfo?.name ?? "--",
-          chain_id: chainId,
-          withdrawal_fee: chain.withdrawal_fee,
-          cross_chain_withdrawal_fee: chain.cross_chain_withdrawal_fee,
-          bridgeless: true
-        },
-        token_infos: [
-          {
-            symbol: item.token,
-            address: chain.contract_address,
-            decimals: chain.decimals,
-            display_name: chain.display_name
-          }
-        ]
+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 } = React.useContext(OrderlyContext);
+  const { data: swapChainsRes, error: swapChainsError } = useSWR__namespace.default(
+    () => enableSwapDeposit ? "https://fi-api.woo.org/swap_support" : null,
+    (url) => fetch(url).then((res) => res.json()),
+    {
+      revalidateIfStale: false,
+      revalidateOnFocus: false,
+      revalidateOnReconnect: false,
+      // If false, undefined data gets cached against the key.
+      revalidateOnMount: true,
+      // dont duplicate a request w/ same key for 1hr
+      dedupingInterval: 36e5
+    }
+  );
+  const swapChains = React.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
       };
-      if (typeof filter === "function") {
-        if (!filter(_chain))
-          return;
+      const nativeToken = token_infos.find(
+        (item) => item.symbol === network_infos.currency_symbol
+      );
+      if (nativeToken) {
+        networkInfos.currency_decimal = nativeToken.decimals;
+      } else {
+        networkInfos.currency_decimal = 18;
       }
-      _chains.push(_chain);
+      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 || []
+      };
     });
-  });
-  return _chains;
+  }, [enableSwapDeposit, swapChainsRes]);
+  return { swapChains, swapChainsError };
 }
-function filterAndUpdateChains(chains, chainInfos, filter, isTestNet) {
-  const chainsMap = /* @__PURE__ */ new Map();
-  chains.forEach((chain) => {
-    const _chain = { ...chain };
-    const networkInfo = chainInfos?.find(
-      (item) => item.chain_id == chain.network_infos.chain_id
+function formatChains({
+  chainInfos = [],
+  tokenChains = [],
+  swapChains = [],
+  filter,
+  mainnet,
+  chainTransformer
+}) {
+  const chains = [];
+  for (const chainInfo of chainInfos) {
+    const chainId = Number(chainInfo.chain_id);
+    const swapChainInfo = swapChains.find(
+      (item) => item.network_infos.chain_id === chainId
     );
-    if (networkInfo) {
-      const { name, public_rpc_url, currency_symbol, explorer_base_url } = networkInfo;
-      _chain.network_infos = {
-        ..._chain.network_infos,
-        name,
-        shortName: name,
-        public_rpc_url,
-        currency_symbol,
-        bridge_enable: true,
-        mainnet: !isTestNet,
-        explorer_base_url
-        // est_txn_mins: null,
+    const swapNetworkInfo = swapChainInfo?.network_infos;
+    const swapTokenInfos = swapChainInfo?.token_infos || [];
+    const {
+      name,
+      public_rpc_url,
+      currency_symbol,
+      explorer_base_url,
+      vault_address
+    } = chainInfo;
+    const { shortName, cross_chain_router, depositor, est_txn_mins } = swapNetworkInfo || {};
+    const network_infos = {
+      name,
+      chain_id: chainId,
+      bridgeless: true,
+      mainnet,
+      public_rpc_url,
+      currency_symbol,
+      bridge_enable: true,
+      explorer_base_url,
+      // swap field
+      shortName: shortName ?? name,
+      cross_chain_router,
+      depositor,
+      est_txn_mins,
+      vault_address
+    };
+    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
+      );
+      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,
+        display_name: chain?.display_name,
+        withdrawal_fee: chain?.withdrawal_fee,
+        cross_chain_withdrawal_fee: chain?.cross_chain_withdrawal_fee,
+        minimum_withdraw_amount: item.minimum_withdraw_amount,
+        base_weight: item.base_weight,
+        discount_factor: item.discount_factor,
+        haircut: item.haircut,
+        user_max_qty: item.user_max_qty,
+        is_collateral: item.is_collateral,
+        swap_enable: false
       };
-    }
+    });
+    const swapTokens = swapTokenInfos?.filter((item) => {
+      return !tokenInfos?.some((token) => token.symbol === item.symbol);
+    });
+    const _chain = {
+      network_infos,
+      token_infos: [...tokenInfos, ...swapTokens]
+    };
     if (typeof filter === "function") {
       if (!filter(_chain))
-        return;
-    }
-    if (networkInfo) {
-      chainsMap.set(chain.network_infos.chain_id, _chain);
+        continue;
     }
-  });
-  return Array.from(chainsMap.values());
+    chains.push(_chain);
+  }
+  if (typeof chainTransformer === "function") {
+    return chainTransformer({
+      chains,
+      chainInfos,
+      tokenChains,
+      swapChains,
+      mainnet
+    });
+  }
+  return chains;
 }
-function filterByAllowedChains(chains, allowedChains) {
-  if (!allowedChains) {
-    return chains;
+function formatTestnetChainInfos(chainInfos, envChainInfos) {
+  if (!chainInfos || !envChainInfos || !Array.isArray(chainInfos) || !Array.isArray(envChainInfos)) {
+    return chainInfos;
   }
-  return chains.filter(
-    (chain) => allowedChains.some(
-      (allowedChain) => allowedChain.id === parseInt(chain?.network_infos?.chain_id)
-    )
-  );
+  return chainInfos.map((chain) => {
+    const info = envChainInfos.find((item) => item.chain_id === chain.chain_id);
+    if (info) {
+      chain.vault_address = info.vault_address;
+    }
+    return chain;
+  });
 }
 function useStorageChain() {
   const [chain, setChain] = useLocalStorage(types.ChainKey, null);
@@ -4264,9 +4479,10 @@ function useStorageChain() {
 var useChain = (token) => {
   const { data, isLoading } = useQuery("/v1/public/token");
   const chains = React.useMemo(() => {
-    if (!data)
+    if (!data) {
       return null;
-    let item = data.find((chain) => chain.token === token);
+    }
+    const item = data.find((chain) => chain.token === token);
     if (item) {
       item.chain_details = item.chain_details.map((d) => {
         const chain = types.chainsInfoMap.get(Number(d.chain_id));
@@ -4333,19 +4549,72 @@ var useHoldingStream = () => {
   };
 };
 
+// src/orderly/useMaxWithdrawal.ts
+var { maxWithdrawalUSDC, maxWithdrawalOtherCollateral, collateralRatio: collateralRatio2 } = perp.account;
+function useMaxWithdrawal(token) {
+  const { unsettledPnL, freeCollateral } = useCollateral();
+  const tokenInfo = useTokenInfo(token);
+  const { data: indexPrices } = useIndexPricesStream();
+  const { usdc, data: holdings = [] } = useHoldingStream();
+  const holding = React.useMemo(() => {
+    return holdings?.find((item) => item?.token === token);
+  }, [holdings, token]);
+  const usdcBalance = usdc?.holding ?? 0;
+  const indexPrice = React.useMemo(() => {
+    if (token === "USDC") {
+      return 1;
+    }
+    const symbol = `PERP_${token}_USDC`;
+    return indexPrices[symbol] ?? 0;
+  }, [token, indexPrices]);
+  const memoizedCollateralRatio = React.useMemo(() => {
+    const { base_weight = 0, discount_factor = 0 } = tokenInfo || {};
+    const holdingQty = holding?.holding ?? 0;
+    return collateralRatio2({
+      baseWeight: base_weight,
+      discountFactor: discount_factor,
+      collateralQty: holdingQty,
+      collateralCap: tokenInfo?.user_max_qty ?? holdingQty,
+      indexPrice
+    });
+  }, [holdings, tokenInfo, indexPrice, token, holding]);
+  const maxAmount = React.useMemo(() => {
+    if (token === "USDC") {
+      return maxWithdrawalUSDC({
+        USDCBalance: usdcBalance,
+        freeCollateral,
+        upnl: unsettledPnL ?? 0
+      });
+    }
+    return maxWithdrawalOtherCollateral({
+      collateralQty: holding?.holding ?? 0,
+      freeCollateral,
+      indexPrice,
+      weight: memoizedCollateralRatio
+    });
+  }, [
+    usdcBalance,
+    freeCollateral,
+    unsettledPnL,
+    memoizedCollateralRatio,
+    holdings,
+    indexPrice,
+    token,
+    holding
+  ]);
+  return maxAmount;
+}
+
 // src/orderly/useWithdraw.ts
 var useWithdraw = (options) => {
-  const { account: account7, state } = useAccount();
+  const { srcChainId, token, decimals } = options;
+  const { account: account9, state } = useAccount();
   const [isLoading, setIsLoading] = React.useState(false);
   const { unsettledPnL, availableBalance, freeCollateral } = useCollateral();
   const networkId = useConfig("networkId");
   const [_, { findByChainId }] = useChains(void 0);
-  useEventEmitter();
   const { track: track2 } = useTrack();
-  const { usdc } = useHoldingStream();
-  const maxAmount = React.useMemo(() => {
-    return freeCollateral;
-  }, [freeCollateral]);
+  const maxAmount = useMaxWithdrawal(token);
   const availableWithdraw = React.useMemo(() => {
     if (unsettledPnL < 0) {
       return freeCollateral;
@@ -4357,19 +4626,19 @@ var useWithdraw = (options) => {
     let chain;
     if (networkId === "testnet") {
       chain = findByChainId(
-        utils.isTestnet(options?.srcChainId) ? options?.srcChainId : types.ARBITRUM_TESTNET_CHAINID
+        utils.isTestnet(srcChainId) ? srcChainId : types.ARBITRUM_TESTNET_CHAINID
       );
     } else {
-      chain = findByChainId(options?.srcChainId);
+      chain = findByChainId(srcChainId);
       if (!chain?.network_infos?.bridgeless) {
         chain = findByChainId(types.ARBITRUM_MAINNET_CHAINID);
       }
     }
     return chain;
-  }, [networkId, findByChainId, options?.srcChainId]);
+  }, [networkId, findByChainId, srcChainId]);
   const dst = React.useMemo(() => {
     const USDC = targetChain?.token_infos.find(
-      (token) => token.symbol === "USDC"
+      (token2) => token2.symbol === "USDC"
     );
     return {
       symbol: USDC?.display_name || "USDC",
@@ -4381,7 +4650,7 @@ var useWithdraw = (options) => {
   }, [targetChain]);
   const withdraw = React.useCallback(
     (inputs) => {
-      return account7.assetsManager.withdraw({ ...inputs, decimals: 6 }).then((res) => {
+      return account9.assetsManager.withdraw({ ...inputs, decimals: decimals ?? 6 }).then((res) => {
         if (res.success) {
           track2(types.TrackerEventName.withdrawSuccess, {
             wallet: state?.connectWallet?.name,
@@ -4400,16 +4669,17 @@ var useWithdraw = (options) => {
         throw err;
       });
     },
-    [state, targetChain, state, options?.decimals]
+    [state, targetChain, state, decimals]
   );
   return {
     dst,
     withdraw,
     isLoading,
     maxAmount,
+    unsettledPnL,
     availableBalance,
-    availableWithdraw,
-    unsettledPnL
+    /** @deprecated use maxAmount instead */
+    availableWithdraw
   };
 };
 var useDeposit = (options) => {
@@ -4422,7 +4692,7 @@ var useDeposit = (options) => {
   const [depositFeeRevalidating, setDepositFeeRevalidating] = React.useState(false);
   const [balance, setBalance] = React.useState("0");
   const [allowance, setAllowance] = React.useState("0");
-  const { account: account7, state } = useAccount();
+  const { account: account9, state } = useAccount();
   const { track: track2 } = useTrack();
   const prevAddress = React.useRef();
   const getBalanceListener = React.useRef();
@@ -4448,8 +4718,8 @@ var useDeposit = (options) => {
       symbol: "USDC",
       address: USDC?.address,
       decimals: USDC?.decimals,
-      chainId: targetChain?.network_infos?.chain_id,
-      network: targetChain?.network_infos?.shortName
+      chainId: targetChain?.network_infos.chain_id,
+      network: targetChain?.network_infos.shortName
     };
   }, [targetChain]);
   const isNativeToken = React.useMemo(
@@ -4459,12 +4729,12 @@ var useDeposit = (options) => {
   const fetchBalanceHandler = React.useCallback(
     async (address, decimals) => {
       let balance2;
-      if (!!address && types.isNativeTokenChecker(address)) {
-        balance2 = await account7.assetsManager.getNativeBalance({
+      if (address && types.isNativeTokenChecker(address)) {
+        balance2 = await account9.assetsManager.getNativeBalance({
           decimals
         });
       } else {
-        balance2 = await account7.assetsManager.getBalance(address, { decimals });
+        balance2 = await account9.assetsManager.getBalance(address, { decimals });
       }
       return balance2;
     },
@@ -4490,29 +4760,30 @@ var useDeposit = (options) => {
         continue;
       }
       tasks.push(
-        account7.assetsManager.getBalanceByAddress(token.address, {
+        account9.assetsManager.getBalance(token.address, {
           decimals: token?.decimals
         })
       );
     }
-    await Promise.all(tasks);
+    const balances = await Promise.all(tasks);
+    return balances;
   }, []);
   const getAllowance = async (inputs) => {
-    const { address, vaultAddress, decimals } = inputs;
-    const key = `${address}-${vaultAddress}`;
+    const { address, vaultAddress: vaultAddress2, decimals } = inputs;
+    const key = `${address}-${vaultAddress2}`;
     if (prevAddress.current === key)
       return;
-    if (!address || !vaultAddress)
+    if (!address || !vaultAddress2)
       return;
-    if (address && types.isNativeTokenChecker(address))
+    if (types.isNativeTokenChecker(address))
       return;
     prevAddress.current = key;
-    const allowance2 = await account7.assetsManager.getAllowance({
+    const allowance2 = await account9.assetsManager.getAllowance({
       address,
-      vaultAddress,
+      vaultAddress: vaultAddress2,
       decimals
     });
-    setAllowance(() => allowance2);
+    setAllowance(allowance2);
     return allowance2;
   };
   const getAllowanceByDefaultAddress = async (inputs) => {
@@ -4522,12 +4793,31 @@ var useDeposit = (options) => {
     if (!address || types.isNativeTokenChecker(address))
       return;
     prevAddress.current = address;
-    const allowance2 = await account7.assetsManager.getAllowance({
+    const allowance2 = await account9.assetsManager.getAllowance({
       address,
-      decimals
+      decimals,
+      vaultAddress
     });
-    setAllowance(() => allowance2);
+    setAllowance(allowance2);
+    return allowance2;
   };
+  const vaultAddress = React.useMemo(() => {
+    if (dst.chainId !== options.srcChainId) {
+      return options.crossChainRouteAddress;
+    }
+    if (options.srcToken !== (options.dstToken || dst.symbol)) {
+      return options.depositorAddress;
+    }
+    return targetChain?.network_infos.vault_address;
+  }, [
+    dst,
+    options.srcChainId,
+    options.srcToken,
+    options.dstToken,
+    options.crossChainRouteAddress,
+    options.depositorAddress,
+    targetChain
+  ]);
   const queryBalance = useDebounce.useDebouncedCallback(
     (address, decimals) => {
       fetchBalance(address, decimals).finally(() => {
@@ -4547,89 +4837,113 @@ var useDeposit = (options) => {
       return;
     setBalanceRevalidating(true);
     queryBalance(options.address, options.decimals);
-    const params = {
-      address: options.address,
-      decimals: options.decimals
-    };
-    if (account7.walletAdapter?.chainNamespace === types.ChainNamespace.solana) {
+    if (account9.walletAdapter?.chainNamespace === types.ChainNamespace.solana) {
       setAllowance(
-        account7.walletAdapter.formatUnits(types.MaxUint256, options.decimals)
+        account9.walletAdapter.formatUnits(types.MaxUint256, options.decimals)
       );
       return;
     }
-    if (dst.chainId !== options.srcChainId) {
-      queryAllowance(params);
+    if (vaultAddress && options.address) {
+      queryAllowance({
+        address: options.address,
+        decimals: options.decimals,
+        vaultAddress
+      });
     } else {
-      if (dst.symbol !== options.srcToken) {
-        queryAllowance(params);
-      } else {
-        getAllowanceByDefaultAddress(params);
-      }
+      getAllowanceByDefaultAddress({
+        address: options.address,
+        decimals: options.decimals
+      });
     }
   }, [
     state.status,
     options.address,
-    options.srcChainId,
-    options.srcToken,
     options.decimals,
-    account7.address,
-    dst.chainId,
-    dst.symbol
+    account9.address,
+    vaultAddress
   ]);
   const updateAllowanceWhenTxSuccess = React.useCallback(
     (txHash) => {
-      return account7.walletAdapter?.pollTransactionReceiptWithBackoff(txHash).then((receipt) => {
+      return account9.walletAdapter?.pollTransactionReceiptWithBackoff(txHash).then((receipt) => {
         if (receipt.status === 1) {
-          account7.assetsManager.getAllowance({ address: options.address }).then((allowance2) => {
-            setAllowance(() => allowance2);
+          account9.assetsManager.getAllowance({
+            address: options.address,
+            decimals: options.decimals,
+            vaultAddress
+          }).then((allowance2) => {
+            setAllowance(allowance2);
           });
         }
       });
     },
-    [account7, options.address]
+    [account9, options.address, options.decimals, vaultAddress]
   );
+  const enquireAllowance = React.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,
+    vaultAddress,
+    quantity,
+    isNativeToken
+  ]);
   const approve = React.useCallback(
     async (amount) => {
       if (!options.address) {
-        throw new types.SDKError("Address is required");
+        throw new Error("address is required");
       }
-      return account7.assetsManager.approve({
+      return account9.assetsManager.approve({
         address: options.address,
         amount,
+        vaultAddress,
         decimals: options.decimals
-      }).then((res) => {
-        return updateAllowanceWhenTxSuccess(res.hash);
-      }).catch((e) => {
-        throw e;
+      }).then((result) => {
+        return updateAllowanceWhenTxSuccess(result.hash);
       });
     },
-    [account7, getAllowance, options.address, options.decimals, dst]
+    [
+      account9,
+      options.address,
+      options.decimals,
+      vaultAddress,
+      updateAllowanceWhenTxSuccess
+    ]
   );
   const deposit = React.useCallback(async () => {
-    if (!options.address) {
-      throw new types.SDKError("Address is required");
-    }
-    const _allowance = await account7.assetsManager.getAllowance({
-      address: options.address,
-      decimals: options.decimals
-    });
-    setAllowance(() => _allowance);
-    if (new utils.Decimal(quantity).greaterThan(_allowance)) {
-      throw new types.SDKError("Insufficient allowance");
-    }
-    return account7.assetsManager.deposit({
+    await enquireAllowance();
+    const inputs = {
       amount: quantity,
       fee: depositFee,
-      decimals: options.decimals
-    }).then((res) => {
+      decimals: options.decimals,
+      token: options.srcToken,
+      vaultAddress
+    };
+    const depositPromise = isNativeToken ? account9.assetsManager.depositNativeToken(inputs) : account9.assetsManager.deposit(inputs);
+    return depositPromise.then((result) => {
+      updateAllowanceWhenTxSuccess(result.hash);
+      setBalance((value) => new utils.Decimal(value).sub(quantity).toString());
       track2(types.TrackerEventName.depositSuccess, {
         wallet: state?.connectWallet?.name,
         network: targetChain?.network_infos.name,
         quantity
       });
-      updateAllowanceWhenTxSuccess(res.hash);
-      setBalance((value) => new utils.Decimal(value).sub(quantity).toString());
-      return res;
+      return result;
     }).catch((e) => {
       track2(types.TrackerEventName.depositFailed, {
         wallet: state?.connectWallet?.name,
@@ -4639,16 +4953,23 @@ var useDeposit = (options) => {
       throw e;
     });
   }, [
-    account7,
-    fetchBalance,
+    state,
+    account9,
     quantity,
     depositFee,
-    options.address,
-    options.decimals
+    targetChain,
+    options.decimals,
+    options.srcToken,
+    enquireAllowance,
+    updateAllowanceWhenTxSuccess,
+    isNativeToken,
+    vaultAddress
   ]);
   const loopGetBalance = async () => {
-    getBalanceListener.current && clearTimeout(getBalanceListener.current);
-    const time = account7.walletAdapter?.chainNamespace === types.ChainNamespace.solana ? 1e4 : 3e3;
+    if (getBalanceListener.current) {
+      clearTimeout(getBalanceListener.current);
+    }
+    const time = account9.walletAdapter?.chainNamespace === types.ChainNamespace.solana ? 1e4 : 3e3;
     getBalanceListener.current = setTimeout(async () => {
       try {
         const balance2 = await fetchBalanceHandler(
@@ -4663,13 +4984,15 @@ var useDeposit = (options) => {
   };
   const getDepositFee = React.useCallback(
     async (quantity2) => {
-      return account7.assetsManager.getDepositFee({
+      return account9.assetsManager.getDepositFee({
         amount: quantity2,
         chain: targetChain?.network_infos,
-        decimals: options.decimals
+        decimals: options.decimals,
+        token: options.srcToken,
+        address: options.address
       });
     },
-    [account7, targetChain, options.decimals]
+    [account9, targetChain, options.decimals, options.srcToken, options.address]
   );
   const enquiryDepositFee = React.useCallback(() => {
     if (isNaN(Number(quantity)) || !quantity || Number(quantity) === 0) {
@@ -4697,7 +5020,9 @@ var useDeposit = (options) => {
     }
     loopGetBalance();
     return () => {
-      getBalanceListener.current && clearTimeout(getBalanceListener.current);
+      if (getBalanceListener.current) {
+        clearTimeout(getBalanceListener.current);
+      }
     };
   }, [options.address, options.decimals]);
   return {
@@ -4716,12 +5041,26 @@ var useDeposit = (options) => {
     depositFeeRevalidating,
     approve,
     deposit,
-    fetchBalances,
     fetchBalance: fetchBalanceHandler,
+    fetchBalances,
     /** set input quantity */
     setQuantity
   };
 };
+
+// src/orderly/useConvert.ts
+var useConvert = (options) => {
+  const { token = "" } = options;
+  const { account: account9 } = useAccount();
+  const maxAmount = useMaxWithdrawal(token);
+  const convert = async (inputs) => {
+    return account9.assetsManager.convert({
+      ...inputs,
+      converted_asset: token
+    });
+  };
+  return { maxAmount, convert };
+};
 var fetcher3 = (url, options) => {
   const init2 = {
     method: options.arg.method,
@@ -4745,7 +5084,7 @@ var useSubAccountMutation = (url, method = "POST", options) => {
   if (!url.startsWith("http")) {
     fullUrl = `${apiBaseUrl}${url}`;
   }
-  const account7 = useAccountInstance();
+  const account9 = useAccountInstance();
   const { trigger, reset, data, error, isMutating } = useSWRMutation__default.default(
     fullUrl,
     // method === "POST" ? fetcher : deleteFetcher,
@@ -4765,7 +5104,7 @@ var useSubAccountMutation = (url, method = "POST", options) => {
         url: newUrl,
         data: data2
       };
-      const signer = account7.signer;
+      const signer = account9.signer;
       const signature = await signer.sign(payload, utils.getTimestamp());
       return trigger(
         {
@@ -4774,13 +5113,13 @@ var useSubAccountMutation = (url, method = "POST", options) => {
           method,
           signature: {
             ...signature,
-            "orderly-account-id": accountId || _accountId || account7.accountId
+            "orderly-account-id": accountId || _accountId || account9.accountId
           }
         },
         restOptions2
       );
     },
-    [trigger, account7, accountId]
+    [trigger, account9, accountId]
   );
   return [
     mutation,
@@ -4795,8 +5134,8 @@ var useSubAccountMutation = (url, method = "POST", options) => {
 
 // src/orderly/useTransfer.ts
 var useTransfer = (options) => {
-  const { fromAccountId } = options || {};
-  const { unsettledPnL, availableBalance, freeCollateral, holding } = useCollateral();
+  const { fromAccountId, token } = options || {};
+  const { unsettledPnL, holding } = useCollateral();
   const [doTransfer, { isMutating: submitting }] = useSubAccountMutation(
     "/v1/internal_transfer",
     "POST",
@@ -4805,9 +5144,9 @@ var useTransfer = (options) => {
     }
   );
   const transfer = React.useCallback(
-    async (token, receivers) => {
+    async (token2, receivers) => {
       return doTransfer({
-        token,
+        token: token2,
         receiver_list: Array.isArray(receivers) ? receivers : [receivers]
       }).then((res) => {
         if (res.success) {
@@ -4820,23 +5159,12 @@ var useTransfer = (options) => {
     },
     [doTransfer]
   );
-  const maxAmount = React.useMemo(() => {
-    return freeCollateral;
-  }, [freeCollateral]);
-  const availableTransfer = React.useMemo(() => {
-    if (unsettledPnL < 0) {
-      return freeCollateral;
-    } else {
-      return freeCollateral - unsettledPnL;
-    }
-  }, [freeCollateral, unsettledPnL]);
+  const maxAmount = useMaxWithdrawal(token);
   return {
     submitting,
     transfer,
     maxAmount,
     unsettledPnL,
-    availableBalance,
-    availableTransfer,
     holding
   };
 };
@@ -6438,7 +6766,7 @@ var OrderFactory = class {
 };
 function useSubAccountQuery(query, options) {
   const { formatter, accountId, ...swrOptions } = options || {};
-  const { state, account: account7 } = useAccount();
+  const { state, account: account9 } = useAccount();
   const middleware = Array.isArray(options?.use) ? options?.use ?? [] : [];
   return useSWR__namespace.default(
     () => accountId && (state.status >= types.AccountStatusEnum.EnableTrading || state.status === types.AccountStatusEnum.EnableTradingWithoutConnected) ? [query, accountId] : null,
@@ -6447,13 +6775,13 @@ function useSubAccountQuery(query, options) {
     },
     {
       ...swrOptions,
-      use: [...middleware, signatureMiddleware2(account7, accountId)],
+      use: [...middleware, signatureMiddleware2(account9, accountId)],
       onError: () => {
       }
     }
   );
 }
-function signatureMiddleware2(account7, accountId) {
+function signatureMiddleware2(account9, accountId) {
   const apiBaseUrl = useConfig("apiBaseUrl");
   return (useSWRNext) => {
     return (key, fetcher4, config) => {
@@ -6461,7 +6789,7 @@ function signatureMiddleware2(account7, accountId) {
         const extendedFetcher = async (args) => {
           const url = Array.isArray(args) ? args[0] : args;
           const fullUrl = `${apiBaseUrl}${url}`;
-          const signer = account7.signer;
+          const signer = account9.signer;
           const payload = {
             method: "GET",
             url
@@ -6482,13 +6810,25 @@ function signatureMiddleware2(account7, accountId) {
   };
 }
 function formatPortfolio(inputs) {
-  const { holding, positions: positions3, markPrices, accountInfo, symbolsInfo } = inputs;
-  if (!holding || !positions3 || !Array.isArray(positions3.rows) || !markPrices || !accountInfo || symbolsInfo?.isNil) {
+  const {
+    holding,
+    positions: positions3,
+    markPrices,
+    indexPrices,
+    accountInfo,
+    symbolsInfo,
+    tokensInfo
+  } = inputs;
+  if (!holding || !positions3 || !Array.isArray(positions3.rows) || !markPrices || !indexPrices || !accountInfo || symbolsInfo?.isNil) {
     return null;
   }
   const unsettledPnL = ramda.pathOr(0, ["total_unsettled_pnl"])(positions3);
   const unrealizedPnL = ramda.pathOr(0, ["total_unreal_pnl"])(positions3);
-  const [USDC_holding, nonUSDC] = parseHolding(holding, markPrices);
+  const [USDC_holding, nonUSDC] = parseHolding(
+    holding,
+    indexPrices,
+    tokensInfo
+  );
   const usdc = holding.find((item) => item.token === "USDC");
   const totalCollateral = perp.account.totalCollateral({
     USDCHolding: USDC_holding,
@@ -6640,7 +6980,7 @@ function calcByPrice(positions3, markPrice, indexPrice) {
 var useSubAccountWS = (options) => {
   const { accountId } = options;
   const { configStore } = React.useContext(OrderlyContext);
-  const { state, account: account7 } = useAccount();
+  const { state, account: account9 } = useAccount();
   const websocketClient = React.useRef(
     new net.WS({
       networkId: configStore.get("networkId"),
@@ -6648,7 +6988,7 @@ var useSubAccountWS = (options) => {
       // publicUrl: configStore.get("publicWsUrl"),
       privateUrl: configStore.get("privateWsUrl"),
       onSigntureRequest: async () => {
-        const signer = account7.signer;
+        const signer = account9.signer;
         const timestamp = utils.getTimestamp();
         const result = await signer.signText(timestamp.toString());
         return { ...result, timestamp };
@@ -6673,11 +7013,12 @@ var useSubAccountDataObserver = (accountId) => {
   const { data: indexPrices } = useIndexPricesStream();
   const symbolsInfo = useSymbolsInfo();
   const fundingRates = useFundingRatesStore();
+  const tokensInfo = useTokensInfo();
   const [holding, setHolding] = React.useState([]);
   const [positions3, setPositions] = React.useState(
     POSITION_EMPTY
   );
-  const [portfolio, setportfolio] = React.useState();
+  const [portfolio, setPortfolio] = React.useState();
   const { data: accountInfo } = useSubAccountQuery(
     "/v1/client/info",
     { accountId, revalidateOnFocus: false }
@@ -6701,11 +7042,21 @@ var useSubAccountDataObserver = (accountId) => {
       holding,
       positions: positions3,
       markPrices,
+      indexPrices,
       accountInfo,
-      symbolsInfo
+      symbolsInfo,
+      tokensInfo
     });
-    setportfolio(portfolio2);
-  }, [holding, positions3, markPrices, accountInfo, symbolsInfo]);
+    setPortfolio(portfolio2);
+  }, [
+    holding,
+    positions3,
+    markPrices,
+    indexPrices,
+    accountInfo,
+    symbolsInfo,
+    tokensInfo
+  ]);
   React.useEffect(() => {
     if (!positionsInfo)
       return;
@@ -6814,6 +7165,63 @@ var useSubAccountDataObserver = (accountId) => {
   }, [accountId]);
   return { portfolio, positions: positions3 };
 };
+var { maxWithdrawalUSDC: maxWithdrawalUSDC2, maxWithdrawalOtherCollateral: maxWithdrawalOtherCollateral2, collateralRatio: collateralRatio3 } = perp.account;
+function useSubAccountMaxWithdrawal(options) {
+  const { token, unsettledPnL, freeCollateral, holdings } = options;
+  const tokenInfo = useTokenInfo(token);
+  const { data: indexPrices } = useIndexPricesStream();
+  const usdc = React.useMemo(() => {
+    const usdc2 = holdings?.find((item) => item.token === "USDC");
+    return usdc2;
+  }, [holdings]);
+  const holding = React.useMemo(() => {
+    return holdings?.find((item) => item?.token === token);
+  }, [holdings, token]);
+  const usdcBalance = usdc?.holding ?? 0;
+  const indexPrice = React.useMemo(() => {
+    if (token === "USDC") {
+      return 1;
+    }
+    const symbol = `PERP_${token}_USDC`;
+    return indexPrices[symbol] ?? 0;
+  }, [token, indexPrices]);
+  const memoizedCollateralRatio = React.useMemo(() => {
+    const { base_weight = 0, discount_factor = 0 } = tokenInfo || {};
+    const holdingQty = holding?.holding ?? 0;
+    return collateralRatio3({
+      baseWeight: base_weight,
+      discountFactor: discount_factor,
+      collateralQty: holdingQty,
+      collateralCap: tokenInfo?.user_max_qty ?? holdingQty,
+      indexPrice
+    });
+  }, [holdings, tokenInfo, indexPrice, token, holding]);
+  const maxAmount = React.useMemo(() => {
+    if (token === "USDC") {
+      return maxWithdrawalUSDC2({
+        USDCBalance: usdcBalance,
+        freeCollateral,
+        upnl: unsettledPnL ?? 0
+      });
+    }
+    return maxWithdrawalOtherCollateral2({
+      collateralQty: holding?.holding ?? 0,
+      freeCollateral,
+      indexPrice,
+      weight: memoizedCollateralRatio
+    });
+  }, [
+    usdcBalance,
+    freeCollateral,
+    unsettledPnL,
+    memoizedCollateralRatio,
+    holdings,
+    indexPrice,
+    token,
+    holding
+  ]);
+  return maxAmount;
+}
 function offsetToPrice(inputs) {
   const { offset, entryPrice, orderType, orderSide } = inputs;
   if (!offset)
@@ -7613,7 +8021,7 @@ var useStorageLedgerAddress = () => {
 var usePrivateDataObserver = (options) => {
   const ws = useWS();
   const ee = useEventEmitter();
-  const { state, account: account7 } = useAccount();
+  const { state, account: account9 } = useAccount();
   const { setAccountInfo, restoreHolding, cleanAll } = useAppStore(
     (state2) => state2.actions
   );
@@ -7646,9 +8054,9 @@ var usePrivateDataObserver = (options) => {
         positionsActions.clearAll();
       }
     };
-    account7.on(core.EVENT_NAMES.statusChanged, handler);
+    account9.on(core.EVENT_NAMES.statusChanged, handler);
     return () => {
-      account7.off(core.EVENT_NAMES.statusChanged, handler);
+      account9.off(core.EVENT_NAMES.statusChanged, handler);
     };
   }, []);
   React.useEffect(() => {
@@ -7669,7 +8077,7 @@ var usePrivateDataObserver = (options) => {
     }
   );
   React.useEffect(() => {
-    if (!account7.accountId)
+    if (!account9.accountId)
       return;
     const unsubscribe = ws.privateSubscribe(
       {
@@ -7688,11 +8096,11 @@ var usePrivateDataObserver = (options) => {
       }
     );
     return () => unsubscribe?.();
-  }, [account7.accountId]);
+  }, [account9.accountId]);
   const isHoldingInit = React.useRef(false);
   React.useEffect(() => {
     isHoldingInit.current = false;
-  }, [state.accountId]);
+  }, [state.address]);
   React.useEffect(() => {
     if (!holding) {
       return;
@@ -7861,6 +8269,7 @@ var usePublicDataObserver = () => {
     (state) => state.actions
   );
   const { updateMarket } = useMarketStore((state) => state.actions);
+  const setTokensInfo = useTokensInfoStore((state) => state.setTokensInfo);
   useQuery(`/v1/public/info`, {
     ...publicQueryOptions,
     onSuccess(data) {
@@ -7913,6 +8322,16 @@ var usePublicDataObserver = () => {
       updateMarket(data);
     }
   });
+  useQuery(`/v1/public/token`, {
+    // revalidateOnFocus: false,
+    ...publicQueryOptions,
+    onSuccess(data) {
+      if (!data || !data.length) {
+        return [];
+      }
+      setTokensInfo(data);
+    }
+  });
 };
 function getEstFundingRate(data) {
   if (!data)
@@ -8027,7 +8446,7 @@ var ExtendedConfigStore = class extends core.DefaultConfigStore {
   }
 };
 var OrderlyConfigProvider = (props) => {
-  const [account7, setAccount] = React__default.default.useState(null);
+  const [account9, setAccount] = React__default.default.useState(null);
   const {
     configStore,
     keyStore,
@@ -8038,7 +8457,9 @@ var OrderlyConfigProvider = (props) => {
     networkId,
     contracts,
     chainFilter,
-    customChains
+    customChains,
+    enableSwapDeposit = true,
+    chainTransformer
   } = props;
   if (typeof configStore !== "undefined" && !configStore.get("brokerId")) {
     throw new types.SDKError(
@@ -8068,9 +8489,9 @@ var OrderlyConfigProvider = (props) => {
     return props.orderbookDefaultTickSizes || DEFAULT_TICK_SIZES;
   }, [props.orderbookDefaultTickSizes]);
   React.useLayoutEffect(() => {
-    let account8 = core.SimpleDI.get(core.Account.instanceName);
-    if (!account8) {
-      account8 = new core.Account(
+    let account10 = core.SimpleDI.get(core.Account.instanceName);
+    if (!account10) {
+      account10 = new core.Account(
         innerConfigStore,
         innerKeyStore,
         // innerGetWalletAdapter,
@@ -8079,9 +8500,9 @@ var OrderlyConfigProvider = (props) => {
           contracts
         }
       );
-      core.SimpleDI.registerByName(core.Account.instanceName, account8);
+      core.SimpleDI.registerByName(core.Account.instanceName, account10);
     }
-    setAccount(account8);
+    setAccount(account10);
   }, []);
   const filteredChains = React.useMemo(() => {
     if (typeof chainFilter === "function") {
@@ -8089,7 +8510,7 @@ var OrderlyConfigProvider = (props) => {
     }
     return chainFilter;
   }, [props.chainFilter, innerConfigStore]);
-  if (!account7) {
+  if (!account9) {
     return null;
   }
   return /* @__PURE__ */ jsxRuntime.jsx(
@@ -8104,6 +8525,8 @@ var OrderlyConfigProvider = (props) => {
         walletAdapters: innerWalletAdapters,
         // apiBaseUrl,
         customChains,
+        enableSwapDeposit,
+        chainTransformer,
         defaultOrderbookTickSizes
       },
       children: /* @__PURE__ */ jsxRuntime.jsx(StatusProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(DataCenterProvider, { children: props.children }) })
@@ -9929,9 +10352,9 @@ var useAllBrokers = () => {
 };
 var useCurEpochEstimate = (type) => {
   const [data, setData] = React.useState(void 0);
-  const { account: account7 } = useAccount();
+  const { account: account9 } = useAccount();
   const brokers = useAllBrokers();
-  const address = account7.address;
+  const address = account9.address;
   const path2 = type === "normal" /* normal */ ? `/v1/public/trading_rewards/current_epoch_estimate?address=${address}` : `/v1/public/market_making_rewards/current_epoch_estimate?address=${address}`;
   const { data: estimateData } = useQuery(address !== void 0 ? path2 : "", {
     formatter: (res) => {
@@ -14891,14 +15314,14 @@ var DistributionId = /* @__PURE__ */ ((DistributionId2) => {
 })(DistributionId || {});
 var useGetClaimed = (id) => {
   const [data, setData] = React.useState(0);
-  const { account: account7 } = useAccount();
-  const address = account7.address;
+  const { account: account9 } = useAccount();
+  const address = account9.address;
   const env = useGetEnv();
   const refresh = React.useCallback(() => {
     const params = getContractByEnv(env);
     if (typeof address === "undefined")
       return;
-    account7.walletAdapter?.callOnChain(
+    account9.walletAdapter?.callOnChain(
       // @ts-ignore
       { public_rpc_url: params.orderlyChainRpcUrl },
       params.orderlyContract,
@@ -14923,8 +15346,8 @@ var useGetClaimed = (id) => {
 
 // src/trading-rewards/useWalletRewardsHistory.ts
 var useWalletRewardsHistory = (type) => {
-  const { account: account7 } = useAccount();
-  const address = account7.address;
+  const { account: account9 } = useAccount();
+  const address = account9.address;
   const path2 = type === "normal" /* normal */ ? `/v1/public/trading_rewards/wallet_rewards_history?address=${address}` : `/v1/public/market_making_rewards/group_rewards_history?address=${address}`;
   const {
     data,
@@ -14972,7 +15395,7 @@ function useTradingRewardsStatus(isMMRewards) {
   };
 }
 var useApiKeyManager = (queryParams) => {
-  const { account: account7, state, isSubAccount } = useAccount();
+  const { account: account9, state, isSubAccount } = useAccount();
   const { keyInfo } = queryParams || {};
   const keyInfoPrams = getQueryParamsFromObject(keyInfo);
   const { data, mutate: mutate5, error, isLoading } = usePrivateQuery(
@@ -15009,13 +15432,13 @@ var useApiKeyManager = (queryParams) => {
   }, []);
   const generateOrderlyKey = (scope) => {
     if (isSubAccount) {
-      return account7?.createSubAccountApiKey(365, {
+      return account9?.createSubAccountApiKey(365, {
         tag: "manualCreated",
         scope,
         subAccountId: state.accountId
       });
     }
-    return account7?.createApiKey(365, {
+    return account9?.createApiKey(365, {
       tag: "manualCreated",
       scope
     });
@@ -16109,7 +16532,9 @@ exports.useChains = useChains;
 exports.useCheckReferralCode = useCheckReferralCode;
 exports.useCollateral = useCollateral;
 exports.useCommission = useCommission;
+exports.useComputedLTV = useComputedLTV;
 exports.useConfig = useConfig;
+exports.useConvert = useConvert;
 exports.useCurEpochEstimate = useCurEpochEstimate;
 exports.useDaily = useDaily;
 exports.useDeposit = useDeposit;
@@ -16147,6 +16572,7 @@ exports.useMaxQty = useMaxQty;
 exports.useMediaQuery = useMediaQuery;
 exports.useMutation = useMutation;
 exports.useNetworkInfo = useNetworkInfo;
+exports.useOdosQuote = useOdosQuote;
 exports.useOrderEntity = useOrderEntity;
 exports.useOrderEntry = useOrderEntry2;
 exports.useOrderEntry_deprecated = useOrderEntry;
@@ -16175,6 +16601,7 @@ exports.useStatisticsDaily = useStatisticsDaily;
 exports.useStorageChain = useStorageChain;
 exports.useStorageLedgerAddress = useStorageLedgerAddress;
 exports.useSubAccountDataObserver = useSubAccountDataObserver;
+exports.useSubAccountMaxWithdrawal = useSubAccountMaxWithdrawal;
 exports.useSubAccountMutation = useSubAccountMutation;
 exports.useSubAccountQuery = useSubAccountQuery;
 exports.useSubAccountWS = useSubAccountWS;
@@ -16184,6 +16611,8 @@ exports.useSymbolsInfo = useSymbolsInfo;
 exports.useSymbolsInfoStore = useSymbolsInfoStore;
 exports.useTPSLOrder = useTPSLOrder;
 exports.useTickerStream = useTickerStream;
+exports.useTokenInfo = useTokenInfo;
+exports.useTokensInfo = useTokensInfo;
 exports.useTrack = useTrack;
 exports.useTrackingInstance = useTrackingInstance;
 exports.useTradingRewardsStatus = useTradingRewardsStatus;