@flarenetwork/multichain-wallet-connector 0.0.1-rc.0

package/dist/multichain-C5wKiJke.mjs

@@ -0,0 +1,2863 @@
+import { createPublicClient, createWalletClient, custom, defineChain, getAddress, getTypesForEIP712Domain, hashDomain, hashStruct, http, serializeSignature, serializeTransaction } from "viem";
+import { flare, flareTestnet, mainnet, sepolia, songbird } from "viem/chains";
+import { DisconnectedDevice, DisconnectedDeviceDuringOperation, LockedDeviceError, TransportInterfaceNotAvailable, TransportOpenUserCancelled, UserRefusedOnDevice } from "@ledgerhq/errors";
+import { Client, RippledError, encode } from "xrpl";
+import Eth from "@ledgerhq/hw-app-eth";
+import * as secp256k1 from "@noble/secp256k1";
+import { publicKeyToAddress, toAccount } from "viem/accounts";
+import { bytesToHex } from "viem/utils";
+import { FlareApp } from "@zondax/ledger-flare";
+import Xrp from "@ledgerhq/hw-app-xrp";
+import TransportWebHID from "@ledgerhq/hw-transport-webhid";
+import { MetaMaskSDK } from "@metamask/sdk";
+import { createAppKit } from "@reown/appkit";
+import UniversalProvider from "@walletconnect/universal-provider";
+import { Xumm } from "xumm";
+import { createStore } from "@xstate/store";
+
+//#region src/core/shared/type-utils.ts
+var TypeUtils = class {
+	static isError(value) {
+		return value instanceof Error;
+	}
+	static isObject(value) {
+		return typeof value === "object" && value !== null;
+	}
+	static isString(value) {
+		return typeof value === "string";
+	}
+};
+
+//#endregion
+//#region src/core/utils/utils.ts
+/**
+* Shortens an address for display (e.g., "0x1234...abcd").
+* @param address - The full address string
+* @param prefixLength - Number of characters to show at start (default: 6)
+* @param suffixLength - Number of characters to show at end (default: 4)
+*/
+function shortenAddress(address, prefixLength = 6, suffixLength = 4) {
+	const minLength = prefixLength + suffixLength + 3;
+	if (address.length <= minLength) return address;
+	return `${address.slice(0, prefixLength)}...${address.slice(-suffixLength)}`;
+}
+/** Type-safe `Object.keys()` that preserves key types. */
+function objectKeys(obj) {
+	return Object.keys(obj);
+}
+/** Type-safe `Object.values()` that preserves value types. */
+function objectValues(obj) {
+	return Object.values(obj);
+}
+/** Type-safe `Object.entries()` that preserves key and value types. */
+function objectEntries(obj) {
+	return Object.entries(obj);
+}
+/** Type-safe `Object.fromEntries()` that preserves key and value types. */
+function objectFromEntries(entries) {
+	return Object.fromEntries(entries);
+}
+
+//#endregion
+//#region src/core/chains/chain.constants.ts
+const CAIP2_NAMESPACES = {
+	eip155: "eip155",
+	xrpl: "xrpl",
+	bip122: "bip122"
+};
+const CAIP2 = {
+	[CAIP2_NAMESPACES.eip155]: {
+		"1": "Ethereum Mainnet",
+		"11155111": "Ethereum Sepolia",
+		"14": "Flare Mainnet",
+		"16": "Flare Testnet Coston",
+		"114": "Flare Testnet Coston2",
+		"19": "Songbird Canary-Network"
+	},
+	[CAIP2_NAMESPACES.xrpl]: {
+		"0": "XRP Ledger Mainnet",
+		"1": "XRP Ledger Testnet"
+	},
+	[CAIP2_NAMESPACES.bip122]: { "1a91e3dace36e2be3bf030a65679fe821": "Dogecoin Mainnet" }
+};
+
+//#endregion
+//#region src/core/chains/chain.utils.ts
+var ChainGuards = class {
+	static isRpcError(error) {
+		return TypeUtils.isObject(error) && Object.hasOwn(error, "code");
+	}
+	static isEvmCaip2(caip2) {
+		return caip2.startsWith("eip155:");
+	}
+	static isXrplCaip2(caip2) {
+		return caip2.startsWith("xrpl:");
+	}
+	static isEvmChain(chain) {
+		return chain.isEvm;
+	}
+	static isXrplChain(chain) {
+		return chain.caip2.startsWith("xrpl:");
+	}
+	static {
+		this.isEvmNamespace = (namespace) => namespace === "eip155";
+	}
+};
+function getEvmChainIdFromReference(reference) {
+	const referenceAsNumber = Number.parseInt(reference);
+	return {
+		id: referenceAsNumber.toString(),
+		hex: `0x${referenceAsNumber.toString(16)}`
+	};
+}
+function getChainName(namespace, reference) {
+	return CAIP2[namespace][reference];
+}
+function parseCaip2(caip2) {
+	const [namespace, reference] = caip2.split(":");
+	return {
+		namespace,
+		reference
+	};
+}
+function parseCaip10(account) {
+	const [namespace, reference, address] = account.split(":");
+	return {
+		namespace,
+		reference,
+		address
+	};
+}
+function createChainConfig(config) {
+	return objectFromEntries(objectEntries(config).map(([caip2, chain]) => {
+		const { namespace, reference } = parseCaip2(caip2);
+		const name = getChainName(namespace, reference);
+		if (ChainGuards.isEvmNamespace(namespace)) return [caip2, {
+			...chain,
+			namespace,
+			caip2,
+			name,
+			isEvm: true,
+			evmChain: getEvmChainIdFromReference(reference)
+		}];
+		return [caip2, {
+			...chain,
+			namespace,
+			caip2,
+			isEvm: false,
+			name
+		}];
+	}));
+}
+
+//#endregion
+//#region src/core/chains/viem/custom-chains.ts
+const flareCoston = defineChain({
+	id: 16,
+	name: "Flare Testnet Coston",
+	nativeCurrency: {
+		decimals: 18,
+		name: "Coston Flare",
+		symbol: "CFLR"
+	},
+	rpcUrls: { default: { http: ["https://coston-api.flare.network/ext/C/rpc"] } },
+	blockExplorers: { default: {
+		name: "Coston Explorer",
+		url: "https://coston-explorer.flare.network",
+		apiUrl: "https://coston-explorer.flare.network/api"
+	} },
+	testnet: true
+});
+
+//#endregion
+//#region src/core/chains/chain-registry.ts
+function defineChainRegistry(registry) {
+	return registry;
+}
+const chainRegistry = defineChainRegistry({
+	caip2Names: CAIP2,
+	chains: {
+		"eip155:1": {
+			testnet: false,
+			nativeCurrency: {
+				name: "Ethereum",
+				symbol: "ETH",
+				decimals: 18
+			},
+			rpcUrls: ["https://mainnet.infura.io/v3/"],
+			bip44Part: 60,
+			blockExplorerUrls: ["https://etherscan.io"]
+		},
+		"eip155:11155111": {
+			testnet: true,
+			nativeCurrency: {
+				name: "Ethereum",
+				symbol: "ETH",
+				decimals: 18
+			},
+			bip44Part: 60,
+			rpcUrls: ["https://sepolia.infura.io/v3/"],
+			blockExplorerUrls: ["https://sepolia.etherscan.io"]
+		},
+		"eip155:14": {
+			testnet: false,
+			nativeCurrency: {
+				name: "Flare",
+				symbol: "FLR",
+				decimals: 18
+			},
+			ledgerHrp: "flare",
+			bip44Part: 60,
+			rpcUrls: ["https://flare-api.flare.network/ext/C/rpc"],
+			blockExplorerUrls: ["https://flare-explorer.flare.network"]
+		},
+		"eip155:16": {
+			testnet: true,
+			nativeCurrency: {
+				name: "Coston Spark",
+				symbol: "CFLR",
+				decimals: 18
+			},
+			rpcUrls: ["https://coston-api.flare.network/ext/C/rpc"],
+			ledgerHrp: "coston",
+			bip44Part: 60,
+			blockExplorerUrls: ["https://coston-explorer.flare.network"]
+		},
+		"eip155:114": {
+			testnet: true,
+			nativeCurrency: {
+				name: "Coston2 Spark",
+				symbol: "C2FLR",
+				decimals: 18
+			},
+			ledgerHrp: "costwo",
+			bip44Part: 60,
+			rpcUrls: ["https://coston2-api.flare.network/ext/C/rpc"],
+			blockExplorerUrls: ["https://coston2-explorer.flare.network"]
+		},
+		"eip155:19": {
+			testnet: false,
+			nativeCurrency: {
+				name: "Songbird",
+				symbol: "SGB",
+				decimals: 18
+			},
+			ledgerHrp: "songbird",
+			bip44Part: 60,
+			rpcUrls: ["https://songbird-api.flare.network/ext/C/rpc"],
+			blockExplorerUrls: ["https://songbird-explorer.flare.network"]
+		},
+		"xrpl:0": {
+			testnet: false,
+			nativeCurrency: {
+				name: "XRP",
+				symbol: "XRP",
+				decimals: 15
+			},
+			bip44Part: 144,
+			rpcUrls: ["wss://xrplcluster.com"],
+			blockExplorerUrls: ["https://xrpscan.com"]
+		},
+		"xrpl:1": {
+			testnet: true,
+			nativeCurrency: {
+				name: "XRP",
+				symbol: "XRP",
+				decimals: 15
+			},
+			bip44Part: 144,
+			rpcUrls: ["wss://s.altnet.rippletest.net:51233"],
+			blockExplorerUrls: ["https://testnet.xrpscan.com"]
+		},
+		"bip122:1a91e3dace36e2be3bf030a65679fe821": {
+			testnet: false,
+			nativeCurrency: {
+				name: "Dogecoin",
+				symbol: "DOGE",
+				decimals: 8
+			},
+			bip44Part: 3,
+			rpcUrls: ["https://dogecoin-rpc.com"],
+			blockExplorerUrls: ["https://dogechain.info"]
+		}
+	},
+	viem: { chains: {
+		"eip155:1": mainnet,
+		"eip155:11155111": sepolia,
+		"eip155:14": flare,
+		"eip155:16": flareCoston,
+		"eip155:114": flareTestnet,
+		"eip155:19": songbird
+	} }
+});
+const chainConfig = createChainConfig(chainRegistry.chains);
+const evmCaip2s = objectKeys(chainConfig).filter(ChainGuards.isEvmCaip2);
+const evmChains = objectValues(chainConfig).filter(ChainGuards.isEvmChain);
+const isCaip2 = (caip2) => {
+	if (!caip2) return false;
+	return Object.hasOwn(chainConfig, caip2);
+};
+
+//#endregion
+//#region src/core/config/config-resolver.ts
+var ConfigResolver = class ConfigResolver {
+	constructor(options) {
+		this.globalOverrides = new Map(objectEntries(options.chainOverrides ?? {}));
+		this.walletOverrides = /* @__PURE__ */ new Map();
+		this.walletOptions = /* @__PURE__ */ new Map();
+		for (const [walletType, walletConfig] of objectEntries(options.wallets)) {
+			if (!walletConfig) continue;
+			this.walletOptions.set(walletType, walletConfig);
+			if (walletConfig.chainOverrides) this.walletOverrides.set(walletType, new Map(objectEntries(walletConfig.chainOverrides)));
+		}
+	}
+	getWalletOptions(walletType) {
+		return this.walletOptions.get(walletType);
+	}
+	resolveForWallet(walletType) {
+		const resolvedChains = {};
+		for (const [caip2, defaultConfig] of objectEntries(chainConfig)) resolvedChains[caip2] = this.resolveChain(caip2, defaultConfig, walletType);
+		return ConfigResolver.createResolvedConfig(walletType, resolvedChains);
+	}
+	resolveChain(caip2, defaultConfig, walletType) {
+		const globalOverride = this.globalOverrides.get(caip2);
+		const walletOverride = this.walletOverrides.get(walletType)?.get(caip2);
+		if (!globalOverride && !walletOverride) return defaultConfig;
+		let rpcUrls = defaultConfig.rpcUrls;
+		let blockExplorerUrls = defaultConfig.blockExplorerUrls;
+		let rpcOverride;
+		let explorerOverride;
+		if (globalOverride) {
+			if (globalOverride.rpcUrls?.length) {
+				rpcOverride = {
+					source: "global",
+					default: defaultConfig.rpcUrls[0]
+				};
+				rpcUrls = globalOverride.rpcUrls;
+			}
+			if (globalOverride.blockExplorerUrls?.length) {
+				explorerOverride = {
+					source: "global",
+					default: defaultConfig.blockExplorerUrls[0]
+				};
+				blockExplorerUrls = globalOverride.blockExplorerUrls;
+			}
+		}
+		if (walletOverride) {
+			if (walletOverride.rpcUrls?.length) {
+				rpcOverride = {
+					source: "wallet",
+					default: rpcOverride?.default ?? defaultConfig.rpcUrls[0]
+				};
+				rpcUrls = walletOverride.rpcUrls;
+			}
+			if (walletOverride.blockExplorerUrls?.length) {
+				explorerOverride = {
+					source: "wallet",
+					default: explorerOverride?.default ?? defaultConfig.blockExplorerUrls[0]
+				};
+				blockExplorerUrls = walletOverride.blockExplorerUrls;
+			}
+		}
+		const hasOverride = rpcOverride || explorerOverride;
+		return Object.freeze({
+			...defaultConfig,
+			rpcUrls,
+			blockExplorerUrls,
+			_override: hasOverride ? {
+				rpcUrls: rpcOverride,
+				blockExplorerUrls: explorerOverride
+			} : void 0
+		});
+	}
+	static createResolvedConfig(walletType, chains) {
+		const evmHexMap = /* @__PURE__ */ new Map();
+		for (const chain of objectValues(chains)) if (ChainGuards.isEvmChain(chain)) evmHexMap.set(chain.evmChain.hex, chain.caip2);
+		return Object.freeze({
+			walletType,
+			chains,
+			evmHexMap,
+			getChain(caip2) {
+				return chains[caip2];
+			},
+			getEvmChain(caip2) {
+				return chains[caip2];
+			},
+			getXrplChain(caip2) {
+				return chains[caip2];
+			},
+			getRpcUrl(caip2) {
+				return chains[caip2].rpcUrls[0];
+			},
+			getSupportedChains() {
+				return objectKeys(chains);
+			}
+		});
+	}
+};
+
+//#endregion
+//#region src/core/errors/error-codes.ts
+/**
+* Error codes for all connectors.
+* Numbers as keys = duplicates impossible.
+*
+* Ranges:
+* - 4000-4099: Common (all connectors)
+* - 4100-4199: MetaMask
+* - 4200-4299: Ledger
+* - 4300-4399: WalletConnect
+* - 4400-4499: Xaman
+* - 4500-4599: D'CENT
+*/
+const errorCodeMap = {
+	4001: "COMMON_USER_REJECTED",
+	4002: "COMMON_NOT_CONNECTED",
+	4003: "COMMON_CHAIN_NOT_CONFIGURED",
+	4004: "COMMON_CHAIN_NOT_SUPPORTED",
+	4005: "COMMON_FEATURE_NOT_SUPPORTED",
+	4006: "COMMON_CONNECTION_FAILED",
+	4007: "COMMON_UNKNOWN_CHAIN_ID",
+	4008: "COMMON_NO_ACCOUNTS",
+	4009: "COMMON_PROVIDER_ERROR",
+	4010: "COMMON_CONNECTION_IN_PROGRESS",
+	4100: "METAMASK_PROVIDER_NOT_FOUND",
+	4101: "METAMASK_CHAIN_NOT_ADDED",
+	4102: "METAMASK_NOT_INSTALLED",
+	4200: "LEDGER_DEVICE_LOCKED",
+	4201: "LEDGER_APP_NOT_OPEN",
+	4202: "LEDGER_WRONG_APP",
+	4203: "LEDGER_TRANSPORT_ERROR",
+	4204: "LEDGER_CONNECTION_FAILED",
+	4205: "LEDGER_TX_REJECTED",
+	4300: "WALLET_CONNECT_SESSION_EXPIRED",
+	4301: "WALLET_CONNECT_PAIRING_FAILED",
+	4302: "WALLET_CONNECT_SESSION_NOT_FOUND",
+	4303: "WALLET_CONNECT_PROVIDER_NOT_INITIALIZED",
+	4400: "XAMAN_SIGN_REJECTED",
+	4401: "XAMAN_QR_TIMEOUT",
+	4402: "XAMAN_SDK_NOT_READY",
+	4403: "XAMAN_AUTHORIZATION_FAILED",
+	4500: "DCENT_NOT_IN_BROWSER",
+	4501: "DCENT_SIGN_REJECTED"
+};
+function buildReverseMap() {
+	const entries = [];
+	for (const key in errorCodeMap) {
+		const num = Number(key);
+		const name = errorCodeMap[num];
+		entries.push([name, num]);
+	}
+	return objectFromEntries(entries);
+}
+const ErrorCode = buildReverseMap();
+
+//#endregion
+//#region src/core/errors/error-messages.ts
+/**
+* Human-readable error messages for each error code.
+*/
+const ErrorMessages = {
+	COMMON_USER_REJECTED: "User rejected the request",
+	COMMON_NOT_CONNECTED: "Wallet is not connected",
+	COMMON_CHAIN_NOT_CONFIGURED: "Chain is not configured",
+	COMMON_CHAIN_NOT_SUPPORTED: "Chain is not supported by this wallet",
+	COMMON_FEATURE_NOT_SUPPORTED: "Feature is not supported by this wallet",
+	COMMON_CONNECTION_FAILED: "Connection failed",
+	COMMON_UNKNOWN_CHAIN_ID: "Unknown chain ID",
+	COMMON_NO_ACCOUNTS: "No accounts available",
+	COMMON_PROVIDER_ERROR: "Provider error",
+	COMMON_CONNECTION_IN_PROGRESS: "Connection already in progress",
+	METAMASK_PROVIDER_NOT_FOUND: "MetaMask provider not found",
+	METAMASK_CHAIN_NOT_ADDED: "Chain is not added to MetaMask",
+	METAMASK_NOT_INSTALLED: "MetaMask is not installed",
+	LEDGER_DEVICE_LOCKED: "Ledger device is locked",
+	LEDGER_APP_NOT_OPEN: "Please open the correct app on your Ledger",
+	LEDGER_WRONG_APP: "Wrong app is open on Ledger device",
+	LEDGER_TRANSPORT_ERROR: "Ledger transport error",
+	LEDGER_CONNECTION_FAILED: "Failed to connect to Ledger device",
+	LEDGER_TX_REJECTED: "Transaction rejected on Ledger device",
+	WALLET_CONNECT_SESSION_EXPIRED: "WalletConnect session has expired",
+	WALLET_CONNECT_PAIRING_FAILED: "WalletConnect pairing failed",
+	WALLET_CONNECT_SESSION_NOT_FOUND: "WalletConnect session not found",
+	WALLET_CONNECT_PROVIDER_NOT_INITIALIZED: "WalletConnect provider not initialized",
+	XAMAN_SIGN_REJECTED: "Sign request rejected in Xaman",
+	XAMAN_QR_TIMEOUT: "Xaman QR scan timed out",
+	XAMAN_SDK_NOT_READY: "Xaman SDK is not ready",
+	XAMAN_AUTHORIZATION_FAILED: "Xaman authorization failed",
+	DCENT_NOT_IN_BROWSER: "D'CENT in-app browser not detected",
+	DCENT_SIGN_REJECTED: "Transaction rejected in D'CENT wallet"
+};
+
+//#endregion
+//#region src/core/errors/wallet-error.ts
+var WalletError = class extends Error {
+	constructor(walletType, codeKey, cause) {
+		const message = ErrorMessages[codeKey];
+		super(message, { cause });
+		this.name = "WalletError";
+		this.walletType = walletType;
+		this.codeKey = codeKey;
+		this.code = ErrorCode[codeKey];
+		this.cause = cause;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+
+//#endregion
+//#region src/core/connectors/dcent/dcent-error.ts
+var DcentError = class extends WalletError {
+	constructor(code, cause) {
+		super("dcent", code, cause);
+		this.name = "DcentError";
+	}
+	static fromError(_error) {
+		return null;
+	}
+};
+
+//#endregion
+//#region src/core/connectors/ledger/ledger-error.ts
+var LedgerError = class LedgerError extends WalletError {
+	static {
+		this.TRANSPORT_MAPPINGS = [
+			{
+				match: (e) => e instanceof LockedDeviceError,
+				code: "LEDGER_DEVICE_LOCKED"
+			},
+			{
+				match: (e) => e instanceof UserRefusedOnDevice,
+				code: "LEDGER_TX_REJECTED"
+			},
+			{
+				match: (e) => e instanceof TransportOpenUserCancelled,
+				code: "COMMON_USER_REJECTED"
+			},
+			{
+				match: (e) => e instanceof DisconnectedDevice,
+				code: "LEDGER_CONNECTION_FAILED"
+			},
+			{
+				match: (e) => e instanceof DisconnectedDeviceDuringOperation,
+				code: "LEDGER_CONNECTION_FAILED"
+			},
+			{
+				match: (e) => e instanceof TransportInterfaceNotAvailable,
+				code: "LEDGER_CONNECTION_FAILED"
+			}
+		];
+	}
+	constructor(code, cause) {
+		super("ledger", code, cause);
+		this.name = "LedgerError";
+	}
+	/** Maps raw @ledgerhq transport errors to LedgerError. Returns null for unknown errors. */
+	static fromError(error) {
+		for (const mapping of LedgerError.TRANSPORT_MAPPINGS) if (mapping.match(error)) return new LedgerError(mapping.code, error);
+		return null;
+	}
+};
+
+//#endregion
+//#region src/core/utils/chain-utils.ts
+/**
+* Chain utilities - extends ChainGuards with additional helpers.
+* For basic type guards (isEvmCaip2, isXrplCaip2), use ChainGuards directly.
+*/
+var ChainUtils = class ChainUtils {
+	static {
+		this.isEvmCaip2 = ChainGuards.isEvmCaip2;
+	}
+	static {
+		this.isXrplCaip2 = ChainGuards.isXrplCaip2;
+	}
+	static {
+		this.isEvmChain = ChainGuards.isEvmChain;
+	}
+	static isRpcError(error) {
+		return TypeUtils.isObject(error) && "code" in error && typeof error.code === "number";
+	}
+	static isRpcErrorWithCode(error, code) {
+		return ChainUtils.isRpcError(error) && error.code === code;
+	}
+	static buildEvmHexMap(chains) {
+		const map = /* @__PURE__ */ new Map();
+		for (const chain of chains) if (ChainGuards.isEvmChain(chain)) map.set(chain.evmChain.hex, chain.caip2);
+		return map;
+	}
+};
+
+//#endregion
+//#region src/core/connectors/metamask/metamask-error.ts
+var MetaMaskError = class MetaMaskError extends WalletError {
+	constructor(code, cause) {
+		super("metamask", code, cause);
+		this.name = "MetaMaskError";
+	}
+	static fromError(error) {
+		if (ChainUtils.isRpcErrorWithCode(error, 4001)) return new MetaMaskError("COMMON_USER_REJECTED", error);
+		return null;
+	}
+};
+
+//#endregion
+//#region src/core/connectors/wallet-connect/wallet-connect-error.ts
+var WalletConnectError = class WalletConnectError extends WalletError {
+	constructor(code, cause) {
+		super("wallet-connect", code, cause);
+		this.name = "WalletConnectError";
+	}
+	static fromError(error) {
+		if (ChainUtils.isRpcErrorWithCode(error, 4001)) return new WalletConnectError("COMMON_USER_REJECTED", error);
+		return null;
+	}
+};
+
+//#endregion
+//#region src/core/connectors/xaman/xaman-error.ts
+var XamanError = class extends WalletError {
+	constructor(code, cause) {
+		super("xaman", code, cause);
+		this.name = "XamanError";
+	}
+	static fromError(_error) {
+		return null;
+	}
+};
+
+//#endregion
+//#region src/core/errors/wallet-error-helper.ts
+var WalletErrorHelper = class {
+	static isWalletError(error) {
+		return error instanceof WalletError;
+	}
+	static from(error, walletType) {
+		if (error instanceof WalletError) return error;
+		switch (walletType) {
+			case "ledger": return LedgerError.fromError(error);
+			case "wallet-connect": return WalletConnectError.fromError(error);
+			case "metamask": return MetaMaskError.fromError(error);
+			case "xaman": return XamanError.fromError(error);
+			case "dcent": return DcentError.fromError(error);
+			default: return null;
+		}
+	}
+};
+
+//#endregion
+//#region src/core/utils/error-utils.ts
+var ErrorUtils = class ErrorUtils {
+	static extractMessage(error) {
+		if (TypeUtils.isString(error)) return error;
+		if (TypeUtils.isError(error)) return error.message;
+		if (TypeUtils.isObject(error) && "message" in error && TypeUtils.isString(error.message)) return error.message;
+		try {
+			return JSON.stringify(error);
+		} catch {
+			return "Unknown error";
+		}
+	}
+	static ensureError(error) {
+		if (TypeUtils.isError(error)) return error;
+		return new Error(ErrorUtils.extractMessage(error));
+	}
+};
+
+//#endregion
+//#region src/core/connectors/connector-events.ts
+var ConnectorEventEmitter = class {
+	constructor(store, walletType) {
+		this.store = store;
+		this.walletType = walletType;
+	}
+	startConnecting() {
+		this.store.send({ type: "startConnecting" });
+	}
+	connected(data) {
+		this.store.send({
+			type: "connectionEstablished",
+			activeAddress: data.address,
+			availableAddresses: this.resolveAddresses(data.addresses, data.caip2),
+			caip2: data.caip2
+		});
+	}
+	reconnected(data) {
+		this.store.send({
+			type: "connectionRestored",
+			activeAddress: data.address,
+			availableAddresses: this.resolveAddresses(data.addresses, data.caip2),
+			caip2: data.caip2
+		});
+	}
+	startDisconnecting() {
+		this.store.send({ type: "startDisconnecting" });
+	}
+	disconnected() {
+		this.store.send({ type: "disconnected" });
+	}
+	chainChanged(caip2) {
+		this.store.send({
+			type: "chainChanged",
+			caip2
+		});
+	}
+	addressChanged(data) {
+		this.store.send({
+			type: "addressChanged",
+			activeAddress: data.address,
+			availableAddresses: this.resolveAddresses(data.addresses, data.caip2)
+		});
+	}
+	error(error) {
+		this.store.send({
+			type: "error",
+			error
+		});
+	}
+	resolveAddresses(addresses, caip2) {
+		if (addresses.length === 0) return [];
+		if (typeof addresses[0] === "string") {
+			const isEvm = ChainUtils.isEvmCaip2(caip2);
+			return addresses.map((address) => ({
+				type: this.walletType,
+				address,
+				caip2,
+				isEvm
+			}));
+		}
+		return addresses;
+	}
+};
+
+//#endregion
+//#region src/core/connectors/base-connector.ts
+var BaseConnector = class {
+	constructor(store, config) {
+		this.initPromise = null;
+		this.initResolved = false;
+		this.store = store;
+		this.config = config;
+		this.walletType = config.walletType;
+		this.resolvedConfig = config.resolvedConfig;
+		this.events = new ConnectorEventEmitter(store, config.walletType);
+		this.connect = this.wrapAsync(this.connect);
+		this.disconnect = this.wrapAsync(this.disconnect);
+		this.restoreConnection = this.wrapAsync(this.restoreConnection);
+		this.switchChain = this.wrapAsync(this.switchChain);
+	}
+	get initialized() {
+		return this.initResolved;
+	}
+	async initialize() {
+		if (!this.initPromise) this.initPromise = this.onInitialize().then(() => {
+			this.initResolved = true;
+		}).catch((error) => {
+			this.initPromise = null;
+			throw error;
+		});
+		return this.initPromise;
+	}
+	/**
+	* Reset init state so next operation re-initializes the SDK.
+	* Required for MetaMask/Xaman (SDK terminates on disconnect).
+	* WalletConnect should NOT call this — its provider survives disconnect.
+	*/
+	resetInitialization() {
+		this.initPromise = null;
+		this.initResolved = false;
+	}
+	emitError(error) {
+		const message = ErrorUtils.extractMessage(error);
+		const code = WalletErrorHelper.isWalletError(error) ? error.code : "unknown";
+		this.events.error({
+			code,
+			message
+		});
+	}
+	wrapAsync(method) {
+		return (async (...args) => {
+			try {
+				return await method.apply(this, args);
+			} catch (error) {
+				this.emitError(error);
+				throw error;
+			}
+		});
+	}
+};
+
+//#endregion
+//#region src/core/clients/xrp/base-xrpl-client.ts
+var BaseXrplClient = class extends Client {
+	async onDestroy() {
+		if (this.isConnected()) await this.disconnect();
+	}
+	async ensureConnected() {
+		if (!this.isConnected()) await this.connect();
+	}
+	async getBalance(address) {
+		try {
+			await this.ensureConnected();
+			return await this.getXrpBalance(address);
+		} catch (error) {
+			if (error instanceof RippledError && error.message === "Account not found.") return 0;
+			throw error;
+		}
+	}
+};
+
+//#endregion
+//#region src/core/clients/xrp/xrpl-client.ts
+var XrplClient = class extends BaseXrplClient {
+	constructor(chain) {
+		super(chain.rpcUrls[0]);
+		this.chain = chain;
+	}
+	async getCaip2() {
+		return this.chain.caip2;
+	}
+	async onDestroy() {
+		await super.onDestroy();
+	}
+};
+
+//#endregion
+//#region src/core/connectors/dcent/dcent-xrpl-client.ts
+var DcentXrpClient = class {
+	constructor(provider, resolvedConfig) {
+		this.provider = provider;
+		this.resolvedConfig = resolvedConfig;
+	}
+	async sendTx(tx) {
+		const caip2 = await this.getCaip2();
+		const result = await this.provider.request({
+			method: "xrpl_signTransaction",
+			params: [{
+				tx_json: tx,
+				submit: true,
+				chainId: caip2,
+				autofill: true
+			}]
+		});
+		if (!result?.tx_hash) throw new DcentError("DCENT_SIGN_REJECTED");
+		return result.tx_hash;
+	}
+	async getBalance(address) {
+		const caip2 = await this.getCaip2();
+		return new XrplClient(this.resolvedConfig.getXrplChain(caip2)).getBalance(address);
+	}
+	async getCaip2() {
+		return (await this.provider.getWalletInfo()).chainId;
+	}
+	async onDestroy() {}
+};
+
+//#endregion
+//#region src/core/connectors/dcent/dcent-connector.ts
+const DCENT_NETWORK_MAP = {
+	"xrpl:0": "xrpl-mainnet",
+	"xrpl:1": "xrpl-testnet"
+};
+var DcentConnector = class DcentConnector extends BaseConnector {
+	constructor(store, config) {
+		super(store, config);
+	}
+	static isAvailable() {
+		return typeof window !== "undefined" && typeof window.xrpl !== "undefined";
+	}
+	static getDynamicLink(targetUrl, caip2) {
+		const url = new URL("https://link.dcentwallet.com/DAppBrowser/");
+		url.searchParams.set("url", targetUrl);
+		url.searchParams.set("network", DCENT_NETWORK_MAP[caip2]);
+		return url.toString();
+	}
+	async onInitialize() {
+		if (!DcentConnector.isAvailable()) return;
+		this.provider = window.xrpl;
+		this.client = new DcentXrpClient(this.provider, this.resolvedConfig);
+	}
+	async connect(_chains) {
+		if (!DcentConnector.isAvailable()) throw new DcentError("DCENT_NOT_IN_BROWSER");
+		if (this.connectionState === "connecting") throw new DcentError("COMMON_CONNECTION_IN_PROGRESS");
+		await this.initialize();
+		this.events.startConnecting();
+		const accounts = await this.provider.request({ method: "xrpl_accounts" });
+		if (!accounts?.length) throw new DcentError("COMMON_NO_ACCOUNTS");
+		const address = accounts[0];
+		const caip2 = await this.client.getCaip2();
+		this.events.connected({
+			address,
+			addresses: [address],
+			caip2
+		});
+	}
+	async disconnect() {
+		this.events.startDisconnecting();
+		this.events.disconnected();
+	}
+	async restoreConnection() {
+		if (!DcentConnector.isAvailable()) return;
+		await this.initialize();
+		const accounts = await this.provider.request({ method: "xrpl_accounts" });
+		if (!accounts?.length) return;
+		const address = accounts[0];
+		const caip2 = await this.client.getCaip2();
+		this.events.reconnected({
+			address,
+			addresses: [address],
+			caip2
+		});
+	}
+	async switchChain(caip2) {
+		await this.provider.request({
+			method: "xrpl_switchChain",
+			params: [{ chainId: caip2 }]
+		});
+		this.events.chainChanged(caip2);
+	}
+	getClient() {
+		return this.client;
+	}
+	getProvider() {
+		return this.provider;
+	}
+	get connectionState() {
+		return this.store.getSnapshot().context.connectionState;
+	}
+};
+
+//#endregion
+//#region src/core/shared/bip44.ts
+const BIP44_HARDENED_OFFSET = 2147483648;
+var Bip44 = class Bip44 {
+	constructor(path) {
+		const segments = (path.startsWith("m/") ? path.slice(2) : path).split("/");
+		if (segments.length !== 5) throw new Error(`Invalid BIP44 path: ${path}. Expected 5 components.`);
+		if (!segments[0].startsWith("44")) throw new Error(`Invalid BIP44 purpose: ${segments[0]}. Must be 44'.`);
+		this._purpose = this.parseComponent(segments[0]);
+		this._coinType = this.parseComponent(segments[1]);
+		this._account = this.parseComponent(segments[2]);
+		this._change = this.parseComponent(segments[3]);
+		this._addressIndex = this.parseComponent(segments[4]);
+		if (this._change.value !== 0 && this._change.value !== 1) throw new Error(`Invalid change value: ${this._change.value}. Must be 0 or 1.`);
+		if (!this._purpose.hardened || !this._coinType.hardened || !this._account.hardened) throw new Error("BIP44 requires purpose, coin type, and account to be hardened.");
+	}
+	get purpose() {
+		return this._purpose.value;
+	}
+	get coinType() {
+		return this._coinType.value;
+	}
+	get account() {
+		return this._account.value;
+	}
+	get change() {
+		return this._change.value;
+	}
+	get addressIndex() {
+		return this._addressIndex.value;
+	}
+	/**
+	* Generate paginated BIP44 paths.
+	* - bip44 standard: m/44'/coin'/0'/0/i — increments address index
+	* - Ledger Live: m/44'/coin'/i'/0/0 — increments account
+	*/
+	static getPaginatedBip44s({ from, to, ledgerHDStandard, caip2 }) {
+		const paths = [];
+		const coinType = Bip44.fromCaip2ToCoinType(caip2);
+		if (ledgerHDStandard === "bip44") for (let i = from; i < to; i++) {
+			const path = new Bip44(`44'/${coinType}'/0'/0/${i}`);
+			paths.push(path);
+		}
+		else for (let i = from; i < to; i++) {
+			const path = new Bip44(`44'/${coinType}'/${i}'/0/0`);
+			paths.push(path);
+		}
+		return {
+			paths,
+			from,
+			to,
+			ledgerHDStandard
+		};
+	}
+	static fromCaip2ToCoinType(caip2) {
+		if (!isCaip2(caip2)) throw new Error(`Invalid CAIP2: ${caip2}`);
+		const chain = chainConfig[caip2];
+		if (!chain.bip44Part) throw new Error(`Chain ${caip2} does not define a BIP44 part.`);
+		return chain.bip44Part;
+	}
+	static fromCaip2(caip2, account = 0, change = 0, addressIndex = 0) {
+		return Bip44.fromCoin(Bip44.fromCaip2ToCoinType(caip2), account, change, addressIndex);
+	}
+	static fromCoin(coinType, account = 0, change = 0, addressIndex = 0) {
+		return new Bip44(`44'/${coinType}'/${account}'/${change}/${addressIndex}`);
+	}
+	static bitcoin(account = 0, change = 0, addressIndex = 0) {
+		return Bip44.fromCoin(0, account, change, addressIndex);
+	}
+	static ethereum(account = 0, change = 0, addressIndex = 0) {
+		return Bip44.fromCoin(60, account, change, addressIndex);
+	}
+	static ledgerLiveEthereum(accountIndex = 0) {
+		return new Bip44(`44'/60'/${accountIndex}'/0/0`);
+	}
+	getIndexForStandard(standard) {
+		if (standard === "bip44") return this.addressIndex;
+		return this.account;
+	}
+	isChangeAddress() {
+		return this._change.value === 1;
+	}
+	isReceivingAddress() {
+		return this._change.value === 0;
+	}
+	getFullPath() {
+		return `m/${this.getPathWithoutMaster()}`;
+	}
+	getPathWithoutMaster() {
+		return `${this._purpose}/${this._coinType}/${this._account}/${this._change}/${this._addressIndex}`;
+	}
+	toPathArray() {
+		return [
+			this.hardenedValue(this._purpose),
+			this.hardenedValue(this._coinType),
+			this.hardenedValue(this._account),
+			this._change.value,
+			this._addressIndex.value
+		];
+	}
+	deriveFromAddressIndex(newAddressIndex) {
+		return new Bip44(`${this._purpose}/${this._coinType}/${this._account}/${this._change}/${newAddressIndex}`);
+	}
+	nextAddress(standard = "bip44") {
+		if (standard === "bip44") return this.deriveFromAddressIndex(this._addressIndex.value + 1);
+		return new Bip44(`${this._purpose}/${this._coinType}/${this._account.value + 1}'/${this._change}/${this._addressIndex}`);
+	}
+	toReceivingAddress(addressIndex) {
+		const index = addressIndex !== void 0 ? addressIndex : this._addressIndex.value;
+		return new Bip44(`${this._purpose}/${this._coinType}/${this._account}/0/${index}`);
+	}
+	toChangeAddress(addressIndex) {
+		const index = addressIndex !== void 0 ? addressIndex : this._addressIndex.value;
+		return new Bip44(`${this._purpose}/${this._coinType}/${this._account}/1/${index}`);
+	}
+	deriveAccount(accountIndex) {
+		return new Bip44(`${this._purpose}/${this._coinType}/${accountIndex}'/${this._change}/${this._addressIndex}`);
+	}
+	toString() {
+		return this.getFullPath();
+	}
+	getNextPaginatedBip44s(caip2, ledgerHDStandard) {
+		const currentAccountIndex = this.getIndexForStandard(ledgerHDStandard);
+		return Bip44.getPaginatedBip44s({
+			from: currentAccountIndex + 1,
+			to: currentAccountIndex + 6,
+			ledgerHDStandard,
+			caip2
+		});
+	}
+	isValidCaip2(caip2) {
+		return Bip44.fromCaip2ToCoinType(caip2) === this.coinType;
+	}
+	parseComponent(component) {
+		const hardened = component.endsWith("'") || component.endsWith("h");
+		const value = Number.parseInt(hardened ? component.slice(0, -1) : component, 10);
+		if (Number.isNaN(value)) throw new TypeError(`Invalid path component: ${component}`);
+		return {
+			value,
+			hardened,
+			toString: () => hardened ? `${value}'` : `${value}`
+		};
+	}
+	hardenedValue(component) {
+		return component.hardened ? component.value + BIP44_HARDENED_OFFSET : component.value;
+	}
+};
+
+//#endregion
+//#region src/core/shared/connection-mutex.ts
+/**
+* Async mutex for serializing connection operations.
+* Uses promise chaining to ensure FIFO ordering.
+*/
+var ConnectionMutex = class {
+	constructor() {
+		this.queue = Promise.resolve();
+	}
+	async run(fn) {
+		let release;
+		const waitForTurn = this.queue;
+		this.queue = new Promise((r) => {
+			release = r;
+		});
+		await waitForTurn;
+		try {
+			return await fn();
+		} finally {
+			release();
+		}
+	}
+};
+
+//#endregion
+//#region src/core/connectors/ledger/internal/ledger-hex-utils.ts
+var LedgerHexUtils = class {
+	static ensureLeading0x(input) {
+		return input.startsWith("0x") ? input : `0x${input}`;
+	}
+	static trimLeading0x(input) {
+		return input.startsWith("0x") ? input.substring(2) : input;
+	}
+	static fromBuffer(buffer) {
+		return `0x${Array.from(buffer).map((item) => item.toString(16).padStart(2, "0")).join("")}`;
+	}
+};
+
+//#endregion
+//#region src/core/connectors/ledger/internal/ledger-address-helper.ts
+var LedgerAddressHelper = class {
+	static async getComputedAddresses(app, bip44s, hrp) {
+		const addresses = [];
+		for (const bip44 of bip44s) {
+			const computedAddress = await app.getComputedAddress(bip44, hrp);
+			addresses.push(computedAddress);
+		}
+		return addresses;
+	}
+	static compressedPKToAddress(compressedPK) {
+		const publicKeyHex = bytesToHex(compressedPK);
+		const point = secp256k1.Point.fromHex(LedgerHexUtils.trimLeading0x(publicKeyHex));
+		return publicKeyToAddress(LedgerHexUtils.fromBuffer(point.toBytes(false)));
+	}
+};
+
+//#endregion
+//#region src/core/connectors/ledger/apps/ethereum/ethereum-viem-adapter.ts
+async function ledgerToEthAccount({ ledger, derivationPath }) {
+	const resolvedPath = derivationPath ?? `44'/60'/0'/0/0`;
+	const { address, publicKey } = await ledger.getAddress(resolvedPath, false);
+	return {
+		...toAccount({
+			address: getAddress(address),
+			async signTransaction(transaction) {
+				const hash = serializeTransaction(transaction);
+				const signedTxn = await ledger.signTransaction(resolvedPath, LedgerHexUtils.trimLeading0x(hash), null);
+				let { v: _v } = signedTxn;
+				const { r, s } = signedTxn;
+				if (typeof _v === "string" && (_v === "" || _v === "0x")) _v = "0x0";
+				let v;
+				try {
+					v = BigInt(typeof _v === "string" ? LedgerHexUtils.ensureLeading0x(_v) : _v);
+				} catch (error) {
+					throw new Error(`Ledger signature \`v\` was malformed and couldn't be parsed \`${_v}\` (Original error: ${error})`);
+				}
+				return serializeTransaction(transaction, {
+					r: LedgerHexUtils.ensureLeading0x(r),
+					s: LedgerHexUtils.ensureLeading0x(s),
+					v
+				});
+			},
+			async signMessage({ message }) {
+				const { r, s, v } = await ledger.signPersonalMessage(resolvedPath, `0x${Buffer.from(message).toString("hex")}`);
+				return serializeSignature({
+					r: LedgerHexUtils.ensureLeading0x(r),
+					s: LedgerHexUtils.ensureLeading0x(s),
+					v: BigInt(v)
+				});
+			},
+			async signTypedData(_parameters) {
+				const { domain = {}, message, primaryType } = _parameters;
+				const types = {
+					EIP712Domain: getTypesForEIP712Domain({ domain }),
+					..._parameters.types
+				};
+				const domainSeparator = hashDomain({
+					domain,
+					types
+				});
+				const messageHash = hashStruct({
+					data: message,
+					primaryType,
+					types
+				});
+				const { r, s, v } = await ledger.signEIP712HashedMessage(resolvedPath, domainSeparator, messageHash);
+				return serializeSignature({
+					r: LedgerHexUtils.ensureLeading0x(r),
+					s: LedgerHexUtils.ensureLeading0x(s),
+					v: BigInt(v)
+				});
+			}
+		}),
+		publicKey: LedgerHexUtils.ensureLeading0x(publicKey),
+		source: "ledger"
+	};
+}
+
+//#endregion
+//#region src/core/connectors/ledger/apps/ethereum/ethereum-ledger-app.ts
+var EthereumLedgerApp = class extends Eth {
+	async getComputedAddress(bip44, _hrp) {
+		return {
+			address: (await this.getAddress(bip44.getFullPath())).address,
+			bip44
+		};
+	}
+	async getComputedAddresses(bip44s, hrp) {
+		return LedgerAddressHelper.getComputedAddresses(this, bip44s, hrp);
+	}
+	async getViemAccount(bip44) {
+		return ledgerToEthAccount({
+			ledger: this,
+			derivationPath: bip44.getPathWithoutMaster()
+		});
+	}
+};
+
+//#endregion
+//#region src/core/connectors/ledger/apps/flare/flare-viem-adapter.ts
+async function ledgerToFlareAccount({ ledger, derivationPath }) {
+	const resolvedPath = derivationPath ?? `44'/60'/0'/0/0`;
+	const { address, publicKey } = await ledger.getEVMAddress(resolvedPath, false);
+	return {
+		...toAccount({
+			address: getAddress(address),
+			async signTransaction(transaction) {
+				const hash = serializeTransaction(transaction);
+				const signedTxn = await ledger.signEVMTransaction(resolvedPath, LedgerHexUtils.trimLeading0x(hash), null);
+				let { v: _v } = signedTxn;
+				const { r, s } = signedTxn;
+				if (typeof _v === "string" && (_v === "" || _v === "0x")) _v = "0x0";
+				let v;
+				try {
+					v = BigInt(typeof _v === "string" ? LedgerHexUtils.ensureLeading0x(_v) : _v);
+				} catch (error) {
+					throw new Error(`Ledger signature \`v\` was malformed and couldn't be parsed \`${_v}\` (Original error: ${error})`);
+				}
+				return serializeTransaction(transaction, {
+					r: LedgerHexUtils.ensureLeading0x(r),
+					s: LedgerHexUtils.ensureLeading0x(s),
+					v
+				});
+			},
+			async signMessage({ message }) {
+				const { r, s, v } = await ledger.signPersonalMessage(resolvedPath, `0x${Buffer.from(message).toString("hex")}`);
+				return serializeSignature({
+					r: LedgerHexUtils.ensureLeading0x(r),
+					s: LedgerHexUtils.ensureLeading0x(s),
+					v: BigInt(v)
+				});
+			},
+			async signTypedData() {
+				throw new Error("signTypedData not supported for Flare Ledger");
+			}
+		}),
+		publicKey: LedgerHexUtils.ensureLeading0x(publicKey),
+		source: "ledger"
+	};
+}
+
+//#endregion
+//#region src/core/connectors/ledger/apps/flare/flare-ledger-app.ts
+var FlareLedgerApp = class extends FlareApp {
+	async getComputedAddress(bip44, hrp) {
+		const addressData = await this.getAddressAndPubKey(bip44.getFullPath(), hrp);
+		return {
+			address: LedgerAddressHelper.compressedPKToAddress(addressData.compressed_pk),
+			bip44
+		};
+	}
+	async getComputedAddresses(bip44s, hrp) {
+		return LedgerAddressHelper.getComputedAddresses(this, bip44s, hrp);
+	}
+	async getViemAccount(bip44) {
+		return ledgerToFlareAccount({
+			ledger: this,
+			derivationPath: bip44.getPathWithoutMaster()
+		});
+	}
+};
+
+//#endregion
+//#region src/core/connectors/ledger/apps/xrp/xrp-ledger-app.ts
+var XrpLedgerApp = class extends Xrp {
+	async getComputedAddress(bip44, _hrp) {
+		const pathWithoutMaster = bip44.getPathWithoutMaster();
+		return {
+			address: (await this.getAddress(pathWithoutMaster)).address,
+			bip44
+		};
+	}
+	async getComputedAddresses(bip44s, hrp) {
+		return LedgerAddressHelper.getComputedAddresses(this, bip44s, hrp);
+	}
+};
+
+//#endregion
+//#region src/core/connectors/ledger/internal/ledger-app-factory.ts
+const CHAIN_TO_APP = {
+	"eip155:1": ["Ethereum"],
+	"eip155:11155111": ["Ethereum"],
+	"eip155:14": ["Flare Network"],
+	"eip155:16": ["Flare Network"],
+	"eip155:114": ["Flare Network"],
+	"eip155:19": ["Flare Network"],
+	"xrpl:0": ["XRP"],
+	"xrpl:1": ["XRP"]
+};
+var LedgerAppFactory = class {
+	static getRequiredAppName(chain) {
+		const apps = CHAIN_TO_APP[chain];
+		if (!apps?.length) throw new LedgerError("COMMON_CHAIN_NOT_SUPPORTED");
+		return apps[0];
+	}
+	static createApp(chain, transport) {
+		const validApps = CHAIN_TO_APP[chain];
+		if (!validApps?.length) throw new LedgerError("COMMON_CHAIN_NOT_SUPPORTED");
+		switch (validApps[0]) {
+			case "XRP": return new XrpLedgerApp(transport);
+			case "Ethereum": return new EthereumLedgerApp(transport);
+			case "Flare Network": return new FlareLedgerApp(transport);
+			default: throw new LedgerError("COMMON_CHAIN_NOT_SUPPORTED");
+		}
+	}
+};
+
+//#endregion
+//#region src/core/chains/viem/viem-helper.ts
+var ViemHelper = class ViemHelper {
+	static {
+		this.caip2ToViemChain = ViemHelper.buildChainMap();
+	}
+	static toViemChain(chain) {
+		return defineChain({
+			id: Number(chain.evmChain.id),
+			name: chain.name,
+			nativeCurrency: chain.nativeCurrency,
+			rpcUrls: { default: { http: chain.rpcUrls } },
+			blockExplorers: chain.blockExplorerUrls.length ? { default: {
+				name: "Explorer",
+				url: chain.blockExplorerUrls[0]
+			} } : void 0,
+			testnet: chain.testnet
+		});
+	}
+	static buildChainMap() {
+		return {
+			...objectFromEntries(evmChains.map((chain) => [chain.caip2, ViemHelper.toViemChain(chain)])),
+			...chainRegistry.viem?.chains ?? {}
+		};
+	}
+	static {
+		this.getViemWalletClientFromAccount = (caip2, account) => {
+			return createWalletClient({
+				chain: ViemHelper.caip2ToViemChain[caip2],
+				transport: http(),
+				account
+			});
+		};
+	}
+	static {
+		this.getViemPublicClientFromAccount = (caip2, _account) => {
+			return createPublicClient({
+				chain: ViemHelper.caip2ToViemChain[caip2],
+				transport: http()
+			});
+		};
+	}
+};
+
+//#endregion
+//#region src/core/clients/base-evm-client.ts
+var BaseEvmClient = class {
+	constructor(chainConfig) {
+		this.chainConfig = chainConfig;
+	}
+	async getCaip2() {
+		return this.chainConfig.caip2;
+	}
+	async onDestroy() {}
+};
+
+//#endregion
+//#region src/core/clients/evm/evm-client.ts
+/**
+* EVM chain client.
+* Provides Viem public and wallet clients for EVM chain interactions.
+*/
+var EvmClient = class EvmClient extends BaseEvmClient {
+	constructor(chainConfig, publicClient, walletClient) {
+		super(chainConfig);
+		this.publicClient = publicClient;
+		this.walletClient = walletClient;
+	}
+	/**
+	* Create an EVM client from chain config and provider.
+	*/
+	static create(chainConfig, provider) {
+		const viemChain = ViemHelper.toViemChain(chainConfig);
+		return new EvmClient(chainConfig, createPublicClient({
+			chain: viemChain,
+			transport: custom(provider)
+		}), createWalletClient({
+			chain: viemChain,
+			transport: custom(provider)
+		}));
+	}
+	/**
+	* Create an EVM client with HTTP transport (for read-only operations).
+	*/
+	static createReadOnly(chainConfig) {
+		const viemChain = ViemHelper.toViemChain(chainConfig);
+		return new EvmClient(chainConfig, createPublicClient({
+			chain: viemChain,
+			transport: http(chainConfig.rpcUrls[0])
+		}), createWalletClient({
+			chain: viemChain,
+			transport: http(chainConfig.rpcUrls[0])
+		}));
+	}
+	getPublicClient() {
+		return this.publicClient;
+	}
+	getWalletClient() {
+		return this.walletClient;
+	}
+	async getAccount() {
+		if (this.walletClient.account) return this.walletClient.account;
+		const [address] = await this.walletClient.getAddresses();
+		return address;
+	}
+	/**
+	* Get balance for an address in wei.
+	*/
+	async getBalance(address) {
+		return this.publicClient.getBalance({ address });
+	}
+	/**
+	* Get the EVM chain config.
+	*/
+	get evmChainConfig() {
+		return this.chainConfig;
+	}
+};
+
+//#endregion
+//#region src/core/connectors/ledger/clients/ledger-evm-client.ts
+var LedgerEvmClient = class LedgerEvmClient extends EvmClient {
+	constructor(chain, publicClient, walletClient, app) {
+		super(chain, publicClient, walletClient);
+		this._app = app;
+	}
+	static createForLedger(args, chain, account) {
+		return new LedgerEvmClient(chain, ViemHelper.getViemPublicClientFromAccount(chain.caip2, account), ViemHelper.getViemWalletClientFromAccount(chain.caip2, account), args.app);
+	}
+	getLedgerApp() {
+		return this._app;
+	}
+};
+
+//#endregion
+//#region src/core/connectors/ledger/clients/ledger-xrp-client.ts
+var LedgerXrpClient = class extends XrplClient {
+	constructor(chain, args) {
+		super(chain);
+		this.args = args;
+	}
+	getLedgerApp() {
+		return this.args.app;
+	}
+	async getAddressInfo() {
+		const app = this.getLedgerApp();
+		const path = this.args.bip44.getPathWithoutMaster();
+		return app.getAddress(path);
+	}
+	async sendTx(tx) {
+		await this.ensureConnected();
+		const { publicKey } = await this.getAddressInfo();
+		const prepared = await this.autofill(tx);
+		prepared.SigningPubKey = publicKey.toUpperCase();
+		const blob = encode(prepared);
+		const app = this.getLedgerApp();
+		const path = this.args.bip44.getPathWithoutMaster();
+		prepared.TxnSignature = (await app.signTransaction(path, blob)).toUpperCase();
+		return (await this.submitAndWait(prepared)).result.hash;
+	}
+};
+
+//#endregion
+//#region src/core/connectors/ledger/internal/ledger-client-factory.ts
+var LedgerClientFactory = class {
+	constructor(resolvedConfig) {
+		this.resolvedConfig = resolvedConfig;
+	}
+	async create(chain, app, bip44) {
+		if (ChainGuards.isXrplCaip2(chain)) return new LedgerXrpClient(this.resolvedConfig.getXrplChain(chain), {
+			app,
+			caip2: chain,
+			bip44
+		});
+		if (ChainGuards.isEvmCaip2(chain)) {
+			const evmChain = this.resolvedConfig.getEvmChain(chain);
+			const viemAccount = await app.getViemAccount(bip44);
+			return LedgerEvmClient.createForLedger({
+				app,
+				caip2: chain,
+				bip44
+			}, evmChain, viemAccount);
+		}
+		throw new LedgerError("COMMON_CHAIN_NOT_SUPPORTED");
+	}
+};
+
+//#endregion
+//#region src/core/storage/local-storage-manager.ts
+var LocalStorageManager = class {
+	constructor(options) {
+		this.prefix = options.prefix;
+		this.separator = options.separator;
+	}
+	getPrefixedKey(key) {
+		return `${this.prefix}${this.separator}${String(key)}`;
+	}
+	getKey(key) {
+		return this.getPrefixedKey(key);
+	}
+	set(key, value) {
+		const fullKey = this.getPrefixedKey(key);
+		const stringifiedValue = typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
+		try {
+			localStorage.setItem(fullKey, stringifiedValue);
+		} catch (error) {
+			console.error(`LocalStorageManager: Failed to set "${fullKey}"`, error);
+		}
+	}
+	get(key) {
+		const fullKey = this.getPrefixedKey(key);
+		const storedValue = localStorage.getItem(fullKey);
+		if (storedValue === null) return null;
+		try {
+			return JSON.parse(storedValue);
+		} catch {
+			return storedValue;
+		}
+	}
+	remove(key) {
+		localStorage.removeItem(this.getPrefixedKey(key));
+	}
+	has(key) {
+		return localStorage.getItem(this.getPrefixedKey(key)) !== null;
+	}
+	clear() {
+		const prefixWithSeparator = `${this.prefix}${this.separator}`;
+		const keysToRemove = [];
+		for (let i = 0; i < localStorage.length; i++) {
+			const key = localStorage.key(i);
+			if (key?.startsWith(prefixWithSeparator)) keysToRemove.push(key);
+		}
+		keysToRemove.forEach((key) => localStorage.removeItem(key));
+	}
+};
+
+//#endregion
+//#region src/core/storage/local-storage-schema.ts
+/**
+* Main storage instance for MWC.
+* All keys are prefixed with "mwc:".
+*/
+const mwcStorage = new LocalStorageManager({
+	prefix: "mwc",
+	separator: ":"
+});
+
+//#endregion
+//#region src/core/connectors/ledger/internal/ledger-storage.ts
+var LedgerStorage = class {
+	constructor(storage) {
+		this.storage = storage;
+	}
+	setCaip2(caip2) {
+		this.storage.set("ledger:caip2", caip2);
+	}
+	getCaip2() {
+		return this.storage.get("ledger:caip2");
+	}
+	setBip44(bip44) {
+		this.storage.set("ledger:bip44", bip44);
+	}
+	getBip44() {
+		return this.storage.get("ledger:bip44");
+	}
+	setHDStandard(standard) {
+		this.storage.set("ledger:hd-standard", standard);
+	}
+	getHDStandard() {
+		return this.storage.get("ledger:hd-standard");
+	}
+	clear() {
+		this.storage.remove("ledger:caip2");
+		this.storage.remove("ledger:bip44");
+		this.storage.remove("ledger:hd-standard");
+		this.storage.remove("ledger:device-hid");
+	}
+};
+const ledgerStorage = new LedgerStorage(mwcStorage);
+
+//#endregion
+//#region src/core/connectors/ledger/internal/ledger-session-manager.ts
+var LedgerSessionManager = class {
+	constructor() {
+		this.current = null;
+	}
+	save(session) {
+		this.current = session;
+		ledgerStorage.setCaip2(session.caip2);
+		ledgerStorage.setBip44(session.bip44.getFullPath());
+		ledgerStorage.setHDStandard(session.hdStandard);
+	}
+	loadSaved() {
+		const caip2 = ledgerStorage.getCaip2();
+		const bip44Path = ledgerStorage.getBip44();
+		const hdStandard = ledgerStorage.getHDStandard();
+		if (!caip2 || !bip44Path || !hdStandard) return null;
+		try {
+			return {
+				caip2,
+				bip44: new Bip44(bip44Path),
+				hdStandard
+			};
+		} catch {
+			ledgerStorage.clear();
+			return null;
+		}
+	}
+	getSession() {
+		return this.current;
+	}
+	requireSession() {
+		if (!this.current) throw new LedgerError("COMMON_NOT_CONNECTED");
+		return this.current;
+	}
+	clear() {
+		this.current = null;
+		ledgerStorage.clear();
+	}
+};
+
+//#endregion
+//#region src/core/connectors/ledger/internal/ledger-transport-manager.ts
+var LedgerTransportManager = class {
+	constructor() {
+		this.transport = null;
+		this.disconnectHandler = null;
+	}
+	async open() {
+		if (this.transport) {
+			console.debug("[Ledger] TransportManager.open(): reusing existing transport");
+			return this.transport;
+		}
+		console.debug("[Ledger] TransportManager.open(): checking for connected device");
+		const existing = await TransportWebHID.openConnected();
+		if (existing) console.debug("[Ledger] TransportManager.open(): found connected device");
+		else console.debug("[Ledger] TransportManager.open(): creating new transport (will prompt user)");
+		this.transport = existing ?? await TransportWebHID.create();
+		this.attachDisconnectHandler();
+		console.debug("[Ledger] TransportManager.open(): transport ready");
+		return this.transport;
+	}
+	async checkDeviceStatus() {
+		const devices = await TransportWebHID.list();
+		console.debug("[Ledger] TransportManager.checkDeviceStatus(): devices found", devices.length);
+		if (devices.length === 0) return { available: false };
+		try {
+			console.debug("[Ledger] TransportManager.checkDeviceStatus(): opening transport");
+			const transport = await TransportWebHID.openConnected();
+			if (!transport) {
+				console.debug("[Ledger] TransportManager.checkDeviceStatus(): could not open transport");
+				return { available: false };
+			}
+			this.transport = transport;
+			this.attachDisconnectHandler();
+			console.debug("[Ledger] TransportManager.checkDeviceStatus(): getting current app");
+			const currentApp = await this.getCurrentApp();
+			console.debug("[Ledger] TransportManager.checkDeviceStatus(): current app", currentApp.name);
+			return {
+				available: true,
+				currentApp
+			};
+		} catch (error) {
+			console.debug("[Ledger] TransportManager.checkDeviceStatus(): failed", error);
+			return { available: false };
+		}
+	}
+	async getCurrentApp() {
+		const transport = await this.open();
+		console.debug("[Ledger] TransportManager.getCurrentApp(): sending APDU command");
+		const response = await transport.send(176, 1, 0, 0);
+		let index = 0;
+		if (response[index++] !== 1) throw new LedgerError("LEDGER_APP_NOT_OPEN");
+		const nameLength = response[index++];
+		const nameStartIndex = index;
+		index += nameLength;
+		const name = response.subarray(nameStartIndex, index).toString("ascii");
+		const versionLength = response[index++];
+		const versionStartIndex = index;
+		index += versionLength;
+		const version = response.subarray(versionStartIndex, index).toString("ascii");
+		const flagLength = response[index++];
+		const flagsStartIndex = index;
+		index += flagLength;
+		const flags = response.subarray(flagsStartIndex, index);
+		console.debug("[Ledger] TransportManager.getCurrentApp(): received", {
+			name,
+			version
+		});
+		return {
+			name,
+			version,
+			flags
+		};
+	}
+	async close() {
+		if (this.transport) {
+			console.debug("[Ledger] TransportManager.close(): closing transport");
+			await this.transport.close();
+			this.transport = null;
+			console.debug("[Ledger] TransportManager.close(): transport closed");
+		}
+	}
+	onDisconnect(handler) {
+		this.disconnectHandler = handler;
+		this.attachDisconnectHandler();
+	}
+	attachDisconnectHandler() {
+		if (this.transport && this.disconnectHandler) this.transport.on("disconnect", this.disconnectHandler);
+	}
+};
+
+//#endregion
+//#region src/core/connectors/ledger/ledger-connector.ts
+var LedgerConnector = class extends BaseConnector {
+	constructor(store, config) {
+		super(store, config);
+		this.transportManager = new LedgerTransportManager();
+		this.sessionManager = new LedgerSessionManager();
+		this.mutex = new ConnectionMutex();
+		this.client = null;
+		this.clientFactory = new LedgerClientFactory(this.resolvedConfig);
+		this.transportManager.onDisconnect(() => this.handleDisconnect());
+	}
+	async onInitialize() {}
+	async connect(chain, options) {
+		console.debug("[Ledger] connect() called", {
+			chain,
+			options
+		});
+		await this.mutex.run(() => this.performConnect(chain, options ?? {
+			bip44: Bip44.fromCaip2(chain, 0, 0, 0),
+			ledgerHDStandard: "bip44"
+		}));
+	}
+	async disconnect() {
+		this.events.startDisconnecting();
+		await this.transportManager.close();
+		this.client = null;
+		this.sessionManager.clear();
+		this.events.disconnected();
+	}
+	async restoreConnection() {
+		console.debug("[Ledger] restoreConnection() called");
+		if (this.client) {
+			console.debug("[Ledger] restoreConnection(): client already exists, skipping");
+			return;
+		}
+		const saved = this.sessionManager.loadSaved();
+		if (!saved) {
+			console.debug("[Ledger] restoreConnection(): no saved session, skipping");
+			return;
+		}
+		const status = await this.transportManager.checkDeviceStatus();
+		if (!status.available) {
+			console.debug("[Ledger] restoreConnection(): device not available, skipping");
+			return;
+		}
+		const requiredApp = LedgerAppFactory.getRequiredAppName(saved.caip2);
+		if (status.currentApp?.name !== requiredApp) {
+			console.debug("[Ledger] restoreConnection(): wrong app", {
+				required: requiredApp,
+				current: status.currentApp?.name
+			});
+			return;
+		}
+		console.debug("[Ledger] restoreConnection(): starting restore", { chain: saved.caip2 });
+		await this.mutex.run(() => this.performRestore(saved));
+	}
+	async switchChain(chain) {
+		const { bip44, hdStandard } = this.sessionManager.requireSession();
+		await this.connect(chain, {
+			bip44: Bip44.fromCaip2(chain, bip44.account, bip44.change, bip44.addressIndex),
+			ledgerHDStandard: hdStandard
+		});
+	}
+	getSession() {
+		return this.sessionManager.getSession();
+	}
+	getClient() {
+		if (!this.client) throw new LedgerError("COMMON_NOT_CONNECTED");
+		return this.client;
+	}
+	getProvider() {
+		throw new LedgerError("COMMON_FEATURE_NOT_SUPPORTED");
+	}
+	async fetchAddressesForSelection(chain, paths) {
+		const transport = await this.transportManager.open();
+		await this.requireApp(chain);
+		return LedgerAppFactory.createApp(chain, transport).getComputedAddresses(paths, this.resolvedConfig.getChain(chain).ledgerHrp);
+	}
+	async performConnect(chain, options) {
+		console.debug("[Ledger] performConnect() started", {
+			chain,
+			bip44: options.bip44
+		});
+		this.events.startConnecting();
+		try {
+			const { account, client } = await this.establishConnection(chain, options);
+			this.client = client;
+			this.sessionManager.save({
+				caip2: chain,
+				bip44: options.bip44,
+				hdStandard: options.ledgerHDStandard,
+				account
+			});
+			this.events.connected({
+				address: account.address,
+				addresses: [account.address],
+				caip2: chain
+			});
+			console.debug("[Ledger] performConnect() completed", { address: account.address });
+		} catch (error) {
+			console.debug("[Ledger] performConnect() failed", error);
+			this.events.disconnected();
+			throw error;
+		}
+	}
+	async performRestore(saved) {
+		console.debug("[Ledger] performRestore() started", {
+			chain: saved.caip2,
+			bip44: saved.bip44
+		});
+		try {
+			const { account, client } = await this.establishConnection(saved.caip2, {
+				bip44: saved.bip44,
+				ledgerHDStandard: saved.hdStandard
+			});
+			this.client = client;
+			this.sessionManager.save({
+				caip2: saved.caip2,
+				bip44: saved.bip44,
+				hdStandard: saved.hdStandard,
+				account
+			});
+			this.events.reconnected({
+				address: account.address,
+				addresses: [account.address],
+				caip2: saved.caip2
+			});
+			console.debug("[Ledger] performRestore() completed", { address: account.address });
+		} catch (error) {
+			console.debug("[Ledger] performRestore() failed", error);
+			await this.transportManager.close();
+		}
+	}
+	async establishConnection(chain, options) {
+		console.debug("[Ledger] establishConnection() started", { chain });
+		try {
+			const transport = await this.transportManager.open();
+			console.debug("[Ledger] establishConnection(): transport opened");
+			await this.requireApp(chain);
+			console.debug("[Ledger] establishConnection(): app verified");
+			const app = LedgerAppFactory.createApp(chain, transport);
+			const hrp = this.resolvedConfig.getChain(chain).ledgerHrp;
+			const result = {
+				account: await app.getComputedAddress(options.bip44, hrp),
+				client: await this.clientFactory.create(chain, app, options.bip44)
+			};
+			console.debug("[Ledger] establishConnection() completed");
+			return result;
+		} catch (error) {
+			throw LedgerError.fromError(error) ?? error;
+		}
+	}
+	handleDisconnect() {
+		this.client = null;
+		this.sessionManager.clear();
+		this.events.disconnected();
+	}
+	async requireApp(chain) {
+		const requiredApp = LedgerAppFactory.getRequiredAppName(chain);
+		const currentApp = await this.transportManager.getCurrentApp();
+		if (currentApp.name !== requiredApp) throw new LedgerError("LEDGER_WRONG_APP", /* @__PURE__ */ new Error(`Please open the ${requiredApp} app on your Ledger. Currently running: ${currentApp.name}`));
+	}
+};
+
+//#endregion
+//#region src/core/connectors/metamask/metamask-connector.ts
+const RPC_ERROR = {
+	USER_REJECTED: 4001,
+	REQUEST_PENDING: -32002,
+	CHAIN_NOT_ADDED: 4902
+};
+var MetaMaskConnector = class extends BaseConnector {
+	constructor(..._args) {
+		super(..._args);
+		this.client = null;
+	}
+	async onInitialize() {
+		this.sdk = new MetaMaskSDK({ dappMetadata: {
+			name: this.config.metadata.name,
+			url: this.config.metadata.url
+		} });
+		await this.sdk.sdkInitPromise;
+		const provider = this.sdk.getProvider();
+		if (!provider) throw new MetaMaskError("METAMASK_NOT_INSTALLED");
+		this.provider = provider;
+		this.provider.on("accountsChanged", (accounts) => this.onAccountsChanged(accounts));
+		this.provider.on("chainChanged", (hex) => this.onChainChanged(hex));
+		this.provider.on("disconnect", () => {
+			if (this.getConnectionState() === "connected") {
+				this.client = null;
+				this.events.disconnected();
+			}
+		});
+	}
+	async connect(chain) {
+		if (this.getConnectionState() === "connecting") throw new MetaMaskError("COMMON_CONNECTION_IN_PROGRESS");
+		await this.initialize();
+		this.events.startConnecting();
+		let accounts = await this.provider.request({ method: "eth_accounts" });
+		if (accounts.length === 0) {
+			const connected = await this.sdk.connect().catch((error) => {
+				this.events.disconnected();
+				if (ChainUtils.isRpcErrorWithCode(error, RPC_ERROR.USER_REJECTED)) throw new MetaMaskError("COMMON_USER_REJECTED", error);
+				if (ChainUtils.isRpcErrorWithCode(error, RPC_ERROR.REQUEST_PENDING)) throw new MetaMaskError("COMMON_CONNECTION_IN_PROGRESS", error);
+				throw new MetaMaskError("COMMON_CONNECTION_FAILED", error);
+			});
+			if (!connected?.length) {
+				this.events.disconnected();
+				throw new MetaMaskError("COMMON_NO_ACCOUNTS");
+			}
+			accounts = connected;
+		}
+		if (chain && !ChainGuards.isEvmCaip2(chain)) {
+			this.events.disconnected();
+			throw new MetaMaskError("COMMON_CHAIN_NOT_SUPPORTED");
+		}
+		const hex = await this.provider.request({ method: "eth_chainId" });
+		const currentChain = this.resolvedConfig.evmHexMap.get(hex);
+		if (chain && currentChain !== chain) await this.switchChain(chain);
+		else if (!currentChain) {
+			this.events.disconnected();
+			throw new MetaMaskError("COMMON_UNKNOWN_CHAIN_ID");
+		}
+		const caip2 = chain ?? currentChain;
+		this.createClient(caip2);
+		this.events.connected({
+			address: accounts[0],
+			addresses: accounts,
+			caip2
+		});
+	}
+	async disconnect() {
+		this.events.startDisconnecting();
+		if (this.initialized) await this.sdk.terminate();
+		this.client = null;
+		this.resetInitialization();
+		this.events.disconnected();
+	}
+	async restoreConnection() {
+		if (this.getConnectionState() !== "disconnected") return;
+		await this.initialize();
+		if (!this.provider) return;
+		if (this.getConnectionState() !== "disconnected") return;
+		const accounts = await this.provider.request({ method: "eth_accounts" });
+		if (accounts.length === 0 || this.getConnectionState() !== "disconnected") return;
+		const hex = await this.provider.request({ method: "eth_chainId" });
+		const caip2 = this.resolvedConfig.evmHexMap.get(hex);
+		if (!caip2) return;
+		this.createClient(caip2);
+		this.events.reconnected({
+			address: accounts[0],
+			addresses: accounts,
+			caip2
+		});
+	}
+	async switchChain(caip2) {
+		const chain = this.resolvedConfig.getEvmChain(caip2);
+		try {
+			await this.provider.request({
+				method: "wallet_switchEthereumChain",
+				params: [{ chainId: chain.evmChain.hex }]
+			});
+		} catch (error) {
+			if (ChainUtils.isRpcErrorWithCode(error, RPC_ERROR.CHAIN_NOT_ADDED)) await this.addChain(chain);
+			else if (ChainUtils.isRpcErrorWithCode(error, RPC_ERROR.USER_REJECTED)) throw new MetaMaskError("COMMON_USER_REJECTED", error);
+			else throw new MetaMaskError("COMMON_CHAIN_NOT_SUPPORTED", error);
+		}
+		this.createClient(caip2);
+	}
+	getClient() {
+		if (!this.client) throw new MetaMaskError("COMMON_NOT_CONNECTED");
+		return this.client;
+	}
+	getProvider() {
+		return this.provider;
+	}
+	onAccountsChanged(accounts) {
+		if (accounts.length === 0) {
+			if (this.getConnectionState() !== "connected") return;
+			this.events.startDisconnecting();
+			this.events.disconnected();
+			return;
+		}
+		this.provider.request({ method: "eth_chainId" }).then((hex) => {
+			const caip2 = this.resolvedConfig.evmHexMap.get(hex);
+			if (!caip2) return;
+			if (this.getConnectionState() === "disconnected") {
+				this.events.startConnecting();
+				this.createClient(caip2);
+				this.events.connected({
+					address: accounts[0],
+					addresses: accounts,
+					caip2
+				});
+			} else this.events.addressChanged({
+				address: accounts[0],
+				addresses: accounts,
+				caip2
+			});
+		}).catch((error) => {
+			this.emitError(error);
+		});
+	}
+	onChainChanged(hex) {
+		const caip2 = this.resolvedConfig.evmHexMap.get(hex);
+		if (!caip2) {
+			this.client = null;
+			this.events.disconnected();
+			return;
+		}
+		if (this.getCurrentCaip2() !== caip2) {
+			this.createClient(caip2);
+			this.events.chainChanged(caip2);
+		}
+	}
+	createClient(caip2) {
+		this.client = EvmClient.create(this.resolvedConfig.getEvmChain(caip2), this.provider);
+	}
+	async addChain(chain) {
+		await this.provider.request({
+			method: "wallet_addEthereumChain",
+			params: [{
+				chainId: chain.evmChain.hex,
+				chainName: chain.name,
+				nativeCurrency: chain.nativeCurrency,
+				rpcUrls: chain.rpcUrls,
+				blockExplorerUrls: chain.blockExplorerUrls
+			}]
+		});
+	}
+	getConnectionState() {
+		return this.store.getSnapshot().context.connectionState;
+	}
+	getCurrentCaip2() {
+		return this.store.getSnapshot().context.caip2;
+	}
+};
+
+//#endregion
+//#region src/core/connectors/wallet-connect/clients/wallet-connect-evm-client.ts
+/**
+* WalletConnect EVM client with hybrid transport.
+* Reads go direct to RPC (avoids Reown unsupported chain issue),
+* writes/signing go through WalletConnect provider.
+*/
+var WalletConnectEvmClient = class WalletConnectEvmClient extends EvmClient {
+	constructor(chain, publicClient, walletClient) {
+		super(chain, publicClient, walletClient);
+	}
+	static createWithProvider(chainConfig, provider) {
+		const viemChain = ViemHelper.toViemChain(chainConfig);
+		return new WalletConnectEvmClient(chainConfig, createPublicClient({
+			chain: viemChain,
+			transport: http(chainConfig.rpcUrls[0])
+		}), createWalletClient({
+			chain: viemChain,
+			transport: custom(provider)
+		}));
+	}
+};
+
+//#endregion
+//#region src/core/connectors/wallet-connect/clients/wallet-connect-xrpl-client.ts
+var WalletConnectXrpClient = class extends XrplClient {
+	constructor(chain, provider) {
+		super(chain);
+		this.provider = provider;
+	}
+	async sendTx(tx) {
+		await this.connect();
+		try {
+			const prepared = await this.autofill(tx);
+			const xrpCaip2 = await this.getCaip2();
+			const result = await this.provider.request({
+				method: "xrpl_signTransaction",
+				params: {
+					tx_json: prepared,
+					submit: false
+				}
+			}, xrpCaip2);
+			return (await this.submitAndWait(result.tx_json)).result.hash;
+		} finally {
+			await this.disconnect();
+		}
+	}
+};
+
+//#endregion
+//#region src/core/connectors/wallet-connect/internal/wallet-connect-client-factory.ts
+var WalletConnectClientFactory = class {
+	constructor(provider, resolvedConfig) {
+		this.provider = provider;
+		this.resolvedConfig = resolvedConfig;
+	}
+	create(caip2) {
+		if (ChainUtils.isEvmCaip2(caip2)) {
+			const chain = this.resolvedConfig.getEvmChain(caip2);
+			return WalletConnectEvmClient.createWithProvider(chain, this.provider);
+		}
+		if (ChainUtils.isXrplCaip2(caip2)) return new WalletConnectXrpClient(this.resolvedConfig.getXrplChain(caip2), this.provider);
+		throw new WalletConnectError("COMMON_CHAIN_NOT_SUPPORTED");
+	}
+};
+
+//#endregion
+//#region src/core/connectors/wallet-connect/internal/wallet-connect-session-storage.ts
+var SessionStorage = class {
+	constructor(storage) {
+		this.storage = storage;
+	}
+	setLastSession(session) {
+		this.storage.set("wc:last-session", session);
+	}
+	getLastSession() {
+		return this.storage.get("wc:last-session");
+	}
+	setLastAddress(address) {
+		this.storage.set("wc:last-address", address);
+	}
+	getLastAddress() {
+		return this.storage.get("wc:last-address");
+	}
+	setLastChain(caip2) {
+		this.storage.set("wc:last-chain", caip2);
+	}
+	getLastChain() {
+		return this.storage.get("wc:last-chain");
+	}
+	clear() {
+		this.storage.remove("wc:last-session");
+		this.storage.remove("wc:last-address");
+		this.storage.remove("wc:last-chain");
+	}
+};
+const sessionStorage = new SessionStorage(mwcStorage);
+
+//#endregion
+//#region src/core/connectors/wallet-connect/internal/wallet-connect-session-manager.ts
+var WalletConnectSessionManager = class {
+	constructor(provider) {
+		this.provider = provider;
+	}
+	parseSession() {
+		const session = this.provider.session;
+		if (!session) throw new WalletConnectError("WALLET_CONNECT_SESSION_NOT_FOUND");
+		const availableAddresses = [];
+		const eip155 = session.namespaces.eip155;
+		if (eip155?.accounts) for (const account of eip155.accounts) {
+			const { namespace, reference, address } = parseCaip10(account);
+			availableAddresses.push({
+				type: "wallet-connect",
+				address,
+				caip2: `${namespace}:${reference}`,
+				isEvm: true
+			});
+		}
+		const xrpl = session.namespaces.xrpl;
+		if (xrpl?.accounts) for (const account of xrpl.accounts) {
+			const { namespace, reference, address } = parseCaip10(account);
+			availableAddresses.push({
+				type: "wallet-connect",
+				address,
+				caip2: `${namespace}:${reference}`,
+				isEvm: false
+			});
+		}
+		return {
+			availableAddresses,
+			selectedAddress: availableAddresses[0]
+		};
+	}
+	resolveSessionWithStorage(parsedSession) {
+		const lastAddress = sessionStorage.getLastAddress();
+		const lastChain = sessionStorage.getLastChain();
+		if (lastAddress && lastChain) {
+			const validAddress = parsedSession.availableAddresses.find((addressState) => addressState.address === lastAddress && addressState.caip2 === lastChain);
+			if (validAddress) return {
+				availableAddresses: parsedSession.availableAddresses,
+				selectedAddress: validAddress
+			};
+		}
+		return parsedSession;
+	}
+	saveLastConnection(address) {
+		sessionStorage.setLastAddress(address.address);
+		sessionStorage.setLastChain(address.caip2);
+	}
+	buildNamespaces(chains) {
+		const evmChains = chains.filter(ChainUtils.isEvmCaip2);
+		const xrplChains = chains.filter(ChainUtils.isXrplCaip2);
+		const namespaces = {};
+		if (evmChains.length > 0) namespaces.eip155 = {
+			chains: evmChains,
+			methods: [
+				"eth_sendTransaction",
+				"eth_signTransaction",
+				"eth_sign",
+				"personal_sign",
+				"eth_signTypedData"
+			],
+			events: ["chainChanged", "accountsChanged"]
+		};
+		if (xrplChains.length > 0) namespaces.xrpl = {
+			chains: xrplChains,
+			methods: ["xrpl_signTransaction"],
+			events: []
+		};
+		return namespaces;
+	}
+};
+
+//#endregion
+//#region src/core/connectors/wallet-connect/wallet-connect-connector.ts
+/**
+* WalletConnect connector using Reown AppKit for QR modal.
+*
+* - connect() opens AppKit first (spinner), then provider.connect() emits display_uri
+*   which auto-populates the QR in the modal. The empty display_uri handler is required.
+* - disconnect() cleans up the WC session, but provider and AppKit survive —
+*   no re-initialization needed (unlike MetaMask/Xaman).
+* - Only EVM chains are registered with AppKit (ChainNamespace doesn't include "xrpl").
+*   XRPL sessions still work fine without AppKit awareness.
+*/
+var WalletConnectConnector = class extends BaseConnector {
+	constructor(store, config) {
+		super(store, config);
+		this.client = null;
+		this.config = config;
+	}
+	async onInitialize() {
+		this.provider = await UniversalProvider.init({
+			projectId: this.config.projectId,
+			metadata: {
+				name: this.config.metadata.name,
+				description: this.config.metadata.description ?? "",
+				url: this.config.metadata.url,
+				icons: this.config.metadata.icons ?? []
+			}
+		});
+		this.sessionManager = new WalletConnectSessionManager(this.provider);
+		this.clientFactory = new WalletConnectClientFactory(this.provider, this.resolvedConfig);
+		this.appKit = createAppKit({
+			projectId: this.config.projectId,
+			universalProvider: this.provider,
+			manualWCControl: true,
+			networks: this.buildAppKitNetworks(),
+			customRpcUrls: this.buildCustomRpcUrls()
+		});
+		this.registerProviderEvents();
+		this.registerModalCloseHandler();
+	}
+	async connect(chains) {
+		if (this.connectionState === "connecting") throw new WalletConnectError("COMMON_CONNECTION_IN_PROGRESS");
+		if (!chains?.length) throw new WalletConnectError("COMMON_CHAIN_NOT_CONFIGURED");
+		await this.initialize();
+		this.events.startConnecting();
+		await this.appKit.open();
+		this.getProvider().connect({ optionalNamespaces: this.sessionManager.buildNamespaces([...chains]) }).then((session) => this.onSessionCreated(session)).catch((error) => this.onConnectionFailed(error));
+	}
+	async disconnect() {
+		this.events.startDisconnecting();
+		sessionStorage.clear();
+		if (this.initialized && this.provider?.session) await this.provider.disconnect();
+		this.client = null;
+		this.events.disconnected();
+	}
+	async restoreConnection() {
+		if (this.connectionState !== "disconnected") return;
+		await this.initialize();
+		if (!this.provider?.session) return;
+		if (this.connectionState !== "disconnected") return;
+		const parsedSession = this.sessionManager.parseSession();
+		const resolved = this.sessionManager.resolveSessionWithStorage(parsedSession);
+		if (!resolved.selectedAddress) return;
+		this.client = this.clientFactory.create(resolved.selectedAddress.caip2);
+		this.events.reconnected({
+			address: resolved.selectedAddress.address,
+			addresses: resolved.availableAddresses.map((address) => address.address),
+			caip2: resolved.selectedAddress.caip2
+		});
+	}
+	async switchChain(caip2) {
+		if (!this.provider.session) throw new WalletConnectError("WALLET_CONNECT_SESSION_NOT_FOUND");
+		const targetAddress = this.sessionManager.parseSession().availableAddresses.find((address) => address.caip2 === caip2);
+		if (!targetAddress) return;
+		this.sessionManager.saveLastConnection(targetAddress);
+		this.client = this.clientFactory.create(caip2);
+		this.events.chainChanged(caip2);
+	}
+	getClient() {
+		if (!this.client) throw new WalletConnectError("COMMON_NOT_CONNECTED");
+		return this.client;
+	}
+	getProvider() {
+		return this.provider;
+	}
+	registerProviderEvents() {
+		this.provider.on("display_uri", (_uri) => {});
+		this.provider.on("disconnect", (error) => this.onDisconnect(error));
+		this.provider.on("session_delete", () => this.onDisconnect());
+		this.provider.on("chainChanged", (chainId) => this.onChainChanged(chainId));
+		this.provider.on("accountsChanged", (accounts) => this.onAccountsChanged(accounts));
+		this.provider.client?.on("proposal_expire", (event) => this.onProposalExpire(event));
+	}
+	registerModalCloseHandler() {
+		this.appKit.subscribeState((state) => {
+			if (!state.open && this.connectionState === "connecting") this.events.disconnected();
+		});
+	}
+	onSessionCreated(session) {
+		this.appKit.close();
+		if (!session) {
+			this.events.disconnected();
+			this.emitError(new WalletConnectError("WALLET_CONNECT_PAIRING_FAILED"));
+			return;
+		}
+		const parsedSession = this.sessionManager.parseSession();
+		if (!parsedSession.selectedAddress) {
+			this.events.disconnected();
+			this.emitError(new WalletConnectError("COMMON_NO_ACCOUNTS"));
+			return;
+		}
+		this.client = this.clientFactory.create(parsedSession.selectedAddress.caip2);
+		this.sessionManager.saveLastConnection(parsedSession.selectedAddress);
+		this.events.connected({
+			address: parsedSession.selectedAddress.address,
+			addresses: parsedSession.availableAddresses.map((address) => address.address),
+			caip2: parsedSession.selectedAddress.caip2
+		});
+	}
+	onConnectionFailed(error) {
+		this.appKit.close();
+		if (this.connectionState === "connecting") this.events.disconnected();
+		if (error instanceof Error && error.message.includes("Proposal expired")) return;
+		this.emitError(error);
+	}
+	onProposalExpire(event) {
+		console.log("[WC] proposal_expire", event);
+		if (this.connectionState !== "connecting") return;
+		this.appKit.close();
+		this.events.disconnected();
+	}
+	onAccountsChanged(accounts) {
+		if (this.connectionState !== "connected") return;
+		if (!accounts.length) {
+			this.events.disconnected();
+			return;
+		}
+		const parsedSession = this.sessionManager.parseSession();
+		const newAddress = accounts[0];
+		const matched = parsedSession.availableAddresses.find((address) => address.address === newAddress);
+		if (!matched) return;
+		this.events.addressChanged({
+			address: newAddress,
+			addresses: parsedSession.availableAddresses.map((address) => address.address),
+			caip2: matched.caip2
+		});
+	}
+	onChainChanged(chainId) {
+		const caip2 = chainId;
+		if (this.storedCaip2 === caip2) return;
+		this.client = this.clientFactory.create(caip2);
+		this.events.chainChanged(caip2);
+	}
+	onDisconnect(error) {
+		if (error) console.warn("[WC] disconnect error:", error);
+		this.client = null;
+		this.events.disconnected();
+	}
+	buildAppKitNetworks() {
+		const networks = [];
+		for (const [caip2, chain] of objectEntries(this.resolvedConfig.chains)) {
+			if (!chain.isEvm) continue;
+			const { reference } = parseCaip2(caip2);
+			if (!reference) continue;
+			networks.push({
+				id: Number(reference),
+				name: chain.name,
+				chainNamespace: "eip155",
+				caipNetworkId: `eip155:${reference}`,
+				nativeCurrency: chain.nativeCurrency,
+				rpcUrls: { default: { http: [...chain.rpcUrls] } }
+			});
+		}
+		const [first, ...rest] = networks;
+		if (!first) throw new WalletConnectError("COMMON_CHAIN_NOT_CONFIGURED");
+		return [first, ...rest];
+	}
+	buildCustomRpcUrls() {
+		const rpcUrls = {};
+		for (const [caip2, chain] of objectEntries(this.resolvedConfig.chains)) rpcUrls[caip2] = [{ url: chain.rpcUrls[0] }];
+		return rpcUrls;
+	}
+	get connectionState() {
+		return this.store.getSnapshot().context.connectionState;
+	}
+	get storedCaip2() {
+		return this.store.getSnapshot().context.caip2;
+	}
+};
+
+//#endregion
+//#region src/core/connectors/xaman/xaman-xrpl-client.ts
+var XamanClient = class XamanClient extends Xumm {
+	static {
+		this.NETWORK_KEYS = {
+			"0": "MAINNET",
+			"1": "TESTNET"
+		};
+	}
+	constructor(config, resolvedConfig) {
+		super(config.apiKey);
+		this.resolvedConfig = resolvedConfig;
+	}
+	async sendTx(tx) {
+		if (!this.payload) throw new XamanError("XAMAN_SDK_NOT_READY");
+		const { reference } = parseCaip2(await this.getCaip2());
+		const networkKey = XamanClient.NETWORK_KEYS[reference];
+		const subscription = await this.payload.createAndSubscribe({
+			txjson: {
+				...tx,
+				TransactionType: tx.TransactionType
+			},
+			options: networkKey ? { force_network: networkKey } : {}
+		}, (event) => "signed" in event.data ? event : void 0);
+		if (!subscription?.created) throw new XamanError("XAMAN_SDK_NOT_READY");
+		const txid = (await subscription.resolved)?.payload?.response?.txid;
+		if (!txid) throw new XamanError("XAMAN_SIGN_REJECTED");
+		return txid;
+	}
+	async getCaip2() {
+		const networkId = await this.user.networkId;
+		return this.toCaip2Network(networkId);
+	}
+	async onDestroy() {
+		await super.logout();
+	}
+	async getBalance(address) {
+		return (await this.getSimpleClient()).getBalance(address);
+	}
+	async getSimpleClient() {
+		const caip2 = await this.getCaip2();
+		return new XrplClient(this.resolvedConfig.getXrplChain(caip2));
+	}
+	toCaip2Network(networkId) {
+		return `xrpl:${networkId}`;
+	}
+};
+
+//#endregion
+//#region src/core/connectors/xaman/xaman-connector.ts
+var XamanConnector = class extends BaseConnector {
+	constructor(store, config) {
+		super(store, config);
+		this.config = config;
+	}
+	async onInitialize() {
+		this.client = new XamanClient({ apiKey: this.config.apiKey }, this.resolvedConfig);
+		this.client.on("ready", () => this.onReady());
+		this.client.on("success", () => this.onSuccess().catch((error) => this.emitError(error)));
+		this.client.on("error", (error) => this.onError(error));
+		this.client.on("logout", () => this.onLogout());
+		this.client.on("loggedout", () => this.onLogout());
+		this.client.on("networkswitch", (event) => event.network && this.onNetworkSwitch(event.network));
+	}
+	/**
+	* Xaman doesn't support session restoration — authorize() is fire-and-forget,
+	* with state changes arriving via SDK events (ready, success, error, logout).
+	*/
+	async restoreConnection() {}
+	async connect(_chains) {
+		if (this.connectionState === "connecting") throw new XamanError("COMMON_CONNECTION_IN_PROGRESS");
+		await this.initialize();
+		this.events.startConnecting();
+		this.getClient().authorize().catch((error) => this.emitError(error));
+	}
+	async disconnect() {
+		this.events.startDisconnecting();
+		if (this.initialized) await this.client.logout().catch((error) => {
+			throw new XamanError("COMMON_CONNECTION_FAILED", error);
+		});
+		this.resetInitialization();
+		this.events.disconnected();
+	}
+	async switchChain(_caip2) {
+		throw new XamanError("COMMON_FEATURE_NOT_SUPPORTED");
+	}
+	getClient() {
+		return this.client;
+	}
+	getProvider() {
+		return this.client;
+	}
+	onReady() {
+		if (this.connectionState === "connected" && !this.isLoggedIn()) this.events.disconnected();
+	}
+	async onSuccess() {
+		const client = this.getClient();
+		const address = await client.user.account;
+		if (!await client.user.networkId) throw new XamanError("COMMON_PROVIDER_ERROR");
+		if (!address) throw new XamanError("COMMON_NO_ACCOUNTS");
+		const caip2 = await client.getCaip2();
+		const isReconnect = this.connectionState !== "connecting";
+		const eventData = {
+			address,
+			addresses: [address],
+			caip2
+		};
+		isReconnect ? this.events.reconnected(eventData) : this.events.connected(eventData);
+	}
+	onError(error) {
+		if (this.connectionState === "connecting") this.events.disconnected();
+		this.emitError(error);
+	}
+	onLogout() {
+		if (this.connectionState === "connected") this.events.disconnected();
+	}
+	onNetworkSwitch(network) {
+		const networkId = network === "1" ? 1 : 0;
+		const caip2 = this.getClient().toCaip2Network(networkId);
+		if (this.storedCaip2 !== caip2) this.events.chainChanged(caip2);
+	}
+	isLoggedIn() {
+		return this.initialized ? !!this.client.runtime.xapp : false;
+	}
+	get connectionState() {
+		return this.store.getSnapshot().context.connectionState;
+	}
+	get storedCaip2() {
+		return this.store.getSnapshot().context.caip2;
+	}
+};
+
+//#endregion
+//#region src/core/connectors/connector-factory.ts
+const DEFAULT_METADATA = {
+	name: "App",
+	url: typeof window !== "undefined" ? window.location.origin : "https://localhost"
+};
+var ConnectorFactory = class {
+	static create(options) {
+		const { walletType, store, resolvedConfig, walletOptions } = options;
+		const metadata = walletOptions.metadata ?? DEFAULT_METADATA;
+		switch (walletType) {
+			case "metamask": return new MetaMaskConnector(store, {
+				walletType: "metamask",
+				metadata,
+				resolvedConfig
+			});
+			case "wallet-connect": return new WalletConnectConnector(store, {
+				walletType: "wallet-connect",
+				metadata,
+				resolvedConfig,
+				projectId: walletOptions.projectId
+			});
+			case "ledger": return new LedgerConnector(store, {
+				walletType: "ledger",
+				metadata,
+				resolvedConfig
+			});
+			case "xaman": return new XamanConnector(store, {
+				walletType: "xaman",
+				metadata,
+				resolvedConfig,
+				apiKey: walletOptions.apiKey
+			});
+			case "dcent": return new DcentConnector(store, {
+				walletType: "dcent",
+				metadata,
+				resolvedConfig
+			});
+			default: throw new Error(`Unknown wallet type: ${walletType}`);
+		}
+	}
+};
+
+//#endregion
+//#region src/core/stores/wallet-store/aggregate-wallet-store.ts
+const createAggregateWalletStore = (stores) => {
+	return createStore({
+		context: { wallets: objectFromEntries(Array.from(stores.entries()).map(([type, store]) => [type, store.getSnapshot().context])) },
+		on: { walletUpdated: (state, { walletType, context }) => ({ wallets: {
+			...state.wallets,
+			[walletType]: context
+		} }) }
+	});
+};
+
+//#endregion
+//#region src/core/stores/wallet-store/wallet-store.ts
+const INITIAL_STATE = {
+	connectionState: "disconnected",
+	activeAddress: void 0,
+	availableAddresses: [],
+	caip2: void 0,
+	error: void 0
+};
+const createWalletStore = (walletType) => {
+	return createStore({
+		context: INITIAL_STATE,
+		on: {
+			startConnecting: (context) => ({
+				...context,
+				connectionState: "connecting"
+			}),
+			connectionEstablished: (context, { activeAddress, availableAddresses, caip2 }, enqueue) => {
+				enqueue.emit.walletConnected({
+					activeAddress,
+					availableAddresses,
+					caip2,
+					walletType,
+					isReconnect: false
+				});
+				return {
+					...context,
+					connectionState: "connected",
+					activeAddress,
+					availableAddresses,
+					caip2,
+					error: void 0
+				};
+			},
+			connectionRestored: (context, { activeAddress, availableAddresses, caip2 }, enqueue) => {
+				enqueue.emit.walletConnected({
+					activeAddress,
+					availableAddresses,
+					caip2,
+					walletType,
+					isReconnect: true
+				});
+				return {
+					...context,
+					connectionState: "connected",
+					activeAddress,
+					availableAddresses,
+					caip2,
+					error: void 0
+				};
+			},
+			error: (context, { error }, enqueue) => {
+				enqueue.emit.walletError({
+					error,
+					walletType
+				});
+				return {
+					...context,
+					connectionState: "error",
+					error
+				};
+			},
+			startDisconnecting: (context) => ({
+				...context,
+				connectionState: "disconnecting"
+			}),
+			disconnected: (context, _, enqueue) => {
+				enqueue.emit.walletDisconnected({ walletType });
+				return {
+					...context,
+					connectionState: "disconnected",
+					activeAddress: void 0,
+					availableAddresses: [],
+					caip2: void 0,
+					error: void 0
+				};
+			},
+			chainChanged: (context, { caip2 }, enqueue) => {
+				enqueue.emit.walletChainChanged({
+					caip2,
+					walletType
+				});
+				return {
+					...context,
+					caip2
+				};
+			},
+			addressChanged: (context, { activeAddress, availableAddresses }, enqueue) => {
+				enqueue.emit.walletAddressChanged({
+					activeAddress,
+					walletType
+				});
+				return {
+					...context,
+					availableAddresses,
+					activeAddress
+				};
+			}
+		}
+	});
+};
+
+//#endregion
+//#region src/core/multichain/multichain.ts
+var MultiChain = class {
+	constructor(options, inspector) {
+		this.stores = /* @__PURE__ */ new Map();
+		this.connectors = /* @__PURE__ */ new Map();
+		this.subscriptions = [];
+		this.mounted = false;
+		this.configResolver = new ConfigResolver(options);
+		this.events = options.events ?? {};
+		for (const [walletType, walletOptions] of objectEntries(options.wallets)) {
+			if (!walletOptions) continue;
+			const wType = walletType;
+			const store = createWalletStore(wType);
+			this.stores.set(wType, store);
+			if (inspector) store.inspect(inspector.inspect);
+			const resolvedConfig = this.configResolver.resolveForWallet(wType);
+			const connector = ConnectorFactory.create({
+				walletType: wType,
+				store,
+				resolvedConfig,
+				walletOptions
+			});
+			this.connectors.set(wType, connector);
+			this.registerGlobalListeners(wType);
+		}
+		this.aggregateStore = createAggregateWalletStore(this.stores);
+		for (const [walletType, store] of this.stores) this.registerAggregateSync(walletType, store);
+		if (inspector) this.aggregateStore.inspect(inspector.inspect);
+	}
+	async mount() {
+		if (this.mounted) return;
+		this.mounted = true;
+		const results = await Promise.allSettled(Array.from(this.connectors.entries()).map(async ([walletType, connector]) => {
+			await connector.initialize();
+			await connector.restoreConnection();
+			return walletType;
+		}));
+		for (const result of results) if (result.status === "rejected") console.warn("[MultiChain] Connector failed to mount:", result.reason);
+	}
+	async disconnect(walletType) {
+		const connector = this.connectors.get(walletType);
+		if (!connector) throw new Error(`Wallet "${walletType}" is not configured`);
+		await connector.disconnect();
+	}
+	async disconnectAll() {
+		const disconnectPromises = Array.from(this.connectors.values()).map((connector) => connector.disconnect());
+		await Promise.all(disconnectPromises);
+	}
+	/**
+	* Connect a wallet with type-safe discriminated union arguments.
+	*
+	* Each wallet type has its own connection signature:
+	* - wallet-connect: { wallet: "wallet-connect", chains: [...] }
+	* - metamask: { wallet: "metamask", chain: "eip155:..." }
+	* - ledger: { wallet: "ledger", chain: "...", options?: {...} }
+	* - xaman: { wallet: "xaman" }
+	* - dcent: { wallet: "dcent" }
+	*/
+	async connect(args) {
+		switch (args.wallet) {
+			case "wallet-connect": return this.getConnector("wallet-connect").connect(args.chains);
+			case "metamask": return this.getConnector("metamask").connect(args.chain);
+			case "ledger": return this.getConnector("ledger").connect(args.chain, args.options);
+			case "xaman": return this.getConnector("xaman").connect();
+			case "dcent": return this.getConnector("dcent").connect();
+		}
+	}
+	getAggregateStore() {
+		return this.aggregateStore;
+	}
+	getWalletTypes() {
+		return Array.from(this.stores.keys());
+	}
+	getConnector(walletType) {
+		const connector = this.connectors.get(walletType);
+		if (!connector) throw new Error(`Wallet "${walletType}" is not configured`);
+		return connector;
+	}
+	onWalletEvent(walletType, eventType, callback) {
+		const store = this.stores.get(walletType);
+		if (!store) return void 0;
+		return store.on(eventType, callback);
+	}
+	getConfigResolver() {
+		return this.configResolver;
+	}
+	/** Check if any wallet is currently connected to a specific chain. */
+	isConnectedByCaip2(caip2) {
+		const wallets = this.aggregateStore.getSnapshot().context.wallets;
+		return objectValues(wallets).some((state) => state.connectionState === "connected" && state.caip2 === caip2);
+	}
+	registerGlobalListeners(walletType) {
+		const store = this.stores.get(walletType);
+		if (!store) return;
+		this.subscriptions.push(store.on("walletConnected", (event) => {
+			this.events.onConnect?.({
+				walletType,
+				caip2: event.caip2,
+				address: event.activeAddress,
+				availableAddresses: event.availableAddresses,
+				isReconnect: event.isReconnect
+			});
+		}));
+		this.subscriptions.push(store.on("walletDisconnected", () => {
+			this.events.onDisconnect?.({ walletType });
+		}));
+		this.subscriptions.push(store.on("walletError", (event) => {
+			this.events.onError?.({
+				walletType,
+				error: new Error(event.error.message)
+			});
+		}));
+		this.subscriptions.push(store.on("walletChainChanged", (event) => {
+			this.events.onChainChanged?.({
+				walletType,
+				caip2: event.caip2
+			});
+		}));
+	}
+	registerAggregateSync(walletType, store) {
+		const sync = () => {
+			this.aggregateStore.send({
+				type: "walletUpdated",
+				walletType,
+				context: store.getSnapshot().context
+			});
+		};
+		sync();
+		this.subscriptions.push(store.subscribe(sync));
+	}
+};
+
+//#endregion
+export { objectFromEntries as _, WalletErrorHelper as a, shortenAddress as b, MetaMaskError as c, WalletError as d, ErrorCode as f, objectEntries as g, ChainGuards as h, DcentConnector as i, LedgerError as l, evmCaip2s as m, EvmClient as n, XamanError as o, ConfigResolver as p, Bip44 as r, WalletConnectError as s, MultiChain as t, DcentError as u, objectKeys as v, objectValues as y };
+//# sourceMappingURL=multichain-C5wKiJke.mjs.map