@multiversx/sdk-dapp-liquidity 0.2.0-alpha.1

package/reactjs/hooks/useBridgeFormik.mjs

@@ -0,0 +1,181 @@
+import { useFormik } from "formik";
+import { useState, useRef, useEffect } from "react";
+import { useSwitchChain } from "wagmi";
+import { object, string } from "yup";
+import { useAccount } from "./useAccount.mjs";
+import { useAmountSchema } from "./validation/useAmountSchema.mjs";
+import { useSecondAmountSchema } from "./validation/useSecondAmountSchema.mjs";
+import { confirmRate } from "../../api/confirmRate.mjs";
+import { getApiURL } from "../../helpers/getApiURL.mjs";
+var BridgeFormikValuesEnum = /* @__PURE__ */ ((BridgeFormikValuesEnum2) => {
+  BridgeFormikValuesEnum2["firstToken"] = "firstToken";
+  BridgeFormikValuesEnum2["firstAmount"] = "firstAmount";
+  BridgeFormikValuesEnum2["secondToken"] = "secondToken";
+  BridgeFormikValuesEnum2["secondAmount"] = "secondAmount";
+  BridgeFormikValuesEnum2["fromChainId"] = "fromChainId";
+  BridgeFormikValuesEnum2["toChainId"] = "toChainId";
+  return BridgeFormikValuesEnum2;
+})(BridgeFormikValuesEnum || {});
+const useBridgeFormik = ({
+  nativeAuthToken,
+  mvxAccountAddress,
+  firstToken,
+  firstAmount,
+  secondToken,
+  secondAmount,
+  fromChainId,
+  toChainId,
+  fee = "0",
+  onSubmit
+}) => {
+  const [lastChangedField, setLastChangedField] = useState(null);
+  const pendingSigningRef = useRef();
+  const account = useAccount();
+  const { switchChainAsync } = useSwitchChain();
+  const initialValues = {
+    firstAmount: "",
+    secondAmount: "",
+    fromChainId: fromChainId ?? "",
+    toChainId: toChainId ?? ""
+  };
+  const resetSwapForm = () => {
+    formik.setTouched({}, false);
+    formik.setErrors({});
+    setFieldValue("firstAmount", "");
+    setFieldValue("secondAmount", "");
+  };
+  const onSubmitFormik = async (values2) => {
+    var _a, _b;
+    if (values2.fromChainId) {
+      await switchChainAsync({
+        chainId: Number(values2.fromChainId)
+      });
+    }
+    if (pendingSigningRef.current) {
+      return;
+    }
+    pendingSigningRef.current = true;
+    const { data } = await confirmRate({
+      url: getApiURL(),
+      nativeAuthToken: nativeAuthToken ?? "",
+      body: {
+        tokenIn: ((_a = values2.firstToken) == null ? void 0 : _a.address) ?? "",
+        amountIn: (firstAmount == null ? void 0 : firstAmount.toString()) ?? "",
+        fromChainId: values2.fromChainId ?? "",
+        tokenOut: ((_b = values2.secondToken) == null ? void 0 : _b.address) ?? "",
+        toChainId: values2.toChainId ?? "",
+        fee: fee ?? "0",
+        amountOut: (secondAmount == null ? void 0 : secondAmount.toString()) ?? "",
+        sender: account.address ?? "",
+        receiver: mvxAccountAddress ?? ""
+      }
+    });
+    const transactions = data;
+    if (!transactions || transactions.length === 0) {
+      pendingSigningRef.current = false;
+      return;
+    }
+    resetSwapForm();
+    onSubmit(transactions);
+    pendingSigningRef.current = false;
+  };
+  const formik = useFormik({
+    initialValues,
+    validationSchema: object().shape({
+      [
+        "firstAmount"
+        /* firstAmount */
+      ]: useAmountSchema(),
+      [
+        "firstToken"
+        /* firstToken */
+      ]: object().required(),
+      [
+        "secondAmount"
+        /* secondAmount */
+      ]: useSecondAmountSchema(),
+      [
+        "secondToken"
+        /* secondToken */
+      ]: object().required(),
+      [
+        "fromChainId"
+        /* fromChainId */
+      ]: string().required(),
+      [
+        "toChainId"
+        /* toChainId */
+      ]: string().required()
+    }),
+    onSubmit: onSubmitFormik
+  });
+  const {
+    values,
+    errors,
+    touched,
+    handleBlur,
+    handleSubmit,
+    handleChange,
+    setFieldValue,
+    setFieldTouched
+  } = formik;
+  useEffect(() => {
+    if (!values.firstAmount && touched.firstAmount) {
+      setFieldValue("secondAmount", 0, true);
+      return;
+    }
+    if (lastChangedField === "firstAmount" && values.firstAmount && values.firstAmount !== "") {
+      const calculatedSecondAmount = parseFloat(values.firstAmount) - Number(fee);
+      setFieldValue(
+        "secondAmount",
+        calculatedSecondAmount > 0 ? calculatedSecondAmount : "0"
+      );
+    }
+  }, [values.firstAmount, fee, lastChangedField, touched.firstAmount]);
+  useEffect(() => {
+    if (!values.secondAmount && touched.secondAmount) {
+      setFieldValue("firstAmount", 0, true);
+      return;
+    }
+    if (lastChangedField === "secondAmount" && values.secondAmount && values.secondAmount !== "") {
+      const calculatedFirstAmount = parseFloat(values.secondAmount) + Number(fee);
+      setFieldValue("firstAmount", calculatedFirstAmount);
+    }
+  }, [values.secondAmount, fee, lastChangedField, touched.secondAmount]);
+  useEffect(() => {
+    setFieldValue("firstToken", firstToken, true);
+  }, [firstToken]);
+  useEffect(() => {
+    setFieldValue("secondToken", secondToken, true);
+  }, [secondToken]);
+  useEffect(() => {
+    setFieldValue("fromChainId", fromChainId, true);
+  }, [fromChainId]);
+  useEffect(() => {
+    setFieldValue("toChainId", toChainId, true);
+  }, [toChainId]);
+  const secondAmountError = "secondAmount" in errors && "secondAmount" in touched ? errors.secondAmount : void 0;
+  const firstAmountError = "firstAmount" in errors && "firstAmount" in touched ? errors.firstAmount : void 0;
+  const fromChainError = "fromChainId" in errors && "fromChainId" in touched ? errors.fromChainId : void 0;
+  return {
+    formik,
+    errors,
+    touched,
+    firstToken,
+    secondToken,
+    firstAmountError,
+    secondAmountError,
+    fromChainError,
+    handleBlur,
+    handleChange,
+    handleSubmit,
+    setFieldValue,
+    resetSwapForm,
+    setFieldTouched,
+    setLastChangedField
+  };
+};
+export {
+  BridgeFormikValuesEnum,
+  useBridgeFormik
+};

package/reactjs/hooks/useDebounce.d.ts

@@ -0,0 +1 @@
+export declare const useDebounce: (value: any, timeout: number) => any;

package/reactjs/hooks/useDebounce.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require$$0 = require("react");
+const useDebounce = (value, timeout) => {
+  const [state, setState] = require$$0.useState(value);
+  const effect = () => {
+    const handler = setTimeout(() => setState(value), timeout);
+    return () => clearTimeout(handler);
+  };
+  require$$0.useEffect(effect, [value]);
+  return state;
+};
+exports.useDebounce = useDebounce;

package/reactjs/hooks/useDebounce.mjs

@@ -0,0 +1,13 @@
+import { useState, useEffect } from "react";
+const useDebounce = (value, timeout) => {
+  const [state, setState] = useState(value);
+  const effect = () => {
+    const handler = setTimeout(() => setState(value), timeout);
+    return () => clearTimeout(handler);
+  };
+  useEffect(effect, [value]);
+  return state;
+};
+export {
+  useDebounce
+};

package/reactjs/hooks/useFetchBridgeData.d.ts

@@ -0,0 +1,45 @@
+export declare const useFetchBridgeData: ({ refetchTrigger, mvxAddress, mvxApiURL }: {
+    refetchTrigger?: number;
+    mvxAddress?: string;
+    mvxApiURL: string;
+}) => {
+    isTokensError: boolean;
+    isTokensLoading: boolean;
+    evmTokensWithBalances: {
+        balance: string;
+        chainId: number;
+        address: string;
+        name: string;
+        symbol: string;
+        decimals: number;
+        crosschain: boolean;
+        pngUrl: string;
+        svgUrl: string;
+        metadata: {
+            minBridgeAmount: string;
+            maxBridgeAmount: string;
+        };
+    }[] | undefined;
+    isLoadingEvmTokensBalances: boolean;
+    isErrorMvxTokensBalances: boolean;
+    mvxTokensWithBalances: {
+        balance: string;
+        chainId: number;
+        address: string;
+        name: string;
+        symbol: string;
+        decimals: number;
+        crosschain: boolean;
+        pngUrl: string;
+        svgUrl: string;
+        metadata: {
+            minBridgeAmount: string;
+            maxBridgeAmount: string;
+        };
+    }[] | undefined;
+    isLoadingMvxTokensBalances: boolean;
+    isErrorEvmTokensBalances: boolean;
+    chains: import('../..').ChainDTO[] | undefined;
+    isChainsLoading: boolean;
+    isChainsError: boolean;
+};

package/reactjs/hooks/useFetchBridgeData.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const reactjs_hooks_useFetchTokens = require("./useFetchTokens.js");
+const reactjs_queries_useGetChains_query = require("../queries/useGetChains.query.js");
+const useFetchBridgeData = ({
+  refetchTrigger,
+  mvxAddress,
+  mvxApiURL
+}) => {
+  const {
+    isTokensError,
+    isTokensLoading,
+    evmTokensWithBalances,
+    isLoadingEvmTokensBalances,
+    isErrorMvxTokensBalances,
+    mvxTokensWithBalances,
+    isLoadingMvxTokensBalances,
+    isErrorEvmTokensBalances
+  } = reactjs_hooks_useFetchTokens.useFetchTokens({
+    mvxApiURL,
+    mvxAddress,
+    refetchTrigger
+  });
+  const {
+    data: chains,
+    isLoading: isChainsLoading,
+    isError: isChainsError
+  } = reactjs_queries_useGetChains_query.useGetChainsQuery();
+  return {
+    isTokensError,
+    isTokensLoading,
+    evmTokensWithBalances,
+    isLoadingEvmTokensBalances,
+    isErrorMvxTokensBalances,
+    mvxTokensWithBalances,
+    isLoadingMvxTokensBalances,
+    isErrorEvmTokensBalances,
+    chains,
+    isChainsLoading,
+    isChainsError
+  };
+};
+exports.useFetchBridgeData = useFetchBridgeData;

package/reactjs/hooks/useFetchBridgeData.mjs

@@ -0,0 +1,43 @@
+import { useFetchTokens } from "./useFetchTokens.mjs";
+import { useGetChainsQuery } from "../queries/useGetChains.query.mjs";
+const useFetchBridgeData = ({
+  refetchTrigger,
+  mvxAddress,
+  mvxApiURL
+}) => {
+  const {
+    isTokensError,
+    isTokensLoading,
+    evmTokensWithBalances,
+    isLoadingEvmTokensBalances,
+    isErrorMvxTokensBalances,
+    mvxTokensWithBalances,
+    isLoadingMvxTokensBalances,
+    isErrorEvmTokensBalances
+  } = useFetchTokens({
+    mvxApiURL,
+    mvxAddress,
+    refetchTrigger
+  });
+  const {
+    data: chains,
+    isLoading: isChainsLoading,
+    isError: isChainsError
+  } = useGetChainsQuery();
+  return {
+    isTokensError,
+    isTokensLoading,
+    evmTokensWithBalances,
+    isLoadingEvmTokensBalances,
+    isErrorMvxTokensBalances,
+    mvxTokensWithBalances,
+    isLoadingMvxTokensBalances,
+    isErrorEvmTokensBalances,
+    chains,
+    isChainsLoading,
+    isChainsError
+  };
+};
+export {
+  useFetchBridgeData
+};

package/reactjs/hooks/useFetchTokens.d.ts

@@ -0,0 +1,42 @@
+export declare const useFetchTokens: ({ mvxAddress, mvxApiURL, refetchTrigger }: {
+    mvxAddress?: string;
+    mvxApiURL: string;
+    refetchTrigger?: number;
+}) => {
+    isTokensLoading: boolean;
+    isTokensError: boolean;
+    isLoadingEvmTokensBalances: boolean;
+    isErrorEvmTokensBalances: boolean;
+    evmTokensWithBalances: {
+        balance: string;
+        chainId: number;
+        address: string;
+        name: string;
+        symbol: string;
+        decimals: number;
+        crosschain: boolean;
+        pngUrl: string;
+        svgUrl: string;
+        metadata: {
+            minBridgeAmount: string;
+            maxBridgeAmount: string;
+        };
+    }[] | undefined;
+    isLoadingMvxTokensBalances: boolean;
+    isErrorMvxTokensBalances: boolean;
+    mvxTokensWithBalances: {
+        balance: string;
+        chainId: number;
+        address: string;
+        name: string;
+        symbol: string;
+        decimals: number;
+        crosschain: boolean;
+        pngUrl: string;
+        svgUrl: string;
+        metadata: {
+            minBridgeAmount: string;
+            maxBridgeAmount: string;
+        };
+    }[] | undefined;
+};

package/reactjs/hooks/useFetchTokens.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require$$0 = require("react");
+const reactjs_hooks_useAccount = require("./useAccount.js");
+const reactjs_hooks_useGetChainId = require("./useGetChainId.js");
+const constants_index = require("../../constants/index.js");
+const reactjs_queries_useGetAllTokens_query = require("../queries/useGetAllTokens.query.js");
+const reactjs_queries_useGetEvmTokensBalances_query = require("../queries/useGetEvmTokensBalances.query.js");
+const reactjs_queries_useGetMvxTokensBalances_query = require("../queries/useGetMvxTokensBalances.query.js");
+const useFetchTokens = ({
+  mvxAddress,
+  mvxApiURL,
+  refetchTrigger
+}) => {
+  const chainId = reactjs_hooks_useGetChainId.useGetChainId();
+  const account = reactjs_hooks_useAccount.useAccount();
+  const {
+    data: tokens,
+    isLoading: isTokensLoading,
+    isError: isTokensError
+  } = reactjs_queries_useGetAllTokens_query.useGetAllTokensQuery();
+  const evmTokens = require$$0.useMemo(
+    () => tokens == null ? void 0 : tokens.filter(
+      (token) => !constants_index.MVX_CHAIN_IDS.includes(Number(token.chainId.toString()))
+    ),
+    [tokens]
+  );
+  const mvxTokens = require$$0.useMemo(
+    () => tokens == null ? void 0 : tokens.filter(
+      (token) => constants_index.MVX_CHAIN_IDS.includes(Number(token.chainId.toString()))
+    ),
+    [tokens]
+  );
+  const {
+    data: evmTokensBalances,
+    isLoading: isLoadingEvmTokensBalances,
+    isError: isErrorEvmTokensBalances
+  } = reactjs_queries_useGetEvmTokensBalances_query.useGetEvmTokensBalancesQuery({
+    tokens: evmTokens ?? [],
+    chainId: chainId == null ? void 0 : chainId.toString()
+  });
+  const {
+    data: mvxTokensBalances,
+    isLoading: isLoadingMvxTokensBalances,
+    isError: isErrorMvxTokensBalances
+  } = reactjs_queries_useGetMvxTokensBalances_query.useGetMvxTokensBalancesQuery({
+    tokens: mvxTokens ?? [],
+    mvxAddress,
+    apiURL: mvxApiURL
+  });
+  const mvxTokensWithBalances = require$$0.useMemo(() => {
+    return mvxTokens == null ? void 0 : mvxTokens.map((token) => {
+      const foundToken = mvxTokensBalances == null ? void 0 : mvxTokensBalances.find(
+        (mvxToken) => mvxToken.address === token.address
+      );
+      if (!foundToken) {
+        return {
+          ...token,
+          balance: "0"
+        };
+      }
+      return {
+        ...foundToken,
+        balance: foundToken.balance.toString()
+      };
+    });
+  }, [mvxTokens, mvxTokensBalances]);
+  const evmTokensWithBalances = require$$0.useMemo(() => {
+    return evmTokens == null ? void 0 : evmTokens.map((token) => {
+      const foundToken = evmTokensBalances == null ? void 0 : evmTokensBalances.find(
+        (evmToken) => evmToken.address === token.address
+      );
+      if (!foundToken) {
+        return {
+          ...token,
+          balance: "0"
+        };
+      }
+      return {
+        ...foundToken,
+        balance: foundToken.balance.toString()
+      };
+    });
+  }, [evmTokens, evmTokensBalances]);
+  require$$0.useEffect(() => {
+    if (account.address) {
+      reactjs_queries_useGetEvmTokensBalances_query.invalidateEvmTokensBalances();
+    }
+    if (mvxAddress) {
+      reactjs_queries_useGetMvxTokensBalances_query.invalidateMvxTokensBalancesQuery();
+    }
+  }, [refetchTrigger, chainId, account.address, mvxAddress]);
+  return {
+    isTokensLoading,
+    isTokensError,
+    isLoadingEvmTokensBalances,
+    isErrorEvmTokensBalances,
+    evmTokensWithBalances,
+    isLoadingMvxTokensBalances,
+    isErrorMvxTokensBalances,
+    mvxTokensWithBalances
+  };
+};
+exports.useFetchTokens = useFetchTokens;

package/reactjs/hooks/useFetchTokens.mjs

@@ -0,0 +1,104 @@
+import { useMemo, useEffect } from "react";
+import { useAccount } from "./useAccount.mjs";
+import { useGetChainId } from "./useGetChainId.mjs";
+import { MVX_CHAIN_IDS } from "../../constants/index.mjs";
+import { useGetAllTokensQuery } from "../queries/useGetAllTokens.query.mjs";
+import { useGetEvmTokensBalancesQuery, invalidateEvmTokensBalances } from "../queries/useGetEvmTokensBalances.query.mjs";
+import { useGetMvxTokensBalancesQuery, invalidateMvxTokensBalancesQuery } from "../queries/useGetMvxTokensBalances.query.mjs";
+const useFetchTokens = ({
+  mvxAddress,
+  mvxApiURL,
+  refetchTrigger
+}) => {
+  const chainId = useGetChainId();
+  const account = useAccount();
+  const {
+    data: tokens,
+    isLoading: isTokensLoading,
+    isError: isTokensError
+  } = useGetAllTokensQuery();
+  const evmTokens = useMemo(
+    () => tokens == null ? void 0 : tokens.filter(
+      (token) => !MVX_CHAIN_IDS.includes(Number(token.chainId.toString()))
+    ),
+    [tokens]
+  );
+  const mvxTokens = useMemo(
+    () => tokens == null ? void 0 : tokens.filter(
+      (token) => MVX_CHAIN_IDS.includes(Number(token.chainId.toString()))
+    ),
+    [tokens]
+  );
+  const {
+    data: evmTokensBalances,
+    isLoading: isLoadingEvmTokensBalances,
+    isError: isErrorEvmTokensBalances
+  } = useGetEvmTokensBalancesQuery({
+    tokens: evmTokens ?? [],
+    chainId: chainId == null ? void 0 : chainId.toString()
+  });
+  const {
+    data: mvxTokensBalances,
+    isLoading: isLoadingMvxTokensBalances,
+    isError: isErrorMvxTokensBalances
+  } = useGetMvxTokensBalancesQuery({
+    tokens: mvxTokens ?? [],
+    mvxAddress,
+    apiURL: mvxApiURL
+  });
+  const mvxTokensWithBalances = useMemo(() => {
+    return mvxTokens == null ? void 0 : mvxTokens.map((token) => {
+      const foundToken = mvxTokensBalances == null ? void 0 : mvxTokensBalances.find(
+        (mvxToken) => mvxToken.address === token.address
+      );
+      if (!foundToken) {
+        return {
+          ...token,
+          balance: "0"
+        };
+      }
+      return {
+        ...foundToken,
+        balance: foundToken.balance.toString()
+      };
+    });
+  }, [mvxTokens, mvxTokensBalances]);
+  const evmTokensWithBalances = useMemo(() => {
+    return evmTokens == null ? void 0 : evmTokens.map((token) => {
+      const foundToken = evmTokensBalances == null ? void 0 : evmTokensBalances.find(
+        (evmToken) => evmToken.address === token.address
+      );
+      if (!foundToken) {
+        return {
+          ...token,
+          balance: "0"
+        };
+      }
+      return {
+        ...foundToken,
+        balance: foundToken.balance.toString()
+      };
+    });
+  }, [evmTokens, evmTokensBalances]);
+  useEffect(() => {
+    if (account.address) {
+      invalidateEvmTokensBalances();
+    }
+    if (mvxAddress) {
+      invalidateMvxTokensBalancesQuery();
+    }
+  }, [refetchTrigger, chainId, account.address, mvxAddress]);
+  return {
+    isTokensLoading,
+    isTokensError,
+    isLoadingEvmTokensBalances,
+    isErrorEvmTokensBalances,
+    evmTokensWithBalances,
+    isLoadingMvxTokensBalances,
+    isErrorMvxTokensBalances,
+    mvxTokensWithBalances
+  };
+};
+export {
+  useFetchTokens
+};

package/reactjs/hooks/useGetChainId.d.ts

@@ -0,0 +1 @@
+export declare const useGetChainId: () => string | number | undefined;

package/reactjs/hooks/useGetChainId.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const react = require("../../react-BaXyw3AO.js");
+const require$$0 = require("react");
+const reactjs_context_useWeb3App = require("../context/useWeb3App.js");
+const useGetChainId = () => {
+  const { chainId } = react.useAppKitNetwork();
+  const { appKit } = reactjs_context_useWeb3App.useWeb3App();
+  return require$$0.useMemo(() => chainId ?? appKit.getChainId(), [chainId, appKit]);
+};
+exports.useGetChainId = useGetChainId;

package/reactjs/hooks/useGetChainId.mjs

@@ -0,0 +1,11 @@
+import { u as useAppKitNetwork } from "../../react-B9sQBOh0.mjs";
+import { useMemo } from "react";
+import { useWeb3App } from "../context/useWeb3App.mjs";
+const useGetChainId = () => {
+  const { chainId } = useAppKitNetwork();
+  const { appKit } = useWeb3App();
+  return useMemo(() => chainId ?? appKit.getChainId(), [chainId, appKit]);
+};
+export {
+  useGetChainId
+};

package/reactjs/hooks/useResolveTokenChain.d.ts

@@ -0,0 +1,9 @@
+import { TokenDTO } from '../../dto/Token.dto';
+
+export declare const useResolveTokenChain: ({ token }: {
+    token?: TokenDTO;
+}) => {
+    tokenChain: import('../..').ChainDTO | undefined;
+    isLoading: boolean;
+    chainIcon: string | null;
+};

package/reactjs/hooks/useResolveTokenChain.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require$$0 = require("react");
+require("../constants/index.js");
+const reactjs_queries_useGetChains_query = require("../queries/useGetChains.query.js");
+const reactjs_constants_chains = require("../constants/chains.js");
+const useResolveTokenChain = ({ token }) => {
+  const { data: chains, isLoading } = reactjs_queries_useGetChains_query.useGetChainsQuery();
+  const tokenChain = require$$0.useMemo(() => {
+    return chains == null ? void 0 : chains.find(
+      (chain) => chain.chainId.toString() === (token == null ? void 0 : token.chainId.toString())
+    );
+  }, [chains, token]);
+  return {
+    tokenChain,
+    isLoading,
+    chainIcon: tokenChain ? tokenChain.svgUrl ?? reactjs_constants_chains.chainIdentifier[tokenChain.chainName] : null
+  };
+};
+exports.useResolveTokenChain = useResolveTokenChain;

package/reactjs/hooks/useResolveTokenChain.mjs

@@ -0,0 +1,20 @@
+import { useMemo } from "react";
+import "../constants/index.mjs";
+import { useGetChainsQuery } from "../queries/useGetChains.query.mjs";
+import { chainIdentifier } from "../constants/chains.mjs";
+const useResolveTokenChain = ({ token }) => {
+  const { data: chains, isLoading } = useGetChainsQuery();
+  const tokenChain = useMemo(() => {
+    return chains == null ? void 0 : chains.find(
+      (chain) => chain.chainId.toString() === (token == null ? void 0 : token.chainId.toString())
+    );
+  }, [chains, token]);
+  return {
+    tokenChain,
+    isLoading,
+    chainIcon: tokenChain ? tokenChain.svgUrl ?? chainIdentifier[tokenChain.chainName] : null
+  };
+};
+export {
+  useResolveTokenChain
+};

package/reactjs/hooks/useSendTransactions.d.ts

@@ -0,0 +1,3 @@
+import { SendTransactionsType } from '../../api/sendTransactions';
+
+export declare const useSendTransactions: () => ({ transactions, url, token, axiosConfig }: SendTransactionsType) => Promise<import('axios').AxiosResponse<import('../..').BatchTransactions, any>>;