cppay-sdk 0.0.2-beta.23 → 0.0.2-beta.25

package/dist/core-DKXmyfMB.js

@@ -0,0 +1,2337 @@
+import { P as esm_default, _ as Ge, y as Ue } from "./index.es-DDV8bPq_.js";
+import { C as SnackController, F as ONRAMP_PROVIDERS, I as subscribeKey, J as ConstantsUtil, L as proxy, M as StorageUtil, N as ConstantsUtil$1, O as withErrorBoundary, P as MELD_PUBLIC_KEY, R as subscribe, S as BlockchainApiController, T as AssetUtil, U as UserRejectedRequestError, V as isSafe, W as ParseUtil, _ as PublicStateController, a as ProviderController, b as ConnectorUtil, c as ConnectionController, g as ModalController, h as ThemeController, j as CoreHelperUtil, k as OptionsController, l as ConnectionControllerUtil, m as ConnectorController, n as ChainController, o as AdapterController, p as getPreferredAccountType, q as NetworkUtil, r as SendController, t as ApiController, v as EventsController, x as WalletUtil, y as RouterController } from "./ApiController-Crww70p3.js";
+import { c as setColorTheme, l as setThemeVariables, n as ConstantsUtil$2, t as HelpersUtil } from "./HelpersUtil-CeTmhhZv.js";
+import { n as SIWXUtil, r as N, t as AlertController } from "./AlertController-BPGQ5PgH.js";
+import { t as CaipNetworksUtil } from "./CaipNetworkUtil-Bd4HeTLY.js";
+import { toHex } from "viem";
+const USDC_CURRENCY_DEFAULT = {
+	id: "2b92315d-eab7-5bef-84fa-089a131333f5",
+	name: "USD Coin",
+	symbol: "USDC",
+	networks: [{
+		name: "ethereum-mainnet",
+		display_name: "Ethereum",
+		chain_id: "1",
+		contract_address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+	}, {
+		name: "polygon-mainnet",
+		display_name: "Polygon",
+		chain_id: "137",
+		contract_address: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"
+	}]
+}, USD_CURRENCY_DEFAULT = {
+	id: "USD",
+	payment_method_limits: [{
+		id: "card",
+		min: "10.00",
+		max: "7500.00"
+	}, {
+		id: "ach_bank_account",
+		min: "10.00",
+		max: "25000.00"
+	}]
+};
+var state$1 = proxy({
+	providers: ONRAMP_PROVIDERS,
+	selectedProvider: null,
+	error: null,
+	purchaseCurrency: USDC_CURRENCY_DEFAULT,
+	paymentCurrency: USD_CURRENCY_DEFAULT,
+	purchaseCurrencies: [USDC_CURRENCY_DEFAULT],
+	paymentCurrencies: [],
+	quotesLoading: !1
+});
+const OnRampController = withErrorBoundary({
+	state: state$1,
+	subscribe(f) {
+		return subscribe(state$1, () => f(state$1));
+	},
+	subscribeKey(f, V) {
+		return subscribeKey(state$1, f, V);
+	},
+	setSelectedProvider(f) {
+		if (f && f.name === "meld") {
+			let V = ChainController.state.activeChain, H = V === ConstantsUtil.CHAIN.SOLANA ? "SOL" : "USDC", U = V ? ChainController.state.chains.get(V)?.accountState?.address ?? "" : "", W = new URL(f.url);
+			W.searchParams.append("publicKey", MELD_PUBLIC_KEY), W.searchParams.append("destinationCurrencyCode", H), W.searchParams.append("walletAddress", U), W.searchParams.append("externalCustomerId", OptionsController.state.projectId), state$1.selectedProvider = {
+				...f,
+				url: W.toString()
+			};
+		} else state$1.selectedProvider = f;
+	},
+	setOnrampProviders(f) {
+		if (Array.isArray(f) && f.every((f) => typeof f == "string")) {
+			let V = f;
+			state$1.providers = ONRAMP_PROVIDERS.filter((f) => V.includes(f.name));
+		} else state$1.providers = [];
+	},
+	setPurchaseCurrency(f) {
+		state$1.purchaseCurrency = f;
+	},
+	setPaymentCurrency(f) {
+		state$1.paymentCurrency = f;
+	},
+	setPurchaseAmount(f) {
+		OnRampController.state.purchaseAmount = f;
+	},
+	setPaymentAmount(f) {
+		OnRampController.state.paymentAmount = f;
+	},
+	async getAvailableCurrencies() {
+		let f = await BlockchainApiController.getOnrampOptions();
+		state$1.purchaseCurrencies = f.purchaseCurrencies, state$1.paymentCurrencies = f.paymentCurrencies, state$1.paymentCurrency = f.paymentCurrencies[0] || USD_CURRENCY_DEFAULT, state$1.purchaseCurrency = f.purchaseCurrencies[0] || USDC_CURRENCY_DEFAULT, await ApiController.fetchCurrencyImages(f.paymentCurrencies.map((f) => f.id)), await ApiController.fetchTokenImages(f.purchaseCurrencies.map((f) => f.symbol));
+	},
+	async getQuote() {
+		state$1.quotesLoading = !0;
+		try {
+			let f = await BlockchainApiController.getOnrampQuote({
+				purchaseCurrency: state$1.purchaseCurrency,
+				paymentCurrency: state$1.paymentCurrency,
+				amount: state$1.paymentAmount?.toString() || "0",
+				network: state$1.purchaseCurrency?.symbol
+			});
+			return state$1.quotesLoading = !1, state$1.purchaseAmount = Number(f?.purchaseAmount.amount), f;
+		} catch (f) {
+			return state$1.error = f.message, state$1.quotesLoading = !1, null;
+		} finally {
+			state$1.quotesLoading = !1;
+		}
+	},
+	resetState() {
+		state$1.selectedProvider = null, state$1.error = null, state$1.purchaseCurrency = USDC_CURRENCY_DEFAULT, state$1.paymentCurrency = USD_CURRENCY_DEFAULT, state$1.purchaseCurrencies = [USDC_CURRENCY_DEFAULT], state$1.paymentCurrencies = [], state$1.paymentAmount = void 0, state$1.purchaseAmount = void 0, state$1.quotesLoading = !1;
+	}
+});
+var SLIP44_MSB = 2147483648;
+const EnsUtil = { convertEVMChainIdToCoinType(f) {
+	if (f >= SLIP44_MSB) throw Error("Invalid chainId");
+	return (SLIP44_MSB | f) >>> 0;
+} };
+var state = proxy({
+	suggestions: [],
+	loading: !1
+});
+const EnsController = withErrorBoundary({
+	state,
+	subscribe(f) {
+		return subscribe(state, () => f(state));
+	},
+	subscribeKey(f, V) {
+		return subscribeKey(state, f, V);
+	},
+	async resolveName(f) {
+		try {
+			return await BlockchainApiController.lookupEnsName(f);
+		} catch (f) {
+			let V = f;
+			throw Error(V?.reasons?.[0]?.description || "Error resolving name");
+		}
+	},
+	async isNameRegistered(f) {
+		try {
+			return await BlockchainApiController.lookupEnsName(f), !0;
+		} catch {
+			return !1;
+		}
+	},
+	async getSuggestions(f) {
+		try {
+			return state.loading = !0, state.suggestions = [], state.suggestions = (await BlockchainApiController.getEnsNameSuggestions(f)).suggestions || [], state.suggestions;
+		} catch (f) {
+			let V = EnsController.parseEnsApiError(f, "Error fetching name suggestions");
+			throw Error(V);
+		} finally {
+			state.loading = !1;
+		}
+	},
+	async getNamesForAddress(f) {
+		try {
+			if (!ChainController.state.activeCaipNetwork) return [];
+			let V = StorageUtil.getEnsFromCacheForAddress(f);
+			if (V) return V;
+			let H = await BlockchainApiController.reverseLookupEnsName({ address: f });
+			return StorageUtil.updateEnsCache({
+				address: f,
+				ens: H,
+				timestamp: Date.now()
+			}), H;
+		} catch (f) {
+			let V = EnsController.parseEnsApiError(f, "Error fetching names for address");
+			throw Error(V);
+		}
+	},
+	async registerName(f) {
+		let V = ChainController.state.activeCaipNetwork, H = ChainController.getAccountData(V?.chainNamespace)?.address, U = ConnectorController.getAuthConnector();
+		if (!V) throw Error("Network not found");
+		if (!H || !U) throw Error("Address or auth connector not found");
+		state.loading = !0;
+		try {
+			let U = JSON.stringify({
+				name: f,
+				attributes: {},
+				timestamp: Math.floor(Date.now() / 1e3)
+			});
+			RouterController.pushTransactionStack({ onCancel() {
+				RouterController.replace("RegisterAccountName");
+			} });
+			let W = await ConnectionController.signMessage(U);
+			state.loading = !1;
+			let G = V.id;
+			if (!G) throw Error("Network not found");
+			let K = EnsUtil.convertEVMChainIdToCoinType(Number(G));
+			await BlockchainApiController.registerEnsName({
+				coinType: K,
+				address: H,
+				signature: W,
+				message: U
+			}), ChainController.setAccountProp("profileName", f, V.chainNamespace), StorageUtil.updateEnsCache({
+				address: H,
+				ens: [{
+					name: f,
+					registered_at: (/* @__PURE__ */ new Date()).toISOString(),
+					updated_at: void 0,
+					addresses: {},
+					attributes: []
+				}],
+				timestamp: Date.now()
+			}), RouterController.replace("RegisterAccountNameSuccess");
+		} catch (V) {
+			let H = EnsController.parseEnsApiError(V, `Error registering name ${f}`);
+			throw RouterController.replace("RegisterAccountName"), Error(H);
+		} finally {
+			state.loading = !1;
+		}
+	},
+	validateName(f) {
+		return /^[a-zA-Z0-9-]{4,}$/u.test(f);
+	},
+	parseEnsApiError(f, V) {
+		return f?.reasons?.[0]?.description || V;
+	}
+});
+function parseUrl(f) {
+	try {
+		return new URL(f);
+	} catch {
+		return null;
+	}
+}
+function parseSchemelessHostPort(f) {
+	let V = f.split("/"), H = V.length > 0 && V[0] !== void 0 ? V[0] : "", U = H.lastIndexOf(":");
+	return U === -1 ? { host: H } : {
+		host: H.slice(0, U),
+		port: H.slice(U + 1)
+	};
+}
+function parseOriginRaw(f) {
+	let V = f.indexOf("://");
+	if (V === -1) return null;
+	let H = f.slice(0, V), U = V + 3, W = f.indexOf("/", U);
+	W === -1 && (W = f.length);
+	let G = f.slice(U, W), K = G.lastIndexOf(":");
+	return K === -1 ? {
+		scheme: H,
+		host: G
+	} : {
+		scheme: H,
+		host: G.slice(0, K),
+		port: G.slice(K + 1)
+	};
+}
+function matchNonWildcardPattern(f, V) {
+	if (V.includes("://")) {
+		let H = parseUrl(V);
+		return H ? H.origin === f : !1;
+	}
+	let { host: H, port: U } = parseSchemelessHostPort(V), W = f.indexOf("://");
+	if (W !== -1) {
+		let V = W + 3, G = f.indexOf("/", V);
+		G === -1 && (G = f.length);
+		let K = f.slice(V, G);
+		return U === void 0 ? H === K.split(":")[0] : `${H}:${U}` === K;
+	}
+	let G = parseUrl(f);
+	return G ? U === void 0 ? H === G.hostname : H === G.hostname && U === (G.port || void 0) : !1;
+}
+function matchWildcardPattern(f, V, H) {
+	let U = H, W, G = U.indexOf("://");
+	G !== -1 && (W = U.slice(0, G), U = U.slice(G + 3));
+	let K = U.indexOf("/");
+	K !== -1 && (U = U.slice(0, K));
+	let q = U, J, Y = q.lastIndexOf(":");
+	Y !== -1 && (J = q.slice(Y + 1), q = q.slice(0, Y));
+	let X = q.split(".");
+	for (let f of X) if (f.includes("*") && f !== "*") return !1;
+	let Z = f.protocol.replace(/:$/u, "");
+	if (W && W !== Z || J !== void 0 && J !== "*" && J !== f.port) return !1;
+	let Q = parseOriginRaw(V), $ = (Q ? Q.host : f.hostname).split(".");
+	if (X.length !== $.length) return !1;
+	for (let f = X.length - 1; f >= 0; --f) {
+		let V = X[f], H = $[f];
+		if (V !== "*" && V !== H) return !1;
+	}
+	return !0;
+}
+const DEFAULT_METHODS = {
+	ton: ["ton_sendMessage", "ton_signData"],
+	solana: [
+		"solana_signMessage",
+		"solana_signTransaction",
+		"solana_requestAccounts",
+		"solana_getAccounts",
+		"solana_signAllTransactions",
+		"solana_signAndSendTransaction"
+	],
+	eip155: [
+		"eth_accounts",
+		"eth_requestAccounts",
+		"eth_sendRawTransaction",
+		"eth_sign",
+		"eth_signTransaction",
+		"eth_signTypedData",
+		"eth_signTypedData_v3",
+		"eth_signTypedData_v4",
+		"eth_sendTransaction",
+		"personal_sign",
+		"wallet_switchEthereumChain",
+		"wallet_addEthereumChain",
+		"wallet_getPermissions",
+		"wallet_requestPermissions",
+		"wallet_registerOnboarding",
+		"wallet_watchAsset",
+		"wallet_scanQRCode",
+		"wallet_getCallsStatus",
+		"wallet_showCallsStatus",
+		"wallet_sendCalls",
+		"wallet_getCapabilities",
+		"wallet_grantPermissions",
+		"wallet_revokePermissions",
+		"wallet_getAssets"
+	],
+	bip122: [
+		"sendTransfer",
+		"signMessage",
+		"signPsbt",
+		"getAccountAddresses"
+	]
+}, WcHelpersUtil = {
+	RPC_ERROR_CODE: {
+		USER_REJECTED: 5e3,
+		USER_REJECTED_METHODS: 5002
+	},
+	getMethodsByChainNamespace(f) {
+		return DEFAULT_METHODS[f] || [];
+	},
+	createDefaultNamespace(f) {
+		return {
+			methods: this.getMethodsByChainNamespace(f),
+			events: ["accountsChanged", "chainChanged"],
+			chains: [],
+			rpcMap: {}
+		};
+	},
+	applyNamespaceOverrides(f, V) {
+		if (!V) return { ...f };
+		let H = { ...f }, U = /* @__PURE__ */ new Set();
+		if (V.methods && Object.keys(V.methods).forEach((f) => U.add(f)), V.chains && Object.keys(V.chains).forEach((f) => U.add(f)), V.events && Object.keys(V.events).forEach((f) => U.add(f)), V.rpcMap && Object.keys(V.rpcMap).forEach((f) => {
+			let [V] = f.split(":");
+			V && U.add(V);
+		}), U.forEach((f) => {
+			H[f] || (H[f] = this.createDefaultNamespace(f));
+		}), V.methods && Object.entries(V.methods).forEach(([f, V]) => {
+			H[f] && (H[f].methods = V);
+		}), V.chains && Object.entries(V.chains).forEach(([f, V]) => {
+			H[f] && (H[f].chains = V);
+		}), V.events && Object.entries(V.events).forEach(([f, V]) => {
+			H[f] && (H[f].events = V);
+		}), V.rpcMap) {
+			let f = /* @__PURE__ */ new Set();
+			Object.entries(V.rpcMap).forEach(([V, U]) => {
+				let [W, G] = V.split(":");
+				!W || !G || !H[W] || (H[W].rpcMap || (H[W].rpcMap = {}), f.has(W) || (H[W].rpcMap = {}, f.add(W)), H[W].rpcMap[G] = U);
+			});
+		}
+		return H;
+	},
+	createNamespaces(f, V) {
+		let H = f.reduce((f, V) => {
+			let { id: H, chainNamespace: U, rpcUrls: W } = V, G = W.default.http[0];
+			f[U] || (f[U] = this.createDefaultNamespace(U));
+			let K = `${U}:${H}`, q = f[U];
+			switch (q.chains.push(K), K) {
+				case "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp":
+					q.chains.push("solana:4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZ");
+					break;
+				case "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1":
+					q.chains.push("solana:8E9rvCKLFQia2Y35HXjjpWzj8weVo44K");
+					break;
+				default:
+			}
+			return q?.rpcMap && G && (q.rpcMap[H] = G), f;
+		}, {});
+		return this.applyNamespaceOverrides(H, V);
+	},
+	resolveReownName: async (f) => {
+		let V = await EnsController.resolveName(f);
+		return (V?.addresses ? Object.values(V.addresses) : [])[0]?.address || !1;
+	},
+	getChainsFromNamespaces(f = {}) {
+		return Object.values(f).flatMap((f) => {
+			let V = f.chains || [], H = f.accounts.map((f) => {
+				let [V, H] = f.split(":");
+				return `${V}:${H}`;
+			});
+			return Array.from(new Set([...V, ...H]));
+		});
+	},
+	isSessionEventData(f) {
+		return typeof f == "object" && !!f && "id" in f && "topic" in f && "params" in f && typeof f.params == "object" && f.params !== null && "chainId" in f.params && "event" in f.params && typeof f.params.event == "object" && f.params.event !== null;
+	},
+	isUserRejectedRequestError(f) {
+		try {
+			if (typeof f == "object" && f) {
+				let V = f, H = typeof V.code == "number", U = H && V.code === WcHelpersUtil.RPC_ERROR_CODE.USER_REJECTED_METHODS, W = H && V.code === WcHelpersUtil.RPC_ERROR_CODE.USER_REJECTED;
+				return U || W;
+			}
+			return !1;
+		} catch {
+			return !1;
+		}
+	},
+	isOriginAllowed(f, V, H) {
+		let U = [...V, ...H];
+		if (V.length === 0) return !0;
+		let W = parseUrl(f);
+		if (!W) return U.some((V) => !V.includes("*") && V === f);
+		if (W.hostname === "localhost" || W.hostname === "127.0.0.1") return !0;
+		for (let V of U) if (V.includes("*")) {
+			if (matchWildcardPattern(W, f, V)) return !0;
+		} else if (matchNonWildcardPattern(f, V)) return !0;
+		return !1;
+	},
+	listenWcProvider({ universalProvider: f, namespace: V, onConnect: H, onDisconnect: U, onAccountsChanged: W, onChainChanged: G, onDisplayUri: K }) {
+		H && f.on("connect", () => {
+			H(WcHelpersUtil.getWalletConnectAccounts(f, V));
+		}), U && f.on("disconnect", () => {
+			U();
+		}), W && f.on("accountsChanged", (H) => {
+			try {
+				let U = f.session?.namespaces?.[V]?.accounts || [], G = f.rpcProviders?.[V]?.getDefaultChain(), K = H.map((f) => {
+					let H = U.find((H) => H.includes(`${V}:${G}:${f}`));
+					if (!H) return;
+					let { chainId: W, chainNamespace: K } = ParseUtil.parseCaipAddress(H);
+					return {
+						address: f,
+						chainId: W,
+						chainNamespace: K
+					};
+				}).filter((f) => f !== void 0);
+				K.length > 0 && W(K);
+			} catch (f) {
+				console.warn("Failed to parse accounts for namespace on accountsChanged event", V, H, f);
+			}
+		}), G && f.on("chainChanged", (f) => {
+			G(f);
+		}), K && f.on("display_uri", (f) => {
+			K(f);
+		});
+	},
+	getWalletConnectAccounts(f, V) {
+		let H = /* @__PURE__ */ new Set(), U = f?.session?.namespaces?.[V]?.accounts?.map((f) => ParseUtil.parseCaipAddress(f)).filter(({ address: f }) => H.has(f.toLowerCase()) ? !1 : (H.add(f.toLowerCase()), !0));
+		return U && U.length > 0 ? U : [];
+	}
+};
+var IGNORED_CONNECTOR_IDS_FOR_LISTENER = [ConstantsUtil.CONNECTOR_ID.AUTH, ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT], AdapterBlueprint = class {
+	constructor(f) {
+		this.availableConnectors = [], this.availableConnections = [], this.providerHandlers = {}, this.eventListeners = /* @__PURE__ */ new Map(), this.getCaipNetworks = (f) => ChainController.getCaipNetworks(f), this.getConnectorId = (f) => ConnectorController.getConnectorId(f), f && this.construct(f);
+	}
+	construct(f) {
+		this.projectId = f.projectId, this.namespace = f.namespace, this.adapterType = f.adapterType;
+	}
+	get connectors() {
+		return this.availableConnectors;
+	}
+	get connections() {
+		return this.availableConnections;
+	}
+	get networks() {
+		return this.getCaipNetworks(this.namespace);
+	}
+	onAuthConnected({ accounts: f, chainId: V }) {
+		let H = this.getCaipNetworks().filter((f) => f.chainNamespace === this.namespace).find((f) => f.id.toString() === V?.toString());
+		f && H && this.addConnection({
+			connectorId: ConstantsUtil.CONNECTOR_ID.AUTH,
+			accounts: f,
+			caipNetwork: H
+		});
+	}
+	setAuthProvider(f) {
+		f.onConnect(this.onAuthConnected.bind(this)), f.onSocialConnected(this.onAuthConnected.bind(this)), this.addConnector({
+			id: ConstantsUtil.CONNECTOR_ID.AUTH,
+			type: "AUTH",
+			name: ConstantsUtil.CONNECTOR_NAMES.AUTH,
+			provider: f,
+			imageId: void 0,
+			chain: this.namespace,
+			chains: []
+		});
+	}
+	addConnector(...f) {
+		let V = /* @__PURE__ */ new Set();
+		this.availableConnectors = [...f, ...this.availableConnectors].filter((f) => V.has(f.id) ? !1 : (V.add(f.id), !0)), this.emit("connectors", this.availableConnectors);
+	}
+	addConnection(...f) {
+		let V = /* @__PURE__ */ new Set();
+		this.availableConnections = [...f, ...this.availableConnections].filter((f) => V.has(f.connectorId.toLowerCase()) ? !1 : (V.add(f.connectorId.toLowerCase()), !0)), this.emit("connections", this.availableConnections);
+	}
+	deleteConnection(f) {
+		this.availableConnections = this.availableConnections.filter((V) => V.connectorId.toLowerCase() !== f.toLowerCase()), this.emit("connections", this.availableConnections);
+	}
+	clearConnections(f = !1) {
+		this.availableConnections = [], f && this.emit("connections", this.availableConnections);
+	}
+	setStatus(f, V) {
+		ChainController.setAccountProp("status", f, V);
+	}
+	on(f, V) {
+		this.eventListeners.has(f) || this.eventListeners.set(f, /* @__PURE__ */ new Set()), this.eventListeners.get(f)?.add(V);
+	}
+	off(f, V) {
+		let H = this.eventListeners.get(f);
+		H && H.delete(V);
+	}
+	removeAllEventListeners() {
+		this.eventListeners.forEach((f) => {
+			f.clear();
+		});
+	}
+	emit(f, V) {
+		let H = this.eventListeners.get(f);
+		H && H.forEach((f) => f(V));
+	}
+	async connectWalletConnect(f) {
+		try {
+			return { clientId: (await this.getWalletConnectConnector().connectWalletConnect()).clientId };
+		} catch (f) {
+			throw WcHelpersUtil.isUserRejectedRequestError(f) ? new UserRejectedRequestError(f) : f;
+		}
+	}
+	async switchNetwork(f) {
+		let { caipNetwork: V } = f, H = ProviderController.getProviderId(V.chainNamespace), U = ProviderController.getProvider(V.chainNamespace);
+		if (!U) throw Error("Provider not found");
+		if (H === "WALLET_CONNECT") {
+			U.setDefaultChain(V.caipNetworkId);
+			return;
+		}
+		if (H === "AUTH") {
+			let f = ConnectorController.getAuthConnector()?.provider;
+			if (!f) throw Error("Auth provider not found");
+			let H = getPreferredAccountType(V.chainNamespace);
+			await f.switchNetwork({ chainId: V.caipNetworkId });
+			let U = await f.getUser({
+				chainId: V.caipNetworkId,
+				preferredAccountType: H
+			});
+			this.emit("switchNetwork", U);
+		}
+	}
+	getWalletConnectConnector() {
+		let f = this.connectors.find((f) => f.id === "walletConnect");
+		if (!f) throw Error("WalletConnectConnector not found");
+		return f;
+	}
+	onConnect(f, V) {
+		if (f.length > 0) {
+			let { address: H, chainId: U } = CoreHelperUtil.getAccount(f[0]), W = this.getCaipNetworks().filter((f) => f.chainNamespace === this.namespace).find((f) => f.id.toString() === U?.toString()), G = this.connectors.find((f) => f.id === V);
+			H && (this.emit("accountChanged", {
+				address: H,
+				chainId: U,
+				connector: G
+			}), this.addConnection({
+				connectorId: V,
+				accounts: f.map((f) => {
+					let { address: V } = CoreHelperUtil.getAccount(f);
+					return { address: V };
+				}),
+				caipNetwork: W
+			}));
+		}
+	}
+	onAccountsChanged(f, V, H = !0) {
+		if (f.length > 0) {
+			let { address: H } = CoreHelperUtil.getAccount(f[0]), U = this.getConnection({
+				connectorId: V,
+				connections: this.connections,
+				connectors: this.connectors
+			});
+			H && this.getConnectorId(ConstantsUtil.CHAIN.EVM)?.toLowerCase() === V.toLowerCase() && this.emit("accountChanged", {
+				address: H,
+				chainId: U?.caipNetwork?.id,
+				connector: U?.connector
+			}), this.addConnection({
+				connectorId: V,
+				accounts: f.map((f) => {
+					let { address: V } = CoreHelperUtil.getAccount(f);
+					return { address: V };
+				}),
+				caipNetwork: U?.caipNetwork
+			});
+		} else H && this.onDisconnect(V);
+	}
+	onDisconnect(f) {
+		this.removeProviderListeners(f), this.deleteConnection(f), this.getConnectorId(ConstantsUtil.CHAIN.EVM)?.toLowerCase() === f.toLowerCase() && this.emitFirstAvailableConnection(), this.connections.length === 0 && this.emit("disconnect");
+	}
+	onChainChanged(f, V) {
+		let H = typeof f == "string" && f.startsWith("0x") ? parseInt(f, 16).toString() : f.toString(), U = this.getConnection({
+			connectorId: V,
+			connections: this.connections,
+			connectors: this.connectors
+		}), W = this.getCaipNetworks().filter((f) => f.chainNamespace === this.namespace).find((f) => f.id.toString() === H);
+		U && this.addConnection({
+			connectorId: V,
+			accounts: U.accounts,
+			caipNetwork: W
+		}), this.getConnectorId(ConstantsUtil.CHAIN.EVM)?.toLowerCase() === V.toLowerCase() && this.emit("switchNetwork", { chainId: H });
+	}
+	listenProviderEvents(f, V) {
+		if (IGNORED_CONNECTOR_IDS_FOR_LISTENER.includes(f)) return;
+		let H = (V) => this.onAccountsChanged(V, f), U = (V) => this.onChainChanged(V, f), W = () => this.onDisconnect(f);
+		this.providerHandlers[f] || (V.on("disconnect", W), V.on("accountsChanged", H), V.on("chainChanged", U), this.providerHandlers[f] = {
+			provider: V,
+			disconnect: W,
+			accountsChanged: H,
+			chainChanged: U
+		});
+	}
+	removeProviderListeners(f) {
+		if (this.providerHandlers[f]) {
+			let { provider: V, disconnect: H, accountsChanged: U, chainChanged: W } = this.providerHandlers[f];
+			V.removeListener("disconnect", H), V.removeListener("accountsChanged", U), V.removeListener("chainChanged", W), this.providerHandlers[f] = null;
+		}
+	}
+	emitFirstAvailableConnection() {
+		let f = this.getConnection({
+			connections: this.connections,
+			connectors: this.connectors
+		});
+		if (f) {
+			let [V] = f.accounts;
+			this.emit("accountChanged", {
+				address: V?.address,
+				chainId: f.caipNetwork?.id,
+				connector: f.connector
+			});
+		}
+	}
+	getConnection({ address: f, connectorId: V, connections: H, connectors: U }) {
+		if (V) {
+			let W = H.find((f) => f.connectorId.toLowerCase() === V.toLowerCase());
+			if (!W) return null;
+			let G = U.find((f) => f.id.toLowerCase() === W.connectorId.toLowerCase()), K = f ? W.accounts.find((V) => V.address.toLowerCase() === f.toLowerCase()) : W.accounts[0];
+			return {
+				...W,
+				account: K,
+				connector: G
+			};
+		}
+		let W = H.find((f) => f.accounts.length > 0 && U.some((V) => V.id.toLowerCase() === f.connectorId.toLowerCase()));
+		if (W) {
+			let [f] = W.accounts, V = U.find((f) => f.id.toLowerCase() === W.connectorId.toLowerCase());
+			return {
+				...W,
+				account: f,
+				connector: V
+			};
+		}
+		return null;
+	}
+}, WalletConnectConnector = class {
+	constructor({ provider: f, namespace: V }) {
+		this.id = ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT, this.name = "WalletConnect", this.type = "WALLET_CONNECT", this.imageId = "ef1a1fcf-7fe8-4d69-bd6d-fda1345b4400", this.getCaipNetworks = ChainController.getCaipNetworks.bind(ChainController), this.caipNetworks = this.getCaipNetworks(), this.provider = f, this.chain = V;
+	}
+	get chains() {
+		return this.getCaipNetworks();
+	}
+	async connectWalletConnect() {
+		if (!await this.authenticate()) {
+			let f = this.getCaipNetworks(), V = OptionsController.state.universalProviderConfigOverride, H = WcHelpersUtil.createNamespaces(f, V);
+			await this.provider.connect({ optionalNamespaces: H });
+		}
+		return {
+			clientId: await this.provider.client.core.crypto.getClientId(),
+			session: this.provider.session
+		};
+	}
+	async disconnect() {
+		await this.provider.disconnect();
+	}
+	async authenticate() {
+		let f = this.chains.map((f) => f.caipNetworkId);
+		return SIWXUtil.universalProviderAuthenticate({
+			universalProvider: this.provider,
+			chains: f,
+			methods: OPTIONAL_METHODS
+		});
+	}
+}, OPTIONAL_METHODS = [
+	"eth_accounts",
+	"eth_requestAccounts",
+	"eth_sendRawTransaction",
+	"eth_sign",
+	"eth_signTransaction",
+	"eth_signTypedData",
+	"eth_signTypedData_v3",
+	"eth_signTypedData_v4",
+	"eth_sendTransaction",
+	"personal_sign",
+	"wallet_switchEthereumChain",
+	"wallet_addEthereumChain",
+	"wallet_getPermissions",
+	"wallet_requestPermissions",
+	"wallet_registerOnboarding",
+	"wallet_watchAsset",
+	"wallet_scanQRCode",
+	"wallet_getCallsStatus",
+	"wallet_sendCalls",
+	"wallet_getCapabilities",
+	"wallet_grantPermissions",
+	"wallet_revokePermissions",
+	"wallet_getAssets"
+];
+const baseUSDC = {
+	network: "eip155:8453",
+	asset: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+	metadata: {
+		name: "USD Coin",
+		symbol: "USDC",
+		decimals: 6
+	}
+}, baseSepoliaUSDC = {
+	network: "eip155:84532",
+	asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+	metadata: {
+		name: "USD Coin",
+		symbol: "USDC",
+		decimals: 6
+	}
+}, ErrorUtil = {
+	EmbeddedWalletAbortController: new AbortController(),
+	UniversalProviderErrors: {
+		UNAUTHORIZED_DOMAIN_NOT_ALLOWED: {
+			message: "Unauthorized: origin not allowed",
+			alertErrorKey: "ORIGIN_NOT_ALLOWED"
+		},
+		JWT_VALIDATION_ERROR: {
+			message: "JWT validation error: JWT Token is not yet valid",
+			alertErrorKey: "JWT_TOKEN_NOT_VALID"
+		},
+		INVALID_KEY: {
+			message: "Unauthorized: invalid key",
+			alertErrorKey: "INVALID_PROJECT_ID"
+		}
+	},
+	ALERT_ERRORS: {
+		SWITCH_NETWORK_NOT_FOUND: {
+			code: "APKT001",
+			displayMessage: "Network Not Found",
+			debugMessage: "The specified network is not recognized. Please ensure it is included in the `networks` array of your `createAppKit` configuration."
+		},
+		ORIGIN_NOT_ALLOWED: {
+			code: "APKT002",
+			displayMessage: "Invalid App Configuration",
+			debugMessage: () => `The origin ${isSafe() ? window.origin : "unknown"} is not in your allow list. Please update your allowed domains at https://dashboard.reown.com. [PID: ${OptionsController.state.projectId}]`
+		},
+		IFRAME_LOAD_FAILED: {
+			code: "APKT003",
+			displayMessage: "Network Error: Wallet Load Failed",
+			debugMessage: () => "Failed to load the embedded wallet. This may be due to network issues or server downtime. Please check your network connection and try again shortly. Contact support if the issue persists."
+		},
+		IFRAME_REQUEST_TIMEOUT: {
+			code: "APKT004",
+			displayMessage: "Wallet Request Timeout",
+			debugMessage: () => "The request to the embedded wallet timed out. Please check your network connection and try again shortly. Contact support if the issue persists."
+		},
+		UNVERIFIED_DOMAIN: {
+			code: "APKT005",
+			displayMessage: "Unverified Domain",
+			debugMessage: () => "Embedded wallet load failed. Ensure your domain is verified in https://dashboard.reown.com."
+		},
+		JWT_TOKEN_NOT_VALID: {
+			code: "APKT006",
+			displayMessage: "Session Expired",
+			debugMessage: "Your session is invalid or expired. Please check your system’s date and time settings, then reconnect."
+		},
+		INVALID_PROJECT_ID: {
+			code: "APKT007",
+			displayMessage: "Invalid Project ID",
+			debugMessage: "The specified project ID is invalid. Please visit https://dashboard.reown.com to obtain a valid project ID."
+		},
+		PROJECT_ID_NOT_CONFIGURED: {
+			code: "APKT008",
+			displayMessage: "Project ID Missing",
+			debugMessage: "No project ID is configured. You can create and configure a project ID at https://dashboard.reown.com."
+		},
+		SERVER_ERROR_APP_CONFIGURATION: {
+			code: "APKT009",
+			displayMessage: "Server Error",
+			debugMessage: (f) => `Unable to fetch App Configuration. ${f}. Please check your network connection and try again shortly. Contact support if the issue persists.`
+		},
+		RATE_LIMITED_APP_CONFIGURATION: {
+			code: "APKT010",
+			displayMessage: "Rate Limited",
+			debugMessage: "You have been rate limited while retrieving App Configuration. Please wait a few minutes and try again. Contact support if the issue persists."
+		}
+	},
+	ALERT_WARNINGS: {
+		LOCAL_CONFIGURATION_IGNORED: { debugMessage: (f) => `[Reown Config Notice] ${f}` },
+		INACTIVE_NAMESPACE_NOT_CONNECTED: {
+			code: "APKTW001",
+			displayMessage: "Inactive Namespace Not Connected",
+			debugMessage: (f, V) => `An error occurred while connecting an inactive namespace ${f}: "${V}"`
+		},
+		INVALID_EMAIL: {
+			code: "APKTW002",
+			displayMessage: "Invalid Email Address",
+			debugMessage: "Please enter a valid email address"
+		}
+	}
+}, TokenUtil = {
+	TOKEN_ADDRESSES_BY_SYMBOL: { USDC: {
+		8453: baseUSDC.asset,
+		84532: baseSepoliaUSDC.asset
+	} },
+	getTokenSymbolByAddress(f) {
+		if (!f) return;
+		let [V] = Object.entries(TokenUtil.TOKEN_ADDRESSES_BY_SYMBOL).find(([V, H]) => Object.values(H).includes(f)) ?? [];
+		return V;
+	}
+}, LoggerUtil = { createLogger(f, U = "error") {
+	let { logger: W } = Ue({ opts: Ge({ level: U }) });
+	return W.error = (...V) => {
+		for (let H of V) if (H instanceof Error) {
+			f(H, ...V);
+			return;
+		}
+		f(void 0, ...V);
+	}, W;
+} }, WcConstantsUtil = {
+	ERROR_CODE_UNRECOGNIZED_CHAIN_ID: 4902,
+	ERROR_CODE_DEFAULT: 5e3,
+	ERROR_INVALID_CHAIN_ID: 32603
+};
+var UniversalAdapter = class extends AdapterBlueprint {
+	async setUniversalProvider(f) {
+		if (!this.namespace) throw Error("UniversalAdapter:setUniversalProvider - namespace is required");
+		return this.addConnector(new WalletConnectConnector({
+			provider: f,
+			caipNetworks: this.getCaipNetworks(),
+			namespace: this.namespace
+		})), Promise.resolve();
+	}
+	async connect(f) {
+		return Promise.resolve({
+			id: "WALLET_CONNECT",
+			type: "WALLET_CONNECT",
+			chainId: Number(f.chainId),
+			provider: this.provider,
+			address: ""
+		});
+	}
+	async disconnect() {
+		try {
+			await this.getWalletConnectConnector().disconnect(), this.emit("disconnect");
+		} catch (f) {
+			console.warn("UniversalAdapter:disconnect - error", f);
+		}
+		return { connections: [] };
+	}
+	syncConnections() {
+		return Promise.resolve();
+	}
+	async writeSolanaTransaction() {
+		return Promise.resolve({ hash: "" });
+	}
+	async getAccounts({ namespace: f }) {
+		let V = this.provider?.session?.namespaces?.[f]?.accounts?.map((f) => {
+			let [, , V] = f.split(":");
+			return V;
+		}).filter((f, V, H) => H.indexOf(f) === V) || [];
+		return Promise.resolve({ accounts: V.map((V) => CoreHelperUtil.createAccount(f, V, f === "bip122" ? "payment" : "eoa")) });
+	}
+	async syncConnectors() {
+		return Promise.resolve();
+	}
+	async getBalance(f) {
+		if (!(f.caipNetwork && ConstantsUtil$1.BALANCE_SUPPORTED_CHAINS.includes(f.caipNetwork?.chainNamespace)) || f.caipNetwork?.testnet) return {
+			balance: "0.00",
+			symbol: f.caipNetwork?.nativeCurrency.symbol || ""
+		};
+		let V = ChainController.getAccountData();
+		if (V?.balanceLoading && f.chainId === ChainController.state.activeCaipNetwork?.id) return {
+			balance: V?.balance || "0.00",
+			symbol: V?.balanceSymbol || ""
+		};
+		let H = (await ChainController.fetchTokenBalance()).find((V) => V.chainId === `${f.caipNetwork?.chainNamespace}:${f.chainId}` && V.symbol === f.caipNetwork?.nativeCurrency.symbol);
+		return {
+			balance: H?.quantity.numeric || "0.00",
+			symbol: H?.symbol || f.caipNetwork?.nativeCurrency.symbol || ""
+		};
+	}
+	async signMessage(V) {
+		let { provider: H, message: U, address: W } = V;
+		if (!H) throw Error("UniversalAdapter:signMessage - provider is undefined");
+		let G = "";
+		return G = ChainController.state.activeCaipNetwork?.chainNamespace === ConstantsUtil.CHAIN.SOLANA ? (await H.request({
+			method: "solana_signMessage",
+			params: {
+				message: esm_default.encode(new TextEncoder().encode(U)),
+				pubkey: W
+			}
+		}, ChainController.state.activeCaipNetwork?.caipNetworkId)).signature : await H.request({
+			method: "personal_sign",
+			params: [U, W]
+		}, ChainController.state.activeCaipNetwork?.caipNetworkId), { signature: G };
+	}
+	async estimateGas() {
+		return Promise.resolve({ gas: BigInt(0) });
+	}
+	async sendTransaction() {
+		return Promise.resolve({ hash: "" });
+	}
+	walletGetAssets(f) {
+		return Promise.resolve({});
+	}
+	async writeContract() {
+		return Promise.resolve({ hash: "" });
+	}
+	emitFirstAvailableConnection() {}
+	parseUnits() {
+		return 0n;
+	}
+	formatUnits() {
+		return "0";
+	}
+	async getCapabilities() {
+		return Promise.resolve({});
+	}
+	async grantPermissions() {
+		return Promise.resolve({});
+	}
+	async revokePermissions() {
+		return Promise.resolve("0x");
+	}
+	async syncConnection() {
+		return Promise.resolve({
+			id: "WALLET_CONNECT",
+			type: "WALLET_CONNECT",
+			chainId: 1,
+			provider: this.provider,
+			address: ""
+		});
+	}
+	async switchNetwork(f) {
+		let { caipNetwork: V } = f, H = this.getWalletConnectConnector();
+		if (V.chainNamespace === ConstantsUtil.CHAIN.EVM) try {
+			await H.provider?.request({
+				method: "wallet_switchEthereumChain",
+				params: [{ chainId: toHex(V.id) }]
+			});
+		} catch (f) {
+			if (f.code === WcConstantsUtil.ERROR_CODE_UNRECOGNIZED_CHAIN_ID || f.code === WcConstantsUtil.ERROR_INVALID_CHAIN_ID || f.code === WcConstantsUtil.ERROR_CODE_DEFAULT || f?.data?.originalError?.code === WcConstantsUtil.ERROR_CODE_UNRECOGNIZED_CHAIN_ID) try {
+				await H.provider?.request({
+					method: "wallet_addEthereumChain",
+					params: [{
+						chainId: toHex(V.id),
+						rpcUrls: [V?.rpcUrls.chainDefault?.http],
+						chainName: V.name,
+						nativeCurrency: V.nativeCurrency,
+						blockExplorerUrls: [V.blockExplorers?.default.url]
+					}]
+				});
+			} catch {
+				throw Error("Chain is not supported");
+			}
+		}
+		H.provider.setDefaultChain(V.caipNetworkId);
+	}
+	getWalletConnectProvider() {
+		return this.connectors.find((f) => f.type === "WALLET_CONNECT")?.provider;
+	}
+}, FEATURE_KEYS = [
+	"email",
+	"socials",
+	"swaps",
+	"onramp",
+	"activity",
+	"reownBranding",
+	"multiWallet",
+	"emailCapture",
+	"payWithExchange",
+	"payments",
+	"reownAuthentication",
+	"headless"
+], featureConfig = {
+	email: {
+		apiFeatureName: "social_login",
+		localFeatureName: "email",
+		returnType: !1,
+		isLegacy: !1,
+		isAvailableOnBasic: !1,
+		processApi: (f) => {
+			if (!f?.config) return !1;
+			let V = f.config;
+			return !!f.isEnabled && V.includes("email");
+		},
+		processFallback: (f) => f === void 0 ? ConstantsUtil$1.DEFAULT_REMOTE_FEATURES.email : !!f
+	},
+	socials: {
+		apiFeatureName: "social_login",
+		localFeatureName: "socials",
+		returnType: !1,
+		isLegacy: !1,
+		isAvailableOnBasic: !1,
+		processApi: (f) => {
+			if (!f?.config) return !1;
+			let V = f.config;
+			return f.isEnabled && V.length > 0 ? V.filter((f) => f !== "email") : !1;
+		},
+		processFallback: (f) => f === void 0 ? ConstantsUtil$1.DEFAULT_REMOTE_FEATURES.socials : typeof f == "boolean" ? f ? ConstantsUtil$1.DEFAULT_REMOTE_FEATURES.socials : !1 : f
+	},
+	swaps: {
+		apiFeatureName: "swap",
+		localFeatureName: "swaps",
+		returnType: !1,
+		isLegacy: !1,
+		isAvailableOnBasic: !1,
+		processApi: (f) => {
+			if (!f?.config) return !1;
+			let V = f.config;
+			return f.isEnabled && V.length > 0 ? V : !1;
+		},
+		processFallback: (f) => f === void 0 ? ConstantsUtil$1.DEFAULT_REMOTE_FEATURES.swaps : typeof f == "boolean" ? f ? ConstantsUtil$1.DEFAULT_REMOTE_FEATURES.swaps : !1 : f
+	},
+	onramp: {
+		apiFeatureName: "onramp",
+		localFeatureName: "onramp",
+		returnType: !1,
+		isLegacy: !1,
+		isAvailableOnBasic: !1,
+		processApi: (f) => {
+			if (!f?.config) return !1;
+			let V = f.config;
+			return f.isEnabled && V.length > 0 ? V : !1;
+		},
+		processFallback: (f) => f === void 0 ? ConstantsUtil$1.DEFAULT_REMOTE_FEATURES.onramp : typeof f == "boolean" ? f ? ConstantsUtil$1.DEFAULT_REMOTE_FEATURES.onramp : !1 : f
+	},
+	activity: {
+		apiFeatureName: "activity",
+		localFeatureName: "history",
+		returnType: !1,
+		isLegacy: !0,
+		isAvailableOnBasic: !1,
+		processApi: (f) => !!f.isEnabled,
+		processFallback: (f) => f === void 0 ? ConstantsUtil$1.DEFAULT_REMOTE_FEATURES.activity : !!f
+	},
+	reownBranding: {
+		apiFeatureName: "reown_branding",
+		localFeatureName: "reownBranding",
+		returnType: !1,
+		isLegacy: !1,
+		isAvailableOnBasic: !1,
+		processApi: (f) => !!f.isEnabled,
+		processFallback: (f) => f === void 0 ? ConstantsUtil$1.DEFAULT_REMOTE_FEATURES.reownBranding : !!f
+	},
+	emailCapture: {
+		apiFeatureName: "email_capture",
+		localFeatureName: "emailCapture",
+		returnType: !1,
+		isLegacy: !1,
+		isAvailableOnBasic: !1,
+		processApi: (f) => f.isEnabled && (f.config ?? []),
+		processFallback: (f) => !1
+	},
+	multiWallet: {
+		apiFeatureName: "multi_wallet",
+		localFeatureName: "multiWallet",
+		returnType: !1,
+		isLegacy: !1,
+		isAvailableOnBasic: !1,
+		processApi: (f) => !!f.isEnabled,
+		processFallback: () => ConstantsUtil$1.DEFAULT_REMOTE_FEATURES.multiWallet
+	},
+	payWithExchange: {
+		apiFeatureName: "fund_from_exchange",
+		localFeatureName: "payWithExchange",
+		returnType: !1,
+		isLegacy: !1,
+		isAvailableOnBasic: !1,
+		processApi: (f) => !!f.isEnabled,
+		processFallback: () => ConstantsUtil$1.DEFAULT_REMOTE_FEATURES.payWithExchange
+	},
+	payments: {
+		apiFeatureName: "payments",
+		localFeatureName: "payments",
+		returnType: !1,
+		isLegacy: !1,
+		isAvailableOnBasic: !1,
+		processApi: (f) => !!f.isEnabled,
+		processFallback: () => ConstantsUtil$1.DEFAULT_REMOTE_FEATURES.payments
+	},
+	reownAuthentication: {
+		apiFeatureName: "reown_authentication",
+		localFeatureName: "reownAuthentication",
+		returnType: !1,
+		isLegacy: !1,
+		isAvailableOnBasic: !1,
+		processApi: (f) => !!f.isEnabled,
+		processFallback: (f) => f === void 0 ? ConstantsUtil$1.DEFAULT_REMOTE_FEATURES.reownAuthentication : !!f
+	},
+	headless: {
+		apiFeatureName: "headless",
+		localFeatureName: "headless",
+		returnType: !1,
+		isLegacy: !1,
+		isAvailableOnBasic: !1,
+		processApi: (f) => !!f.isEnabled,
+		processFallback: () => ConstantsUtil$1.DEFAULT_REMOTE_FEATURES.headless
+	}
+};
+const ConfigUtil = {
+	localSettingsOverridden: /* @__PURE__ */ new Set(),
+	getApiConfig(f, V) {
+		return V?.find((V) => V.id === f);
+	},
+	addWarning(f, V) {
+		if (f !== void 0) {
+			let f = featureConfig[V], H = f.isLegacy ? `"features.${f.localFeatureName}" (now "${V}")` : `"features.${V}"`;
+			this.localSettingsOverridden.add(H);
+		}
+	},
+	processFeature(f, V, H, U, W) {
+		let G = featureConfig[f], K = V[G.localFeatureName];
+		if (W && !G.isAvailableOnBasic) return !1;
+		if (U) {
+			let V = this.getApiConfig(G.apiFeatureName, H);
+			return V?.config === null ? this.processFallbackFeature(f, K) : V?.config ? (K !== void 0 && this.addWarning(K, f), this.processApiFeature(f, V)) : !1;
+		}
+		return this.processFallbackFeature(f, K);
+	},
+	processApiFeature(f, V) {
+		return featureConfig[f].processApi(V);
+	},
+	processFallbackFeature(f, V) {
+		return featureConfig[f].processFallback(V);
+	},
+	async fetchRemoteFeatures(f) {
+		let V = f.basic ?? !1, H = f.features || {};
+		this.localSettingsOverridden.clear();
+		let U = null, W = !1;
+		try {
+			U = await ApiController.fetchProjectConfig(), W = U != null;
+		} catch (f) {
+			console.warn("[Reown Config] Failed to fetch remote project configuration. Using local/default values.", f);
+		}
+		let G = W && !V ? ConstantsUtil$1.DEFAULT_REMOTE_FEATURES : ConstantsUtil$1.DEFAULT_REMOTE_FEATURES_DISABLED;
+		try {
+			for (let f of FEATURE_KEYS) {
+				let K = this.processFeature(f, H, U, W, V);
+				Object.assign(G, { [f]: K });
+			}
+		} catch (f) {
+			return console.warn("[Reown Config] Failed to process the configuration from Cloud. Using default values.", f), ConstantsUtil$1.DEFAULT_REMOTE_FEATURES;
+		}
+		if (W && this.localSettingsOverridden.size > 0) {
+			let f = `Your local configuration for ${Array.from(this.localSettingsOverridden).join(", ")} was ignored because a remote configuration was successfully fetched. Please manage these features via your project dashboard on dashboard.reown.com.`;
+			AlertController.open({ debugMessage: ErrorUtil.ALERT_WARNINGS.LOCAL_CONFIGURATION_IGNORED.debugMessage(f) }, "warning");
+		}
+		return G;
+	}
+};
+var AppKitBaseClient = class {
+	constructor(f) {
+		this.chainNamespaces = [], this.features = {}, this.remoteFeatures = {}, this.reportedAlertErrors = {}, this.getCaipNetwork = (f, V) => f ? ChainController.getCaipNetworks(f)?.find((f) => f.id === V) || ChainController.getNetworkData(f)?.caipNetwork || ChainController.getRequestedCaipNetworks(f).filter((V) => V.chainNamespace === f)?.[0] : ChainController.state.activeCaipNetwork || this.defaultCaipNetwork, this.getCaipNetworkId = () => {
+			let f = this.getCaipNetwork();
+			if (f) return f.id;
+		}, this.getCaipNetworks = (f) => ChainController.getCaipNetworks(f), this.getActiveChainNamespace = () => ChainController.state.activeChain, this.setRequestedCaipNetworks = (f, V) => {
+			ChainController.setRequestedCaipNetworks(f, V);
+		}, this.getApprovedCaipNetworkIds = () => ChainController.getAllApprovedCaipNetworkIds(), this.getCaipAddress = (f) => ChainController.state.activeChain === f || !f ? ChainController.state.activeCaipAddress : ChainController.state.chains.get(f)?.accountState?.caipAddress, this.setClientId = (f) => {
+			BlockchainApiController.setClientId(f);
+		}, this.getProvider = (f) => ProviderController.getProvider(f), this.getProviderType = (f) => ProviderController.getProviderId(f), this.getPreferredAccountType = (f) => getPreferredAccountType(f), this.setCaipAddress = (f, V, H = !1) => {
+			ChainController.setAccountProp("caipAddress", f, V, H), ChainController.setAccountProp("address", CoreHelperUtil.getPlainAddress(f), V, H);
+		}, this.setBalance = (f, V, H) => {
+			ChainController.setAccountProp("balance", f, H), ChainController.setAccountProp("balanceSymbol", V, H);
+		}, this.setProfileName = (f, V) => {
+			ChainController.setAccountProp("profileName", f, V);
+		}, this.setProfileImage = (f, V) => {
+			ChainController.setAccountProp("profileImage", f, V);
+		}, this.setUser = (f, V) => {
+			ChainController.setAccountProp("user", f, V);
+		}, this.resetAccount = (f) => {
+			ChainController.resetAccount(f);
+		}, this.setCaipNetwork = (f) => {
+			ChainController.setActiveCaipNetwork(f);
+		}, this.setCaipNetworkOfNamespace = (f, V) => {
+			ChainController.setChainNetworkData(V, { caipNetwork: f });
+		}, this.setStatus = (f, V) => {
+			ChainController.setAccountProp("status", f, V), ConnectorController.isConnected() ? StorageUtil.setConnectionStatus("connected") : StorageUtil.setConnectionStatus("disconnected");
+		}, this.getAddressByChainNamespace = (f) => ChainController.getAccountData(f)?.address, this.setConnectors = (f) => {
+			let V = [...ConnectorController.state.allConnectors, ...f];
+			ConnectorController.setConnectors(V);
+		}, this.setConnections = (f, V) => {
+			StorageUtil.setConnections(f, V), ConnectionController.setConnections(f, V);
+		}, this.fetchIdentity = (f) => BlockchainApiController.fetchIdentity(f), this.getReownName = (f) => EnsController.getNamesForAddress(f), this.getConnectors = () => ConnectorController.getConnectors(), this.getConnectorImage = (f) => AssetUtil.getConnectorImage(f), this.getConnections = (f) => this.remoteFeatures.multiWallet ? ConnectionControllerUtil.getConnectionsData(f).connections : (AlertController.open(ConstantsUtil.REMOTE_FEATURES_ALERTS.MULTI_WALLET_NOT_ENABLED.DEFAULT, "info"), []), this.getRecentConnections = (f) => this.remoteFeatures.multiWallet ? ConnectionControllerUtil.getConnectionsData(f).recentConnections : (AlertController.open(ConstantsUtil.REMOTE_FEATURES_ALERTS.MULTI_WALLET_NOT_ENABLED.DEFAULT, "info"), []), this.switchConnection = async (f) => {
+			if (!this.remoteFeatures.multiWallet) {
+				AlertController.open(ConstantsUtil.REMOTE_FEATURES_ALERTS.MULTI_WALLET_NOT_ENABLED.DEFAULT, "info");
+				return;
+			}
+			await ConnectionController.switchConnection(f);
+		}, this.deleteConnection = (f) => {
+			if (!this.remoteFeatures.multiWallet) {
+				AlertController.open(ConstantsUtil.REMOTE_FEATURES_ALERTS.MULTI_WALLET_NOT_ENABLED.DEFAULT, "info");
+				return;
+			}
+			StorageUtil.deleteAddressFromConnection(f), ConnectionController.syncStorageConnections();
+		}, this.setConnectedWalletInfo = (f, V) => {
+			let H = ProviderController.getProviderId(V), U = f ? {
+				...f,
+				type: H
+			} : void 0;
+			ChainController.setAccountProp("connectedWalletInfo", U, V);
+		}, this.getIsConnectedState = () => !!ChainController.state.activeCaipAddress, this.addAddressLabel = (f, V, H) => {
+			let U = ChainController.getAccountData(H)?.addressLabels || {};
+			ChainController.setAccountProp("addressLabels", {
+				...U,
+				[f]: V
+			}, H);
+		}, this.removeAddressLabel = (f, V) => {
+			let H = ChainController.getAccountData(V)?.addressLabels || {};
+			ChainController.setAccountProp("addressLabels", {
+				...H,
+				[f]: void 0
+			}, V);
+		}, this.getAddress = (f) => {
+			let V = f || ChainController.state.activeChain;
+			return ChainController.getAccountData(V)?.address;
+		}, this.resetNetwork = (f) => {
+			ChainController.resetNetwork(f);
+		}, this.addConnector = (f) => {
+			ConnectorController.addConnector(f);
+		}, this.resetWcConnection = () => {
+			ConnectionController.resetWcConnection();
+		}, this.setAddressExplorerUrl = (f, V) => {
+			ChainController.setAccountProp("addressExplorerUrl", f, V);
+		}, this.setSmartAccountDeployed = (f, V) => {
+			ChainController.setAccountProp("smartAccountDeployed", f, V);
+		}, this.setPreferredAccountType = (f, V) => {
+			ChainController.setAccountProp("preferredAccountType", f, V);
+		}, this.setEIP6963Enabled = (f) => {
+			OptionsController.setEIP6963Enabled(f);
+		}, this.handleUnsafeRPCRequest = () => {
+			if (this.isOpen()) {
+				if (this.isTransactionStackEmpty()) return;
+				this.redirect("ApproveTransaction");
+			} else this.open({ view: "ApproveTransaction" });
+		}, this.options = f, this.version = f.sdkVersion, this.caipNetworks = this.extendCaipNetworks(f), this.chainNamespaces = this.getChainNamespacesSet(f.adapters, this.caipNetworks), this.defaultCaipNetwork = this.extendDefaultCaipNetwork(f), this.chainAdapters = this.createAdapters(f.adapters), this.readyPromise = this.initialize(f);
+	}
+	getChainNamespacesSet(f, V) {
+		let H = f?.map((f) => f.namespace).filter((f) => !!f);
+		if (H?.length) return [...new Set(H)];
+		let U = V?.map((f) => f.chainNamespace);
+		return [...new Set(U)];
+	}
+	async initialize(f) {
+		if (this.initializeProjectSettings(f), this.initControllers(f), await this.initChainAdapters(), this.sendInitializeEvent(f), f.features?.headless && !ConnectorUtil.hasInjectedConnectors() && ApiController.prefetch({
+			fetchNetworkImages: !1,
+			fetchConnectorImages: !1,
+			fetchWalletRanks: !1,
+			fetchRecommendedWallets: !0
+		}), OptionsController.state.enableReconnect ? (await this.syncExistingConnection(), await this.syncAdapterConnections()) : await this.unSyncExistingConnection(), !f.basic && !f.manualWCControl && (this.remoteFeatures = await ConfigUtil.fetchRemoteFeatures(f)), await ApiController.fetchUsage(), OptionsController.setRemoteFeatures(this.remoteFeatures), this.remoteFeatures.onramp && OnRampController.setOnrampProviders(this.remoteFeatures.onramp), (OptionsController.state.remoteFeatures?.email || Array.isArray(OptionsController.state.remoteFeatures?.socials) && OptionsController.state.remoteFeatures?.socials.length > 0) && await this.checkAllowedOrigins(), OptionsController.state.features?.reownAuthentication || OptionsController.state.remoteFeatures?.reownAuthentication) {
+			let { ReownAuthentication: f } = await import("./features-_5Pi-gXV.js"), V = OptionsController.state.siwx;
+			V instanceof f || (V && console.warn("ReownAuthentication option is enabled, SIWX configuration will be overridden."), OptionsController.setSIWX(new f()));
+		}
+	}
+	async openSend(f) {
+		let V = f.namespace || ChainController.state.activeChain, H = this.getCaipAddress(V), U = this.getCaipNetwork(V)?.id;
+		if (!H) throw Error("openSend: caipAddress not found");
+		if (U?.toString() !== f.chainId.toString()) {
+			let H = ChainController.getCaipNetworkById(f.chainId, V);
+			if (!H) throw Error(`openSend: caipNetwork with chainId ${f.chainId} not found`);
+			await this.switchNetwork(H, { throwOnFailure: !0 });
+		}
+		try {
+			let V = TokenUtil.getTokenSymbolByAddress(f.assetAddress);
+			V && await ApiController.fetchTokenImages([V]);
+		} catch {}
+		return await ModalController.open({
+			view: "WalletSend",
+			data: { send: f }
+		}), new Promise((f, V) => {
+			let H = SendController.subscribeKey("hash", (V) => {
+				V && (W(), f({ hash: V }));
+			}), U = ModalController.subscribe((f) => {
+				f.open || (W(), V(/* @__PURE__ */ Error("Modal closed")));
+			}), W = this.createCleanupHandler([H, U]);
+		});
+	}
+	toModalOptions() {
+		function f(f) {
+			return f?.view === "Swap";
+		}
+		function V(f) {
+			return f?.view === "WalletSend";
+		}
+		return {
+			isSwap: f,
+			isSend: V
+		};
+	}
+	async checkAllowedOrigins() {
+		try {
+			let f = await ApiController.fetchAllowedOrigins();
+			if (!CoreHelperUtil.isClient()) return;
+			let V = window.location.origin;
+			WcHelpersUtil.isOriginAllowed(V, f, ConstantsUtil.DEFAULT_ALLOWED_ANCESTORS) || AlertController.open(ErrorUtil.ALERT_ERRORS.ORIGIN_NOT_ALLOWED, "error");
+		} catch (f) {
+			if (!(f instanceof Error)) return;
+			switch (f.message) {
+				case "RATE_LIMITED":
+					AlertController.open(ErrorUtil.ALERT_ERRORS.RATE_LIMITED_APP_CONFIGURATION, "error");
+					break;
+				case "SERVER_ERROR": {
+					let V = f.cause instanceof Error ? f.cause : f;
+					AlertController.open({
+						displayMessage: ErrorUtil.ALERT_ERRORS.SERVER_ERROR_APP_CONFIGURATION.displayMessage,
+						debugMessage: ErrorUtil.ALERT_ERRORS.SERVER_ERROR_APP_CONFIGURATION.debugMessage(V.message)
+					}, "error");
+					break;
+				}
+				default: break;
+			}
+		}
+	}
+	createCleanupHandler(f) {
+		return () => {
+			f.forEach((f) => {
+				try {
+					f();
+				} catch {}
+			});
+		};
+	}
+	sendInitializeEvent(f) {
+		let { ...V } = f;
+		delete V.adapters, delete V.universalProvider, EventsController.sendEvent({
+			type: "track",
+			event: "INITIALIZE",
+			properties: {
+				...V,
+				networks: f.networks.map((f) => f.id),
+				siweConfig: { options: f.siweConfig?.options || {} }
+			}
+		});
+	}
+	initControllers(f) {
+		this.initializeOptionsController(f), this.initializeChainController(f), this.initializeThemeController(f), this.initializeConnectionController(f), this.initializeConnectorController();
+	}
+	initAdapterController() {
+		AdapterController.initialize(this.chainAdapters);
+	}
+	initializeThemeController(f) {
+		f.themeMode && ThemeController.setThemeMode(f.themeMode), f.themeVariables && ThemeController.setThemeVariables(f.themeVariables);
+	}
+	initializeChainController(f) {
+		if (!this.connectionControllerClient) throw Error("ConnectionControllerClient must be set");
+		ChainController.initialize(f.adapters ?? [], this.caipNetworks, { connectionControllerClient: this.connectionControllerClient });
+		let V = this.getDefaultNetwork();
+		V && ChainController.setActiveCaipNetwork(V);
+	}
+	initializeConnectionController(f) {
+		ConnectionController.initialize(f.adapters ?? []), ConnectionController.setWcBasic(f.basic ?? !1);
+	}
+	initializeConnectorController() {
+		ConnectorController.initialize(this.chainNamespaces);
+	}
+	initializeProjectSettings(f) {
+		OptionsController.setProjectId(f.projectId), OptionsController.setSdkVersion(f.sdkVersion);
+	}
+	initializeOptionsController(f) {
+		OptionsController.setDebug(f.debug !== !1), OptionsController.setEnableWalletGuide(f.enableWalletGuide !== !1), OptionsController.setEnableWallets(f.enableWallets !== !1), OptionsController.setEIP6963Enabled(f.enableEIP6963 !== !1), OptionsController.setEnableNetworkSwitch(f.enableNetworkSwitch !== !1), OptionsController.setEnableReconnect(f.enableReconnect !== !1), OptionsController.setEnableMobileFullScreen(f.enableMobileFullScreen === !0), OptionsController.setCoinbasePreference(f.coinbasePreference), OptionsController.setEnableAuthLogger(f.enableAuthLogger !== !1), OptionsController.setCustomRpcUrls(f.customRpcUrls), OptionsController.setEnableEmbedded(f.enableEmbedded), OptionsController.setAllWallets(f.allWallets), OptionsController.setIncludeWalletIds(f.includeWalletIds), OptionsController.setExcludeWalletIds(f.excludeWalletIds), OptionsController.setFeaturedWalletIds(f.featuredWalletIds), OptionsController.setTokens(f.tokens), OptionsController.setTermsConditionsUrl(f.termsConditionsUrl), OptionsController.setPrivacyPolicyUrl(f.privacyPolicyUrl), OptionsController.setCustomWallets(f.customWallets), OptionsController.setFeatures(f.features), OptionsController.setAllowUnsupportedChain(f.allowUnsupportedChain), OptionsController.setUniversalProviderConfigOverride(f.universalProviderConfigOverride), OptionsController.setPreferUniversalLinks(f.experimental_preferUniversalLinks), OptionsController.setDefaultAccountTypes(f.defaultAccountTypes);
+		let V = this.getDefaultMetaData();
+		if (!f.metadata && V && (f.metadata = V), OptionsController.setMetadata(f.metadata), OptionsController.setDisableAppend(f.disableAppend), OptionsController.setEnableEmbedded(f.enableEmbedded), OptionsController.setSIWX(f.siwx), this.features = OptionsController.state.features ?? {}, !f.projectId) {
+			AlertController.open(ErrorUtil.ALERT_ERRORS.PROJECT_ID_NOT_CONFIGURED, "error");
+			return;
+		}
+		if (f.adapters?.find((f) => f.namespace === ConstantsUtil.CHAIN.EVM) && f.siweConfig) {
+			if (f.siwx) throw Error("Cannot set both `siweConfig` and `siwx` options");
+			OptionsController.setSIWX(f.siweConfig.mapToSIWX());
+		}
+	}
+	getDefaultMetaData() {
+		return CoreHelperUtil.isClient() ? {
+			name: document.getElementsByTagName("title")?.[0]?.textContent || "",
+			description: document.querySelector("meta[property=\"og:description\"]")?.content || "",
+			url: window.location.origin,
+			icons: [document.querySelector("link[rel~=\"icon\"]")?.href || ""]
+		} : null;
+	}
+	setUnsupportedNetwork(f) {
+		let V = this.getActiveChainNamespace();
+		if (V) {
+			let H = CaipNetworksUtil.getUnsupportedNetwork(`${V}:${f}`);
+			ChainController.setActiveCaipNetwork(H);
+		}
+	}
+	getDefaultNetwork() {
+		return CaipNetworksUtil.getCaipNetworkFromStorage(this.defaultCaipNetwork);
+	}
+	extendCaipNetwork(f, V) {
+		return CaipNetworksUtil.extendCaipNetwork(f, {
+			customNetworkImageUrls: V.chainImages,
+			projectId: V.projectId
+		});
+	}
+	extendCaipNetworks(f) {
+		return CaipNetworksUtil.extendCaipNetworks(f.networks, {
+			customNetworkImageUrls: f.chainImages,
+			customRpcUrls: f.customRpcUrls,
+			projectId: f.projectId
+		});
+	}
+	extendDefaultCaipNetwork(f) {
+		let V = f.networks.find((V) => V.id === f.defaultNetwork?.id);
+		return V ? CaipNetworksUtil.extendCaipNetwork(V, {
+			customNetworkImageUrls: f.chainImages,
+			customRpcUrls: f.customRpcUrls,
+			projectId: f.projectId
+		}) : void 0;
+	}
+	async disconnectConnector(f, V) {
+		try {
+			this.setLoading(!0, f);
+			let H = { connections: [] }, U = this.getAdapter(f);
+			return (ChainController.state.chains.get(f)?.accountState?.caipAddress || !OptionsController.state.enableReconnect) && U?.disconnect && (H = await U.disconnect({ id: V })), this.setLoading(!1, f), H;
+		} catch (V) {
+			throw this.setLoading(!1, f), Error(`Failed to disconnect chains: ${V.message}`);
+		}
+	}
+	createClients() {
+		this.connectionControllerClient = {
+			connectWalletConnect: async () => {
+				let f = ChainController.state.activeChain, V = this.getAdapter(f), H = this.getCaipNetwork(f)?.id, U = ConnectionController.getConnections(f), W = this.remoteFeatures.multiWallet, G = U.length > 0;
+				if (!V) throw Error("Adapter not found");
+				let K = await V.connectWalletConnect(H);
+				(!G || !W) && this.close(), this.setClientId(K?.clientId || null), StorageUtil.setConnectedNamespaces([...ChainController.state.chains.keys()]), await this.syncWalletConnectAccount(), await SIWXUtil.initializeIfEnabled();
+			},
+			connectExternal: async (f) => {
+				let V = await this.onConnectExternal(f);
+				return await this.connectInactiveNamespaces(f, V), V ? { address: V.address } : void 0;
+			},
+			reconnectExternal: async ({ id: f, info: V, type: H, provider: U }) => {
+				let W = ChainController.state.activeChain, G = this.getAdapter(W);
+				if (!W) throw Error("reconnectExternal: namespace not found");
+				if (!G) throw Error("reconnectExternal: adapter not found");
+				G?.reconnect && (await G?.reconnect({
+					id: f,
+					info: V,
+					type: H,
+					provider: U,
+					chainId: this.getCaipNetwork()?.id
+				}), StorageUtil.addConnectedNamespace(W), this.syncConnectedWalletInfo(W));
+			},
+			disconnectConnector: async (f) => {
+				await this.disconnectConnector(f.namespace, f.id);
+			},
+			disconnect: async (f) => {
+				let { id: V, chainNamespace: H, initialDisconnect: U } = f || {}, W = H || ChainController.state.activeChain, G = ConnectorController.getConnectorId(W), q = V === ConstantsUtil.CONNECTOR_ID.AUTH || G === ConstantsUtil.CONNECTOR_ID.AUTH, Y = V === ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT || G === ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT;
+				try {
+					let f = Array.from(ChainController.state.chains.keys()), W = H ? [H] : f;
+					(Y || q) && (W = f);
+					let G = W.map(async (f) => {
+						let H = ConnectorController.getConnectorId(f), W = V || H, G = await this.disconnectConnector(f, W);
+						G && (q && StorageUtil.deleteConnectedSocialProvider(), G.connections.forEach((V) => {
+							StorageUtil.addDisconnectedConnectorId(V.connectorId, f);
+						})), U && this.onDisconnectNamespace({
+							chainNamespace: f,
+							closeModal: !1
+						});
+					}), K = await Promise.allSettled(G);
+					SendController.resetSend(), ConnectionController.resetWcConnection(), SIWXUtil.getSIWX()?.signOutOnDisconnect && await SIWXUtil.clearSessions(), ConnectorController.setFilterByNamespace(void 0), ConnectionController.syncStorageConnections();
+					let X = K.filter((f) => f.status === "rejected");
+					if (X.length > 0) throw Error(X.map((f) => f.reason.message).join(", "));
+					EventsController.sendEvent({
+						type: "track",
+						event: "DISCONNECT_SUCCESS",
+						properties: { namespace: H || "all" }
+					});
+				} catch (f) {
+					throw Error(`Failed to disconnect chains: ${f.message}`);
+				}
+			},
+			checkInstalled: (f) => f ? f.some((f) => !!window.ethereum?.[String(f)]) : !!window.ethereum,
+			signMessage: async (f) => {
+				let V = ChainController.state.activeChain, H = this.getAdapter(ChainController.state.activeChain);
+				if (!V) throw Error("signMessage: namespace not found");
+				if (!H) throw Error("signMessage: adapter not found");
+				let U = this.getAddress(V);
+				if (!U) throw Error("signMessage: address not found");
+				return (await H?.signMessage({
+					message: f,
+					address: U,
+					provider: ProviderController.getProvider(V)
+				}))?.signature || "";
+			},
+			sendTransaction: async (f) => {
+				let V = f.chainNamespace;
+				if (!V) throw Error("sendTransaction: namespace not found");
+				if (ConstantsUtil$1.SEND_SUPPORTED_NAMESPACES.includes(V)) {
+					let H = this.getAdapter(V);
+					if (!H) throw Error("sendTransaction: adapter not found");
+					let U = ProviderController.getProvider(V);
+					return (await H?.sendTransaction({
+						...f,
+						caipNetwork: this.getCaipNetwork(),
+						provider: U
+					}))?.hash || "";
+				}
+				return "";
+			},
+			estimateGas: async (f) => {
+				let V = f.chainNamespace;
+				if (V === ConstantsUtil.CHAIN.EVM) {
+					let H = this.getAdapter(V);
+					if (!H) throw Error("estimateGas: adapter is required but got undefined");
+					let U = ProviderController.getProvider(V), W = this.getCaipNetwork();
+					if (!W) throw Error("estimateGas: caipNetwork is required but got undefined");
+					return (await H?.estimateGas({
+						...f,
+						provider: U,
+						caipNetwork: W
+					}))?.gas || 0n;
+				}
+				return 0n;
+			},
+			getEnsAvatar: async () => {
+				let f = ChainController.state.activeChain;
+				if (!f) throw Error("getEnsAvatar: namespace is required but got undefined");
+				let V = this.getAddress(f);
+				if (!V) throw Error("getEnsAvatar: address not found");
+				return await this.syncIdentity({
+					address: V,
+					chainId: Number(this.getCaipNetwork()?.id),
+					chainNamespace: f
+				}), ChainController.getAccountData()?.profileImage || !1;
+			},
+			getEnsAddress: async (f) => await WcHelpersUtil.resolveReownName(f),
+			writeContract: async (f) => {
+				let V = ChainController.state.activeChain, H = this.getAdapter(V);
+				if (!V) throw Error("writeContract: namespace is required but got undefined");
+				if (!H) throw Error("writeContract: adapter is required but got undefined");
+				let U = this.getCaipNetwork(), W = this.getCaipAddress(), G = ProviderController.getProvider(V);
+				if (!U || !W) throw Error("writeContract: caipNetwork or caipAddress is required but got undefined");
+				return (await H?.writeContract({
+					...f,
+					caipNetwork: U,
+					provider: G,
+					caipAddress: W
+				}))?.hash;
+			},
+			writeSolanaTransaction: async (f) => {
+				let V = ChainController.state.activeChain, H = this.getAdapter(V);
+				if (!V) throw Error("writeContract: namespace is required but got undefined");
+				if (!H) throw Error("writeContract: adapter is required but got undefined");
+				let U = this.getCaipNetwork(), W = this.getCaipAddress(), G = ProviderController.getProvider(V);
+				if (!U || !W) throw Error("writeContract: caipNetwork or caipAddress is required but got undefined");
+				return (await H?.writeSolanaTransaction({
+					...f,
+					caipNetwork: U,
+					provider: G,
+					caipAddress: W
+				}))?.hash;
+			},
+			parseUnits: (f, V) => {
+				let H = this.getAdapter(ChainController.state.activeChain);
+				if (!H) throw Error("parseUnits: adapter is required but got undefined");
+				return H?.parseUnits({
+					value: f,
+					decimals: V
+				}) ?? 0n;
+			},
+			formatUnits: (f, V) => {
+				let H = this.getAdapter(ChainController.state.activeChain);
+				if (!H) throw Error("formatUnits: adapter is required but got undefined");
+				return H?.formatUnits({
+					value: f,
+					decimals: V
+				}) ?? "0";
+			},
+			getCapabilities: async (f) => {
+				let V = this.getAdapter(ChainController.state.activeChain);
+				if (!V) throw Error("getCapabilities: adapter is required but got undefined");
+				return await V?.getCapabilities(f);
+			},
+			grantPermissions: async (f) => {
+				let V = this.getAdapter(ChainController.state.activeChain);
+				if (!V) throw Error("grantPermissions: adapter is required but got undefined");
+				return await V?.grantPermissions(f);
+			},
+			revokePermissions: async (f) => {
+				let V = this.getAdapter(ChainController.state.activeChain);
+				if (!V) throw Error("revokePermissions: adapter is required but got undefined");
+				return V?.revokePermissions ? await V.revokePermissions(f) : "0x";
+			},
+			walletGetAssets: async (f) => {
+				let V = this.getAdapter(ChainController.state.activeChain);
+				if (!V) throw Error("walletGetAssets: adapter is required but got undefined");
+				return await V?.walletGetAssets(f) ?? {};
+			},
+			updateBalance: (f) => {
+				let V = this.getAddress(f), H = this.getCaipNetwork(f);
+				!H || !V || this.updateNativeBalance(V, H?.id, f);
+			}
+		}, ConnectionController.setClient(this.connectionControllerClient);
+	}
+	async onConnectExternal(f) {
+		let V = ChainController.state.activeChain, H = f.chain || V, U = this.getAdapter(H), W = !0;
+		if (f.type === ConstantsUtil$2.CONNECTOR_TYPE_AUTH && ConstantsUtil.AUTH_CONNECTOR_SUPPORTED_CHAINS.some((f) => ConnectorController.getConnectorId(f) === ConstantsUtil.CONNECTOR_ID.AUTH) && f.chain !== V && (W = !1), f.chain && f.chain !== V && !f.caipNetwork) {
+			let V = this.getCaipNetworks().find((V) => V.chainNamespace === f.chain);
+			V && W && this.setCaipNetwork(V);
+		}
+		if (!H) throw Error("connectExternal: namespace not found");
+		if (!U) throw Error("connectExternal: adapter not found");
+		let G = this.getCaipNetwork(H), q = f.caipNetwork || G, Y = await U.connect({
+			id: f.id,
+			address: f.address,
+			info: f.info,
+			type: f.type,
+			provider: f.provider,
+			socialUri: f.socialUri,
+			chainId: f.caipNetwork?.id || G?.id,
+			rpcUrl: f.caipNetwork?.rpcUrls?.default?.http?.[0] || G?.rpcUrls?.default?.http?.[0]
+		});
+		if (Y) return StorageUtil.addConnectedNamespace(H), this.syncProvider({
+			...Y,
+			chainNamespace: H
+		}), this.setStatus("connected", H), this.syncConnectedWalletInfo(H), StorageUtil.removeDisconnectedConnectorId(f.id, H), {
+			address: Y.address,
+			connectedCaipNetwork: q
+		};
+	}
+	async connectInactiveNamespaces(f, V) {
+		let H = f.type === ConstantsUtil$2.CONNECTOR_TYPE_AUTH, U = HelpersUtil.getOtherAuthNamespaces(V?.connectedCaipNetwork?.chainNamespace), W = ChainController.state.activeCaipNetwork, G = this.getAdapter(W?.chainNamespace);
+		H && (await Promise.all(U.map(async (V) => {
+			try {
+				let H = ProviderController.getProvider(V), U = this.getCaipNetwork(V);
+				await this.getAdapter(V)?.connect({
+					...f,
+					provider: H,
+					socialUri: void 0,
+					chainId: U?.id,
+					rpcUrl: U?.rpcUrls?.default?.http?.[0]
+				}) && (StorageUtil.addConnectedNamespace(V), StorageUtil.removeDisconnectedConnectorId(f.id, V), this.setStatus("connected", V), this.syncConnectedWalletInfo(V));
+			} catch (f) {
+				AlertController.warn(ErrorUtil.ALERT_WARNINGS.INACTIVE_NAMESPACE_NOT_CONNECTED.displayMessage, ErrorUtil.ALERT_WARNINGS.INACTIVE_NAMESPACE_NOT_CONNECTED.debugMessage(V, f instanceof Error ? f.message : void 0), ErrorUtil.ALERT_WARNINGS.INACTIVE_NAMESPACE_NOT_CONNECTED.code);
+			}
+		})), W && await G?.switchNetwork({ caipNetwork: W }));
+	}
+	getApprovedCaipNetworksData() {
+		if (ProviderController.getProviderId(ChainController.state.activeChain) === ConstantsUtil$2.CONNECTOR_TYPE_WALLET_CONNECT) {
+			let f = this.universalProvider?.session?.namespaces;
+			return {
+				supportsAllNetworks: this.universalProvider?.session?.peer?.metadata.name === "MetaMask Wallet",
+				approvedCaipNetworkIds: this.getChainsFromNamespaces(f)
+			};
+		}
+		return {
+			supportsAllNetworks: !0,
+			approvedCaipNetworkIds: []
+		};
+	}
+	async switchCaipNetwork(f) {
+		let V = f.chainNamespace;
+		if (this.getAddressByChainNamespace(f.chainNamespace)) {
+			let H = ProviderController.getProviderId(V);
+			if (f.chainNamespace === ChainController.state.activeChain) await this.getAdapter(V)?.switchNetwork({ caipNetwork: f });
+			else if (this.setCaipNetwork(f), H === ConstantsUtil$2.CONNECTOR_TYPE_WALLET_CONNECT) this.syncWalletConnectAccount();
+			else {
+				let H = this.getAddressByChainNamespace(V);
+				H && this.syncAccount({
+					address: H,
+					chainId: f.id,
+					chainNamespace: V
+				});
+			}
+		} else this.setCaipNetwork(f);
+	}
+	getChainsFromNamespaces(f = {}) {
+		return Object.values(f).flatMap((f) => {
+			let V = f.chains || [], H = f.accounts.map((f) => {
+				let { chainId: V, chainNamespace: H } = ParseUtil.parseCaipAddress(f);
+				return `${H}:${V}`;
+			});
+			return Array.from(new Set([...V, ...H]));
+		});
+	}
+	createAdapters(f) {
+		return this.createClients(), this.chainNamespaces.reduce((V, H) => {
+			let U = f?.find((f) => f.namespace === H);
+			return U ? (U.construct({
+				namespace: H,
+				projectId: this.options?.projectId,
+				networks: this.caipNetworks?.filter(({ chainNamespace: f }) => f === H)
+			}), V[H] = U) : V[H] = new UniversalAdapter({
+				namespace: H,
+				networks: this.getCaipNetworks()
+			}), V;
+		}, {});
+	}
+	async initChainAdapter(f) {
+		this.onConnectors(f), this.listenAdapter(f);
+		let V = this.getAdapter(f);
+		if (!V) throw Error("adapter not found");
+		await V.syncConnectors(), await this.createUniversalProviderForAdapter(f);
+	}
+	async initChainAdapters() {
+		await Promise.all(this.chainNamespaces.map(async (f) => {
+			await this.initChainAdapter(f);
+		})), this.initAdapterController();
+	}
+	onConnectors(f) {
+		this.getAdapter(f)?.on("connectors", this.setConnectors.bind(this));
+	}
+	listenAdapter(f) {
+		let V = this.getAdapter(f);
+		if (!V) return;
+		let H = StorageUtil.getConnectionStatus();
+		OptionsController.state.enableReconnect === !1 ? this.setStatus("disconnected", f) : H === "connected" ? this.setStatus("connecting", f) : (H === "disconnected" && StorageUtil.clearAddressCache(), this.setStatus(H, f)), V.on("switchNetwork", ({ address: V, chainId: H }) => {
+			let U = this.getCaipNetworks().find((f) => f.id.toString() === H.toString() || f.caipNetworkId.toString() === H.toString()), W = ChainController.state.activeChain === f, G = ChainController.state.chains.get(f)?.accountState?.address;
+			if (U) {
+				let H = W && V ? V : G;
+				H && this.syncAccount({
+					address: H,
+					chainId: U.id,
+					chainNamespace: f
+				});
+			} else this.setUnsupportedNetwork(H);
+		}), V.on("disconnect", () => {
+			let V = this.remoteFeatures.multiWallet, H = Array.from(ConnectionController.state.connections.values()).flat();
+			this.onDisconnectNamespace({
+				chainNamespace: f,
+				closeModal: !V || H.length === 0
+			});
+		}), V.on("connections", (V) => {
+			this.setConnections(V, f);
+		}), V.on("pendingTransactions", () => {
+			let V = this.getAddress(f), H = ChainController.state.activeCaipNetwork;
+			!V || !H?.id || this.updateNativeBalance(V, H.id, H.chainNamespace);
+		}), V.on("accountChanged", ({ address: V, chainId: H, connector: U }) => {
+			this.handlePreviousConnectorConnection(U);
+			let W = ChainController.state.activeChain === f;
+			U?.provider && (this.syncProvider({
+				id: U.id,
+				type: U.type,
+				provider: U?.provider,
+				chainNamespace: f
+			}), this.syncConnectedWalletInfo(f));
+			let G = ChainController.getNetworkData(f)?.caipNetwork?.id, K = H || G;
+			W && K ? this.syncAccount({
+				address: V,
+				chainId: K,
+				chainNamespace: f
+			}) : !W && K ? (this.syncAccountInfo(V, K, f), this.syncBalance({
+				address: V,
+				chainId: K,
+				chainNamespace: f
+			})) : this.syncAccountInfo(V, H, f), StorageUtil.addConnectedNamespace(f);
+		});
+	}
+	async handlePreviousConnectorConnection(f) {
+		let V = f?.chain, H = f?.id, U = ConnectorController.getConnectorId(V), W = OptionsController.state.remoteFeatures?.multiWallet, G = V && H && U && U !== H && !W;
+		try {
+			G && await ConnectionController.disconnect({
+				id: U,
+				namespace: V
+			});
+		} catch (f) {
+			console.warn("Error disconnecting previous connector", f);
+		}
+	}
+	async createUniversalProviderForAdapter(f) {
+		await this.getUniversalProvider(), this.universalProvider && await this.chainAdapters?.[f]?.setUniversalProvider?.(this.universalProvider);
+	}
+	async syncExistingConnection() {
+		await Promise.allSettled(this.chainNamespaces.map((f) => this.syncNamespaceConnection(f)));
+	}
+	async unSyncExistingConnection() {
+		try {
+			await Promise.allSettled(this.chainNamespaces.map((f) => ConnectionController.disconnect({
+				namespace: f,
+				initialDisconnect: !0
+			})));
+		} catch (f) {
+			console.error("Error disconnecting existing connections:", f);
+		}
+	}
+	async reconnectWalletConnect() {
+		await this.syncWalletConnectAccount();
+		let f = this.getAddress();
+		this.getCaipAddress() || StorageUtil.deleteRecentWallet();
+		let V = StorageUtil.getRecentWallet();
+		EventsController.sendEvent({
+			type: "track",
+			event: "CONNECT_SUCCESS",
+			address: f,
+			properties: {
+				method: CoreHelperUtil.isMobile() ? "mobile" : "qrcode",
+				name: V?.name || "Unknown",
+				reconnect: !0,
+				view: RouterController.state.view,
+				walletRank: V?.order
+			}
+		});
+	}
+	async syncNamespaceConnection(f) {
+		try {
+			f === ConstantsUtil.CHAIN.EVM && CoreHelperUtil.isSafeApp() && ConnectorController.setConnectorId(ConstantsUtil.CONNECTOR_ID.SAFE, f);
+			let V = ConnectorController.getConnectorId(f);
+			switch (this.setStatus("connecting", f), V) {
+				case ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT:
+					await this.reconnectWalletConnect();
+					break;
+				case ConstantsUtil.CONNECTOR_ID.AUTH: break;
+				default: await this.syncAdapterConnection(f);
+			}
+		} catch (V) {
+			console.warn("AppKit couldn't sync existing connection", V), this.setStatus("disconnected", f);
+		}
+	}
+	onDisconnectNamespace(f) {
+		let { chainNamespace: V, closeModal: H } = f || {};
+		ChainController.resetAccount(V), ChainController.resetNetwork(V), StorageUtil.removeConnectedNamespace(V);
+		let U = Array.from(ChainController.state.chains.keys());
+		(V ? [V] : U).forEach((f) => StorageUtil.addDisconnectedConnectorId(ConnectorController.getConnectorId(f) || "", f)), ConnectorController.removeConnectorId(V), ProviderController.resetChain(V), this.setUser(null, V), this.setStatus("disconnected", V), this.setConnectedWalletInfo(null, V), H !== !1 && ModalController.close();
+	}
+	async syncAdapterConnections() {
+		await Promise.allSettled(this.chainNamespaces.map((f) => {
+			let V = this.getAdapter(f), H = this.getCaipAddress(f), U = this.getCaipNetwork(f);
+			return V?.syncConnections({
+				connectToFirstConnector: !H,
+				caipNetwork: U
+			});
+		}));
+	}
+	async syncAdapterConnection(f) {
+		let V = this.getAdapter(f), H = this.getCaipNetwork(f), U = ConnectorController.getConnectorId(f), W = ConnectorController.getConnectors(f).find((f) => f.id === U);
+		try {
+			if (!V || !W) throw Error(`Adapter or connector not found for namespace ${f}`);
+			if (!H?.id) throw Error("CaipNetwork not found");
+			let U = await V?.syncConnection({
+				namespace: f,
+				id: W.id,
+				chainId: H.id,
+				rpcUrl: H?.rpcUrls?.default?.http?.[0]
+			});
+			U ? (this.syncProvider({
+				...U,
+				chainNamespace: f
+			}), await this.syncAccount({
+				...U,
+				chainNamespace: f
+			}), this.setStatus("connected", f), EventsController.sendEvent({
+				type: "track",
+				event: "CONNECT_SUCCESS",
+				address: U.address,
+				properties: {
+					method: "browser",
+					name: W.info?.name || W.name || "Unknown",
+					reconnect: !0,
+					view: RouterController.state.view,
+					walletRank: W?.explorerWallet?.order
+				}
+			})) : this.setStatus("disconnected", f);
+		} catch {
+			this.onDisconnectNamespace({
+				chainNamespace: f,
+				closeModal: !1
+			});
+		}
+	}
+	async syncWalletConnectAccount() {
+		let f = Object.keys(this.universalProvider?.session?.namespaces || {}), V = this.chainNamespaces.map(async (V) => {
+			let H = this.getAdapter(V);
+			if (!H) return;
+			let U = this.universalProvider?.session?.namespaces?.[V]?.accounts || [], W = ChainController.state.activeCaipNetwork?.id, G = U.find((f) => {
+				let { chainId: V } = ParseUtil.parseCaipAddress(f);
+				return V === W?.toString();
+			}) || U[0];
+			if (G) {
+				let f = ParseUtil.validateCaipAddress(G), { chainId: U, address: W } = ParseUtil.parseCaipAddress(f);
+				if (ProviderController.setProviderId(V, ConstantsUtil$2.CONNECTOR_TYPE_WALLET_CONNECT), this.caipNetworks && ChainController.state.activeCaipNetwork && H.namespace !== ConstantsUtil.CHAIN.EVM) {
+					let f = H.getWalletConnectProvider({
+						caipNetworks: this.getCaipNetworks(),
+						provider: this.universalProvider,
+						activeCaipNetwork: ChainController.state.activeCaipNetwork
+					});
+					ProviderController.setProvider(V, f);
+				} else ProviderController.setProvider(V, this.universalProvider);
+				ConnectorController.setConnectorId(ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT, V), StorageUtil.addConnectedNamespace(V), await this.syncAccount({
+					address: W,
+					chainId: U,
+					chainNamespace: V
+				});
+			} else f.includes(V) && this.setStatus("disconnected", V);
+			let q = this.getApprovedCaipNetworksData();
+			this.syncConnectedWalletInfo(V), ChainController.setApprovedCaipNetworksData(V, {
+				approvedCaipNetworkIds: q.approvedCaipNetworkIds,
+				supportsAllNetworks: q.supportsAllNetworks
+			});
+		});
+		await Promise.all(V);
+	}
+	syncProvider({ type: f, provider: V, id: H, chainNamespace: U }) {
+		ProviderController.setProviderId(U, f), ProviderController.setProvider(U, V), ConnectorController.setConnectorId(H, U);
+	}
+	async syncAccount(f) {
+		let V = f.chainNamespace === ChainController.state.activeChain, H = ChainController.getCaipNetworkByNamespace(f.chainNamespace, f.chainId), { address: U, chainId: W, chainNamespace: G } = f, { chainId: q } = StorageUtil.getActiveNetworkProps(), Y = H?.id || q, X = ChainController.state.activeCaipNetwork?.name === ConstantsUtil.UNSUPPORTED_NETWORK_NAME, Z = ChainController.getNetworkProp("supportsAllNetworks", G);
+		if (this.setStatus("connected", G), !(X && !Z) && Y) {
+			let f = this.getCaipNetworks().find((f) => f.id.toString() === Y.toString()), q = this.getCaipNetworks().find((f) => f.chainNamespace === G);
+			if (!Z && !f && !q) {
+				let V = this.getApprovedCaipNetworkIds() || [], H = V.find((f) => ParseUtil.parseCaipNetworkId(f)?.chainId === Y.toString()), U = V.find((f) => ParseUtil.parseCaipNetworkId(f)?.chainNamespace === G);
+				f = this.getCaipNetworks().find((f) => f.caipNetworkId === H), q = this.getCaipNetworks().find((f) => f.caipNetworkId === U || "deprecatedCaipNetworkId" in f && f.deprecatedCaipNetworkId === U);
+			}
+			let J = f || q;
+			J?.chainNamespace === ChainController.state.activeChain ? OptionsController.state.enableNetworkSwitch && !OptionsController.state.allowUnsupportedChain && ChainController.state.activeCaipNetwork?.name === ConstantsUtil.UNSUPPORTED_NETWORK_NAME ? ChainController.showUnsupportedChainUI() : this.setCaipNetwork(J) : V || H && this.setCaipNetworkOfNamespace(H, G), this.syncConnectedWalletInfo(G);
+			let X = this.getAddress(G);
+			HelpersUtil.isLowerCaseMatch(U, X) || this.syncAccountInfo(U, J?.id, G), V ? await this.syncBalance({
+				address: U,
+				chainId: J?.id,
+				chainNamespace: G
+			}) : await this.syncBalance({
+				address: U,
+				chainId: H?.id,
+				chainNamespace: G
+			}), this.syncIdentity({
+				address: U,
+				chainId: W,
+				chainNamespace: G
+			});
+		}
+	}
+	async syncAccountInfo(f, V, H) {
+		let U = this.getCaipAddress(H), W = V || U?.split(":")[1];
+		if (!W) return;
+		let G = `${H}:${W}:${f}`;
+		this.setCaipAddress(G, H, !0), await this.syncIdentity({
+			address: f,
+			chainId: W,
+			chainNamespace: H
+		});
+	}
+	async syncReownName(f, V) {
+		try {
+			let H = await this.getReownName(f);
+			if (H[0]) {
+				let f = H[0];
+				this.setProfileName(f.name, V);
+			} else this.setProfileName(null, V);
+		} catch {
+			this.setProfileName(null, V);
+		}
+	}
+	syncConnectedWalletInfo(f) {
+		let V = ConnectorController.getConnectorId(f), H = ProviderController.getProviderId(f);
+		if (H === ConstantsUtil$2.CONNECTOR_TYPE_ANNOUNCED || H === ConstantsUtil$2.CONNECTOR_TYPE_INJECTED) {
+			if (V) {
+				let H = this.getConnectors().find((f) => {
+					let H = f.id === V, U = f.info?.rdns === V, W = f.connectors?.some((f) => f.id === V || f.info?.rdns === V);
+					return H || U || !!W;
+				});
+				if (H) {
+					let { info: V, name: U, imageUrl: W } = H, G = W || this.getConnectorImage(H);
+					this.setConnectedWalletInfo({
+						name: U,
+						icon: G,
+						...V
+					}, f);
+				}
+			}
+		} else if (H === ConstantsUtil$2.CONNECTOR_TYPE_WALLET_CONNECT) {
+			let V = ProviderController.getProvider(f);
+			V?.session && this.setConnectedWalletInfo({
+				...V.session.peer.metadata,
+				name: V.session.peer.metadata.name,
+				icon: V.session.peer.metadata.icons?.[0]
+			}, f);
+		} else if (V && (V === ConstantsUtil.CONNECTOR_ID.COINBASE_SDK || V === ConstantsUtil.CONNECTOR_ID.COINBASE)) {
+			let H = this.getConnectors().find((f) => f.id === V), U = H?.name || "Coinbase Wallet", W = H?.imageUrl || this.getConnectorImage(H), G = H?.info;
+			this.setConnectedWalletInfo({
+				...G,
+				name: U,
+				icon: W
+			}, f);
+		}
+	}
+	async syncBalance(f) {
+		!NetworkUtil.getNetworksByNamespace(this.getCaipNetworks(), f.chainNamespace).find((V) => V.id.toString() === f.chainId?.toString()) || !f.chainId || await this.updateNativeBalance(f.address, f.chainId, f.chainNamespace);
+	}
+	async ready() {
+		await this.readyPromise;
+	}
+	async updateNativeBalance(f, V, H) {
+		let U = this.getAdapter(H), W = ChainController.getCaipNetworkByNamespace(H, V);
+		if (U) {
+			let G = await U.getBalance({
+				address: f,
+				chainId: V,
+				caipNetwork: W,
+				tokens: this.options.tokens
+			});
+			return this.setBalance(G.balance, G.symbol, H), G;
+		}
+	}
+	async initializeUniversalAdapter() {
+		let f = LoggerUtil.createLogger((f, ...V) => {
+			f && this.handleAlertError(f), console.error(...V);
+		}), V = {
+			projectId: this.options?.projectId,
+			metadata: {
+				name: this.options?.metadata ? this.options?.metadata.name : "",
+				description: this.options?.metadata ? this.options?.metadata.description : "",
+				url: this.options?.metadata ? this.options?.metadata.url : "",
+				icons: this.options?.metadata ? this.options?.metadata.icons : [""]
+			},
+			logger: f
+		};
+		OptionsController.setManualWCControl(!!this.options?.manualWCControl), this.universalProvider = this.options.universalProvider ?? await N.init(V);
+		let H = this.universalProvider.disconnect.bind(this.universalProvider);
+		this.universalProvider.disconnect = async () => {
+			try {
+				return await H();
+			} catch (f) {
+				if (f instanceof Error && f.message.includes("Missing or invalid. Record was recently deleted")) return;
+				throw f;
+			}
+		}, OptionsController.state.enableReconnect === !1 && this.universalProvider.session && await this.universalProvider.disconnect(), this.listenWalletConnect();
+	}
+	listenWalletConnect() {
+		this.universalProvider && this.chainNamespaces.forEach((f) => {
+			WcHelpersUtil.listenWcProvider({
+				universalProvider: this.universalProvider,
+				namespace: f,
+				onDisplayUri: (f) => {
+					ConnectionController.setUri(f);
+				},
+				onConnect: (f) => {
+					let { address: V } = CoreHelperUtil.getAccount(f[0]);
+					for (let f of this.chainNamespaces) StorageUtil.removeDisconnectedConnectorId(ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT, f);
+					ConnectionController.finalizeWcConnection(V);
+				},
+				onDisconnect: () => {
+					ChainController.state.noAdapters && this.resetAccount(f), ConnectionController.resetWcConnection();
+				},
+				onChainChanged: (V) => {
+					let H = ChainController.state.activeChain, U = H && ConnectorController.state.activeConnectorIds[H] === ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT;
+					if (H === f && (ChainController.state.noAdapters || U)) {
+						let f = this.getCaipNetworks().find((f) => f.id.toString() === V.toString() || f.caipNetworkId.toString() === V.toString()), H = this.getCaipNetwork();
+						if (!f) {
+							this.setUnsupportedNetwork(V);
+							return;
+						}
+						H?.id.toString() !== f?.id.toString() && H?.chainNamespace === f?.chainNamespace && this.setCaipNetwork(f);
+					}
+				},
+				onAccountsChanged: (V) => {
+					let H = ChainController.state.activeChain, U = H && ConnectorController.state.activeConnectorIds[H] === ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT;
+					if (H === f && (ChainController.state.noAdapters || U)) {
+						let f = V?.[0];
+						f && this.syncAccount({
+							address: f.address,
+							chainId: f.chainId,
+							chainNamespace: f.chainNamespace
+						});
+					}
+				}
+			});
+		});
+	}
+	createUniversalProvider() {
+		return !this.universalProviderInitPromise && CoreHelperUtil.isClient() && this.options?.projectId && (this.universalProviderInitPromise = this.initializeUniversalAdapter()), this.universalProviderInitPromise;
+	}
+	async getUniversalProvider() {
+		if (!this.universalProvider) try {
+			await this.createUniversalProvider();
+		} catch (f) {
+			EventsController.sendEvent({
+				type: "error",
+				event: "INTERNAL_SDK_ERROR",
+				properties: {
+					errorType: "UniversalProviderInitError",
+					errorMessage: f instanceof Error ? f.message : "Unknown",
+					uncaught: !1
+				}
+			}), console.error("AppKit:getUniversalProvider - Cannot create provider", f);
+		}
+		return this.universalProvider;
+	}
+	getDisabledCaipNetworks() {
+		let f = ChainController.getAllApprovedCaipNetworkIds(), V = ChainController.getAllRequestedCaipNetworks();
+		return CoreHelperUtil.sortRequestedNetworks(f, V).filter((f) => ChainController.isCaipNetworkDisabled(f));
+	}
+	handleAlertError(f) {
+		let [V, H] = Object.entries(ErrorUtil.UniversalProviderErrors).find(([, { message: V }]) => f.message.includes(V)) ?? [], { message: U, alertErrorKey: W } = H ?? {};
+		if (V && U && !this.reportedAlertErrors[V]) {
+			let f = ErrorUtil.ALERT_ERRORS[W];
+			f && (AlertController.open(f, "error"), this.reportedAlertErrors[V] = !0);
+		}
+	}
+	getAdapter(f) {
+		if (f) return this.chainAdapters?.[f];
+	}
+	createAdapter(f) {
+		if (!f) return;
+		let V = f.namespace;
+		if (!V) return;
+		this.createClients();
+		let H = f;
+		H.namespace = V, H.construct({
+			namespace: V,
+			projectId: this.options?.projectId,
+			networks: this.caipNetworks?.filter(({ chainNamespace: f }) => f === V)
+		}), this.chainNamespaces.includes(V) || this.chainNamespaces.push(V), this.chainAdapters && (this.chainAdapters[V] = H);
+	}
+	async open(f) {
+		await this.injectModalUi(), f?.uri && ConnectionController.setUri(f.uri);
+		let { isSwap: V, isSend: H } = this.toModalOptions();
+		return V(f) ? ModalController.open({
+			...f,
+			data: { swap: f.arguments }
+		}) : H(f) && f.arguments ? this.openSend(f.arguments) : ModalController.open(f);
+	}
+	async close() {
+		await this.injectModalUi(), ModalController.close();
+	}
+	setLoading(f, V) {
+		ModalController.setLoading(f, V);
+	}
+	async disconnect(f) {
+		await ConnectionController.disconnect({ namespace: f });
+	}
+	getSIWX() {
+		return OptionsController.state.siwx;
+	}
+	getError() {
+		return "";
+	}
+	getChainId() {
+		return ChainController.state.activeCaipNetwork?.id;
+	}
+	async switchNetwork(f, { throwOnFailure: V = !1 } = {}) {
+		let H = this.getCaipNetworks().find((V) => V.id === f.id);
+		if (!H) {
+			AlertController.open(ErrorUtil.ALERT_ERRORS.SWITCH_NETWORK_NOT_FOUND, "error");
+			return;
+		}
+		await ChainController.switchActiveNetwork(H, { throwOnFailure: V });
+	}
+	getWalletProvider() {
+		return ChainController.state.activeChain ? ProviderController.state.providers[ChainController.state.activeChain] : null;
+	}
+	getWalletProviderType() {
+		return ProviderController.getProviderId(ChainController.state.activeChain);
+	}
+	subscribeProviders(f) {
+		return ProviderController.subscribeProviders(f);
+	}
+	getThemeMode() {
+		return ThemeController.state.themeMode;
+	}
+	getThemeVariables() {
+		return ThemeController.state.themeVariables;
+	}
+	setThemeMode(f) {
+		ThemeController.setThemeMode(f), setColorTheme(ThemeController.state.themeMode);
+	}
+	setTermsConditionsUrl(f) {
+		OptionsController.setTermsConditionsUrl(f);
+	}
+	setPrivacyPolicyUrl(f) {
+		OptionsController.setPrivacyPolicyUrl(f);
+	}
+	setThemeVariables(f) {
+		ThemeController.setThemeVariables(f), setThemeVariables(ThemeController.state.themeVariables);
+	}
+	subscribeTheme(f) {
+		return ThemeController.subscribe(f);
+	}
+	subscribeConnections(f) {
+		return this.remoteFeatures.multiWallet ? ConnectionController.subscribe(f) : (AlertController.open(ConstantsUtil.REMOTE_FEATURES_ALERTS.MULTI_WALLET_NOT_ENABLED.DEFAULT, "info"), () => void 0);
+	}
+	getWalletInfo(f) {
+		return f ? ChainController.state.chains.get(f)?.accountState?.connectedWalletInfo : ChainController.getAccountData()?.connectedWalletInfo;
+	}
+	getAccount(f) {
+		let V = f || ChainController.state.activeChain, H = ConnectorController.getAuthConnector(V), U = ChainController.getAccountData(V), W = StorageUtil.getConnectedConnectorId(ChainController.state.activeChain), G = ConnectionController.getConnections(V);
+		if (!V) throw Error("AppKit:getAccount - namespace is required");
+		let q = G.flatMap((f) => f.accounts.map(({ address: f, type: H, publicKey: U }) => CoreHelperUtil.createAccount(V, f, H || "eoa", U)));
+		if (U) return {
+			allAccounts: q,
+			caipAddress: U.caipAddress,
+			address: CoreHelperUtil.getPlainAddress(U.caipAddress),
+			isConnected: !!U.caipAddress,
+			status: U.status,
+			embeddedWalletInfo: H && W === ConstantsUtil.CONNECTOR_ID.AUTH ? {
+				user: U.user ? {
+					...U.user,
+					username: StorageUtil.getConnectedSocialUsername()
+				} : void 0,
+				authProvider: U.socialProvider || "email",
+				accountType: getPreferredAccountType(V),
+				isSmartAccountDeployed: !!U.smartAccountDeployed
+			} : void 0
+		};
+	}
+	subscribeAccount(f, V) {
+		let H = [], U = () => {
+			let H = this.getAccount(V);
+			H && f(H);
+		};
+		if (V) {
+			let f = ChainController.subscribeChainProp("accountState", U, V);
+			H.push(f);
+		} else {
+			let f = ChainController.subscribe(U);
+			H.push(f);
+		}
+		let W = ConnectorController.subscribe(U);
+		return H.push(W), () => {
+			H.forEach((f) => f());
+		};
+	}
+	subscribeNetwork(f) {
+		return ChainController.subscribe(({ activeCaipNetwork: V }) => {
+			f({
+				caipNetwork: V,
+				chainId: V?.id,
+				caipNetworkId: V?.caipNetworkId
+			});
+		});
+	}
+	subscribeWalletInfo(f, V) {
+		return V ? ChainController.subscribeChainProp("accountState", (V) => f(V?.connectedWalletInfo), V) : ChainController.subscribeChainProp("accountState", (V) => f(V?.connectedWalletInfo));
+	}
+	subscribeShouldUpdateToAddress(f) {
+		return ChainController.subscribeChainProp("accountState", (V) => f(V?.shouldUpdateToAddress));
+	}
+	subscribeCaipNetworkChange(f) {
+		return ChainController.subscribeKey("activeCaipNetwork", f);
+	}
+	getState() {
+		return PublicStateController.state;
+	}
+	getRemoteFeatures() {
+		return OptionsController.state.remoteFeatures;
+	}
+	subscribeState(f) {
+		return PublicStateController.subscribe(f);
+	}
+	subscribeRemoteFeatures(f) {
+		return OptionsController.subscribeKey("remoteFeatures", f);
+	}
+	showErrorMessage(f) {
+		SnackController.showError(f);
+	}
+	showSuccessMessage(f) {
+		SnackController.showSuccess(f);
+	}
+	getEvent() {
+		return { ...EventsController.state };
+	}
+	subscribeEvents(f) {
+		return EventsController.subscribe(f);
+	}
+	replace(f) {
+		RouterController.replace(f);
+	}
+	redirect(f) {
+		RouterController.push(f);
+	}
+	popTransactionStack(f) {
+		RouterController.popTransactionStack(f);
+	}
+	isOpen() {
+		return ModalController.state.open;
+	}
+	isTransactionStackEmpty() {
+		return RouterController.state.transactionStack.length === 0;
+	}
+	static getInstance() {
+		return this.instance;
+	}
+	updateFeatures(f) {
+		OptionsController.setFeatures(f);
+	}
+	updateRemoteFeatures(f) {
+		OptionsController.setRemoteFeatures(f);
+	}
+	updateOptions(f) {
+		let V = {
+			...OptionsController.state || {},
+			...f
+		};
+		OptionsController.setOptions(V);
+	}
+	setConnectMethodsOrder(f) {
+		OptionsController.setConnectMethodsOrder(f);
+	}
+	setWalletFeaturesOrder(f) {
+		OptionsController.setWalletFeaturesOrder(f);
+	}
+	setCollapseWallets(f) {
+		OptionsController.setCollapseWallets(f);
+	}
+	setSocialsOrder(f) {
+		OptionsController.setSocialsOrder(f);
+	}
+	getConnectMethodsOrder() {
+		return WalletUtil.getConnectOrderMethod(OptionsController.state.features, ConnectorController.getConnectors());
+	}
+	addNetwork(f, V) {
+		if (this.chainAdapters && !this.chainAdapters[f]) throw Error(`Adapter for namespace ${f} doesn't exist`);
+		let H = this.extendCaipNetwork(V, this.options);
+		this.getCaipNetworks().find((f) => f.id === H.id) || ChainController.addNetwork(H);
+	}
+	removeNetwork(f, V) {
+		if (this.chainAdapters && !this.chainAdapters[f]) throw Error(`Adapter for namespace ${f} doesn't exist`);
+		this.getCaipNetworks().find((f) => f.id === V) && ChainController.removeNetwork(f, V);
+	}
+}, isInitialized = !1, AppKit = class extends AppKitBaseClient {
+	async open(f) {
+		ConnectorController.isConnected() || await super.open(f);
+	}
+	async close() {
+		if (await super.close(), this.options.manualWCControl) {
+			let f = ChainController.getAccountData(this.activeChainNamespace)?.address;
+			ConnectionController.finalizeWcConnection(f);
+		}
+	}
+	async syncIdentity(f) {
+		return Promise.resolve();
+	}
+	async syncBalance(f) {
+		return Promise.resolve();
+	}
+	async injectModalUi() {
+		if (!isInitialized && CoreHelperUtil.isClient()) {
+			if (await import("./basic-C16-Uba1.js"), await import("./w3m-modal-CFhImDZN.js"), !document.querySelector("w3m-modal")) {
+				let f = document.createElement("w3m-modal");
+				!OptionsController.state.disableAppend && !OptionsController.state.enableEmbedded && document.body.insertAdjacentElement("beforeend", f);
+			}
+			isInitialized = !0;
+		}
+	}
+};
+function createAppKit(f) {
+	return new AppKit({
+		...f,
+		basic: !0,
+		sdkVersion: "html-core-1.8.17-wc-circular-dependencies-fix.0"
+	});
+}
+export { createAppKit };