@0xsquid/react-hooks 8.3.1 → 8.4.0

package/dist/{index-qAOvcSon.js → index-BdrSk8Ed.js}

@@ -102,6 +102,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";
@@ -20855,6 +20856,309 @@ const isBitcoinAddressValid = (address) => {
     }
 };
 
+exports.HistoryTxType = void 0;
+(function (HistoryTxType) {
+    HistoryTxType[HistoryTxType["SWAP"] = 0] = "SWAP";
+    HistoryTxType[HistoryTxType["BUY"] = 1] = "BUY";
+    HistoryTxType[HistoryTxType["SEND"] = 2] = "SEND";
+})(exports.HistoryTxType || (exports.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 = {}));
+exports.AxelarStatusResponseType = void 0;
+(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";
+})(exports.AxelarStatusResponseType || (exports.AxelarStatusResponseType = {}));
+exports.TransactionStatus = void 0;
+(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";
+})(exports.TransactionStatus || (exports.TransactionStatus = {}));
+exports.SendTransactionStatus = void 0;
+(function (SendTransactionStatus) {
+    SendTransactionStatus[SendTransactionStatus["ONGOING"] = 0] = "ONGOING";
+    SendTransactionStatus[SendTransactionStatus["SUCCESS"] = 1] = "SUCCESS";
+    SendTransactionStatus[SendTransactionStatus["ERROR"] = 2] = "ERROR";
+})(exports.SendTransactionStatus || (exports.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 === squidTypes.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 === squidTypes.SquidDataType.ChainflipDepositAddress);
+};
+/**
+ * Checks if the route contains a Chainflip bridge action
+ */
+function isChainflipBridgeTransaction(actions = []) {
+    return actions.some((action) => action.type === squidTypes.ActionType.BRIDGE &&
+        action.data?.type === squidTypes.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 [
+        squidTypes.SquidDataType.OnChainExecution,
+        squidTypes.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 === squidTypes.SquidDataType.DepositAddressWithSignature;
+}
+function getHistoryTransactionId(tx) {
+    switch (tx.txType) {
+        case exports.HistoryTxType.SWAP:
+            return tx.data.transactionId;
+        case exports.HistoryTxType.BUY:
+            return tx.data.orderId;
+        case exports.HistoryTxType.SEND:
+            return tx.data.hash;
+    }
+}
+
 const STANDARD_FEATURES = [
     "standard:connect",
     "standard:events",
@@ -21031,7 +21335,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;
@@ -21906,285 +22210,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;
-};
-
-exports.HistoryTxType = void 0;
-(function (HistoryTxType) {
-    HistoryTxType[HistoryTxType["SWAP"] = 0] = "SWAP";
-    HistoryTxType[HistoryTxType["BUY"] = 1] = "BUY";
-    HistoryTxType[HistoryTxType["SEND"] = 2] = "SEND";
-})(exports.HistoryTxType || (exports.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 = {}));
-exports.AxelarStatusResponseType = void 0;
-(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";
-})(exports.AxelarStatusResponseType || (exports.AxelarStatusResponseType = {}));
-exports.TransactionStatus = void 0;
-(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";
-})(exports.TransactionStatus || (exports.TransactionStatus = {}));
-exports.SendTransactionStatus = void 0;
-(function (SendTransactionStatus) {
-    SendTransactionStatus[SendTransactionStatus["ONGOING"] = 0] = "ONGOING";
-    SendTransactionStatus[SendTransactionStatus["SUCCESS"] = 1] = "SUCCESS";
-    SendTransactionStatus[SendTransactionStatus["ERROR"] = 2] = "ERROR";
-})(exports.SendTransactionStatus || (exports.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 === squidTypes.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 === squidTypes.SquidDataType.ChainflipDepositAddress);
-};
-/**
- * Checks if the route contains a Chainflip bridge action
- */
-function isChainflipBridgeTransaction(actions = []) {
-    return actions.some((action) => action.type === squidTypes.ActionType.BRIDGE &&
-        action.data?.type === squidTypes.BridgeType.CHAINFLIP);
-}
-function getHistoryTransactionId(tx) {
-    switch (tx.txType) {
-        case exports.HistoryTxType.SWAP:
-            return tx.data.transactionId;
-        case exports.HistoryTxType.BUY:
-            return tx.data.orderId;
-        case exports.HistoryTxType.SEND:
-            return tx.data.hash;
-    }
-}
-
 exports.QueryKeys = void 0;
 (function (QueryKeys) {
     QueryKeys["All"] = "all";
@@ -23153,7 +23178,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 Promise.resolve().then(function () { return require('./secretService-B_-XWo1F.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-DRTd4cda.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -24625,6 +24650,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
@@ -26438,7 +26494,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 Promise.resolve().then(function () { return require('./stellarService.client-sRzC5VSD.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-CRFUb2R6.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -27938,7 +27994,7 @@ function hederaWalletConnect(parameters) {
                 const optionalChains = config.chains.map((x) => x.id);
                 if (!optionalChains.length)
                     return;
-                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-Cu_QQTg-.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-DhiQj1ju.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -29699,6 +29755,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 } = wagmi.useBalance({
+        address: userAddressParsed,
+        chainId: Number(chain?.chainId),
+        query: {
+            enabled: enabled &&
+                !!userAddress &&
+                isNativeToken &&
+                !!chain &&
+                chain.chainType === squidTypes.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 } = wagmi.useReadContract({
+        address: token?.address,
+        abi: viem.erc20Abi,
+        functionName: "balanceOf",
+        args: [userAddressParsed],
+        chainId: Number(chain?.chainId),
+        query: {
+            enabled: isChainTypeConnected(squidTypes.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 } = reactQuery.useQuery({
+        queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
+        queryFn: async () => {
+            if (!userAddress || !token || chain?.chainType !== squidTypes.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 === squidTypes.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 } = reactQuery.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 === squidTypes.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 = React.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 } = reactQuery.useQuery({
+        queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
+        queryFn: async () => {
+            if (!userAddress ||
+                token?.type !== squidTypes.ChainType.SUI ||
+                chain?.chainType !== squidTypes.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 === squidTypes.ChainType.SUI &&
+            chain?.chainType === squidTypes.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 } = reactQuery.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 === squidTypes.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 } = reactQuery.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 === squidTypes.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 squidTypes.ChainType.EVM:
+                return evmTokens;
+            case squidTypes.ChainType.COSMOS:
+                return cosmosTokens;
+            case squidTypes.ChainType.SOLANA:
+                return solanaTokens;
+            case squidTypes.ChainType.BTC:
+                return bitcoinTokens;
+            case squidTypes.ChainType.SUI:
+                return suiTokens;
+            case squidTypes.ChainType.XRPL:
+                return xrplTokens;
+            case squidTypes.ChainType.STELLAR:
+                return stellarTokens;
+        }
+    };
+    const nativeTokenForChainType = React.useMemo(() => {
+        return findNativeToken(getTokensForChainType(), chain);
+    }, [chain]);
+    return { nativeToken: nativeTokenForChainType };
+}
+
+const useEvmNativeBalance = ({ address, chain, }) => {
+    const { isChainTypeConnected } = useWallet();
+    const { data: nativeEvmBalance, isLoading } = wagmi.useBalance({
+        address: address,
+        chainId: Number(chain?.chainId),
+        query: {
+            enabled: isChainTypeConnected(squidTypes.ChainType.EVM) && !!address,
+            refetchInterval: 10000,
+            staleTime: 5000,
+            refetchOnWindowFocus: true,
+            refetchOnMount: true,
+        },
+    });
+    const balance = React.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 === squidTypes.ChainType.COSMOS,
+        refreshIntervalMs: 10000,
+    });
+    const balance = React.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 } = reactQuery.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 === squidTypes.ChainType.BTC &&
+            nativeToken?.decimals != null &&
+            isWalletAddressValid(chain, address),
+        refetchInterval: 40000,
+        staleTime: 20000,
+        refetchOnWindowFocus: true,
+        refetchOnMount: true,
+    });
+    const balance = React.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 } = reactQuery.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 === squidTypes.ChainType.SOLANA,
+        refetchInterval: 40000,
+        staleTime: 20000,
+        refetchOnWindowFocus: true,
+        refetchOnMount: true,
+    });
+    const balance = React.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 = React.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 === squidTypes.ChainType.XRPL,
+    });
+    const balance = React.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 === squidTypes.ChainType.STELLAR,
+    });
+    const balance = React.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[squidTypes.ChainType.EVM], chain });
+    const { balance: nativeBitcoinBalance, isLoading: isBitcoinLoading } = useBitcoinNativeBalance({
+        address: connectedAddresses[squidTypes.ChainType.BTC],
+        chain,
+    });
+    const { balance: nativeSolanaBalance, isLoading: isSolanaLoading } = useSolanaNativeBalance({
+        address: connectedAddresses[squidTypes.ChainType.SOLANA],
+        chain,
+    });
+    const { balance: nativeSuiBalance, isLoading: isSuiLoading } = useSuiNativeBalance({
+        address: connectedAddresses[squidTypes.ChainType.SUI],
+        chain,
+    });
+    const { balance: nativeXrplBalance, isLoading: isXrpLoading } = useXrplNativeBalance({
+        address: connectedAddresses[squidTypes.ChainType.XRPL],
+        chain,
+    });
+    const { balance: nativeStellarBalance, isLoading: isStellarLoading } = useStellarNativeBalance({
+        address: connectedAddresses[squidTypes.ChainType.STELLAR],
+        chain,
+    });
+    const { nativeBalance, nativeBalanceFormatted } = React.useMemo(() => {
+        let balance;
+        switch (chain?.chainType) {
+            case squidTypes.ChainType.EVM:
+                balance = nativeEvmBalance;
+                break;
+            case squidTypes.ChainType.COSMOS:
+                balance = nativeCosmosBalance;
+                break;
+            case squidTypes.ChainType.BTC:
+                balance = nativeBitcoinBalance;
+                break;
+            case squidTypes.ChainType.SOLANA:
+                balance = nativeSolanaBalance;
+                break;
+            case squidTypes.ChainType.SUI:
+                balance = nativeSuiBalance;
+                break;
+            case squidTypes.ChainType.XRPL:
+                balance = nativeXrplBalance;
+                break;
+            case squidTypes.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 = React.useMemo(() => {
+        if (!chain?.chainType)
+            return false;
+        switch (chain.chainType) {
+            case squidTypes.ChainType.EVM:
+                return isEvmLoading;
+            case squidTypes.ChainType.COSMOS:
+                return isCosmosLoading;
+            case squidTypes.ChainType.BTC:
+                return isBitcoinLoading;
+            case squidTypes.ChainType.SOLANA:
+                return isSolanaLoading;
+            case squidTypes.ChainType.SUI:
+                return isSuiLoading;
+            case squidTypes.ChainType.XRPL:
+                return isXrpLoading;
+            case squidTypes.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 = React.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 = zustand.create(middleware.persist((set) => ({
     addressBook: [],
     add: (newAddressData) => {
@@ -30064,473 +30604,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 squidTypes.ChainType.EVM:
-                return evmTokens;
-            case squidTypes.ChainType.COSMOS:
-                return cosmosTokens;
-            case squidTypes.ChainType.SOLANA:
-                return solanaTokens;
-            case squidTypes.ChainType.BTC:
-                return bitcoinTokens;
-            case squidTypes.ChainType.SUI:
-                return suiTokens;
-            case squidTypes.ChainType.XRPL:
-                return xrplTokens;
-            case squidTypes.ChainType.STELLAR:
-                return stellarTokens;
-        }
-    };
-    const nativeTokenForChainType = React.useMemo(() => {
-        return findNativeToken(getTokensForChainType(), chain);
-    }, [chain]);
-    return { nativeToken: nativeTokenForChainType };
-}
-
-const useEvmNativeBalance = ({ address, chain, }) => {
-    const { isChainTypeConnected } = useWallet();
-    const { data: nativeEvmBalance, isLoading } = wagmi.useBalance({
-        address: address,
-        chainId: Number(chain?.chainId),
-        query: {
-            enabled: isChainTypeConnected(squidTypes.ChainType.EVM) && !!address,
-            refetchInterval: 10000,
-            staleTime: 5000,
-            refetchOnWindowFocus: true,
-            refetchOnMount: true,
-        },
-    });
-    const balance = React.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 === squidTypes.ChainType.COSMOS,
-        refreshIntervalMs: 10000,
-    });
-    const balance = React.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 } = reactQuery.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 === squidTypes.ChainType.BTC &&
-            nativeToken?.decimals != null &&
-            isWalletAddressValid(chain, address),
-        refetchInterval: 40000,
-        staleTime: 20000,
-        refetchOnWindowFocus: true,
-        refetchOnMount: true,
-    });
-    const balance = React.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 } = reactQuery.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 === squidTypes.ChainType.SOLANA,
-        refetchInterval: 40000,
-        staleTime: 20000,
-        refetchOnWindowFocus: true,
-        refetchOnMount: true,
-    });
-    const balance = React.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 = React.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 === squidTypes.ChainType.XRPL,
-    });
-    const balance = React.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 === squidTypes.ChainType.STELLAR,
-    });
-    const balance = React.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[squidTypes.ChainType.EVM], chain });
-    const { balance: nativeBitcoinBalance, isLoading: isBitcoinLoading } = useBitcoinNativeBalance({
-        address: connectedAddresses[squidTypes.ChainType.BTC],
-        chain,
-    });
-    const { balance: nativeSolanaBalance, isLoading: isSolanaLoading } = useSolanaNativeBalance({
-        address: connectedAddresses[squidTypes.ChainType.SOLANA],
-        chain,
-    });
-    const { balance: nativeSuiBalance, isLoading: isSuiLoading } = useSuiNativeBalance({
-        address: connectedAddresses[squidTypes.ChainType.SUI],
-        chain,
-    });
-    const { balance: nativeXrplBalance, isLoading: isXrpLoading } = useXrplNativeBalance({
-        address: connectedAddresses[squidTypes.ChainType.XRPL],
-        chain,
-    });
-    const { balance: nativeStellarBalance, isLoading: isStellarLoading } = useStellarNativeBalance({
-        address: connectedAddresses[squidTypes.ChainType.STELLAR],
-        chain,
-    });
-    const { nativeBalance, nativeBalanceFormatted } = React.useMemo(() => {
-        let balance;
-        switch (chain?.chainType) {
-            case squidTypes.ChainType.EVM:
-                balance = nativeEvmBalance;
-                break;
-            case squidTypes.ChainType.COSMOS:
-                balance = nativeCosmosBalance;
-                break;
-            case squidTypes.ChainType.BTC:
-                balance = nativeBitcoinBalance;
-                break;
-            case squidTypes.ChainType.SOLANA:
-                balance = nativeSolanaBalance;
-                break;
-            case squidTypes.ChainType.SUI:
-                balance = nativeSuiBalance;
-                break;
-            case squidTypes.ChainType.XRPL:
-                balance = nativeXrplBalance;
-                break;
-            case squidTypes.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 = React.useMemo(() => {
-        if (!chain?.chainType)
-            return false;
-        switch (chain.chainType) {
-            case squidTypes.ChainType.EVM:
-                return isEvmLoading;
-            case squidTypes.ChainType.COSMOS:
-                return isCosmosLoading;
-            case squidTypes.ChainType.BTC:
-                return isBitcoinLoading;
-            case squidTypes.ChainType.SOLANA:
-                return isSolanaLoading;
-            case squidTypes.ChainType.SUI:
-                return isSuiLoading;
-            case squidTypes.ChainType.XRPL:
-                return isXrpLoading;
-            case squidTypes.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 } = wagmi.useBalance({
-        address: userAddressParsed,
-        chainId: Number(chain?.chainId),
-        query: {
-            enabled: enabled &&
-                !!userAddress &&
-                isNativeToken &&
-                !!chain &&
-                chain.chainType === squidTypes.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 } = wagmi.useReadContract({
-        address: token?.address,
-        abi: viem.erc20Abi,
-        functionName: "balanceOf",
-        args: [userAddressParsed],
-        chainId: Number(chain?.chainId),
-        query: {
-            enabled: isChainTypeConnected(squidTypes.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 } = reactQuery.useQuery({
-        queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
-        queryFn: async () => {
-            if (!userAddress || !token || chain?.chainType !== squidTypes.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 === squidTypes.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 } = reactQuery.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 === squidTypes.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 = React.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 } = reactQuery.useQuery({
-        queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
-        queryFn: async () => {
-            if (!userAddress ||
-                token?.type !== squidTypes.ChainType.SUI ||
-                chain?.chainType !== squidTypes.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 === squidTypes.ChainType.SUI &&
-            chain?.chainType === squidTypes.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 } = reactQuery.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 === squidTypes.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 } = reactQuery.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 === squidTypes.ChainType.STELLAR &&
-            isStellarAddressValid(userAddress),
-        refetchInterval: refreshIntervalMs,
-        retry: 2,
-    });
-    return { balance, isLoading };
-};
-
 /**
  * Hook to get balance depending on the chain type
  * @param {ChainData} chain
@@ -31043,6 +31116,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
@@ -31054,7 +31131,7 @@ function useSendTransactionGas({ chain, token, from, }) {
                             value: 1,
                             chainId: chain.chainId,
                         });
-                        return gas * feeData.maxFeePerGas;
+                        return gas * maxFeePerGas;
                     }
                     const erc20Interface = new ethers.Interface(viem.erc20Abi);
                     const data = erc20Interface.encodeFunctionData("transfer", [
@@ -31067,7 +31144,7 @@ function useSendTransactionGas({ chain, token, from, }) {
                         data,
                         chainId: chain.chainId,
                     });
-                    return gas * feeData.maxFeePerGas;
+                    return gas * maxFeePerGas;
                 }
                 case squidTypes.ChainType.COSMOS: {
                     // TODO: get gas estimation from backend
@@ -31163,9 +31240,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 {
@@ -31993,7 +32074,12 @@ const useErc20Allowance = ({ tokenAddress, ownerAddress, spenderAddress, amount
     const parsedOwnerAddress = parseEvmAddress(ownerAddress);
     const parsedSpenderAddress = parseEvmAddress(spenderAddress);
     const isNativeToken = parsedTokenAddress?.toLowerCase() === nativeEvmTokenAddress.toLowerCase();
-    const isDepositAddressTx = transactionType === squidTypes.SquidDataType.DepositAddressCalldata;
+    const isDepositAddressTx = !!transactionType &&
+        [
+            squidTypes.SquidDataType.DepositAddressCalldata,
+            squidTypes.SquidDataType.DepositAddressWithSignature,
+            squidTypes.SquidDataType.DepositAddressWithMemo,
+        ].includes(transactionType);
     const result = wagmi.useReadContract({
         abi: viem.erc20Abi,
         address: parsedTokenAddress ?? undefined,
@@ -35279,7 +35365,7 @@ const useExecuteTransaction = (squidRoute) => {
      * Set the transaction state in the store
      * This is useful to access the latest transaction from any hook
      */
-    const setTransactionState = React.useCallback(({ route, txHash, transactionIdForStatus, nonce, status, sourceStatus, userAddress, axelarUrl, id, }) => {
+    const setTransactionState = React.useCallback(({ route, txHash, transactionIdForStatus, nonce, status, sourceStatus, userAddress, axelarUrl, id, depositTxVerificationSignature, }) => {
         if (!route?.transactionRequest)
             return undefined;
         const { quoteId } = route;
@@ -35298,10 +35384,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 = React.useCallback(async () => {
         if (!fromChain)
             return null;
@@ -35479,6 +35566,7 @@ const useExecuteTransaction = (squidRoute) => {
                 sourceStatus: exports.TransactionStatus.ONGOING,
                 axelarUrl: undefined,
                 id,
+                depositTxVerificationSignature: txResponse.depositTxVerificationSignature,
             });
             if (txParams) {
                 addSwapTransaction({
@@ -35673,7 +35761,7 @@ const useExecuteTransaction = (squidRoute) => {
         if (!route?.transactionRequest || !xrplSigner) {
             throw new Error("Need all parameters");
         }
-        if (route.transactionRequest.type !== squidTypes.SquidDataType.OnChainExecution) {
+        if (!isOnChainTxData(route.transactionRequest)) {
             throw new Error("Invalid route type");
         }
         const { data } = route.transactionRequest;
@@ -35709,10 +35797,10 @@ const useExecuteTransaction = (squidRoute) => {
         }
     }, {});
     const swapMutationSui = reactQuery.useMutation(async ({ id, route }) => {
-        if (!route || !suiSigner || !fromChain) {
+        if (!route?.transactionRequest || !suiSigner || !fromChain) {
             throw new Error("Need all parameters");
         }
-        if (route.transactionRequest?.type !== squidTypes.SquidDataType.OnChainExecution) {
+        if (!isOnChainTxData(route.transactionRequest)) {
             throw new Error("Invalid route type");
         }
         const suiWalletState = connectedWalletsByChainType[squidTypes.ChainType.SUI];
@@ -35763,9 +35851,15 @@ const useExecuteTransaction = (squidRoute) => {
         });
     }, {});
     const swapMutationStellar = reactQuery.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) {
@@ -35868,11 +35962,13 @@ const useExecuteTransaction = (squidRoute) => {
         squidRoute,
     ]);
     const swapMutation = reactQuery.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 squidTypes.ChainType.COSMOS: {
                 return swapMutationCosmos.mutateAsync(mutationParams);
@@ -36061,7 +36157,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);
@@ -36816,6 +36912,7 @@ const SquidProvider = ({ children, config, placeholder, }) => {
 exports.CHAIN_IDS = CHAIN_IDS;
 exports.CosmosProvider = CosmosProvider;
 exports.DEFAULT_LOCALE = DEFAULT_LOCALE;
+exports.DEFAULT_ROUTE_REFETCH_INTERVAL = DEFAULT_ROUTE_REFETCH_INTERVAL;
 exports.EnsService = EnsService;
 exports.EvmNetworkNotSupportedErrorCode = EvmNetworkNotSupportedErrorCode;
 exports.FINAL_TRANSACTION_STATUSES = FINAL_TRANSACTION_STATUSES;
@@ -36897,6 +36994,7 @@ exports.getMainExplorerUrl = getMainExplorerUrl;
 exports.getNewSwapParamsFromInput = getNewSwapParamsFromInput;
 exports.getNumericValue = getNumericValue;
 exports.getQueryHeaders = getQueryHeaders;
+exports.getRouteExpiry = getRouteExpiry;
 exports.getSecretNetworkBalances = getSecretNetworkBalances;
 exports.getSendTxStatusRefetchInterval = getSendTxStatusRefetchInterval;
 exports.getSourceExplorerTxUrl = getSourceExplorerTxUrl;
@@ -36925,6 +37023,7 @@ exports.isChainflipBridgeTransaction = isChainflipBridgeTransaction;
 exports.isCoralBridgeAction = isCoralBridgeAction;
 exports.isCosmosAddressValid = isCosmosAddressValid;
 exports.isDepositRoute = isDepositRoute;
+exports.isDepositWithSignatureTxData = isDepositWithSignatureTxData;
 exports.isEmptyObject = isEmptyObject;
 exports.isEvmChainNotSupportedError = isEvmChainNotSupportedError;
 exports.isEvmosChain = isEvmosChain;
@@ -36933,6 +37032,7 @@ exports.isHistoryTransactionEnded = isHistoryTransactionEnded;
 exports.isHistoryTransactionFailed = isHistoryTransactionFailed;
 exports.isHistoryTransactionPending = isHistoryTransactionPending;
 exports.isHistoryTransactionWarning = isHistoryTransactionWarning;
+exports.isOnChainTxData = isOnChainTxData;
 exports.isProblematicConnector = isProblematicConnector;
 exports.isSolanaAddressValid = isSolanaAddressValid;
 exports.isStatusError = isStatusError;
@@ -36960,6 +37060,8 @@ exports.populateWallets = populateWallets;
 exports.randomIntFromInterval = randomIntFromInterval;
 exports.redirectToExtensionsStore = redirectToExtensionsStore;
 exports.roundNumericValue = roundNumericValue;
+exports.scaleHbarToWei = scaleHbarToWei;
+exports.scaleWeiToHbar = scaleWeiToHbar;
 exports.searchTokens = searchTokens;
 exports.shareSubgraphId = shareSubgraphId;
 exports.simplifyRouteAction = simplifyRouteAction;
@@ -36981,11 +37083,13 @@ exports.useAssetsColorsStore = useAssetsColorsStore;
 exports.useAutoConnect = useAutoConnect;
 exports.useAvailableQuotes = useAvailableQuotes;
 exports.useAvatar = useAvatar;
+exports.useBitcoinNativeBalance = useBitcoinNativeBalance;
 exports.useClient = useClient;
 exports.useConfigStore = useConfigStore;
 exports.useCosmosBalance = useCosmosBalance;
 exports.useCosmosContext = useCosmosContext;
 exports.useCosmosForChain = useCosmosForChain;
+exports.useCosmosNativeBalance = useCosmosNativeBalance;
 exports.useCountryDetails = useCountryDetails;
 exports.useCurrencyDetails = useCurrencyDetails;
 exports.useDebouncedValue = useDebouncedValue;
@@ -36996,6 +37100,7 @@ exports.useEstimate = useEstimate;
 exports.useEstimatePriceImpact = useEstimatePriceImpact;
 exports.useEstimateSendTransaction = useEstimateSendTransaction;
 exports.useEvmBalance = useEvmBalance;
+exports.useEvmNativeBalance = useEvmNativeBalance;
 exports.useExecuteFiatQuote = useExecuteFiatQuote;
 exports.useExecuteTransaction = useExecuteTransaction;
 exports.useFavoriteTokensStore = useFavoriteTokensStore;
@@ -37007,6 +37112,7 @@ exports.useGetOnrampPaymentTypes = useGetOnrampPaymentTypes;
 exports.useGetRoute = useGetRoute;
 exports.useGetRouteWrapper = useGetRouteWrapper;
 exports.useGnosisContext = useGnosisContext;
+exports.useHederaAccountActivation = useHederaAccountActivation;
 exports.useHederaTokenAssociations = useHederaTokenAssociations;
 exports.useHistoricalData = useHistoricalData;
 exports.useHistory = useHistory;
@@ -37027,13 +37133,16 @@ exports.useSendTransactionStatus = useSendTransactionStatus;
 exports.useSendTransactionStore = useSendTransactionStore;
 exports.useSigner = useSigner;
 exports.useSingleTokenPrice = useSingleTokenPrice;
+exports.useSolanaNativeBalance = useSolanaNativeBalance;
 exports.useSquid = useSquid;
 exports.useSquidChains = useSquidChains;
 exports.useSquidQueryClient = useSquidQueryClient;
 exports.useSquidStore = useSquidStore;
 exports.useSquidTokens = useSquidTokens;
 exports.useStellarAccountActivation = useStellarAccountActivation;
+exports.useStellarNativeBalance = useStellarNativeBalance;
 exports.useSuggestedFiatAmounts = useSuggestedFiatAmounts;
+exports.useSuiNativeBalance = useSuiNativeBalance;
 exports.useSwap = useSwap;
 exports.useSwapRoutePersistStore = useSwapRoutePersistStore;
 exports.useSwapTransactionStatus = useSwapTransactionStatus;
@@ -37044,8 +37153,9 @@ exports.useUserParams = useUserParams;
 exports.useWallet = useWallet;
 exports.useWalletStore = useWalletStore;
 exports.useWallets = useWallets;
+exports.useXrplNativeBalance = useXrplNativeBalance;
 exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-qAOvcSon.js.map
+//# sourceMappingURL=index-BdrSk8Ed.js.map