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

package/dist/use-wallets-DXRPNM7H.mjs

@@ -0,0 +1,885 @@
+import { _ as objectFromEntries, g as objectEntries, h as ChainGuards, m as evmCaip2s, v as objectKeys, y as objectValues } from "./multichain-C5wKiJke.mjs";
+import { createStore } from "@xstate/store";
+import { c } from "react/compiler-runtime";
+import { createContext, useContext, useEffect, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+import { useSelector } from "@xstate/store-react";
+
+//#region src/core/stores/multichain/multichain-context.tsx
+const MultichainContext = createContext(void 0);
+
+//#endregion
+//#region src/core/stores/multichain/multichain-provider.tsx
+const MultichainProvider = (t0) => {
+	const $ = c(6);
+	const { multichain, children } = t0;
+	let t1;
+	let t2;
+	if ($[0] !== multichain) {
+		t1 = () => {
+			multichain.mount();
+		};
+		t2 = [multichain];
+		$[0] = multichain;
+		$[1] = t1;
+		$[2] = t2;
+	} else {
+		t1 = $[1];
+		t2 = $[2];
+	}
+	useEffect(t1, t2);
+	let t3;
+	if ($[3] !== children || $[4] !== multichain) {
+		t3 = /* @__PURE__ */ jsx(MultichainContext.Provider, {
+			value: multichain,
+			children
+		});
+		$[3] = children;
+		$[4] = multichain;
+		$[5] = t3;
+	} else t3 = $[5];
+	return t3;
+};
+
+//#endregion
+//#region src/core/stores/multichain/use-multichain-context.tsx
+const useMultichainContext = () => {
+	const context = useContext(MultichainContext);
+	if (context === void 0) throw new Error("useMultichainContext must be used within a WalletContextProvider");
+	return context;
+};
+
+//#endregion
+//#region src/core/wallets/wallet-registry.ts
+function defineWalletRegistry(registry) {
+	return registry;
+}
+const walletRegistry = defineWalletRegistry({
+	metamask: {
+		label: "MetaMask",
+		chains: evmCaip2s,
+		canConnect: "single-at-once"
+	},
+	"wallet-connect": {
+		label: "WalletConnect",
+		chains: [
+			...evmCaip2s,
+			"xrpl:0",
+			"xrpl:1"
+		],
+		canConnect: "all-at-once"
+	},
+	ledger: {
+		label: "Ledger",
+		chains: [
+			"eip155:1",
+			"eip155:11155111",
+			"eip155:14",
+			"eip155:16",
+			"eip155:114",
+			"eip155:19",
+			"xrpl:0",
+			"xrpl:1"
+		],
+		canConnect: "single-at-once"
+	},
+	xaman: {
+		label: "Xaman",
+		chains: ["xrpl:0", "xrpl:1"],
+		canConnect: "single-at-once"
+	},
+	dcent: {
+		label: "D'CENT",
+		chains: ["xrpl:0", "xrpl:1"],
+		canConnect: "single-at-once"
+	}
+});
+const walletLabels = objectFromEntries(objectEntries(walletRegistry).map(([walletType, wallet]) => [walletType, wallet.label]));
+const walletSupportForChain = objectFromEntries(objectEntries(walletRegistry).map(([walletType, wallet]) => [walletType, {
+	chains: wallet.chains,
+	canConnect: wallet.canConnect
+}]));
+
+//#endregion
+//#region src/react/hooks/use-chain-support/use-chain-support.ts
+/**
+* Hook to access chain configuration.
+*
+* @example
+* ```tsx
+* // Get all chains
+* const allChains = useChainSupport();
+*
+* // Get EVM chains only
+* const evmChains = useChainSupport({ chainType: 'evm' });
+*
+* // Get XRPL chains only
+* const xrplChains = useChainSupport({ chainType: 'xrpl' });
+*
+* // Get chains supported by a wallet
+* const ledgerChains = useChainSupport({ wallet: 'ledger' });
+* ```
+*/
+function useChainSupport(filter) {
+	const $ = c(6);
+	const multichain = useMultichainContext();
+	let allChains;
+	let t0;
+	if ($[0] !== filter || $[1] !== multichain) {
+		t0 = Symbol.for("react.early_return_sentinel");
+		bb0: {
+			const configResolver = multichain.getConfigResolver();
+			const filterChainType = filter && "chainType" in filter ? filter.chainType : void 0;
+			const filterWallet = filter && "wallet" in filter ? filter.wallet : void 0;
+			const firstWallet = multichain.getWalletTypes()[0];
+			const resolvedConfig = firstWallet ? configResolver.resolveForWallet(firstWallet) : null;
+			if (!resolvedConfig) {
+				t0 = [];
+				break bb0;
+			}
+			allChains = objectValues(resolvedConfig.chains);
+			if (!filterChainType && !filterWallet) {
+				t0 = allChains;
+				break bb0;
+			}
+			if (filterChainType === "evm") {
+				t0 = allChains.filter(_temp$4);
+				break bb0;
+			}
+			if (filterChainType === "xrpl") {
+				t0 = allChains.filter(_temp2$1);
+				break bb0;
+			}
+			if (filterWallet) {
+				const supportedCaip2s = walletSupportForChain[filterWallet].chains;
+				let t1;
+				if ($[4] !== supportedCaip2s) {
+					t1 = (chain_1) => supportedCaip2s.includes(chain_1.caip2);
+					$[4] = supportedCaip2s;
+					$[5] = t1;
+				} else t1 = $[5];
+				t0 = allChains.filter(t1);
+				break bb0;
+			}
+		}
+		$[0] = filter;
+		$[1] = multichain;
+		$[2] = allChains;
+		$[3] = t0;
+	} else {
+		allChains = $[2];
+		t0 = $[3];
+	}
+	if (t0 !== Symbol.for("react.early_return_sentinel")) return t0;
+	return allChains;
+}
+function _temp2$1(chain_0) {
+	return ChainGuards.isXrplCaip2(chain_0.caip2);
+}
+function _temp$4(chain) {
+	return ChainGuards.isEvmCaip2(chain.caip2);
+}
+
+//#endregion
+//#region src/react/hooks/use-chain/use-chain.tsx
+function useChain(caip2, options) {
+	const $ = c(9);
+	const multichain = useMultichainContext();
+	let t0;
+	if ($[0] !== multichain) {
+		t0 = multichain.getAggregateStore();
+		$[0] = multichain;
+		$[1] = t0;
+	} else t0 = $[1];
+	const wallets = useSelector(t0, _temp$3);
+	let t1;
+	if ($[2] !== caip2 || $[3] !== multichain || $[4] !== options || $[5] !== wallets) {
+		t1 = Symbol.for("react.early_return_sentinel");
+		bb0: for (const [walletType, context] of objectEntries(wallets)) {
+			if (options?.wallet && walletType !== options.wallet) continue;
+			if (context?.caip2 === caip2 && context.connectionState === "connected") {
+				const narrowedWalletType = walletType;
+				const client = multichain.getConnector(narrowedWalletType).getClient();
+				t1 = {
+					exists: true,
+					address: context.activeAddress,
+					state: context,
+					walletType: narrowedWalletType,
+					caip2,
+					client
+				};
+				break bb0;
+			}
+		}
+		$[2] = caip2;
+		$[3] = multichain;
+		$[4] = options;
+		$[5] = wallets;
+		$[6] = t1;
+	} else t1 = $[6];
+	if (t1 !== Symbol.for("react.early_return_sentinel")) return t1;
+	let t2;
+	if ($[7] !== caip2) {
+		t2 = {
+			exists: false,
+			address: void 0,
+			state: void 0,
+			walletType: void 0,
+			caip2,
+			client: null
+		};
+		$[7] = caip2;
+		$[8] = t2;
+	} else t2 = $[8];
+	return t2;
+}
+function _temp$3(s) {
+	return s.context.wallets;
+}
+
+//#endregion
+//#region src/react/hooks/use-ledger-selection/use-ledger-selection.ts
+const DEFAULT_HD_STANDARD = "bip44";
+function useLedgerSelection(selectedCaip2, options) {
+	const $ = c(17);
+	const multichain = useMultichainContext();
+	let t0;
+	if ($[0] !== multichain) {
+		t0 = multichain.getConnector("ledger").getSession();
+		$[0] = multichain;
+		$[1] = t0;
+	} else t0 = $[1];
+	const session = t0;
+	const resolvedHdStandard = options?.initialHdStandard ?? session?.hdStandard ?? DEFAULT_HD_STANDARD;
+	let t1;
+	if ($[2] !== options?.initialSelections || $[3] !== session) {
+		t1 = options?.initialSelections ?? (session ? { [session.caip2]: session.account } : {});
+		$[2] = options?.initialSelections;
+		$[3] = session;
+		$[4] = t1;
+	} else t1 = $[4];
+	const resolvedSelections = t1;
+	const [hdStandard, setHdStandard] = useState(resolvedHdStandard);
+	const [selections, setSelections] = useState(resolvedSelections);
+	const selectedAddress = selections[selectedCaip2] ?? null;
+	let t2;
+	if ($[5] !== selectedCaip2) {
+		t2 = (address) => {
+			setSelections((prev) => {
+				if (prev[selectedCaip2] === address) return prev;
+				return {
+					...prev,
+					[selectedCaip2]: address
+				};
+			});
+		};
+		$[5] = selectedCaip2;
+		$[6] = t2;
+	} else t2 = $[6];
+	const selectAddress = t2;
+	let t3;
+	if ($[7] !== selectedCaip2) {
+		t3 = () => {
+			setSelections((prev_0) => {
+				if (!prev_0[selectedCaip2]) return prev_0;
+				const next = { ...prev_0 };
+				delete next[selectedCaip2];
+				return next;
+			});
+		};
+		$[7] = selectedCaip2;
+		$[8] = t3;
+	} else t3 = $[8];
+	const clearSelection = t3;
+	let t4;
+	if ($[9] !== clearSelection || $[10] !== hdStandard || $[11] !== selectAddress || $[12] !== selectedAddress) {
+		t4 = {
+			selectedAddress,
+			hdStandard,
+			selectAddress,
+			setHdStandard,
+			clearSelection
+		};
+		$[9] = clearSelection;
+		$[10] = hdStandard;
+		$[11] = selectAddress;
+		$[12] = selectedAddress;
+		$[13] = t4;
+	} else t4 = $[13];
+	const selection = t4;
+	let t5;
+	if ($[14] !== selection || $[15] !== selections) {
+		t5 = {
+			selection,
+			selections
+		};
+		$[14] = selection;
+		$[15] = selections;
+		$[16] = t5;
+	} else t5 = $[16];
+	return t5;
+}
+
+//#endregion
+//#region src/react/hooks/use-multichain-events/use-multichain-events.tsx
+const useMultichainEvents = (options) => {
+	const $ = c(5);
+	const multichain = useMultichainContext();
+	const optionsRef = useRef(options);
+	let t0;
+	if ($[0] !== options) {
+		t0 = () => {
+			optionsRef.current = options;
+		};
+		$[0] = options;
+		$[1] = t0;
+	} else t0 = $[1];
+	useEffect(t0);
+	let t1;
+	let t2;
+	if ($[2] !== multichain) {
+		t1 = () => {
+			const subscriptions = [];
+			const wallets = multichain.getWalletTypes();
+			for (const walletType of wallets) {
+				const connectSub = multichain.onWalletEvent(walletType, "walletConnected", (event) => {
+					optionsRef.current.onConnect?.({
+						walletType,
+						caip2: event.caip2,
+						address: event.activeAddress,
+						availableAddresses: event.availableAddresses,
+						isReconnect: event.isReconnect
+					});
+				});
+				if (connectSub) subscriptions.push(connectSub);
+				const disconnectSub = multichain.onWalletEvent(walletType, "walletDisconnected", () => {
+					optionsRef.current.onDisconnect?.({ walletType });
+				});
+				if (disconnectSub) subscriptions.push(disconnectSub);
+				const errorSub = multichain.onWalletEvent(walletType, "walletError", (event_0) => {
+					optionsRef.current.onError?.({
+						walletType,
+						error: new Error(event_0.error.message)
+					});
+				});
+				if (errorSub) subscriptions.push(errorSub);
+				const chainChangedSub = multichain.onWalletEvent(walletType, "walletChainChanged", (event_1) => {
+					optionsRef.current.onChainChanged?.({
+						walletType,
+						caip2: event_1.caip2
+					});
+				});
+				if (chainChangedSub) subscriptions.push(chainChangedSub);
+				const addressChangedSub = multichain.onWalletEvent(walletType, "walletAddressChanged", (event_2) => {
+					optionsRef.current.onAccountChanged?.({
+						walletType,
+						address: event_2.activeAddress
+					});
+				});
+				if (addressChangedSub) subscriptions.push(addressChangedSub);
+			}
+			return () => {
+				for (const sub of subscriptions) sub.unsubscribe();
+			};
+		};
+		t2 = [multichain];
+		$[2] = multichain;
+		$[3] = t1;
+		$[4] = t2;
+	} else {
+		t1 = $[3];
+		t2 = $[4];
+	}
+	useEffect(t1, t2);
+};
+
+//#endregion
+//#region src/core/connectors/connector-types.ts
+function getChainSelectionMode(wallet, walletSupport) {
+	if (!wallet) return null;
+	return walletSupport[wallet].canConnect === "all-at-once" ? "multi" : "single";
+}
+function buildConnectArgs(wallet, chains) {
+	if (!wallet) return null;
+	switch (wallet) {
+		case "wallet-connect": return chains.length ? {
+			wallet,
+			chains
+		} : null;
+		case "metamask": return chains.length ? {
+			wallet,
+			chain: chains[0]
+		} : null;
+		case "ledger": return chains.length ? {
+			wallet,
+			chain: chains[0]
+		} : null;
+		case "xaman": return { wallet };
+		case "dcent": return { wallet };
+	}
+}
+
+//#endregion
+//#region src/react/hooks/use-wallet-selection/wallet-selection.store.ts
+const INITIAL = {
+	selectedWalletType: null,
+	selectedCaip2s: []
+};
+function createMultichainSelectionStore(fixedCaip2) {
+	const getSelectionMode = (walletType) => walletType ? walletSupportForChain[walletType].canConnect === "all-at-once" ? "multi" : "single" : null;
+	return createStore({
+		context: INITIAL,
+		on: {
+			selectWallet: (_ctx, { walletType, preselect }) => ({
+				selectedWalletType: walletType,
+				selectedCaip2s: preselect
+			}),
+			clearWallet: () => INITIAL,
+			toggleCaip2: (ctx, { caip2 }) => {
+				if (fixedCaip2) return ctx;
+				if (getSelectionMode(ctx.selectedWalletType) === "single") return {
+					...ctx,
+					selectedCaip2s: ctx.selectedCaip2s[0] === caip2 ? [] : [caip2]
+				};
+				const has = ctx.selectedCaip2s.includes(caip2);
+				return {
+					...ctx,
+					selectedCaip2s: has ? ctx.selectedCaip2s.filter((selected) => selected !== caip2) : [...ctx.selectedCaip2s, caip2]
+				};
+			},
+			setSelectedCaip2s: (ctx, { caip2s }) => {
+				if (fixedCaip2) return {
+					...ctx,
+					selectedCaip2s: [fixedCaip2]
+				};
+				if (getSelectionMode(ctx.selectedWalletType) === "single") return {
+					...ctx,
+					selectedCaip2s: caip2s.length ? [caip2s[0]] : []
+				};
+				return {
+					...ctx,
+					selectedCaip2s: [...caip2s]
+				};
+			},
+			reset: () => INITIAL
+		}
+	});
+}
+
+//#endregion
+//#region src/react/hooks/use-wallet-selection/wallet-selection.utils.ts
+function isSingleChainMode(config) {
+	return config.mode.includes("single-chain");
+}
+function deriveSelectionWallets(walletTypes, walletStates, chainOptions) {
+	return walletTypes.map((type) => {
+		const state = walletStates[type];
+		return {
+			type,
+			name: walletLabels[type],
+			caip2s: chainOptions[type] ?? [],
+			multiChain: walletSupportForChain[type].canConnect === "all-at-once",
+			isConnecting: state?.connectionState === "connecting",
+			isConnected: state?.connectionState === "connected",
+			caip2: state?.caip2 ?? null
+		};
+	});
+}
+
+//#endregion
+//#region src/react/hooks/use-wallet-selection/wallet-selection.provider.tsx
+const MultichainSelectionContext = createContext(null);
+function buildChainOptions(wallets, fixedCaip2) {
+	const options = {};
+	for (const [walletType, setting] of objectEntries(wallets)) {
+		if (!setting) continue;
+		const supported = walletSupportForChain[walletType].chains;
+		const requested = setting === "all" ? supported : setting.filter((caip2) => supported.includes(caip2));
+		if (fixedCaip2) {
+			if (requested.includes(fixedCaip2)) options[walletType] = [fixedCaip2];
+		} else options[walletType] = [...requested];
+	}
+	return options;
+}
+function MultichainSelectionProvider(t0) {
+	const $ = c(5);
+	const { config, children } = t0;
+	let t1;
+	if ($[0] !== config) {
+		t1 = () => {
+			const fixedCaip2 = isSingleChainMode(config) ? config.caip2 : null;
+			const chainOptions = buildChainOptions(config.wallets, fixedCaip2);
+			return {
+				store: createMultichainSelectionStore(fixedCaip2),
+				mode: config.mode,
+				fixedCaip2,
+				chainOptions,
+				wallets: objectKeys(chainOptions)
+			};
+		};
+		$[0] = config;
+		$[1] = t1;
+	} else t1 = $[1];
+	const [ctx] = useState(t1);
+	let t2;
+	if ($[2] !== children || $[3] !== ctx) {
+		t2 = /* @__PURE__ */ jsx(MultichainSelectionContext.Provider, {
+			value: ctx,
+			children
+		});
+		$[2] = children;
+		$[3] = ctx;
+		$[4] = t2;
+	} else t2 = $[4];
+	return t2;
+}
+
+//#endregion
+//#region src/react/hooks/use-wallet-selection/use-wallet-selection.ts
+function useMultichainSelection() {
+	const $ = c(46);
+	const ctx = useContext(MultichainSelectionContext);
+	if (!ctx) throw new Error("useMultichainSelection must be used within MultichainSelectionProvider");
+	const { store, mode, fixedCaip2, chainOptions, wallets: walletTypes } = ctx;
+	const { selectedWalletType, selectedCaip2s } = useSelector(store, _temp$2);
+	const multichain = useMultichainContext();
+	let t0;
+	if ($[0] !== multichain) {
+		t0 = multichain.getAggregateStore();
+		$[0] = multichain;
+		$[1] = t0;
+	} else t0 = $[1];
+	const walletStates = useSelector(t0, _temp2);
+	let t1;
+	let wallets;
+	if ($[2] !== chainOptions || $[3] !== selectedWalletType || $[4] !== walletStates || $[5] !== walletTypes) {
+		wallets = deriveSelectionWallets(walletTypes, walletStates, chainOptions);
+		t1 = selectedWalletType ? wallets.find((wallet) => wallet.type === selectedWalletType) ?? null : null;
+		$[2] = chainOptions;
+		$[3] = selectedWalletType;
+		$[4] = walletStates;
+		$[5] = walletTypes;
+		$[6] = t1;
+		$[7] = wallets;
+	} else {
+		t1 = $[6];
+		wallets = $[7];
+	}
+	const selectedWallet = t1;
+	let t2;
+	if ($[8] !== selectedWalletType) {
+		t2 = getChainSelectionMode(selectedWalletType, walletSupportForChain);
+		$[8] = selectedWalletType;
+		$[9] = t2;
+	} else t2 = $[9];
+	const chainSelectionMode = t2;
+	let t3;
+	if ($[10] !== selectedCaip2s || $[11] !== selectedWalletType) {
+		t3 = buildConnectArgs(selectedWalletType, selectedCaip2s);
+		$[10] = selectedCaip2s;
+		$[11] = selectedWalletType;
+		$[12] = t3;
+	} else t3 = $[12];
+	const connectArgs = t3;
+	let t4;
+	if ($[13] !== fixedCaip2 || $[14] !== walletStates) {
+		t4 = (walletType) => {
+			const state = walletStates[walletType];
+			const caip2 = fixedCaip2 ?? state?.caip2;
+			return caip2 ? [caip2] : [];
+		};
+		$[13] = fixedCaip2;
+		$[14] = walletStates;
+		$[15] = t4;
+	} else t4 = $[15];
+	const preselectFor = t4;
+	let t5;
+	if ($[16] !== preselectFor || $[17] !== store) {
+		t5 = (walletType_0) => {
+			const preselect = preselectFor(walletType_0);
+			const args = buildConnectArgs(walletType_0, preselect);
+			if (!args) throw new Error(`Cannot build connect args for "${walletType_0}": no chains available. Ensure the wallet has chains configured or a chain is selected.`);
+			store.trigger.selectWallet({
+				walletType: walletType_0,
+				preselect
+			});
+			return args;
+		};
+		$[16] = preselectFor;
+		$[17] = store;
+		$[18] = t5;
+	} else t5 = $[18];
+	const selectWallet = t5;
+	let t6;
+	if ($[19] !== store) {
+		t6 = () => store.trigger.clearWallet();
+		$[19] = store;
+		$[20] = t6;
+	} else t6 = $[20];
+	const clearWallet = t6;
+	let t7;
+	if ($[21] !== store) {
+		t7 = (caip2_0) => store.trigger.toggleCaip2({ caip2: caip2_0 });
+		$[21] = store;
+		$[22] = t7;
+	} else t7 = $[22];
+	const toggleCaip2 = t7;
+	let t8;
+	if ($[23] !== store) {
+		t8 = (caip2s) => store.trigger.setSelectedCaip2s({ caip2s });
+		$[23] = store;
+		$[24] = t8;
+	} else t8 = $[24];
+	const setSelectedCaip2s = t8;
+	let t9;
+	if ($[25] !== store) {
+		t9 = () => store.trigger.reset();
+		$[25] = store;
+		$[26] = t9;
+	} else t9 = $[26];
+	const reset = t9;
+	let t10;
+	if ($[27] !== selectedWallet?.caip2s) {
+		t10 = selectedWallet?.caip2s ?? [];
+		$[27] = selectedWallet?.caip2s;
+		$[28] = t10;
+	} else t10 = $[28];
+	let t11;
+	if ($[29] !== chainSelectionMode || $[30] !== clearWallet || $[31] !== fixedCaip2 || $[32] !== mode || $[33] !== reset || $[34] !== selectWallet || $[35] !== selectedCaip2s || $[36] !== selectedWallet || $[37] !== selectedWalletType || $[38] !== setSelectedCaip2s || $[39] !== t10 || $[40] !== toggleCaip2 || $[41] !== wallets) {
+		t11 = {
+			mode,
+			fixedCaip2,
+			wallets,
+			selectedWalletType,
+			selectedWallet,
+			selectedCaip2s,
+			availableCaip2s: t10,
+			chainSelectionMode,
+			selectWallet,
+			clearWallet,
+			toggleCaip2,
+			setSelectedCaip2s,
+			reset
+		};
+		$[29] = chainSelectionMode;
+		$[30] = clearWallet;
+		$[31] = fixedCaip2;
+		$[32] = mode;
+		$[33] = reset;
+		$[34] = selectWallet;
+		$[35] = selectedCaip2s;
+		$[36] = selectedWallet;
+		$[37] = selectedWalletType;
+		$[38] = setSelectedCaip2s;
+		$[39] = t10;
+		$[40] = toggleCaip2;
+		$[41] = wallets;
+		$[42] = t11;
+	} else t11 = $[42];
+	const base = t11;
+	let t12;
+	if ($[43] !== base || $[44] !== connectArgs) {
+		t12 = connectArgs ? {
+			...base,
+			canConnect: true,
+			connectArgs
+		} : {
+			...base,
+			canConnect: false,
+			connectArgs: null
+		};
+		$[43] = base;
+		$[44] = connectArgs;
+		$[45] = t12;
+	} else t12 = $[45];
+	return t12;
+}
+function _temp2(snapshot_0) {
+	return snapshot_0.context.wallets;
+}
+function _temp$2(snapshot) {
+	return snapshot.context;
+}
+
+//#endregion
+//#region src/react/hooks/use-multichain/use-multichain.tsx
+/**
+* Hook for wallet connection actions.
+*
+* Use this for connect/disconnect operations.
+* For connection state, use useWallet() instead.
+*
+* @example
+* ```tsx
+* const { connect, disconnect, getConnector } = useMultichain();
+*
+* // Connect MetaMask to a single chain
+* await connect({ wallet: 'metamask', chain: 'eip155:14' });
+*
+* // Connect WalletConnect to multiple chains
+* await connect({ wallet: 'wallet-connect', chains: ['eip155:14', 'eip155:1'] });
+*
+* // Connect Ledger with options
+* await connect({ wallet: 'ledger', chain: 'eip155:14', options: { bip44, ledgerHDStandard } });
+*
+* // Disconnect
+* await disconnect('metamask');
+*
+* // Get connector for advanced operations
+* const connector = getConnector('metamask');
+* const client = connector.getClient();
+* ```
+*/
+function useMultichain() {
+	const $ = c(2);
+	const multichain = useMultichainContext();
+	let t0;
+	if ($[0] !== multichain) {
+		t0 = {
+			connect: (args) => multichain.connect(args),
+			disconnect: (wallet) => multichain.disconnect(wallet),
+			disconnectAll: () => multichain.disconnectAll(),
+			getConnector: (wallet_0) => multichain.getConnector(wallet_0)
+		};
+		$[0] = multichain;
+		$[1] = t0;
+	} else t0 = $[1];
+	return t0;
+}
+
+//#endregion
+//#region src/react/hooks/use-wallet-support/use-wallet-support.ts
+/**
+* Hook to access wallet support configuration.
+*
+* @example
+* ```tsx
+* // Get all wallets
+* const wallets = useWalletSupport();
+*
+* // Exclude specific wallets
+* const simpleWallets = useWalletSupport({ exclude: ['ledger'] });
+*
+* // All wallet info with chains and mode
+* wallets // [{ type: 'metamask', name: 'MetaMask', chains: [...], singleChain: true }, ...]
+*
+* // Find specific wallet
+* const mm = wallets.find(w => w.type === 'metamask');
+* mm.chains      // ['eip155:14', 'eip155:16', ...]
+* mm.singleChain // true
+* ```
+*/
+function useWalletSupport(filter) {
+	const $ = c(3);
+	const multichain = useMultichainContext();
+	const excludeList = filter?.exclude;
+	let t0;
+	if ($[0] !== excludeList || $[1] !== multichain) {
+		const walletTypes = multichain.getWalletTypes();
+		t0 = (excludeList ? walletTypes.filter((type) => !excludeList.includes(type)) : walletTypes).map(_temp$1);
+		$[0] = excludeList;
+		$[1] = multichain;
+		$[2] = t0;
+	} else t0 = $[2];
+	return t0;
+}
+function _temp$1(type_0) {
+	return {
+		type: type_0,
+		name: walletLabels[type_0],
+		chains: [...walletSupportForChain[type_0].chains],
+		singleChain: walletSupportForChain[type_0].canConnect === "single-at-once"
+	};
+}
+
+//#endregion
+//#region src/react/hooks/use-wallet/use-wallet.tsx
+/**
+* Hook to access a specific wallet's state and connector.
+*
+* @example
+* ```tsx
+* const { state, connector, isConnected } = useWallet('metamask');
+*
+* if (isConnected) {
+*   const client = connector.getClient();
+*   await client.getPublicClient().readContract({...});
+* }
+* ```
+*/
+function useWallet(walletType) {
+	const $ = c(13);
+	const multichain = useMultichainContext();
+	let t0;
+	if ($[0] !== multichain) {
+		t0 = multichain.getAggregateStore();
+		$[0] = multichain;
+		$[1] = t0;
+	} else t0 = $[1];
+	let t1;
+	if ($[2] !== walletType) {
+		t1 = (s) => s.context.wallets[walletType];
+		$[2] = walletType;
+		$[3] = t1;
+	} else t1 = $[3];
+	const state = useSelector(t0, t1);
+	let t2;
+	if ($[4] !== multichain || $[5] !== walletType) {
+		t2 = multichain.getConnector(walletType);
+		$[4] = multichain;
+		$[5] = walletType;
+		$[6] = t2;
+	} else t2 = $[6];
+	const connector = t2;
+	const t3 = state?.connectionState === "connected";
+	const t4 = state?.connectionState === "connecting";
+	let t5;
+	if ($[7] !== connector || $[8] !== state || $[9] !== t3 || $[10] !== t4 || $[11] !== walletType) {
+		t5 = {
+			state,
+			connector,
+			walletType,
+			isConnected: t3,
+			isConnecting: t4
+		};
+		$[7] = connector;
+		$[8] = state;
+		$[9] = t3;
+		$[10] = t4;
+		$[11] = walletType;
+		$[12] = t5;
+	} else t5 = $[12];
+	return t5;
+}
+
+//#endregion
+//#region src/react/hooks/use-wallets/use-wallets.ts
+const useWallets = () => {
+	const $ = c(4);
+	const multichain = useMultichainContext();
+	const walletTypes = multichain.getWalletTypes();
+	let t0;
+	if ($[0] !== multichain) {
+		t0 = multichain.getAggregateStore();
+		$[0] = multichain;
+		$[1] = t0;
+	} else t0 = $[1];
+	const wallets = useSelector(t0, _temp);
+	let t1;
+	if ($[2] !== wallets) {
+		t1 = (type) => ({
+			state: wallets[type],
+			type
+		});
+		$[2] = wallets;
+		$[3] = t1;
+	} else t1 = $[3];
+	return walletTypes.map(t1);
+};
+function _temp(s) {
+	return s.context.wallets;
+}
+
+//#endregion
+export { useMultichainSelection as a, useLedgerSelection as c, MultichainProvider as d, useMultichain as i, useChain as l, useWallet as n, MultichainSelectionProvider as o, useWalletSupport as r, useMultichainEvents as s, useWallets as t, useChainSupport as u };
+//# sourceMappingURL=use-wallets-DXRPNM7H.mjs.map