@0xsquid/react-hooks 8.3.1-beta-update-ethers.0 → 8.3.1-beta-stellar-issued-assets.2

package/dist/{index-CMrdTYeW.js → index-z1TwF4-p.js}

@@ -13,7 +13,7 @@ import { isValidXAddress, isValidClassicAddress } from 'ripple-address-codec';
 import { getAssociatedTokenAddress, createAssociatedTokenAccountInstruction, createTransferInstruction } from '@solana/spl-token';
 import { StandardWalletAdapter } from '@solana/wallet-standard-wallet-adapter-base';
 import { PublicKey, VersionedTransaction, Transaction, SystemProgram, Connection } from '@solana/web3.js';
-import { Networks, StrKey, nativeToScVal, Address, rpc, TransactionBuilder, BASE_FEE, Contract, TimeoutInfinite, scValToNative, Operation, Transaction as Transaction$1, xdr } from '@stellar/stellar-sdk';
+import { StrKey, Networks, nativeToScVal, Address, rpc, TransactionBuilder, BASE_FEE, Contract, TimeoutInfinite, scValToNative, Asset, Operation, Transaction as Transaction$1, xdr } from '@stellar/stellar-sdk';
 import { SUI_TESTNET_CHAIN, SUI_MAINNET_CHAIN } from '@mysten/wallet-standard';
 import { CloudflareProvider, BrowserProvider, JsonRpcSigner, JsonRpcProvider, ethers, Interface, Contract as Contract$1, isError } from 'ethers';
 import BigNumber$1, { BigNumber } from 'bignumber.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";
@@ -20096,14 +20097,17 @@ function isXrplAddressValid(address) {
     return isValidXAddress(address) || isValidClassicAddress(address);
 }
 function buildXrplTrustSetTx({ amount, sourceAddress, token, }) {
-    const [currency, issuer] = token.address.split(".");
+    const asset = parseXrplTokenAddress(token.address);
+    if (!asset) {
+        throw new Error("Invalid asset");
+    }
     return {
         TransactionType: XrplTransactionType.TRUST_SET,
         Flags: XrplTransactionFlag.tfSetNoRipple,
         Account: sourceAddress,
         LimitAmount: {
-            currency,
-            issuer,
+            currency: asset.code,
+            issuer: asset.issuer,
             value: amount,
         },
     };
@@ -20132,6 +20136,16 @@ function parseXrplPaymentTx(data) {
         throw new Error("Could not parse payment transaction");
     }
 }
+function parseXrplTokenAddress(address) {
+    const [code, issuer] = address.split(".");
+    if (!code || !issuer) {
+        return null;
+    }
+    return {
+        code,
+        issuer,
+    };
+}
 
 const chains = [XrplCAIP2ChainId.MAINNET, XrplCAIP2ChainId.TESTNET];
 class XrplWalletConnect {
@@ -20834,6 +20848,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;
+        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,
+        SquidDataType.DepositAddressCalldata,
+        SquidDataType.DepositAddressWithSignature,
+        SquidDataType.DepositAddressWithMemo,
+    ].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 +21327,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;
@@ -21097,6 +21414,28 @@ const executeSolanaTransfer = async ({ amount, target, signer, connection, sourc
     return signature;
 };
 
+var StellarHorizonAssetType;
+(function (StellarHorizonAssetType) {
+    /**
+     * XLM native token
+     */
+    StellarHorizonAssetType["NATIVE"] = "native";
+    /**
+     * 1-4 char asset code (e.g. USDC)
+     */
+    StellarHorizonAssetType["ALPHANUM4"] = "credit_alphanum4";
+    /**
+     * 5-12 char asset code (e.g. wstETH)
+     */
+    StellarHorizonAssetType["ALPHANUM12"] = "credit_alphanum12";
+})(StellarHorizonAssetType || (StellarHorizonAssetType = {}));
+var StellarTokenType;
+(function (StellarTokenType) {
+    StellarTokenType["NATIVE_TOKEN"] = "nativeToken";
+    StellarTokenType["ISSUER_TOKEN"] = "issuerToken";
+    StellarTokenType["CONTRACT_TOKEN"] = "contractToken";
+})(StellarTokenType || (StellarTokenType = {}));
+
 function isStellarAddressValid(address) {
     return StrKey.isValidEd25519PublicKey(address);
 }
@@ -21118,6 +21457,78 @@ function stellarAddressToScVal(addressString) {
         type: "address",
     });
 }
+function getStellarTrustLineAsset(token) {
+    // The address format for issued assets is `CODE-ISSUER`
+    // Example: USDC-GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN
+    const [code, issuer] = token.address.split("-");
+    if (!code || !issuer) {
+        return null;
+    }
+    return {
+        code,
+        issuer,
+    };
+}
+function isStellarToken(token) {
+    try {
+        const stellarToken = token;
+        return (Object.values(StellarTokenType).includes(stellarToken.chainAssetConfig.stellar.assetType) &&
+            typeof stellarToken.chainAssetConfig.stellar.contractAddress === "string");
+    }
+    catch {
+        return false;
+    }
+}
+function isStellarIssuedToken(token) {
+    try {
+        return (isStellarToken(token) &&
+            token.chainAssetConfig.stellar.assetType === StellarTokenType.ISSUER_TOKEN);
+    }
+    catch {
+        return false;
+    }
+}
+function getStellarHorizonApiUrl(chain) {
+    try {
+        const stellarChain = chain;
+        const [horizonApiUrl] = stellarChain.horizonRpcList;
+        if (typeof horizonApiUrl !== "string") {
+            throw new Error("Invalid Horizon API URL");
+        }
+        return horizonApiUrl;
+    }
+    catch {
+        return null;
+    }
+}
+const VALID_ASSET_TYPES = new Set(Object.values(StellarHorizonAssetType));
+function isValidNativeAsset(asset) {
+    return (typeof asset === "object" &&
+        asset !== null &&
+        "balance" in asset &&
+        typeof asset.balance === "string" &&
+        "asset_type" in asset &&
+        asset.asset_type === StellarHorizonAssetType.NATIVE);
+}
+function isValidIssuedAsset(asset) {
+    return (typeof asset === "object" &&
+        asset !== null &&
+        "balance" in asset &&
+        typeof asset.balance === "string" &&
+        "asset_type" in asset &&
+        typeof asset.asset_type === "string" &&
+        VALID_ASSET_TYPES.has(asset.asset_type) &&
+        asset.asset_type !== StellarHorizonAssetType.NATIVE &&
+        "asset_code" in asset &&
+        typeof asset.asset_code === "string" &&
+        "asset_issuer" in asset &&
+        typeof asset.asset_issuer === "string" &&
+        "limit" in asset &&
+        typeof asset.limit === "string");
+}
+function isValidHorizonAsset(asset) {
+    return isValidNativeAsset(asset) || isValidIssuedAsset(asset);
+}
 
 const SUI_FEATURES = ["sui:signTransaction"];
 function isSuiStandardWallet(wallet) {
@@ -21885,285 +22296,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";
@@ -22196,6 +22328,8 @@ var QueryKeys;
     QueryKeys["XrplAccountActivatedInfo"] = "xrplAccountActivatedInfo";
     QueryKeys["FiatToCryptoPaymentMethods"] = "fiatToCryptoPaymentMethods";
     QueryKeys["Stellar"] = "stellar";
+    QueryKeys["StellarTrustLine"] = "stellarTrustLine";
+    QueryKeys["IsStellarTrustLineApproved"] = "isStellarTrustLineApproved";
     QueryKeys["StellarAccountActivatedInfo"] = "stellarAccountActivatedInfo";
     QueryKeys["Hedera"] = "hedera";
     QueryKeys["IsHederaTokenAssociated"] = "isHederaTokenAssociated";
@@ -22303,7 +22437,7 @@ const keys = () => ({
     // ============
     // Approval
     // ============
-    routeApproved: (routeData, allowanceInWei) => [
+    routeApproved: (routeData, allowanceInWei, isAllowanceQueryEnabled, hasAllowance) => [
         ...keys().transactions(),
         QueryKeys.RouteApproved,
         routeData?.params.fromAddress,
@@ -22311,6 +22445,8 @@ const keys = () => ({
         routeData?.params.fromToken,
         routeData?.params.fromAmount,
         allowanceInWei?.toString(),
+        isAllowanceQueryEnabled,
+        hasAllowance,
     ],
     sendTransactionGas: (chainId, tokenAddress, from) => [
         QueryKeys.All,
@@ -22383,6 +22519,23 @@ const keys = () => ({
     // ============
     // Stellar
     // ============
+    stellarTrustLine: (tokenAddress, chainId, address) => [
+        ...keys().stellar(),
+        QueryKeys.StellarTrustLine,
+        tokenAddress,
+        chainId,
+        address,
+    ],
+    isStellarTrustLineApproved: (address, chainId, chainType, tokenAddress, trustLineLimit, amountToApprove) => [
+        ...keys().stellar(),
+        QueryKeys.IsStellarTrustLineApproved,
+        address,
+        chainId,
+        chainType,
+        tokenAddress,
+        trustLineLimit,
+        amountToApprove?.toString(),
+    ],
     stellarAccountActivatedInfo: (address, chainId, chainType) => [
         ...keys().stellar(),
         QueryKeys.StellarAccountActivatedInfo,
@@ -22418,6 +22571,8 @@ const getPrefixKey = (key) => {
             return [...keys().transactions(), key];
         case QueryKeys.XrplTrustLine:
             return [...keys().xrpl(), key];
+        case QueryKeys.StellarTrustLine:
+            return [...keys().stellar(), key];
         case QueryKeys.IsHederaTokenAssociated:
             return [...keys().hedera(), key];
         default:
@@ -23132,7 +23287,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-aK5p-g0D.js');
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -24605,6 +24760,25 @@ function convertEvmAddressToHederaAccountId(address) {
     return "0.0." + Number(address);
 }
 
+/**
+ * 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
  * Some tokens can have very short addresses (e.g. "uosmo", "uixo", "satoshi", etc...)
@@ -26417,7 +26591,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-BB88L49R.js');
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -27917,7 +28091,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-Rc3LIf6Y.js');
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -29280,12 +29454,15 @@ const getAllXrplTokensBalance = async (userAddress, xrplTokens, xrplChains) => {
 };
 const getStellarTokenBalance = async (userAddress, token, chain) => {
     const stellarClient = await getClient(chain);
-    const balance = await stellarClient.getBalance(userAddress, token.address, chain.chainId);
+    if (!isStellarToken(token)) {
+        throw new Error("Token must be a Stellar token");
+    }
+    const balance = await stellarClient.getBalance(userAddress, token.chainAssetConfig.stellar.contractAddress, chain.chainId);
     return BigInt(balance);
 };
 const getAllStellarTokensBalance = async (userAddress, stellarTokens, stellarChains) => {
     const getBalancesForChain = async (chain) => {
-        const tokensForChain = stellarTokens.filter((t) => t.chainId === chain.chainId);
+        const tokensForChain = stellarTokens.filter((t) => t.chainId === chain.chainId && isStellarToken(t));
         const stellarClient = await getClient(chain);
         const allBalances = await stellarClient.getAllBalances(userAddress, tokensForChain);
         return allBalances.map((token) => {
@@ -29340,7 +29517,7 @@ class StellarRpcClient {
             .build();
         const simulateTxResponse = await this.server.simulateTransaction(tx);
         if ("error" in simulateTxResponse) {
-            const isNoBalanceError = simulateTxResponse.error.includes("trying to get non-existing value for contract instance");
+            const isNoBalanceError = /trying to get non-existing value for contract instance|trustline entry is missing for account/.test(simulateTxResponse.error);
             // If the error message indicates that the user has no balance just return 0
             // We don't want to spam with this error as it's pretty common
             if (isNoBalanceError) {
@@ -29356,7 +29533,7 @@ class StellarRpcClient {
     }
     async getAllBalances(userAddress, tokens) {
         const balancePromises = tokens.map((token) => {
-            return this.getBalance(userAddress, token.address, token.chainId);
+            return this.getBalance(userAddress, token.chainAssetConfig.stellar.contractAddress, token.chainId);
         });
         const results = await Promise.allSettled(balancePromises);
         const balances = results.map((result) => {
@@ -29456,9 +29633,9 @@ class XrplRpcClient {
             },
         ]);
     }
-    async getTrustLine(address, issuer, currency) {
-        const response = await this.getTrustLines(address, issuer);
-        const trustLine = response.lines.find((line) => line.currency === currency);
+    async getTrustLine(address, asset) {
+        const response = await this.getTrustLines(address, asset.issuer);
+        const trustLine = response.lines.find((line) => line.currency === asset.code);
         return trustLine ?? null;
     }
     async accountActivatedInfo(address) {
@@ -29634,9 +29811,26 @@ class StellarApiClient {
         const baseReserveBn = BigInt(latestLedger.base_reserve_in_stroops);
         return baseReserveBn;
     }
+    async getTrustLines(userAddress) {
+        const response = await fetch(`${this.apiUrl}/accounts/${userAddress}`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch account data: ${response.statusText}`);
+        }
+        const data = await response.json();
+        if (!Array.isArray(data?.balances)) {
+            throw new Error("Invalid response from Horizon API");
+        }
+        const assets = data.balances.filter(isValidHorizonAsset);
+        return assets.filter(isValidIssuedAsset);
+    }
+    async getTrustLine(address, asset) {
+        const trustLines = await this.getTrustLines(address);
+        const trustLine = trustLines.find((line) => line.asset_code === asset.code && line.asset_issuer === asset.issuer);
+        return trustLine ?? null;
+    }
 }
 
-const DEFAULT_REFETCH_INTERVAL$1 = 20_000;
+const DEFAULT_REFETCH_INTERVAL$2 = 20_000;
 function useStellarAccountActivation({ address, chain, token, }) {
     /**
      * Checks if the destination account exists on the Stellar network
@@ -29652,9 +29846,8 @@ function useStellarAccountActivation({ address, chain, token, }) {
             if (!address) {
                 throw new Error("Destination address is required");
             }
-            // TODO: update types
-            const [horizonApiUrl] = chain?.horizonRpcList;
-            if (typeof horizonApiUrl !== "string") {
+            const horizonApiUrl = getStellarHorizonApiUrl(chain);
+            if (!horizonApiUrl) {
                 throw new Error("Invalid Horizon API URL");
             }
             const stellarApiClient = new StellarApiClient(horizonApiUrl);
@@ -29670,7 +29863,7 @@ function useStellarAccountActivation({ address, chain, token, }) {
             };
         },
         enabled: !!address && chain?.chainType === ChainType.STELLAR,
-        refetchInterval: DEFAULT_REFETCH_INTERVAL$1,
+        refetchInterval: DEFAULT_REFETCH_INTERVAL$2,
         refetchOnWindowFocus: true,
     });
     return {
@@ -29678,6 +29871,149 @@ function useStellarAccountActivation({ address, chain, token, }) {
     };
 }
 
+/**
+ * Maximum asset amount on Stellar
+ * @see https://developers.stellar.org/docs/learn/fundamentals/stellar-data-structures/assets#amount-precision
+ */
+const MAX_ASSET_AMOUNT = "922337203685.4775807";
+const DEFAULT_REFETCH_INTERVAL$1 = 20_000;
+function useStellarTrustLine({ address, chain, token, amount }) {
+    const { stellarSigner } = useSigner({ chain });
+    const queryClient = useQueryClient();
+    /**
+     * Retrieves the destination account's trust line data for the given token
+     */
+    const trustLineQuery = useQuery({
+        queryKey: keys().stellarTrustLine(token?.address, chain?.chainId, address),
+        queryFn: async () => {
+            if (chain?.chainType !== ChainType.STELLAR ||
+                token?.type !== ChainType.STELLAR) {
+                return null;
+            }
+            if (!address || !isStellarAddressValid(address)) {
+                return null;
+            }
+            // Only issued tokens require trust lines
+            // Other token types like contract tokens don't need trust lines
+            if (!isStellarIssuedToken(token)) {
+                return null;
+            }
+            const asset = getStellarTrustLineAsset(token);
+            if (!asset) {
+                throw new Error("Invalid asset");
+            }
+            const horizonApiUrl = getStellarHorizonApiUrl(chain);
+            if (!horizonApiUrl) {
+                throw new Error("Invalid Horizon API URL");
+            }
+            const stellarApiClient = new StellarApiClient(horizonApiUrl);
+            return stellarApiClient.getTrustLine(address, asset);
+        },
+        enabled: !!address &&
+            chain?.chainType === ChainType.STELLAR &&
+            token?.type === ChainType.STELLAR,
+        refetchInterval: DEFAULT_REFETCH_INTERVAL$1,
+    });
+    /**
+     * Creates a trust line where the destination account authorizes to receive the given token
+     */
+    const createTrustLine = useMutation({
+        mutationFn: async () => {
+            try {
+                if (!stellarSigner) {
+                    throw new Error("Stellar signer not found");
+                }
+                if (!address) {
+                    throw new Error("Destination address is required");
+                }
+                if (chain?.chainType !== ChainType.STELLAR ||
+                    token?.type !== ChainType.STELLAR) {
+                    throw new Error("Chain and token to approve must be a Stellar token");
+                }
+                if (!isStellarIssuedToken(token)) {
+                    throw new Error("Token must be a Stellar issued token");
+                }
+                const assetInfo = getStellarTrustLineAsset(token);
+                if (!assetInfo) {
+                    throw new Error("Invalid asset");
+                }
+                const network = getStellarNetwork(chain.chainId);
+                if (network == null) {
+                    throw new Error(`Stellar network not found for chain ${chain.chainId}`);
+                }
+                const client = await getClient(chain);
+                const account = await client.getAccount(address);
+                const asset = new Asset(assetInfo.code, assetInfo.issuer);
+                const changeTrustOperation = Operation.changeTrust({
+                    asset,
+                    limit: MAX_ASSET_AMOUNT,
+                });
+                const builtTransaction = new TransactionBuilder(account, {
+                    fee: (BigInt(BASE_FEE) * BigInt(2)).toString(),
+                    networkPassphrase: network,
+                })
+                    .addOperation(changeTrustOperation)
+                    .setTimeout(300)
+                    .build();
+                const { signedTxXdr } = await stellarSigner.signTransaction(builtTransaction.toXDR(), {
+                    networkPassphrase: network,
+                });
+                const signedTransaction = new Transaction$1(signedTxXdr, network);
+                const sentTransaction = await client.sendTransaction(signedTransaction);
+                const txStatus = await client.waitForTransaction(sentTransaction.hash, {
+                    interval: 1_000,
+                });
+                if (txStatus !== rpc.Api.GetTransactionStatus.SUCCESS) {
+                    throw new Error(`Transaction failed with status: ${txStatus}`);
+                }
+                return true;
+            }
+            catch (error) {
+                console.error("Error creating trust line:", error);
+                return false;
+            }
+        },
+        async onSuccess() {
+            queryClient.invalidateQueries({
+                queryKey: getPrefixKey(QueryKeys.StellarTrustLine),
+            });
+        },
+    });
+    /**
+     * Checks if the destination account has created a trust line to receive the given token.
+     */
+    const isTrustLineApproved = useQuery({
+        queryKey: keys().isStellarTrustLineApproved(address, token?.chainId, token?.type, token?.address, trustLineQuery.data?.limit, amount),
+        queryFn: async () => {
+            if (token?.type !== ChainType.STELLAR) {
+                return true;
+            }
+            // The native Stellar token doesn't need a trust line
+            if (token.address.toLowerCase() === nativeStellarTokenAddress.toLowerCase()) {
+                return true;
+            }
+            if (!amount) {
+                throw new Error("Amount is required");
+            }
+            const limitBn = BigNumber$1(trustLineQuery.data?.limit || "0");
+            const balanceBn = BigNumber$1(trustLineQuery.data?.balance || "0");
+            const availableAllowanceBn = limitBn.minus(balanceBn);
+            const amountBn = BigNumber$1(formatBNToReadable(amount, token.decimals));
+            return availableAllowanceBn.gte(amountBn);
+        },
+        enabled: !!address &&
+            !!amount &&
+            !trustLineQuery?.isLoading &&
+            trustLineQuery?.isFetched &&
+            token?.type === ChainType.STELLAR,
+    });
+    return {
+        createTrustLine,
+        trustLineQuery,
+        isTrustLineApproved,
+    };
+}
+
 const useAddressBookStore = create(persist((set) => ({
     addressBook: [],
     add: (newAddressData) => {
@@ -31300,15 +31636,18 @@ async function sendTransactionXrpl({ amount, signer, to, token, from, }) {
             txHash: hash,
         };
     }
-    const [currency, issuer] = token.address.split(".");
+    const asset = parseXrplTokenAddress(token.address);
+    if (!asset) {
+        throw new Error("Invalid asset");
+    }
     const amountFormatted = formatBNToReadable(amount, token.decimals);
     const { hash } = await signer.signAndSubmit({
         network: xrplNetwork,
         tx: {
             ...baseTransaction,
             Amount: {
-                currency,
-                issuer,
+                currency: asset.code,
+                issuer: asset.issuer,
                 value: amountFormatted,
             },
         },
@@ -31972,7 +32311,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,
@@ -32041,7 +32385,7 @@ const useApproval = ({ squidRoute, }) => {
      * On Error: Showing the error message if any
      * @returns {boolean} approved
      */
-    const routeApproved = useQuery(keys().routeApproved(squidRoute, allowanceInWei), async () => {
+    const routeApproved = useQuery(keys().routeApproved(squidRoute, allowanceInWei, erc20AllowanceQueryEnabled, hasAllowance), async () => {
         if (erc20AllowanceQueryEnabled) {
             return hasAllowance;
         }
@@ -35262,7 +35606,9 @@ const useExecuteTransaction = (squidRoute) => {
         if (!route?.transactionRequest)
             return undefined;
         const { quoteId } = route;
+        const currentTx = getTransaction(id);
         const tx = {
+            ...currentTx,
             fromChain,
             toChain,
             routeType: route.transactionRequest.type,
@@ -35280,7 +35626,7 @@ const useExecuteTransaction = (squidRoute) => {
         };
         setTransactionStoreState(id, tx);
         return tx;
-    }, [fromChain, setTransactionStoreState, toChain]);
+    }, [fromChain, toChain, setTransactionStoreState, getTransaction]);
     const getCosmosSignerClient = useCallback(async () => {
         if (!fromChain)
             return null;
@@ -35652,7 +35998,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 +36034,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,28 +36088,56 @@ 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) {
             throw new Error(`No Stellar network found for chainId ${fromChainId}`);
         }
-        const { data: xdrHex, gasPrice } = route.transactionRequest;
-        const { address } = await stellarSigner.getAddress();
         const client = await getClient(fromChain);
-        const account = await client.getAccount(address);
-        const operation = xdr.Operation.fromXDR(xdrHex, "hex");
-        const builtTransaction = new TransactionBuilder(account, {
-            fee: gasPrice || (BigInt(BASE_FEE) * BigInt(2)).toString(),
-            networkPassphrase: stellarNetwork,
-        })
-            .addOperation(operation)
-            .setTimeout(300)
-            .build();
-        const preparedTransaction = await client.prepareTransaction(builtTransaction);
-        const { signedTxXdr } = await stellarSigner.signTransaction(preparedTransaction.toXDR(), {
+        // TODO: at the moment we're receiving different formats depending on the route type.
+        //
+        // For OnChainExecution we get a single operation xdr string, so we need to build
+        // a full transaction frontend-side (by adding the operation to a new transaction).
+        //
+        // For DepositAddressCalldata we get the full transaction xdr,
+        // so we just need to send it to the wallet for signing.
+        //
+        // In the future this will be standardized backend-side so we have a unified flow for all route types.
+        let txXdrToSign;
+        if (route.transactionRequest.type === SquidDataType.OnChainExecution) {
+            const { data: operationXdrHex, gasPrice } = route.transactionRequest;
+            const { address } = await stellarSigner.getAddress();
+            const account = await client.getAccount(address);
+            const operation = xdr.Operation.fromXDR(operationXdrHex, "hex");
+            const builtTransaction = new TransactionBuilder(account, {
+                fee: gasPrice || (BigInt(BASE_FEE) * BigInt(2)).toString(),
+                networkPassphrase: stellarNetwork,
+            })
+                .addOperation(operation)
+                .setTimeout(300)
+                .build();
+            // This is a smart-contract transaction, so it needs to be simulated first
+            const preparedTransaction = await client.prepareTransaction(builtTransaction);
+            txXdrToSign = preparedTransaction.toXDR();
+        }
+        else if (route.transactionRequest.type === SquidDataType.DepositAddressCalldata) {
+            // For this route type, we get the full transaction xdr in the data field.
+            // This is a payment transaction, so simulation must be skipped.
+            txXdrToSign = route.transactionRequest.data;
+        }
+        else {
+            throw new Error(`Invalid route type ${route.transactionRequest.type}`);
+        }
+        const { signedTxXdr } = await stellarSigner.signTransaction(txXdrToSign, {
             networkPassphrase: stellarNetwork,
         });
         const signedTransaction = new Transaction$1(signedTxXdr, stellarNetwork);
@@ -35847,11 +36221,36 @@ 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");
+        // For deposit-with-signature routes, we need to prompt the user
+        // for a signature before continuing the swap flow
+        if (isDepositWithSignatureTxData(mutationParams.route.transactionRequest)) {
+            if (!mutationParams.route.transactionRequest.signatureRequired) {
+                throw new Error("Data to sign was empty");
+            }
+            switch (sourceChain.chainType) {
+                case ChainType.EVM: {
+                    if (!evmSigner) {
+                        throw new Error("EVM signer is required");
+                    }
+                    const signature = await evmSigner.signMessage(mutationParams.route.transactionRequest.signatureRequired);
+                    const currentTx = getTransaction(mutationParams.id);
+                    setTransactionStoreState(mutationParams.id, {
+                        ...currentTx,
+                        depositTxVerificationSignature: signature,
+                    });
+                    break;
+                }
+                default:
+                    throw new Error(`deposit-with-signature flow not implemented for chain type: ${sourceChain.chainType}`);
+            }
+        }
+        // After getting signature (if needed), continue with the swap flow
         switch (sourceChain.chainType) {
             case ChainType.COSMOS: {
                 return swapMutationCosmos.mutateAsync(mutationParams);
@@ -36040,7 +36439,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);
@@ -36549,12 +36948,12 @@ function useXrplTrustLine({ address, chain, token, amount }) {
             if (!address || !isXrplAddressValid(address)) {
                 return null;
             }
-            const [currency, issuer] = token.address.split(".");
-            if (!currency || !issuer) {
+            const trustLineAsset = parseXrplTokenAddress(token.address);
+            if (!trustLineAsset) {
                 return null;
             }
             const xrplClient = await getClient(chain);
-            const trustLine = await xrplClient.getTrustLine(address, issuer, currency);
+            const trustLine = await xrplClient.getTrustLine(address, trustLineAsset);
             return trustLine;
         },
         enabled: !!address &&
@@ -36792,5 +37191,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, useStellarTrustLine 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, sortTokensBySharedSubgraphIds as a$, useAllConnectedWalletBalances as a0, useAllTokensWithBalanceForChainType as a1, useCosmosBalance as a2, useEvmBalance as a3, useMultiChainBalance as a4, useMultipleTokenPrices as a5, useNativeBalance as a6, useNativeTokenForChain as a7, useSingleTokenPrice as a8, useSquidTokens as a9, useMultiChainWallet as aA, useSigner as aB, useWallet as aC, useWallets as aD, useXrplTrustLine as aE, TX_STATUS_CONSTANTS as aF, FINAL_TRANSACTION_STATUSES as aG, useGetFiatQuote as aH, useGetOnRampConfig as aI, useExecuteFiatQuote as aJ, useFiatOnRampTxStatus as aK, useFiatTransactions as aL, useCurrencyDetails as aM, useCountryDetails as aN, useAvailableQuotes as aO, useRecommendedQuote as aP, useGetOnrampPaymentTypes as aQ, useSuggestedFiatAmounts as aR, SquidProvider as aS, EnsService as aT, getXummClient as aU, isXamanXAppContext as aV, getQueryHeaders as aW, getStatusCode as aX, is404Error as aY, assetsBaseUrl as aZ, shareSubgraphId as a_, useHistoricalData as aa, useTokensData as ab, useEstimateSendTransaction as ac, useSendTransaction as ad, useSendTransactionGas as ae, useAllTransactionsStatus as af, useApproval as ag, useEstimate as ah, useEstimatePriceImpact as ai, useExecuteTransaction as aj, useGetRoute as ak, useGetRouteWrapper as al, useRouteWarnings as am, useSendTransactionStatus as an, useSwapTransactionStatus as ao, useAvatar as ap, useHistory as aq, useUserParams as ar, useDebouncedValue as as, useAddToken as at, useAutoConnect as au, useEnsDataForAddress as av, useEnsSearch as aw, useGnosisContext as ax, useIsSameAddressAndGnosisContext as ay, useIntegratorContext as az, chainTypeToZeroAddressMap as b, formatUnitsRounded as b$, getSupportedChainIdsForDirection as b0, filterChains as b1, filterTokens as b2, getTokenImage as b3, getNewSwapParamsFromInput as b4, sortAllTokens as b5, findToken as b6, findNativeToken as b7, normalizeIbcAddress as b8, groupTokensBySymbol as b9, isFallbackAddressNeeded as bA, suggestChainOrThrow as bB, normalizeError as bC, transactionErrorCode as bD, isUserRejectionError as bE, getTransactionError as bF, handleTransactionErrorEvents as bG, isSwapRouteError as bH, isStatusError as bI, createQuoteRequestParamsHash as bJ, WidgetEvents as bK, EvmNetworkNotSupportedErrorCode as bL, addEthereumChain as bM, parseEvmAddress as bN, formatEvmWallet as bO, filterWagmiConnector as bP, waitForReceiptWithRetry as bQ, getUserCountry as bR, getCountryData as bS, getCurrencyData as bT, adaptiveRound as bU, getSuggestedAmountsForCurrency as bV, HederaExtensionHelper as bW, convertHederaAccountIdToEvmAddress as bX, convertEvmAddressToHederaAccountId as bY, parseToBigInt as bZ, roundNumericValue as b_, groupTokensByChainId as ba, filterViewableTokens as bb, getSecretNetworkBalances as bc, getTokenAssetsKey as bd, fetchAssetsColors as be, initializeSquidWithAssetsColors as bf, isEmptyObject as bg, normalizeTokenSymbol as bh, areTokenSymbolsCompatible as bi, isEvmosChain as bj, getConfigWithDefaults as bk, randomIntFromInterval as bl, getTokensForChain as bm, getFirstAvailableChainId as bn, fetchHighestBalanceToken as bo, getInitialOrDefaultTokenAddressForChain as bp, getInitialTokenAddressForChain as bq, filterTokensForDestination as br, getInitialChainIdFromConfig as bs, getCosmosKey as bt, getKeysSettled as bu, getAllKeysForSupportedCosmosChains as bv, isCosmosAddressValid as bw, getCosmosSigningClient as bx, getCosmosChainInfosObject as by, connectCosmosWallet as bz, chainTypeToNativeTokenAddressMap as c, addTokenToWallet as c$, formatTokenAmount as c0, formatUsdAmount as c1, trimExtraDecimals as c2, getNumericValue as c3, cleanAmount as c4, convertTokenAmountToUSD as c5, convertUSDToTokenAmount as c6, calculateTotal24hChange as c7, getRouteExpiry as c8, searchTokens 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_, filterSolanaWallets as ca, isSolanaAddressValid as cb, executeSolanaSwap as cc, executeSolanaTransfer as cd, isStellarAddressValid as ce, getStellarNetwork as cf, stellarAddressToScVal as cg, getStellarTrustLineAsset as ch, isStellarToken as ci, isStellarIssuedToken as cj, getStellarHorizonApiUrl as ck, isValidIssuedAsset as cl, isValidHorizonAsset 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, parseXrplTokenAddress as dd, 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-z1TwF4-p.js.map