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

package/dist/{index-mgE1SeE-.js → index-z1nGQX9p.js}

@@ -5,7 +5,7 @@ var viem = require('viem');
 var React = require('react');
 var reactQuery = require('@tanstack/react-query');
 var encoding = require('@cosmjs/encoding');
-var bitcoin = require('bitcoinjs-lib');
+var bitcoin$1 = require('bitcoinjs-lib');
 var ecc = require('@bitcoinerlab/secp256k1');
 var axios = require('axios');
 var modal = require('@walletconnect/modal');
@@ -54,7 +54,7 @@ function _interopNamespaceDefault(e) {
     return Object.freeze(n);
 }
 
-var bitcoin__namespace = /*#__PURE__*/_interopNamespaceDefault(bitcoin);
+var bitcoin__namespace = /*#__PURE__*/_interopNamespaceDefault(bitcoin$1);
 var ecc__namespace = /*#__PURE__*/_interopNamespaceDefault(ecc);
 
 const squidApiBaseUrl = "https://v2.api.squidrouter.com";
@@ -78,8 +78,6 @@ const solanaZeroAddress = "11111111111111111111111111111111";
 const suiZeroAddress = "0x0000000000000000000000000000000000000000";
 const xrplZeroAddress = "rrrrrrrrrrrrrrrrrrrrrhoLvTp";
 const stellarZeroAddress = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF";
-// TODO: check
-const cantonZeroAddress = "none::12200000000000000000000000000000000000000000000000000000000000000000";
 const chainTypeToZeroAddressMap = {
     [squidTypes.ChainType.EVM]: viem.zeroAddress,
     [squidTypes.ChainType.COSMOS]: cosmosZeroAddress,
@@ -88,7 +86,6 @@ const chainTypeToZeroAddressMap = {
     [squidTypes.ChainType.SUI]: suiZeroAddress,
     [squidTypes.ChainType.XRPL]: xrplZeroAddress,
     [squidTypes.ChainType.STELLAR]: stellarZeroAddress,
-    [squidTypes.ChainType.CANTON]: cantonZeroAddress,
 };
 const nativeEvmTokenAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 const nativeCosmosTokenAddress = "uosmo";
@@ -97,7 +94,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";
@@ -161,7 +157,6 @@ const CHAIN_IDS = {
     XRPL_TESTNET: "xrpl-testnet",
     STELLAR: "stellar-mainnet",
     STELLAR_TESTNET: "stellar-testnet",
-    CANTON: "canton",
 };
 const chainTypeToDefaultChainIdMap = {
     [squidTypes.ChainType.EVM]: CHAIN_IDS.ETHEREUM,
@@ -171,7 +166,6 @@ const chainTypeToDefaultChainIdMap = {
     [squidTypes.ChainType.SUI]: CHAIN_IDS.SUI,
     [squidTypes.ChainType.XRPL]: CHAIN_IDS.XRPL,
     [squidTypes.ChainType.STELLAR]: CHAIN_IDS.STELLAR,
-    [squidTypes.ChainType.CANTON]: CHAIN_IDS.CANTON,
 };
 const chainTypeToNativeTokenAddressMap = {
     [squidTypes.ChainType.EVM]: nativeEvmTokenAddress,
@@ -181,12 +175,12 @@ const chainTypeToNativeTokenAddressMap = {
     [squidTypes.ChainType.SUI]: nativeSuiTokenAddress,
     [squidTypes.ChainType.XRPL]: nativeXrplTokenAddress,
     [squidTypes.ChainType.STELLAR]: nativeStellarTokenAddress,
-    [squidTypes.ChainType.CANTON]: nativeCantonTokenAddress,
 };
 const defaultConfigValues = {
     integratorId: INTEGRATOR_ID,
     slippage: defaultSlippage,
     apiUrl: squidApiBaseUrl,
+    xamanApiUrl: XAMAN_API_URL,
     priceImpactWarnings: {
         warning: 3,
         critical: 5,
@@ -4214,11 +4208,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);
     }
 }
 
@@ -4716,6 +4710,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);
@@ -4763,6 +4944,9 @@ class KeplrConnector {
             address: account,
         };
     }
+    async signMessage(message) {
+        return this.getProvider.signMessage(message, build.BitcoinSignMessageType.BIP322_SIMPLE);
+    }
 }
 
 bitcoin__namespace.initEccLib(ecc__namespace);
@@ -4906,6 +5090,7 @@ class PhantomConnector {
     }
 }
 
+const UNISAT_BIP322_SIMPLE_SIGNATURE_TYPE = "bip322-simple";
 class UnisatConnector {
     get getProvider() {
         const provider = window?.unisat;
@@ -4931,8 +5116,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;
+}
+
+exports.WalletVerificationSignatureType = void 0;
+(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";
+})(exports.WalletVerificationSignatureType || (exports.WalletVerificationSignatureType = {}));
+const WALLET_VERIFICATION_SIGNATURE_TYPE_BY_CHAIN_TYPE = {
+    [squidTypes.ChainType.EVM]: exports.WalletVerificationSignatureType.EVM,
+    [squidTypes.ChainType.COSMOS]: exports.WalletVerificationSignatureType.COSMOS,
+    [squidTypes.ChainType.BTC]: exports.WalletVerificationSignatureType.BITCOIN,
+    [squidTypes.ChainType.SOLANA]: exports.WalletVerificationSignatureType.SOLANA,
+    [squidTypes.ChainType.SUI]: exports.WalletVerificationSignatureType.SUI,
+    [squidTypes.ChainType.XRPL]: exports.WalletVerificationSignatureType.XRPL,
+    [squidTypes.ChainType.STELLAR]: exports.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: squidTypes.ChainType.BTC,
+    signatureType: exports.WalletVerificationSignatureType.BITCOIN,
+});
+
+const buildCosmosWalletVerificationSignatureResult = (params) => buildSignedPayloadWalletVerificationSignatureResult({
+    ...params,
+    chainType: squidTypes.ChainType.COSMOS,
+    signatureType: exports.WalletVerificationSignatureType.COSMOS,
+});
+
+const buildWalletVerificationSignatureResult = ({ address, message, signature, }) => buildSignatureOnlyWalletVerificationSignatureResult({
+    chainType: squidTypes.ChainType.EVM,
+    signatureType: exports.WalletVerificationSignatureType.EVM,
+    address,
+    message,
+    signature,
+});
+
+exports.WalletVerificationSignatureErrorCode = void 0;
+(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";
+})(exports.WalletVerificationSignatureErrorCode || (exports.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: exports.WalletVerificationSignatureErrorCode.INVALID_MESSAGE,
+            chainType,
+            message: "Invalid wallet verification message.",
+        });
+    }
+};
+const assertEvmVerificationSigningRequest = ({ message, chainType, }) => {
+    if (chainType !== squidTypes.ChainType.EVM) {
+        throw new WalletVerificationSignatureError({
+            code: exports.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: squidTypes.ChainType.SOLANA,
+    signatureType: exports.WalletVerificationSignatureType.SOLANA,
+    address,
+    message,
+    signedPayload,
+    signature,
+    publicKey,
+    publicKeyEncoding,
+    signedPayloadEncoding,
+});
+
+const buildStellarWalletVerificationSignatureResult = (params) => buildSignedPayloadWalletVerificationSignatureResult({
+    ...params,
+    chainType: squidTypes.ChainType.STELLAR,
+    signatureType: exports.WalletVerificationSignatureType.STELLAR,
+});
+
+const buildSuiWalletVerificationSignatureResult = ({ address, message, signedPayload, signature, publicKey, publicKeyEncoding, signedPayloadEncoding, }) => buildSignedPayloadWalletVerificationSignatureResult({
+    chainType: squidTypes.ChainType.SUI,
+    signatureType: exports.WalletVerificationSignatureType.SUI,
+    address,
+    message,
+    signedPayload,
+    signature,
+    publicKey,
+    publicKeyEncoding,
+    signedPayloadEncoding,
+});
+
+const buildXrplWalletVerificationSignatureResult = (params) => {
+    return buildSignedPayloadWalletVerificationSignatureResult({
+        ...params,
+        chainType: squidTypes.ChainType.XRPL,
+        signatureType: params.signatureType,
+    });
+};
+
 var XrplTransactionType;
 (function (XrplTransactionType) {
     XrplTransactionType["PAYMENT"] = "Payment";
@@ -4979,6 +5376,14 @@ var XRPL_METHOD;
     XRPL_METHOD["SIGN_TRANSACTION"] = "xrpl_signTransaction";
 })(XRPL_METHOD || (XRPL_METHOD = {}));
 
+function createXrplActiveAccountMismatchError(walletName) {
+    return new WalletVerificationSignatureError({
+        code: exports.WalletVerificationSignatureErrorCode.ACTIVE_ACCOUNT_MISMATCH,
+        chainType: squidTypes.ChainType.XRPL,
+        message: `${walletName} signed with a different active account. Reconnect the XRPL wallet and try again.`,
+    });
+}
+
 var NetworkLabel;
 (function (NetworkLabel) {
     NetworkLabel["XAHAU"] = "xahau";
@@ -5031,6 +5436,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: exports.WalletVerificationSignatureType.XRPL,
+        };
+    }
     getActiveNetwork() {
         const provider = this.getProvider();
         if (!provider) {
@@ -20409,6 +20846,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: exports.WalletVerificationSignatureType.XRPL,
+        };
+    }
     // Cannot use constructor because of the async initialization
     async initialize() {
         this.provider = await this.getProvider();
@@ -20866,11 +21331,11 @@ const isBitcoinAddressValid = (address) => {
         if (address.startsWith("bc1p")) {
             // this is a bitcoin taproot address type, it has different encoding than other 3 address types
             // and requires different validation logic
-            const decoded = bitcoin.address.fromBech32(address);
+            const decoded = bitcoin$1.address.fromBech32(address);
             return decoded.prefix === "bc" && decoded.version === 1;
         }
         else {
-            bitcoin.address.toOutputScript(address);
+            bitcoin$1.address.toOutputScript(address);
             return true;
         }
     }
@@ -20879,18 +21344,6 @@ const isBitcoinAddressValid = (address) => {
     }
 };
 
-// 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);
-}
-
 exports.HistoryTxType = void 0;
 (function (HistoryTxType) {
     HistoryTxType[HistoryTxType["SWAP"] = 0] = "SWAP";
@@ -21004,7 +21457,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:
@@ -21114,16 +21566,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,
@@ -21170,7 +21616,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 === squidTypes.SquidDataType.ChainflipDepositAddress);
 };
@@ -21195,12 +21641,6 @@ function isOnChainTxData(squidData) {
         squidTypes.SquidDataType.DepositAddressWithMemo,
     ].includes(squidData.type);
 }
-/**
- * Checks if a route is of type DepositAddressDirectTransfer
- */
-function isDepositAddressDirectTransferRoute(squidData) {
-    return (squidData.type === squidTypes.SquidDataType.DepositAddressDirectTransfer);
-}
 function getHistoryTransactionId(tx) {
     switch (tx.txType) {
         case exports.HistoryTxType.SWAP:
@@ -21339,6 +21779,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 viem.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: squidTypes.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
@@ -21640,6 +22167,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) {
@@ -21703,17 +22231,7 @@ const chainTypeToTrimLength = {
         start: 4,
         end: 4,
     },
-    // abc...123::abc...123
-    [squidTypes.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 "";
@@ -21726,22 +22244,21 @@ const formatHash = ({ chainType, hash }) => {
             chainTypeFormat = squidTypes.ChainType.COSMOS;
         }
     }
-    const { start, end } = chainTypeToTrimLength[chainTypeFormat];
-    if (chainTypeFormat === squidTypes.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 squidTypes.ChainType.EVM:
-            return viem.isAddress(address);
+            return isEvmAddressValid(address);
         case squidTypes.ChainType.COSMOS:
             return isCosmosAddressValid(chainData.bech32Config.bech32PrefixAccAddr, address);
         case squidTypes.ChainType.BTC:
@@ -21754,8 +22271,6 @@ const isWalletAddressValid = (chainData, address) => {
             return isXrplAddressValid(address);
         case squidTypes.ChainType.STELLAR:
             return isStellarAddressValid(address);
-        case squidTypes.ChainType.CANTON:
-            return isCantonAddressValid(address);
     }
 };
 const redirectToExtensionsStore = (wallet) => {
@@ -22017,8 +22532,6 @@ const connectByChainType = async (chainType, wallet, defaultChain, params) => {
                     connector,
                 },
             });
-        case squidTypes.ChainType.CANTON:
-            return null;
     }
 };
 const getChainTypesToConnect = (selectedChainTypes, defaultChain, supportedChains) => {
@@ -22296,6 +22809,17 @@ class EnsService {
     }
 }
 
+const XAMAN_OWNERSHIP_CHALLENGE_MEMO_TYPE = "squid-history-challenge";
+function getXamanNetwork(network) {
+    switch (network) {
+        case XrplNetwork.MAINNET:
+            return exports.XamanXrplNetwork.MAINNET;
+        case XrplNetwork.TESTNET:
+            return exports.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:
@@ -22304,38 +22828,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 exports.XamanXrplNetwork.MAINNET;
-            case XrplNetwork.TESTNET:
-                return exports.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() {
@@ -22668,6 +23208,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),
@@ -23093,10 +23634,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,
@@ -23375,7 +23913,7 @@ const filterViewableTokens = (tokens, config, direction) => {
 };
 const getSecretNetworkBalances = async (chainData, cosmosAddress, squidTokens, keplrTypeWallet) => {
     const squidSecretTokens = squidTokens.filter((t) => t.chainId === CHAIN_IDS.SECRET);
-    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-DWq78rM5.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-BFehLMb_.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -23402,29 +23940,9 @@ async function fetchAssetsColors() {
         };
     }
 }
-const supportedChainTypes = new Set(Object.values(squidTypes.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,
@@ -23433,7 +23951,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
@@ -23503,90 +24021,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 && viem.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: squidTypes.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",
@@ -25310,7 +25744,7 @@ const useSquid = () => {
         queryFn: async () => {
             if (squid) {
                 await squid?.init();
-                initializeSquidData(squid, assetsColors);
+                initializeSquidWithAssetsColors(squid, assetsColors);
                 return squid;
             }
             return null;
@@ -25369,7 +25803,7 @@ const useSquidTokens = (direction) => {
         config.availableChains,
         direction,
     ]);
-    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, cantonTokens, } = React.useMemo(() => {
+    const { evmTokens, cosmosTokens, solanaTokens, bitcoinTokens, suiTokens, xrplTokens, stellarTokens, } = React.useMemo(() => {
         return tokens?.reduce((acc, token) => {
             switch (token.type) {
                 case squidTypes.ChainType.EVM:
@@ -25393,9 +25827,6 @@ const useSquidTokens = (direction) => {
                 case squidTypes.ChainType.STELLAR:
                     acc.stellarTokens.push(token);
                     break;
-                case squidTypes.ChainType.CANTON:
-                    acc.cantonTokens.push(token);
-                    break;
             }
             return acc;
         }, {
@@ -25406,7 +25837,6 @@ const useSquidTokens = (direction) => {
             suiTokens: [],
             xrplTokens: [],
             stellarTokens: [],
-            cantonTokens: [],
         });
     }, [tokens]);
     const findToken = React.useCallback((address, chainId) => {
@@ -25424,7 +25854,6 @@ const useSquidTokens = (direction) => {
         suiTokens,
         xrplTokens,
         stellarTokens,
-        cantonTokens,
     };
 };
 
@@ -25962,7 +26391,6 @@ const chainTypeToRefetchInterval = {
     [squidTypes.ChainType.SUI]: 1_000,
     [squidTypes.ChainType.XRPL]: 1_000,
     [squidTypes.ChainType.STELLAR]: 1_000,
-    [squidTypes.ChainType.CANTON]: 1_000,
 };
 /**
  * Returns the status refetch interval of a Send transaction
@@ -26229,7 +26657,7 @@ const useSquidChains = (direction) => {
         const chain = findChain(chainId);
         return chain?.chainType;
     }, [findChain]);
-    const { evmChains, cosmosChains, suiChains, stellarChains, xrplChains, cantonChains, } = React.useMemo(() => {
+    const { evmChains, cosmosChains, suiChains, stellarChains, xrplChains } = React.useMemo(() => {
         return chains.reduce((acc, chain) => {
             switch (chain.chainType) {
                 case squidTypes.ChainType.EVM:
@@ -26247,9 +26675,6 @@ const useSquidChains = (direction) => {
                 case squidTypes.ChainType.STELLAR:
                     acc.stellarChains.push(chain);
                     break;
-                case squidTypes.ChainType.CANTON:
-                    acc.cantonChains.push(chain);
-                    break;
             }
             return acc;
         }, {
@@ -26258,7 +26683,6 @@ const useSquidChains = (direction) => {
             suiChains: [],
             xrplChains: [],
             stellarChains: [],
-            cantonChains: [],
         });
     }, [chains]);
     const { supportedSourceChains, supportedDestinationChains } = React.useMemo(() => {
@@ -26279,7 +26703,6 @@ const useSquidChains = (direction) => {
         suiChains,
         xrplChains,
         stellarChains,
-        cantonChains,
         getChainType,
         findChain,
     };
@@ -26804,7 +27227,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 Promise.resolve().then(function () { return require('./stellarService.client-DBROJ4yf.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-yWCDuq6S.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -26984,6 +27407,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();
@@ -27001,7 +27474,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: {
@@ -27009,33 +27482,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: exports.WalletVerificationSignatureType.XAMAN,
+                    signerAddress: fullPayload.response.signer ?? undefined,
+                };
+            },
         });
         return response;
     }
@@ -27077,96 +27582,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: exports.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 = React.useMemo(() => {
         const isXAppContext = isXamanXAppContext();
         const xamanWalletIcon = `${walletIconBaseUrl}/xaman.webp`;
@@ -27187,7 +27753,7 @@ function useXrplWallets() {
             type: squidTypes.ChainType.XRPL,
             name: "Xaman",
             windowFlag: exports.WindowWalletFlag.XamanQr,
-            connector: new XamanQrConnector(),
+            connector: new XamanQrConnector(new XamanClient({ baseUrl: xamanApiUrl })),
             skipInstallCheck: true,
             isMobile: true,
             connectorId: "xaman-qr",
@@ -27201,7 +27767,7 @@ function useXrplWallets() {
             isXAppContext ? xamanXAppWallet : xamanQrWallet,
             ...populateWallets(clientWindow, xrplWallets),
         ];
-    }, [clientWindow]);
+    }, [clientWindow, xamanApiUrl]);
     return {
         wallets,
     };
@@ -27336,6 +27902,7 @@ const useWallet = () => {
             setConnectingWallet({
                 wallet,
                 status: exports.ConnectingWalletStatus.CONNECTING,
+                qrScanned: false,
             });
             try {
                 const result = await connectWallet({
@@ -27470,11 +28037,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 {
@@ -27503,7 +28088,6 @@ const useMultiChainWallet = (chain) => {
     const suiAddress = connectedAddresses[squidTypes.ChainType.SUI];
     const xrplAddress = connectedAddresses[squidTypes.ChainType.XRPL];
     const stellarAddress = connectedAddresses[squidTypes.ChainType.STELLAR];
-    const cantonAddress = connectedAddresses[squidTypes.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);
@@ -27591,16 +28175,6 @@ const useMultiChainWallet = (chain) => {
                         chainType: chain.chainType,
                     }),
                 };
-            case squidTypes.ChainType.CANTON:
-                if (!cantonAddress)
-                    return {};
-                return {
-                    address: cantonAddress,
-                    formatted: formatHash({
-                        hash: cantonAddress,
-                        chainType: chain.chainType,
-                    }),
-                };
         }
     }, [
         chain?.chainType,
@@ -27612,7 +28186,6 @@ const useMultiChainWallet = (chain) => {
         suiAddress,
         xrplAddress,
         stellarAddress,
-        cantonAddress,
     ]);
     /**
      * Change current network for desired chain
@@ -28437,8 +29010,6 @@ async function createClient(chain) {
             return new XrplRpcClient(chain.rpc);
         case squidTypes.ChainType.STELLAR:
             return new StellarRpcClient(chain.rpc);
-        case squidTypes.ChainType.CANTON:
-            return null;
     }
 }
 
@@ -29631,7 +30202,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 [];
@@ -29650,8 +30221,6 @@ function useNativeTokenForChain(chain) {
                 return xrplTokens;
             case squidTypes.ChainType.STELLAR:
                 return stellarTokens;
-            case squidTypes.ChainType.CANTON:
-                return cantonTokens;
         }
     };
     const nativeTokenForChainType = React.useMemo(() => {
@@ -29886,11 +30455,6 @@ const useNativeBalance = (chain) => {
                 break;
             case squidTypes.ChainType.STELLAR:
                 balance = nativeStellarBalance;
-                break;
-            case squidTypes.ChainType.CANTON:
-                // TODO: implement canton balance fetching
-                balance = undefined;
-                break;
         }
         const balanceFormatted = !!balance
             ? formatBNToReadable(balance.value, balance.decimals)
@@ -29927,9 +30491,6 @@ const useNativeBalance = (chain) => {
                 return isXrpLoading;
             case squidTypes.ChainType.STELLAR:
                 return isStellarLoading;
-            case squidTypes.ChainType.CANTON:
-                // TODO: implement canton balance fetching
-                return false;
         }
     }, [
         chain?.chainType,
@@ -30154,7 +30715,7 @@ function hederaWalletConnect(parameters) {
                 const optionalChains = config.chains.map((x) => x.id);
                 if (!optionalChains.length)
                     return;
-                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-3JPbTFKq.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-D8CAnRf1.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -30384,8 +30945,6 @@ const useSigner = ({ chain }) => {
                 return isXrplSignerReady;
             case squidTypes.ChainType.STELLAR:
                 return isStellarSignerReady;
-            case squidTypes.ChainType.CANTON:
-                return false;
         }
     }, [
         chain?.chainType,
@@ -30835,21 +31394,21 @@ const useSendTransactionStore = zustand.create((set, get) => ({
 
 const useDepositAddressStore = zustand.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 = React.useMemo(() => {
@@ -30858,7 +31417,6 @@ function useDepositAddress(squidRoute) {
         const chainsSupportingDepositAddress = [
             CHAIN_IDS.BITCOIN,
             CHAIN_IDS.SOLANA,
-            CHAIN_IDS.CANTON,
         ];
         return chainsSupportingDepositAddress.includes(fromChain.chainId);
     }, [fromChain?.chainId]);
@@ -30866,50 +31424,34 @@ function useDepositAddress(squidRoute) {
         return (squidRoute?.transactionRequest?.type ===
             squidTypes.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 = React.useCallback(() => {
+        toggleDepositFlow(true);
+    }, [toggleDepositFlow]);
+    const disable = React.useCallback(() => {
+        toggleDepositFlow(false);
+    }, [toggleDepositFlow]);
     const closeDepositChannel = React.useCallback(() => {
+        toggleDepositFlow(false);
         setDeposit(null);
-    }, [setDeposit]);
+    }, [toggleDepositFlow, setDeposit]);
     const getRouteWithDeposit = reactQuery.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,
@@ -30941,7 +31483,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 = React.useMemo(() => {
         const tokens = {
@@ -30952,7 +31494,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
             [squidTypes.ChainType.SUI]: suiTokens.map((t) => ({ ...t, balance: "0" })),
             [squidTypes.ChainType.XRPL]: xrplTokens.map((t) => ({ ...t, balance: "0" })),
             [squidTypes.ChainType.STELLAR]: stellarTokens.map((t) => ({ ...t, balance: "0" })),
-            [squidTypes.ChainType.CANTON]: cantonTokens.map((t) => ({ ...t, balance: "0" })),
         };
         if (!chainType) {
             // Return all tokens with zero balance
@@ -30974,7 +31515,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         suiTokens,
         xrplTokens,
         stellarTokens,
-        cantonTokens,
     ]);
     const isQueryEnabled = React.useMemo(() => {
         // Respect the queryOptions.enabled override if provided
@@ -30997,8 +31537,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
                 return xrplTokens.length > 0;
             case squidTypes.ChainType.STELLAR:
                 return stellarTokens.length > 0;
-            case squidTypes.ChainType.CANTON:
-                return cantonTokens.length > 0;
         }
     }, [
         chainType,
@@ -31011,7 +31549,6 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         suiTokens.length,
         xrplTokens.length,
         stellarTokens.length,
-        cantonTokens.length,
     ]);
     const query = reactQuery.useQuery(keys().allTokensBalance(address, chainType, direction), async () => {
         // Return zero balances if no address
@@ -31121,12 +31658,6 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         direction,
         queryOptions,
     });
-    const cantonBalancesQuery = useAllTokensWithBalanceForChainType({
-        chainType: squidTypes.ChainType.CANTON,
-        address: connectedAddresses?.[squidTypes.ChainType.CANTON],
-        direction,
-        queryOptions,
-    });
     // Create a map of chain type to balance query results
     const balanceQueries = React.useMemo(() => ({
         [squidTypes.ChainType.EVM]: evmBalancesQuery,
@@ -31136,7 +31667,6 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         [squidTypes.ChainType.SUI]: suiBalancesQuery,
         [squidTypes.ChainType.XRPL]: xrplBalancesQuery,
         [squidTypes.ChainType.STELLAR]: stellarBalancesQuery,
-        [squidTypes.ChainType.CANTON]: cantonBalancesQuery,
     }), [
         evmBalancesQuery,
         cosmosBalancesQuery,
@@ -31145,7 +31675,6 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
         suiBalancesQuery,
         xrplBalancesQuery,
         stellarBalancesQuery,
-        cantonBalancesQuery,
     ]);
     // Combine all tokens from different chains
     const allTokens = React.useMemo(() => Object.values(balanceQueries).flatMap((query) => query.data?.tokens ?? []), [balanceQueries]);
@@ -31245,9 +31774,6 @@ const useMultiChainBalance = ({ chain, token, userAddress, enabled = true, }) =>
                 return xrplBalance;
             case squidTypes.ChainType.STELLAR:
                 return stellarBalance;
-            case squidTypes.ChainType.CANTON:
-                // TODO: implement canton balance fetching
-                return "0";
         }
     }, [
         chain?.chainType,
@@ -32356,9 +32882,6 @@ function useSendTransaction({ to, amount, token, chain, }) {
                         chain,
                     });
                     break;
-                case squidTypes.ChainType.CANTON: {
-                    throw new Error("Not implemented");
-                }
             }
             return {
                 amount,
@@ -32562,8 +33085,6 @@ async function getSendTransactionStatus({ chain, txHash, }) {
                 txHash,
                 chain,
             });
-        case squidTypes.ChainType.CANTON:
-            throw new Error("Not implemented");
     }
 }
 
@@ -32587,7 +33108,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,
@@ -33015,129 +33536,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] = React.useState(false);
-    const [refetchInterval, setRefetchInterval] = React.useState(getSwapTxStatusRefetchInterval(transaction));
-    const { getChainType } = useSquidChains();
-    const fetchTransactionStatusWithLatestConfig = React.useCallback(async () => {
-        const latestConfig = useConfigStore.getState().config;
-        return fetchSwapTransactionStatus({
-            transaction,
-            integratorId: latestConfig.integratorId,
-            apiUrl: latestConfig.apiUrl,
-        });
-    }, [transaction]);
-    const transactionStatusQuery = reactQuery.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) === squidTypes.ChainType.COSMOS ? 5000 : 3000,
-        retry: getChainType(transaction?.fromChain) === squidTypes.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: exports.TransactionStatus.ONGOING,
-                sourceStatus: exports.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) => {
@@ -34197,13 +34595,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) {
@@ -36456,7 +36854,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) {
@@ -36467,7 +36865,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,
@@ -36477,7 +36875,7 @@ const useExecuteTransaction = (squidRoute) => {
                         const txParams = setTransactionState({
                             route,
                             txHash,
-                            transactionIdForStatus: depositData.statusTrackingId,
+                            transactionIdForStatus: depositData.chainflipStatusTrackingId,
                             userAddress: sourceUserAddress,
                             status: exports.TransactionStatus.INITIAL_LOADING,
                             sourceStatus: exports.TransactionStatus.ONGOING,
@@ -36528,7 +36926,7 @@ const useExecuteTransaction = (squidRoute) => {
         }
     });
     const swapMutationBitcoin = reactQuery.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}`);
         }
@@ -36551,7 +36949,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: exports.TransactionStatus.INITIAL_LOADING,
                     sourceStatus: exports.TransactionStatus.ONGOING,
@@ -36999,7 +37397,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);
@@ -37007,7 +37405,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 = React.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), [
@@ -37152,50 +37550,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] = React.useState(false);
+    const [refetchInterval, setRefetchInterval] = React.useState(getSwapTxStatusRefetchInterval(transaction));
+    const { getChainType } = useSquidChains();
     const currentHistoryItem = React.useMemo(() => findTransaction({
         transactionId: transaction?.transactionId,
         txType: exports.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 = React.useCallback(async () => {
+        const latestConfig = useConfigStore.getState().config;
+        return fetchSwapTransactionStatus({
+            transaction,
+            integratorId: latestConfig.integratorId,
+            apiUrl: latestConfig.apiUrl,
+        });
+    }, [transaction]);
+    const transactionStatusQuery = reactQuery.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: exports.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: exports.TransactionStatus.NOT_FOUND,
-            });
+        // At the moment Cosmos indexing takes more time, so need more time between retries
+        retryDelay: getChainType(transaction?.fromChain) === squidTypes.ChainType.COSMOS ? 5000 : 3000,
+        retry: getChainType(transaction?.fromChain) === squidTypes.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: exports.TransactionStatus.ERROR,
-            });
+            if (is404) {
+                replaceSwapTransactionStatus({
+                    transactionId: transaction.transactionId,
+                    statusResponse: undefined,
+                    status: exports.TransactionStatus.NOT_FOUND,
+                });
+            }
+            else {
+                setRefetchInterval(-1);
+                setIsTransactionComplete(true);
+                replaceSwapTransactionStatus({
+                    transactionId: transaction.transactionId,
+                    statusResponse: undefined,
+                    status: exports.TransactionStatus.ERROR,
+                });
+            }
         },
-    }).transactionStatusQuery;
+    });
     return {
         transactionStatusQuery,
         latestStatus: transactionStatusQuery.data
@@ -37406,6 +37848,430 @@ const useIntegratorContext = () => {
     return { walletHandledExternally, isEmbed, widgetInIframe };
 };
 
+function wrapSignatureError({ chainType, message, error, }) {
+    if (error instanceof WalletVerificationSignatureError) {
+        throw error;
+    }
+    throw new WalletVerificationSignatureError({
+        code: exports.WalletVerificationSignatureErrorCode.SIGNATURE_REJECTED,
+        chainType,
+        message,
+        cause: error,
+    });
+}
+function getEvmAddress({ connectedWallets, walletClient, wagmiAddress, }) {
+    return (connectedWallets[squidTypes.ChainType.EVM].address ??
+        walletClient?.account?.address ??
+        wagmiAddress);
+}
+
+function createBitcoinWalletVerificationSigner({ connectedWallets, }) {
+    const bitcoinWallet = connectedWallets[squidTypes.ChainType.BTC].wallet;
+    return {
+        sign: async ({ message }) => {
+            const bitcoinAddress = connectedWallets[squidTypes.ChainType.BTC].address;
+            const bitcoinConnector = bitcoinWallet?.connector;
+            const signMessage = bitcoinConnector?.signMessage;
+            if (!bitcoinAddress) {
+                throw new WalletVerificationSignatureError({
+                    code: exports.WalletVerificationSignatureErrorCode.WALLET_NOT_CONNECTED,
+                    chainType: squidTypes.ChainType.BTC,
+                    message: "Connect a Bitcoin wallet before signing verification messages.",
+                });
+            }
+            if (typeof signMessage !== "function") {
+                throw new WalletVerificationSignatureError({
+                    code: exports.WalletVerificationSignatureErrorCode.SIGNER_UNAVAILABLE,
+                    chainType: squidTypes.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: squidTypes.ChainType.BTC,
+                    message: "Failed to sign Bitcoin wallet verification message.",
+                    error,
+                });
+            }
+        },
+    };
+}
+
+function createCosmosWalletVerificationSigner({ connectedWallets, }) {
+    const cosmosWallet = connectedWallets[squidTypes.ChainType.COSMOS].wallet;
+    return {
+        sign: async ({ message, chainId }) => {
+            const cosmosAddress = connectedWallets[squidTypes.ChainType.COSMOS].address;
+            const provider = cosmosWallet?.connector?.().provider;
+            const signArbitrary = provider?.signArbitrary;
+            const getKey = provider?.getKey;
+            if (!cosmosAddress) {
+                throw new WalletVerificationSignatureError({
+                    code: exports.WalletVerificationSignatureErrorCode.WALLET_NOT_CONNECTED,
+                    chainType: squidTypes.ChainType.COSMOS,
+                    message: "Connect a Cosmos wallet before signing verification messages.",
+                });
+            }
+            if (typeof signArbitrary !== "function" || typeof getKey !== "function") {
+                throw new WalletVerificationSignatureError({
+                    code: exports.WalletVerificationSignatureErrorCode.SIGNER_UNAVAILABLE,
+                    chainType: squidTypes.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: squidTypes.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: exports.WalletVerificationSignatureErrorCode.WALLET_NOT_CONNECTED,
+                    chainType: squidTypes.ChainType.EVM,
+                    message: "Connect an EVM wallet before signing verification messages.",
+                });
+            }
+            if (typeof walletClient?.signMessage !== "function") {
+                throw new WalletVerificationSignatureError({
+                    code: exports.WalletVerificationSignatureErrorCode.SIGNER_UNAVAILABLE,
+                    chainType: squidTypes.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: squidTypes.ChainType.EVM,
+                    message: "Failed to sign EVM wallet verification message.",
+                    error,
+                });
+            }
+        },
+    };
+}
+
+function createSolanaWalletVerificationSigner({ connectedWallets, }) {
+    const solanaWallet = connectedWallets[squidTypes.ChainType.SOLANA].wallet;
+    return {
+        sign: async ({ message }) => {
+            const solanaAddress = connectedWallets[squidTypes.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: exports.WalletVerificationSignatureErrorCode.WALLET_NOT_CONNECTED,
+                    chainType: squidTypes.ChainType.SOLANA,
+                    message: "Connect a Solana wallet before signing verification messages.",
+                });
+            }
+            if (typeof signMessage !== "function") {
+                throw new WalletVerificationSignatureError({
+                    code: exports.WalletVerificationSignatureErrorCode.SIGNER_UNAVAILABLE,
+                    chainType: squidTypes.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: squidTypes.ChainType.SOLANA,
+                    message: "Failed to sign Solana wallet verification message.",
+                    error,
+                });
+            }
+        },
+    };
+}
+
+function createStellarWalletVerificationSigner({ connectedWallets, }) {
+    const stellarWallet = connectedWallets[squidTypes.ChainType.STELLAR].wallet;
+    return {
+        sign: async ({ message, networkPassphrase }) => {
+            const stellarAddress = connectedWallets[squidTypes.ChainType.STELLAR].address;
+            const stellarConnector = stellarWallet?.connector;
+            const signMessage = stellarConnector?.signMessage;
+            if (!stellarAddress) {
+                throw new WalletVerificationSignatureError({
+                    code: exports.WalletVerificationSignatureErrorCode.WALLET_NOT_CONNECTED,
+                    chainType: squidTypes.ChainType.STELLAR,
+                    message: "Connect a Stellar wallet before signing verification messages.",
+                });
+            }
+            if (typeof signMessage !== "function") {
+                throw new WalletVerificationSignatureError({
+                    code: exports.WalletVerificationSignatureErrorCode.SIGNER_UNAVAILABLE,
+                    chainType: squidTypes.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: exports.WalletVerificationSignatureErrorCode.ACTIVE_ACCOUNT_MISMATCH,
+                        chainType: squidTypes.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: squidTypes.ChainType.STELLAR,
+                    message: "Failed to sign Stellar wallet verification message.",
+                    error,
+                });
+            }
+        },
+    };
+}
+
+function createSuiWalletVerificationSigner({ connectedWallets, }) {
+    const suiWallet = connectedWallets[squidTypes.ChainType.SUI].wallet;
+    return {
+        sign: async ({ message }) => {
+            const suiAddress = connectedWallets[squidTypes.ChainType.SUI].address;
+            const suiAccount = connectedWallets[squidTypes.ChainType.SUI].account;
+            const signPersonalMessage = suiWallet?.connector.signPersonalMessage;
+            if (!suiAddress || !suiAccount) {
+                throw new WalletVerificationSignatureError({
+                    code: exports.WalletVerificationSignatureErrorCode.WALLET_NOT_CONNECTED,
+                    chainType: squidTypes.ChainType.SUI,
+                    message: "Connect a Sui wallet before signing verification messages.",
+                });
+            }
+            if (typeof signPersonalMessage !== "function") {
+                throw new WalletVerificationSignatureError({
+                    code: exports.WalletVerificationSignatureErrorCode.SIGNER_UNAVAILABLE,
+                    chainType: squidTypes.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: squidTypes.ChainType.SUI,
+                    message: "Failed to sign Sui wallet verification message.",
+                    error,
+                });
+            }
+        },
+    };
+}
+
+function createXrplWalletVerificationSigner({ connectedWallets, }) {
+    const xrplWallet = connectedWallets[squidTypes.ChainType.XRPL].wallet;
+    return {
+        sign: async ({ message }) => {
+            const xrplAddress = connectedWallets[squidTypes.ChainType.XRPL].address;
+            const xrplConnector = xrplWallet?.connector;
+            const signOwnershipMessage = xrplConnector?.signOwnershipMessage;
+            if (!xrplAddress) {
+                throw new WalletVerificationSignatureError({
+                    code: exports.WalletVerificationSignatureErrorCode.WALLET_NOT_CONNECTED,
+                    chainType: squidTypes.ChainType.XRPL,
+                    message: "Connect an XRPL wallet before signing verification messages.",
+                });
+            }
+            if (typeof signOwnershipMessage !== "function") {
+                throw new WalletVerificationSignatureError({
+                    code: exports.WalletVerificationSignatureErrorCode.SIGNER_UNAVAILABLE,
+                    chainType: squidTypes.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: squidTypes.ChainType.XRPL,
+                    message: "Failed to sign XRPL wallet verification message.",
+                    error,
+                });
+            }
+        },
+        cancel: () => {
+            xrplWallet?.connector.cancelSignOwnershipMessage?.();
+        },
+    };
+}
+
+function createWalletVerificationSigners(params) {
+    return {
+        [squidTypes.ChainType.EVM]: createEvmWalletVerificationSigner(params),
+        [squidTypes.ChainType.COSMOS]: createCosmosWalletVerificationSigner(params),
+        [squidTypes.ChainType.BTC]: createBitcoinWalletVerificationSigner(params),
+        [squidTypes.ChainType.SOLANA]: createSolanaWalletVerificationSigner(params),
+        [squidTypes.ChainType.SUI]: createSuiWalletVerificationSigner(params),
+        [squidTypes.ChainType.XRPL]: createXrplWalletVerificationSigner(params),
+        [squidTypes.ChainType.STELLAR]: createStellarWalletVerificationSigner(params),
+    };
+}
+
+const useWalletVerificationSignature = () => {
+    const connectedWallets = useWalletStore((store) => store.connectedWalletsByChainType);
+    const { address: wagmiAddress, connector: activeConnector } = wagmi.useAccount();
+    const evmWallet = connectedWallets[squidTypes.ChainType.EVM].wallet;
+    const evmConnector = evmWallet?.connector ?? activeConnector;
+    const { data: walletClient } = wagmi.useWalletClient({ connector: evmConnector });
+    const signers = React.useMemo(() => createWalletVerificationSigners({
+        connectedWallets,
+        walletClient,
+        wagmiAddress,
+    }), [connectedWallets, wagmiAddress, walletClient]);
+    const signVerificationMessage = React.useCallback(async (request) => {
+        assertWalletVerificationSigningRequest(request);
+        const signer = signers[request.chainType];
+        if (!signer) {
+            throw new WalletVerificationSignatureError({
+                code: exports.WalletVerificationSignatureErrorCode.UNSUPPORTED_CHAIN_TYPE,
+                chainType: request.chainType,
+                message: "Unsupported wallet verification chain type.",
+            });
+        }
+        return signer.sign(request);
+    }, [signers]);
+    const cancelSignVerificationMessage = React.useCallback(({ chainType } = {}) => {
+        if (!chainType) {
+            return;
+        }
+        signers[chainType]?.cancel?.();
+    }, [signers]);
+    const signVerificationMessageMutation = reactQuery.useMutation({
+        mutationFn: signVerificationMessage,
+    });
+    return {
+        signatureTypes: WALLET_VERIFICATION_SIGNATURE_TYPE_BY_CHAIN_TYPE,
+        supportedChainTypes: Object.values(squidTypes.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
@@ -37594,10 +38460,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 ||
@@ -37685,17 +38549,29 @@ exports.HederaExtensionHelper = HederaExtensionHelper;
 exports.Nr = Nr;
 exports.SquidProvider = SquidProvider;
 exports.TX_STATUS_CONSTANTS = TX_STATUS_CONSTANTS;
+exports.WALLET_VERIFICATION_SIGNATURE_TYPE_BY_CHAIN_TYPE = WALLET_VERIFICATION_SIGNATURE_TYPE_BY_CHAIN_TYPE;
+exports.WalletVerificationSignatureError = WalletVerificationSignatureError;
 exports.WidgetEvents = WidgetEvents;
 exports.Wo = Wo;
+exports.XAMAN_OWNERSHIP_CHALLENGE_MEMO_TYPE = XAMAN_OWNERSHIP_CHALLENGE_MEMO_TYPE;
 exports.accessProperty = accessProperty;
 exports.adaptiveRound = adaptiveRound;
 exports.addEthereumChain = addEthereumChain;
 exports.addTokenToWallet = addTokenToWallet;
 exports.areSameAddress = areSameAddress;
 exports.areTokenSymbolsCompatible = areTokenSymbolsCompatible;
+exports.assertEvmVerificationSigningRequest = assertEvmVerificationSigningRequest;
+exports.assertWalletVerificationSigningRequest = assertWalletVerificationSigningRequest;
 exports.assetsBaseUrl = assetsBaseUrl;
+exports.buildBitcoinWalletVerificationSignatureResult = buildBitcoinWalletVerificationSignatureResult;
+exports.buildCosmosWalletVerificationSignatureResult = buildCosmosWalletVerificationSignatureResult;
+exports.buildSolanaWalletVerificationSignatureResult = buildSolanaWalletVerificationSignatureResult;
+exports.buildStellarWalletVerificationSignatureResult = buildStellarWalletVerificationSignatureResult;
+exports.buildSuiWalletVerificationSignatureResult = buildSuiWalletVerificationSignatureResult;
 exports.buildUrlSearchParamsFromSwapEvent = buildUrlSearchParamsFromSwapEvent;
+exports.buildWalletVerificationSignatureResult = buildWalletVerificationSignatureResult;
 exports.buildXrplTrustSetTx = buildXrplTrustSetTx;
+exports.buildXrplWalletVerificationSignatureResult = buildXrplWalletVerificationSignatureResult;
 exports.calculateTotal24hChange = calculateTotal24hChange;
 exports.calculateTotalUsdBalanceUSD = calculateTotalUsdBalanceUSD;
 exports.cancelConnectWallet = cancelConnectWallet;
@@ -37722,6 +38598,7 @@ exports.fetchHighestBalanceToken = fetchHighestBalanceToken;
 exports.fetchSwapTransactionStatus = fetchSwapTransactionStatus;
 exports.filterChains = filterChains;
 exports.filterSolanaWallets = filterSolanaWallets;
+exports.filterSuiWallets = filterSuiWallets;
 exports.filterTokens = filterTokens;
 exports.filterTokensForDestination = filterTokensForDestination;
 exports.filterViewableTokens = filterViewableTokens;
@@ -37771,6 +38648,7 @@ exports.getStellarTrustLineAsset = getStellarTrustLineAsset;
 exports.getStepStatuses = getStepStatuses;
 exports.getStepsInfos = getStepsInfos;
 exports.getSuggestedAmountsForCurrency = getSuggestedAmountsForCurrency;
+exports.getSuiChain = getSuiChain;
 exports.getSupportedChainIdsForDirection = getSupportedChainIdsForDirection;
 exports.getSwapTxStatusRefetchInterval = getSwapTxStatusRefetchInterval;
 exports.getTokenAssetsKey = getTokenAssetsKey;
@@ -37786,15 +38664,16 @@ exports.getXummClient = getXummClient;
 exports.groupTokensByChainId = groupTokensByChainId;
 exports.groupTokensBySymbol = groupTokensBySymbol;
 exports.handleTransactionErrorEvents = handleTransactionErrorEvents;
-exports.initializeSquidData = initializeSquidData;
+exports.initializeSquidWithAssetsColors = initializeSquidWithAssetsColors;
 exports.is404Error = is404Error;
 exports.isActionCompletedOnSourceTx = isActionCompletedOnSourceTx;
+exports.isBitcoinAddressValid = isBitcoinAddressValid;
 exports.isChainflipBridgeTransaction = isChainflipBridgeTransaction;
-exports.isChainflipDepositRoute = isChainflipDepositRoute;
 exports.isCoralBridgeAction = isCoralBridgeAction;
 exports.isCosmosAddressValid = isCosmosAddressValid;
-exports.isDepositAddressDirectTransferRoute = isDepositAddressDirectTransferRoute;
+exports.isDepositRoute = isDepositRoute;
 exports.isEmptyObject = isEmptyObject;
+exports.isEvmAddressValid = isEvmAddressValid;
 exports.isEvmChainNotSupportedError = isEvmChainNotSupportedError;
 exports.isEvmosChain = isEvmosChain;
 exports.isFallbackAddressNeeded = isFallbackAddressNeeded;
@@ -37809,7 +38688,7 @@ exports.isStatusError = isStatusError;
 exports.isStellarAddressValid = isStellarAddressValid;
 exports.isStellarIssuedToken = isStellarIssuedToken;
 exports.isStellarToken = isStellarToken;
-exports.isSupportedChainType = isSupportedChainType;
+exports.isSuiAddressValid = isSuiAddressValid;
 exports.isSwapRouteError = isSwapRouteError;
 exports.isUserRejectionError = isUserRejectionError;
 exports.isValidHorizonAsset = isValidHorizonAsset;
@@ -37845,6 +38724,7 @@ exports.searchTokens = searchTokens;
 exports.shareSubgraphId = shareSubgraphId;
 exports.simplifyRouteAction = simplifyRouteAction;
 exports.sleep = sleep;
+exports.slushWebWalletData = slushWebWalletData;
 exports.sortAddressBook = sortAddressBook;
 exports.sortAllTokens = sortAllTokens;
 exports.sortTokensBySharedSubgraphIds = sortTokensBySharedSubgraphIds;
@@ -37874,7 +38754,6 @@ exports.useCountryDetails = useCountryDetails;
 exports.useCurrencyDetails = useCurrencyDetails;
 exports.useDebouncedValue = useDebouncedValue;
 exports.useDepositAddress = useDepositAddress;
-exports.useDepositTransactionStatus = useDepositTransactionStatus;
 exports.useEnsDataForAddress = useEnsDataForAddress;
 exports.useEnsSearch = useEnsSearch;
 exports.useEstimate = useEstimate;
@@ -37935,10 +38814,11 @@ exports.useTransactionStore = useTransactionStore;
 exports.useUrlSwapParams = useUrlSwapParams;
 exports.useWallet = useWallet;
 exports.useWalletStore = useWalletStore;
+exports.useWalletVerificationSignature = useWalletVerificationSignature;
 exports.useWallets = useWallets;
 exports.useXrplNativeBalance = useXrplNativeBalance;
 exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-mgE1SeE-.js.map
+//# sourceMappingURL=index-z1nGQX9p.js.map