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

package/dist/{index-qAOvcSon.js → index-xSvE7oVI.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";
@@ -20117,14 +20118,17 @@ function isXrplAddressValid(address) {
     return rippleAddressCodec.isValidXAddress(address) || rippleAddressCodec.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,
         },
     };
@@ -20153,6 +20157,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 {
@@ -20855,6 +20869,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;
+        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,
+        squidTypes.SquidDataType.DepositAddressCalldata,
+        squidTypes.SquidDataType.DepositAddressWithSignature,
+        squidTypes.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 === 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 +21348,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;
@@ -21118,6 +21435,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 stellarSdk.StrKey.isValidEd25519PublicKey(address);
 }
@@ -21139,6 +21478,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) {
@@ -21906,285 +22317,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";
@@ -22217,6 +22349,8 @@ exports.QueryKeys = void 0;
     QueryKeys["XrplAccountActivatedInfo"] = "xrplAccountActivatedInfo";
     QueryKeys["FiatToCryptoPaymentMethods"] = "fiatToCryptoPaymentMethods";
     QueryKeys["Stellar"] = "stellar";
+    QueryKeys["StellarTrustLine"] = "stellarTrustLine";
+    QueryKeys["IsStellarTrustLineApproved"] = "isStellarTrustLineApproved";
     QueryKeys["StellarAccountActivatedInfo"] = "stellarAccountActivatedInfo";
     QueryKeys["Hedera"] = "hedera";
     QueryKeys["IsHederaTokenAssociated"] = "isHederaTokenAssociated";
@@ -22324,7 +22458,7 @@ const keys = () => ({
     // ============
     // Approval
     // ============
-    routeApproved: (routeData, allowanceInWei) => [
+    routeApproved: (routeData, allowanceInWei, isAllowanceQueryEnabled, hasAllowance) => [
         ...keys().transactions(),
         exports.QueryKeys.RouteApproved,
         routeData?.params.fromAddress,
@@ -22332,6 +22466,8 @@ const keys = () => ({
         routeData?.params.fromToken,
         routeData?.params.fromAmount,
         allowanceInWei?.toString(),
+        isAllowanceQueryEnabled,
+        hasAllowance,
     ],
     sendTransactionGas: (chainId, tokenAddress, from) => [
         exports.QueryKeys.All,
@@ -22404,6 +22540,23 @@ const keys = () => ({
     // ============
     // Stellar
     // ============
+    stellarTrustLine: (tokenAddress, chainId, address) => [
+        ...keys().stellar(),
+        exports.QueryKeys.StellarTrustLine,
+        tokenAddress,
+        chainId,
+        address,
+    ],
+    isStellarTrustLineApproved: (address, chainId, chainType, tokenAddress, trustLineLimit, amountToApprove) => [
+        ...keys().stellar(),
+        exports.QueryKeys.IsStellarTrustLineApproved,
+        address,
+        chainId,
+        chainType,
+        tokenAddress,
+        trustLineLimit,
+        amountToApprove?.toString(),
+    ],
     stellarAccountActivatedInfo: (address, chainId, chainType) => [
         ...keys().stellar(),
         exports.QueryKeys.StellarAccountActivatedInfo,
@@ -22439,6 +22592,8 @@ const getPrefixKey = (key) => {
             return [...keys().transactions(), key];
         case exports.QueryKeys.XrplTrustLine:
             return [...keys().xrpl(), key];
+        case exports.QueryKeys.StellarTrustLine:
+            return [...keys().stellar(), key];
         case exports.QueryKeys.IsHederaTokenAssociated:
             return [...keys().hedera(), key];
         default:
@@ -23153,7 +23308,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-BEEQh-7r.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -24626,6 +24781,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...)
@@ -26438,7 +26612,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-Dl_XfhX_.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -27938,7 +28112,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-CtYD1WrB.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -29301,12 +29475,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) => {
@@ -29361,7 +29538,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) {
@@ -29377,7 +29554,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) => {
@@ -29477,9 +29654,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) {
@@ -29655,9 +29832,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
@@ -29673,9 +29867,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);
@@ -29691,7 +29884,7 @@ function useStellarAccountActivation({ address, chain, token, }) {
             };
         },
         enabled: !!address && chain?.chainType === squidTypes.ChainType.STELLAR,
-        refetchInterval: DEFAULT_REFETCH_INTERVAL$1,
+        refetchInterval: DEFAULT_REFETCH_INTERVAL$2,
         refetchOnWindowFocus: true,
     });
     return {
@@ -29699,6 +29892,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 = reactQuery.useQueryClient();
+    /**
+     * Retrieves the destination account's trust line data for the given token
+     */
+    const trustLineQuery = reactQuery.useQuery({
+        queryKey: keys().stellarTrustLine(token?.address, chain?.chainId, address),
+        queryFn: async () => {
+            if (chain?.chainType !== squidTypes.ChainType.STELLAR ||
+                token?.type !== squidTypes.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 === squidTypes.ChainType.STELLAR &&
+            token?.type === squidTypes.ChainType.STELLAR,
+        refetchInterval: DEFAULT_REFETCH_INTERVAL$1,
+    });
+    /**
+     * Creates a trust line where the destination account authorizes to receive the given token
+     */
+    const createTrustLine = reactQuery.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 !== squidTypes.ChainType.STELLAR ||
+                    token?.type !== squidTypes.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 stellarSdk.Asset(assetInfo.code, assetInfo.issuer);
+                const changeTrustOperation = stellarSdk.Operation.changeTrust({
+                    asset,
+                    limit: MAX_ASSET_AMOUNT,
+                });
+                const builtTransaction = new stellarSdk.TransactionBuilder(account, {
+                    fee: (BigInt(stellarSdk.BASE_FEE) * BigInt(2)).toString(),
+                    networkPassphrase: network,
+                })
+                    .addOperation(changeTrustOperation)
+                    .setTimeout(300)
+                    .build();
+                const { signedTxXdr } = await stellarSigner.signTransaction(builtTransaction.toXDR(), {
+                    networkPassphrase: network,
+                });
+                const signedTransaction = new stellarSdk.Transaction(signedTxXdr, network);
+                const sentTransaction = await client.sendTransaction(signedTransaction);
+                const txStatus = await client.waitForTransaction(sentTransaction.hash, {
+                    interval: 1_000,
+                });
+                if (txStatus !== stellarSdk.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(exports.QueryKeys.StellarTrustLine),
+            });
+        },
+    });
+    /**
+     * Checks if the destination account has created a trust line to receive the given token.
+     */
+    const isTrustLineApproved = reactQuery.useQuery({
+        queryKey: keys().isStellarTrustLineApproved(address, token?.chainId, token?.type, token?.address, trustLineQuery.data?.limit, amount),
+        queryFn: async () => {
+            if (token?.type !== squidTypes.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(trustLineQuery.data?.limit || "0");
+            const balanceBn = BigNumber(trustLineQuery.data?.balance || "0");
+            const availableAllowanceBn = limitBn.minus(balanceBn);
+            const amountBn = BigNumber(formatBNToReadable(amount, token.decimals));
+            return availableAllowanceBn.gte(amountBn);
+        },
+        enabled: !!address &&
+            !!amount &&
+            !trustLineQuery?.isLoading &&
+            trustLineQuery?.isFetched &&
+            token?.type === squidTypes.ChainType.STELLAR,
+    });
+    return {
+        createTrustLine,
+        trustLineQuery,
+        isTrustLineApproved,
+    };
+}
+
 const useAddressBookStore = zustand.create(middleware.persist((set) => ({
     addressBook: [],
     add: (newAddressData) => {
@@ -31321,15 +31657,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,
             },
         },
@@ -31993,7 +32332,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,
@@ -32062,7 +32406,7 @@ const useApproval = ({ squidRoute, }) => {
      * On Error: Showing the error message if any
      * @returns {boolean} approved
      */
-    const routeApproved = reactQuery.useQuery(keys().routeApproved(squidRoute, allowanceInWei), async () => {
+    const routeApproved = reactQuery.useQuery(keys().routeApproved(squidRoute, allowanceInWei, erc20AllowanceQueryEnabled, hasAllowance), async () => {
         if (erc20AllowanceQueryEnabled) {
             return hasAllowance;
         }
@@ -35283,7 +35627,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,
@@ -35301,7 +35647,7 @@ const useExecuteTransaction = (squidRoute) => {
         };
         setTransactionStoreState(id, tx);
         return tx;
-    }, [fromChain, setTransactionStoreState, toChain]);
+    }, [fromChain, toChain, setTransactionStoreState, getTransaction]);
     const getCosmosSignerClient = React.useCallback(async () => {
         if (!fromChain)
             return null;
@@ -35673,7 +36019,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 +36055,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,28 +36109,56 @@ 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) {
             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 = stellarSdk.xdr.Operation.fromXDR(xdrHex, "hex");
-        const builtTransaction = new stellarSdk.TransactionBuilder(account, {
-            fee: gasPrice || (BigInt(stellarSdk.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 === squidTypes.SquidDataType.OnChainExecution) {
+            const { data: operationXdrHex, gasPrice } = route.transactionRequest;
+            const { address } = await stellarSigner.getAddress();
+            const account = await client.getAccount(address);
+            const operation = stellarSdk.xdr.Operation.fromXDR(operationXdrHex, "hex");
+            const builtTransaction = new stellarSdk.TransactionBuilder(account, {
+                fee: gasPrice || (BigInt(stellarSdk.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 === squidTypes.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 stellarSdk.Transaction(signedTxXdr, stellarNetwork);
@@ -35868,11 +36242,36 @@ 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");
+        // 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 squidTypes.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 squidTypes.ChainType.COSMOS: {
                 return swapMutationCosmos.mutateAsync(mutationParams);
@@ -36061,7 +36460,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);
@@ -36570,12 +36969,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 &&
@@ -36816,6 +37215,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,10 +37297,14 @@ exports.getMainExplorerUrl = getMainExplorerUrl;
 exports.getNewSwapParamsFromInput = getNewSwapParamsFromInput;
 exports.getNumericValue = getNumericValue;
 exports.getQueryHeaders = getQueryHeaders;
+exports.getRouteExpiry = getRouteExpiry;
 exports.getSecretNetworkBalances = getSecretNetworkBalances;
 exports.getSendTxStatusRefetchInterval = getSendTxStatusRefetchInterval;
 exports.getSourceExplorerTxUrl = getSourceExplorerTxUrl;
 exports.getStatusCode = getStatusCode;
+exports.getStellarHorizonApiUrl = getStellarHorizonApiUrl;
+exports.getStellarNetwork = getStellarNetwork;
+exports.getStellarTrustLineAsset = getStellarTrustLineAsset;
 exports.getStepStatuses = getStepStatuses;
 exports.getStepsInfos = getStepsInfos;
 exports.getSuggestedAmountsForCurrency = getSuggestedAmountsForCurrency;
@@ -36925,6 +37329,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,11 +37338,17 @@ exports.isHistoryTransactionEnded = isHistoryTransactionEnded;
 exports.isHistoryTransactionFailed = isHistoryTransactionFailed;
 exports.isHistoryTransactionPending = isHistoryTransactionPending;
 exports.isHistoryTransactionWarning = isHistoryTransactionWarning;
+exports.isOnChainTxData = isOnChainTxData;
 exports.isProblematicConnector = isProblematicConnector;
 exports.isSolanaAddressValid = isSolanaAddressValid;
 exports.isStatusError = isStatusError;
+exports.isStellarAddressValid = isStellarAddressValid;
+exports.isStellarIssuedToken = isStellarIssuedToken;
+exports.isStellarToken = isStellarToken;
 exports.isSwapRouteError = isSwapRouteError;
 exports.isUserRejectionError = isUserRejectionError;
+exports.isValidHorizonAsset = isValidHorizonAsset;
+exports.isValidIssuedAsset = isValidIssuedAsset;
 exports.isWalletAddressValid = isWalletAddressValid;
 exports.isXamanXAppContext = isXamanXAppContext;
 exports.isXionSmartContractAddress = isXionSmartContractAddress;
@@ -36956,6 +37367,7 @@ exports.normalizeTokenSymbol = normalizeTokenSymbol;
 exports.parseEvmAddress = parseEvmAddress;
 exports.parseToBigInt = parseToBigInt;
 exports.parseXrplPaymentTx = parseXrplPaymentTx;
+exports.parseXrplTokenAddress = parseXrplTokenAddress;
 exports.populateWallets = populateWallets;
 exports.randomIntFromInterval = randomIntFromInterval;
 exports.redirectToExtensionsStore = redirectToExtensionsStore;
@@ -36968,6 +37380,7 @@ exports.sortAddressBook = sortAddressBook;
 exports.sortAllTokens = sortAllTokens;
 exports.sortTokensBySharedSubgraphIds = sortTokensBySharedSubgraphIds;
 exports.sortWallets = sortWallets;
+exports.stellarAddressToScVal = stellarAddressToScVal;
 exports.suggestChainOrThrow = suggestChainOrThrow;
 exports.transactionErrorCode = transactionErrorCode;
 exports.trimExtraDecimals = trimExtraDecimals;
@@ -37033,6 +37446,7 @@ exports.useSquidQueryClient = useSquidQueryClient;
 exports.useSquidStore = useSquidStore;
 exports.useSquidTokens = useSquidTokens;
 exports.useStellarAccountActivation = useStellarAccountActivation;
+exports.useStellarTrustLine = useStellarTrustLine;
 exports.useSuggestedFiatAmounts = useSuggestedFiatAmounts;
 exports.useSwap = useSwap;
 exports.useSwapRoutePersistStore = useSwapRoutePersistStore;
@@ -37048,4 +37462,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-qAOvcSon.js.map
+//# sourceMappingURL=index-xSvE7oVI.js.map