@0xsquid/react-hooks 8.3.1 → 8.4.0

package/dist/{index-CMrdTYeW.js → index-BxJVsDEs.js}

@@ -81,6 +81,7 @@ const gasRefundMultiplier = 25;
 const internalSquidApiBaseUrl = "https://app.squidrouter.com/api";
 const XAMAN_API_URL = `${internalSquidApiBaseUrl}/xaman/`;
 const TOKEN_PRICE_API_URL = `${internalSquidApiBaseUrl}/coingecko`;
+const DEFAULT_ROUTE_REFETCH_INTERVAL = 30_000;
 const SOLANA_RPC_URL = "https://meredith-ute2ko-fast-mainnet.helius-rpc.com";
 const INTEGRATOR_ID = "squid-widget-playground-local-cd33cba6-7e12-4fcc-8d5d-35e286f655ea";
 const DEFAULT_COUNTRY_CODE = "US";
@@ -20834,6 +20835,309 @@ const isBitcoinAddressValid = (address$1) => {
     }
 };
 
+var HistoryTxType;
+(function (HistoryTxType) {
+    HistoryTxType[HistoryTxType["SWAP"] = 0] = "SWAP";
+    HistoryTxType[HistoryTxType["BUY"] = 1] = "BUY";
+    HistoryTxType[HistoryTxType["SEND"] = 2] = "SEND";
+})(HistoryTxType || (HistoryTxType = {}));
+
+var TransactionType;
+(function (TransactionType) {
+    TransactionType["BRIDGE"] = "BRIDGE";
+    TransactionType["BRIDGE_CALL"] = "BRIDGE_CALL";
+    TransactionType["CALL_BRIDGE"] = "CALL_BRIDGE";
+    TransactionType["CALL_BRIDGE_CALL"] = "CALL_BRIDGE_CALL";
+})(TransactionType || (TransactionType = {}));
+var AxelarStatusResponseType;
+(function (AxelarStatusResponseType) {
+    AxelarStatusResponseType["GAS_PAID_NOT_ENOUGH_GAS"] = "gas_paid_not_enough_gas";
+    AxelarStatusResponseType["DESTINATION_EXECUTED"] = "destination_executed";
+    AxelarStatusResponseType["EXPRESS_EXECUTED"] = "express_executed";
+    AxelarStatusResponseType["CROSS_MULTICALL_EXECUTED"] = "CrossMulticallExecuted";
+    AxelarStatusResponseType["CROSS_MULTICALL_FAILED"] = "CrossMulticallFailed";
+    AxelarStatusResponseType["SRC_GATEWAY_CALLED"] = "source_gateway_called";
+    AxelarStatusResponseType["DEST_GATEWAY_APPROVED"] = "destination_gateway_approved";
+    AxelarStatusResponseType["DESTINATION_EXECUTE_ERROR"] = "destination_execute_error";
+    AxelarStatusResponseType["DESTINATION_EXECUTING"] = "executing";
+    AxelarStatusResponseType["UNKNOWN_ERROR"] = "unknown_error";
+    AxelarStatusResponseType["CANNOT_FETCH_STATUS"] = "cannot_fetch_status";
+    AxelarStatusResponseType["ERROR"] = "error";
+})(AxelarStatusResponseType || (AxelarStatusResponseType = {}));
+var TransactionStatus;
+(function (TransactionStatus) {
+    // Submitted transaction, returned by squid axelar
+    TransactionStatus["SUCCESS"] = "success";
+    TransactionStatus["NEEDS_GAS"] = "needs_gas";
+    TransactionStatus["ONGOING"] = "ongoing";
+    TransactionStatus["PARTIAL_SUCCESS"] = "partial_success";
+    TransactionStatus["NOT_FOUND"] = "not_found";
+    // Unsubmitted Transaction, can be status from wallet
+    TransactionStatus["INITIAL_LOADING"] = "initialLoading";
+    TransactionStatus["GENERATING_DEPOSIT"] = "generating_deposit";
+    TransactionStatus["ERROR"] = "error";
+    TransactionStatus["WARNING"] = "warning";
+    TransactionStatus["PENDING"] = "pending";
+    TransactionStatus["REJECTED"] = "rejected";
+    // Coral refund
+    TransactionStatus["REFUNDED"] = "refunded";
+})(TransactionStatus || (TransactionStatus = {}));
+var SendTransactionStatus;
+(function (SendTransactionStatus) {
+    SendTransactionStatus[SendTransactionStatus["ONGOING"] = 0] = "ONGOING";
+    SendTransactionStatus[SendTransactionStatus["SUCCESS"] = 1] = "SUCCESS";
+    SendTransactionStatus[SendTransactionStatus["ERROR"] = 2] = "ERROR";
+})(SendTransactionStatus || (SendTransactionStatus = {}));
+
+const getQueryHeaders = (integratorId, requestId) => {
+    return {
+        ...(integratorId ? { "X-Integrator-Id": integratorId } : {}),
+        ...(requestId ? { "X-Request-Id": requestId } : {}),
+    };
+};
+const getStatusCode = (error) => {
+    if (axios.isAxiosError(error)) {
+        return error.response?.status;
+    }
+    return undefined;
+};
+const is404Error = (error) => {
+    const statusCode = getStatusCode(error);
+    if (statusCode === 404) {
+        return true;
+    }
+    return false;
+};
+
+const formatTransactionHistoryDate = (transaction) => {
+    if (!transaction?.timestamp)
+        return undefined;
+    try {
+        const date = new Date(Number(transaction.timestamp));
+        // Format date to: MMM DD. Examples:
+        // Jan 01
+        // May 12
+        const month = new Intl.DateTimeFormat(DEFAULT_LOCALE, {
+            month: "short",
+        }).format(date);
+        const day = date.toLocaleString(DEFAULT_LOCALE, { day: "2-digit" });
+        return { month, day };
+    }
+    catch (error) {
+        console.error("Error formatting date:", error);
+        return undefined;
+    }
+};
+const getAxelarExplorerTxUrl = (urlPrefix, routeType, txID) => {
+    if (!urlPrefix) {
+        return undefined;
+    }
+    const txType = routeType ?? TransactionType.BRIDGE;
+    if (txType === TransactionType.CALL_BRIDGE ||
+        txType === TransactionType.BRIDGE) {
+        return `${urlPrefix}transfer/${txID}`;
+    }
+    return `${urlPrefix}gmp/${txID}`;
+};
+const getSourceExplorerTxUrl = (chain, txID) => {
+    if (!chain || !chain.blockExplorerUrls[0] || !txID) {
+        return undefined;
+    }
+    let txSuffix;
+    switch (chain.chainId) {
+        case CHAIN_IDS.AGORIC:
+        case CHAIN_IDS.XRPL:
+        case CHAIN_IDS.XRPL_TESTNET:
+            txSuffix = "/transactions/";
+            break;
+        case CHAIN_IDS.HEDERA:
+            txSuffix = "/transaction/";
+            break;
+        default:
+            txSuffix = "/tx/";
+    }
+    if (chain.blockExplorerUrls[0].endsWith("/")) {
+        txSuffix = txSuffix.slice(1);
+    }
+    return `${chain.blockExplorerUrls[0]}${txSuffix}${txID}`;
+};
+const getMainExplorerUrl = (transaction) => {
+    // The most accurate one is coming from squid /status api
+    if (transaction?.statusResponse?.axelarTransactionUrl) {
+        return transaction?.statusResponse.axelarTransactionUrl;
+    }
+    // If not, we can try to get it from the source chain
+    if (transaction?.sourceTxExplorerUrl) {
+        return transaction?.sourceTxExplorerUrl;
+    }
+    // If not, we can try to guess it from the transaction type
+    if (transaction && transaction?.transactionId) {
+        return getAxelarExplorerTxUrl(transaction.statusResponse?.axelarTransactionUrl, transaction.routeType, transaction.transactionId);
+    }
+    return undefined;
+};
+const formatDistance = (date, baseDate, options) => {
+    const { includeSeconds = false, addSuffix = false, locale = { locale: DEFAULT_LOCALE }, } = options || {};
+    const elapsedMilliseconds = Math.abs(new Date(date).getTime() - new Date(baseDate).getTime());
+    const seconds = Math.round(elapsedMilliseconds / 1000);
+    const minutes = Math.round(seconds / 60);
+    const hours = Math.round(minutes / 60);
+    const days = Math.round(hours / 24);
+    const months = Math.round(days / 30.44);
+    const years = Math.round(days / 365.25);
+    const rtf = new Intl.RelativeTimeFormat(locale.locale, { numeric: "auto" });
+    let formatted = "";
+    if (includeSeconds && seconds < 45) {
+        const unit = addSuffix ? "second" : "seconds";
+        formatted = rtf.format(-seconds, unit);
+    }
+    else if (minutes < 60) {
+        formatted = rtf.format(-minutes, "minutes");
+    }
+    else if (hours < 24) {
+        formatted = rtf.format(-hours, "hours");
+    }
+    else if (days < 30) {
+        formatted = rtf.format(-days, "days");
+    }
+    else if (months < 12) {
+        formatted = rtf.format(-months, "months");
+    }
+    else {
+        formatted = rtf.format(-years, "years");
+    }
+    // remove "ago" from the string
+    // before: "2 minutes ago"
+    // after: "2 minutes"
+    return addSuffix ? formatted : formatted.replace(/\b(?:ago)\b/, "").trim();
+};
+const formatSeconds = (seconds, secondsTemplate = "s", minutesTemplate = "m", hoursTemplate = "h") => {
+    let duration = "";
+    if (seconds < 60) {
+        duration = `${seconds.toString()}${secondsTemplate}`;
+    }
+    else {
+        duration = formatDistance(0, seconds * 1000, { includeSeconds: true });
+    }
+    const result = duration.startsWith("1 ")
+        ? duration
+            .replace(" minute", minutesTemplate)
+            .replace(" hour", hoursTemplate)
+        : duration
+            .replace(" minutes", minutesTemplate)
+            .replace(" hours", hoursTemplate);
+    return result;
+};
+/**
+ * Remove the chainData from statusResponse to gain some storage space
+ */
+const formatSwapTxStatusResponseForStorage = (sr) => {
+    if (!sr) {
+        return sr;
+    }
+    return {
+        axelarTransactionUrl: sr.axelarTransactionUrl,
+        toChain: sr.toChain?.transactionUrl
+            ? {
+                transactionUrl: sr.toChain?.transactionUrl,
+            }
+            : undefined,
+    };
+};
+const simplifyRouteAction = (action) => {
+    return {
+        type: action.type,
+        provider: action.provider,
+        data: {
+            type: action.data?.type,
+        },
+        ...(action.coralV2Order ? { isCoralV2: true } : undefined),
+    };
+};
+const fetchSwapTransactionStatus = async ({ transaction, integratorId, apiUrl, }) => {
+    const statusEndpoint = `${apiUrl}/v2/status`;
+    try {
+        const response = await axios.get(statusEndpoint, {
+            params: {
+                transactionId: transaction?.transactionIdForStatus ?? transaction?.transactionId,
+                fromChainId: transaction?.fromChain,
+                toChainId: transaction?.toChain,
+                bridgeType: transaction?.bridgeType,
+                quoteId: transaction?.quoteId,
+                depositTxVerificationSignature: transaction?.depositTxVerificationSignature,
+            },
+            headers: getQueryHeaders(integratorId, transaction?.quoteId),
+        });
+        return response.data;
+    }
+    catch (error) {
+        if (error) {
+            throw new Error("Fetch transaction status failed", { cause: error });
+        }
+        throw new Error("Fetch transaction status failed", { cause: undefined });
+    }
+};
+const compareTransactionIds = (idA, idB) => {
+    if (!idA || !idB) {
+        return false;
+    }
+    const normalizedA = idA.toLowerCase();
+    const normalizedB = idB.toLowerCase();
+    return normalizedA.includes(normalizedB) || normalizedB.includes(normalizedA);
+};
+/**
+ * Checks if the provided action is Coral bridge action
+ */
+function isCoralBridgeAction(action) {
+    return (action.type === ActionType.RFQ &&
+        // TODO: update types
+        action.provider?.toLowerCase() === "coral");
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const isDepositRoute = (route) => {
+    return (!!route &&
+        route.transactionRequest?.type === SquidDataType.ChainflipDepositAddress);
+};
+/**
+ * Checks if the route contains a Chainflip bridge action
+ */
+function isChainflipBridgeTransaction(actions = []) {
+    return actions.some((action) => action.type === ActionType.BRIDGE &&
+        action.data?.type === BridgeType.CHAINFLIP);
+}
+/**
+ * Checks if a route is of type {@link OnChainExecutionData}
+ *
+ * On-chain routes require calling a smart contract to execute
+ */
+function isOnChainTxData(squidData) {
+    return [
+        SquidDataType.OnChainExecution,
+        SquidDataType.DepositAddressWithSignature,
+    ].includes(squidData.type);
+}
+/**
+ * Checks if a route is of type deposit-with-signature
+ *
+ * deposit-with-signature routes are on-chain routes
+ * that require a signature from the user to execute
+ */
+function isDepositWithSignatureTxData(squidData) {
+    return squidData.type === SquidDataType.DepositAddressWithSignature;
+}
+function getHistoryTransactionId(tx) {
+    switch (tx.txType) {
+        case HistoryTxType.SWAP:
+            return tx.data.transactionId;
+        case HistoryTxType.BUY:
+            return tx.data.orderId;
+        case HistoryTxType.SEND:
+            return tx.data.hash;
+    }
+}
+
 const STANDARD_FEATURES = [
     "standard:connect",
     "standard:events",
@@ -21010,7 +21314,7 @@ const isSolanaAddressValid = (address) => {
  * This will be used for the swap flow - Using Jupiter Dex under the hood
  */
 const executeSolanaSwap = async ({ route, signer, connection, onSigned, }) => {
-    if (!route?.transactionRequest?.data) {
+    if (!route.transactionRequest || !isOnChainTxData(route.transactionRequest)) {
         throw new Error("Invalid parameters");
     }
     const swapRequest = route.transactionRequest.data;
@@ -21885,285 +22189,6 @@ async function getXummClient() {
     return xummClient;
 }
 
-const getQueryHeaders = (integratorId, requestId) => {
-    return {
-        ...(integratorId ? { "X-Integrator-Id": integratorId } : {}),
-        ...(requestId ? { "X-Request-Id": requestId } : {}),
-    };
-};
-const getStatusCode = (error) => {
-    if (axios.isAxiosError(error)) {
-        return error.response?.status;
-    }
-    return undefined;
-};
-const is404Error = (error) => {
-    const statusCode = getStatusCode(error);
-    if (statusCode === 404) {
-        return true;
-    }
-    return false;
-};
-
-var HistoryTxType;
-(function (HistoryTxType) {
-    HistoryTxType[HistoryTxType["SWAP"] = 0] = "SWAP";
-    HistoryTxType[HistoryTxType["BUY"] = 1] = "BUY";
-    HistoryTxType[HistoryTxType["SEND"] = 2] = "SEND";
-})(HistoryTxType || (HistoryTxType = {}));
-
-var TransactionType;
-(function (TransactionType) {
-    TransactionType["BRIDGE"] = "BRIDGE";
-    TransactionType["BRIDGE_CALL"] = "BRIDGE_CALL";
-    TransactionType["CALL_BRIDGE"] = "CALL_BRIDGE";
-    TransactionType["CALL_BRIDGE_CALL"] = "CALL_BRIDGE_CALL";
-})(TransactionType || (TransactionType = {}));
-var AxelarStatusResponseType;
-(function (AxelarStatusResponseType) {
-    AxelarStatusResponseType["GAS_PAID_NOT_ENOUGH_GAS"] = "gas_paid_not_enough_gas";
-    AxelarStatusResponseType["DESTINATION_EXECUTED"] = "destination_executed";
-    AxelarStatusResponseType["EXPRESS_EXECUTED"] = "express_executed";
-    AxelarStatusResponseType["CROSS_MULTICALL_EXECUTED"] = "CrossMulticallExecuted";
-    AxelarStatusResponseType["CROSS_MULTICALL_FAILED"] = "CrossMulticallFailed";
-    AxelarStatusResponseType["SRC_GATEWAY_CALLED"] = "source_gateway_called";
-    AxelarStatusResponseType["DEST_GATEWAY_APPROVED"] = "destination_gateway_approved";
-    AxelarStatusResponseType["DESTINATION_EXECUTE_ERROR"] = "destination_execute_error";
-    AxelarStatusResponseType["DESTINATION_EXECUTING"] = "executing";
-    AxelarStatusResponseType["UNKNOWN_ERROR"] = "unknown_error";
-    AxelarStatusResponseType["CANNOT_FETCH_STATUS"] = "cannot_fetch_status";
-    AxelarStatusResponseType["ERROR"] = "error";
-})(AxelarStatusResponseType || (AxelarStatusResponseType = {}));
-var TransactionStatus;
-(function (TransactionStatus) {
-    // Submitted transaction, returned by squid axelar
-    TransactionStatus["SUCCESS"] = "success";
-    TransactionStatus["NEEDS_GAS"] = "needs_gas";
-    TransactionStatus["ONGOING"] = "ongoing";
-    TransactionStatus["PARTIAL_SUCCESS"] = "partial_success";
-    TransactionStatus["NOT_FOUND"] = "not_found";
-    // Unsubmitted Transaction, can be status from wallet
-    TransactionStatus["INITIAL_LOADING"] = "initialLoading";
-    TransactionStatus["GENERATING_DEPOSIT"] = "generating_deposit";
-    TransactionStatus["ERROR"] = "error";
-    TransactionStatus["WARNING"] = "warning";
-    TransactionStatus["PENDING"] = "pending";
-    TransactionStatus["REJECTED"] = "rejected";
-    // Coral refund
-    TransactionStatus["REFUNDED"] = "refunded";
-})(TransactionStatus || (TransactionStatus = {}));
-var SendTransactionStatus;
-(function (SendTransactionStatus) {
-    SendTransactionStatus[SendTransactionStatus["ONGOING"] = 0] = "ONGOING";
-    SendTransactionStatus[SendTransactionStatus["SUCCESS"] = 1] = "SUCCESS";
-    SendTransactionStatus[SendTransactionStatus["ERROR"] = 2] = "ERROR";
-})(SendTransactionStatus || (SendTransactionStatus = {}));
-
-const formatTransactionHistoryDate = (transaction) => {
-    if (!transaction?.timestamp)
-        return undefined;
-    try {
-        const date = new Date(Number(transaction.timestamp));
-        // Format date to: MMM DD. Examples:
-        // Jan 01
-        // May 12
-        const month = new Intl.DateTimeFormat(DEFAULT_LOCALE, {
-            month: "short",
-        }).format(date);
-        const day = date.toLocaleString(DEFAULT_LOCALE, { day: "2-digit" });
-        return { month, day };
-    }
-    catch (error) {
-        console.error("Error formatting date:", error);
-        return undefined;
-    }
-};
-const getAxelarExplorerTxUrl = (urlPrefix, routeType, txID) => {
-    if (!urlPrefix) {
-        return undefined;
-    }
-    const txType = routeType ?? TransactionType.BRIDGE;
-    if (txType === TransactionType.CALL_BRIDGE ||
-        txType === TransactionType.BRIDGE) {
-        return `${urlPrefix}transfer/${txID}`;
-    }
-    return `${urlPrefix}gmp/${txID}`;
-};
-const getSourceExplorerTxUrl = (chain, txID) => {
-    if (!chain || !chain.blockExplorerUrls[0] || !txID) {
-        return undefined;
-    }
-    let txSuffix;
-    switch (chain.chainId) {
-        case CHAIN_IDS.AGORIC:
-        case CHAIN_IDS.XRPL:
-        case CHAIN_IDS.XRPL_TESTNET:
-            txSuffix = "/transactions/";
-            break;
-        default:
-            txSuffix = "/tx/";
-    }
-    if (chain.blockExplorerUrls[0].endsWith("/")) {
-        txSuffix = txSuffix.slice(1);
-    }
-    return `${chain.blockExplorerUrls[0]}${txSuffix}${txID}`;
-};
-const getMainExplorerUrl = (transaction) => {
-    // The most accurate one is coming from squid /status api
-    if (transaction?.statusResponse?.axelarTransactionUrl) {
-        return transaction?.statusResponse.axelarTransactionUrl;
-    }
-    // If not, we can try to get it from the source chain
-    if (transaction?.sourceTxExplorerUrl) {
-        return transaction?.sourceTxExplorerUrl;
-    }
-    // If not, we can try to guess it from the transaction type
-    if (transaction && transaction?.transactionId) {
-        return getAxelarExplorerTxUrl(transaction.statusResponse?.axelarTransactionUrl, transaction.routeType, transaction.transactionId);
-    }
-    return undefined;
-};
-const formatDistance = (date, baseDate, options) => {
-    const { includeSeconds = false, addSuffix = false, locale = { locale: DEFAULT_LOCALE }, } = options || {};
-    const elapsedMilliseconds = Math.abs(new Date(date).getTime() - new Date(baseDate).getTime());
-    const seconds = Math.round(elapsedMilliseconds / 1000);
-    const minutes = Math.round(seconds / 60);
-    const hours = Math.round(minutes / 60);
-    const days = Math.round(hours / 24);
-    const months = Math.round(days / 30.44);
-    const years = Math.round(days / 365.25);
-    const rtf = new Intl.RelativeTimeFormat(locale.locale, { numeric: "auto" });
-    let formatted = "";
-    if (includeSeconds && seconds < 45) {
-        const unit = addSuffix ? "second" : "seconds";
-        formatted = rtf.format(-seconds, unit);
-    }
-    else if (minutes < 60) {
-        formatted = rtf.format(-minutes, "minutes");
-    }
-    else if (hours < 24) {
-        formatted = rtf.format(-hours, "hours");
-    }
-    else if (days < 30) {
-        formatted = rtf.format(-days, "days");
-    }
-    else if (months < 12) {
-        formatted = rtf.format(-months, "months");
-    }
-    else {
-        formatted = rtf.format(-years, "years");
-    }
-    // remove "ago" from the string
-    // before: "2 minutes ago"
-    // after: "2 minutes"
-    return addSuffix ? formatted : formatted.replace(/\b(?:ago)\b/, "").trim();
-};
-const formatSeconds = (seconds, secondsTemplate = "s", minutesTemplate = "m", hoursTemplate = "h") => {
-    let duration = "";
-    if (seconds < 60) {
-        duration = `${seconds.toString()}${secondsTemplate}`;
-    }
-    else {
-        duration = formatDistance(0, seconds * 1000, { includeSeconds: true });
-    }
-    const result = duration.startsWith("1 ")
-        ? duration
-            .replace(" minute", minutesTemplate)
-            .replace(" hour", hoursTemplate)
-        : duration
-            .replace(" minutes", minutesTemplate)
-            .replace(" hours", hoursTemplate);
-    return result;
-};
-/**
- * Remove the chainData from statusResponse to gain some storage space
- */
-const formatSwapTxStatusResponseForStorage = (sr) => {
-    if (!sr) {
-        return sr;
-    }
-    return {
-        axelarTransactionUrl: sr.axelarTransactionUrl,
-        toChain: sr.toChain?.transactionUrl
-            ? {
-                transactionUrl: sr.toChain?.transactionUrl,
-            }
-            : undefined,
-    };
-};
-const simplifyRouteAction = (action) => {
-    return {
-        type: action.type,
-        provider: action.provider,
-        data: {
-            type: action.data?.type,
-        },
-        ...(action.coralV2Order ? { isCoralV2: true } : undefined),
-    };
-};
-const fetchSwapTransactionStatus = async ({ transaction, integratorId, apiUrl, }) => {
-    const statusEndpoint = `${apiUrl}/v2/status`;
-    try {
-        const response = await axios.get(statusEndpoint, {
-            params: {
-                transactionId: transaction?.transactionIdForStatus ?? transaction?.transactionId,
-                fromChainId: transaction?.fromChain,
-                toChainId: transaction?.toChain,
-                bridgeType: transaction?.bridgeType,
-                quoteId: transaction?.quoteId,
-            },
-            headers: getQueryHeaders(integratorId, transaction?.quoteId),
-        });
-        return response.data;
-    }
-    catch (error) {
-        if (error) {
-            throw new Error("Fetch transaction status failed", { cause: error });
-        }
-        throw new Error("Fetch transaction status failed", { cause: undefined });
-    }
-};
-const compareTransactionIds = (idA, idB) => {
-    if (!idA || !idB) {
-        return false;
-    }
-    const normalizedA = idA.toLowerCase();
-    const normalizedB = idB.toLowerCase();
-    return normalizedA.includes(normalizedB) || normalizedB.includes(normalizedA);
-};
-/**
- * Checks if the provided action is Coral bridge action
- */
-function isCoralBridgeAction(action) {
-    return (action.type === ActionType.RFQ &&
-        // TODO: update types
-        action.provider?.toLowerCase() === "coral");
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-const isDepositRoute = (route) => {
-    return (!!route &&
-        route.transactionRequest?.type === SquidDataType.ChainflipDepositAddress);
-};
-/**
- * Checks if the route contains a Chainflip bridge action
- */
-function isChainflipBridgeTransaction(actions = []) {
-    return actions.some((action) => action.type === ActionType.BRIDGE &&
-        action.data?.type === BridgeType.CHAINFLIP);
-}
-function getHistoryTransactionId(tx) {
-    switch (tx.txType) {
-        case HistoryTxType.SWAP:
-            return tx.data.transactionId;
-        case HistoryTxType.BUY:
-            return tx.data.orderId;
-        case HistoryTxType.SEND:
-            return tx.data.hash;
-    }
-}
-
 var QueryKeys;
 (function (QueryKeys) {
     QueryKeys["All"] = "all";
@@ -23132,7 +23157,7 @@ const filterViewableTokens = (tokens, config, direction) => {
 };
 const getSecretNetworkBalances = async (chainData, cosmosAddress, squidTokens, keplrTypeWallet) => {
     const squidSecretTokens = squidTokens.filter((t) => t.chainId === CHAIN_IDS.SECRET);
-    const { fetchAllSecretBalances } = await import('./secretService-B3sc6ibT.js');
+    const { fetchAllSecretBalances } = await import('./secretService-D0xrwhEv.js');
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -24604,6 +24629,37 @@ function convertHederaAccountIdToEvmAddress(accId) {
 function convertEvmAddressToHederaAccountId(address) {
     return "0.0." + Number(address);
 }
+/**
+ * In Hedera, native HBAR has 8 decimals, but when handling `value` or gas in the EVM we need to use 18 decimals.
+ * To handle this we need to multiply/divide the 1e8 HBAR by 10^10 to get the scaled 1e18/1e8 HBAR value.
+ * @see https://docs.hedera.com/hedera/core-concepts/smart-contracts/understanding-hederas-evm-differences-and-compatibility/for-evm-developers-migrating-to-hedera/decimal-handling-8-vs.-18-decimals
+ */
+const HBAR_SCALING_FACTOR = BigInt(10 ** 10);
+function scaleHbarToWei(hbar) {
+    return hbar * HBAR_SCALING_FACTOR;
+}
+function scaleWeiToHbar(wei) {
+    return wei / HBAR_SCALING_FACTOR;
+}
+
+/**
+ * Return the expiry of a route in milliseconds
+ *
+ * @param route - Squid route
+ * @returns expiry in milliseconds
+ */
+function getRouteExpiry(route) {
+    if (!route?.transactionRequest)
+        return DEFAULT_ROUTE_REFETCH_INTERVAL;
+    if (!isOnChainTxData(route.transactionRequest)) {
+        return DEFAULT_ROUTE_REFETCH_INTERVAL;
+    }
+    const { expiryOffset } = route.transactionRequest;
+    if (expiryOffset != null && Number(expiryOffset) >= 0) {
+        return Number(expiryOffset) * 1_000;
+    }
+    return DEFAULT_ROUTE_REFETCH_INTERVAL;
+}
 
 /**
  * Minimum length of a search query to search by address
@@ -26417,7 +26473,7 @@ function useStellarWallets() {
             try {
                 const { allowAllModules: initializeAllModules } = await import('@creit.tech/stellar-wallets-kit');
                 const { LedgerModule } = await import('@creit.tech/stellar-wallets-kit/modules/ledger.module');
-                const { formatStellarWallet } = await import('./stellarService.client-Ciqw9lmL.js');
+                const { formatStellarWallet } = await import('./stellarService.client-xMf7fjCz.js');
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -27917,7 +27973,7 @@ function hederaWalletConnect(parameters) {
                 const optionalChains = config.chains.map((x) => x.id);
                 if (!optionalChains.length)
                     return;
-                const { EthereumProvider } = await import('./index.es-DRgOycmm.js');
+                const { EthereumProvider } = await import('./index.es-CFf55ppw.js');
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -29678,6 +29734,490 @@ function useStellarAccountActivation({ address, chain, token, }) {
     };
 }
 
+const DEFAULT_REFRESH_INTERVAL_MS = 15000;
+const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
+    const { isChainTypeConnected } = useWallet();
+    const isNativeToken = token?.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase();
+    const userAddressParsed = userAddress;
+    // Only fetch using useBalance if it's a native token
+    const { data: nativeBalance, isLoading: isNativeTokenLoading } = useBalance({
+        address: userAddressParsed,
+        chainId: Number(chain?.chainId),
+        query: {
+            enabled: enabled &&
+                !!userAddress &&
+                isNativeToken &&
+                !!chain &&
+                chain.chainType === ChainType.EVM &&
+                isChainTypeConnected(chain.chainType),
+            refetchInterval: refreshIntervalMs,
+            retry: 2,
+        },
+    });
+    // Only fetch using useReadContract if it's not a native token
+    // This is temporary, because of wagmi error: https://github.com/wevm/wagmi/issues/4353
+    const { data: erc20Balance, isLoading: isErc20Loading } = useReadContract({
+        address: token?.address,
+        abi: erc20Abi,
+        functionName: "balanceOf",
+        args: [userAddressParsed],
+        chainId: Number(chain?.chainId),
+        query: {
+            enabled: isChainTypeConnected(ChainType.EVM) &&
+                enabled &&
+                !!userAddress &&
+                !isNativeToken,
+            refetchInterval: refreshIntervalMs,
+            retry: 2,
+        },
+    });
+    if (isNativeToken) {
+        return {
+            isLoading: isNativeTokenLoading,
+            balance: nativeBalance
+                ? formatBNToReadable(nativeBalance.value, nativeBalance.decimals)
+                : "0",
+        };
+    }
+    return {
+        balance: erc20Balance && token
+            ? formatBNToReadable(erc20Balance, token.decimals)
+            : "0",
+        isLoading: isErc20Loading,
+    };
+};
+const useCosmosBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
+    const { isConnected } = useCosmosContext();
+    const { data: balance = "0", isLoading } = useQuery({
+        queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
+        queryFn: async () => {
+            if (!userAddress || !token || chain?.chainType !== ChainType.COSMOS) {
+                return "0";
+            }
+            const isAddressValid = isCosmosAddressValid(chain.bech32Config.bech32PrefixAccAddr, userAddress);
+            if (!isAddressValid)
+                return "0";
+            const balanceBn = await getCosmosTokenBalance(chain, userAddress, token.address);
+            return formatBNToReadable(balanceBn, token.decimals);
+        },
+        enabled: isConnected &&
+            enabled &&
+            !!userAddress &&
+            !!token &&
+            chain?.chainType === ChainType.COSMOS,
+        refetchInterval: refreshIntervalMs,
+        retry: 2,
+    });
+    return { balance, isLoading };
+};
+const useSolanaBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
+    const { data: balance = "0", isLoading } = useQuery({
+        queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
+        queryFn: async () => {
+            if (!userAddress || !token)
+                return "0";
+            const balanceBn = await getSolanaTokenBalance(userAddress, token.address);
+            return formatBNToReadable(balanceBn, token.decimals);
+        },
+        enabled: enabled &&
+            !!userAddress &&
+            !!token &&
+            chain?.chainType === ChainType.SOLANA,
+        refetchInterval: refreshIntervalMs,
+        retry: 2,
+    });
+    return { balance, isLoading };
+};
+// TODO: implement fetching balances for all bitcoin tokens
+const useBitcoinBalance = ({ userAddress, chain, }) => {
+    const { balance: balanceBn, isLoading } = useBitcoinNativeBalance({
+        address: userAddress,
+        chain,
+    });
+    const balance = useMemo(() => {
+        if (!balanceBn)
+            return "0";
+        return formatBNToReadable(balanceBn?.value, balanceBn?.decimals);
+    }, [balanceBn]);
+    return { balance, isLoading };
+};
+const useSuiBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
+    const { data: balance = "0", isLoading } = useQuery({
+        queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
+        queryFn: async () => {
+            if (!userAddress ||
+                token?.type !== ChainType.SUI ||
+                chain?.chainType !== ChainType.SUI) {
+                throw new Error("Invalid SUI balance query parameters");
+            }
+            const balanceBn = await getSuiTokenBalance(userAddress, token.address, chain.rpc);
+            return formatBNToReadable(balanceBn, token.decimals) ?? "0";
+        },
+        enabled: enabled &&
+            !!userAddress &&
+            !!chain?.rpc &&
+            token?.type === ChainType.SUI &&
+            chain?.chainType === ChainType.SUI &&
+            isSuiAddressValid(userAddress),
+        refetchInterval: refreshIntervalMs,
+        retry: 2,
+    });
+    return { balance, isLoading };
+};
+const useXrplBalance = ({ userAddress, chain, enabled, token, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
+    const { data: balance = "0", isLoading } = useQuery({
+        queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
+        queryFn: async () => {
+            if (!userAddress || !token || !chain)
+                return "0";
+            const balanceBn = await getXrplTokenBalance(userAddress, token, chain);
+            return formatBNToReadable(balanceBn, token.decimals) ?? "0";
+        },
+        enabled: enabled &&
+            !!userAddress &&
+            !!token &&
+            !!chain?.rpc &&
+            chain?.chainType === ChainType.XRPL &&
+            isXrplAddressValid(userAddress),
+        refetchInterval: refreshIntervalMs,
+        retry: 2,
+    });
+    return { balance, isLoading };
+};
+const useStellarBalance = ({ userAddress, chain, enabled, token, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
+    const { data: balance = "0", isLoading } = useQuery({
+        queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
+        queryFn: async () => {
+            if (!userAddress || !token || !chain)
+                return "0";
+            const balanceBn = await getStellarTokenBalance(userAddress, token, chain);
+            return formatBNToReadable(balanceBn, token.decimals) ?? "0";
+        },
+        enabled: enabled &&
+            !!userAddress &&
+            !!token &&
+            !!chain?.rpc &&
+            chain?.chainType === ChainType.STELLAR &&
+            isStellarAddressValid(userAddress),
+        refetchInterval: refreshIntervalMs,
+        retry: 2,
+    });
+    return { balance, isLoading };
+};
+
+function useNativeTokenForChain(chain) {
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, } = useSquidTokens();
+    const getTokensForChainType = () => {
+        if (!chain?.chainType)
+            return [];
+        switch (chain.chainType) {
+            case ChainType.EVM:
+                return evmTokens;
+            case ChainType.COSMOS:
+                return cosmosTokens;
+            case ChainType.SOLANA:
+                return solanaTokens;
+            case ChainType.BTC:
+                return bitcoinTokens;
+            case ChainType.SUI:
+                return suiTokens;
+            case ChainType.XRPL:
+                return xrplTokens;
+            case ChainType.STELLAR:
+                return stellarTokens;
+        }
+    };
+    const nativeTokenForChainType = useMemo(() => {
+        return findNativeToken(getTokensForChainType(), chain);
+    }, [chain]);
+    return { nativeToken: nativeTokenForChainType };
+}
+
+const useEvmNativeBalance = ({ address, chain, }) => {
+    const { isChainTypeConnected } = useWallet();
+    const { data: nativeEvmBalance, isLoading } = useBalance({
+        address: address,
+        chainId: Number(chain?.chainId),
+        query: {
+            enabled: isChainTypeConnected(ChainType.EVM) && !!address,
+            refetchInterval: 10000,
+            staleTime: 5000,
+            refetchOnWindowFocus: true,
+            refetchOnMount: true,
+        },
+    });
+    const balance = useMemo(() => {
+        if (nativeEvmBalance?.decimals && nativeEvmBalance?.value) {
+            return {
+                decimals: nativeEvmBalance.decimals,
+                value: nativeEvmBalance.value,
+            };
+        }
+        return;
+    }, [nativeEvmBalance?.decimals, nativeEvmBalance?.value]);
+    return {
+        balance,
+        isLoading,
+    };
+};
+const useCosmosNativeBalance = ({ address, chain, }) => {
+    const { isConnected: isCosmosConnected } = useCosmosContext();
+    const { nativeToken: nativeCosmosToken } = useNativeTokenForChain(chain);
+    const { balance: rawBalance, isLoading } = useCosmosBalance({
+        chain,
+        token: nativeCosmosToken,
+        userAddress: address,
+        enabled: isCosmosConnected && chain?.chainType === ChainType.COSMOS,
+        refreshIntervalMs: 10000,
+    });
+    const balance = useMemo(() => {
+        if (nativeCosmosToken?.decimals && rawBalance) {
+            return {
+                decimals: nativeCosmosToken.decimals,
+                value: parseToBigInt(rawBalance, nativeCosmosToken.decimals),
+            };
+        }
+    }, [nativeCosmosToken?.decimals, rawBalance]);
+    return { balance, isLoading };
+};
+const useBitcoinNativeBalance = ({ chain, address, }) => {
+    const { nativeToken } = useNativeTokenForChain(chain);
+    const { data: rawBalance = "0", isLoading } = useQuery(keys().balance(chain?.chainId, nativeToken?.address, address), async () => {
+        if (!address || !nativeToken)
+            return "0";
+        const balance = await getBitcoinNativeBalance(address);
+        return formatBNToReadable(balance, nativeToken.decimals);
+    }, {
+        enabled: chain?.chainType === ChainType.BTC &&
+            nativeToken?.decimals != null &&
+            isWalletAddressValid(chain, address),
+        refetchInterval: 40000,
+        staleTime: 20000,
+        refetchOnWindowFocus: true,
+        refetchOnMount: true,
+    });
+    const balance = useMemo(() => {
+        if (nativeToken?.decimals && rawBalance) {
+            return {
+                decimals: nativeToken.decimals,
+                value: parseToBigInt(rawBalance, nativeToken.decimals),
+            };
+        }
+    }, [nativeToken?.decimals, rawBalance]);
+    return {
+        balance,
+        isLoading,
+    };
+};
+const useSolanaNativeBalance = ({ chain, address, }) => {
+    const { nativeToken } = useNativeTokenForChain(chain);
+    const { data: rawBalance, isLoading } = useQuery(keys().balance(chain?.chainId, nativeToken?.address, address), async () => {
+        const balance = await getSolanaNativeBalance(address);
+        return formatBNToReadable(balance, nativeToken.decimals);
+    }, {
+        enabled: !!address &&
+            nativeToken?.decimals != null &&
+            chain?.chainType === ChainType.SOLANA,
+        refetchInterval: 40000,
+        staleTime: 20000,
+        refetchOnWindowFocus: true,
+        refetchOnMount: true,
+    });
+    const balance = useMemo(() => {
+        if (nativeToken?.decimals && rawBalance) {
+            return {
+                decimals: nativeToken.decimals,
+                value: parseToBigInt(rawBalance, nativeToken.decimals),
+            };
+        }
+    }, [nativeToken?.decimals, rawBalance]);
+    return {
+        balance,
+        isLoading,
+    };
+};
+const useSuiNativeBalance = ({ address, chain, }) => {
+    const { nativeToken } = useNativeTokenForChain(chain);
+    const { balance: rawBalance, isLoading } = useSuiBalance({
+        chain,
+        token: nativeToken,
+        userAddress: address,
+    });
+    const balance = useMemo(() => {
+        if (nativeToken?.decimals && rawBalance) {
+            return {
+                decimals: nativeToken.decimals,
+                value: parseToBigInt(rawBalance, nativeToken.decimals),
+            };
+        }
+    }, [nativeToken?.decimals, rawBalance]);
+    return {
+        balance,
+        isLoading,
+    };
+};
+const useXrplNativeBalance = ({ address, chain, }) => {
+    const { nativeToken } = useNativeTokenForChain(chain);
+    const { balance: rawBalance, isLoading } = useXrplBalance({
+        chain,
+        token: nativeToken,
+        userAddress: address,
+        enabled: chain?.chainType === ChainType.XRPL,
+    });
+    const balance = useMemo(() => {
+        if (nativeToken?.decimals && rawBalance) {
+            return {
+                decimals: nativeToken.decimals,
+                value: parseToBigInt(rawBalance, nativeToken.decimals),
+            };
+        }
+    }, [nativeToken?.decimals, rawBalance]);
+    return {
+        balance,
+        isLoading,
+    };
+};
+const useStellarNativeBalance = ({ address, chain, }) => {
+    const { nativeToken } = useNativeTokenForChain(chain);
+    const { balance: rawBalance, isLoading } = useStellarBalance({
+        chain,
+        token: nativeToken,
+        userAddress: address,
+        enabled: chain?.chainType === ChainType.STELLAR,
+    });
+    const balance = useMemo(() => {
+        if (nativeToken?.decimals && rawBalance) {
+            return {
+                decimals: nativeToken.decimals,
+                value: parseToBigInt(rawBalance, nativeToken.decimals),
+            };
+        }
+    }, [nativeToken?.decimals, rawBalance]);
+    return {
+        balance,
+        isLoading,
+    };
+};
+const useNativeBalance = (chain) => {
+    const { connectedAddresses } = useWallet();
+    const { data: cosmosAddressForChain } = useCosmosForChain(chain);
+    // Cosmos is a special case because the address changes on every chain
+    // so we can't use the default cosmos connected address
+    const { balance: nativeCosmosBalance, isLoading: isCosmosLoading } = useCosmosNativeBalance({
+        address: cosmosAddressForChain,
+        chain,
+    });
+    const { balance: nativeEvmBalance, isLoading: isEvmLoading } = useEvmNativeBalance({ address: connectedAddresses[ChainType.EVM], chain });
+    const { balance: nativeBitcoinBalance, isLoading: isBitcoinLoading } = useBitcoinNativeBalance({
+        address: connectedAddresses[ChainType.BTC],
+        chain,
+    });
+    const { balance: nativeSolanaBalance, isLoading: isSolanaLoading } = useSolanaNativeBalance({
+        address: connectedAddresses[ChainType.SOLANA],
+        chain,
+    });
+    const { balance: nativeSuiBalance, isLoading: isSuiLoading } = useSuiNativeBalance({
+        address: connectedAddresses[ChainType.SUI],
+        chain,
+    });
+    const { balance: nativeXrplBalance, isLoading: isXrpLoading } = useXrplNativeBalance({
+        address: connectedAddresses[ChainType.XRPL],
+        chain,
+    });
+    const { balance: nativeStellarBalance, isLoading: isStellarLoading } = useStellarNativeBalance({
+        address: connectedAddresses[ChainType.STELLAR],
+        chain,
+    });
+    const { nativeBalance, nativeBalanceFormatted } = useMemo(() => {
+        let balance;
+        switch (chain?.chainType) {
+            case ChainType.EVM:
+                balance = nativeEvmBalance;
+                break;
+            case ChainType.COSMOS:
+                balance = nativeCosmosBalance;
+                break;
+            case ChainType.BTC:
+                balance = nativeBitcoinBalance;
+                break;
+            case ChainType.SOLANA:
+                balance = nativeSolanaBalance;
+                break;
+            case ChainType.SUI:
+                balance = nativeSuiBalance;
+                break;
+            case ChainType.XRPL:
+                balance = nativeXrplBalance;
+                break;
+            case ChainType.STELLAR:
+                balance = nativeStellarBalance;
+        }
+        const balanceFormatted = !!balance
+            ? formatBNToReadable(balance.value, balance.decimals)
+            : undefined;
+        return {
+            nativeBalance: balance,
+            nativeBalanceFormatted: balanceFormatted,
+        };
+    }, [
+        chain?.chainType,
+        nativeEvmBalance,
+        nativeCosmosBalance,
+        nativeBitcoinBalance,
+        nativeSolanaBalance,
+        nativeSuiBalance,
+        nativeXrplBalance,
+        nativeStellarBalance,
+    ]);
+    const isLoading = useMemo(() => {
+        if (!chain?.chainType)
+            return false;
+        switch (chain.chainType) {
+            case ChainType.EVM:
+                return isEvmLoading;
+            case ChainType.COSMOS:
+                return isCosmosLoading;
+            case ChainType.BTC:
+                return isBitcoinLoading;
+            case ChainType.SOLANA:
+                return isSolanaLoading;
+            case ChainType.SUI:
+                return isSuiLoading;
+            case ChainType.XRPL:
+                return isXrpLoading;
+            case ChainType.STELLAR:
+                return isStellarLoading;
+        }
+    }, [
+        chain?.chainType,
+        isEvmLoading,
+        isCosmosLoading,
+        isBitcoinLoading,
+        isSolanaLoading,
+        isSuiLoading,
+        isXrpLoading,
+        isStellarLoading,
+    ]);
+    return { nativeBalance, nativeBalanceFormatted, isLoading };
+};
+
+function useHederaAccountActivation({ address, chain, token }) {
+    const { balance: destNativeEvmBalance } = useEvmNativeBalance({
+        chain,
+        address,
+    });
+    const isHederaAccountActivated = useMemo(() => {
+        if (token?.chainId !== CHAIN_IDS.HEDERA)
+            return true;
+        if (token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase())
+            return true;
+        return (!!destNativeEvmBalance?.value && destNativeEvmBalance.value > BigInt(0));
+    }, [token?.chainId, token?.address, destNativeEvmBalance?.value]);
+    return {
+        isHederaAccountActivated,
+    };
+}
+
 const useAddressBookStore = create(persist((set) => ({
     addressBook: [],
     add: (newAddressData) => {
@@ -30043,473 +30583,6 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
     };
 };
 
-function useNativeTokenForChain(chain) {
-    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, } = useSquidTokens();
-    const getTokensForChainType = () => {
-        if (!chain?.chainType)
-            return [];
-        switch (chain.chainType) {
-            case ChainType.EVM:
-                return evmTokens;
-            case ChainType.COSMOS:
-                return cosmosTokens;
-            case ChainType.SOLANA:
-                return solanaTokens;
-            case ChainType.BTC:
-                return bitcoinTokens;
-            case ChainType.SUI:
-                return suiTokens;
-            case ChainType.XRPL:
-                return xrplTokens;
-            case ChainType.STELLAR:
-                return stellarTokens;
-        }
-    };
-    const nativeTokenForChainType = useMemo(() => {
-        return findNativeToken(getTokensForChainType(), chain);
-    }, [chain]);
-    return { nativeToken: nativeTokenForChainType };
-}
-
-const useEvmNativeBalance = ({ address, chain, }) => {
-    const { isChainTypeConnected } = useWallet();
-    const { data: nativeEvmBalance, isLoading } = useBalance({
-        address: address,
-        chainId: Number(chain?.chainId),
-        query: {
-            enabled: isChainTypeConnected(ChainType.EVM) && !!address,
-            refetchInterval: 10000,
-            staleTime: 5000,
-            refetchOnWindowFocus: true,
-            refetchOnMount: true,
-        },
-    });
-    const balance = useMemo(() => {
-        if (nativeEvmBalance?.decimals && nativeEvmBalance?.value) {
-            return {
-                decimals: nativeEvmBalance.decimals,
-                value: nativeEvmBalance.value,
-            };
-        }
-        return;
-    }, [nativeEvmBalance?.decimals, nativeEvmBalance?.value]);
-    return {
-        balance,
-        isLoading,
-    };
-};
-const useCosmosNativeBalance = ({ address, chain, }) => {
-    const { isConnected: isCosmosConnected } = useCosmosContext();
-    const { nativeToken: nativeCosmosToken } = useNativeTokenForChain(chain);
-    const { balance: rawBalance, isLoading } = useCosmosBalance({
-        chain,
-        token: nativeCosmosToken,
-        userAddress: address,
-        enabled: isCosmosConnected && chain?.chainType === ChainType.COSMOS,
-        refreshIntervalMs: 10000,
-    });
-    const balance = useMemo(() => {
-        if (nativeCosmosToken?.decimals && rawBalance) {
-            return {
-                decimals: nativeCosmosToken.decimals,
-                value: parseToBigInt(rawBalance, nativeCosmosToken.decimals),
-            };
-        }
-    }, [nativeCosmosToken?.decimals, rawBalance]);
-    return { balance, isLoading };
-};
-const useBitcoinNativeBalance = ({ chain, address, }) => {
-    const { nativeToken } = useNativeTokenForChain(chain);
-    const { data: rawBalance = "0", isLoading } = useQuery(keys().balance(chain?.chainId, nativeToken?.address, address), async () => {
-        if (!address || !nativeToken)
-            return "0";
-        const balance = await getBitcoinNativeBalance(address);
-        return formatBNToReadable(balance, nativeToken.decimals);
-    }, {
-        enabled: chain?.chainType === ChainType.BTC &&
-            nativeToken?.decimals != null &&
-            isWalletAddressValid(chain, address),
-        refetchInterval: 40000,
-        staleTime: 20000,
-        refetchOnWindowFocus: true,
-        refetchOnMount: true,
-    });
-    const balance = useMemo(() => {
-        if (nativeToken?.decimals && rawBalance) {
-            return {
-                decimals: nativeToken.decimals,
-                value: parseToBigInt(rawBalance, nativeToken.decimals),
-            };
-        }
-    }, [nativeToken?.decimals, rawBalance]);
-    return {
-        balance,
-        isLoading,
-    };
-};
-const useSolanaNativeBalance = ({ chain, address, }) => {
-    const { nativeToken } = useNativeTokenForChain(chain);
-    const { data: rawBalance, isLoading } = useQuery(keys().balance(chain?.chainId, nativeToken?.address, address), async () => {
-        const balance = await getSolanaNativeBalance(address);
-        return formatBNToReadable(balance, nativeToken.decimals);
-    }, {
-        enabled: !!address &&
-            nativeToken?.decimals != null &&
-            chain?.chainType === ChainType.SOLANA,
-        refetchInterval: 40000,
-        staleTime: 20000,
-        refetchOnWindowFocus: true,
-        refetchOnMount: true,
-    });
-    const balance = useMemo(() => {
-        if (nativeToken?.decimals && rawBalance) {
-            return {
-                decimals: nativeToken.decimals,
-                value: parseToBigInt(rawBalance, nativeToken.decimals),
-            };
-        }
-    }, [nativeToken?.decimals, rawBalance]);
-    return {
-        balance,
-        isLoading,
-    };
-};
-const useSuiNativeBalance = ({ address, chain, }) => {
-    const { nativeToken } = useNativeTokenForChain(chain);
-    const { balance: rawBalance, isLoading } = useSuiBalance({
-        chain,
-        token: nativeToken,
-        userAddress: address,
-    });
-    const balance = useMemo(() => {
-        if (nativeToken?.decimals && rawBalance) {
-            return {
-                decimals: nativeToken.decimals,
-                value: parseToBigInt(rawBalance, nativeToken.decimals),
-            };
-        }
-    }, [nativeToken?.decimals, rawBalance]);
-    return {
-        balance,
-        isLoading,
-    };
-};
-const useXrplNativeBalance = ({ address, chain, }) => {
-    const { nativeToken } = useNativeTokenForChain(chain);
-    const { balance: rawBalance, isLoading } = useXrplBalance({
-        chain,
-        token: nativeToken,
-        userAddress: address,
-        enabled: chain?.chainType === ChainType.XRPL,
-    });
-    const balance = useMemo(() => {
-        if (nativeToken?.decimals && rawBalance) {
-            return {
-                decimals: nativeToken.decimals,
-                value: parseToBigInt(rawBalance, nativeToken.decimals),
-            };
-        }
-    }, [nativeToken?.decimals, rawBalance]);
-    return {
-        balance,
-        isLoading,
-    };
-};
-const useStellarNativeBalance = ({ address, chain, }) => {
-    const { nativeToken } = useNativeTokenForChain(chain);
-    const { balance: rawBalance, isLoading } = useStellarBalance({
-        chain,
-        token: nativeToken,
-        userAddress: address,
-        enabled: chain?.chainType === ChainType.STELLAR,
-    });
-    const balance = useMemo(() => {
-        if (nativeToken?.decimals && rawBalance) {
-            return {
-                decimals: nativeToken.decimals,
-                value: parseToBigInt(rawBalance, nativeToken.decimals),
-            };
-        }
-    }, [nativeToken?.decimals, rawBalance]);
-    return {
-        balance,
-        isLoading,
-    };
-};
-const useNativeBalance = (chain) => {
-    const { connectedAddresses } = useWallet();
-    const { data: cosmosAddressForChain } = useCosmosForChain(chain);
-    // Cosmos is a special case because the address changes on every chain
-    // so we can't use the default cosmos connected address
-    const { balance: nativeCosmosBalance, isLoading: isCosmosLoading } = useCosmosNativeBalance({
-        address: cosmosAddressForChain,
-        chain,
-    });
-    const { balance: nativeEvmBalance, isLoading: isEvmLoading } = useEvmNativeBalance({ address: connectedAddresses[ChainType.EVM], chain });
-    const { balance: nativeBitcoinBalance, isLoading: isBitcoinLoading } = useBitcoinNativeBalance({
-        address: connectedAddresses[ChainType.BTC],
-        chain,
-    });
-    const { balance: nativeSolanaBalance, isLoading: isSolanaLoading } = useSolanaNativeBalance({
-        address: connectedAddresses[ChainType.SOLANA],
-        chain,
-    });
-    const { balance: nativeSuiBalance, isLoading: isSuiLoading } = useSuiNativeBalance({
-        address: connectedAddresses[ChainType.SUI],
-        chain,
-    });
-    const { balance: nativeXrplBalance, isLoading: isXrpLoading } = useXrplNativeBalance({
-        address: connectedAddresses[ChainType.XRPL],
-        chain,
-    });
-    const { balance: nativeStellarBalance, isLoading: isStellarLoading } = useStellarNativeBalance({
-        address: connectedAddresses[ChainType.STELLAR],
-        chain,
-    });
-    const { nativeBalance, nativeBalanceFormatted } = useMemo(() => {
-        let balance;
-        switch (chain?.chainType) {
-            case ChainType.EVM:
-                balance = nativeEvmBalance;
-                break;
-            case ChainType.COSMOS:
-                balance = nativeCosmosBalance;
-                break;
-            case ChainType.BTC:
-                balance = nativeBitcoinBalance;
-                break;
-            case ChainType.SOLANA:
-                balance = nativeSolanaBalance;
-                break;
-            case ChainType.SUI:
-                balance = nativeSuiBalance;
-                break;
-            case ChainType.XRPL:
-                balance = nativeXrplBalance;
-                break;
-            case ChainType.STELLAR:
-                balance = nativeStellarBalance;
-        }
-        const balanceFormatted = !!balance
-            ? formatBNToReadable(balance.value, balance.decimals)
-            : undefined;
-        return {
-            nativeBalance: balance,
-            nativeBalanceFormatted: balanceFormatted,
-        };
-    }, [
-        chain?.chainType,
-        nativeEvmBalance,
-        nativeCosmosBalance,
-        nativeBitcoinBalance,
-        nativeSolanaBalance,
-        nativeSuiBalance,
-        nativeXrplBalance,
-        nativeStellarBalance,
-    ]);
-    const isLoading = useMemo(() => {
-        if (!chain?.chainType)
-            return false;
-        switch (chain.chainType) {
-            case ChainType.EVM:
-                return isEvmLoading;
-            case ChainType.COSMOS:
-                return isCosmosLoading;
-            case ChainType.BTC:
-                return isBitcoinLoading;
-            case ChainType.SOLANA:
-                return isSolanaLoading;
-            case ChainType.SUI:
-                return isSuiLoading;
-            case ChainType.XRPL:
-                return isXrpLoading;
-            case ChainType.STELLAR:
-                return isStellarLoading;
-        }
-    }, [
-        chain?.chainType,
-        isEvmLoading,
-        isCosmosLoading,
-        isBitcoinLoading,
-        isSolanaLoading,
-        isSuiLoading,
-        isXrpLoading,
-        isStellarLoading,
-    ]);
-    return { nativeBalance, nativeBalanceFormatted, isLoading };
-};
-
-const DEFAULT_REFRESH_INTERVAL_MS = 15000;
-const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { isChainTypeConnected } = useWallet();
-    const isNativeToken = token?.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase();
-    const userAddressParsed = userAddress;
-    // Only fetch using useBalance if it's a native token
-    const { data: nativeBalance, isLoading: isNativeTokenLoading } = useBalance({
-        address: userAddressParsed,
-        chainId: Number(chain?.chainId),
-        query: {
-            enabled: enabled &&
-                !!userAddress &&
-                isNativeToken &&
-                !!chain &&
-                chain.chainType === ChainType.EVM &&
-                isChainTypeConnected(chain.chainType),
-            refetchInterval: refreshIntervalMs,
-            retry: 2,
-        },
-    });
-    // Only fetch using useReadContract if it's not a native token
-    // This is temporary, because of wagmi error: https://github.com/wevm/wagmi/issues/4353
-    const { data: erc20Balance, isLoading: isErc20Loading } = useReadContract({
-        address: token?.address,
-        abi: erc20Abi,
-        functionName: "balanceOf",
-        args: [userAddressParsed],
-        chainId: Number(chain?.chainId),
-        query: {
-            enabled: isChainTypeConnected(ChainType.EVM) &&
-                enabled &&
-                !!userAddress &&
-                !isNativeToken,
-            refetchInterval: refreshIntervalMs,
-            retry: 2,
-        },
-    });
-    if (isNativeToken) {
-        return {
-            isLoading: isNativeTokenLoading,
-            balance: nativeBalance
-                ? formatBNToReadable(nativeBalance.value, nativeBalance.decimals)
-                : "0",
-        };
-    }
-    return {
-        balance: erc20Balance && token
-            ? formatBNToReadable(erc20Balance, token.decimals)
-            : "0",
-        isLoading: isErc20Loading,
-    };
-};
-const useCosmosBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { isConnected } = useCosmosContext();
-    const { data: balance = "0", isLoading } = useQuery({
-        queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
-        queryFn: async () => {
-            if (!userAddress || !token || chain?.chainType !== ChainType.COSMOS) {
-                return "0";
-            }
-            const isAddressValid = isCosmosAddressValid(chain.bech32Config.bech32PrefixAccAddr, userAddress);
-            if (!isAddressValid)
-                return "0";
-            const balanceBn = await getCosmosTokenBalance(chain, userAddress, token.address);
-            return formatBNToReadable(balanceBn, token.decimals);
-        },
-        enabled: isConnected &&
-            enabled &&
-            !!userAddress &&
-            !!token &&
-            chain?.chainType === ChainType.COSMOS,
-        refetchInterval: refreshIntervalMs,
-        retry: 2,
-    });
-    return { balance, isLoading };
-};
-const useSolanaBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { data: balance = "0", isLoading } = useQuery({
-        queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
-        queryFn: async () => {
-            if (!userAddress || !token)
-                return "0";
-            const balanceBn = await getSolanaTokenBalance(userAddress, token.address);
-            return formatBNToReadable(balanceBn, token.decimals);
-        },
-        enabled: enabled &&
-            !!userAddress &&
-            !!token &&
-            chain?.chainType === ChainType.SOLANA,
-        refetchInterval: refreshIntervalMs,
-        retry: 2,
-    });
-    return { balance, isLoading };
-};
-// TODO: implement fetching balances for all bitcoin tokens
-const useBitcoinBalance = ({ userAddress, chain, }) => {
-    const { balance: balanceBn, isLoading } = useBitcoinNativeBalance({
-        address: userAddress,
-        chain,
-    });
-    const balance = useMemo(() => {
-        if (!balanceBn)
-            return "0";
-        return formatBNToReadable(balanceBn?.value, balanceBn?.decimals);
-    }, [balanceBn]);
-    return { balance, isLoading };
-};
-const useSuiBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { data: balance = "0", isLoading } = useQuery({
-        queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
-        queryFn: async () => {
-            if (!userAddress ||
-                token?.type !== ChainType.SUI ||
-                chain?.chainType !== ChainType.SUI) {
-                throw new Error("Invalid SUI balance query parameters");
-            }
-            const balanceBn = await getSuiTokenBalance(userAddress, token.address, chain.rpc);
-            return formatBNToReadable(balanceBn, token.decimals) ?? "0";
-        },
-        enabled: enabled &&
-            !!userAddress &&
-            !!chain?.rpc &&
-            token?.type === ChainType.SUI &&
-            chain?.chainType === ChainType.SUI &&
-            isSuiAddressValid(userAddress),
-        refetchInterval: refreshIntervalMs,
-        retry: 2,
-    });
-    return { balance, isLoading };
-};
-const useXrplBalance = ({ userAddress, chain, enabled, token, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { data: balance = "0", isLoading } = useQuery({
-        queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
-        queryFn: async () => {
-            if (!userAddress || !token || !chain)
-                return "0";
-            const balanceBn = await getXrplTokenBalance(userAddress, token, chain);
-            return formatBNToReadable(balanceBn, token.decimals) ?? "0";
-        },
-        enabled: enabled &&
-            !!userAddress &&
-            !!token &&
-            !!chain?.rpc &&
-            chain?.chainType === ChainType.XRPL &&
-            isXrplAddressValid(userAddress),
-        refetchInterval: refreshIntervalMs,
-        retry: 2,
-    });
-    return { balance, isLoading };
-};
-const useStellarBalance = ({ userAddress, chain, enabled, token, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { data: balance = "0", isLoading } = useQuery({
-        queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
-        queryFn: async () => {
-            if (!userAddress || !token || !chain)
-                return "0";
-            const balanceBn = await getStellarTokenBalance(userAddress, token, chain);
-            return formatBNToReadable(balanceBn, token.decimals) ?? "0";
-        },
-        enabled: enabled &&
-            !!userAddress &&
-            !!token &&
-            !!chain?.rpc &&
-            chain?.chainType === ChainType.STELLAR &&
-            isStellarAddressValid(userAddress),
-        refetchInterval: refreshIntervalMs,
-        retry: 2,
-    });
-    return { balance, isLoading };
-};
-
 /**
  * Hook to get balance depending on the chain type
  * @param {ChainData} chain
@@ -31022,6 +31095,10 @@ function useSendTransactionGas({ chain, token, from, }) {
                     const feeData = await client.getFeeData();
                     if (!feeData.maxFeePerGas)
                         return BigInt(0);
+                    let maxFeePerGas = feeData.maxFeePerGas;
+                    if (token.chainId === CHAIN_IDS.HEDERA) {
+                        maxFeePerGas = scaleWeiToHbar(BigInt(feeData.maxFeePerGas));
+                    }
                     const dummyAddress = "0x1111111111111111111111111111111111111111";
                     // Some RPC providers require the sender to have enough balance, otherwise estimation reverts
                     // so we'll try to use the user provided address when possible
@@ -31033,7 +31110,7 @@ function useSendTransactionGas({ chain, token, from, }) {
                             value: 1,
                             chainId: chain.chainId,
                         });
-                        return gas * feeData.maxFeePerGas;
+                        return gas * maxFeePerGas;
                     }
                     const erc20Interface = new Interface(erc20Abi);
                     const data = erc20Interface.encodeFunctionData("transfer", [
@@ -31046,7 +31123,7 @@ function useSendTransactionGas({ chain, token, from, }) {
                         data,
                         chainId: chain.chainId,
                     });
-                    return gas * feeData.maxFeePerGas;
+                    return gas * maxFeePerGas;
                 }
                 case ChainType.COSMOS: {
                     // TODO: get gas estimation from backend
@@ -31142,9 +31219,13 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
 async function sendTransactionEvm({ to, amount, token, signer, rpcUrl, }) {
     const isNativeToken = token.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase();
     if (isNativeToken) {
+        let value = amount;
+        if (token.chainId === CHAIN_IDS.HEDERA) {
+            value = scaleHbarToWei(BigInt(amount)).toString();
+        }
         const tx = await signer.sendTransaction({
             to,
-            value: amount,
+            value,
             chainId: Number(token.chainId),
         });
         return {
@@ -31972,7 +32053,12 @@ const useErc20Allowance = ({ tokenAddress, ownerAddress, spenderAddress, amount
     const parsedOwnerAddress = parseEvmAddress(ownerAddress);
     const parsedSpenderAddress = parseEvmAddress(spenderAddress);
     const isNativeToken = parsedTokenAddress?.toLowerCase() === nativeEvmTokenAddress.toLowerCase();
-    const isDepositAddressTx = transactionType === SquidDataType.DepositAddressCalldata;
+    const isDepositAddressTx = !!transactionType &&
+        [
+            SquidDataType.DepositAddressCalldata,
+            SquidDataType.DepositAddressWithSignature,
+            SquidDataType.DepositAddressWithMemo,
+        ].includes(transactionType);
     const result = useReadContract({
         abi: erc20Abi,
         address: parsedTokenAddress ?? undefined,
@@ -35258,7 +35344,7 @@ const useExecuteTransaction = (squidRoute) => {
      * Set the transaction state in the store
      * This is useful to access the latest transaction from any hook
      */
-    const setTransactionState = useCallback(({ route, txHash, transactionIdForStatus, nonce, status, sourceStatus, userAddress, axelarUrl, id, }) => {
+    const setTransactionState = useCallback(({ route, txHash, transactionIdForStatus, nonce, status, sourceStatus, userAddress, axelarUrl, id, depositTxVerificationSignature, }) => {
         if (!route?.transactionRequest)
             return undefined;
         const { quoteId } = route;
@@ -35277,10 +35363,11 @@ const useExecuteTransaction = (squidRoute) => {
             sourceTxExplorerUrl: getSourceExplorerTxUrl(fromChain, txHash),
             sourceExplorerImgUrl: fromChain?.chainIconURI,
             axelarUrl,
+            depositTxVerificationSignature,
         };
         setTransactionStoreState(id, tx);
         return tx;
-    }, [fromChain, setTransactionStoreState, toChain]);
+    }, [fromChain, toChain, setTransactionStoreState]);
     const getCosmosSignerClient = useCallback(async () => {
         if (!fromChain)
             return null;
@@ -35458,6 +35545,7 @@ const useExecuteTransaction = (squidRoute) => {
                 sourceStatus: TransactionStatus.ONGOING,
                 axelarUrl: undefined,
                 id,
+                depositTxVerificationSignature: txResponse.depositTxVerificationSignature,
             });
             if (txParams) {
                 addSwapTransaction({
@@ -35652,7 +35740,7 @@ const useExecuteTransaction = (squidRoute) => {
         if (!route?.transactionRequest || !xrplSigner) {
             throw new Error("Need all parameters");
         }
-        if (route.transactionRequest.type !== SquidDataType.OnChainExecution) {
+        if (!isOnChainTxData(route.transactionRequest)) {
             throw new Error("Invalid route type");
         }
         const { data } = route.transactionRequest;
@@ -35688,10 +35776,10 @@ const useExecuteTransaction = (squidRoute) => {
         }
     }, {});
     const swapMutationSui = useMutation(async ({ id, route }) => {
-        if (!route || !suiSigner || !fromChain) {
+        if (!route?.transactionRequest || !suiSigner || !fromChain) {
             throw new Error("Need all parameters");
         }
-        if (route.transactionRequest?.type !== SquidDataType.OnChainExecution) {
+        if (!isOnChainTxData(route.transactionRequest)) {
             throw new Error("Invalid route type");
         }
         const suiWalletState = connectedWalletsByChainType[ChainType.SUI];
@@ -35742,9 +35830,15 @@ const useExecuteTransaction = (squidRoute) => {
         });
     }, {});
     const swapMutationStellar = useMutation(async ({ id, route }) => {
-        if (!stellarSigner || !route || !squid || !fromChain) {
+        if (!stellarSigner ||
+            !route?.transactionRequest ||
+            !squid ||
+            !fromChain) {
             throw new Error("Need all parameters");
         }
+        if (!isOnChainTxData(route.transactionRequest)) {
+            throw new Error("Invalid route type");
+        }
         const fromChainId = route.params.fromChain;
         const stellarNetwork = getStellarNetwork(fromChainId);
         if (stellarNetwork == null) {
@@ -35847,11 +35941,13 @@ const useExecuteTransaction = (squidRoute) => {
         squidRoute,
     ]);
     const swapMutation = useMutation(async (mutationParams) => {
-        if (!mutationParams.route)
-            throw new Error("route is required");
+        if (!mutationParams.route?.transactionRequest) {
+            throw new Error("Route is required");
+        }
         const sourceChain = findChain(mutationParams.route.params?.fromChain);
         if (!sourceChain)
             throw new Error("Could not find source chain");
+        // After getting signature (if needed), continue with the swap flow
         switch (sourceChain.chainType) {
             case ChainType.COSMOS: {
                 return swapMutationCosmos.mutateAsync(mutationParams);
@@ -36040,7 +36136,7 @@ const useGetRoute = () => {
 };
 const useGetRouteWrapper = ({ enabled, cacheTime = 5 * 60 * 1000, // 5 minutes
 staleTime = 60 * 1000, // 1 minute
-refetchOnWindowFocus = (query) => Date.now() - query.state.dataUpdatedAt > 30000, // Update if older than 30 seconds, when window is focused
+refetchOnWindowFocus = (query) => Date.now() - query.state.dataUpdatedAt > DEFAULT_ROUTE_REFETCH_INTERVAL, // Update if older than default refetch interval, when window is focused
 refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true, }) => {
     const config = useConfigStore((state) => state.config);
     const squid = useSquidStore((state) => state.squid);
@@ -36792,5 +36888,5 @@ const SquidProvider = ({ children, config, placeholder, }) => {
                                     React.createElement(CosmosProvider, null, children)))))))))) : (placeholder);
 };
 
-export { useAllTokensWithBalanceForChainType as $, AxelarStatusResponseType as A, useSquidQueryClient as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, useSquid as E, useStellarAccountActivation as F, useAddressBookStore as G, HistoryTxType as H, useAssetsColorsStore as I, useFavoriteTokensStore as J, useHistoryStore as K, useSendTransactionStore as L, useConfigStore as M, Nr as N, useSquidStore as O, useSwapRoutePersistStore as P, QueryKeys as Q, useTransactionStore as R, SquidStatusErrorType as S, TransactionErrorType as T, ConnectingWalletStatus as U, useWalletStore as V, Wo as W, XamanXrplNetwork as X, useDepositAddress as Y, useSwap as Z, useAllConnectedWalletBalances as _, WindowWalletFlag as a, filterChains as a$, useCosmosBalance as a0, useEvmBalance as a1, useMultiChainBalance as a2, useMultipleTokenPrices as a3, useNativeBalance as a4, useNativeTokenForChain as a5, useSingleTokenPrice as a6, useSquidTokens as a7, useHistoricalData as a8, useTokensData as a9, useWallet as aA, useWallets as aB, useXrplTrustLine as aC, TX_STATUS_CONSTANTS as aD, FINAL_TRANSACTION_STATUSES as aE, useGetFiatQuote as aF, useGetOnRampConfig as aG, useExecuteFiatQuote as aH, useFiatOnRampTxStatus as aI, useFiatTransactions as aJ, useCurrencyDetails as aK, useCountryDetails as aL, useAvailableQuotes as aM, useRecommendedQuote as aN, useGetOnrampPaymentTypes as aO, useSuggestedFiatAmounts as aP, SquidProvider as aQ, EnsService as aR, getXummClient as aS, isXamanXAppContext as aT, getQueryHeaders as aU, getStatusCode as aV, is404Error as aW, assetsBaseUrl as aX, shareSubgraphId as aY, sortTokensBySharedSubgraphIds as aZ, getSupportedChainIdsForDirection as a_, useEstimateSendTransaction as aa, useSendTransaction as ab, useSendTransactionGas as ac, useAllTransactionsStatus as ad, useApproval as ae, useEstimate as af, useEstimatePriceImpact as ag, useExecuteTransaction as ah, useGetRoute as ai, useGetRouteWrapper as aj, useRouteWarnings as ak, useSendTransactionStatus as al, useSwapTransactionStatus as am, useAvatar as an, useHistory as ao, useUserParams as ap, useDebouncedValue as aq, useAddToken as ar, useAutoConnect as as, useEnsDataForAddress as at, useEnsSearch as au, useGnosisContext as av, useIsSameAddressAndGnosisContext as aw, useIntegratorContext as ax, useMultiChainWallet as ay, useSigner as az, chainTypeToZeroAddressMap as b, formatUsdAmount as b$, filterTokens as b0, getTokenImage as b1, getNewSwapParamsFromInput as b2, sortAllTokens as b3, findToken as b4, findNativeToken as b5, normalizeIbcAddress as b6, groupTokensBySymbol as b7, groupTokensByChainId as b8, filterViewableTokens as b9, normalizeError as bA, transactionErrorCode as bB, isUserRejectionError as bC, getTransactionError as bD, handleTransactionErrorEvents as bE, isSwapRouteError as bF, isStatusError as bG, createQuoteRequestParamsHash as bH, WidgetEvents as bI, EvmNetworkNotSupportedErrorCode as bJ, addEthereumChain as bK, parseEvmAddress as bL, formatEvmWallet as bM, filterWagmiConnector as bN, waitForReceiptWithRetry as bO, getUserCountry as bP, getCountryData as bQ, getCurrencyData as bR, adaptiveRound as bS, getSuggestedAmountsForCurrency as bT, HederaExtensionHelper as bU, convertHederaAccountIdToEvmAddress as bV, convertEvmAddressToHederaAccountId as bW, parseToBigInt as bX, roundNumericValue as bY, formatUnitsRounded as bZ, formatTokenAmount as b_, getSecretNetworkBalances as ba, getTokenAssetsKey as bb, fetchAssetsColors as bc, initializeSquidWithAssetsColors as bd, isEmptyObject as be, normalizeTokenSymbol as bf, areTokenSymbolsCompatible as bg, isEvmosChain as bh, getConfigWithDefaults as bi, randomIntFromInterval as bj, getTokensForChain as bk, getFirstAvailableChainId as bl, fetchHighestBalanceToken as bm, getInitialOrDefaultTokenAddressForChain as bn, getInitialTokenAddressForChain as bo, filterTokensForDestination as bp, getInitialChainIdFromConfig as bq, getCosmosKey as br, getKeysSettled as bs, getAllKeysForSupportedCosmosChains as bt, isCosmosAddressValid as bu, getCosmosSigningClient as bv, getCosmosChainInfosObject as bw, connectCosmosWallet as bx, isFallbackAddressNeeded as by, suggestChainOrThrow as bz, chainTypeToNativeTokenAddressMap as c, trimExtraDecimals as c0, getNumericValue as c1, cleanAmount as c2, convertTokenAmountToUSD as c3, convertUSDToTokenAmount as c4, calculateTotal24hChange as c5, searchTokens as c6, filterSolanaWallets as c7, isSolanaAddressValid as c8, executeSolanaSwap as c9, isHistoryTransactionFailed as cA, isHistoryTransactionWarning as cB, isHistoryTransactionEnded as cC, formatHash as cD, isWalletAddressValid as cE, redirectToExtensionsStore as cF, accessProperty as cG, populateWallets as cH, getDefaultChain as cI, sortWallets as cJ, areSameAddress as cK, sortAddressBook as cL, calculateTotalUsdBalanceUSD as cM, addTokenToWallet as cN, isEvmChainNotSupportedError as cO, getWalletSupportedChainTypes as cP, getConnectorForChainType as cQ, walletSupportsChainType as cR, connectWallet as cS, cancelConnectWallet as cT, isProblematicConnector as cU, mergeWallets as cV, isXionSmartContractAddress as cW, isXrplAddressValid as cX, buildXrplTrustSetTx as cY, getXrplNetwork as cZ, parseXrplPaymentTx as c_, executeSolanaTransfer as ca, formatTransactionHistoryDate as cb, getAxelarExplorerTxUrl as cc, getSourceExplorerTxUrl as cd, getMainExplorerUrl as ce, formatDistance as cf, formatSeconds as cg, formatSwapTxStatusResponseForStorage as ch, simplifyRouteAction as ci, fetchSwapTransactionStatus as cj, compareTransactionIds as ck, isCoralBridgeAction as cl, sleep as cm, isDepositRoute as cn, isChainflipBridgeTransaction as co, getHistoryTransactionId as cp, getStepStatuses as cq, getHalfSuccessState as cr, getStepsInfos as cs, getSwapTxStatusRefetchInterval as ct, getSendTxStatusRefetchInterval as cu, chainflipMultihopBridgeType as cv, getBridgeType as cw, getTransactionStatus as cx, getTransactionEndStatus as cy, isHistoryTransactionPending as cz, definedInWindow as d, er as e, formatBNToReadable as f, destinationAddressResetValue as g, fallbackAddressResetValue as h, nativeCosmosTokenAddress as i, nativeEvmTokenAddress as j, nativeSolanaTokenAddress as k, nativeStellarTokenAddress as l, nativeSuiTokenAddress as m, nativeBitcoinTokenAddress as n, nativeXrplTokenAddress as o, CosmosProvider as p, SendTransactionStatus as q, TransactionStatus as r, useTrackSearchEmpty as s, useSquidChains as t, useCosmosContext as u, useClient as v, walletIconBaseUrl as w, useCosmosForChain as x, useHederaTokenAssociations as y, useKeyboardNavigation as z };
-//# sourceMappingURL=index-CMrdTYeW.js.map
+export { useSwap as $, AxelarStatusResponseType as A, useKeyboardNavigation as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, useSquidQueryClient as E, useSquid as F, useStellarAccountActivation as G, HistoryTxType as H, useHederaAccountActivation as I, useAddressBookStore as J, useAssetsColorsStore as K, useFavoriteTokensStore as L, useHistoryStore as M, Nr as N, useSendTransactionStore as O, useConfigStore as P, QueryKeys as Q, useSquidStore as R, SquidStatusErrorType as S, TransactionErrorType as T, useSwapRoutePersistStore as U, useTransactionStore as V, Wo as W, XamanXrplNetwork as X, ConnectingWalletStatus as Y, useWalletStore as Z, useDepositAddress as _, WindowWalletFlag as a, getXummClient as a$, useAllConnectedWalletBalances as a0, useAllTokensWithBalanceForChainType as a1, useCosmosBalance as a2, useEvmBalance as a3, useMultiChainBalance as a4, useMultipleTokenPrices as a5, useBitcoinNativeBalance as a6, useCosmosNativeBalance as a7, useEvmNativeBalance as a8, useNativeBalance as a9, useAddToken as aA, useAutoConnect as aB, useEnsDataForAddress as aC, useEnsSearch as aD, useGnosisContext as aE, useIsSameAddressAndGnosisContext as aF, useIntegratorContext as aG, useMultiChainWallet as aH, useSigner as aI, useWallet as aJ, useWallets as aK, useXrplTrustLine as aL, TX_STATUS_CONSTANTS as aM, FINAL_TRANSACTION_STATUSES as aN, useGetFiatQuote as aO, useGetOnRampConfig as aP, useExecuteFiatQuote as aQ, useFiatOnRampTxStatus as aR, useFiatTransactions as aS, useCurrencyDetails as aT, useCountryDetails as aU, useAvailableQuotes as aV, useRecommendedQuote as aW, useGetOnrampPaymentTypes as aX, useSuggestedFiatAmounts as aY, SquidProvider as aZ, EnsService as a_, useSolanaNativeBalance as aa, useStellarNativeBalance as ab, useSuiNativeBalance as ac, useXrplNativeBalance as ad, useNativeTokenForChain as ae, useSingleTokenPrice as af, useSquidTokens as ag, useHistoricalData as ah, useTokensData as ai, useEstimateSendTransaction as aj, useSendTransaction as ak, useSendTransactionGas as al, useAllTransactionsStatus as am, useApproval as an, useEstimate as ao, useEstimatePriceImpact as ap, useExecuteTransaction as aq, useGetRoute as ar, useGetRouteWrapper as as, useRouteWarnings as at, useSendTransactionStatus as au, useSwapTransactionStatus as av, useAvatar as aw, useHistory as ax, useUserParams as ay, useDebouncedValue as az, chainTypeToZeroAddressMap as b, adaptiveRound as b$, isXamanXAppContext as b0, getQueryHeaders as b1, getStatusCode as b2, is404Error as b3, assetsBaseUrl as b4, shareSubgraphId as b5, sortTokensBySharedSubgraphIds as b6, getSupportedChainIdsForDirection as b7, filterChains as b8, filterTokens as b9, getCosmosKey as bA, getKeysSettled as bB, getAllKeysForSupportedCosmosChains as bC, isCosmosAddressValid as bD, getCosmosSigningClient as bE, getCosmosChainInfosObject as bF, connectCosmosWallet as bG, isFallbackAddressNeeded as bH, suggestChainOrThrow as bI, normalizeError as bJ, transactionErrorCode as bK, isUserRejectionError as bL, getTransactionError as bM, handleTransactionErrorEvents as bN, isSwapRouteError as bO, isStatusError as bP, createQuoteRequestParamsHash as bQ, WidgetEvents as bR, EvmNetworkNotSupportedErrorCode as bS, addEthereumChain as bT, parseEvmAddress as bU, formatEvmWallet as bV, filterWagmiConnector as bW, waitForReceiptWithRetry as bX, getUserCountry as bY, getCountryData as bZ, getCurrencyData as b_, getTokenImage as ba, getNewSwapParamsFromInput as bb, sortAllTokens as bc, findToken as bd, findNativeToken as be, normalizeIbcAddress as bf, groupTokensBySymbol as bg, groupTokensByChainId as bh, filterViewableTokens as bi, getSecretNetworkBalances as bj, getTokenAssetsKey as bk, fetchAssetsColors as bl, initializeSquidWithAssetsColors as bm, isEmptyObject as bn, normalizeTokenSymbol as bo, areTokenSymbolsCompatible as bp, isEvmosChain as bq, getConfigWithDefaults as br, randomIntFromInterval as bs, getTokensForChain as bt, getFirstAvailableChainId as bu, fetchHighestBalanceToken as bv, getInitialOrDefaultTokenAddressForChain as bw, getInitialTokenAddressForChain as bx, filterTokensForDestination as by, getInitialChainIdFromConfig as bz, chainTypeToNativeTokenAddressMap as c, addTokenToWallet as c$, getSuggestedAmountsForCurrency as c0, HederaExtensionHelper as c1, convertHederaAccountIdToEvmAddress as c2, convertEvmAddressToHederaAccountId as c3, scaleHbarToWei as c4, scaleWeiToHbar as c5, parseToBigInt as c6, roundNumericValue as c7, formatUnitsRounded as c8, formatTokenAmount as c9, isChainflipBridgeTransaction as cA, isOnChainTxData as cB, isDepositWithSignatureTxData as cC, getHistoryTransactionId as cD, getStepStatuses as cE, getHalfSuccessState as cF, getStepsInfos as cG, getSwapTxStatusRefetchInterval as cH, getSendTxStatusRefetchInterval as cI, chainflipMultihopBridgeType as cJ, getBridgeType as cK, getTransactionStatus as cL, getTransactionEndStatus as cM, isHistoryTransactionPending as cN, isHistoryTransactionFailed as cO, isHistoryTransactionWarning as cP, isHistoryTransactionEnded as cQ, formatHash as cR, isWalletAddressValid as cS, redirectToExtensionsStore as cT, accessProperty as cU, populateWallets as cV, getDefaultChain as cW, sortWallets as cX, areSameAddress as cY, sortAddressBook as cZ, calculateTotalUsdBalanceUSD as c_, formatUsdAmount as ca, trimExtraDecimals as cb, getNumericValue as cc, cleanAmount as cd, convertTokenAmountToUSD as ce, convertUSDToTokenAmount as cf, calculateTotal24hChange as cg, getRouteExpiry as ch, searchTokens as ci, filterSolanaWallets as cj, isSolanaAddressValid as ck, executeSolanaSwap as cl, executeSolanaTransfer as cm, formatTransactionHistoryDate as cn, getAxelarExplorerTxUrl as co, getSourceExplorerTxUrl as cp, getMainExplorerUrl as cq, formatDistance as cr, formatSeconds as cs, formatSwapTxStatusResponseForStorage as ct, simplifyRouteAction as cu, fetchSwapTransactionStatus as cv, compareTransactionIds as cw, isCoralBridgeAction as cx, sleep as cy, isDepositRoute as cz, definedInWindow as d, isEvmChainNotSupportedError as d0, getWalletSupportedChainTypes as d1, getConnectorForChainType as d2, walletSupportsChainType as d3, connectWallet as d4, cancelConnectWallet as d5, isProblematicConnector as d6, mergeWallets as d7, isXionSmartContractAddress as d8, isXrplAddressValid as d9, buildXrplTrustSetTx as da, getXrplNetwork as db, parseXrplPaymentTx as dc, er as e, formatBNToReadable as f, DEFAULT_ROUTE_REFETCH_INTERVAL as g, destinationAddressResetValue as h, fallbackAddressResetValue as i, nativeCosmosTokenAddress as j, nativeEvmTokenAddress as k, nativeSolanaTokenAddress as l, nativeStellarTokenAddress as m, nativeBitcoinTokenAddress as n, nativeSuiTokenAddress as o, nativeXrplTokenAddress as p, CosmosProvider as q, SendTransactionStatus as r, TransactionStatus as s, useTrackSearchEmpty as t, useCosmosContext as u, useSquidChains as v, walletIconBaseUrl as w, useClient as x, useCosmosForChain as y, useHederaTokenAssociations as z };
+//# sourceMappingURL=index-BxJVsDEs.js.map