@0xsquid/react-hooks 8.8.1-beta-canton.4 → 8.8.1-beta-wallet-verification.0

package/dist/{index-D5QOR7JT.js → index-CtXS5uny.js}

@@ -3,7 +3,7 @@ import { zeroAddress as zeroAddress$1, parseUnits, formatUnits, isAddress, Switc
 import React, { useMemo, useCallback, useState, useEffect, createContext, useContext, useRef } from 'react';
 import { useQuery, useMutation, useQueries, useQueryClient, QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { fromBech32 } from '@cosmjs/encoding';
-import * as bitcoin from 'bitcoinjs-lib';
+import * as bitcoin$1 from 'bitcoinjs-lib';
 import { address } from 'bitcoinjs-lib';
 import * as ecc from '@bitcoinerlab/secp256k1';
 import axios, { AxiosError } from 'axios';
@@ -57,8 +57,6 @@ const solanaZeroAddress = "11111111111111111111111111111111";
 const suiZeroAddress = "0x0000000000000000000000000000000000000000";
 const xrplZeroAddress = "rrrrrrrrrrrrrrrrrrrrrhoLvTp";
 const stellarZeroAddress = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF";
-// TODO: check
-const cantonZeroAddress = "none::12200000000000000000000000000000000000000000000000000000000000000000";
 const chainTypeToZeroAddressMap = {
     [ChainType.EVM]: zeroAddress$1,
     [ChainType.COSMOS]: cosmosZeroAddress,
@@ -67,7 +65,6 @@ const chainTypeToZeroAddressMap = {
     [ChainType.SUI]: suiZeroAddress,
     [ChainType.XRPL]: xrplZeroAddress,
     [ChainType.STELLAR]: stellarZeroAddress,
-    [ChainType.CANTON]: cantonZeroAddress,
 };
 const nativeEvmTokenAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 const nativeCosmosTokenAddress = "uosmo";
@@ -76,7 +73,6 @@ const nativeBitcoinTokenAddress = "satoshi";
 const nativeSuiTokenAddress = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
 const nativeXrplTokenAddress = "xrp";
 const nativeStellarTokenAddress = "CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA";
-const nativeCantonTokenAddress = "DSO::1220b1431ef217342db44d516bb9befde802be7d8899637d290895fa58880f19accc";
 // by setting slippage to undefined, it's set to "auto"
 const defaultSlippage = undefined;
 const destinationAddressResetValue = "null";
@@ -140,7 +136,6 @@ const CHAIN_IDS = {
     XRPL_TESTNET: "xrpl-testnet",
     STELLAR: "stellar-mainnet",
     STELLAR_TESTNET: "stellar-testnet",
-    CANTON: "canton",
 };
 const chainTypeToDefaultChainIdMap = {
     [ChainType.EVM]: CHAIN_IDS.ETHEREUM,
@@ -150,7 +145,6 @@ const chainTypeToDefaultChainIdMap = {
     [ChainType.SUI]: CHAIN_IDS.SUI,
     [ChainType.XRPL]: CHAIN_IDS.XRPL,
     [ChainType.STELLAR]: CHAIN_IDS.STELLAR,
-    [ChainType.CANTON]: CHAIN_IDS.CANTON,
 };
 const chainTypeToNativeTokenAddressMap = {
     [ChainType.EVM]: nativeEvmTokenAddress,
@@ -160,12 +154,12 @@ const chainTypeToNativeTokenAddressMap = {
     [ChainType.SUI]: nativeSuiTokenAddress,
     [ChainType.XRPL]: nativeXrplTokenAddress,
     [ChainType.STELLAR]: nativeStellarTokenAddress,
-    [ChainType.CANTON]: nativeCantonTokenAddress,
 };
 const defaultConfigValues = {
     integratorId: INTEGRATOR_ID,
     slippage: defaultSlippage,
     apiUrl: squidApiBaseUrl,
+    xamanApiUrl: XAMAN_API_URL,
     priceImpactWarnings: {
         warning: 3,
         critical: 5,
@@ -4193,11 +4187,11 @@ class WidgetEvents extends EventTarget {
         this.dispatch("qrCodeGenerationFailedForSign", data);
     }
     /**
-     * Dispatches event after the QR code for signing a transaction is scanned
-     * and we're waiting for the user to approve or reject it.
+     * Dispatches event after a QR code is scanned and we're waiting for the user
+     * to approve or reject it.
      */
-    dispatchQrTxScannedAwaitingApproval(data) {
-        this.dispatch("qrTxScannedAwaitingUserApproval", data);
+    dispatchQrScannedAwaitingApproval(data) {
+        this.dispatch("qrScannedAwaitingUserApproval", data);
     }
 }
 
@@ -4695,6 +4689,193 @@ function extractRpcUrls(parameters) {
     return transports.map(({ value }) => value?.url || fallbackUrl);
 }
 
+var build = {};
+
+var currency = {};
+
+Object.defineProperty(currency, "__esModule", { value: true });
+
+var bech32 = {};
+
+Object.defineProperty(bech32, "__esModule", { value: true });
+
+var bip44 = {};
+
+Object.defineProperty(bip44, "__esModule", { value: true });
+
+var chainInfo = {};
+
+Object.defineProperty(chainInfo, "__esModule", { value: true });
+
+var wallet = {};
+
+var keplr = {};
+
+Object.defineProperty(keplr, "__esModule", { value: true });
+
+var eip6963 = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.EIP6963EventNames = void 0;
+	(function (EIP6963EventNames) {
+	    EIP6963EventNames["Announce"] = "eip6963:announceProvider";
+	    EIP6963EventNames["Request"] = "eip6963:requestProvider";
+	})(exports.EIP6963EventNames || (exports.EIP6963EventNames = {}));
+	
+} (eip6963));
+
+var ethereum$1 = {};
+
+Object.defineProperty(ethereum$1, "__esModule", { value: true });
+
+var starknet = {};
+
+Object.defineProperty(starknet, "__esModule", { value: true });
+
+var bitcoin = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.CHAIN_TYPE_TO_GENESIS_HASH = exports.GENESIS_HASH_TO_CHAIN_TYPE = exports.NETWORK_TO_GENESIS_HASH = exports.GENESIS_HASH_TO_NETWORK = exports.ChainType = exports.Network = exports.GenesisHash = exports.BitcoinSignMessageType = void 0;
+	(function (BitcoinSignMessageType) {
+	    BitcoinSignMessageType["ECDSA"] = "ecdsa";
+	    BitcoinSignMessageType["BIP322_SIMPLE"] = "bip322-simple";
+	})(exports.BitcoinSignMessageType || (exports.BitcoinSignMessageType = {}));
+	var GenesisHash;
+	(function (GenesisHash) {
+	    GenesisHash["MAINNET"] = "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f";
+	    GenesisHash["TESTNET"] = "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943";
+	    GenesisHash["SIGNET"] = "00000008819873e925422c1ff0f99f7cc9bbb232af63a077a480a3633bee1ef6";
+	})(GenesisHash = exports.GenesisHash || (exports.GenesisHash = {}));
+	var Network;
+	(function (Network) {
+	    Network["MAINNET"] = "mainnet";
+	    Network["LIVENET"] = "livenet";
+	    Network["TESTNET"] = "testnet";
+	    Network["SIGNET"] = "signet";
+	})(Network = exports.Network || (exports.Network = {}));
+	var ChainType;
+	(function (ChainType) {
+	    ChainType["BITCOIN_MAINNET"] = "BITCOIN_MAINNET";
+	    ChainType["BITCOIN_TESTNET"] = "BITCOIN_TESTNET";
+	    ChainType["BITCOIN_SIGNET"] = "BITCOIN_SIGNET";
+	})(ChainType = exports.ChainType || (exports.ChainType = {}));
+	exports.GENESIS_HASH_TO_NETWORK = {
+	    [GenesisHash.MAINNET]: Network.MAINNET,
+	    [GenesisHash.TESTNET]: Network.TESTNET,
+	    [GenesisHash.SIGNET]: Network.SIGNET,
+	};
+	exports.NETWORK_TO_GENESIS_HASH = {
+	    [Network.MAINNET]: GenesisHash.MAINNET,
+	    [Network.LIVENET]: GenesisHash.MAINNET,
+	    [Network.TESTNET]: GenesisHash.TESTNET,
+	    [Network.SIGNET]: GenesisHash.SIGNET,
+	};
+	exports.GENESIS_HASH_TO_CHAIN_TYPE = {
+	    [GenesisHash.MAINNET]: ChainType.BITCOIN_MAINNET,
+	    [GenesisHash.TESTNET]: ChainType.BITCOIN_TESTNET,
+	    [GenesisHash.SIGNET]: ChainType.BITCOIN_SIGNET,
+	};
+	exports.CHAIN_TYPE_TO_GENESIS_HASH = {
+	    [ChainType.BITCOIN_MAINNET]: GenesisHash.MAINNET,
+	    [ChainType.BITCOIN_TESTNET]: GenesisHash.TESTNET,
+	    [ChainType.BITCOIN_SIGNET]: GenesisHash.SIGNET,
+	};
+	
+} (bitcoin));
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(keplr, exports);
+	__exportStar(eip6963, exports);
+	__exportStar(ethereum$1, exports);
+	__exportStar(starknet, exports);
+	__exportStar(bitcoin, exports);
+	
+} (wallet));
+
+var window$1 = {};
+
+Object.defineProperty(window$1, "__esModule", { value: true });
+
+var ethereum = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.EthTxStatus = exports.EthSignType = void 0;
+	(function (EthSignType) {
+	    EthSignType["MESSAGE"] = "message";
+	    EthSignType["TRANSACTION"] = "transaction";
+	    EthSignType["EIP712"] = "eip-712";
+	})(exports.EthSignType || (exports.EthSignType = {}));
+	(function (EthTxStatus) {
+	    EthTxStatus["Success"] = "0x1";
+	    EthTxStatus["Failure"] = "0x0";
+	})(exports.EthTxStatus || (exports.EthTxStatus = {}));
+	
+} (ethereum));
+
+var cosmjs = {};
+
+Object.defineProperty(cosmjs, "__esModule", { value: true });
+
+var cosmjsAlt = {};
+
+Object.defineProperty(cosmjsAlt, "__esModule", { value: true });
+
+var secretjs = {};
+
+Object.defineProperty(secretjs, "__esModule", { value: true });
+
+var settled = {};
+
+Object.defineProperty(settled, "__esModule", { value: true });
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(currency, exports);
+	__exportStar(bech32, exports);
+	__exportStar(bip44, exports);
+	__exportStar(chainInfo, exports);
+	__exportStar(wallet, exports);
+	__exportStar(window$1, exports);
+	__exportStar(ethereum, exports);
+	__exportStar(cosmjs, exports);
+	__exportStar(cosmjsAlt, exports);
+	__exportStar(secretjs, exports);
+	__exportStar(settled, exports);
+	
+} (build));
+
 class BitcoinConnectorError extends Error {
     constructor(message) {
         super(message);
@@ -4742,10 +4923,13 @@ class KeplrConnector {
             address: account,
         };
     }
+    async signMessage(message) {
+        return this.getProvider.signMessage(message, build.BitcoinSignMessageType.BIP322_SIMPLE);
+    }
 }
 
-bitcoin.initEccLib(ecc);
-const network = bitcoin.networks.bitcoin;
+bitcoin$1.initEccLib(ecc);
+const network = bitcoin$1.networks.bitcoin;
 const fromHexString = (hexString) => {
     const matches = hexString.match(/.{1,2}/g);
     if (!matches) {
@@ -4780,11 +4964,11 @@ async function createSendBtcPsbt(senderAddress, recipientAddress, amount) {
     const transactionSize = inputs.length * 150 + outputsCount * 34 + 10;
     const fee = feeRate * transactionSize;
     const satsNeeded = fee + amount;
-    const psbt = new bitcoin.Psbt({ network });
+    const psbt = new bitcoin$1.Psbt({ network });
     let amountGathered = 0;
     for (const utxo of sortedUtxos) {
         const { txid, vout, value } = utxo;
-        const script = bitcoin.address.toOutputScript(senderAddress, network);
+        const script = bitcoin$1.address.toOutputScript(senderAddress, network);
         psbt.addInput({
             hash: txid,
             index: vout,
@@ -4832,7 +5016,7 @@ async function getTransactionStatus$1(txHash) {
         .then((response) => response.data);
 }
 
-const MAINNET = bitcoin.networks.bitcoin;
+const MAINNET = bitcoin$1.networks.bitcoin;
 class PhantomConnector {
     get getProvider() {
         const provider = window?.phantom?.bitcoin;
@@ -4863,7 +5047,7 @@ class PhantomConnector {
     }
     async signPsbt(psbtHex) {
         const { address: paymentAddress } = await this.requestAccount();
-        const toSignPsbt = bitcoin.Psbt.fromHex(String(psbtHex), {
+        const toSignPsbt = bitcoin$1.Psbt.fromHex(String(psbtHex), {
             network: MAINNET,
         });
         const inputs = toSignPsbt.data.inputs;
@@ -4877,7 +5061,7 @@ class PhantomConnector {
         const signedPsbtBytes = await this.getProvider.signPSBT(fromHexString(psbtHex), {
             inputsToSign,
         });
-        const signedPsbt = bitcoin.Psbt.fromBuffer(signedPsbtBytes);
+        const signedPsbt = bitcoin$1.Psbt.fromBuffer(signedPsbtBytes);
         signedPsbt.finalizeAllInputs();
         const tx = signedPsbt.extractTransaction();
         const txId = await broadcastTx(tx.toHex());
@@ -4885,6 +5069,7 @@ class PhantomConnector {
     }
 }
 
+const UNISAT_BIP322_SIMPLE_SIGNATURE_TYPE = "bip322-simple";
 class UnisatConnector {
     get getProvider() {
         const provider = window?.unisat;
@@ -4910,8 +5095,220 @@ class UnisatConnector {
             address: account,
         };
     }
+    async signMessage(message) {
+        const signMessage = this.getProvider.signMessage;
+        if (typeof signMessage !== "function") {
+            throw new Error("Unisat does not expose Bitcoin message signing.");
+        }
+        return signMessage(message, UNISAT_BIP322_SIMPLE_SIGNATURE_TYPE);
+    }
 }
 
+function encodeUtf8(value) {
+    return new TextEncoder().encode(value);
+}
+function bytesToBase64(bytes) {
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(Uint8Array.from(bytes)).toString("base64");
+    }
+    let binary = "";
+    for (let index = 0; index < bytes.length; index += 1) {
+        binary += String.fromCharCode(bytes[index]);
+    }
+    return btoa(binary);
+}
+function isBase64(value) {
+    const trimmedValue = value.trim();
+    if (!trimmedValue) {
+        return false;
+    }
+    try {
+        if (typeof Buffer !== "undefined") {
+            return (Buffer.from(trimmedValue, "base64")
+                .toString("base64")
+                .replace(/=+$/, "") === trimmedValue.replace(/=+$/, ""));
+        }
+        return (btoa(atob(trimmedValue)).replace(/=+$/, "") ===
+            trimmedValue.replace(/=+$/, ""));
+    }
+    catch {
+        return false;
+    }
+}
+function base64StringOrBytes(value) {
+    if (typeof value === "string") {
+        return isBase64(value) ? value : bytesToBase64(encodeUtf8(value));
+    }
+    return bytesToBase64(value);
+}
+function normalizeBase64Ed25519Signature(signature) {
+    if (!isBase64(signature) || typeof Buffer === "undefined") {
+        return signature;
+    }
+    const decoded = Buffer.from(signature, "base64");
+    if (decoded.length === 64) {
+        return signature;
+    }
+    const nestedSignature = decoded.toString("utf8");
+    return isBase64(nestedSignature) &&
+        Buffer.from(nestedSignature, "base64").length === 64
+        ? nestedSignature
+        : signature;
+}
+function stringToUtf8Hex(value, { uppercase = false } = {}) {
+    const hex = Array.from(encodeUtf8(value), (byte) => byte.toString(16).padStart(2, "0")).join("");
+    return uppercase ? hex.toUpperCase() : hex;
+}
+
+var WalletVerificationSignatureType;
+(function (WalletVerificationSignatureType) {
+    WalletVerificationSignatureType["EVM"] = "eip191";
+    WalletVerificationSignatureType["COSMOS"] = "cosmos-adr36";
+    WalletVerificationSignatureType["BITCOIN"] = "bitcoin-bip322-simple";
+    WalletVerificationSignatureType["SOLANA"] = "solana-ed25519";
+    WalletVerificationSignatureType["SUI"] = "sui-personal-message";
+    WalletVerificationSignatureType["XRPL"] = "xrpl-signin";
+    WalletVerificationSignatureType["XAMAN"] = "xaman-signin";
+    WalletVerificationSignatureType["STELLAR"] = "stellar-sep53";
+})(WalletVerificationSignatureType || (WalletVerificationSignatureType = {}));
+const WALLET_VERIFICATION_SIGNATURE_TYPE_BY_CHAIN_TYPE = {
+    [ChainType.EVM]: WalletVerificationSignatureType.EVM,
+    [ChainType.COSMOS]: WalletVerificationSignatureType.COSMOS,
+    [ChainType.BTC]: WalletVerificationSignatureType.BITCOIN,
+    [ChainType.SOLANA]: WalletVerificationSignatureType.SOLANA,
+    [ChainType.SUI]: WalletVerificationSignatureType.SUI,
+    [ChainType.XRPL]: WalletVerificationSignatureType.XRPL,
+    [ChainType.STELLAR]: WalletVerificationSignatureType.STELLAR,
+};
+
+function buildSignatureOnlyWalletVerificationSignatureResult({ chainType, signatureType, address, message, signature, }) {
+    return {
+        chainType,
+        address,
+        message,
+        signedPayload: message,
+        signature,
+        signatureType,
+        metadata: {},
+    };
+}
+function buildSignedPayloadWalletVerificationSignatureResult({ chainType, signatureType, address, message, signedPayload, signature, publicKey, publicKeyEncoding, signedPayloadEncoding, signerAddress, }) {
+    return {
+        chainType,
+        address,
+        message,
+        signedPayload,
+        signature,
+        signatureType,
+        metadata: {
+            signedPayloadEncoding,
+            ...(publicKey ? { publicKey } : {}),
+            ...(publicKeyEncoding ? { publicKeyEncoding } : {}),
+            ...(signerAddress ? { signerAddress } : {}),
+        },
+    };
+}
+
+const buildBitcoinWalletVerificationSignatureResult = (params) => buildSignedPayloadWalletVerificationSignatureResult({
+    ...params,
+    chainType: ChainType.BTC,
+    signatureType: WalletVerificationSignatureType.BITCOIN,
+});
+
+const buildCosmosWalletVerificationSignatureResult = (params) => buildSignedPayloadWalletVerificationSignatureResult({
+    ...params,
+    chainType: ChainType.COSMOS,
+    signatureType: WalletVerificationSignatureType.COSMOS,
+});
+
+const buildWalletVerificationSignatureResult = ({ address, message, signature, }) => buildSignatureOnlyWalletVerificationSignatureResult({
+    chainType: ChainType.EVM,
+    signatureType: WalletVerificationSignatureType.EVM,
+    address,
+    message,
+    signature,
+});
+
+var WalletVerificationSignatureErrorCode;
+(function (WalletVerificationSignatureErrorCode) {
+    WalletVerificationSignatureErrorCode["INVALID_MESSAGE"] = "INVALID_MESSAGE";
+    WalletVerificationSignatureErrorCode["UNSUPPORTED_CHAIN_TYPE"] = "UNSUPPORTED_CHAIN_TYPE";
+    WalletVerificationSignatureErrorCode["WALLET_NOT_CONNECTED"] = "WALLET_NOT_CONNECTED";
+    WalletVerificationSignatureErrorCode["SIGNER_UNAVAILABLE"] = "SIGNER_UNAVAILABLE";
+    WalletVerificationSignatureErrorCode["ACTIVE_ACCOUNT_MISMATCH"] = "ACTIVE_ACCOUNT_MISMATCH";
+    WalletVerificationSignatureErrorCode["SIGNATURE_REJECTED"] = "SIGNATURE_REJECTED";
+})(WalletVerificationSignatureErrorCode || (WalletVerificationSignatureErrorCode = {}));
+class WalletVerificationSignatureError extends Error {
+    code;
+    chainType;
+    cause;
+    constructor({ code, message, chainType, cause, }) {
+        super(message);
+        this.name = "WalletVerificationSignatureError";
+        this.code = code;
+        this.chainType = chainType;
+        this.cause = cause;
+    }
+}
+
+const assertWalletVerificationSigningRequest = ({ message, chainType, }) => {
+    if (message.trim().length === 0) {
+        throw new WalletVerificationSignatureError({
+            code: WalletVerificationSignatureErrorCode.INVALID_MESSAGE,
+            chainType,
+            message: "Invalid wallet verification message.",
+        });
+    }
+};
+const assertEvmVerificationSigningRequest = ({ message, chainType, }) => {
+    if (chainType !== ChainType.EVM) {
+        throw new WalletVerificationSignatureError({
+            code: WalletVerificationSignatureErrorCode.UNSUPPORTED_CHAIN_TYPE,
+            chainType,
+            message: "Unsupported EVM wallet verification chain type.",
+        });
+    }
+    assertWalletVerificationSigningRequest({ message, chainType });
+};
+
+const buildSolanaWalletVerificationSignatureResult = ({ address, message, signedPayload, signature, publicKey, publicKeyEncoding, signedPayloadEncoding, }) => buildSignedPayloadWalletVerificationSignatureResult({
+    chainType: ChainType.SOLANA,
+    signatureType: WalletVerificationSignatureType.SOLANA,
+    address,
+    message,
+    signedPayload,
+    signature,
+    publicKey,
+    publicKeyEncoding,
+    signedPayloadEncoding,
+});
+
+const buildStellarWalletVerificationSignatureResult = (params) => buildSignedPayloadWalletVerificationSignatureResult({
+    ...params,
+    chainType: ChainType.STELLAR,
+    signatureType: WalletVerificationSignatureType.STELLAR,
+});
+
+const buildSuiWalletVerificationSignatureResult = ({ address, message, signedPayload, signature, publicKey, publicKeyEncoding, signedPayloadEncoding, }) => buildSignedPayloadWalletVerificationSignatureResult({
+    chainType: ChainType.SUI,
+    signatureType: WalletVerificationSignatureType.SUI,
+    address,
+    message,
+    signedPayload,
+    signature,
+    publicKey,
+    publicKeyEncoding,
+    signedPayloadEncoding,
+});
+
+const buildXrplWalletVerificationSignatureResult = (params) => {
+    return buildSignedPayloadWalletVerificationSignatureResult({
+        ...params,
+        chainType: ChainType.XRPL,
+        signatureType: params.signatureType,
+    });
+};
+
 var XrplTransactionType;
 (function (XrplTransactionType) {
     XrplTransactionType["PAYMENT"] = "Payment";
@@ -4958,6 +5355,14 @@ var XRPL_METHOD;
     XRPL_METHOD["SIGN_TRANSACTION"] = "xrpl_signTransaction";
 })(XRPL_METHOD || (XRPL_METHOD = {}));
 
+function createXrplActiveAccountMismatchError(walletName) {
+    return new WalletVerificationSignatureError({
+        code: WalletVerificationSignatureErrorCode.ACTIVE_ACCOUNT_MISMATCH,
+        chainType: ChainType.XRPL,
+        message: `${walletName} signed with a different active account. Reconnect the XRPL wallet and try again.`,
+    });
+}
+
 var NetworkLabel;
 (function (NetworkLabel) {
     NetworkLabel["XAHAU"] = "xahau";
@@ -5010,6 +5415,38 @@ class CrossmarkConnector {
             status: data.resp.result.meta.TransactionResult,
         };
     }
+    async signOwnershipMessage({ address, message, }) {
+        const provider = this.getProvider();
+        if (!provider) {
+            throw new Error("Crossmark provider not found");
+        }
+        const signedPayload = stringToUtf8Hex(message);
+        const result = await provider.async.signInAndWait(signedPayload);
+        const proof = result?.response.data;
+        if (!proof) {
+            throw new Error("Invalid Crossmark sign-in response");
+        }
+        if (proof.meta?.isRejected) {
+            throw new Error("User rejected the request.");
+        }
+        if (proof.meta?.isError) {
+            throw new Error(proof.errorMessage || "Error signing message");
+        }
+        if (proof.address.trim() !== address) {
+            throw createXrplActiveAccountMismatchError("Crossmark");
+        }
+        if (!proof.publicKey || !proof.signature) {
+            throw new Error("Invalid Crossmark sign-in response");
+        }
+        return {
+            signedPayload,
+            signedPayloadEncoding: "utf8-hex",
+            signature: proof.signature,
+            publicKey: proof.publicKey,
+            publicKeyEncoding: "hex",
+            signatureType: WalletVerificationSignatureType.XRPL,
+        };
+    }
     getActiveNetwork() {
         const provider = this.getProvider();
         if (!provider) {
@@ -20388,6 +20825,34 @@ class XrplMetamaskSnapConnector {
             status: txStatus,
         };
     }
+    async signOwnershipMessage({ address, message, }) {
+        await this.initialize();
+        if (!this.provider)
+            throw new Error("Provider not initialized");
+        await this.requestSnap(snapId);
+        const account = await this.getAccount();
+        if (account.account !== address) {
+            throw createXrplActiveAccountMismatchError("XRPL Snap");
+        }
+        const signedPayload = stringToUtf8Hex(message);
+        const response = await this.invokeSnap({
+            method: "xrpl_signMessage",
+            params: {
+                message: signedPayload,
+            },
+        });
+        if (!account.publicKey || !response.signature) {
+            throw new Error("Invalid XRPL Snap sign-message response");
+        }
+        return {
+            signedPayload,
+            signedPayloadEncoding: "utf8-hex",
+            signature: response.signature,
+            publicKey: account.publicKey,
+            publicKeyEncoding: "hex",
+            signatureType: WalletVerificationSignatureType.XRPL,
+        };
+    }
     // Cannot use constructor because of the async initialization
     async initialize() {
         this.provider = await this.getProvider();
@@ -20858,18 +21323,6 @@ const isBitcoinAddressValid = (address$1) => {
     }
 };
 
-// Canton PartyID = address
-const CANTON_PARTY_ID_SEPARATOR = "::";
-function isCantonAddressValid(address) {
-    // Canton address format: `name::fingerprint`, where name is an arbitrary string
-    // and fingerprint is a 64-character hex string with a 1220 prefix (SHA-256 hash of the public key)
-    const parts = address.split(CANTON_PARTY_ID_SEPARATOR);
-    if (parts.length !== 2)
-        return false;
-    const [name, fingerprint] = parts;
-    return name.length > 0 && /^1220[0-9a-f]{64}$/.test(fingerprint);
-}
-
 var HistoryTxType;
 (function (HistoryTxType) {
     HistoryTxType[HistoryTxType["SWAP"] = 0] = "SWAP";
@@ -20983,7 +21436,6 @@ const getSourceExplorerTxUrl = (chain, txID) => {
         case CHAIN_IDS.AGORIC:
         case CHAIN_IDS.XRPL:
         case CHAIN_IDS.XRPL_TESTNET:
-        case CHAIN_IDS.CANTON:
             txSuffix = "/transactions/";
             break;
         case CHAIN_IDS.HEDERA:
@@ -21093,16 +21545,10 @@ const simplifyRouteAction = (action) => {
 };
 const fetchSwapTransactionStatus = async ({ transaction, integratorId, apiUrl, }) => {
     const statusEndpoint = `${apiUrl}/v2/status`;
-    const isCanton = transaction?.fromChain === CHAIN_IDS.CANTON;
-    // For Canton, the backend handles all tx detection/submission from the quoteId
-    // alone, so no transactionId is sent — only the quoteId param below.
-    const transactionId = isCanton
-        ? undefined
-        : transaction?.transactionIdForStatus ?? transaction?.transactionId;
     try {
         const response = await axios.get(statusEndpoint, {
             params: {
-                transactionId,
+                transactionId: transaction?.transactionIdForStatus ?? transaction?.transactionId,
                 fromChainId: transaction?.fromChain,
                 toChainId: transaction?.toChain,
                 bridgeType: transaction?.bridgeType,
@@ -21149,7 +21595,7 @@ function isActionCompletedOnSourceTx(action, fromChainId) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-const isChainflipDepositRoute = (route) => {
+const isDepositRoute = (route) => {
     return (!!route &&
         route.transactionRequest?.type === SquidDataType.ChainflipDepositAddress);
 };
@@ -21174,12 +21620,6 @@ function isOnChainTxData(squidData) {
         SquidDataType.DepositAddressWithMemo,
     ].includes(squidData.type);
 }
-/**
- * Checks if a route is of type DepositAddressDirectTransfer
- */
-function isDepositAddressDirectTransferRoute(squidData) {
-    return (squidData.type === SquidDataType.DepositAddressDirectTransfer);
-}
 function getHistoryTransactionId(tx) {
     switch (tx.txType) {
         case HistoryTxType.SWAP:
@@ -21318,6 +21758,93 @@ const standardWalletOverrides = {
     }),
 };
 
+const EvmNetworkNotSupportedErrorCode = 4902;
+async function addEthereumChain({ chain, provider, }) {
+    const chainName = chain.rpc.includes("tenderly")
+        ? `${chain.networkName} Tenderly fork`
+        : chain.networkName;
+    const chainParameters = {
+        chainId: `0x${parseInt(chain.chainId, 10).toString(16)}`,
+        chainName,
+        nativeCurrency: chain.nativeCurrency,
+        rpcUrls: [chain.rpc],
+        blockExplorerUrls: chain.blockExplorerUrls,
+        iconUrls: [chain.chainIconURI],
+    };
+    try {
+        return provider.request({
+            method: "wallet_addEthereumChain",
+            params: [chainParameters],
+        });
+    }
+    catch (error) {
+        console.debug("Error adding chain:", error);
+    }
+}
+const parseEvmAddress = (address) => {
+    if (address && isEvmAddressValid(address)) {
+        return address;
+    }
+};
+function isEvmAddressValid(address) {
+    return isAddress(address);
+}
+/**
+ * Formats a Wagmi connector into a Squid Wallet
+ */
+function formatEvmWallet(connector) {
+    const { icon, name: defaultName, id: wagmiConnectorId } = connector;
+    const walletOverrides = standardWalletOverrides[wagmiConnectorId];
+    const walletIcon = walletOverrides?.icon || icon;
+    const name = walletOverrides?.name || defaultName;
+    const connectorId = walletOverrides?.connectorId || wagmiConnectorId;
+    const isNonInstallableWallet = [
+        "injected",
+        "walletConnect",
+        "metaMaskSDK",
+        "coinbaseWalletSDK",
+    ].includes(wagmiConnectorId);
+    return {
+        connectorId,
+        name,
+        connectorName: name,
+        type: ChainType.EVM,
+        icon: walletIcon,
+        rdns: wagmiConnectorId,
+        windowFlag: name,
+        // For non-installable wallets, we don't want to show the "Installed" label
+        // but still want to allow the user to connect
+        skipInstallCheck: isNonInstallableWallet,
+        isInstalled: isNonInstallableWallet ? undefined : () => true,
+        connector,
+        isMobile: true,
+    };
+}
+function filterWagmiConnector(connector) {
+    // Safe is auto-connected when available, should not be listed as an available wallet
+    return connector.id !== "safe";
+}
+/**
+ * Waits for a transaction receipt, handling retries if indexing is in progress
+ */
+async function waitForReceiptWithRetry(txResponse, retries = 5, delayMs = 2000) {
+    let lastError;
+    for (let i = 0; i < retries; i++) {
+        try {
+            return await txResponse.wait();
+        }
+        catch (error) {
+            lastError = error;
+            if (error?.message?.match(/transaction indexing is in progress/i)) {
+                await sleep(delayMs);
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw lastError;
+}
+
 const SOLANA_FEATURES = ["solana:signTransaction"];
 /**
  * Validates that a given standard wallet has all the required features for a Solana wallet
@@ -21619,6 +22146,7 @@ function formatSuiWallet(wallet) {
         skipInstallCheck: isSlushWebWallet,
         connector: {
             signTransaction: features["sui:signTransaction"].signTransaction,
+            signPersonalMessage: features["sui:signPersonalMessage"]?.signPersonalMessage,
             connect: async (params) => {
                 const { accounts } = await features["standard:connect"].connect(params);
                 if (!accounts.length) {
@@ -21682,17 +22210,7 @@ const chainTypeToTrimLength = {
         start: 4,
         end: 4,
     },
-    // abc...123::abc...123
-    [ChainType.CANTON]: {
-        start: 3,
-        end: 3,
-    },
 };
-const truncateWithEllipsis = (value, startLength, endLength) => value.length <= startLength + endLength
-    ? value
-    : value.slice(0, startLength) +
-        "..." +
-        value.slice(value.length - endLength);
 const formatHash = ({ chainType, hash }) => {
     if (!hash)
         return "";
@@ -21705,22 +22223,21 @@ const formatHash = ({ chainType, hash }) => {
             chainTypeFormat = ChainType.COSMOS;
         }
     }
-    const { start, end } = chainTypeToTrimLength[chainTypeFormat];
-    if (chainTypeFormat === ChainType.CANTON &&
-        hash.includes(CANTON_PARTY_ID_SEPARATOR)) {
-        const [namespace, identifier] = hash.split(CANTON_PARTY_ID_SEPARATOR);
-        return (truncateWithEllipsis(namespace, start, end) +
-            CANTON_PARTY_ID_SEPARATOR +
-            truncateWithEllipsis(identifier, start, end));
-    }
-    return truncateWithEllipsis(hash, start, end);
+    const trimLengthStart = chainTypeToTrimLength[chainTypeFormat].start;
+    const trimLengthEnd = chainTypeToTrimLength[chainTypeFormat].end;
+    // return the same hash if its length is less than the trim length
+    if (hash.length <= trimLengthStart + trimLengthEnd)
+        return hash;
+    return (hash.slice(0, trimLengthStart) +
+        "..." +
+        hash.slice(hash.length - trimLengthEnd, hash.length));
 };
 const isWalletAddressValid = (chainData, address) => {
     if (!address || !chainData?.chainType)
         return false;
     switch (chainData.chainType) {
         case ChainType.EVM:
-            return isAddress(address);
+            return isEvmAddressValid(address);
         case ChainType.COSMOS:
             return isCosmosAddressValid(chainData.bech32Config.bech32PrefixAccAddr, address);
         case ChainType.BTC:
@@ -21733,8 +22250,6 @@ const isWalletAddressValid = (chainData, address) => {
             return isXrplAddressValid(address);
         case ChainType.STELLAR:
             return isStellarAddressValid(address);
-        case ChainType.CANTON:
-            return isCantonAddressValid(address);
     }
 };
 const redirectToExtensionsStore = (wallet) => {
@@ -21996,8 +22511,6 @@ const connectByChainType = async (chainType, wallet, defaultChain, params) => {
                     connector,
                 },
             });
-        case ChainType.CANTON:
-            return null;
     }
 };
 const getChainTypesToConnect = (selectedChainTypes, defaultChain, supportedChains) => {
@@ -22275,6 +22788,17 @@ class EnsService {
     }
 }
 
+const XAMAN_OWNERSHIP_CHALLENGE_MEMO_TYPE = "squid-history-challenge";
+function getXamanNetwork(network) {
+    switch (network) {
+        case XrplNetwork.MAINNET:
+            return XamanXrplNetwork.MAINNET;
+        case XrplNetwork.TESTNET:
+            return XamanXrplNetwork.TESTNET;
+        default:
+            throw new Error(`Network ${network} is not supported`);
+    }
+}
 /**
  * Client to interact with the Xaman backend through a Squid proxy.
  * Retrieves the QR code data for the following methods:
@@ -22283,38 +22807,54 @@ class EnsService {
  * - send tx
  */
 class XamanClient {
-    static baseUrl = XAMAN_API_URL;
-    static async signIn(signal) {
+    static defaultBaseUrl = XAMAN_API_URL;
+    baseUrl;
+    constructor({ baseUrl = XAMAN_API_URL } = {}) {
+        this.baseUrl = baseUrl;
+    }
+    async signIn(signal) {
         return this.fetch("sign-in", undefined, signal);
     }
-    static async userSession(payload, signal) {
+    async userSession(payload, signal) {
         return this.fetch("user-session", { payload }, signal);
     }
-    static async sendTx({ tx, signal, network, }) {
-        const xamanNetwork = this.getXamanNetwork(network);
+    /**
+     * Requests a Xaman SignIn payload for wallet ownership verification.
+     *
+     * Expected proxy endpoint: POST /xaman/sign-ownership-message with
+     * `{ message }`, returning the same QR/deeplink/websocket shape as sign-in.
+     * The backend should create a SignIn payload whose signed Memo contains:
+     * - MemoType: UTF-8 hex for the Xaman ownership challenge memo
+     * - MemoData: UTF-8 hex for the challenge message
+     */
+    async signOwnershipMessage(message, signal) {
+        return this.fetch("sign-ownership-message", { message }, signal);
+    }
+    async sendTx({ tx, signal, network, }) {
+        const xamanNetwork = getXamanNetwork(network);
         return this.fetch("send-tx", { tx, network: xamanNetwork }, signal);
     }
-    static async fetch(endpoint, body, signal) {
-        const url = new URL(endpoint, this.baseUrl);
+    async fetch(endpoint, body, signal) {
+        const url = this.createUrl(endpoint);
         const res = await fetch(url.toString(), {
             method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
             body: body != null ? JSON.stringify(body) : undefined,
             signal,
         });
         if (!res.ok) {
-            throw new Error(`Request failed with status ${res.status}`);
+            const errorBody = await res.text().catch(() => "");
+            throw new Error(`Request failed with status ${res.status}${errorBody ? `: ${errorBody}` : ""}`);
         }
         return res.json();
     }
-    static getXamanNetwork(network) {
-        switch (network) {
-            case XrplNetwork.MAINNET:
-                return XamanXrplNetwork.MAINNET;
-            case XrplNetwork.TESTNET:
-                return XamanXrplNetwork.TESTNET;
-            default:
-                throw new Error(`Network ${network} is not supported`);
-        }
+    createUrl(endpoint) {
+        const baseUrl = this.baseUrl.startsWith("/") && typeof window !== "undefined"
+            ? new URL(this.baseUrl, window.location.origin).toString()
+            : this.baseUrl;
+        return new URL(endpoint, baseUrl);
     }
 }
 function isXamanXAppContext() {
@@ -22647,6 +23187,7 @@ const getConfigWithDefaults = (config) => {
         slippage: get$2(config, "slippage", defaultConfigValues.slippage),
         collectFees: get$2(config, "collectFees", defaultConfigValues.collectFees),
         apiUrl: get$2(config, "apiUrl", defaultConfigValues.apiUrl),
+        xamanApiUrl: get$2(config, "xamanApiUrl", defaultConfigValues.xamanApiUrl),
         priceImpactWarnings: get$2(config, "priceImpactWarnings", defaultConfigValues.priceImpactWarnings),
         initialAssets: get$2(config, "initialAssets", defaultConfigValues.initialAssets),
         defaultTokensPerChain: get$2(config, "defaultTokensPerChain", defaultConfigValues.defaultTokensPerChain),
@@ -23072,10 +23613,7 @@ const getNewSwapParamsFromInput = ({ inputParams, initialSwapRoute, tokens, chai
     else {
         newFallbackAddress = fallbackAddress ?? initialSwapRoute?.fallbackAddress;
     }
-    const sourceChainChanged = fromChainId !== undefined && fromChainId !== initialSwapRoute?.fromChainId;
-    const newDepositRefundAddress = sourceChainChanged
-        ? undefined
-        : depositRefundAddress || initialSwapRoute?.depositRefundAddress;
+    const newDepositRefundAddress = depositRefundAddress || initialSwapRoute?.depositRefundAddress;
     return {
         fromChainId: srcChainId,
         fromTokenAddress: sourceTokenAddress,
@@ -23354,7 +23892,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-DOOg6zVn.js');
+    const { fetchAllSecretBalances } = await import('./secretService-B2i6U8uo.js');
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -23381,29 +23919,9 @@ async function fetchAssetsColors() {
         };
     }
 }
-const supportedChainTypes = new Set(Object.values(ChainType));
-function isSupportedChainType(chainType) {
-    return supportedChainTypes.has(chainType);
-}
-/**
- * Normalizes SDK data after each init/refetch before the rest of hooks consumes it.
- *
- * - Removes chains whose chainType is not supported by the local package.
- * - Drops tokens for those removed chains.
- * - Converts Evmos chains/tokens to EVM.
- * - Applies optional asset colors.
- */
-function initializeSquidData(squid, assetsColors = {
-    chains: {},
-    tokens: {},
-}) {
-    const supportedChains = squid.chains.filter((chain) => isSupportedChainType(chain.chainType));
-    const supportedChainIds = new Set(supportedChains.map((chain) => chain.chainId));
-    const evmosChainIds = supportedChains
-        .filter(isEvmosChain)
-        .map((c) => c.chainId);
-    const supportedTokens = squid.tokens.filter((token) => supportedChainIds.has(token.chainId));
-    squid.tokens = supportedTokens.map((token) => {
+function initializeSquidWithAssetsColors(squid, assetsColors) {
+    const evmosChainIds = squid.chains.filter(isEvmosChain).map((c) => c.chainId);
+    squid.tokens = squid.tokens.map((token) => {
         const isEvmosToken = evmosChainIds.includes(token.chainId);
         return {
             ...token,
@@ -23412,7 +23930,7 @@ function initializeSquidData(squid, assetsColors = {
             textColor: assetsColors.tokens[getTokenAssetsKey(token)]?.textColor,
         };
     });
-    squid.chains = supportedChains.map((chain) => {
+    squid.chains = squid.chains.map((chain) => {
         const bgColor = assetsColors.chains[chain.chainId]?.bgColor;
         // convert evmos cosmos chains to evm chains
         // TODO: this will be fixed in the backend
@@ -23482,90 +24000,6 @@ function convertEvmosToEvmChain(cosmosChain) {
     };
 }
 
-const EvmNetworkNotSupportedErrorCode = 4902;
-async function addEthereumChain({ chain, provider, }) {
-    const chainName = chain.rpc.includes("tenderly")
-        ? `${chain.networkName} Tenderly fork`
-        : chain.networkName;
-    const chainParameters = {
-        chainId: `0x${parseInt(chain.chainId, 10).toString(16)}`,
-        chainName,
-        nativeCurrency: chain.nativeCurrency,
-        rpcUrls: [chain.rpc],
-        blockExplorerUrls: chain.blockExplorerUrls,
-        iconUrls: [chain.chainIconURI],
-    };
-    try {
-        return provider.request({
-            method: "wallet_addEthereumChain",
-            params: [chainParameters],
-        });
-    }
-    catch (error) {
-        console.debug("Error adding chain:", error);
-    }
-}
-const parseEvmAddress = (address) => {
-    if (address && isAddress(address)) {
-        return address;
-    }
-};
-/**
- * Formats a Wagmi connector into a Squid Wallet
- */
-function formatEvmWallet(connector) {
-    const { icon, name: defaultName, id: wagmiConnectorId } = connector;
-    const walletOverrides = standardWalletOverrides[wagmiConnectorId];
-    const walletIcon = walletOverrides?.icon || icon;
-    const name = walletOverrides?.name || defaultName;
-    const connectorId = walletOverrides?.connectorId || wagmiConnectorId;
-    const isNonInstallableWallet = [
-        "injected",
-        "walletConnect",
-        "metaMaskSDK",
-        "coinbaseWalletSDK",
-    ].includes(wagmiConnectorId);
-    return {
-        connectorId,
-        name,
-        connectorName: name,
-        type: ChainType.EVM,
-        icon: walletIcon,
-        rdns: wagmiConnectorId,
-        windowFlag: name,
-        // For non-installable wallets, we don't want to show the "Installed" label
-        // but still want to allow the user to connect
-        skipInstallCheck: isNonInstallableWallet,
-        isInstalled: isNonInstallableWallet ? undefined : () => true,
-        connector,
-        isMobile: true,
-    };
-}
-function filterWagmiConnector(connector) {
-    // Safe is auto-connected when available, should not be listed as an available wallet
-    return connector.id !== "safe";
-}
-/**
- * Waits for a transaction receipt, handling retries if indexing is in progress
- */
-async function waitForReceiptWithRetry(txResponse, retries = 5, delayMs = 2000) {
-    let lastError;
-    for (let i = 0; i < retries; i++) {
-        try {
-            return await txResponse.wait();
-        }
-        catch (error) {
-            lastError = error;
-            if (error?.message?.match(/transaction indexing is in progress/i)) {
-                await sleep(delayMs);
-                continue;
-            }
-            throw error;
-        }
-    }
-    throw lastError;
-}
-
 const countryCurrencyMap = [
     {
         currencyCode: "AED",
@@ -25289,7 +25723,7 @@ const useSquid = () => {
         queryFn: async () => {
             if (squid) {
                 await squid?.init();
-                initializeSquidData(squid, assetsColors);
+                initializeSquidWithAssetsColors(squid, assetsColors);
                 return squid;
             }
             return null;
@@ -25348,7 +25782,7 @@ const useSquidTokens = (direction) => {
         config.availableChains,
         direction,
     ]);
-    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = useMemo(() => {
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, } = useMemo(() => {
         return tokens?.reduce((acc, token) => {
             switch (token.type) {
                 case ChainType.EVM:
@@ -25372,9 +25806,6 @@ const useSquidTokens = (direction) => {
                 case ChainType.STELLAR:
                     acc.stellarTokens.push(token);
                     break;
-                case ChainType.CANTON:
-                    acc.cantonTokens.push(token);
-                    break;
             }
             return acc;
         }, {
@@ -25385,7 +25816,6 @@ const useSquidTokens = (direction) => {
             suiTokens: [],
             xrplTokens: [],
             stellarTokens: [],
-            cantonTokens: [],
         });
     }, [tokens]);
     const findToken = useCallback((address, chainId) => {
@@ -25403,7 +25833,6 @@ const useSquidTokens = (direction) => {
         suiTokens,
         xrplTokens,
         stellarTokens,
-        cantonTokens,
     };
 };
 
@@ -25941,7 +26370,6 @@ const chainTypeToRefetchInterval = {
     [ChainType.SUI]: 1_000,
     [ChainType.XRPL]: 1_000,
     [ChainType.STELLAR]: 1_000,
-    [ChainType.CANTON]: 1_000,
 };
 /**
  * Returns the status refetch interval of a Send transaction
@@ -26208,7 +26636,7 @@ const useSquidChains = (direction) => {
         const chain = findChain(chainId);
         return chain?.chainType;
     }, [findChain]);
-    const { evmChains, cosmosChains, suiChains, stellarChains, xrplChains, cantonChains, } = useMemo(() => {
+    const { evmChains, cosmosChains, suiChains, stellarChains, xrplChains } = useMemo(() => {
         return chains.reduce((acc, chain) => {
             switch (chain.chainType) {
                 case ChainType.EVM:
@@ -26226,9 +26654,6 @@ const useSquidChains = (direction) => {
                 case ChainType.STELLAR:
                     acc.stellarChains.push(chain);
                     break;
-                case ChainType.CANTON:
-                    acc.cantonChains.push(chain);
-                    break;
             }
             return acc;
         }, {
@@ -26237,7 +26662,6 @@ const useSquidChains = (direction) => {
             suiChains: [],
             xrplChains: [],
             stellarChains: [],
-            cantonChains: [],
         });
     }, [chains]);
     const { supportedSourceChains, supportedDestinationChains } = useMemo(() => {
@@ -26258,7 +26682,6 @@ const useSquidChains = (direction) => {
         suiChains,
         xrplChains,
         stellarChains,
-        cantonChains,
         getChainType,
         findChain,
     };
@@ -26783,7 +27206,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.mjs');
-                const { formatStellarWallet } = await import('./stellarService.client-C-pOt34O.js');
+                const { formatStellarWallet } = await import('./stellarService.client-D20h9JPG.js');
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -26963,6 +27386,56 @@ class XamanConnector {
             this.xumm = await getXummClient();
         }
     }
+    async runPayloadFlow({ txPayload, onSigned, }) {
+        this.validateXummInitialized();
+        if (!this.xumm.xapp) {
+            throw new Error("Not in xApp context");
+        }
+        if (!this.xumm.payload) {
+            throw new Error("Payload not available");
+        }
+        await this.xumm.xapp.openSignRequest(txPayload);
+        return new Promise((resolve, reject) => {
+            this.validateXummInitialized();
+            const unsubscribe = () => {
+                this.xumm?.off("payload", handlePayload);
+            };
+            const rejectAndUnsubscribe = (error) => {
+                unsubscribe();
+                reject(error);
+            };
+            const handlePayload = async (data) => {
+                this.validateXummInitialized();
+                if (!data) {
+                    return;
+                }
+                if (data.reason === "DECLINED") {
+                    rejectAndUnsubscribe(new Error("User rejected the request."));
+                    return;
+                }
+                if (data.reason !== "SIGNED") {
+                    return;
+                }
+                if (!this.xumm.payload) {
+                    rejectAndUnsubscribe(new Error("Payload not available"));
+                    return;
+                }
+                try {
+                    const fullPayload = await this.xumm.payload.get(data.uuid);
+                    if (!fullPayload) {
+                        throw new Error("Invalid Xaman payload response");
+                    }
+                    unsubscribe();
+                    const response = await onSigned(fullPayload);
+                    resolve(response);
+                }
+                catch (error) {
+                    rejectAndUnsubscribe(error);
+                }
+            };
+            this.xumm.on("payload", handlePayload);
+        });
+    }
     async connect() {
         await this.initializeXumm();
         this.validateXummInitialized();
@@ -26980,7 +27453,7 @@ class XamanConnector {
         if (!this.xumm.payload) {
             throw new Error("Payload not available");
         }
-        const xamanNetwork = XamanClient.getXamanNetwork(network);
+        const xamanNetwork = getXamanNetwork(network);
         const txPayload = await this.xumm.payload.create({
             TransactionType: XrplTransactionType.PAYMENT,
             options: {
@@ -26988,33 +27461,65 @@ class XamanConnector {
             },
             txjson: tx,
         });
-        await this.xumm.xapp.openSignRequest(txPayload);
-        const response = await new Promise((resolve, reject) => {
-            this.validateXummInitialized();
-            if (!this.xumm.xapp) {
-                reject(new Error("Not in xApp context"));
-            }
-            this.xumm.on("payload", async (data) => {
-                this.validateXummInitialized();
-                if (data && data.reason === "DECLINED") {
-                    reject(new Error("User rejected the request."));
+        const response = await this.runPayloadFlow({
+            txPayload,
+            onSigned: (fullPayload) => {
+                if (!fullPayload.response.txid) {
+                    throw new Error("Transaction hash not found");
                 }
-                if (data && data.reason === "SIGNED") {
-                    if (!this.xumm.payload) {
-                        throw new Error("Payload not available");
-                    }
-                    const fullPayload = await this.xumm.payload.get(data.uuid);
-                    if (fullPayload?.response.txid) {
-                        resolve({
-                            hash: fullPayload.response.txid,
-                            status: XrplTxStatus.SUCCESS,
-                        });
-                    }
-                    else {
-                        reject(new Error("Transaction hash not found"));
-                    }
+                return {
+                    hash: fullPayload.response.txid,
+                    status: XrplTxStatus.SUCCESS,
+                };
+            },
+        });
+        return response;
+    }
+    async signOwnershipMessage({ address, message, }) {
+        await this.initializeXumm();
+        this.validateXummInitialized();
+        if (!this.xumm.xapp) {
+            throw new Error("Not in xApp context");
+        }
+        if (!this.xumm.payload) {
+            throw new Error("Payload not available");
+        }
+        const txPayload = await this.xumm.payload.create({
+            txjson: {
+                TransactionType: "SignIn",
+                Memos: [
+                    {
+                        Memo: {
+                            MemoType: stringToUtf8Hex(XAMAN_OWNERSHIP_CHALLENGE_MEMO_TYPE, {
+                                uppercase: true,
+                            }),
+                            MemoData: stringToUtf8Hex(message, { uppercase: true }),
+                        },
+                    },
+                ],
+            },
+        });
+        if (!txPayload) {
+            throw new Error("Failed to create Xaman sign-in payload");
+        }
+        const response = await this.runPayloadFlow({
+            txPayload,
+            onSigned: (fullPayload) => {
+                const signedAddress = fullPayload.response.account;
+                const signedPayload = fullPayload.response.hex;
+                if (signedAddress !== address) {
+                    throw createXrplActiveAccountMismatchError("Xaman");
                 }
-            });
+                if (!signedPayload) {
+                    throw new Error("Invalid Xaman sign-in response");
+                }
+                return {
+                    signedPayload,
+                    signedPayloadEncoding: "xrpl-tx-hex",
+                    signatureType: WalletVerificationSignatureType.XAMAN,
+                    signerAddress: fullPayload.response.signer ?? undefined,
+                };
+            },
         });
         return response;
     }
@@ -27056,96 +27561,157 @@ function websocket(url, onMessage) {
 
 const genericXamanQrErrorMessage = "Failed to generate Xaman QR code";
 class XamanQrConnector {
+    xamanClient;
     cancelConnectQr = null;
     cancelSignAndSubmitQr = null;
+    cancelSignOwnershipQr = null;
+    constructor(xamanClient = new XamanClient()) {
+        this.xamanClient = xamanClient;
+    }
     cancelConnect() {
         this.cancelConnectQr?.();
     }
     cancelSignAndSubmit() {
         this.cancelSignAndSubmitQr?.();
     }
-    async connect() {
+    cancelSignOwnershipMessage() {
+        this.cancelSignOwnershipQr?.();
+    }
+    getPayloadId(message) {
+        if (!message.payload_uuidv4) {
+            throw new Error("Invalid Xaman websocket response");
+        }
+        return message.payload_uuidv4;
+    }
+    async runQrFlow({ flow, cancelMessage, setCancel, createPayload, onSigned, }) {
         const controller = new AbortController();
-        this.cancelConnectQr = () => {
-            controller.abort("User canceled the connection process");
-        };
+        setCancel(() => {
+            controller.abort(cancelMessage);
+        });
         let response;
         try {
-            response = await XamanClient.signIn(controller.signal);
+            response = await createPayload(controller.signal);
         }
-        catch (error) {
+        catch {
+            if (flow === "sign") {
+                WidgetEvents.getInstance().dispatchQrCodeGenerationFailedForSign(undefined);
+            }
             throw new QrCodeGenerationError(genericXamanQrErrorMessage);
         }
-        WidgetEvents.getInstance().dispatchQrCodeGeneratedForConnect({
-            matrix: response.qrMatrix,
-            deepLinkUrl: response.deepLinkUrl,
-        });
+        if (flow === "connect") {
+            WidgetEvents.getInstance().dispatchQrCodeGeneratedForConnect({
+                matrix: response.qrMatrix,
+                deepLinkUrl: response.deepLinkUrl,
+            });
+        }
+        else {
+            WidgetEvents.getInstance().dispatchQrCodeGeneratedForSign({
+                matrix: response.qrMatrix,
+                deepLinkUrl: response.deepLinkUrl,
+            });
+        }
         const { promise, close } = websocket(response.wsStatusUrl, (event, resolve, reject) => {
-            const msg = JSON.parse(event.data);
-            if (msg.signed === true) {
-                XamanClient.userSession(msg.payload_uuidv4).then((data) => {
-                    resolve(data.response.account);
+            let message;
+            try {
+                message = JSON.parse(event.data);
+            }
+            catch (error) {
+                reject(error);
+                return;
+            }
+            if (message.opened === true) {
+                WidgetEvents.getInstance().dispatchQrScannedAwaitingApproval({
+                    flow,
                 });
+                return;
+            }
+            if (message.signed === true) {
+                Promise.resolve(onSigned(message)).then(resolve).catch(reject);
+                return;
             }
-            else if (msg.signed === false) {
+            if (message.signed === false) {
                 reject(new Error("User rejected the request."));
             }
         });
-        this.cancelConnectQr = () => {
+        setCancel(() => {
             close();
-        };
-        const address = await promise;
-        return address;
+        });
+        return promise.finally(() => {
+            setCancel(null);
+        });
+    }
+    async connect() {
+        return this.runQrFlow({
+            flow: "connect",
+            cancelMessage: "User canceled the connection process",
+            setCancel: (cancel) => {
+                this.cancelConnectQr = cancel;
+            },
+            createPayload: (signal) => this.xamanClient.signIn(signal),
+            onSigned: async (message) => {
+                const data = await this.xamanClient.userSession(this.getPayloadId(message));
+                if (!data.response.account) {
+                    throw new Error("Invalid Xaman sign-in response");
+                }
+                return data.response.account;
+            },
+        });
     }
     async signAndSubmit({ tx, network, }) {
-        const controller = new AbortController();
-        this.cancelSignAndSubmitQr = () => {
-            controller.abort("User canceled the transaction");
-        };
-        let response;
-        try {
-            response = await XamanClient.sendTx({
+        return this.runQrFlow({
+            flow: "sign",
+            cancelMessage: "User canceled the transaction",
+            setCancel: (cancel) => {
+                this.cancelSignAndSubmitQr = cancel;
+            },
+            createPayload: (signal) => this.xamanClient.sendTx({
                 tx,
                 network,
-                signal: controller.signal,
-            });
-        }
-        catch (error) {
-            WidgetEvents.getInstance().dispatchQrCodeGenerationFailedForSign(undefined);
-            throw new QrCodeGenerationError(genericXamanQrErrorMessage);
-        }
-        WidgetEvents.getInstance().dispatchQrCodeGeneratedForSign({
-            matrix: response.qrMatrix,
-            deepLinkUrl: response.deepLinkUrl,
-        });
-        const { promise, close } = websocket(response.wsStatusUrl, (event, resolve, reject) => {
-            const msg = JSON.parse(event.data);
-            if (msg.opened === true) {
-                // User has scanned the QR code
-                WidgetEvents.getInstance().dispatchQrTxScannedAwaitingApproval(undefined);
-            }
-            else if (msg.signed === true) {
-                // Tx has been signed
-                resolve({
-                    hash: msg.txid,
+                signal,
+            }),
+            onSigned: (message) => {
+                if (!message.txid) {
+                    throw new Error("Invalid Xaman transaction response");
+                }
+                return {
+                    hash: message.txid,
                     status: XrplTxStatus.SUCCESS,
-                });
-            }
-            else if (msg.signed === false) {
-                // User rejected the transaction
-                reject(new Error("User rejected the request."));
-            }
+                };
+            },
+        });
+    }
+    async signOwnershipMessage({ address, message, }) {
+        return this.runQrFlow({
+            flow: "sign",
+            cancelMessage: "User canceled the signing process",
+            setCancel: (cancel) => {
+                this.cancelSignOwnershipQr = cancel;
+            },
+            createPayload: (signal) => this.xamanClient.signOwnershipMessage(message, signal),
+            onSigned: async (statusMessage) => {
+                const data = await this.xamanClient.userSession(this.getPayloadId(statusMessage));
+                const signedAddress = data.response.account;
+                const signedPayload = data.response.hex;
+                if (signedAddress !== address) {
+                    throw createXrplActiveAccountMismatchError("Xaman");
+                }
+                if (!signedPayload) {
+                    throw new Error("Invalid Xaman sign-in response");
+                }
+                return {
+                    signedPayload,
+                    signedPayloadEncoding: "xrpl-tx-hex",
+                    signatureType: WalletVerificationSignatureType.XAMAN,
+                    signerAddress: data.response.signer ?? undefined,
+                };
+            },
         });
-        this.cancelSignAndSubmitQr = () => {
-            close();
-        };
-        const result = await promise;
-        return result;
     }
 }
 
 function useXrplWallets() {
     const { clientWindow } = useClient();
+    const xamanApiUrl = useConfigStore((state) => state.config.xamanApiUrl);
     const wallets = useMemo(() => {
         const isXAppContext = isXamanXAppContext();
         const xamanWalletIcon = `${walletIconBaseUrl}/xaman.webp`;
@@ -27166,7 +27732,7 @@ function useXrplWallets() {
             type: ChainType.XRPL,
             name: "Xaman",
             windowFlag: WindowWalletFlag.XamanQr,
-            connector: new XamanQrConnector(),
+            connector: new XamanQrConnector(new XamanClient({ baseUrl: xamanApiUrl })),
             skipInstallCheck: true,
             isMobile: true,
             connectorId: "xaman-qr",
@@ -27180,7 +27746,7 @@ function useXrplWallets() {
             isXAppContext ? xamanXAppWallet : xamanQrWallet,
             ...populateWallets(clientWindow, xrplWallets),
         ];
-    }, [clientWindow]);
+    }, [clientWindow, xamanApiUrl]);
     return {
         wallets,
     };
@@ -27315,6 +27881,7 @@ const useWallet = () => {
             setConnectingWallet({
                 wallet,
                 status: ConnectingWalletStatus.CONNECTING,
+                qrScanned: false,
             });
             try {
                 const result = await connectWallet({
@@ -27449,11 +28016,29 @@ const useWallet = () => {
                     matrix: event.detail.matrix,
                     deepLinkUrl: event.detail.deepLinkUrl,
                 },
+                qrScanned: false,
+            });
+        };
+        const onQrWalletScannedAwaitingApproval = () => {
+            const currentState = useWalletStore.getState().connectingWalletState;
+            if (currentState.qrData == null) {
+                return;
+            }
+            setConnectingWallet({
+                ...currentState,
+                qrScanned: true,
             });
         };
+        const onQrScannedAwaitingApproval = (event) => {
+            if (event.detail.flow === "connect") {
+                onQrWalletScannedAwaitingApproval();
+            }
+        };
         WidgetEvents.getInstance().listenToWidget("qrCodeGeneratedForConnect", onQrWalletConnectData);
+        WidgetEvents.getInstance().listenToWidget("qrScannedAwaitingUserApproval", onQrScannedAwaitingApproval);
         return () => {
             WidgetEvents.getInstance().removeWidgetListener("qrCodeGeneratedForConnect", onQrWalletConnectData);
+            WidgetEvents.getInstance().removeWidgetListener("qrScannedAwaitingUserApproval", onQrScannedAwaitingApproval);
         };
     }, [setConnectingWallet]);
     return {
@@ -27482,7 +28067,6 @@ const useMultiChainWallet = (chain) => {
     const suiAddress = connectedAddresses[ChainType.SUI];
     const xrplAddress = connectedAddresses[ChainType.XRPL];
     const stellarAddress = connectedAddresses[ChainType.STELLAR];
-    const cantonAddress = connectedAddresses[ChainType.CANTON];
     // Cosmos is a special case because the address changes on every chain
     // so we can't use the default cosmos connected address
     const { data: cosmosAddress } = useCosmosForChain(chain);
@@ -27570,16 +28154,6 @@ const useMultiChainWallet = (chain) => {
                         chainType: chain.chainType,
                     }),
                 };
-            case ChainType.CANTON:
-                if (!cantonAddress)
-                    return {};
-                return {
-                    address: cantonAddress,
-                    formatted: formatHash({
-                        hash: cantonAddress,
-                        chainType: chain.chainType,
-                    }),
-                };
         }
     }, [
         chain?.chainType,
@@ -27591,7 +28165,6 @@ const useMultiChainWallet = (chain) => {
         suiAddress,
         xrplAddress,
         stellarAddress,
-        cantonAddress,
     ]);
     /**
      * Change current network for desired chain
@@ -28416,8 +28989,6 @@ async function createClient(chain) {
             return new XrplRpcClient(chain.rpc);
         case ChainType.STELLAR:
             return new StellarRpcClient(chain.rpc);
-        case ChainType.CANTON:
-            return null;
     }
 }
 
@@ -29610,7 +30181,7 @@ const useStellarBalance = ({ userAddress, chain, enabled, token, refreshInterval
 };
 
 function useNativeTokenForChain(chain) {
-    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = useSquidTokens();
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, } = useSquidTokens();
     const getTokensForChainType = () => {
         if (!chain?.chainType)
             return [];
@@ -29629,8 +30200,6 @@ function useNativeTokenForChain(chain) {
                 return xrplTokens;
             case ChainType.STELLAR:
                 return stellarTokens;
-            case ChainType.CANTON:
-                return cantonTokens;
         }
     };
     const nativeTokenForChainType = useMemo(() => {
@@ -29865,11 +30434,6 @@ const useNativeBalance = (chain) => {
                 break;
             case ChainType.STELLAR:
                 balance = nativeStellarBalance;
-                break;
-            case ChainType.CANTON:
-                // TODO: implement canton balance fetching
-                balance = undefined;
-                break;
         }
         const balanceFormatted = !!balance
             ? formatBNToReadable(balance.value, balance.decimals)
@@ -29906,9 +30470,6 @@ const useNativeBalance = (chain) => {
                 return isXrpLoading;
             case ChainType.STELLAR:
                 return isStellarLoading;
-            case ChainType.CANTON:
-                // TODO: implement canton balance fetching
-                return false;
         }
     }, [
         chain?.chainType,
@@ -30133,7 +30694,7 @@ function hederaWalletConnect(parameters) {
                 const optionalChains = config.chains.map((x) => x.id);
                 if (!optionalChains.length)
                     return;
-                const { EthereumProvider } = await import('./index.es-Cq4mUT_n.js');
+                const { EthereumProvider } = await import('./index.es-CBWh71yD.js');
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -30363,8 +30924,6 @@ const useSigner = ({ chain }) => {
                 return isXrplSignerReady;
             case ChainType.STELLAR:
                 return isStellarSignerReady;
-            case ChainType.CANTON:
-                return false;
         }
     }, [
         chain?.chainType,
@@ -30814,21 +31373,21 @@ const useSendTransactionStore = create((set, get) => ({
 
 const useDepositAddressStore = create((set) => ({
     deposit: null,
-    selectedPaymentMethod: "connectedWallet",
+    isEnabled: false,
     setDeposit: (data) => {
         set({ deposit: data });
     },
-    setPaymentMethod: (method) => {
-        set({ selectedPaymentMethod: method });
+    toggleDepositFlow: (enabled) => {
+        set({ isEnabled: enabled });
     },
 }));
 
 function useDepositAddress(squidRoute) {
-    const { selectedPaymentMethod, depositAddress } = useDepositAddressStore((state) => ({
-        selectedPaymentMethod: state.selectedPaymentMethod,
+    const { isEnabled, depositAddress } = useDepositAddressStore((state) => ({
+        isEnabled: state.isEnabled,
         depositAddress: state.deposit?.depositAddress,
     }));
-    const { setDeposit, setPaymentMethod, deposit } = useDepositAddressStore();
+    const { setDeposit, toggleDepositFlow, deposit } = useDepositAddressStore();
     const { squid } = useSquidStore();
     const { fromChain } = useSwap();
     const isAvailableAsPaymentMethod = useMemo(() => {
@@ -30837,7 +31396,6 @@ function useDepositAddress(squidRoute) {
         const chainsSupportingDepositAddress = [
             CHAIN_IDS.BITCOIN,
             CHAIN_IDS.SOLANA,
-            CHAIN_IDS.CANTON,
         ];
         return chainsSupportingDepositAddress.includes(fromChain.chainId);
     }, [fromChain?.chainId]);
@@ -30845,50 +31403,34 @@ function useDepositAddress(squidRoute) {
         return (squidRoute?.transactionRequest?.type ===
             SquidDataType.ChainflipDepositAddress);
     }, [squidRoute?.transactionRequest?.type]);
-    // Effective payment method: the user's intent clamped by what the current
-    // source chain can actually do. Reading this (instead of raw intent) is what
-    // keeps every consumer in sync — if the source chain can't use a deposit
-    // address, the effective method is "connectedWallet" immediately at read time.
-    const paymentMethod = isAvailableAsPaymentMethod
-        ? selectedPaymentMethod
-        : "connectedWallet";
-    const isDepositAddressActive = paymentMethod === "depositAddress";
+    const enable = useCallback(() => {
+        toggleDepositFlow(true);
+    }, [toggleDepositFlow]);
+    const disable = useCallback(() => {
+        toggleDepositFlow(false);
+    }, [toggleDepositFlow]);
     const closeDepositChannel = useCallback(() => {
+        toggleDepositFlow(false);
         setDeposit(null);
-    }, [setDeposit]);
+    }, [toggleDepositFlow, setDeposit]);
     const getRouteWithDeposit = useMutation(async ({ route }) => {
-        if (!squid || !route.transactionRequest)
-            throw new Error("Missing required params");
-        if (isChainflipDepositRoute(route)) {
-            const depositAddressResponse = (await squid.executeRoute({
-                signer: {},
-                route,
-            }));
-            setDeposit({
-                amount: depositAddressResponse.amount,
-                depositAddress: depositAddressResponse.depositAddress,
-                statusTrackingId: depositAddressResponse.chainflipStatusTrackingId,
-            });
-            return;
-        }
-        else if (isDepositAddressDirectTransferRoute(route.transactionRequest)) {
-            const orderHash = route.transactionRequest.data;
-            setDeposit({
-                amount: route.params.fromAmount ?? "",
-                depositAddress: route.transactionRequest.target,
-                // Squid Scan indexes the Canton tx by the orderHash
-                statusTrackingId: orderHash,
-                memo: orderHash,
-            });
-            return;
-        }
+        if (!squid)
+            throw new Error("Squid SDK not initialized");
+        const depositAddressResponse = (await squid.executeRoute({
+            signer: {},
+            route,
+        }));
+        setDeposit(depositAddressResponse);
+        return {
+            depositAddress: depositAddressResponse,
+        };
     });
     return {
-        paymentMethod,
-        isDepositAddressActive,
+        isEnabled,
         isAvailableAsPaymentMethod,
         swapWillGenerateDepositAddress,
-        setPaymentMethod,
+        enable,
+        disable,
         getRouteWithDeposit,
         depositAddress,
         closeDepositChannel,
@@ -30920,7 +31462,7 @@ const useUrlSwapParams = () => {
 
 const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, queryOptions, }) => {
     const { evmChains, cosmosChains, suiChains, xrplChains, stellarChains } = useSquidChains(direction);
-    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = useSquidTokens(direction);
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, } = useSquidTokens(direction);
     const { keplrTypeWallet } = useCosmosContext();
     const placeholderData = useMemo(() => {
         const tokens = {
@@ -30931,7 +31473,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
             [ChainType.SUI]: suiTokens.map((t) => ({ ...t, balance: "0" })),
             [ChainType.XRPL]: xrplTokens.map((t) => ({ ...t, balance: "0" })),
             [ChainType.STELLAR]: stellarTokens.map((t) => ({ ...t, balance: "0" })),
-            [ChainType.CANTON]: cantonTokens.map((t) => ({ ...t, balance: "0" })),
         };
         if (!chainType) {
             // Return all tokens with zero balance
@@ -30953,7 +31494,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         suiTokens,
         xrplTokens,
         stellarTokens,
-        cantonTokens,
     ]);
     const isQueryEnabled = useMemo(() => {
         // Respect the queryOptions.enabled override if provided
@@ -30976,8 +31516,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
                 return xrplTokens.length > 0;
             case ChainType.STELLAR:
                 return stellarTokens.length > 0;
-            case ChainType.CANTON:
-                return cantonTokens.length > 0;
         }
     }, [
         chainType,
@@ -30990,7 +31528,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         suiTokens.length,
         xrplTokens.length,
         stellarTokens.length,
-        cantonTokens.length,
     ]);
     const query = useQuery(keys().allTokensBalance(address, chainType, direction), async () => {
         // Return zero balances if no address
@@ -31100,12 +31637,6 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         direction,
         queryOptions,
     });
-    const cantonBalancesQuery = useAllTokensWithBalanceForChainType({
-        chainType: ChainType.CANTON,
-        address: connectedAddresses?.[ChainType.CANTON],
-        direction,
-        queryOptions,
-    });
     // Create a map of chain type to balance query results
     const balanceQueries = useMemo(() => ({
         [ChainType.EVM]: evmBalancesQuery,
@@ -31115,7 +31646,6 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         [ChainType.SUI]: suiBalancesQuery,
         [ChainType.XRPL]: xrplBalancesQuery,
         [ChainType.STELLAR]: stellarBalancesQuery,
-        [ChainType.CANTON]: cantonBalancesQuery,
     }), [
         evmBalancesQuery,
         cosmosBalancesQuery,
@@ -31124,7 +31654,6 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         suiBalancesQuery,
         xrplBalancesQuery,
         stellarBalancesQuery,
-        cantonBalancesQuery,
     ]);
     // Combine all tokens from different chains
     const allTokens = useMemo(() => Object.values(balanceQueries).flatMap((query) => query.data?.tokens ?? []), [balanceQueries]);
@@ -31224,9 +31753,6 @@ const useMultiChainBalance = ({ chain, token, userAddress, enabled = true, }) =>
                 return xrplBalance;
             case ChainType.STELLAR:
                 return stellarBalance;
-            case ChainType.CANTON:
-                // TODO: implement canton balance fetching
-                return "0";
         }
     }, [
         chain?.chainType,
@@ -32335,9 +32861,6 @@ function useSendTransaction({ to, amount, token, chain, }) {
                         chain,
                     });
                     break;
-                case ChainType.CANTON: {
-                    throw new Error("Not implemented");
-                }
             }
             return {
                 amount,
@@ -32541,8 +33064,6 @@ async function getSendTransactionStatus({ chain, txHash, }) {
                 txHash,
                 chain,
             });
-        case ChainType.CANTON:
-            throw new Error("Not implemented");
     }
 }
 
@@ -32566,7 +33087,7 @@ const useHistory = (txType) => {
             fromChain: tx.params.fromChain,
             fromToken: tx.params.fromToken,
             fromAddress: tx.params.fromAddress,
-            fromAmount: tx.params.fromAmount ?? "",
+            fromAmount: tx.params.fromAmount,
             toChain: tx.params.toChain,
             toToken: tx.params.toToken,
             toAddress: tx.params.toAddress,
@@ -32994,129 +33515,6 @@ const useApproval = ({ squidRoute, }) => {
     };
 };
 
-const useSwapStatusQuery = ({ transaction, retry = 25, refetchOnWindowFocus = "always", enabled = true, onStatus, onEndStatus, onNotFound, onError, }) => {
-    const config = useConfigStore((state) => state.config);
-    const isInitialized = useConfigStore((state) => state.isInitialized);
-    const [isTransactionComplete, setIsTransactionComplete] = useState(false);
-    const [refetchInterval, setRefetchInterval] = useState(getSwapTxStatusRefetchInterval(transaction));
-    const { getChainType } = useSquidChains();
-    const fetchTransactionStatusWithLatestConfig = useCallback(async () => {
-        const latestConfig = useConfigStore.getState().config;
-        return fetchSwapTransactionStatus({
-            transaction,
-            integratorId: latestConfig.integratorId,
-            apiUrl: latestConfig.apiUrl,
-        });
-    }, [transaction]);
-    const transactionStatusQuery = useQuery(keys().swapTransactionStatus(transaction?.transactionId), fetchTransactionStatusWithLatestConfig, {
-        enabled: enabled &&
-            transaction?.transactionId !== "0" &&
-            !!transaction?.transactionId &&
-            !!transaction.fromAddress &&
-            !!config.apiUrl &&
-            transaction !== undefined &&
-            !isTransactionComplete &&
-            isInitialized,
-        refetchInterval(statusResponse) {
-            if (statusResponse &&
-                transactionEndStatuses.includes(getTransactionStatus(statusResponse) ?? "")) {
-                return false;
-            }
-            return refetchInterval;
-        },
-        retryDelay: getChainType(transaction?.fromChain) === ChainType.COSMOS ? 5000 : 3000,
-        retry: getChainType(transaction?.fromChain) === ChainType.COSMOS ? 6 : retry,
-        refetchOnWindowFocus,
-        onSuccess: (statusResponse) => {
-            WidgetEvents.getInstance().dispatchSwapStatus(statusResponse.squidTransactionStatus ?? "");
-            onStatus?.({
-                status: getTransactionStatus(statusResponse) ?? "",
-                statusResponse,
-            });
-            const endStatus = getTransactionEndStatus({ statusResponse });
-            if (endStatus) {
-                setIsTransactionComplete(true);
-                onEndStatus?.({ status: endStatus, statusResponse });
-            }
-        },
-        onError: (error) => {
-            if (is404Error(error.cause)) {
-                onNotFound?.();
-                return;
-            }
-            setRefetchInterval(-1);
-            setIsTransactionComplete(true);
-            onError?.();
-        },
-    });
-    return {
-        transactionStatusQuery,
-    };
-};
-
-// Statuses that indicate the source deposit has been received and the swap is
-// now progressing — the point at which it becomes a history-backed transaction.
-const sourceReceivedStatuses = [
-    // Chainflip
-    "DEPOSIT_RECEIVED",
-    "BROADCAST_REQUESTED",
-    "COMPLETE",
-    // Canton (Squid Intents)
-    "awaiting",
-    "success",
-];
-/**
- * Tracks a generated deposit address before it becomes a persisted swap history item.
- *
- * Mirrors the hooks-first pattern of `useExecuteTransaction`: once the source deposit
- * is received, it registers the transaction in the transaction + history stores, then
- * signals the view (via `onReceived`) to navigate. The view never writes to the stores.
- */
-const useDepositTransactionStatus = ({ transaction, route, retry = 25, refetchOnWindowFocus = "always", enabled = true, onReceived, }) => {
-    const { fromChain, toChain } = useSwap();
-    const { addSwapTransaction } = useHistory();
-    const getTransaction = useTransactionStore((state) => state.getTransaction);
-    const setTransactionStoreState = useTransactionStore((state) => state.setTransactionState);
-    return useSwapStatusQuery({
-        transaction,
-        retry,
-        refetchOnWindowFocus,
-        enabled,
-        onStatus: ({ status }) => {
-            if (!sourceReceivedStatuses.includes(status))
-                return;
-            if (!transaction?.transactionId || !route?.transactionRequest)
-                return;
-            const txLocalId = transaction.transactionId;
-            if (getTransaction(txLocalId))
-                return;
-            useTransactionStore.setState({
-                txLocalId,
-                currentTransaction: undefined,
-            });
-            const tx = {
-                routeType: route.transactionRequest.type,
-                fromChain,
-                toChain,
-                fromAddress: transaction.fromAddress,
-                transactionId: txLocalId,
-                transactionIdForStatus: transaction.transactionIdForStatus,
-                quoteId: transaction.quoteId ?? "",
-                status: TransactionStatus.ONGOING,
-                sourceStatus: TransactionStatus.SUCCESS,
-                timestamp: Date.now(),
-            };
-            setTransactionStoreState(txLocalId, tx);
-            addSwapTransaction({
-                ...tx,
-                params: route.params,
-                estimate: route.estimate,
-            });
-            onReceived?.();
-        },
-    });
-};
-
 const DEFAULT_PROVIDER_IMAGE_URL = "https://raw.githubusercontent.com/0xsquid/assets/main/images/webp128/providers/squid.webp";
 const AXELAR_PROVIDER_IMAGE_URL = "https://raw.githubusercontent.com/0xsquid/assets/main/images/webp128/providers/axelar.webp";
 const useEstimate = (squidRoute) => {
@@ -34176,13 +34574,13 @@ function bytesFromBase64(b64) {
     return arr;
 }
 helpers.bytesFromBase64 = bytesFromBase64;
-const btoa = globalThis$1.btoa || ((bin) => globalThis$1.Buffer.from(bin, "binary").toString("base64"));
+const btoa$1 = globalThis$1.btoa || ((bin) => globalThis$1.Buffer.from(bin, "binary").toString("base64"));
 function base64FromBytes(arr) {
     const bin = [];
     arr.forEach((byte) => {
         bin.push(String.fromCharCode(byte));
     });
-    return btoa(bin.join(""));
+    return btoa$1(bin.join(""));
 }
 helpers.base64FromBytes = base64FromBytes;
 function omitDefault(input) {
@@ -36435,7 +36833,7 @@ const useExecuteTransaction = (squidRoute) => {
             if (!route.params.fromAddress || !route.params.toAddress) {
                 throw new Error("From or to address is required");
             }
-            const isDirectTransfer = isChainflipDepositRoute(route);
+            const isDirectTransfer = isDepositRoute(route);
             // Means it's a transfer to a deposit address
             // Instead of a Swap/Contract call using a DEX like Jupiter
             if (isDirectTransfer) {
@@ -36446,7 +36844,7 @@ const useExecuteTransaction = (squidRoute) => {
                     throw new Error("Deposit address is required");
                 }
                 const signature = await executeSolanaTransfer({
-                    amount: BigInt(route.params.fromAmount ?? ""),
+                    amount: BigInt(route.params.fromAmount),
                     target: depositData.depositAddress,
                     signer: solanaSigner,
                     connection: solanaConnection,
@@ -36456,7 +36854,7 @@ const useExecuteTransaction = (squidRoute) => {
                         const txParams = setTransactionState({
                             route,
                             txHash,
-                            transactionIdForStatus: depositData.statusTrackingId,
+                            transactionIdForStatus: depositData.chainflipStatusTrackingId,
                             userAddress: sourceUserAddress,
                             status: TransactionStatus.INITIAL_LOADING,
                             sourceStatus: TransactionStatus.ONGOING,
@@ -36507,7 +36905,7 @@ const useExecuteTransaction = (squidRoute) => {
         }
     });
     const swapMutationBitcoin = useMutation(async ({ id, route }) => {
-        const { depositAddress, amount: sendAmount, statusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
+        const { depositAddress, amount: sendAmount, chainflipStatusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
         if (!depositAddress) {
             throw new Error(`Invalid deposit address: ${depositAddress}`);
         }
@@ -36530,7 +36928,7 @@ const useExecuteTransaction = (squidRoute) => {
                     txHash,
                     // When bridging from Bitcoin we need to send the chainflipId to the status endpoint
                     // instead of the Bitcoin transaction hash
-                    transactionIdForStatus: statusTrackingId,
+                    transactionIdForStatus: chainflipStatusTrackingId,
                     userAddress: sourceUserAddress,
                     status: TransactionStatus.INITIAL_LOADING,
                     sourceStatus: TransactionStatus.ONGOING,
@@ -36978,7 +37376,7 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
     const squid = useSquidStore((state) => state.squid);
     const fallbackAddress = useSwapRoutePersistStore((store) => store.swapRoute?.fallbackAddress);
     const depositRefundAddress = useSwapRoutePersistStore((store) => store.swapRoute?.depositRefundAddress);
-    const { isDepositAddressActive } = useDepositAddress();
+    const { isAvailableAsPaymentMethod, isEnabled: isDepositAddressEnabled } = useDepositAddress();
     const getRouteMutation = useGetRoute();
     const { fromChain, toChain, fromPrice, destinationAddress: { address: destinationAddress } = {}, fromToken, toToken, } = useSwap();
     const { connectedAddress: { address: sourceConnectedAddress }, } = useMultiChainWallet(fromChain);
@@ -36986,7 +37384,7 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
     // Tokens will be sent to this address in case of swap failure
     //
     // If deposit address is not selected, we use the connected address as the source address instead
-    const sourceUserAddress = isDepositAddressActive
+    const sourceUserAddress = isDepositAddressEnabled && isAvailableAsPaymentMethod
         ? depositRefundAddress ?? sourceConnectedAddress
         : sourceConnectedAddress;
     const squidRouteQueryKeys = useMemo(() => keys().transaction(fromChain?.chainId, toChain?.chainId, toToken?.address, fromToken?.address, fromPrice, config.slippage, sourceUserAddress, config.degenMode, destinationAddress, fallbackAddress, quoteOnly, fromChain?.chainType, config.preHook, config.postHook, config.overrideGasRefundAddress), [
@@ -37131,50 +37529,94 @@ function useSendTransactionStatus({ chain, txHash, }) {
  * Fetch status of a Swap transaction
  */
 const useSwapTransactionStatus = ({ transaction, retry = 25, refetchOnWindowFocus = "always", enabled = true, }) => {
+    const config = useConfigStore((state) => state.config);
+    const isInitialized = useConfigStore((state) => state.isInitialized);
     const { replaceSwapTransactionStatus } = useHistory();
     const findTransaction = useHistoryStore((state) => state.findTransaction);
+    const [isTransactionComplete, setIsTransactionComplete] = useState(false);
+    const [refetchInterval, setRefetchInterval] = useState(getSwapTxStatusRefetchInterval(transaction));
+    const { getChainType } = useSquidChains();
     const currentHistoryItem = useMemo(() => findTransaction({
         transactionId: transaction?.transactionId,
         txType: HistoryTxType.SWAP,
     }), [findTransaction, transaction?.transactionId]);
-    const transactionStatusQuery = useSwapStatusQuery({
-        transaction,
-        retry,
-        refetchOnWindowFocus,
+    /**
+     * Transaction status endpoint
+     * Squid api is using axelar endpoint and parsing the response
+     * @returns {StatusResponse} Status response
+     */
+    const fetchTransactionStatusWithLatestConfig = useCallback(async () => {
+        const latestConfig = useConfigStore.getState().config;
+        return fetchSwapTransactionStatus({
+            transaction,
+            integratorId: latestConfig.integratorId,
+            apiUrl: latestConfig.apiUrl,
+        });
+    }, [transaction]);
+    const transactionStatusQuery = useQuery(keys().swapTransactionStatus(transaction?.transactionId), fetchTransactionStatusWithLatestConfig, {
         enabled: enabled &&
+            transaction?.transactionId !== "0" &&
+            !!transaction?.transactionId &&
+            !!transaction.fromAddress &&
+            !!config.apiUrl &&
+            transaction !== undefined &&
+            !isTransactionComplete &&
+            isInitialized &&
             !!currentHistoryItem &&
             !isHistoryTransactionEnded({
                 data: currentHistoryItem?.data,
                 txType: HistoryTxType.SWAP,
             }),
-        onEndStatus: ({ status, statusResponse }) => {
-            if (!transaction?.transactionId)
-                return;
-            replaceSwapTransactionStatus({
-                transactionId: transaction.transactionId,
-                statusResponse,
-                status,
-            });
+        refetchInterval(statusResponse) {
+            // If the status response is something telling that the transaction
+            // is finished, then store transaction history state if success
+            // And return false to indicate refetcher to stop
+            if (statusResponse &&
+                transactionEndStatuses.includes(getTransactionStatus(statusResponse) ?? "")) {
+                return false;
+            }
+            return refetchInterval; // Had to handle a variable here because after onError, we want the interval to stop
         },
-        onNotFound: () => {
-            if (!transaction?.transactionId)
-                return;
-            replaceSwapTransactionStatus({
-                transactionId: transaction.transactionId,
-                statusResponse: undefined,
-                status: TransactionStatus.NOT_FOUND,
-            });
+        // At the moment Cosmos indexing takes more time, so need more time between retries
+        retryDelay: getChainType(transaction?.fromChain) === ChainType.COSMOS ? 5000 : 3000,
+        retry: getChainType(transaction?.fromChain) === ChainType.COSMOS ? 6 : retry,
+        refetchOnWindowFocus,
+        onSuccess: (statusResponse) => {
+            // Dispatch event
+            WidgetEvents.getInstance().dispatchSwapStatus(statusResponse.squidTransactionStatus ?? "");
+            const endStatus = getTransactionEndStatus({ statusResponse });
+            if (endStatus && transaction?.transactionId) {
+                setIsTransactionComplete(true);
+                replaceSwapTransactionStatus({
+                    transactionId: transaction.transactionId,
+                    statusResponse,
+                    status: endStatus,
+                });
+            }
         },
-        onError: () => {
+        onError: (error) => {
+            // `fetchTransactionStatus` throws an error with a cause being an AxiosError
+            const is404 = is404Error(error.cause);
             if (!transaction?.transactionId)
                 return;
-            replaceSwapTransactionStatus({
-                transactionId: transaction.transactionId,
-                statusResponse: undefined,
-                status: TransactionStatus.ERROR,
-            });
+            if (is404) {
+                replaceSwapTransactionStatus({
+                    transactionId: transaction.transactionId,
+                    statusResponse: undefined,
+                    status: TransactionStatus.NOT_FOUND,
+                });
+            }
+            else {
+                setRefetchInterval(-1);
+                setIsTransactionComplete(true);
+                replaceSwapTransactionStatus({
+                    transactionId: transaction.transactionId,
+                    statusResponse: undefined,
+                    status: TransactionStatus.ERROR,
+                });
+            }
         },
-    }).transactionStatusQuery;
+    });
     return {
         transactionStatusQuery,
         latestStatus: transactionStatusQuery.data
@@ -37385,6 +37827,430 @@ const useIntegratorContext = () => {
     return { walletHandledExternally, isEmbed, widgetInIframe };
 };
 
+function wrapSignatureError({ chainType, message, error, }) {
+    if (error instanceof WalletVerificationSignatureError) {
+        throw error;
+    }
+    throw new WalletVerificationSignatureError({
+        code: WalletVerificationSignatureErrorCode.SIGNATURE_REJECTED,
+        chainType,
+        message,
+        cause: error,
+    });
+}
+function getEvmAddress({ connectedWallets, walletClient, wagmiAddress, }) {
+    return (connectedWallets[ChainType.EVM].address ??
+        walletClient?.account?.address ??
+        wagmiAddress);
+}
+
+function createBitcoinWalletVerificationSigner({ connectedWallets, }) {
+    const bitcoinWallet = connectedWallets[ChainType.BTC].wallet;
+    return {
+        sign: async ({ message }) => {
+            const bitcoinAddress = connectedWallets[ChainType.BTC].address;
+            const bitcoinConnector = bitcoinWallet?.connector;
+            const signMessage = bitcoinConnector?.signMessage;
+            if (!bitcoinAddress) {
+                throw new WalletVerificationSignatureError({
+                    code: WalletVerificationSignatureErrorCode.WALLET_NOT_CONNECTED,
+                    chainType: ChainType.BTC,
+                    message: "Connect a Bitcoin wallet before signing verification messages.",
+                });
+            }
+            if (typeof signMessage !== "function") {
+                throw new WalletVerificationSignatureError({
+                    code: WalletVerificationSignatureErrorCode.SIGNER_UNAVAILABLE,
+                    chainType: ChainType.BTC,
+                    message: "The connected Bitcoin wallet does not expose BIP-322 message signing.",
+                });
+            }
+            try {
+                const signature = await signMessage.call(bitcoinConnector, message);
+                return buildBitcoinWalletVerificationSignatureResult({
+                    address: bitcoinAddress,
+                    message,
+                    signedPayload: bytesToBase64(encodeUtf8(message)),
+                    signature,
+                    signedPayloadEncoding: "base64",
+                });
+            }
+            catch (error) {
+                wrapSignatureError({
+                    chainType: ChainType.BTC,
+                    message: "Failed to sign Bitcoin wallet verification message.",
+                    error,
+                });
+            }
+        },
+    };
+}
+
+function createCosmosWalletVerificationSigner({ connectedWallets, }) {
+    const cosmosWallet = connectedWallets[ChainType.COSMOS].wallet;
+    return {
+        sign: async ({ message, chainId }) => {
+            const cosmosAddress = connectedWallets[ChainType.COSMOS].address;
+            const provider = cosmosWallet?.connector?.().provider;
+            const signArbitrary = provider?.signArbitrary;
+            const getKey = provider?.getKey;
+            if (!cosmosAddress) {
+                throw new WalletVerificationSignatureError({
+                    code: WalletVerificationSignatureErrorCode.WALLET_NOT_CONNECTED,
+                    chainType: ChainType.COSMOS,
+                    message: "Connect a Cosmos wallet before signing verification messages.",
+                });
+            }
+            if (typeof signArbitrary !== "function" || typeof getKey !== "function") {
+                throw new WalletVerificationSignatureError({
+                    code: WalletVerificationSignatureErrorCode.SIGNER_UNAVAILABLE,
+                    chainType: ChainType.COSMOS,
+                    message: "The connected Cosmos wallet does not expose ADR-36 message signing.",
+                });
+            }
+            try {
+                const [signed, key] = await Promise.all([
+                    signArbitrary.call(provider, chainId, cosmosAddress, message),
+                    getKey.call(provider, chainId),
+                ]);
+                return buildCosmosWalletVerificationSignatureResult({
+                    address: cosmosAddress,
+                    message,
+                    signedPayload: bytesToBase64(encodeUtf8(message)),
+                    signature: signed.signature,
+                    publicKey: base64StringOrBytes(signed.pub_key?.value ?? key.pubKey),
+                    publicKeyEncoding: "base64",
+                    signedPayloadEncoding: "base64",
+                });
+            }
+            catch (error) {
+                wrapSignatureError({
+                    chainType: ChainType.COSMOS,
+                    message: "Failed to sign Cosmos wallet verification message.",
+                    error,
+                });
+            }
+        },
+    };
+}
+
+function createEvmWalletVerificationSigner(params) {
+    const { connectedWallets, walletClient, wagmiAddress } = params;
+    return {
+        sign: async ({ message }) => {
+            const resolvedAddress = getEvmAddress({
+                connectedWallets,
+                walletClient,
+                wagmiAddress,
+            });
+            if (!resolvedAddress) {
+                throw new WalletVerificationSignatureError({
+                    code: WalletVerificationSignatureErrorCode.WALLET_NOT_CONNECTED,
+                    chainType: ChainType.EVM,
+                    message: "Connect an EVM wallet before signing verification messages.",
+                });
+            }
+            if (typeof walletClient?.signMessage !== "function") {
+                throw new WalletVerificationSignatureError({
+                    code: WalletVerificationSignatureErrorCode.SIGNER_UNAVAILABLE,
+                    chainType: ChainType.EVM,
+                    message: "The connected EVM wallet does not expose message signing.",
+                });
+            }
+            try {
+                const signature = await walletClient.signMessage({
+                    account: resolvedAddress,
+                    message,
+                });
+                return buildWalletVerificationSignatureResult({
+                    address: resolvedAddress,
+                    message,
+                    signature,
+                });
+            }
+            catch (error) {
+                wrapSignatureError({
+                    chainType: ChainType.EVM,
+                    message: "Failed to sign EVM wallet verification message.",
+                    error,
+                });
+            }
+        },
+    };
+}
+
+function createSolanaWalletVerificationSigner({ connectedWallets, }) {
+    const solanaWallet = connectedWallets[ChainType.SOLANA].wallet;
+    return {
+        sign: async ({ message }) => {
+            const solanaAddress = connectedWallets[ChainType.SOLANA].address;
+            const solanaConnector = solanaWallet?.connector;
+            const [account] = solanaConnector?.wallet.accounts ?? [];
+            const signMessage = solanaConnector?.wallet.features["solana:signMessage"]?.signMessage;
+            if (!solanaAddress || !account) {
+                throw new WalletVerificationSignatureError({
+                    code: WalletVerificationSignatureErrorCode.WALLET_NOT_CONNECTED,
+                    chainType: ChainType.SOLANA,
+                    message: "Connect a Solana wallet before signing verification messages.",
+                });
+            }
+            if (typeof signMessage !== "function") {
+                throw new WalletVerificationSignatureError({
+                    code: WalletVerificationSignatureErrorCode.SIGNER_UNAVAILABLE,
+                    chainType: ChainType.SOLANA,
+                    message: "The connected Solana wallet does not expose message signing.",
+                });
+            }
+            try {
+                const [signed] = await signMessage({
+                    account,
+                    message: encodeUtf8(message),
+                });
+                if (!signed) {
+                    throw new Error("Solana wallet did not return a signature.");
+                }
+                return buildSolanaWalletVerificationSignatureResult({
+                    address: solanaAddress,
+                    message,
+                    signedPayload: bytesToBase64(signed.signedMessage),
+                    signature: bytesToBase64(signed.signature),
+                    publicKey: account.address,
+                    publicKeyEncoding: "base58",
+                    signedPayloadEncoding: "base64",
+                });
+            }
+            catch (error) {
+                wrapSignatureError({
+                    chainType: ChainType.SOLANA,
+                    message: "Failed to sign Solana wallet verification message.",
+                    error,
+                });
+            }
+        },
+    };
+}
+
+function createStellarWalletVerificationSigner({ connectedWallets, }) {
+    const stellarWallet = connectedWallets[ChainType.STELLAR].wallet;
+    return {
+        sign: async ({ message, networkPassphrase }) => {
+            const stellarAddress = connectedWallets[ChainType.STELLAR].address;
+            const stellarConnector = stellarWallet?.connector;
+            const signMessage = stellarConnector?.signMessage;
+            if (!stellarAddress) {
+                throw new WalletVerificationSignatureError({
+                    code: WalletVerificationSignatureErrorCode.WALLET_NOT_CONNECTED,
+                    chainType: ChainType.STELLAR,
+                    message: "Connect a Stellar wallet before signing verification messages.",
+                });
+            }
+            if (typeof signMessage !== "function") {
+                throw new WalletVerificationSignatureError({
+                    code: WalletVerificationSignatureErrorCode.SIGNER_UNAVAILABLE,
+                    chainType: ChainType.STELLAR,
+                    message: "The connected Stellar wallet does not expose message signing.",
+                });
+            }
+            try {
+                const network = networkPassphrase == null && stellarConnector?.getNetwork
+                    ? await stellarConnector.getNetwork().catch(() => undefined)
+                    : undefined;
+                const resolvedNetworkPassphrase = networkPassphrase ?? network?.networkPassphrase;
+                const signedPayload = bytesToBase64(encodeUtf8(message));
+                const signed = await signMessage.call(stellarConnector, signedPayload, {
+                    address: stellarAddress,
+                    networkPassphrase: resolvedNetworkPassphrase,
+                });
+                const resolvedSignerAddress = signed.signerAddress ??
+                    (await stellarConnector
+                        ?.getAddress?.()
+                        .then(({ address }) => address)
+                        .catch(() => undefined));
+                if (resolvedSignerAddress && resolvedSignerAddress !== stellarAddress) {
+                    throw new WalletVerificationSignatureError({
+                        code: WalletVerificationSignatureErrorCode.ACTIVE_ACCOUNT_MISMATCH,
+                        chainType: ChainType.STELLAR,
+                        message: "The Stellar wallet signed with a different active account. Reconnect the Stellar wallet and try again.",
+                    });
+                }
+                return buildStellarWalletVerificationSignatureResult({
+                    address: stellarAddress,
+                    message,
+                    signedPayload,
+                    signature: normalizeBase64Ed25519Signature(signed.signedMessage),
+                    publicKey: resolvedSignerAddress ?? stellarAddress,
+                    publicKeyEncoding: "base32",
+                    signedPayloadEncoding: "base64",
+                    signerAddress: resolvedSignerAddress,
+                });
+            }
+            catch (error) {
+                wrapSignatureError({
+                    chainType: ChainType.STELLAR,
+                    message: "Failed to sign Stellar wallet verification message.",
+                    error,
+                });
+            }
+        },
+    };
+}
+
+function createSuiWalletVerificationSigner({ connectedWallets, }) {
+    const suiWallet = connectedWallets[ChainType.SUI].wallet;
+    return {
+        sign: async ({ message }) => {
+            const suiAddress = connectedWallets[ChainType.SUI].address;
+            const suiAccount = connectedWallets[ChainType.SUI].account;
+            const signPersonalMessage = suiWallet?.connector.signPersonalMessage;
+            if (!suiAddress || !suiAccount) {
+                throw new WalletVerificationSignatureError({
+                    code: WalletVerificationSignatureErrorCode.WALLET_NOT_CONNECTED,
+                    chainType: ChainType.SUI,
+                    message: "Connect a Sui wallet before signing verification messages.",
+                });
+            }
+            if (typeof signPersonalMessage !== "function") {
+                throw new WalletVerificationSignatureError({
+                    code: WalletVerificationSignatureErrorCode.SIGNER_UNAVAILABLE,
+                    chainType: ChainType.SUI,
+                    message: "The connected Sui wallet does not expose personal message signing.",
+                });
+            }
+            try {
+                const signed = await signPersonalMessage({
+                    account: suiAccount,
+                    message: encodeUtf8(message),
+                });
+                return buildSuiWalletVerificationSignatureResult({
+                    address: suiAddress,
+                    message,
+                    signedPayload: signed.bytes,
+                    signature: signed.signature,
+                    publicKey: suiAccount.publicKey
+                        ? bytesToBase64(suiAccount.publicKey)
+                        : undefined,
+                    publicKeyEncoding: "base64",
+                    signedPayloadEncoding: "base64",
+                });
+            }
+            catch (error) {
+                wrapSignatureError({
+                    chainType: ChainType.SUI,
+                    message: "Failed to sign Sui wallet verification message.",
+                    error,
+                });
+            }
+        },
+    };
+}
+
+function createXrplWalletVerificationSigner({ connectedWallets, }) {
+    const xrplWallet = connectedWallets[ChainType.XRPL].wallet;
+    return {
+        sign: async ({ message }) => {
+            const xrplAddress = connectedWallets[ChainType.XRPL].address;
+            const xrplConnector = xrplWallet?.connector;
+            const signOwnershipMessage = xrplConnector?.signOwnershipMessage;
+            if (!xrplAddress) {
+                throw new WalletVerificationSignatureError({
+                    code: WalletVerificationSignatureErrorCode.WALLET_NOT_CONNECTED,
+                    chainType: ChainType.XRPL,
+                    message: "Connect an XRPL wallet before signing verification messages.",
+                });
+            }
+            if (typeof signOwnershipMessage !== "function") {
+                throw new WalletVerificationSignatureError({
+                    code: WalletVerificationSignatureErrorCode.SIGNER_UNAVAILABLE,
+                    chainType: ChainType.XRPL,
+                    message: "The connected XRPL wallet does not expose ownership message signing.",
+                });
+            }
+            try {
+                const signed = await signOwnershipMessage.call(xrplConnector, {
+                    address: xrplAddress,
+                    message,
+                });
+                return buildXrplWalletVerificationSignatureResult({
+                    address: xrplAddress,
+                    message,
+                    signedPayload: signed.signedPayload,
+                    signature: signed.signature,
+                    publicKey: signed.publicKey,
+                    publicKeyEncoding: signed.publicKeyEncoding,
+                    signedPayloadEncoding: signed.signedPayloadEncoding,
+                    signatureType: signed.signatureType,
+                    signerAddress: signed.signerAddress,
+                });
+            }
+            catch (error) {
+                wrapSignatureError({
+                    chainType: ChainType.XRPL,
+                    message: "Failed to sign XRPL wallet verification message.",
+                    error,
+                });
+            }
+        },
+        cancel: () => {
+            xrplWallet?.connector.cancelSignOwnershipMessage?.();
+        },
+    };
+}
+
+function createWalletVerificationSigners(params) {
+    return {
+        [ChainType.EVM]: createEvmWalletVerificationSigner(params),
+        [ChainType.COSMOS]: createCosmosWalletVerificationSigner(params),
+        [ChainType.BTC]: createBitcoinWalletVerificationSigner(params),
+        [ChainType.SOLANA]: createSolanaWalletVerificationSigner(params),
+        [ChainType.SUI]: createSuiWalletVerificationSigner(params),
+        [ChainType.XRPL]: createXrplWalletVerificationSigner(params),
+        [ChainType.STELLAR]: createStellarWalletVerificationSigner(params),
+    };
+}
+
+const useWalletVerificationSignature = () => {
+    const connectedWallets = useWalletStore((store) => store.connectedWalletsByChainType);
+    const { address: wagmiAddress, connector: activeConnector } = useAccount();
+    const evmWallet = connectedWallets[ChainType.EVM].wallet;
+    const evmConnector = evmWallet?.connector ?? activeConnector;
+    const { data: walletClient } = useWalletClient({ connector: evmConnector });
+    const signers = useMemo(() => createWalletVerificationSigners({
+        connectedWallets,
+        walletClient,
+        wagmiAddress,
+    }), [connectedWallets, wagmiAddress, walletClient]);
+    const signVerificationMessage = useCallback(async (request) => {
+        assertWalletVerificationSigningRequest(request);
+        const signer = signers[request.chainType];
+        if (!signer) {
+            throw new WalletVerificationSignatureError({
+                code: WalletVerificationSignatureErrorCode.UNSUPPORTED_CHAIN_TYPE,
+                chainType: request.chainType,
+                message: "Unsupported wallet verification chain type.",
+            });
+        }
+        return signer.sign(request);
+    }, [signers]);
+    const cancelSignVerificationMessage = useCallback(({ chainType } = {}) => {
+        if (!chainType) {
+            return;
+        }
+        signers[chainType]?.cancel?.();
+    }, [signers]);
+    const signVerificationMessageMutation = useMutation({
+        mutationFn: signVerificationMessage,
+    });
+    return {
+        signatureTypes: WALLET_VERIFICATION_SIGNATURE_TYPE_BY_CHAIN_TYPE,
+        supportedChainTypes: Object.values(ChainType),
+        signVerificationMessage: signVerificationMessageMutation.mutateAsync,
+        cancelSignVerificationMessage,
+        isSigning: signVerificationMessageMutation.isLoading,
+        error: signVerificationMessageMutation.error,
+        reset: signVerificationMessageMutation.reset,
+    };
+};
+
 /**
  * Maximum IOU amount on XRPL
  * @see https://xrpl.org/docs/references/protocol/data-types/currency-formats#comparison
@@ -37573,10 +38439,8 @@ const SquidProvider = ({ children, config, placeholder, }) => {
             }
             if (assetsColorsResponse.status === "fulfilled") {
                 useAssetsColorsStore.setState(assetsColorsResponse.value);
+                initializeSquidWithAssetsColors(squid, assetsColorsResponse.value);
             }
-            initializeSquidData(squid, assetsColorsResponse.status === "fulfilled"
-                ? assetsColorsResponse.value
-                : undefined);
             const shouldResetSwapRouteStore = 
             // reset swap route if specified in config
             !config?.loadPreviousStateFromLocalStorage ||
@@ -37653,5 +38517,5 @@ const SquidProvider = ({ children, config, placeholder, }) => {
                                     React.createElement(CosmosProvider, null, children)))))))))) : (placeholder);
 };
 
-export { useDepositAddress as $, AxelarStatusResponseType as A, useHederaTokenAssociations as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, useKeyboardNavigation as E, useSquidQueryClient as F, useSquid as G, HistoryTxType as H, useStellarAccountActivation as I, useStellarTrustLine as J, useAddressBookStore as K, useAssetsColorsStore as L, useFavoriteTokensStore as M, Nr as N, useHistoryStore as O, useSendTransactionStore as P, QueryKeys as Q, useConfigStore as R, SquidStatusErrorType as S, TransactionErrorType as T, useSquidStore as U, useSwapRoutePersistStore as V, Wo as W, XamanXrplNetwork as X, useTransactionStore as Y, ConnectingWalletStatus as Z, useWalletStore as _, WindowWalletFlag as a, useRecommendedQuote as a$, useSwap as a0, buildUrlSearchParamsFromSwapEvent as a1, parseInitialAssetsFromUrl as a2, useUrlSwapParams as a3, useAllConnectedWalletBalances as a4, useAllTokensWithBalanceForChainType as a5, useCosmosBalance as a6, useEvmBalance as a7, useMultiChainBalance as a8, useMultipleTokenPrices as a9, useSendTransactionStatus as aA, useSwapTransactionStatus as aB, useAvatar as aC, useHistory as aD, useDebouncedValue as aE, useAddToken as aF, useAutoConnect as aG, useEnsDataForAddress as aH, useEnsSearch as aI, useGnosisContext as aJ, useIsSameAddressAndGnosisContext as aK, useIntegratorContext as aL, useMultiChainWallet as aM, useSigner as aN, useWallet as aO, useWallets as aP, useXrplTrustLine as aQ, TX_STATUS_CONSTANTS as aR, FINAL_TRANSACTION_STATUSES as aS, useGetFiatQuote as aT, useGetOnRampConfig as aU, useExecuteFiatQuote as aV, useFiatOnRampTxStatus as aW, useFiatTransactions as aX, useCurrencyDetails as aY, useCountryDetails as aZ, useAvailableQuotes as a_, useBitcoinNativeBalance as aa, useCosmosNativeBalance as ab, useEvmNativeBalance as ac, useNativeBalance as ad, useSolanaNativeBalance as ae, useStellarNativeBalance as af, useSuiNativeBalance as ag, useXrplNativeBalance as ah, useNativeTokenForChain as ai, useSingleTokenPrice as aj, useSourceChainGasToken as ak, useSquidTokens as al, useHistoricalData as am, useTokensData as an, useEstimateSendTransaction as ao, useSendTransaction as ap, useSendTransactionGas as aq, useAllTransactionsStatus as ar, useApproval as as, useDepositTransactionStatus as at, useEstimate as au, useEstimatePriceImpact as av, useExecuteTransaction as aw, useGetRoute as ax, useGetRouteWrapper as ay, useRouteWarnings as az, chainTypeToZeroAddressMap as b, parseEvmAddress as b$, useGetOnrampPaymentTypes as b0, useSuggestedFiatAmounts as b1, SquidProvider as b2, EnsService as b3, getXummClient as b4, isXamanXAppContext as b5, getQueryHeaders as b6, getStatusCode as b7, is404Error as b8, assetsBaseUrl as b9, getTokensForChain as bA, getFirstAvailableChainId as bB, fetchHighestBalanceToken as bC, getInitialOrDefaultTokenAddressForChain as bD, getInitialTokenAddressForChain as bE, filterTokensForDestination as bF, getInitialChainIdFromConfig as bG, getCosmosKey as bH, getKeysSettled as bI, getAllKeysForSupportedCosmosChains as bJ, isCosmosAddressValid as bK, getCosmosSigningClient as bL, getCosmosChainInfosObject as bM, connectCosmosWallet as bN, isFallbackAddressNeeded as bO, suggestChainOrThrow as bP, normalizeError as bQ, transactionErrorCode as bR, isUserRejectionError as bS, getTransactionError as bT, handleTransactionErrorEvents as bU, isSwapRouteError as bV, isStatusError as bW, createQuoteRequestParamsHash as bX, WidgetEvents as bY, EvmNetworkNotSupportedErrorCode as bZ, addEthereumChain as b_, shareSubgraphId as ba, sortTokensBySharedSubgraphIds as bb, getSupportedChainIdsForDirection as bc, filterChains as bd, filterTokens as be, getTokenImage as bf, getNewSwapParamsFromInput as bg, sortAllTokens as bh, findToken as bi, findNativeToken as bj, normalizeIbcAddress as bk, groupTokensBySymbol as bl, groupTokensByChainId as bm, filterViewableTokens as bn, getSecretNetworkBalances as bo, getTokenAssetsKey as bp, fetchAssetsColors as bq, isSupportedChainType as br, initializeSquidData as bs, isEmptyObject as bt, normalizeTokenSymbol as bu, areTokenSymbolsCompatible as bv, isEvmosChain as bw, resolveChainIdFromAsset as bx, getConfigWithDefaults as by, randomIntFromInterval as bz, chainTypeToNativeTokenAddressMap as c, getBridgeType as c$, formatEvmWallet as c0, filterWagmiConnector as c1, waitForReceiptWithRetry as c2, getUserCountry as c3, getCountryData as c4, getCurrencyData as c5, adaptiveRound as c6, getSuggestedAmountsForCurrency as c7, HederaExtensionHelper as c8, convertHederaAccountIdToEvmAddress as c9, getStellarHorizonApiUrl as cA, isValidIssuedAsset as cB, isValidHorizonAsset as cC, formatTransactionHistoryDate as cD, getAxelarExplorerTxUrl as cE, getSourceExplorerTxUrl as cF, getMainExplorerUrl as cG, formatDistance as cH, formatSeconds as cI, formatSwapTxStatusResponseForStorage as cJ, simplifyRouteAction as cK, fetchSwapTransactionStatus as cL, compareTransactionIds as cM, isCoralBridgeAction as cN, isActionCompletedOnSourceTx as cO, sleep as cP, isChainflipDepositRoute as cQ, isChainflipBridgeTransaction as cR, isOnChainTxData as cS, isDepositAddressDirectTransferRoute as cT, getHistoryTransactionId as cU, getStepStatuses as cV, getHalfSuccessState as cW, getStepsInfos as cX, getSwapTxStatusRefetchInterval as cY, getSendTxStatusRefetchInterval as cZ, chainflipMultihopBridgeType as c_, convertEvmAddressToHederaAccountId as ca, scaleHbarToWei as cb, scaleWeiToHbar as cc, parseToBigInt as cd, roundNumericValue as ce, formatUnitsRounded as cf, formatTokenAmount as cg, formatUsdAmount as ch, trimExtraDecimals as ci, getNumericValue as cj, cleanAmount as ck, convertTokenAmountToUSD as cl, convertUSDToTokenAmount as cm, calculateTotal24hChange as cn, getRouteExpiry as co, searchTokens as cp, filterSolanaWallets as cq, isSolanaAddressValid as cr, executeSolanaSwap as cs, executeSolanaTransfer as ct, isStellarAddressValid as cu, getStellarNetwork as cv, stellarAddressToScVal as cw, getStellarTrustLineAsset as cx, isStellarToken as cy, isStellarIssuedToken as cz, definedInWindow as d, getTransactionStatus as d0, getTransactionEndStatus as d1, isHistoryTransactionPending as d2, isHistoryTransactionFailed as d3, isHistoryTransactionWarning as d4, isHistoryTransactionEnded as d5, formatHash as d6, isWalletAddressValid as d7, redirectToExtensionsStore as d8, accessProperty as d9, populateWallets as da, getDefaultChain as db, sortWallets as dc, areSameAddress as dd, sortAddressBook as de, calculateTotalUsdBalanceUSD as df, addTokenToWallet as dg, isEvmChainNotSupportedError as dh, getWalletSupportedChainTypes as di, getConnectorForChainType as dj, walletSupportsChainType as dk, connectWallet as dl, cancelConnectWallet as dm, isProblematicConnector as dn, mergeWallets as dp, isXionSmartContractAddress as dq, isXrplAddressValid as dr, buildXrplTrustSetTx as ds, getXrplNetwork as dt, parseXrplPaymentTx as du, parseXrplTokenAddress as dv, 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, useHederaAccountActivation as z };
-//# sourceMappingURL=index-D5QOR7JT.js.map
+export { useStellarAccountActivation as $, AxelarStatusResponseType as A, assertWalletVerificationSigningRequest as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, assertEvmVerificationSigningRequest as E, buildSolanaWalletVerificationSignatureResult as F, buildStellarWalletVerificationSignatureResult as G, HistoryTxType as H, buildSuiWalletVerificationSignatureResult as I, WalletVerificationSignatureErrorCode as J, WalletVerificationSignatureError as K, buildXrplWalletVerificationSignatureResult as L, useTrackSearchEmpty as M, Nr as N, useSquidChains as O, useClient as P, QueryKeys as Q, useCosmosForChain as R, SquidStatusErrorType as S, TransactionErrorType as T, useHederaAccountActivation as U, useHederaTokenAssociations as V, Wo as W, XamanXrplNetwork as X, useKeyboardNavigation as Y, useSquidQueryClient as Z, useSquid as _, WindowWalletFlag as a, useWalletVerificationSignature as a$, useStellarTrustLine as a0, useAddressBookStore as a1, useAssetsColorsStore as a2, useFavoriteTokensStore as a3, useHistoryStore as a4, useSendTransactionStore as a5, useConfigStore as a6, useSquidStore as a7, useSwapRoutePersistStore as a8, useTransactionStore as a9, useTokensData as aA, useEstimateSendTransaction as aB, useSendTransaction as aC, useSendTransactionGas as aD, useAllTransactionsStatus as aE, useApproval as aF, useEstimate as aG, useEstimatePriceImpact as aH, useExecuteTransaction as aI, useGetRoute as aJ, useGetRouteWrapper as aK, useRouteWarnings as aL, useSendTransactionStatus as aM, useSwapTransactionStatus as aN, useAvatar as aO, useHistory 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, useWallet as a_, ConnectingWalletStatus as aa, useWalletStore as ab, useDepositAddress as ac, useSwap as ad, buildUrlSearchParamsFromSwapEvent as ae, parseInitialAssetsFromUrl as af, useUrlSwapParams as ag, useAllConnectedWalletBalances as ah, useAllTokensWithBalanceForChainType as ai, useCosmosBalance as aj, useEvmBalance as ak, useMultiChainBalance as al, useMultipleTokenPrices as am, useBitcoinNativeBalance as an, useCosmosNativeBalance as ao, useEvmNativeBalance as ap, useNativeBalance as aq, useSolanaNativeBalance as ar, useStellarNativeBalance as as, useSuiNativeBalance as at, useXrplNativeBalance as au, useNativeTokenForChain as av, useSingleTokenPrice as aw, useSourceChainGasToken as ax, useSquidTokens as ay, useHistoricalData as az, chainTypeToZeroAddressMap as b, connectCosmosWallet as b$, useWallets as b0, useXrplTrustLine as b1, TX_STATUS_CONSTANTS as b2, FINAL_TRANSACTION_STATUSES as b3, useGetFiatQuote as b4, useGetOnRampConfig as b5, useExecuteFiatQuote as b6, useFiatOnRampTxStatus as b7, useFiatTransactions as b8, useCurrencyDetails as b9, 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, isBitcoinAddressValid as bK, resolveChainIdFromAsset as bL, getConfigWithDefaults as bM, randomIntFromInterval as bN, getTokensForChain as bO, getFirstAvailableChainId as bP, fetchHighestBalanceToken as bQ, getInitialOrDefaultTokenAddressForChain as bR, getInitialTokenAddressForChain as bS, filterTokensForDestination as bT, getInitialChainIdFromConfig as bU, getCosmosKey as bV, getKeysSettled as bW, getAllKeysForSupportedCosmosChains as bX, isCosmosAddressValid as bY, getCosmosSigningClient as bZ, getCosmosChainInfosObject as b_, useCountryDetails as ba, useAvailableQuotes as bb, useRecommendedQuote as bc, useGetOnrampPaymentTypes as bd, useSuggestedFiatAmounts as be, SquidProvider as bf, EnsService as bg, XAMAN_OWNERSHIP_CHALLENGE_MEMO_TYPE as bh, getXummClient as bi, isXamanXAppContext as bj, getQueryHeaders as bk, getStatusCode as bl, is404Error as bm, assetsBaseUrl as bn, shareSubgraphId as bo, sortTokensBySharedSubgraphIds as bp, getSupportedChainIdsForDirection as bq, filterChains as br, filterTokens as bs, getTokenImage as bt, getNewSwapParamsFromInput as bu, sortAllTokens as bv, findToken as bw, findNativeToken as bx, normalizeIbcAddress as by, groupTokensBySymbol as bz, chainTypeToNativeTokenAddressMap as c, formatSeconds as c$, isFallbackAddressNeeded as c0, suggestChainOrThrow as c1, normalizeError as c2, transactionErrorCode as c3, isUserRejectionError as c4, getTransactionError as c5, handleTransactionErrorEvents as c6, isSwapRouteError as c7, isStatusError as c8, createQuoteRequestParamsHash as c9, convertTokenAmountToUSD as cA, convertUSDToTokenAmount as cB, calculateTotal24hChange as cC, getRouteExpiry as cD, searchTokens as cE, filterSolanaWallets as cF, isSolanaAddressValid as cG, executeSolanaSwap as cH, executeSolanaTransfer as cI, isStellarAddressValid as cJ, getStellarNetwork as cK, stellarAddressToScVal as cL, getStellarTrustLineAsset as cM, isStellarToken as cN, isStellarIssuedToken as cO, getStellarHorizonApiUrl as cP, isValidIssuedAsset as cQ, isValidHorizonAsset as cR, filterSuiWallets as cS, isSuiAddressValid as cT, slushWebWalletData as cU, getSuiChain as cV, formatTransactionHistoryDate as cW, getAxelarExplorerTxUrl as cX, getSourceExplorerTxUrl as cY, getMainExplorerUrl as cZ, formatDistance as c_, WidgetEvents as ca, EvmNetworkNotSupportedErrorCode as cb, addEthereumChain as cc, parseEvmAddress as cd, isEvmAddressValid as ce, formatEvmWallet as cf, filterWagmiConnector as cg, waitForReceiptWithRetry as ch, getUserCountry as ci, getCountryData as cj, getCurrencyData as ck, adaptiveRound as cl, getSuggestedAmountsForCurrency as cm, HederaExtensionHelper as cn, convertHederaAccountIdToEvmAddress as co, convertEvmAddressToHederaAccountId as cp, scaleHbarToWei as cq, scaleWeiToHbar as cr, parseToBigInt as cs, roundNumericValue as ct, formatUnitsRounded as cu, formatTokenAmount as cv, formatUsdAmount as cw, trimExtraDecimals as cx, getNumericValue as cy, cleanAmount as cz, definedInWindow as d, formatSwapTxStatusResponseForStorage as d0, simplifyRouteAction as d1, fetchSwapTransactionStatus as d2, compareTransactionIds as d3, isCoralBridgeAction as d4, isActionCompletedOnSourceTx as d5, sleep as d6, isDepositRoute as d7, isChainflipBridgeTransaction as d8, isOnChainTxData as d9, isEvmChainNotSupportedError as dA, getWalletSupportedChainTypes as dB, getConnectorForChainType as dC, walletSupportsChainType as dD, connectWallet as dE, cancelConnectWallet as dF, isProblematicConnector as dG, mergeWallets as dH, isXionSmartContractAddress as dI, isXrplAddressValid as dJ, buildXrplTrustSetTx as dK, getXrplNetwork as dL, parseXrplPaymentTx as dM, parseXrplTokenAddress as dN, getHistoryTransactionId as da, getStepStatuses as db, getHalfSuccessState as dc, getStepsInfos as dd, getSwapTxStatusRefetchInterval as de, getSendTxStatusRefetchInterval as df, chainflipMultihopBridgeType as dg, getBridgeType as dh, getTransactionStatus as di, getTransactionEndStatus as dj, isHistoryTransactionPending as dk, isHistoryTransactionFailed as dl, isHistoryTransactionWarning as dm, isHistoryTransactionEnded as dn, formatHash as dp, isWalletAddressValid as dq, redirectToExtensionsStore as dr, accessProperty as ds, populateWallets as dt, getDefaultChain as du, sortWallets as dv, areSameAddress as dw, sortAddressBook as dx, calculateTotalUsdBalanceUSD as dy, addTokenToWallet as dz, 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, buildBitcoinWalletVerificationSignatureResult as t, useCosmosContext as u, WalletVerificationSignatureType as v, walletIconBaseUrl as w, WALLET_VERIFICATION_SIGNATURE_TYPE_BY_CHAIN_TYPE as x, buildCosmosWalletVerificationSignatureResult as y, buildWalletVerificationSignatureResult as z };
+//# sourceMappingURL=index-CtXS5uny.js.map