@usebutr/core 2.0.0 → 3.0.0

package/dist/index.js

@@ -14,79 +14,57 @@ const buildAccount = (address, chain) => ({
 });
 
 //#endregion
-//#region src/types/chains-by-platform.ts
+//#region src/types/chain.ts
 /**
-* Naming only the platforms an app targets keeps the other packages'
-* chain registries out of its bundle. Apps that want all of them import
-* `CHAINS_BY_PLATFORM` from `@usebutr/wallets`.
+* Wallets report bare CAIP-2 ids, so the display name comes from a chain
+* registry. A chain outside `known` keeps its id as its name rather than
+* borrowing the wallet's.
 */
-const buildChainsByPlatform = (partial) => ({
-	bitcoin: partial.bitcoin ?? [],
-	evm: partial.evm ?? [],
-	polkadot: partial.polkadot ?? [],
-	sui: partial.sui ?? [],
-	svm: partial.svm ?? []
-});
+const resolveChain = (id, known = []) => {
+	const match = known.find((chain) => chain.id === id);
+	if (match !== void 0) return match;
+	const [namespace = "", reference = ""] = id.split(":");
+	return {
+		id,
+		name: id,
+		namespace,
+		reference
+	};
+};
 
 //#endregion
 //#region src/types/errors.ts
+var ConnectionError = class extends Error {
+	kind;
+	constructor(kind, message, options) {
+		super(message, options);
+		this.name = "ConnectionError";
+		this.kind = kind;
+	}
+};
+const readCode = (error) => "code" in error && (typeof error.code === "number" || typeof error.code === "string") ? error.code : void 0;
 /**
 * EIP-1193 codes: `4001` rejected, `-32002` pending, `4100`/`4900`/`4901`
 * unauthorized or disconnected. Message-substring matching is the last
 * resort for SDKs that ship no codes at all.
 */
-const mapConnectionError = (raw) => {
-	if (raw instanceof Error) {
-		const message = raw.message;
-		const lower = message.toLowerCase();
-		if (message === "Connection timeout") return {
-			kind: "Timeout",
-			message
-		};
-		if (message === "Failed to get account" || lower.includes("not connected")) return {
-			kind: "NotConnected",
-			message
-		};
-		const code = "code" in raw ? raw.code : void 0;
-		if (code === 4001) return {
-			kind: "UserRejected",
-			message
-		};
-		if (code === -32002) return {
-			kind: "RequestPending",
-			message
-		};
-		if (code === 4100 || code === 4900 || code === 4901) return {
-			kind: "NotConnected",
-			message
-		};
-		if (lower.includes("user rejected") || lower.includes("user denied")) return {
-			kind: "UserRejected",
-			message
-		};
-		if (lower.includes("locked")) return {
-			kind: "WalletLocked",
-			message
-		};
-		if (lower.includes("chain") && (lower.includes("mismatch") || lower.includes("unsupported"))) return {
-			kind: "ChainMismatch",
-			message
-		};
-		return {
-			cause: raw,
-			kind: "Unknown",
-			message
-		};
-	}
-	if (typeof raw === "string") return {
-		kind: "Unknown",
-		message: raw
-	};
-	return {
-		cause: raw,
-		kind: "Unknown",
-		message: "Connection failed"
-	};
+const classify = (error) => {
+	const code = readCode(error);
+	if (code === 4001) return "UserRejected";
+	if (code === -32002) return "RequestPending";
+	if (code === 4100 || code === 4900 || code === 4901) return "NotConnected";
+	const lower = error.message.toLowerCase();
+	if (lower.includes("user rejected") || lower.includes("user denied")) return "UserRejected";
+	if (lower.includes("not connected")) return "NotConnected";
+	if (lower.includes("locked")) return "WalletLocked";
+	if (lower.includes("chain") && (lower.includes("mismatch") || lower.includes("unsupported"))) return "ChainMismatch";
+	return "Unknown";
+};
+/** The one boundary where a thrown value of unknown shape becomes typed. */
+const toConnectionError = (cause) => {
+	if (cause instanceof ConnectionError) return cause;
+	if (cause instanceof Error) return new ConnectionError(classify(cause), cause.message, { cause });
+	return new ConnectionError("Unknown", typeof cause === "string" && cause !== "" ? cause : "Connection failed", { cause });
 };
 
 //#endregion
@@ -103,120 +81,252 @@ const CHAIN_PLATFORMS = [
 	"bitcoin",
 	"polkadot"
 ];
+const PLATFORMS = new Set(CHAIN_PLATFORMS);
+const isChainPlatform = (value) => PLATFORMS.has(value);
+
+//#endregion
+//#region src/types/wallet.ts
+/** Narrows a pool entry to one platform, e.g. before calling its `sendTx`. */
+const isPlatformWallet = (wallet, platform) => wallet.connector.chainPlatform === platform;
+
+//#endregion
+//#region src/chains.ts
+/** Common EVM chains. `switchChain` accepts any `ChainBase`, so a chain
+*  missing here still works; it is just named by its CAIP-2 id. */
+const EVM_CHAINS = {
+	arbitrum: {
+		id: "eip155:42161",
+		name: "Arbitrum One",
+		namespace: "eip155",
+		reference: "42161"
+	},
+	base: {
+		id: "eip155:8453",
+		name: "Base",
+		namespace: "eip155",
+		reference: "8453"
+	},
+	bsc: {
+		id: "eip155:56",
+		name: "BNB Smart Chain",
+		namespace: "eip155",
+		reference: "56"
+	},
+	ethereum: {
+		id: "eip155:1",
+		name: "Ethereum",
+		namespace: "eip155",
+		reference: "1"
+	},
+	optimism: {
+		id: "eip155:10",
+		name: "Optimism",
+		namespace: "eip155",
+		reference: "10"
+	},
+	polygon: {
+		id: "eip155:137",
+		name: "Polygon",
+		namespace: "eip155",
+		reference: "137"
+	},
+	sepolia: {
+		id: "eip155:11155111",
+		name: "Sepolia",
+		namespace: "eip155",
+		reference: "11155111"
+	}
+};
+const SVM_CHAINS = {
+	devnet: {
+		id: "solana:devnet",
+		name: "Solana Devnet",
+		namespace: "solana",
+		reference: "devnet"
+	},
+	mainnet: {
+		id: "solana:mainnet",
+		name: "Solana Mainnet",
+		namespace: "solana",
+		reference: "mainnet"
+	},
+	testnet: {
+		id: "solana:testnet",
+		name: "Solana Testnet",
+		namespace: "solana",
+		reference: "testnet"
+	}
+};
+const SUI_CHAINS = {
+	devnet: {
+		id: "sui:devnet",
+		name: "Sui Devnet",
+		namespace: "sui",
+		reference: "devnet"
+	},
+	localnet: {
+		id: "sui:localnet",
+		name: "Sui Localnet",
+		namespace: "sui",
+		reference: "localnet"
+	},
+	mainnet: {
+		id: "sui:mainnet",
+		name: "Sui Mainnet",
+		namespace: "sui",
+		reference: "mainnet"
+	},
+	testnet: {
+		id: "sui:testnet",
+		name: "Sui Testnet",
+		namespace: "sui",
+		reference: "testnet"
+	}
+};
+/** CAIP-2 Bitcoin references are the first 16 bytes of each network's
+*  genesis block hash, which is what wallets advertise in `wallet.chains`. */
+const BITCOIN_CHAINS = {
+	mainnet: {
+		id: "bip122:000000000019d6689c085ae165831e93",
+		name: "Bitcoin",
+		namespace: "bip122",
+		reference: "000000000019d6689c085ae165831e93"
+	},
+	signet: {
+		id: "bip122:00000008819873e925422c1ff0f99f7c",
+		name: "Bitcoin Signet",
+		namespace: "bip122",
+		reference: "00000008819873e925422c1ff0f99f7c"
+	},
+	testnet: {
+		id: "bip122:000000000933ea01ad0ee984209779ba",
+		name: "Bitcoin Testnet",
+		namespace: "bip122",
+		reference: "000000000933ea01ad0ee984209779ba"
+	},
+	testnet4: {
+		id: "bip122:00000000da84f2bafbbc53dee25a72ae",
+		name: "Bitcoin Testnet4",
+		namespace: "bip122",
+		reference: "00000000da84f2bafbbc53dee25a72ae"
+	}
+};
+const POLKADOT_CHAINS = {
+	kusama: {
+		id: "polkadot:b0a8d493285c2df73290dfb7e61f870f",
+		name: "Kusama",
+		namespace: "polkadot",
+		reference: "b0a8d493285c2df73290dfb7e61f870f"
+	},
+	paseo: {
+		id: "polkadot:77afd6190f1554ad45fd0d31aee62aac",
+		name: "Paseo",
+		namespace: "polkadot",
+		reference: "77afd6190f1554ad45fd0d31aee62aac"
+	},
+	polkadot: {
+		id: "polkadot:91b171bb158e2d3848fa23a9f1c25182",
+		name: "Polkadot",
+		namespace: "polkadot",
+		reference: "91b171bb158e2d3848fa23a9f1c25182"
+	},
+	westend: {
+		id: "polkadot:e143f23803ac50e8f6f8e62695d1ce9e",
+		name: "Westend",
+		namespace: "polkadot",
+		reference: "e143f23803ac50e8f6f8e62695d1ce9e"
+	}
+};
+const EVM_CHAINS_LIST = Object.values(EVM_CHAINS);
+const SVM_CHAINS_LIST = Object.values(SVM_CHAINS);
+const SUI_CHAINS_LIST = Object.values(SUI_CHAINS);
+const BITCOIN_CHAINS_LIST = Object.values(BITCOIN_CHAINS);
+const POLKADOT_CHAINS_LIST = Object.values(POLKADOT_CHAINS);
+/** Every registry as a list, keyed by platform: the shape chain pickers want. */
+const CHAINS_BY_PLATFORM = {
+	bitcoin: BITCOIN_CHAINS_LIST,
+	evm: EVM_CHAINS_LIST,
+	polkadot: POLKADOT_CHAINS_LIST,
+	sui: SUI_CHAINS_LIST,
+	svm: SVM_CHAINS_LIST
+};
+
+//#endregion
+//#region src/logger.ts
+const logWarn = (...args) => {
+	console.warn(...args);
+};
+const logError = (...args) => {
+	console.error(...args);
+};
 
 //#endregion
 //#region src/wallet-source.ts
+const isIterable = (value) => Symbol.iterator in value;
 /**
-* Takes the exact shape of `discoverEvmAdapters` and friends, so a
-* single-platform app keeps `@usebutr/wallets` out of its bundle.
+* For adapters that are built rather than discovered: WalletConnect, Ledger,
+* hand-rolled ones. Takes one adapter or several, or a promise of either; a
+* rejected promise is logged and contributes nothing.
 */
-const createWalletSource = (subscribe) => ({ subscribe });
+const fromAdapters = (adapters) => (onAdapter) => {
+	let active = true;
+	(async () => {
+		try {
+			const resolved = await adapters;
+			for (const adapter of isIterable(resolved) ? resolved : [resolved]) {
+				if (!active) return;
+				onAdapter(adapter);
+			}
+		} catch (error) {
+			logWarn("[butr] fromAdapters: adapters failed to load:", error);
+		}
+	})();
+	return () => {
+		active = false;
+	};
+};
 
 //#endregion
 //#region src/store/shadow-adapter.ts
 /**
-* Loud failure for consumers that called a wallet method without gating
-* on `capabilities.*` (all `false` here) or `reconnectingIds`, before
-* silent reconnect swapped in the live adapter.
+* Thrown by the three required methods of a shadow adapter. Every optional
+* method is simply absent, so only code that skipped the `reconnectingIds`
+* check and called `connect`, `getAccounts` or `getSigner` sees this.
 */
 var ShadowConnectorError = class extends Error {
-	code = "BUTR_RECONNECTING";
 	connectorId;
 	method;
 	constructor(method, connectorId) {
-		super(`[butr] ${method} called on shadow connector "${connectorId}". Wait for silent reconnect to complete (check reconnectingIds.has(id) before calling).`);
+		super(`[butr] ${method} called on "${connectorId}" while it is still reconnecting. Check useIsReconnecting(id) before calling it.`);
 		this.name = "ShadowConnectorError";
 		this.connectorId = connectorId;
 		this.method = method;
 	}
 };
-const ALL_FALSE_CAPABILITIES = Object.freeze({
-	getBalance: false,
-	getTransactionReceipt: false,
-	requestAccounts: false,
-	sendTransaction: false,
-	signIn: false,
-	signMessage: false,
-	signTransaction: false,
-	subscribe: false,
-	switchAccount: false,
-	switchChain: false
-});
 /**
-* Lets `createWalletStore` flip `isHydrated` synchronously from
-* `initialState`; the hydration coordinator later swaps each shadow for
-* a live adapter, or drops the entry from pool and storage.
+* Stands in for a connection seeded from `initialState` so its identity
+* renders before discovery runs. It exposes no optional methods; the manager
+* swaps it for the live adapter, or evicts it, once silent reconnect settles.
 */
 const createShadowAdapter = (entry) => {
-	const id = entry.connectorId;
-	const name = entry.name;
-	const icon = entry.icon;
-	const reject = (method) => Promise.reject(new ShadowConnectorError(method, id));
-	const base = {
-		capabilities: ALL_FALSE_CAPABILITIES,
-		connect: () => reject("connect"),
-		disconnect: () => reject("disconnect"),
-		getAccount: () => reject("getAccount"),
-		getBalance: () => reject("getBalance"),
-		getSigner: () => reject("getSigner"),
-		getTransactionReceipt: () => reject("getTransactionReceipt"),
-		icon,
-		id,
-		name,
-		sendTx: () => reject("sendTx"),
-		sendTxToChain: () => reject("sendTxToChain"),
-		signMessage: () => reject("signMessage"),
-		switchChain: () => reject("switchChain")
+	const reject = (method) => () => Promise.reject(new ShadowConnectorError(method, entry.connectorId));
+	return {
+		chainPlatform: entry.chainPlatform,
+		connect: reject("connect"),
+		getAccounts: reject("getAccounts"),
+		getSigner: reject("getSigner"),
+		icon: entry.icon,
+		id: entry.connectorId,
+		name: entry.name
 	};
-	switch (entry.chainPlatform) {
-		case "bitcoin": return {
-			...base,
-			chainPlatform: "bitcoin"
-		};
-		case "evm": return {
-			...base,
-			chainPlatform: "evm"
-		};
-		case "sui": return {
-			...base,
-			chainPlatform: "sui"
-		};
-		case "svm": return {
-			...base,
-			chainPlatform: "svm"
-		};
-		case "polkadot": return {
-			...base,
-			chainPlatform: "polkadot"
-		};
-		default:
-			entry.chainPlatform;
-			throw new Error(`[butr] unknown chainPlatform: ${entry.chainPlatform}`);
-	}
-};
-/**
-* Structural detection: relies on every live adapter advertising at
-* least one capability, since `getBalance`, `signMessage` and
-* `switchChain` are required on all wallet surfaces.
-*/
-const isShadowAdapter = (adapter) => {
-	return Object.values(adapter.capabilities).every((flag) => !flag);
-};
-
-//#endregion
-//#region src/logger.ts
-const logWarn = (...args) => {
-	console.warn(...args);
-};
-const logError = (...args) => {
-	console.error(...args);
 };
 
 //#endregion
 //#region src/storage/browser-storage-driver.ts
+const webStorageGlobals = globalThis;
 const hasWebStorage = (kind) => {
 	try {
-		return typeof globalThis !== "undefined" && globalThis[kind] !== void 0;
+		return kind === "localStorage" ? webStorageGlobals.localStorage !== void 0 : webStorageGlobals.sessionStorage !== void 0;
 	} catch {
 		return false;
 	}
@@ -291,14 +401,9 @@ const storedPoolEntrySchema = z.looseObject({
 	name: z.string().min(1)
 });
 const recordSchema = z.record(z.string(), z.unknown());
-const parseStoredPoolEntry = (key, value) => {
-	const parsed = storedPoolEntrySchema.safeParse(value);
-	if (!parsed.success || parsed.data.connectorId !== key) return null;
-	return parsed.data;
-};
 const DEFAULT_KEY_PREFIX = "butr";
 /**
-* `WalletStorage` writes these and `readWalletSnapshot` reads them from
+* `createWalletStorage` writes these and `readWalletSnapshot` reads them from
 * a cookie jar; any divergence desyncs the SSR-seeded render from the
 * client that rehydrates it, the failure ADR 0003 exists to prevent.
 */
@@ -311,477 +416,308 @@ const storageKeys = (keyPrefix) => {
 		userDisconnected: `${prefix}-user-disconnected`
 	};
 };
-/**
-* Never repairs or throws: one corrupt entry must not take down a whole
-* session, and `readWalletSnapshot` may run on a server with no cookie
-* jar to write the eviction to.
-*/
-const decodePool = (raw, label = "[butr]") => {
+const parseRecord = (raw, label, what) => {
 	if (raw === null || raw === void 0 || raw === "") return {};
-	let value;
 	try {
-		value = JSON.parse(raw);
+		const parsed = recordSchema.safeParse(JSON.parse(raw));
+		return parsed.success ? parsed.data : {};
 	} catch (error) {
-		logWarn(`${label} failed to parse pool from storage:`, error);
+		logWarn(`${label} failed to parse ${what} from storage:`, error);
 		return {};
 	}
-	const parsed = recordSchema.safeParse(value);
-	if (!parsed.success) return {};
+};
+/**
+* Never repairs or throws: one corrupt entry must not take down a whole
+* session, and `readWalletSnapshot` may run on a server with no cookie
+* jar to write the eviction to. The next save overwrites the bad value.
+*/
+const decodePool = (raw, label = "[butr]") => {
 	const result = {};
-	for (const [key, entryValue] of Object.entries(parsed.data)) {
-		const entry = parseStoredPoolEntry(key, entryValue);
-		if (entry === null) logWarn(`${label} dropping invalid pool entry for ${key}`);
-		else result[key] = entry;
+	for (const [key, value] of Object.entries(parseRecord(raw, label, "pool"))) {
+		const entry = storedPoolEntrySchema.safeParse(value);
+		if (entry.success && entry.data.connectorId === key) result[key] = entry.data;
+		else logWarn(`${label} dropping invalid pool entry for ${key}`);
 	}
 	return result;
 };
 /** Decode a persisted selection payload. Same contract as `decodePool`. */
 const decodeSelection = (raw, label = "[butr]") => {
-	if (raw === null || raw === void 0 || raw === "") return {};
-	let value;
-	try {
-		value = JSON.parse(raw);
-	} catch (error) {
-		logWarn(`${label} failed to parse selection from storage:`, error);
-		return {};
-	}
-	const parsed = recordSchema.safeParse(value);
-	if (!parsed.success) return {};
 	const result = {};
-	for (const [key, selectionValue] of Object.entries(parsed.data)) {
+	for (const [key, value] of Object.entries(parseRecord(raw, label, "selection"))) {
 		const platform = chainPlatformSchema.safeParse(key);
-		if (platform.success && typeof selectionValue === "string" && selectionValue.length > 0) result[platform.data] = selectionValue;
+		if (platform.success && typeof value === "string" && value.length > 0) result[platform.data] = value;
 	}
 	return result;
 };
 
 //#endregion
 //#region src/storage/wallet-storage.ts
-var WalletStorage = class {
-	poolKey;
-	selectionKey;
-	activeKey;
-	userDisconnectedKey;
-	persistent;
-	session;
-	/**
-	* Serializes pool read-modify-writes; without it concurrent `setPool`
-	* calls drop each other's entries. Not reentrant, so a queued mutation
-	* must read via `readPool`: `getPool` re-enters and deadlocks it.
-	*/
-	poolMutationQueue = Promise.resolve();
-	constructor(config) {
-		const keys = storageKeys(config.keyPrefix);
-		this.poolKey = keys.pool;
-		this.selectionKey = keys.selection;
-		this.activeKey = keys.active;
-		this.userDisconnectedKey = keys.userDisconnected;
-		if (config.persistent && config.session) {
-			this.persistent = config.persistent;
-			this.session = config.session;
-		} else {
-			const defaults = createBrowserStorageDriver();
-			this.persistent = config.persistent ?? defaults.persistent;
-			this.session = config.session ?? defaults.session;
-		}
-	}
-	/** Chain `fn` after the in-flight pool mutation. */
-	async serializePoolMutation(fn) {
-		const previous = this.poolMutationQueue;
-		let resolve = () => {};
-		this.poolMutationQueue = new Promise((r) => {
-			resolve = r;
-		});
-		try {
-			await previous;
-		} catch {}
-		try {
-			return await fn();
-		} finally {
-			resolve();
-		}
-	}
-	/** Read and decode the pool without touching the mutation queue. Safe to
-	*  call from inside a queued mutation, unlike `getPool`. */
-	async readPool() {
-		let stored;
-		try {
-			stored = await this.persistent.getItem(this.poolKey);
-		} catch (error) {
-			logWarn("[butr] failed to read pool from storage:", error);
-			return {
-				corrupt: false,
-				decoded: {}
-			};
-		}
-		if (stored === null || stored === "") return {
-			corrupt: false,
-			decoded: {}
-		};
-		const decoded = decodePool(stored);
-		return {
-			corrupt: Object.keys(decoded).length === 0,
-			decoded
-		};
-	}
-	async getPool() {
-		const { corrupt, decoded } = await this.readPool();
-		if (corrupt) try {
-			await this.persistent.removeItem(this.poolKey);
-		} catch (error) {
-			logWarn("[butr] failed to clear corrupt pool:", error);
-		}
-		return decoded;
-	}
-	/**
-	* Additive on purpose: a failed silent reconnect drops the entry from
-	* the live pool, and it must survive to be retried next load.
-	* Eviction goes through `removePoolEntry` or `clearAll`.
-	*/
-	async setPool(pool) {
-		await this.serializePoolMutation(async () => {
-			try {
-				const { decoded: existing } = await this.readPool();
-				const serializable = { ...existing };
-				for (const [connectorId, wallet] of pool) {
-					const entry = {
-						account: wallet.account,
-						accounts: wallet.accounts,
-						chainPlatform: wallet.connector.chainPlatform,
-						connectorId,
-						icon: wallet.connector.icon,
-						name: wallet.connector.name
-					};
-					if (parseStoredPoolEntry(connectorId, entry) === null) throw new Error(`[butr] refusing to persist invalid pool entry for ${connectorId}`);
-					serializable[connectorId] = entry;
-				}
-				await this.persistent.setItem(this.poolKey, JSON.stringify(serializable));
-			} catch (error) {
-				logWarn("[butr] failed to persist pool:", error);
-			}
-		});
-	}
-	async removePoolEntry(connectorId) {
-		await this.serializePoolMutation(async () => {
-			try {
-				const { decoded: stored } = await this.readPool();
-				if (stored[connectorId]) {
-					const { [connectorId]: _, ...remaining } = stored;
-					await this.persistent.setItem(this.poolKey, JSON.stringify(remaining));
-				}
-			} catch (error) {
-				logWarn(`[butr] failed to remove pool entry ${connectorId}:`, error);
-			}
-		});
-	}
-	async clearPool() {
-		await this.serializePoolMutation(async () => {
-			await this.persistent.removeItem(this.poolKey);
-		});
-	}
-	async getSelection() {
-		try {
-			return decodeSelection(await this.persistent.getItem(this.selectionKey));
-		} catch (error) {
-			logWarn("[butr] failed to read selection from storage:", error);
-			return {};
-		}
-	}
-	async setSelection(selection) {
+const isEmpty = (record) => Object.keys(record).length === 0;
+/**
+* Pool, selection and active id go to the persistent driver, the disconnect
+* intent to the session driver. Unchanged keys are not rewritten, so a
+* cookie-backed driver does not re-send every cookie on each save.
+*/
+const createWalletStorage = (options = {}) => {
+	const keys = storageKeys(options.keyPrefix);
+	const browser = createBrowserStorageDriver();
+	const persistent = options.persistent ?? browser.persistent;
+	const session = options.session ?? browser.session;
+	const written = /* @__PURE__ */ new Map();
+	const read = async (driver, key) => {
 		try {
-			const serializable = {};
-			for (const [platform, connectorId] of selection) serializable[platform] = connectorId;
-			await this.persistent.setItem(this.selectionKey, JSON.stringify(serializable));
+			const value = await driver.getItem(key);
+			written.set(key, value);
+			return value;
 		} catch (error) {
-			logWarn("[butr] failed to persist selection:", error);
-		}
-	}
-	async getActiveConnectorId() {
-		try {
-			const value = await this.persistent.getItem(this.activeKey);
-			return value !== null && value.length > 0 ? value : null;
-		} catch {
+			logWarn(`[butr] failed to read ${key} from storage:`, error);
 			return null;
 		}
-	}
-	async setActiveConnectorId(connectorId) {
-		try {
-			await (connectorId === null ? this.persistent.removeItem(this.activeKey) : this.persistent.setItem(this.activeKey, connectorId));
-		} catch (error) {
-			logWarn("[butr] failed to persist active connector id:", error);
-		}
-	}
-	async clearAll() {
-		await Promise.all([
-			this.clearPool(),
-			this.persistent.removeItem(this.selectionKey),
-			this.persistent.removeItem(this.activeKey)
-		]);
-	}
-	/**
-	* Kept in the session driver so it survives remounts (unlike a ref)
-	* yet clears at session end (unlike the persistent driver): a manual
-	* disconnect must suppress auto-connect now, not forever.
-	*/
-	async isUserDisconnected() {
-		try {
-			return await this.session.getItem(this.userDisconnectedKey) === "true";
-		} catch {
-			return false;
+	};
+	const write = async (driver, key, value) => {
+		if (written.get(key) === value) return;
+		await (value === null ? driver.removeItem(key) : driver.setItem(key, value));
+		written.set(key, value);
+	};
+	return {
+		load: async () => {
+			const [pool, selection, active, userDisconnected] = await Promise.all([
+				read(persistent, keys.pool),
+				read(persistent, keys.selection),
+				read(persistent, keys.active),
+				read(session, keys.userDisconnected)
+			]);
+			return {
+				activeConnectorId: active === null || active === "" ? null : active,
+				isUserDisconnected: userDisconnected === "true",
+				pool: decodePool(pool),
+				selection: decodeSelection(selection)
+			};
+		},
+		save: async (state) => {
+			const failure = (await Promise.allSettled([
+				write(persistent, keys.pool, isEmpty(state.pool) ? null : JSON.stringify(state.pool)),
+				write(persistent, keys.selection, isEmpty(state.selection) ? null : JSON.stringify(state.selection)),
+				write(persistent, keys.active, state.activeConnectorId),
+				write(session, keys.userDisconnected, state.isUserDisconnected ? "true" : null)
+			])).find((result) => result.status === "rejected");
+			if (failure !== void 0) throw failure.reason;
 		}
-	}
-	async markUserDisconnected(value) {
-		try {
-			await (value ? this.session.setItem(this.userDisconnectedKey, "true") : this.session.removeItem(this.userDisconnectedKey));
-		} catch {}
-	}
+	};
 };
 
 //#endregion
 //#region src/store/connector-lifecycle.ts
 const createConnectorLifecycle = (handlers) => {
-	const unsubscribers = /* @__PURE__ */ new Map();
+	const live = /* @__PURE__ */ new Map();
 	const detach = (connectorId) => {
-		const unsub = unsubscribers.get(connectorId);
-		if (!unsub) return;
+		const subscription = live.get(connectorId);
+		if (subscription === void 0) return;
+		live.delete(connectorId);
 		try {
-			unsub();
+			subscription.unsubscribe();
 		} catch (error) {
 			logWarn("[butr] unsubscribe threw:", error);
 		}
-		unsubscribers.delete(connectorId);
 	};
-	return {
-		attach: (connectorId, connector) => {
-			if (!connector.subscribe) return;
+	const attach = (connectorId, connector) => {
+		if (connector.subscribe === void 0) return;
+		const disconnected = () => {
 			detach(connectorId);
-			try {
-				const unsub = connector.subscribe((event) => {
-					switch (event.type) {
-						case "accountChanged":
-							handlers.onAccountChanged(connectorId, event.accounts, event.account);
-							break;
-						case "disconnected":
-							detach(connectorId);
-							handlers.onDisconnected(connectorId, connector.chainPlatform);
-					}
-				});
-				unsubscribers.set(connectorId, unsub);
-			} catch (error) {
-				logWarn(`[butr] subscribe failed for ${connectorId}:`, error);
-			}
-		},
-		detach,
-		detachAll: () => {
-			const ids = [];
-			for (const id of unsubscribers.keys()) ids.push(id);
-			for (const id of ids) detach(id);
+			handlers.onDisconnected(connectorId);
+		};
+		try {
+			const unsubscribe = connector.subscribe((event) => {
+				if (live.get(connectorId)?.connector !== connector) return;
+				if (event.type === "disconnected" || event.accounts.length === 0) {
+					disconnected();
+					return;
+				}
+				handlers.onAccountsChanged(connectorId, event.accounts);
+			});
+			live.set(connectorId, {
+				connector,
+				unsubscribe
+			});
+		} catch (error) {
+			logWarn(`[butr] subscribe failed for ${connectorId}:`, error);
 		}
 	};
-};
-
-//#endregion
-//#region src/store/hydration.ts
-const VALID_CHAIN_PLATFORMS$1 = new Set(CHAIN_PLATFORMS);
-const isChainPlatform$1 = (value) => VALID_CHAIN_PLATFORMS$1.has(value);
-/** Pick the right `accounts` list: fresh from the connector if it
-*  exposes `getAccounts`, otherwise the persisted list, otherwise just
-*  the active account. */
-const resolveHydratedAccounts = async (connector, storedAccounts, fallbackAccount) => {
-	if (connector.getAccounts) {
-		const fresh = await connector.getAccounts().catch(() => null);
-		if (fresh && fresh.length > 0) return fresh;
-	}
-	if (storedAccounts.length > 0) return [...storedAccounts];
-	return [fallbackAccount];
-};
-const restoreOneEntry = async (connectorId, entry, connector) => {
-	try {
-		await connector.connect({ silent: true });
-		const accountToUse = await connector.getAccount() ?? entry.account;
-		return {
-			connectorId,
-			entry: {
-				account: accountToUse,
-				accounts: await resolveHydratedAccounts(connector, entry.accounts, accountToUse),
-				connector
-			},
-			kind: "ok"
-		};
-	} catch (error) {
-		return {
-			connectorId,
-			error,
-			kind: "fail"
-		};
-	}
-};
-const createHydrationCoordinator = (storage, createConnector) => {
-	const pending = /* @__PURE__ */ new Map();
 	return {
-		drainPending: async (connectorId) => {
-			const entry = pending.get(connectorId);
-			if (!entry) return null;
-			const connector = createConnector(connectorId);
-			if (!connector) return null;
-			const outcome = await restoreOneEntry(connectorId, entry, connector);
-			pending.delete(connectorId);
-			return outcome;
-		},
-		hydrate: async () => {
-			const [storedPool, storedSelection, storedActive, userDisconnected] = await Promise.all([
-				storage.getPool(),
-				storage.getSelection(),
-				storage.getActiveConnectorId(),
-				storage.isUserDisconnected()
-			]);
-			const pool = /* @__PURE__ */ new Map();
-			const dropped = [];
-			pending.clear();
-			const tasks = [];
-			for (const [connectorId, entry] of Object.entries(storedPool)) {
-				if (!entry) continue;
-				const connector = createConnector(connectorId);
-				if (!connector) {
-					pending.set(connectorId, entry);
-					continue;
-				}
-				tasks.push(restoreOneEntry(connectorId, entry, connector));
-			}
-			const outcomes = await Promise.all(tasks);
-			for (const outcome of outcomes) {
-				if (outcome.kind === "ok") {
-					pool.set(outcome.connectorId, outcome.entry);
-					continue;
-				}
-				dropped.push({
-					connectorId: outcome.connectorId,
-					reason: outcome.error
-				});
-			}
-			const selection = /* @__PURE__ */ new Map();
-			for (const [platform, connectorId] of Object.entries(storedSelection)) if (isChainPlatform$1(platform) && connectorId !== void 0 && pool.has(connectorId)) selection.set(platform, connectorId);
-			for (const [connectorId, wallet] of pool) {
-				const platform = wallet.connector.chainPlatform;
-				if (!selection.has(platform)) selection.set(platform, connectorId);
-			}
-			let activeConnectorId = null;
-			if (storedActive !== null && pool.has(storedActive)) activeConnectorId = storedActive;
-			else if (pool.size > 0) activeConnectorId = pool.keys().next().value ?? null;
-			return {
-				activeConnectorId,
-				dropped,
-				isUserDisconnected: userDisconnected,
-				pendingIds: [...pending.keys()],
-				pool,
-				selection
-			};
+		detachAll: () => {
+			for (const connectorId of live.keys()) detach(connectorId);
 		},
-		pendingIds: () => [...pending.keys()]
+		sync: (pool) => {
+			for (const [connectorId, subscription] of live) if (pool.get(connectorId)?.connector !== subscription.connector) detach(connectorId);
+			for (const [connectorId, wallet] of pool) if (!live.has(connectorId)) attach(connectorId, wallet.connector);
+		}
 	};
 };
 
+//#endregion
+//#region src/wallet-equal.ts
+/** Account ids are canonical (`buildAccount`), so identity is the id. */
+const accountsEqual = (a, b) => a === b || a.length === b.length && a.every((account, i) => account.id === b[i]?.id);
+/**
+* The adapter is compared by reference, not `connector.id`: hydration
+* swaps a shadow adapter for the live one under an unchanged id, and an
+* id check would strand consumers on the placeholder.
+*/
+const walletEqual = (a, b) => a === b || a !== void 0 && b !== void 0 && a.connector === b.connector && a.account.id === b.account.id && accountsEqual(a.accounts, b.accounts);
+
 //#endregion
 //#region src/store/reducer.ts
 const initialState = {
 	activeConnectorId: null,
+	adapters: [],
 	connectingConnectorId: null,
 	connectionError: null,
 	connectionStatus: "idle",
+	dormant: /* @__PURE__ */ new Map(),
 	isHydrated: false,
 	isUserDisconnected: false,
 	pool: /* @__PURE__ */ new Map(),
 	reconnectingIds: /* @__PURE__ */ new Set(),
 	selection: /* @__PURE__ */ new Map()
 };
-/** Find any connector in the pool serving a given platform. */
-const findConnectorForPlatform = (pool, chainPlatform) => {
-	for (const [id, wallet] of pool) if (wallet.connector.chainPlatform === chainPlatform) return id;
+const toStoredEntry = (connectorId, wallet) => ({
+	account: wallet.account,
+	accounts: wallet.accounts,
+	chainPlatform: wallet.connector.chainPlatform,
+	connectorId,
+	icon: wallet.connector.icon,
+	name: wallet.connector.name
+});
+const withEntry = (map, key, value) => new Map(map).set(key, value);
+const withoutKey = (map, key) => {
+	if (!map.has(key)) return map;
+	const next = new Map(map);
+	next.delete(key);
+	return next;
 };
-/** Pure reducer: every state transition is expressed as `(state, event) => state`.
-*  No I/O, no async, no side effects. Side effects live in the runtime. */
-const reducer = (state, event) => {
+const withoutId = (set, id) => {
+	if (!set.has(id)) return set;
+	const next = new Set(set);
+	next.delete(id);
+	return next;
+};
+const keepEntries = (map, keep) => {
+	const kept = [...map].filter(([key, value]) => keep(key, value));
+	return kept.length === map.size ? map : new Map(kept);
+};
+const keepIds = (set, keep) => {
+	const kept = [...set].filter(keep);
+	return kept.length === set.size ? set : new Set(kept);
+};
+const sameEntries = (a, b) => a.size === b.size && [...a].every(([key, value]) => b.get(key) === value);
+const reconcileSelection = (selection, pool) => {
+	const next = /* @__PURE__ */ new Map();
+	for (const [platform, id] of selection) if (pool.get(id)?.connector.chainPlatform === platform) next.set(platform, id);
+	for (const [id, wallet] of pool) if (!next.has(wallet.connector.chainPlatform)) next.set(wallet.connector.chainPlatform, id);
+	return sameEntries(next, selection) ? selection : next;
+};
+/**
+* The invariants every event relies on, enforced once after every event so
+* no case re-derives a fallback. Returns `state` itself when it already
+* holds, which keeps zustand from notifying.
+*/
+const reconcile = (state) => {
+	const { pool } = state;
+	const reconnectingIds = keepIds(state.reconnectingIds, (id) => pool.has(id));
+	const dormant = keepEntries(state.dormant, (id) => !pool.has(id) || reconnectingIds.has(id));
+	const selection = reconcileSelection(state.selection, pool);
+	const activeConnectorId = state.activeConnectorId !== null && pool.has(state.activeConnectorId) ? state.activeConnectorId : pool.keys().next().value ?? null;
+	if (reconnectingIds === state.reconnectingIds && dormant === state.dormant && selection === state.selection && activeConnectorId === state.activeConnectorId) return state;
+	return {
+		...state,
+		activeConnectorId,
+		dormant,
+		reconnectingIds,
+		selection
+	};
+};
+const applyStoredSelection = (selection, stored, pool) => {
+	let next = selection;
+	for (const [platform, id] of Object.entries(stored)) if (isChainPlatform(platform) && pool.get(id)?.connector.chainPlatform === platform) next = withEntry(next, platform, id);
+	return next;
+};
+const changeAccounts = (state, event) => {
+	const wallet = state.pool.get(event.connectorId);
+	const first = event.accounts.at(0);
+	if (wallet === void 0 || first === void 0) return state;
+	const account = event.active ?? event.accounts.find((a) => a.id === wallet.account.id) ?? first;
+	if (account.id === wallet.account.id && accountsEqual(event.accounts, wallet.accounts)) return state;
+	const updated = {
+		...wallet,
+		account,
+		accounts: event.accounts
+	};
+	return {
+		...state,
+		pool: withEntry(state.pool, event.connectorId, updated)
+	};
+};
+const apply = (state, event) => {
 	switch (event.type) {
+		case "ADAPTER_REGISTERED":
+			if (state.adapters.some((adapter) => adapter.id === event.adapter.id)) return state;
+			return {
+				...state,
+				adapters: [...state.adapters, event.adapter]
+			};
+		case "STORAGE_LOADED": {
+			const dormant = new Map(state.dormant);
+			for (const [id, entry] of Object.entries(event.entries)) if (entry !== void 0) dormant.set(id, entry);
+			return {
+				...state,
+				dormant,
+				isUserDisconnected: event.isUserDisconnected
+			};
+		}
+		case "ENTRY_RESTORED":
+			if (!state.dormant.has(event.connectorId)) return state;
+			return {
+				...state,
+				pool: withEntry(state.pool, event.connectorId, event.entry),
+				reconnectingIds: withoutId(state.reconnectingIds, event.connectorId)
+			};
+		case "RESTORE_FAILED":
+			if (!state.reconnectingIds.has(event.connectorId)) return state;
+			return {
+				...state,
+				pool: withoutKey(state.pool, event.connectorId),
+				reconnectingIds: withoutId(state.reconnectingIds, event.connectorId)
+			};
 		case "HYDRATED": {
-			const pool = new Map(state.pool);
-			for (const [id, entry] of event.pool) pool.set(id, entry);
-			for (const id of event.dropped) pool.delete(id);
-			const selection = new Map(state.selection);
-			for (const [platform, id] of event.selection) selection.set(platform, id);
-			let activeConnectorId = null;
-			if (event.activeConnectorId !== null && pool.has(event.activeConnectorId)) activeConnectorId = event.activeConnectorId;
-			else if (state.activeConnectorId !== null && pool.has(state.activeConnectorId)) activeConnectorId = state.activeConnectorId;
-			else if (pool.size > 0) activeConnectorId = pool.keys().next().value ?? null;
-			let nextReconnecting = state.reconnectingIds;
-			if (state.reconnectingIds.size > 0) {
-				const next = new Set(state.reconnectingIds);
-				for (const id of event.pool.keys()) next.delete(id);
-				for (const id of event.dropped) next.delete(id);
-				if (next.size !== state.reconnectingIds.size) nextReconnecting = next;
-			}
-			const selectionAfterDrop = new Map(selection);
-			for (const [platform, id] of selectionAfterDrop) if (!pool.has(id)) {
-				selectionAfterDrop.delete(platform);
-				const fallback = findConnectorForPlatform(pool, platform);
-				if (fallback !== void 0) selectionAfterDrop.set(platform, fallback);
-			}
+			const preferred = event.activeConnectorId;
 			return {
 				...state,
-				activeConnectorId,
+				activeConnectorId: preferred !== null && state.pool.has(preferred) ? preferred : state.activeConnectorId,
 				isHydrated: true,
-				isUserDisconnected: event.isUserDisconnected,
-				pool,
-				reconnectingIds: nextReconnecting,
-				selection: selectionAfterDrop
+				selection: applyStoredSelection(state.selection, event.selection, state.pool)
 			};
 		}
-		case "USER_DISCONNECTED_SET": return {
-			...state,
-			isUserDisconnected: event.value
-		};
 		case "CONNECT_STARTED": return {
 			...state,
 			connectingConnectorId: event.connectorId,
 			connectionError: null,
-			connectionStatus: "connecting"
+			connectionStatus: "connecting",
+			isUserDisconnected: false
 		};
 		case "CONNECT_SUCCEEDED": {
 			const { connectorId, entry } = event;
-			const existing = state.pool.get(connectorId);
-			const nextReconnecting = state.reconnectingIds.has(connectorId) ? new Set([...state.reconnectingIds].filter((id) => id !== connectorId)) : state.reconnectingIds;
-			if (existing && existing.account.walletAddress.toLowerCase() === entry.account.walletAddress.toLowerCase()) return {
-				...state,
-				activeConnectorId: connectorId,
-				connectingConnectorId: null,
-				connectionError: null,
-				connectionStatus: "success",
-				pool: existing.connector === entry.connector ? state.pool : new Map([...state.pool, [connectorId, entry]]),
-				reconnectingIds: nextReconnecting
-			};
-			const newPool = new Map([...state.pool, [connectorId, entry]]);
-			const newSelection = new Map([...state.selection, [entry.connector.chainPlatform, connectorId]]);
+			const isCurrentAttempt = state.connectingConnectorId === connectorId;
 			return {
 				...state,
 				activeConnectorId: connectorId,
-				connectingConnectorId: null,
-				connectionError: null,
-				connectionStatus: "success",
-				pool: newPool,
-				reconnectingIds: nextReconnecting,
-				selection: newSelection
-			};
-		}
-		case "ENTRY_RESTORED": {
-			const { connectorId, entry } = event;
-			const nextReconnecting = state.reconnectingIds.has(connectorId) ? new Set([...state.reconnectingIds].filter((id) => id !== connectorId)) : state.reconnectingIds;
-			const platform = entry.connector.chainPlatform;
-			const selection = state.selection.has(platform) ? state.selection : new Map([...state.selection, [platform, connectorId]]);
-			return {
-				...state,
-				activeConnectorId: state.activeConnectorId ?? connectorId,
-				pool: new Map([...state.pool, [connectorId, entry]]),
-				reconnectingIds: nextReconnecting,
-				selection
+				...isCurrentAttempt && {
+					connectingConnectorId: null,
+					connectionError: null,
+					connectionStatus: "success"
+				},
+				pool: withEntry(state.pool, connectorId, entry),
+				reconnectingIds: withoutId(state.reconnectingIds, connectorId),
+				selection: state.pool.has(connectorId) ? state.selection : withEntry(state.selection, entry.connector.chainPlatform, connectorId)
 			};
 		}
 		case "CONNECT_FAILED":
@@ -792,398 +728,424 @@ const reducer = (state, event) => {
 				connectionError: event.error,
 				connectionStatus: "error"
 			};
-		case "DISCONNECTED": {
-			const wallet = state.pool.get(event.connectorId);
-			if (!wallet) return state;
-			const newPool = new Map(state.pool);
-			newPool.delete(event.connectorId);
-			const newSelection = new Map(state.selection);
-			const platform = wallet.connector.chainPlatform;
-			if (newSelection.get(platform) === event.connectorId) {
-				newSelection.delete(platform);
-				const fallback = findConnectorForPlatform(newPool, platform);
-				if (fallback !== void 0) newSelection.set(platform, fallback);
-			}
-			const firstId = newPool.keys().next();
-			const activeConnectorId = state.activeConnectorId === event.connectorId ? firstId.value ?? null : state.activeConnectorId;
-			const nextReconnecting = state.reconnectingIds.has(event.connectorId) ? new Set([...state.reconnectingIds].filter((id) => id !== event.connectorId)) : state.reconnectingIds;
+		case "STATUS_RESET":
+			if (state.connectionStatus === "idle") return state;
 			return {
 				...state,
-				activeConnectorId,
-				pool: newPool,
-				reconnectingIds: nextReconnecting,
-				selection: newSelection
+				connectingConnectorId: null,
+				connectionError: null,
+				connectionStatus: "idle"
 			};
-		}
-		case "ACCOUNTS_REFRESHED": {
+		case "ACCOUNTS_CHANGED": return changeAccounts(state, event);
+		case "DISCONNECTED": {
+			const pool = withoutKey(state.pool, event.connectorId);
+			if (event.byUser) {
+				const dormant = pool.size === 0 ? keepEntries(state.dormant, () => false) : withoutKey(state.dormant, event.connectorId);
+				if (pool === state.pool && dormant === state.dormant && state.isUserDisconnected) return state;
+				return {
+					...state,
+					dormant,
+					isUserDisconnected: true,
+					pool
+				};
+			}
 			const wallet = state.pool.get(event.connectorId);
-			if (!wallet) return state;
-			let nextAccount;
-			if (event.active) nextAccount = event.active;
-			else nextAccount = event.accounts.some((a) => a.walletAddress === wallet.account.walletAddress && a.chain.id === wallet.account.chain.id) ? wallet.account : event.accounts[0] ?? wallet.account;
-			const sameAccount = nextAccount.walletAddress === wallet.account.walletAddress && nextAccount.chain.id === wallet.account.chain.id;
-			const sameAccountsShape = event.accounts.length === wallet.accounts.length && event.accounts.every((a, i) => a.walletAddress === wallet.accounts[i]?.walletAddress);
-			if (sameAccount && sameAccountsShape) return state;
-			const updated = {
-				...wallet,
-				account: nextAccount,
-				accounts: [...event.accounts]
-			};
-			const newPool = new Map([...state.pool, [event.connectorId, updated]]);
+			if (wallet === void 0) return state;
+			const stored = toStoredEntry(event.connectorId, wallet);
 			return {
 				...state,
-				pool: newPool
+				dormant: withEntry(state.dormant, event.connectorId, stored),
+				pool
 			};
 		}
-		case "WALLET_REFRESHED": {
-			const wallet = state.pool.get(event.connectorId);
-			if (!wallet) return state;
-			const newPool = new Map([...state.pool, [event.connectorId, { ...wallet }]]);
+		case "RESET": return {
+			...initialState,
+			adapters: state.adapters,
+			isHydrated: state.isHydrated,
+			isUserDisconnected: true
+		};
+		case "ACTIVE_CHANGED":
+			if (state.activeConnectorId === event.connectorId || !state.pool.has(event.connectorId)) return state;
 			return {
 				...state,
-				pool: newPool
+				activeConnectorId: event.connectorId
 			};
-		}
-		case "ACTIVE_CHANGED": return {
-			...state,
-			activeConnectorId: event.connectorId
-		};
-		case "SELECTION_CHANGED": {
-			const newSelection = new Map(state.selection);
-			if (event.connectorId === null) newSelection.delete(event.chainPlatform);
-			else newSelection.set(event.chainPlatform, event.connectorId);
+		case "SELECTION_CHANGED":
+			if (state.selection.get(event.chainPlatform) === event.connectorId || state.pool.get(event.connectorId)?.connector.chainPlatform !== event.chainPlatform) return state;
 			return {
 				...state,
-				selection: newSelection
+				selection: withEntry(state.selection, event.chainPlatform, event.connectorId)
 			};
-		}
-		case "STATUS_RESET": return {
-			...state,
-			connectingConnectorId: null,
-			connectionError: null,
-			connectionStatus: "idle"
-		};
-		case "ERROR_SET": return {
-			...state,
-			connectionError: event.error,
-			connectionStatus: event.error ? "error" : "idle"
-		};
-		case "RESET": return {
-			...initialState,
-			isHydrated: state.isHydrated,
-			isUserDisconnected: true,
-			reconnectingIds: /* @__PURE__ */ new Set()
-		};
 		default: return state;
 	}
 };
-
-//#endregion
-//#region src/store/wallet-store-helpers.ts
-/** Run an async operation fire-and-forget, calling onError if it throws. */
-const run = async (fn, onError) => {
-	try {
-		await fn();
-	} catch (error) {
-		onError(error);
-	}
+/** Pure: `(state, event) => state`. Side effects live in the manager. */
+const reducer = (state, event) => {
+	const next = apply(state, event);
+	return next === state ? state : reconcile(next);
 };
-
-//#endregion
-//#region src/store/wallet-store.ts
-const VALID_CHAIN_PLATFORMS = new Set(CHAIN_PLATFORMS);
-const isChainPlatform = (value) => VALID_CHAIN_PLATFORMS.has(value);
 /**
 * `isHydrated` is true from the first render on this path, so
-* `reconnectingIds` (not `isHydrated`) is the "is this connection
-* verified" signal until silent reconnect lands.
+* `reconnectingIds` says whether a connection is verified. Seeded entries
+* are also dormant: persisted, not yet live.
 */
-const seedStateFromSnapshot = (snapshot) => {
+const stateFromSnapshot = (snapshot) => {
 	const pool = /* @__PURE__ */ new Map();
-	const reconnectingIds = /* @__PURE__ */ new Set();
-	for (const [connectorId, entry] of Object.entries(snapshot.pool)) {
-		if (!entry) continue;
-		const connector = createShadowAdapter(entry);
+	const dormant = /* @__PURE__ */ new Map();
+	for (const [connectorId, entry] of Object.entries(snapshot.pool)) if (entry !== void 0) {
 		pool.set(connectorId, {
 			account: entry.account,
-			accounts: [...entry.accounts],
-			connector
+			accounts: entry.accounts,
+			connector: createShadowAdapter(entry)
 		});
-		reconnectingIds.add(connectorId);
+		dormant.set(connectorId, entry);
 	}
-	const selection = /* @__PURE__ */ new Map();
-	for (const [platform, connectorId] of Object.entries(snapshot.selection)) if (isChainPlatform(platform) && connectorId !== void 0 && pool.has(connectorId)) selection.set(platform, connectorId);
-	const activeConnectorId = snapshot.activeConnectorId !== null && pool.has(snapshot.activeConnectorId) ? snapshot.activeConnectorId : pool.keys().next().value ?? null;
-	return {
+	return reconcile({
 		...initialState,
-		activeConnectorId,
+		activeConnectorId: snapshot.activeConnectorId,
+		dormant,
 		isHydrated: true,
 		pool,
-		reconnectingIds,
-		selection
-	};
+		reconnectingIds: new Set(pool.keys()),
+		selection: applyStoredSelection(/* @__PURE__ */ new Map(), snapshot.selection, pool)
+	});
 };
+
+//#endregion
+//#region src/store/wallet-manager.ts
 const CONNECT_TIMEOUT_MS = 9e4;
+const RESTORE_TIMEOUT_MS = 15e3;
 const DEFAULT_SLOW_CONNECT_THRESHOLD_MS = 5e3;
-const normaliseAddress = (addr) => addr.toLowerCase();
-const createWalletStore = (config) => {
-	const storage = config.storage ?? new WalletStorage({ keyPrefix: config.storageKeyPrefix });
-	const reportStorageError = (context) => (error) => {
-		if (config.onStorageError) {
+const EMPTY_PERSISTED = {
+	activeConnectorId: null,
+	isUserDisconnected: false,
+	pool: {},
+	selection: {}
+};
+const toPersistedState = (state) => {
+	const pool = Object.fromEntries(state.dormant);
+	for (const [connectorId, wallet] of state.pool) pool[connectorId] = toStoredEntry(connectorId, wallet);
+	return {
+		activeConnectorId: state.activeConnectorId,
+		isUserDisconnected: state.isUserDisconnected,
+		pool,
+		selection: Object.fromEntries(state.selection)
+	};
+};
+const persistedSliceChanged = (state, prev) => state.pool !== prev.pool || state.dormant !== prev.dormant || state.selection !== prev.selection || state.activeConnectorId !== prev.activeConnectorId || state.isUserDisconnected !== prev.isUserDisconnected;
+const toError = (cause) => cause instanceof Error ? cause : new Error(String(cause));
+/** A consumer callback that throws must not break the manager. */
+const safely = (name, callback, ...args) => {
+	try {
+		callback?.(...args);
+	} catch (error) {
+		logWarn(`[butr] ${name} threw:`, error);
+	}
+};
+const withTimeout = async (promise, ms) => {
+	promise.catch(() => {});
+	let timer;
+	try {
+		return await Promise.race([promise, new Promise((_, reject) => {
+			timer = setTimeout(() => {
+				reject(new ConnectionError("Timeout", `Connection timed out after ${ms / 1e3}s`));
+			}, ms);
+		})]);
+	} finally {
+		clearTimeout(timer);
+	}
+};
+const teardown = async (connector) => {
+	try {
+		await connector.disconnect?.();
+	} catch (error) {
+		logWarn(`[butr] disconnect of ${connector.id} failed:`, error);
+	}
+};
+/**
+* Framework-free: React binds it through `WalletManagerProvider`, anything
+* else calls `start()` itself. Creating one has no side effects, so it is
+* safe during a server render.
+*/
+const createWalletManager = (config = {}, options = {}) => {
+	const storage = config.storage ?? createWalletStorage({ keyPrefix: config.storageKeyPrefix });
+	const store = createStore()(() => options.initialState ? stateFromSnapshot(options.initialState) : initialState);
+	const { getState } = store;
+	const dispatch = (event) => {
+		store.setState((state) => reducer(state, event), true);
+	};
+	const findAdapter = (connectorId) => getState().adapters.find((adapter) => adapter.id === connectorId);
+	const reportStorageError = (cause) => {
+		if (config.onStorageError) safely("onStorageError", config.onStorageError, toError(cause));
+		else logWarn("[butr] wallet persistence failed:", cause);
+	};
+	let persistEnabled = false;
+	let flushing = false;
+	let dirty = false;
+	const persist = async () => {
+		dirty = true;
+		if (flushing) return;
+		flushing = true;
+		while (dirty) {
+			dirty = false;
 			try {
-				config.onStorageError(error, context);
-			} catch (cbError) {
-				logWarn("[butr] onStorageError threw:", cbError);
+				await storage.save(toPersistedState(getState()));
+			} catch (error) {
+				reportStorageError(error);
 			}
-			return;
 		}
-		logWarn(`[butr] ${context}:`, error);
+		flushing = false;
 	};
-	const hydration = createHydrationCoordinator(storage, config.createConnector);
-	return createStore()((set, get) => {
-		const dispatch = (event) => {
-			set((prev) => reducer(prev, event), false);
-		};
-		const persistPool = () => run(() => storage.setPool(get().pool), reportStorageError("failed to persist pool"));
-		const persistSelection = () => run(() => storage.setSelection(get().selection), reportStorageError("failed to persist selection"));
-		const persistActive = () => run(() => storage.setActiveConnectorId(get().activeConnectorId), reportStorageError("failed to persist active connector"));
-		const refreshPoolEntry = (connectorId, accounts, active) => {
+	store.subscribe((state, prev) => {
+		if (persistEnabled && persistedSliceChanged(state, prev)) persist();
+	});
+	const lifecycle = createConnectorLifecycle({
+		onAccountsChanged: (connectorId, accounts) => {
 			dispatch({
 				accounts,
-				active,
+				active: accounts[0],
 				connectorId,
-				type: "ACCOUNTS_REFRESHED"
+				type: "ACCOUNTS_CHANGED"
 			});
-			persistPool();
-		};
-		const lifecycle = createConnectorLifecycle({
-			onAccountChanged: (connectorId, accounts, active) => {
-				refreshPoolEntry(connectorId, [...accounts], active);
-			},
-			onDisconnected: (connectorId, chainPlatform) => {
-				const wallet = get().pool.get(connectorId);
-				if (wallet) run(() => wallet.connector.disconnect?.() ?? Promise.resolve(), logError);
-				dispatch({
-					connectorId,
-					type: "DISCONNECTED"
-				});
-				config.onDisconnect?.(chainPlatform);
+		},
+		onDisconnected: (connectorId) => {
+			const wallet = getState().pool.get(connectorId);
+			if (wallet === void 0) return;
+			teardown(wallet.connector);
+			dispatch({
+				byUser: false,
+				connectorId,
+				type: "DISCONNECTED"
+			});
+			safely("onDisconnect", config.onDisconnect, wallet, { byUser: false });
+		}
+	});
+	const attempted = /* @__PURE__ */ new Set();
+	let loaded = false;
+	let hydration = null;
+	let userChose = false;
+	const choose = (event) => {
+		const before = getState();
+		dispatch(event);
+		if (getState() !== before) userChose = true;
+	};
+	const restore = async (connectorId) => {
+		const adapter = findAdapter(connectorId);
+		if (adapter === void 0 || attempted.has(connectorId) || !getState().dormant.has(connectorId)) return null;
+		attempted.add(connectorId);
+		try {
+			await withTimeout(adapter.connect({ silent: true }), RESTORE_TIMEOUT_MS);
+			const accounts = await adapter.getAccounts();
+			const account = accounts.at(0);
+			if (account === void 0) throw new ConnectionError("NotConnected", `${adapter.name} exposed no accounts`);
+			const wallet = {
+				account,
+				accounts,
+				connector: adapter
+			};
+			const before = getState();
+			dispatch({
+				connectorId,
+				entry: wallet,
+				type: "ENTRY_RESTORED"
+			});
+			if (getState() === before) {
+				if (!before.pool.has(connectorId)) await teardown(adapter);
+				return null;
 			}
+			safely("onConnect", config.onConnect, wallet, { reconnected: true });
+			return {
+				connectorId,
+				ok: true
+			};
+		} catch (error) {
+			dispatch({
+				connectorId,
+				type: "RESTORE_FAILED"
+			});
+			return {
+				connectorId,
+				error: toConnectionError(error),
+				ok: false
+			};
+		}
+	};
+	const restoreLate = async (connectorId) => {
+		const result = await restore(connectorId);
+		if (result?.ok === false) logWarn(`[butr] silent reconnect failed for ${connectorId}:`, result.error);
+	};
+	const hydrate = async () => {
+		let persisted = EMPTY_PERSISTED;
+		try {
+			persisted = await storage.load();
+		} catch (error) {
+			reportStorageError(error);
+		}
+		dispatch({
+			entries: persisted.pool,
+			isUserDisconnected: persisted.isUserDisconnected,
+			type: "STORAGE_LOADED"
 		});
-		return {
-			...config.initialState ? seedStateFromSnapshot(config.initialState) : initialState,
-			_config: config,
-			_storage: storage,
-			connectWallet: async (connectorId, onSuccess, onError) => {
-				get().setUserDisconnected(false);
-				const connector = config.createConnector(connectorId);
-				if (!connector) throw new Error(`Failed to create connector for ${connectorId}`);
-				dispatch({
+		loaded = true;
+		const ids = [...getState().dormant.keys()];
+		const restores = ids.map(restore);
+		const pendingIds = ids.filter((id) => !attempted.has(id));
+		const results = (await Promise.all(restores)).filter((result) => result !== null);
+		dispatch({
+			activeConnectorId: userChose ? null : persisted.activeConnectorId,
+			selection: userChose ? {} : persisted.selection,
+			type: "HYDRATED"
+		});
+		persistEnabled = true;
+		persist();
+		const outcome = {
+			dropped: results.flatMap((result) => result.ok ? [] : [{
+				connectorId: result.connectorId,
+				reason: result.error
+			}]),
+			pendingIds,
+			restoredIds: results.flatMap((result) => result.ok ? [result.connectorId] : [])
+		};
+		if (config.onHydrated) safely("onHydrated", config.onHydrated, outcome);
+		else for (const { connectorId, reason } of outcome.dropped) logWarn(`[butr] silent reconnect failed for ${connectorId}:`, reason);
+	};
+	const register = (adapter) => {
+		const before = getState();
+		dispatch({
+			adapter,
+			type: "ADAPTER_REGISTERED"
+		});
+		if (loaded && getState() !== before) restoreLate(adapter.id);
+	};
+	const subscribeSource = (source) => {
+		try {
+			return source(register);
+		} catch (error) {
+			logError("[butr] a wallet source threw on subscribe:", error);
+			return () => {};
+		}
+	};
+	return {
+		clearConnectionError: () => {
+			dispatch({ type: "STATUS_RESET" });
+		},
+		connect: async (connectorId) => {
+			dispatch({
+				connectorId,
+				type: "CONNECT_STARTED"
+			});
+			const slowTimer = config.onSlowConnect ? setTimeout(() => {
+				safely("onSlowConnect", config.onSlowConnect, connectorId);
+			}, config.slowConnectThresholdMs ?? DEFAULT_SLOW_CONNECT_THRESHOLD_MS) : void 0;
+			const connector = findAdapter(connectorId);
+			try {
+				if (connector === void 0) throw new ConnectionError("WalletNotFound", `No wallet adapter is registered as "${connectorId}"`);
+				await withTimeout(connector.connect(), CONNECT_TIMEOUT_MS);
+				const accounts = await connector.getAccounts();
+				const account = accounts.at(0);
+				if (account === void 0) throw new ConnectionError("NotConnected", `${connector.name} exposed no accounts`);
+				const wallet = {
+					account,
+					accounts,
+					connector
+				};
+				choose({
 					connectorId,
-					type: "CONNECT_STARTED"
+					entry: wallet,
+					type: "CONNECT_SUCCEEDED"
 				});
-				const slowThreshold = config.slowConnectThresholdMs ?? DEFAULT_SLOW_CONNECT_THRESHOLD_MS;
-				const slowTimer = config.onSlowConnect ? setTimeout(() => {
-					try {
-						config.onSlowConnect?.(connectorId);
-					} catch (cbError) {
-						logWarn("[butr] onSlowConnect threw:", cbError);
-					}
-				}, slowThreshold) : null;
-				let connectTimeoutId;
-				try {
-					const connectPromise = connector.connect();
-					connectPromise.catch(() => {});
-					await Promise.race([connectPromise, new Promise((_, reject) => {
-						connectTimeoutId = setTimeout(() => {
-							reject(/* @__PURE__ */ new Error("Connection timeout"));
-						}, CONNECT_TIMEOUT_MS);
-					})]);
-					const account = await connector.getAccount();
-					if (!account) throw new Error("Failed to get account");
-					const fetchedAccounts = connector.getAccounts ? await connector.getAccounts().catch(() => null) : null;
-					const entry = {
-						account,
-						accounts: fetchedAccounts && fetchedAccounts.length > 0 ? fetchedAccounts : [account],
-						connector
-					};
-					dispatch({
-						connectorId,
-						entry,
-						type: "CONNECT_SUCCEEDED"
-					});
-					lifecycle.attach(connectorId, connector);
-					await Promise.all([
-						persistPool(),
-						persistSelection(),
-						persistActive()
-					]);
-					config.onConnect?.(entry);
-					onSuccess?.(entry);
-				} catch (error) {
-					const normalised = mapConnectionError(error);
-					dispatch({
-						connectorId,
-						error: normalised,
-						type: "CONNECT_FAILED"
-					});
-					try {
-						await connector.disconnect?.();
-					} catch (disconnectError) {
-						logWarn("[butr] disconnect during error recovery failed:", disconnectError);
-					}
-					try {
-						config.onConnectError?.(normalised, connectorId);
-					} catch (cbError) {
-						logWarn("[butr] onConnectError threw:", cbError);
-					}
-					onError?.(error instanceof Error ? error : new Error(String(error)));
-					throw error;
-				} finally {
-					clearTimeout(connectTimeoutId);
-					if (slowTimer) clearTimeout(slowTimer);
-				}
-			},
-			disconnectWallet: (connectorId) => {
-				get().setUserDisconnected(true);
-				const state = get();
-				if (!state.isHydrated) return;
-				const wallet = state.pool.get(connectorId);
-				if (!wallet) return;
-				lifecycle.detach(connectorId);
-				run(() => wallet.connector.disconnect?.() ?? Promise.resolve(), logError);
-				const platform = wallet.connector.chainPlatform;
+				safely("onConnect", config.onConnect, wallet, { reconnected: false });
+				return wallet;
+			} catch (error) {
+				const failure = toConnectionError(error);
 				dispatch({
 					connectorId,
-					type: "DISCONNECTED"
+					error: failure,
+					type: "CONNECT_FAILED"
 				});
-				if (get().pool.size === 0) run(() => storage.clearAll(), reportStorageError("failed to clear storage"));
-				else {
-					run(() => storage.removePoolEntry(connectorId), reportStorageError("failed to remove pool entry"));
-					persistSelection();
-					persistActive();
-				}
-				config.onDisconnect?.(platform);
-			},
-			getConnectorInstance: (id) => config.createConnector(id),
-			hydrateWallets: async () => {
-				const result = await hydration.hydrate();
-				dispatch({
-					activeConnectorId: result.activeConnectorId,
-					dropped: result.dropped.map((d) => d.connectorId),
-					isUserDisconnected: result.isUserDisconnected,
-					pool: result.pool,
-					selection: result.selection,
-					type: "HYDRATED"
-				});
-				for (const [connectorId, wallet] of result.pool) lifecycle.attach(connectorId, wallet.connector);
-				await Promise.all([persistSelection(), persistActive()]);
-				for (const id of hydration.pendingIds()) run(() => get().tryRestoreFromPending(id), (e) => {
-					logWarn(`[butr] late restore rejected for ${id}:`, e);
-				});
-				if (config.onHydrated) try {
-					config.onHydrated({
-						dropped: result.dropped,
-						pendingIds: [...result.pendingIds],
-						restoredIds: [...result.pool.keys()]
-					});
-				} catch (cbError) {
-					logWarn("[butr] onHydrated threw:", cbError);
+				if (connector !== void 0 && getState().pool.get(connectorId)?.connector !== connector) await teardown(connector);
+				safely("onConnectError", config.onConnectError, failure, connectorId);
+				throw failure;
+			} finally {
+				clearTimeout(slowTimer);
+			}
+		},
+		disconnect: (connectorId) => {
+			const wallet = getState().pool.get(connectorId);
+			dispatch({
+				byUser: true,
+				connectorId,
+				type: "DISCONNECTED"
+			});
+			if (wallet !== void 0) {
+				teardown(wallet.connector);
+				safely("onDisconnect", config.onDisconnect, wallet, { byUser: true });
+			}
+		},
+		disconnectAll: () => {
+			const wallets = [...getState().pool.values()];
+			dispatch({ type: "RESET" });
+			for (const wallet of wallets) {
+				teardown(wallet.connector);
+				safely("onDisconnect", config.onDisconnect, wallet, { byUser: true });
+			}
+		},
+		getInitialState: store.getInitialState,
+		getState,
+		requestAccounts: async (connectorId) => {
+			const connector = getState().pool.get(connectorId)?.connector;
+			if (connector?.requestAccounts === void 0) return;
+			await connector.requestAccounts();
+			const accounts = await connector.getAccounts();
+			dispatch({
+				accounts,
+				connectorId,
+				type: "ACCOUNTS_CHANGED"
+			});
+		},
+		setAccount: (connectorId, account) => {
+			const wallet = getState().pool.get(connectorId);
+			const active = wallet?.accounts.find((candidate) => candidate.id === account.id);
+			if (wallet === void 0 || active === void 0) return;
+			dispatch({
+				accounts: wallet.accounts,
+				active,
+				connectorId,
+				type: "ACCOUNTS_CHANGED"
+			});
+		},
+		setActive: (connectorId) => {
+			choose({
+				connectorId,
+				type: "ACTIVE_CHANGED"
+			});
+		},
+		setSelection: (chainPlatform, connectorId) => {
+			choose({
+				chainPlatform,
+				connectorId,
+				type: "SELECTION_CHANGED"
+			});
+		},
+		start: () => {
+			const unsubscribes = (config.sources ?? []).map(subscribeSource);
+			lifecycle.sync(getState().pool);
+			const unsubscribePool = store.subscribe((state, prev) => {
+				if (state.pool !== prev.pool) lifecycle.sync(state.pool);
+			});
+			hydration ??= hydrate();
+			return () => {
+				for (const unsubscribe of unsubscribes) try {
+					unsubscribe();
+				} catch (error) {
+					logWarn("[butr] a wallet source threw on unsubscribe:", error);
 				}
-				else if (result.dropped.length > 0) for (const { connectorId, reason } of result.dropped) logWarn(`[butr] failed to restore connector ${connectorId}:`, reason);
-			},
-			refreshWallet: (connectorId) => {
-				dispatch({
-					connectorId,
-					type: "WALLET_REFRESHED"
-				});
-			},
-			requestAccounts: async (connectorId) => {
-				const entry = get().pool.get(connectorId);
-				if (!entry) return;
-				await entry.connector.requestAccounts?.();
-				const fresh = entry.connector.getAccounts ? await entry.connector.getAccounts().catch(() => null) : null;
-				if (!fresh || fresh.length === 0) return;
-				refreshPoolEntry(connectorId, fresh);
-			},
-			reset: () => {
-				get().setUserDisconnected(true);
-				const state = get();
-				if (!state.isHydrated) return;
+				unsubscribePool();
 				lifecycle.detachAll();
-				for (const wallet of state.pool.values()) run(() => wallet.connector.disconnect?.() ?? Promise.resolve(), logError);
-				run(() => storage.clearAll(), reportStorageError("failed to clear storage"));
-				if (config.onReset) {
-					const onReset = config.onReset;
-					run(() => Promise.resolve(onReset()), logError);
-				}
-				dispatch({ type: "RESET" });
-			},
-			resetConnectionStatus: () => {
-				dispatch({ type: "STATUS_RESET" });
-			},
-			setActiveConnector: (connectorId) => {
-				dispatch({
-					connectorId,
-					type: "ACTIVE_CHANGED"
-				});
-				persistActive();
-			},
-			setConnectionError: (error) => {
-				dispatch({
-					error,
-					type: "ERROR_SET"
-				});
-			},
-			setSelection: (chainPlatform, connectorId) => {
-				dispatch({
-					chainPlatform,
-					connectorId,
-					type: "SELECTION_CHANGED"
-				});
-				persistSelection();
-			},
-			setUserDisconnected: (value) => {
-				dispatch({
-					type: "USER_DISCONNECTED_SET",
-					value
-				});
-				run(() => storage.markUserDisconnected(value), reportStorageError("failed to persist disconnect intent"));
-			},
-			tryRestoreFromPending: async (connectorId) => {
-				const outcome = await hydration.drainPending(connectorId);
-				if (!outcome) return;
-				if (outcome.kind === "fail") {
-					logWarn(`[butr] late restore failed for ${connectorId}:`, outcome.error);
-					return;
-				}
-				dispatch({
-					connectorId,
-					entry: outcome.entry,
-					type: "ENTRY_RESTORED"
-				});
-				lifecycle.attach(connectorId, outcome.entry.connector);
-				await Promise.all([
-					persistPool(),
-					persistSelection(),
-					persistActive()
-				]);
-				config.onConnect?.(outcome.entry);
-			},
-			updateWalletAccount: (connectorId, account) => {
-				const entry = get().pool.get(connectorId);
-				if (!entry) return;
-				const newChain = account.chain;
-				const remapped = entry.accounts.map((a) => a.chain.id === newChain.id ? a : {
-					chain: newChain,
-					id: `${newChain.id}:${normaliseAddress(a.walletAddress)}`,
-					walletAddress: a.walletAddress
-				});
-				const accounts = remapped.some((a) => normaliseAddress(a.walletAddress) === normaliseAddress(account.walletAddress)) ? remapped : [...remapped, account];
-				refreshPoolEntry(connectorId, accounts, account);
-			}
-		};
-	});
+			};
+		},
+		subscribe: store.subscribe
+	};
 };
 
 //#endregion
@@ -1264,10 +1226,12 @@ const createCookieStorageDriver = (options = {}) => {
 
 //#endregion
 //#region src/storage/snapshot.ts
+const EMPTY_POOL = Object.freeze({});
+const EMPTY_SELECTION = Object.freeze({});
 const EMPTY_SNAPSHOT = Object.freeze({
 	activeConnectorId: null,
-	pool: Object.freeze({}),
-	selection: Object.freeze({})
+	pool: EMPTY_POOL,
+	selection: EMPTY_SELECTION
 });
 const toCookieMap = (input) => {
 	if (!(Symbol.iterator in input)) return new Map(Object.entries(input));
@@ -1298,7 +1262,7 @@ const readWalletSnapshot = (source, options = {}) => {
 	if (rawActive !== void 0 && rawActive.length > 0 && pool[rawActive] !== void 0) activeConnectorId = rawActive;
 	else {
 		const firstKey = Object.keys(pool)[0];
-		if (firstKey) activeConnectorId = firstKey;
+		if (firstKey !== void 0 && firstKey !== "") activeConnectorId = firstKey;
 	}
 	return {
 		activeConnectorId,
@@ -1432,7 +1396,7 @@ const base58ToBytes = (input) => {
 var SignInUnsupportedError = class extends Error {
 	connectorId;
 	constructor(connectorId) {
-		super(`Wallet "${connectorId}" reports capabilities.signMessage === false, so it cannot sign in.`);
+		super(`Wallet "${connectorId}" cannot sign messages, so it cannot sign in.`);
 		this.connectorId = connectorId;
 		this.name = "SignInUnsupportedError";
 	}
@@ -1448,12 +1412,11 @@ const createSignInFlow = (options) => {
 	const sign = async (wallet, account) => {
 		const { connector } = wallet;
 		const signingAccount = account ?? wallet.account;
-		if (!connector.capabilities.signMessage) throw new SignInUnsupportedError(connector.id);
-		const nonce = await options.getNonce({
-			account: signingAccount,
-			wallet
-		});
-		if (options.preferSignMessage !== true && connector.chainPlatform === "svm" && connector.capabilities.signIn && connector.signIn !== void 0) {
+		if (options.preferSignMessage !== true && connector.chainPlatform === "svm" && connector.signIn !== void 0) {
+			const nonce = await options.getNonce({
+				account: signingAccount,
+				wallet
+			});
 			const output = await connector.signIn({ nonce });
 			return {
 				account: output.account,
@@ -1465,12 +1428,17 @@ const createSignInFlow = (options) => {
 				wallet
 			};
 		}
+		if (connector.signMessage === void 0) throw new SignInUnsupportedError(connector.id);
+		const nonce = await options.getNonce({
+			account: signingAccount,
+			wallet
+		});
 		const message = buildMessage({
 			account: signingAccount,
 			nonce,
 			wallet
 		});
-		const { signature, signedMessage } = await connector.signMessage(new TextEncoder().encode(message), signingAccount);
+		const { signature, signedMessage } = await connector.signMessage(new TextEncoder().encode(message), { account: signingAccount });
 		return {
 			account: signingAccount,
 			message,
@@ -1489,19 +1457,6 @@ const createSignInFlow = (options) => {
 	} };
 };
 
-//#endregion
-//#region src/wallet-equal.ts
-/**
-* The adapter is compared by reference, not `connector.id`: hydration
-* swaps a shadow adapter for the live one under an unchanged id, and an
-* id check would strand consumers on the throwing placeholder.
-*/
-const walletEqual = (a, b) => {
-	if (a === b) return true;
-	if (!a || !b) return false;
-	return a.connector === b.connector && a.account.walletAddress === b.account.walletAddress && a.account.chain.id === b.account.chain.id;
-};
-
 //#endregion
 //#region src/sanitize-icon.ts
 /**
@@ -1516,5 +1471,5 @@ const sanitizeIcon = (icon) => {
 };
 
 //#endregion
-export { CHAIN_PLATFORMS, EMPTY_SNAPSHOT, ShadowConnectorError, SignInUnsupportedError, WalletStorage, base58ToBytes, base64ToBytes, buildAccount, buildChainsByPlatform, bytesToBase58, bytesToBase64, bytesToHex, bytesToHexPrefixed, createBrowserStorageDriver, createCookieStorageDriver, createMemoryStorageDriver, createSignInFlow, createWalletSource, createWalletStore, groupByPlatform, hexToBytes, isShadowAdapter, logError, logWarn, mapConnectionError, readWalletSnapshot, sanitizeIcon, walletEqual };
+export { BITCOIN_CHAINS, BITCOIN_CHAINS_LIST, CHAINS_BY_PLATFORM, CHAIN_PLATFORMS, ConnectionError, EMPTY_SNAPSHOT, EVM_CHAINS, EVM_CHAINS_LIST, POLKADOT_CHAINS, POLKADOT_CHAINS_LIST, SUI_CHAINS, SUI_CHAINS_LIST, SVM_CHAINS, SVM_CHAINS_LIST, ShadowConnectorError, SignInUnsupportedError, accountsEqual, base58ToBytes, base64ToBytes, buildAccount, bytesToBase58, bytesToBase64, bytesToHex, bytesToHexPrefixed, createBrowserStorageDriver, createCookieStorageDriver, createMemoryStorageDriver, createSignInFlow, createWalletManager, createWalletStorage, fromAdapters, groupByPlatform, hexToBytes, isChainPlatform, isPlatformWallet, logError, logWarn, readWalletSnapshot, resolveChain, sanitizeIcon, toConnectionError, walletEqual };
 //# sourceMappingURL=index.js.map