@qntx/wallet-engine 0.6.0 → 0.7.0

package/dist/index.mjs

@@ -1,19 +1,20 @@
-import { A as parseWith, M as INSTALL_ID_HEADER, c as networkById, i as servedNetworksResponse, t as networksPath, u as esploraBasePath, x as rpcPath } from "./contract-D5pguqiZ.mjs";
+import { A as rpcPath, C as EVM_RPC_METHODS, I as parseWith, c as networkById, i as servedNetworksResponse, t as networksPath, u as esploraBasePath, v as INSTALL_ID_HEADER } from "./contract-CEsgLme3.mjs";
 import { createStore } from "zustand/vanilla";
+import { bytesToHex, hexToBytes, utf8ToBytes } from "@noble/hashes/utils.js";
+import { ChainError } from "@qntx/wallet-chains";
+import { WalletError, parseBackupHeader } from "@qntx/wallet";
 import { Address, OutScript, Transaction } from "@scure/btc-signer";
 import { SparkInputError, bitcoinAddressScript, createSparkClient, decodeBolt11, decodeSparkAddress, encodeSparkAddress, parseSparkInvoice, uuidv7 } from "@qntx/spark";
 import { BITCOIN_NETWORKS, bitcoinAddressFromXpub, bitcoinNetwork, bitcoinPubkeyFromXpub, decodeBitcoinPsbt } from "@qntx/wallet-chains/bitcoin";
-import { checksumEvmAddress, decodeEvm, isEvmAddress } from "@qntx/wallet-chains/evm";
+import { checksumEvmAddress, decodeEvm, isEvmAddress, normalizeEvm } from "@qntx/wallet-chains/evm";
 import { PROGRAM_IDS, decodeSolana, isSolanaAddress, netAfterTransferFee, parseMintExtensions } from "@qntx/wallet-chains/solana";
-import { WalletError, parseBackupHeader } from "@qntx/wallet";
-import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";
 import { decodeLnurl, encodeLnurl, lightningAddressUrl, registerLightningAddress, requestInvoice, resolveLnurl, submitWithdraw, unregisterLightningAddress } from "@qntx/spark/lnurl";
 import { signedMatchesUnsigned, verifyEvent } from "@qntx/nostr";
 import { makeZapRequest } from "@qntx/nostr/nips/nip57";
+import { chains } from "@qntx/wallet/chains";
 import { nostr } from "@qntx/wallet/nostr";
 import { spark } from "@qntx/wallet/spark";
 import { createPublicClient, decodeFunctionResult, encodeFunctionData, fallback, http, isAddress, isHex, numberToHex } from "viem";
-import { chains } from "@qntx/wallet/chains";
 import { sha256 } from "@noble/hashes/sha2.js";
 import { base64, hex } from "@scure/base";
 import { p2wpkh } from "@scure/btc-signer/payment.js";
@@ -22,7 +23,7 @@ import { getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction }
 import { getTransferSolInstruction } from "@solana-program/system";
 import { TOKEN_PROGRAM_ADDRESS, findAssociatedTokenPda, getCreateAssociatedTokenIdempotentInstruction, getTransferCheckedInstruction } from "@solana-program/token";
 import { address, appendTransactionMessageInstructions, blockhash, compileTransactionMessage, createNoopSigner, createTransactionMessage, getCompiledTransactionMessageEncoder, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash } from "@solana/kit";
-//#region src/controller.ts
+// src/controller.ts
 /**
 * Controller base: a zustand vanilla store plus lifecycle. `update` applies a recipe that must
 * return a NEW state object; returning the same reference is a no-op (no set, no notification).
@@ -42,8 +43,7 @@ var Controller = class {
 		this.store.setState((state) => recipe(state));
 	}
 };
-//#endregion
-//#region src/events.ts
+// src/events.ts
 function createEventBus(logger) {
 	const listeners = /* @__PURE__ */ new Map();
 	return {
@@ -70,8 +70,7 @@ function createEventBus(logger) {
 		}
 	};
 }
-//#endregion
-//#region src/errors.ts
+// src/errors.ts
 /** Typed engine errors: store codes are `closed` and `integrity` (decrypt or bind failure). */
 var EngineStoreError = class extends Error {
 	code;
@@ -81,14 +80,12 @@ var EngineStoreError = class extends Error {
 		this.code = code;
 	}
 };
-//#endregion
-//#region src/store/guard.ts
+// src/store/guard.ts
 /** NUL is the composite-key/AAD separator — a name or key containing it collides. */
 function checkName(kind, value) {
 	if (value.includes("\0")) throw new EngineStoreError("invalid-input", `${kind} must not contain NUL`);
 }
-//#endregion
-//#region src/store/memory.ts
+// src/store/memory.ts
 /** In-memory EngineStore: the Node/test implementation — same contract, no durability. */
 function createMemoryEngineStore(backing) {
 	const collections = backing?.collections ?? /* @__PURE__ */ new Map();
@@ -133,318 +130,357 @@ function createMemoryEngineStore(backing) {
 		}
 	};
 }
-//#endregion
-//#region src/addresses/errors.ts
-var AddressBookError = class extends Error {
-	category;
-	constructor(category, message) {
+// src/connect/errors.ts
+/** EIP-1193 / EIP-1474 / EIP-3326 error: `code` is what the page's promise rejects with. */
+var ProviderError = class extends Error {
+	code;
+	constructor(code, message) {
 		super(message);
-		this.name = "AddressBookError";
-		this.category = category;
+		this.name = "ProviderError";
+		this.code = code;
 	}
 };
-//#endregion
-//#region src/addresses/normalize.ts
-/**
-* The canonical form of `address` for its family — EIP-55 for EVM, the re-encoded form for bitcoin
-* (accepted on any known bitcoin network, since a contact is not tied to the wallet's network) and
-* Spark (identity key only, no invoice fields) — or `undefined` when it is not a valid address.
-*/
-function normalizeAddress(family, address) {
-	try {
-		if (family === "evm") return isEvmAddress(address) ? checksumEvmAddress(address) : void 0;
-		if (family === "solana") return isSolanaAddress(address) ? address : void 0;
-		if (family === "spark") {
-			const decoded = decodeSparkAddress(address);
-			return encodeSparkAddress({
-				network: decoded.network,
-				identityPublicKey: decoded.identityPublicKey
-			});
-		}
-		for (const network of Object.values(BITCOIN_NETWORKS)) try {
-			const codec = Address(network.params);
-			return codec.encode(codec.decode(address));
-		} catch {}
-		return;
-	} catch {
-		return;
-	}
-}
-//#endregion
-//#region src/addresses/record.ts
+const userRejectedRequest = (message = "user rejected the request") => new ProviderError(4001, message);
+const unauthorized = (message = "not authorized") => new ProviderError(4100, message);
+const unsupportedMethod = (method) => new ProviderError(4200, `${method} is not supported`);
+const unrecognizedChain = (message = "unrecognized chain") => new ProviderError(4902, message);
+const invalidParams = (message) => new ProviderError(-32602, message);
+const requestPending = (message) => new ProviderError(-32002, message);
+const internalError = (message) => new ProviderError(-32603, message);
+// src/connect/controller.ts
 /**
-* The address-book record shared by the controller, the sync merge and the metadata document: a
-* live entry, or a tombstone that carries a deletion to the other devices.
+* DApp connections (CAIP-25 style sessions): one session per origin, authorization by network,
+* account and method, persisted in the engine store and cleared from memory on lock. A connection
+* is approved from a pending queue, by id, like any other request; locking rejects all of it.
 */
-const isTombstone = (record) => "deleted" in record;
-const isFamily = (v) => v === "evm" || v === "solana" || v === "bitcoin" || v === "spark";
-const ENTRY_KEYS = /* @__PURE__ */ new Set([
-	"id",
-	"name",
-	"family",
-	"address",
-	"note",
-	"createdAt",
-	"updatedAt"
-]);
-const TOMBSTONE_KEYS = /* @__PURE__ */ new Set([
-	"id",
-	"deleted",
-	"updatedAt"
-]);
-const isObject$12 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-const isNonNegativeInt$2 = (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
-/** Trimmed name, or `undefined` when it is not 1 to {@link NAME_MAX} characters. */
-const cleanName = (raw) => {
-	const name = raw.trim();
-	return name.length > 0 && name.length <= 32 ? name : void 0;
+const COLLECTION$4 = "connections";
+/** `lastUsedAt` is rewritten at most this often. */
+const TOUCH_INTERVAL_MS = 6e4;
+/** Granted for every network a session covers. */
+const SESSION_METHODS = [
+	"eth_sendTransaction",
+	"personal_sign",
+	"eth_signTypedData_v4"
+];
+const SESSION_NOTIFICATIONS = ["accountsChanged", "chainChanged"];
+/** `eip155:1` → 1; `undefined` for anything that is not an EVM network. */
+const evmChainId = (network) => {
+	const match = /^eip155:(\d+)$/.exec(network);
+	const id = match?.[1] === void 0 ? void 0 : Number(match[1]);
+	return id !== void 0 && Number.isSafeInteger(id) ? id : void 0;
 };
-/** Trimmed note; an empty one means no note. `undefined` return with `ok: false` when too long. */
-const cleanNote = (raw) => {
-	const note = raw?.trim();
-	if (note === void 0 || note.length === 0) return {
-		ok: true,
-		note: void 0
-	};
-	return note.length <= 120 ? {
-		ok: true,
-		note
-	} : { ok: false };
+const caip10 = (network, address) => `${network}:${address}`;
+const addressOf$1 = (account) => account.slice(account.lastIndexOf(":") + 1);
+const isObject$14 = (v) => typeof v === "object" && v !== null;
+const isSession = (value) => {
+	if (!isObject$14(value) || !isObject$14(value["origin"]) || !isObject$14(value["scopes"])) return false;
+	return typeof value["id"] === "string" && value["origin"]["kind"] === "browser" && typeof value["origin"]["origin"] === "string" && typeof value["currentNetwork"] === "string" && typeof value["createdAt"] === "number" && typeof value["lastUsedAt"] === "number";
 };
-const hasOnly = (value, keys) => Object.keys(value).every((k) => keys.has(k));
-/**
-* Strict decode with the controller's rules; the address is re-normalized. Anything else is
-* `undefined`.
-*/
-function decodeRecord(value) {
-	if (!isObject$12(value) || typeof value["id"] !== "string" || !isNonNegativeInt$2(value["updatedAt"])) return;
-	if ("deleted" in value) return value["deleted"] === true && hasOnly(value, TOMBSTONE_KEYS) ? {
-		id: value["id"],
-		deleted: true,
-		updatedAt: value["updatedAt"]
-	} : void 0;
-	const { family, name, address, note } = value;
-	if (!hasOnly(value, ENTRY_KEYS) || !isFamily(family) || typeof name !== "string" || typeof address !== "string" || !isNonNegativeInt$2(value["createdAt"]) || note !== void 0 && typeof note !== "string") return;
-	const cleanedName = cleanName(name);
-	const normalized = normalizeAddress(family, address);
-	const cleanedNote = cleanNote(note);
-	if (cleanedName === void 0 || normalized === void 0 || !cleanedNote.ok || note !== void 0 && cleanedNote.note === void 0) return;
-	return {
-		id: value["id"],
-		name: cleanedName,
-		family,
-		address: normalized,
-		...cleanedNote.note === void 0 ? {} : { note: cleanedNote.note },
-		createdAt: value["createdAt"],
-		updatedAt: value["updatedAt"]
-	};
-}
-const serialized = (record) => JSON.stringify(record);
-/** The winner of two versions of one id: larger `updatedAt`, then the larger serialization. */
-function pickWinner(a, b) {
-	if (a.updatedAt !== b.updatedAt) return a.updatedAt > b.updatedAt ? a : b;
-	return serialized(a) >= serialized(b) ? a : b;
-}
-const pruneTombstones = (records, now) => records.filter((r) => !isTombstone(r) || now - r.updatedAt <= 7776e6);
-/** Newest first, id as the tiebreak, so every device orders (and truncates) the same way. */
-const newestFirst = (a, b) => b.updatedAt - a.updatedAt || (a.id < b.id ? -1 : 1);
-/** Drops the oldest tombstones until at most `max` records remain, or no tombstone is left. */
-function evictTombstones(records, max) {
-	const excess = records.length - max;
-	if (excess <= 0) return records;
-	const oldest = new Set(records.filter(isTombstone).sort((a, b) => a.updatedAt - b.updatedAt || (a.id < b.id ? -1 : 1)).slice(0, excess).map((r) => r.id));
-	return records.filter((r) => !oldest.has(r.id));
-}
-/** {@link mergeRecords}, also counting the live entries the cap forced out. */
-function mergeWithReport(local, remote, now) {
-	const byId = /* @__PURE__ */ new Map();
-	for (const record of [...local, ...remote]) {
-		const existing = byId.get(record.id);
-		byId.set(record.id, existing === void 0 ? record : pickWinner(existing, record));
-	}
-	const live = /* @__PURE__ */ new Map();
-	const kept = [];
-	for (const record of [...pruneTombstones([...byId.values()], now)].sort(newestFirst)) {
-		if (isTombstone(record)) {
-			kept.push(record);
-			continue;
-		}
-		const key = `${record.family}:${record.address}`;
-		if (!live.has(key)) {
-			live.set(key, record);
-			kept.push(record);
-		}
-	}
-	const evicted = evictTombstones(kept, 128);
-	return {
-		records: [...evicted.slice(0, 128)].sort((a, b) => a.id < b.id ? -1 : 1),
-		droppedLive: evicted.slice(128).filter((r) => !isTombstone(r)).length
-	};
-}
-//#endregion
-//#region src/addresses/controller.ts
-/**
-* Address book: named recipients, validated and normalized per chain family, persisted in the
-* engine store and cleared from memory on lock. Deletions are kept as tombstones so they reach the
-* other devices; `syncEntries`/`merge` are the whole surface the metadata sync needs. Request risk
-* checks treat its addresses as known.
-*/
-const COLLECTION$3 = "contacts";
-const entriesOf = (records) => Object.fromEntries(records.flatMap((r) => isTombstone(r) ? [] : [[r.id, r]]));
-var AddressBookController = class extends Controller {
+var ConnectionController = class extends Controller {
 	options;
 	engineStore;
-	/** Every record, tombstones included, by id. */
-	records = /* @__PURE__ */ new Map();
+	waiters = /* @__PURE__ */ new Map();
+	group;
 	constructor(options) {
 		super({
-			name: "address-book",
-			defaultState: () => ({ entries: {} })
+			name: "connections",
+			defaultState: () => ({
+				sessions: {},
+				pending: {}
+			})
 		});
 		this.options = options;
 	}
 	async init() {
 		const store = await this.options.openStore();
 		this.engineStore = store;
-		const collection = store.collection(COLLECTION$3);
+		this.group = void 0;
+		const collection = store.collection(COLLECTION$4);
 		const keys = await collection.list();
 		const rows = await Promise.all(keys.map(async (key) => collection.get(key)));
-		const records = /* @__PURE__ */ new Map();
-		for (const raw of rows) {
-			if (raw === void 0) continue;
-			const record = decodeRecord(JSON.parse(new TextDecoder().decode(raw)));
-			if (record === void 0) this.options.logger.warn("address book record skipped: malformed");
-			else records.set(record.id, record);
+		const now = this.options.now();
+		const sessions = {};
+		const expired = [];
+		for (const [index, raw] of rows.entries()) {
+			const key = keys[index];
+			if (raw === void 0 || key === void 0) continue;
+			const parsed = JSON.parse(new TextDecoder().decode(raw));
+			if (!isSession(parsed)) {
+				this.options.logger.warn("connection session skipped: malformed");
+				expired.push(key);
+			} else if (now - parsed.lastUsedAt > 7776e6) expired.push(key);
+			else sessions[parsed.id] = parsed;
 		}
-		this.records = records;
-		this.update(() => ({ entries: entriesOf([...records.values()]) }));
+		await Promise.all(expired.map(async (key) => collection.delete(key)));
+		this.update(() => ({
+			sessions,
+			pending: {}
+		}));
 	}
 	async destroy() {
 		this.lock();
 		await Promise.resolve();
 	}
+	/** Locking is not consent: every pending connection is rejected. */
 	lock() {
 		this.engineStore = void 0;
-		this.records = /* @__PURE__ */ new Map();
-		this.update(() => ({ entries: {} }));
+		this.group = void 0;
+		for (const waiter of this.waiters.values()) waiter.reject(userRejectedRequest("the wallet was locked"));
+		this.waiters.clear();
+		this.update(() => ({
+			sessions: {},
+			pending: {}
+		}));
 	}
-	/** Entries and tombstones, for the metadata document. */
-	syncEntries() {
-		return [...this.records.values()].sort((a, b) => a.id < b.id ? -1 : 1);
+	/** Throws `4100` unless `origin` is `https://host[:port]` (or localhost in development). */
+	checkOrigin(origin) {
+		let url;
+		try {
+			url = new URL(origin);
+		} catch {
+			throw unauthorized("invalid origin");
+		}
+		const localhost = url.protocol === "http:" && url.hostname === "localhost";
+		if (url.origin !== origin || url.protocol !== "https:" && !(localhost && this.options.allowLocalhost)) throw unauthorized("origin not allowed");
+		return {
+			kind: "browser",
+			origin
+		};
+	}
+	session(origin) {
+		return Object.values(this.getState().sessions).find((s) => s.origin.origin === origin);
+	}
+	pending() {
+		return Object.values(this.getState().pending);
+	}
+	/** The group sessions are bound to: the host's last `setActiveGroup`, else the app's selection. */
+	activeGroup() {
+		return this.group ?? this.options.selectedGroup();
+	}
+	/** Whether `network` is an EVM network the wallet has enabled. */
+	isEnabled(network) {
+		return this.options.enabledNetworks().includes(network);
+	}
+	/** The origin's authorized addresses on its current network; empty when not connected. */
+	accounts(origin) {
+		const session = this.session(origin);
+		return session?.scopes[session.currentNetwork]?.accounts.map(addressOf$1) ?? [];
+	}
+	/** Throws `4100` unless the origin's session covers `method` on `network`. */
+	authorize(origin, network, method) {
+		const session = this.session(origin);
+		const scope = session?.scopes[network];
+		if (session === void 0 || scope === void 0 || !scope.methods.includes(method)) throw unauthorized();
+		return session;
+	}
+	/** Resolves with the session once the host approves; rejects with `4001` when it refuses. */
+	async request(origin, kind, network) {
+		if (this.engineStore === void 0) throw userRejectedRequest("the wallet is locked");
+		if (this.pending().some((p) => p.origin.origin === origin)) throw requestPending("a connection request is already pending");
+		const id = `conn-${[...this.options.random(8)].map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+		const entry = {
+			id,
+			origin: {
+				kind: "browser",
+				origin
+			},
+			kind,
+			...network === void 0 ? {} : { network },
+			createdAt: this.options.now()
+		};
+		return new Promise((resolve, reject) => {
+			this.waiters.set(id, {
+				resolve,
+				reject
+			});
+			this.update((s) => ({
+				...s,
+				pending: {
+					...s.pending,
+					[id]: entry
+				}
+			}));
+		});
 	}
 	/**
-	* Merges records from another device (last writer wins, tombstones win over older entries).
-	* Returns whether anything local changed and whether the merged set holds something `remote`
-	* lacks, i.e. whether the remote copy needs a newer publish.
+	* The host's approval, by id: the accounts granted (EVM addresses of the active group) and the
+	* network.
 	*/
-	async merge(remote) {
+	async approveConnection(id, grant) {
 		const store = this.requireStore();
-		const before = JSON.stringify(this.syncEntries());
-		const { records: merged, droppedLive } = mergeWithReport(this.syncEntries(), remote, this.options.now());
-		if (droppedLive > 0) this.options.logger.warn(`address book sync: ${droppedLive} contacts dropped, over the 128-record cap`);
-		const remoteSorted = JSON.stringify([...remote].sort((a, b) => a.id < b.id ? -1 : 1));
-		const localNewer = JSON.stringify(merged) !== remoteSorted;
-		if (JSON.stringify(merged) === before) return {
-			changed: false,
-			localNewer
+		const entry = this.getState().pending[id];
+		const waiter = this.waiters.get(id);
+		if (entry === void 0 || waiter === void 0) throw new Error(`unknown connection request ${id}`);
+		if (entry.kind === "network" && entry.network !== grant.network) throw new Error(`connection request ${id} is for ${String(entry.network)}`);
+		if (evmChainId(grant.network) === void 0 || !this.options.enabledNetworks().includes(grant.network)) throw invalidParams(`${grant.network} is not an enabled EVM network`);
+		const group = this.activeGroup();
+		if (group === void 0) throw new Error("no account group is selected");
+		const own = (await this.options.evmAddress(group, grant.network)).toLowerCase();
+		if (grant.accounts.length === 0 || grant.accounts.some((a) => a.toLowerCase() !== own)) throw invalidParams("only the active group's account can be granted");
+		if (this.getState().pending[id] === void 0) throw new Error(`connection request ${id} is no longer pending`);
+		const now = this.options.now();
+		const existing = this.session(entry.origin.origin);
+		const scope = {
+			accounts: [caip10(grant.network, own)],
+			methods: SESSION_METHODS,
+			notifications: SESSION_NOTIFICATIONS
 		};
-		const collection = store.collection(COLLECTION$3);
-		const next = new Map(merged.map((r) => [r.id, r]));
-		await Promise.all([...merged.map(async (r) => collection.put(r.id, new TextEncoder().encode(JSON.stringify(r)))), ...[...this.records.keys()].filter((id) => !next.has(id)).map(async (id) => collection.delete(id))]);
-		this.records = next;
-		this.update(() => ({ entries: entriesOf(merged) }));
-		return {
-			changed: true,
-			localNewer
+		const session = {
+			id: existing?.id ?? `session-${[...this.options.random(8)].map((b) => b.toString(16).padStart(2, "0")).join("")}`,
+			origin: entry.origin,
+			scopes: {
+				...existing?.scopes,
+				[grant.network]: scope
+			},
+			currentNetwork: grant.network,
+			createdAt: existing?.createdAt ?? now,
+			lastUsedAt: now
 		};
-	}
-	async add(params) {
+		await this.persist(store, session);
+		this.dropPending(id);
+		if (existing !== void 0 && existing.currentNetwork !== grant.network) this.options.invalidate(entry.origin.origin);
+		waiter.resolve(session);
+		return session;
+	}
+	rejectConnection(id) {
+		const waiter = this.waiters.get(id);
+		if (this.getState().pending[id] === void 0 || waiter === void 0) throw new Error(`unknown connection request ${id}`);
+		this.dropPending(id);
+		waiter.reject(userRejectedRequest());
+	}
+	/** Ends the origin's session; its pending connection and unfinished requests are void. */
+	async revoke(origin) {
 		const store = this.requireStore();
-		const name = cleanName(params.name);
-		if (name === void 0) throw new AddressBookError("invalid-input", `name must be 1 to 32 characters`);
-		const note = this.checkedNote(params.note);
-		const address = normalizeAddress(params.family, params.address.trim());
-		if (address === void 0) throw new AddressBookError("invalid-input", `not a valid ${params.family} address`);
-		if (Object.values(this.getState().entries).some((e) => e.family === params.family && e.address === address)) throw new AddressBookError("duplicate", "this address is already in the address book");
-		if (this.records.size >= 128) {
-			const kept = evictTombstones([...this.records.values()], 127);
-			if (kept.length >= 128) throw new AddressBookError("limit", `the address book holds at most 128 contacts`);
-			const keptIds = new Set(kept.map((r) => r.id));
-			await Promise.all([...this.records.keys()].filter((id) => !keptIds.has(id)).map(async (id) => store.collection(COLLECTION$3).delete(id)));
-			this.records = new Map(kept.map((r) => [r.id, r]));
+		for (const p of this.pending().filter((x) => x.origin.origin === origin)) {
+			const waiter = this.waiters.get(p.id);
+			this.dropPending(p.id);
+			waiter?.reject(userRejectedRequest("the connection was revoked"));
 		}
-		const now = this.options.now();
-		const entry = {
-			id: `contact-${[...this.options.random(8)].map((b) => b.toString(16).padStart(2, "0")).join("")}`,
-			name,
-			family: params.family,
-			address,
-			...note === void 0 ? {} : { note },
-			createdAt: now,
-			updatedAt: now
-		};
-		await this.persist(store, entry);
-		return entry;
+		const session = this.session(origin);
+		if (session !== void 0) {
+			await store.collection(COLLECTION$4).delete(session.id);
+			this.update((s) => {
+				const { [session.id]: _gone, ...sessions } = s.sessions;
+				return {
+					...s,
+					sessions
+				};
+			});
+		}
+		this.options.invalidate(origin);
 	}
-	async rename(id, name) {
+	/** Switches within the session's scope; the origin's unfinished requests are void. */
+	async setCurrentNetwork(origin, network) {
 		const store = this.requireStore();
-		const existing = this.requireEntry(id);
-		const cleaned = cleanName(name);
-		if (cleaned === void 0) throw new AddressBookError("invalid-input", `name must be 1 to 32 characters`);
-		const entry = {
-			...existing,
-			name: cleaned,
-			updatedAt: this.options.now()
-		};
-		await this.persist(store, entry);
-		return entry;
+		const session = this.session(origin);
+		if (session === void 0 || session.scopes[network] === void 0) throw unauthorized();
+		await this.persist(store, {
+			...session,
+			currentNetwork: network
+		});
+		this.options.invalidate(origin);
 	}
-	/** Sets or clears (empty or `undefined`) the note. */
-	async setNote(id, note) {
-		const store = this.requireStore();
-		const existing = this.requireEntry(id);
-		const cleaned = this.checkedNote(note);
-		const { note: _previous, ...rest } = existing;
-		const entry = {
-			...rest,
-			...cleaned === void 0 ? {} : { note: cleaned },
-			updatedAt: this.options.now()
-		};
-		await this.persist(store, entry);
-		return entry;
-	}
-	/** Removes the entry, leaving a tombstone so other devices drop it too. */
-	async remove(id) {
-		const store = this.requireStore();
-		this.requireEntry(id);
+	async touch(origin) {
+		const store = this.engineStore;
+		const session = this.session(origin);
+		const now = this.options.now();
+		if (store === void 0 || session === void 0 || now - session.lastUsedAt < TOUCH_INTERVAL_MS) return;
 		await this.persist(store, {
-			id,
-			deleted: true,
-			updatedAt: this.options.now()
+			...session,
+			lastUsedAt: now
 		});
 	}
-	checkedNote(note) {
-		const cleaned = cleanNote(note);
-		if (!cleaned.ok) throw new AddressBookError("invalid-input", `note must be at most 120 characters`);
-		return cleaned.note;
+	/**
+	* The host switched account group: every session's accounts become the new group's addresses. A
+	* session that cannot get one (no address derivable) is left with an empty list and has to be
+	* authorized again.
+	*/
+	async setActiveGroup(walletId, groupIndex) {
+		const store = this.requireStore();
+		const group = {
+			walletId,
+			groupIndex
+		};
+		this.group = group;
+		await Promise.all(Object.values(this.getState().sessions).map(async (session) => {
+			const entries = await Promise.all(Object.entries(session.scopes).map(async ([network, scope]) => {
+				if (scope.accounts.length === 0) return [network, scope];
+				try {
+					const address = await this.options.evmAddress(group, network);
+					return [network, {
+						...scope,
+						accounts: [caip10(network, address.toLowerCase())]
+					}];
+				} catch (error) {
+					this.options.logger.warn("connection account unavailable in the new group", error);
+					return [network, {
+						...scope,
+						accounts: []
+					}];
+				}
+			}));
+			await this.persist(store, {
+				...session,
+				scopes: Object.fromEntries(entries)
+			});
+		}));
 	}
-	requireEntry(id) {
-		const entry = this.getState().entries[id];
-		if (entry === void 0) throw new AddressBookError("not-found", `unknown contact ${id}`);
-		return entry;
+	dropPending(id) {
+		this.waiters.delete(id);
+		this.update((s) => {
+			const { [id]: _gone, ...pending } = s.pending;
+			return {
+				...s,
+				pending
+			};
+		});
 	}
-	async persist(store, record) {
-		await store.collection(COLLECTION$3).put(record.id, new TextEncoder().encode(JSON.stringify(record)));
-		this.records.set(record.id, record);
-		this.update(() => ({ entries: entriesOf([...this.records.values()]) }));
+	async persist(store, session) {
+		try {
+			await store.collection(COLLECTION$4).put(session.id, new TextEncoder().encode(JSON.stringify(session)));
+		} catch (error) {
+			throw internalError(error instanceof Error ? error.message : String(error));
+		}
+		this.update((s) => ({
+			...s,
+			sessions: {
+				...s.sessions,
+				[session.id]: session
+			}
+		}));
 	}
 	requireStore() {
-		if (this.engineStore === void 0) throw new AddressBookError("locked", "the address book requires an unlocked vault");
+		if (this.engineStore === void 0) throw userRejectedRequest("the wallet is locked");
 		return this.engineStore;
 	}
 };
-//#endregion
-//#region src/spark/errors.ts
+// src/addresses/normalize.ts
+/**
+* The canonical form of `address` for its family — EIP-55 for EVM, the re-encoded form for bitcoin
+* (accepted on any known bitcoin network, since a contact is not tied to the wallet's network) and
+* Spark (identity key only, no invoice fields) — or `undefined` when it is not a valid address.
+*/
+function normalizeAddress(family, address) {
+	try {
+		if (family === "evm") return isEvmAddress(address) ? checksumEvmAddress(address) : void 0;
+		if (family === "solana") return isSolanaAddress(address) ? address : void 0;
+		if (family === "spark") {
+			const decoded = decodeSparkAddress(address);
+			return encodeSparkAddress({
+				network: decoded.network,
+				identityPublicKey: decoded.identityPublicKey
+			});
+		}
+		for (const network of Object.values(BITCOIN_NETWORKS)) try {
+			const codec = Address(network.params);
+			return codec.encode(codec.decode(address));
+		} catch {}
+		return;
+	} catch {
+		return;
+	}
+}
+// src/spark/errors.ts
 var SparkControllerError = class extends Error {
 	category;
 	constructor(category, message, cause) {
@@ -463,8 +499,7 @@ function categorize(error) {
 	return "internal";
 }
 const feeCheck = (amountSats, maxFeeSats) => maxFeeSats !== void 0 && maxFeeSats >= amountSats ? ["fee-exceeds-amount"] : [];
-//#endregion
-//#region src/payments/errors.ts
+// src/payments/errors.ts
 var PaymentError = class extends Error {
 	category;
 	constructor(category, message, cause) {
@@ -473,8 +508,7 @@ var PaymentError = class extends Error {
 		this.category = category;
 	}
 };
-//#endregion
-//#region src/payments/pay.ts
+// src/payments/pay.ts
 const lightningDetails = (invoice) => {
 	const decoded = decodeBolt11(invoice);
 	return {
@@ -688,8 +722,7 @@ async function withdrawLnurl(context, params) {
 		invoice
 	};
 }
-//#endregion
-//#region src/payments/zap.ts
+// src/payments/zap.ts
 /** Everything up to payment: resolve LNURL, sign the 9734, request the invoice. */
 async function prepareZap(params, context) {
 	const amountMsat = params.amountSats * 1e3;
@@ -793,8 +826,13 @@ const lightningInvoiceDetails = (invoice) => ({ payee: bytesToHex(decodeBolt11(i
 function categorizePayment(error) {
 	return categorize(error) === "network" ? "network" : "rejected";
 }
-//#endregion
-//#region src/transactions/route.ts
+// src/spark/l1.ts
+/** The bitcoin network each Spark network settles on; deposits and exits must agree with it. */
+const SPARK_L1_NETWORK = {
+	mainnet: "bip122:000000000019d6689c085ae165831e93",
+	regtest: "bip122:0f9188f13cb7b2c71f2a335e3a4fc328"
+};
+// src/transactions/route.ts
 const hexId = (prefix, random) => `${prefix}-${[...random(8)].map((b) => b.toString(16).padStart(2, "0")).join("")}`;
 const newId = (random) => hexId("tx", random);
 const newRequestId = (random) => hexId("req", random);
@@ -815,8 +853,23 @@ const replacementStaleReason = (ctx, originalId) => {
 	if (original?.state !== "submitted" && original?.state !== "pending") return "original transaction already finished — nothing to replace";
 	return Object.values(txs).some((t) => t.replaces === originalId && LIVE_REPLACEMENT_STATES.has(t.state)) ? "original transaction was already replaced — start over" : void 0;
 };
-//#endregion
-//#region src/requests/checks.ts
+const submitTx = async (ctx, tx, hash) => {
+	const tracked = await ctx.transition(tx, {
+		state: "submitted",
+		hash,
+		submittedAt: ctx.options.now()
+	});
+	ctx.track(tracked.id, hash);
+	return tracked;
+};
+const failTx = async (ctx, tx, error) => {
+	const failed = tx.state === "signed" ? "failed" : "rejected";
+	await ctx.transition(tx, {
+		state: failed,
+		error: errorMessage$1(error)
+	});
+};
+// src/requests/checks.ts
 /** Two reads of one fee differ by more than this share of the smaller one. */
 const FEE_MISMATCH_PERCENT = 25n;
 /** A fee ceiling above this multiple of the independent estimate is flagged. */
@@ -913,18 +966,20 @@ function assessRecipients(family, recipients, known) {
 	}
 	return [...found.values()].sort((a, b) => Number(b.level === "danger") - Number(a.level === "danger"));
 }
-//#endregion
-//#region src/requests/sign-log.ts
+// src/requests/sign-log.ts
 const SIGN_LOG_LIMIT = 1e3;
-const COLLECTION$2 = "sign-log";
-const isObject$11 = (v) => typeof v === "object" && v !== null;
+const COLLECTION$3 = "sign-log";
+const isObject$13 = (v) => typeof v === "object" && v !== null;
 const METHODS = /* @__PURE__ */ new Set([
 	"send",
 	"speed-up",
 	"cancel",
 	"cpfp",
 	"pay",
-	"zap"
+	"zap",
+	"evm-sign",
+	"spark-deposit",
+	"spark-exit"
 ]);
 const OUTCOMES = /* @__PURE__ */ new Set([
 	"submitted",
@@ -939,12 +994,13 @@ const FAMILIES = /* @__PURE__ */ new Set([
 	"bitcoin"
 ]);
 const isAccount = (value) => {
-	if (!isObject$11(value)) return false;
+	if (!isObject$13(value)) return false;
 	if (value["kind"] === "hd") return typeof value["walletId"] === "string" && typeof value["groupIndex"] === "number" && typeof value["template"] === "string";
 	if (value["kind"] === "imported") return typeof value["keyId"] === "string" && FAMILIES.has(value["family"]);
 	return value["kind"] === void 0 && typeof value["walletId"] === "string" && typeof value["groupIndex"] === "number" && typeof value["network"] === "string";
 };
-const isEntry = (value) => isObject$11(value) && typeof value["id"] === "string" && typeof value["at"] === "number" && METHODS.has(value["method"]) && OUTCOMES.has(value["outcome"]) && isAccount(value["account"]);
+const isOrigin = (value) => isObject$13(value) && (value["kind"] === "internal" || value["kind"] === "browser" && typeof value["origin"] === "string");
+const isEntry = (value) => isObject$13(value) && typeof value["id"] === "string" && typeof value["at"] === "number" && isOrigin(value["origin"]) && METHODS.has(value["method"]) && OUTCOMES.has(value["outcome"]) && isAccount(value["account"]);
 /** Sortable key: time first, request id as the tiebreak. */
 const keyOf = (entry) => `${String(entry.at).padStart(16, "0")}-${entry.id}`;
 function createSignLog(logger) {
@@ -962,14 +1018,14 @@ function createSignLog(logger) {
 				logger.warn(`sign log entry for request ${entry.id} (${entry.outcome}) not written: vault locked`);
 				return;
 			}
-			const collection = current.collection(COLLECTION$2);
+			const collection = current.collection(COLLECTION$3);
 			await collection.put(keyOf(entry), new TextEncoder().encode(JSON.stringify(entry)));
 			const keys = [...await collection.list()].sort();
 			await Promise.all(keys.slice(0, Math.max(0, keys.length - SIGN_LOG_LIMIT)).map(async (k) => collection.delete(k)));
 		},
 		list: async () => {
 			if (store === void 0) return [];
-			const collection = store.collection(COLLECTION$2);
+			const collection = store.collection(COLLECTION$3);
 			const keys = [...await collection.list()].sort();
 			const rows = await Promise.all(keys.map(async (k) => collection.get(k)));
 			const entries = [];
@@ -982,30 +1038,39 @@ function createSignLog(logger) {
 		},
 		clear: async () => {
 			if (store === void 0) return;
-			const collection = store.collection(COLLECTION$2);
+			const collection = store.collection(COLLECTION$3);
 			const keys = [...await collection.list()].sort();
 			await Promise.all(keys.map(async (k) => collection.delete(k)));
 		}
 	};
 }
-//#endregion
-//#region src/requests/controller.ts
-/**
-* Request pipeline for internal sends, speed-ups, cancellations and CPFP: `prepare` builds,
-* estimates and cross-checks without signing; `approve(id, method, verify)` is the only way to
-* sign, and only for a live, unexpired request of the right method; locking invalidates everything
-* that has not finished. The unsigned content stays in a private table, never in the state
-* snapshot, and cannot change after prepare.
-*/
+// src/requests/controller.ts
+/** A request that ended without a result: `stage` says how, `message` is the failure if any. */
+var RequestEndedError = class extends Error {
+	stage;
+	constructor(stage, message) {
+		super(message ?? `request ${stage}`);
+		this.name = "RequestEndedError";
+		this.stage = stage;
+	}
+};
+/** The origin already has a request in flight; a dApp gets one at a time. */
+var OriginBusyError = class extends Error {
+	constructor(origin) {
+		super(`${origin} already has an unfinished request`);
+		this.name = "OriginBusyError";
+	}
+};
 /** Requests expire this long after creation. */
 const REQUEST_TTL_MS = 6e5;
-const isSparkInput = (input) => input.method === "pay" || input.method === "zap";
+const originKey = (origin) => `origin:${origin.origin}`;
 const LIVE = /* @__PURE__ */ new Set(["awaiting-approval", "signing"]);
 const errorMessage = (error) => error instanceof Error ? error.message : String(error);
 var RequestController = class extends Controller {
 	options;
 	entries = /* @__PURE__ */ new Map();
 	log;
+	settlers = /* @__PURE__ */ new Map();
 	/** Original transaction id → the unfinished request replacing or accelerating it. */
 	targets = /* @__PURE__ */ new Map();
 	locked = true;
@@ -1024,6 +1089,7 @@ var RequestController = class extends Controller {
 		this.locked = false;
 		this.entries.clear();
 		this.targets.clear();
+		this.settlers.clear();
 		this.update(() => ({ requests: {} }));
 		this.log.open(await this.options.openStore());
 	}
@@ -1038,6 +1104,10 @@ var RequestController = class extends Controller {
 		for (const [id, request] of Object.entries(this.getState().requests)) if (LIVE.has(request.stage)) this.finish(id, "invalidated");
 		this.log.close();
 	}
+	/** A page navigated away, was revoked or changed network: its unfinished requests are void. */
+	invalidateOrigin(origin) {
+		for (const [id, request] of Object.entries(this.getState().requests)) if (LIVE.has(request.stage) && request.origin.kind === "browser" && request.origin.origin === origin) this.finish(id, "invalidated");
+	}
 	/** The signature record, newest first. */
 	async signLog() {
 		return this.log.list();
@@ -1049,7 +1119,12 @@ var RequestController = class extends Controller {
 		if (this.locked) throw new Error("requests require an unlocked vault");
 		const { session } = this;
 		const id = newRequestId(this.options.random);
-		const target = input.method === "send" || isSparkInput(input) ? void 0 : input.txId;
+		const target = "txId" in input ? input.txId : void 0;
+		if (input.method === "evm-sign") {
+			const key = originKey(input.origin);
+			if (this.targets.has(key)) throw new OriginBusyError(input.origin.origin);
+			this.targets.set(key, id);
+		}
 		if (target !== void 0) {
 			if (this.targets.has(target)) throw new Error(`transaction ${target} already has an unfinished replacement request`);
 			this.targets.set(target, id);
@@ -1070,7 +1145,7 @@ var RequestController = class extends Controller {
 		const createdAt = this.options.now();
 		const request = {
 			id,
-			origin: { kind: "internal" },
+			origin: input.method === "evm-sign" ? input.origin : { kind: "internal" },
 			method: input.method,
 			account: built.account,
 			network: built.network,
@@ -1091,8 +1166,57 @@ var RequestController = class extends Controller {
 			stopTimer
 		});
 		this.put(request);
+		this.openSettler(id);
 		return request;
 	}
+	/**
+	* Resolves with what `approve` returned, or rejects with `RequestEndedError` when the request
+	* ends any other way — how a dApp's pending call learns the outcome.
+	*/
+	async outcome(id) {
+		const settler = this.settlers.get(id);
+		if (settler === void 0) throw new Error(`unknown request ${id}`);
+		return settler.promise;
+	}
+	openSettler(id) {
+		const holder = {};
+		const promise = new Promise((resolve, reject) => {
+			holder.resolve = resolve;
+			holder.reject = reject;
+		});
+		Promise.allSettled([promise]);
+		this.settlers.set(id, {
+			promise,
+			resolve: (value) => holder.resolve?.(value),
+			reject: (error) => holder.reject?.(error)
+		});
+	}
+	settle(id, result) {
+		const settler = this.settlers.get(id);
+		if (settler === void 0) return;
+		if (result instanceof Error) settler.reject(result);
+		else settler.resolve(result);
+	}
+	/** The bitcoin network `account`'s Spark network settles on; any other pairing is refused. */
+	l1Network(account) {
+		const network = SPARK_L1_NETWORK[account.network];
+		if (network === void 0) throw new Error(`unknown Spark network ${account.network}`);
+		return network;
+	}
+	sparkBuilt(account, action) {
+		return {
+			account,
+			network: action.display.network,
+			display: action.display,
+			checks: collectChecks(action.checks),
+			risk: this.sparkRisk(action.display),
+			run: {
+				staleReason: () => action.staleReason(this.options.now()),
+				submit: async (verify) => action.execute(this.options.spark, verify),
+				release: () => void 0
+			}
+		};
+	}
 	async build(input, id) {
 		if (input.method === "pay" || input.method === "zap") {
 			const action = input.method === "pay" ? await preparePay({
@@ -1102,17 +1226,60 @@ var RequestController = class extends Controller {
 				maxFeeSats: input.maxFeeSats,
 				now: this.options.now
 			});
+			return this.sparkBuilt(input.account, action);
+		}
+		if (input.method === "spark-deposit") {
+			const l1 = this.l1Network(input.account);
+			if (input.from.kind !== "hd" || input.from.walletId !== input.account.walletId) throw new Error("a Spark deposit must come from the same wallet");
+			const to = await this.options.spark.newDepositAddress(input.account);
+			const prepared = await this.options.transactions.prepareSend({
+				account: input.from,
+				network: l1,
+				to,
+				amount: BigInt(input.amountSats),
+				fee: input.fee
+			}, id, {
+				walletId: input.account.walletId,
+				groupIndex: input.account.groupIndex,
+				network: input.account.network
+			});
 			return {
+				account: prepared.account,
+				network: prepared.network,
+				display: prepared.intent,
+				checks: collectChecks([prepared.intent.verifiability === "full" ? void 0 : "decode-partial", ...prepared.checks]),
+				risk: [],
+				run: prepared
+			};
+		}
+		if (input.method === "spark-exit") {
+			const l1 = this.l1Network(input.account);
+			const address = await this.options.transactions.nextReceiveAddress(input.account.walletId, input.account.groupIndex, l1);
+			const action = await preparePay({
+				fetch: this.options.fetch,
+				now: this.options.now
+			}, {
 				account: input.account,
-				network: action.display.network,
-				display: action.display,
-				checks: collectChecks(action.checks),
-				risk: this.sparkRisk(action.display),
-				run: {
-					staleReason: () => action.staleReason(this.options.now()),
-					submit: async (verify) => action.execute(this.options.spark, verify),
-					release: () => void 0
-				}
+				option: {
+					kind: "bitcoin",
+					address
+				},
+				amountSats: input.amountSats,
+				maxFeeSats: input.maxFeeSats,
+				...input.speed === void 0 ? {} : { speed: input.speed }
+			});
+			return this.sparkBuilt(input.account, action);
+		}
+		if (input.method === "evm-sign") {
+			const prepared = await this.options.transactions.prepareDapp(input.account, input.request);
+			const isTransaction = input.request.kind === "evm.transaction";
+			return {
+				account: prepared.account,
+				network: prepared.network,
+				display: prepared.intent,
+				checks: collectChecks([isTransaction && prepared.intent.verifiability !== "full" ? "decode-partial" : void 0, ...prepared.checks]),
+				risk: isTransaction ? this.chainRisk(prepared.intent) : [],
+				run: prepared
 			};
 		}
 		const prepared = input.method === "send" ? await this.options.transactions.prepareSend(input, id) : await this.options.transactions.prepareReplacement(input, id);
@@ -1165,6 +1332,7 @@ var RequestController = class extends Controller {
 				this.put(done);
 				this.record(done, "submitted");
 			} else this.record(request, "submitted");
+			this.settle(id, result);
 			return result;
 		} catch (error) {
 			if (session === this.session) this.finish(id, this.failureStage(entry.prepared, error), errorMessage(error));
@@ -1226,6 +1394,7 @@ var RequestController = class extends Controller {
 			};
 			this.put(ended);
 			this.record(ended, stage, error);
+			this.settle(id, new RequestEndedError(stage, error));
 		}
 	}
 	/** Appends the final stage to the signature record; a failed write is a warning, not an error. */
@@ -1245,36 +1414,592 @@ var RequestController = class extends Controller {
 			outcome,
 			...error === void 0 ? {} : { error }
 		};
-		this.appendLog(entry);
+		this.appendLog(entry);
+	}
+	async appendLog(entry) {
+		try {
+			await this.log.append(entry);
+		} catch (error) {
+			this.options.logger.warn("sign log write failed", error);
+		}
+	}
+	/**
+	* Addresses the wallet already knows for a family: contacts, plus recipients of tracked chain
+	* sends (Spark payments are not tracked).
+	*/
+	knownAddresses(family) {
+		const contacts = Object.values(this.options.addressBook.getState().entries).filter((e) => e.family === family).map((e) => e.address);
+		if (family === "spark") return contacts;
+		const paid = Object.values(this.options.transactions.getState().txs).filter((tx) => tx.family === family && (tx.state === "submitted" || tx.state === "pending" || tx.state === "confirmed")).flatMap((tx) => tx.intent?.outflows.map((o) => o.to) ?? []);
+		return [...contacts, ...paid];
+	}
+	chainRisk(intent) {
+		return assessRecipients(intent.family, intent.outflows.map((o) => o.to), this.knownAddresses(intent.family));
+	}
+	/** Only a Spark transfer has a recipient to check; Lightning and exits are not assessed. */
+	sparkRisk(display) {
+		if (display.kind !== "transfer") return [];
+		return assessRecipients("spark", [normalizeAddress("spark", display.receiver) ?? display.receiver], this.knownAddresses("spark"));
+	}
+};
+// src/connect/eip1193.ts
+/**
+* Platform-neutral EIP-1193 provider logic: it knows nothing about WebViews. The host hands it a
+* page's origin (computed from the WebView's top-level URL, never from the page) and a JSON-RPC
+* call; signing goes through the request pipeline and waits for the host's approval by id.
+*/
+/** Refused outright, whatever the session. */
+const REFUSED = /* @__PURE__ */ new Set([
+	"eth_sign",
+	"eth_signTypedData",
+	"eth_signTypedData_v3",
+	"eth_signTransaction",
+	"eth_sendRawTransaction"
+]);
+/** Planned for later layers; answered `4200` until then. */
+const DEFERRED = /* @__PURE__ */ new Set([
+	"wallet_addEthereumChain",
+	"wallet_watchAsset",
+	"wallet_sendCalls",
+	"wallet_getCallsStatus",
+	"wallet_getCapabilities",
+	"wallet_showCallsStatus"
+]);
+const READ_ONLY = new Set(EVM_RPC_METHODS.filter((m) => m !== "eth_sendRawTransaction" && m !== "eth_chainId"));
+const hexChainId = (network) => `0x${(evmChainId(network) ?? 0).toString(16)}`;
+const isObject$12 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const paramList = (params) => {
+	if (params === void 0) return [];
+	if (!Array.isArray(params)) throw invalidParams("params must be an array");
+	return params;
+};
+const textBytes = (value) => {
+	if (typeof value !== "string") throw invalidParams("message must be a string");
+	if (/^0x(?:[0-9a-fA-F]{2})*$/.test(value)) {
+		const bytes = hexToBytes(value.slice(2));
+		try {
+			new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+		} catch {
+			throw new ProviderError(4200, "blind signing is not enabled: the message is not UTF-8 text");
+		}
+		return bytes;
+	}
+	return new TextEncoder().encode(value);
+};
+const quantityOf = (value, field, fallback) => {
+	if (value === void 0) return fallback;
+	if (typeof value !== "string" || !/^0x[0-9a-fA-F]+$/.test(value)) throw invalidParams(`${field} must be a 0x quantity`);
+	return value;
+};
+var Eip1193Handler = class {
+	options;
+	listeners = /* @__PURE__ */ new Set();
+	unsubscribe;
+	constructor(options) {
+		this.options = options;
+	}
+	/** Events for the host to forward to pages; derived from changes to the sessions. */
+	subscribe(listener) {
+		this.listeners.add(listener);
+		if (this.unsubscribe === void 0) {
+			let previous = this.options.connections.getState().sessions;
+			this.unsubscribe = this.options.connections.store.subscribe((state) => {
+				for (const event of diffSessions(previous, state.sessions)) for (const l of this.listeners) l(event);
+				previous = state.sessions;
+			});
+		}
+		return () => {
+			this.listeners.delete(listener);
+			if (this.listeners.size === 0) {
+				this.unsubscribe?.();
+				this.unsubscribe = void 0;
+			}
+		};
+	}
+	async handle(origin, request) {
+		const { connections } = this.options;
+		connections.checkOrigin(origin);
+		const { method } = request;
+		const params = paramList(request.params);
+		if (REFUSED.has(method) || DEFERRED.has(method)) throw unsupportedMethod(method);
+		switch (method) {
+			case "eth_accounts": return connections.accounts(origin);
+			case "eth_chainId": return hexChainId(connections.session(origin)?.currentNetwork ?? this.options.defaultNetwork());
+			case "eth_requestAccounts": return this.requestAccounts(origin);
+			case "wallet_requestPermissions":
+				await this.requestAccounts(origin);
+				return this.permissions(origin);
+			case "wallet_getPermissions": return this.permissions(origin);
+			case "wallet_revokePermissions":
+				await connections.revoke(origin);
+				return null;
+			case "wallet_switchEthereumChain": return this.switchChain(origin, params[0]);
+			case "personal_sign": return this.personalSign(origin, params);
+			case "eth_signTypedData_v4": return this.typedData(origin, params);
+			case "eth_sendTransaction": return this.sendTransaction(origin, params[0]);
+		}
+		if (READ_ONLY.has(method)) return this.read(origin, method, params);
+		throw new ProviderError(-32601, `${method} does not exist`);
+	}
+	async requestAccounts(origin) {
+		const { connections } = this.options;
+		if (connections.accounts(origin).length === 0) await connections.request(origin, "connect");
+		await connections.touch(origin);
+		return connections.accounts(origin);
+	}
+	permissions(origin) {
+		const accounts = this.options.connections.accounts(origin);
+		if (accounts.length === 0) return [];
+		return [{
+			parentCapability: "eth_accounts",
+			invoker: origin,
+			caveats: [{
+				type: "restrictReturnedAccounts",
+				value: accounts
+			}]
+		}];
+	}
+	async switchChain(origin, arg) {
+		const { connections } = this.options;
+		const chainId = isObject$12(arg) ? arg["chainId"] : void 0;
+		if (typeof chainId !== "string" || !/^0x[0-9a-fA-F]+$/.test(chainId)) throw invalidParams("chainId must be a 0x quantity");
+		const network = `eip155:${Number.parseInt(chainId, 16)}`;
+		if (!connections.isEnabled(network)) throw unrecognizedChain(`chain ${chainId} is not enabled`);
+		const session = connections.session(origin);
+		if (session === void 0) throw unauthorized();
+		if (session.scopes[network] === void 0) await connections.request(origin, "network", network);
+		else if (session.currentNetwork !== network) await connections.setCurrentNetwork(origin, network);
+		return null;
+	}
+	authorizedAccount(session, address) {
+		const accounts = this.options.connections.accounts(session.origin.origin);
+		const wanted = typeof address === "string" ? address.toLowerCase() : accounts[0];
+		if (wanted === void 0 || !accounts.some((a) => a.toLowerCase() === wanted.toLowerCase())) throw unauthorized("account not authorized");
+		return wanted;
+	}
+	async personalSign(origin, params) {
+		const session = this.signingSession(origin, "personal_sign");
+		this.authorizedAccount(session, params[1]);
+		const message = textBytes(params[0]);
+		return this.sign(origin, session, (account) => ({
+			kind: "evm.personal-message",
+			network: session.currentNetwork,
+			account,
+			message
+		}));
+	}
+	async typedData(origin, params) {
+		const session = this.signingSession(origin, "eth_signTypedData_v4");
+		this.authorizedAccount(session, params[0]);
+		const [, source] = params;
+		const typedData = typeof source === "string" ? source : JSON.stringify(source);
+		return this.sign(origin, session, (account) => ({
+			kind: "evm.typed-data",
+			network: session.currentNetwork,
+			account,
+			typedData
+		}));
+	}
+	async sendTransaction(origin, arg) {
+		const session = this.signingSession(origin, "eth_sendTransaction");
+		if (!isObject$12(arg)) throw invalidParams("transaction must be an object");
+		this.authorizedAccount(session, arg["from"]);
+		const chainId = evmChainId(session.currentNetwork);
+		if (chainId === void 0) throw internalError("session network is not an EVM network");
+		if (arg["chainId"] !== void 0 && Number(arg["chainId"]) !== chainId) throw invalidParams("transaction chainId does not match the session network");
+		const data = arg["data"] ?? arg["input"] ?? "0x";
+		if (typeof data !== "string") throw invalidParams("data must be a hex string");
+		const { to } = arg;
+		if (to !== void 0 && typeof to !== "string") throw invalidParams("to must be an address");
+		return this.sign(origin, session, (account) => ({
+			kind: "evm.transaction",
+			network: session.currentNetwork,
+			account,
+			tx: {
+				type: "eip1559",
+				chainId,
+				nonce: 0,
+				gas: quantityOf(arg["gas"], "gas", "0x0"),
+				value: quantityOf(arg["value"], "value", "0x0"),
+				data,
+				...to === void 0 ? {} : { to },
+				accessList: [],
+				maxFeePerGas: "0x0",
+				maxPriorityFeePerGas: "0x0"
+			}
+		}));
+	}
+	signingSession(origin, method) {
+		const { connections } = this.options;
+		const session = connections.session(origin);
+		if (session === void 0) throw unauthorized();
+		return connections.authorize(origin, session.currentNetwork, method);
+	}
+	async sign(origin, session, build) {
+		const { connections, requests } = this.options;
+		const group = connections.activeGroup();
+		if (group === void 0) throw internalError("no account group is selected");
+		const account = {
+			kind: "hd",
+			...group,
+			template: "evm.bip44"
+		};
+		try {
+			const pending = await requests.prepare({
+				method: "evm-sign",
+				origin: {
+					kind: "browser",
+					origin
+				},
+				account,
+				network: session.currentNetwork,
+				request: build(account)
+			});
+			const result = await requests.outcome(pending.id);
+			await connections.touch(origin);
+			if ("signature" in result && result.signature instanceof Uint8Array) return `0x${bytesToHex(result.signature)}`;
+			if (!("hash" in result) || typeof result.hash !== "string") throw internalError("the transaction has no hash");
+			return result.hash;
+		} catch (error) {
+			throw toProviderError(error);
+		}
+	}
+	async read(origin, method, params) {
+		const { connections, networks } = this.options;
+		const network = connections.session(origin)?.currentNetwork ?? this.options.defaultNetwork();
+		try {
+			return await networks.client(network).transport.request({
+				method,
+				params: [...params]
+			});
+		} catch (error) {
+			throw toProviderError(error);
+		}
+	}
+};
+function toProviderError(error) {
+	if (error instanceof ProviderError) return error;
+	if (error instanceof OriginBusyError) return userRejectedRequest(error.message);
+	if (error instanceof RequestEndedError) return error.stage === "failed" ? internalError(error.message) : userRejectedRequest(error.message);
+	if (error instanceof ChainError) return invalidParams(error.message);
+	return internalError(error instanceof Error ? error.message : String(error));
+}
+function currentAccounts(session) {
+	return session.scopes[session.currentNetwork]?.accounts.map((a) => a.slice(a.lastIndexOf(":") + 1)) ?? [];
+}
+const byOrigin = (sessions) => new Map(Object.values(sessions).map((s) => [s.origin.origin, s]));
+function diffSessions(before, after) {
+	const events = [];
+	const prev = byOrigin(before);
+	const next = byOrigin(after);
+	for (const [origin, session] of prev) {
+		const now = next.get(origin);
+		if (now === void 0) {
+			events.push({
+				name: "disconnect",
+				origin
+			});
+			continue;
+		}
+		if (now.currentNetwork !== session.currentNetwork) events.push({
+			name: "chainChanged",
+			origin,
+			chainId: hexChainId(now.currentNetwork)
+		});
+		if (currentAccounts(session).join(",") !== currentAccounts(now).join(",")) events.push({
+			name: "accountsChanged",
+			origin,
+			accounts: currentAccounts(now)
+		});
+	}
+	for (const [origin, session] of next) if (!prev.has(origin)) events.push({
+		name: "connect",
+		origin,
+		chainId: hexChainId(session.currentNetwork)
+	});
+	return events;
+}
+// src/addresses/errors.ts
+var AddressBookError = class extends Error {
+	category;
+	constructor(category, message) {
+		super(message);
+		this.name = "AddressBookError";
+		this.category = category;
+	}
+};
+// src/addresses/record.ts
+/**
+* The address-book record shared by the controller, the sync merge and the metadata document: a
+* live entry, or a tombstone that carries a deletion to the other devices.
+*/
+const isTombstone = (record) => "deleted" in record;
+const isFamily = (v) => v === "evm" || v === "solana" || v === "bitcoin" || v === "spark";
+const ENTRY_KEYS = /* @__PURE__ */ new Set([
+	"id",
+	"name",
+	"family",
+	"address",
+	"note",
+	"createdAt",
+	"updatedAt"
+]);
+const TOMBSTONE_KEYS = /* @__PURE__ */ new Set([
+	"id",
+	"deleted",
+	"updatedAt"
+]);
+const isObject$11 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const isNonNegativeInt$2 = (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
+/** Trimmed name, or `undefined` when it is not 1 to {@link NAME_MAX} characters. */
+const cleanName = (raw) => {
+	const name = raw.trim();
+	return name.length > 0 && name.length <= 32 ? name : void 0;
+};
+/** Trimmed note; an empty one means no note. `undefined` return with `ok: false` when too long. */
+const cleanNote = (raw) => {
+	const note = raw?.trim();
+	if (note === void 0 || note.length === 0) return {
+		ok: true,
+		note: void 0
+	};
+	return note.length <= 120 ? {
+		ok: true,
+		note
+	} : { ok: false };
+};
+const hasOnly = (value, keys) => Object.keys(value).every((k) => keys.has(k));
+/**
+* Strict decode with the controller's rules; the address is re-normalized. Anything else is
+* `undefined`.
+*/
+function decodeRecord(value) {
+	if (!isObject$11(value) || typeof value["id"] !== "string" || !isNonNegativeInt$2(value["updatedAt"])) return;
+	if ("deleted" in value) return value["deleted"] === true && hasOnly(value, TOMBSTONE_KEYS) ? {
+		id: value["id"],
+		deleted: true,
+		updatedAt: value["updatedAt"]
+	} : void 0;
+	const { family, name, address, note } = value;
+	if (!hasOnly(value, ENTRY_KEYS) || !isFamily(family) || typeof name !== "string" || typeof address !== "string" || !isNonNegativeInt$2(value["createdAt"]) || note !== void 0 && typeof note !== "string") return;
+	const cleanedName = cleanName(name);
+	const normalized = normalizeAddress(family, address);
+	const cleanedNote = cleanNote(note);
+	if (cleanedName === void 0 || normalized === void 0 || !cleanedNote.ok || note !== void 0 && cleanedNote.note === void 0) return;
+	return {
+		id: value["id"],
+		name: cleanedName,
+		family,
+		address: normalized,
+		...cleanedNote.note === void 0 ? {} : { note: cleanedNote.note },
+		createdAt: value["createdAt"],
+		updatedAt: value["updatedAt"]
+	};
+}
+const serialized = (record) => JSON.stringify(record);
+/** The winner of two versions of one id: larger `updatedAt`, then the larger serialization. */
+function pickWinner(a, b) {
+	if (a.updatedAt !== b.updatedAt) return a.updatedAt > b.updatedAt ? a : b;
+	return serialized(a) >= serialized(b) ? a : b;
+}
+const pruneTombstones = (records, now) => records.filter((r) => !isTombstone(r) || now - r.updatedAt <= 7776e6);
+/** Newest first, id as the tiebreak, so every device orders (and truncates) the same way. */
+const newestFirst = (a, b) => b.updatedAt - a.updatedAt || (a.id < b.id ? -1 : 1);
+/** Drops the oldest tombstones until at most `max` records remain, or no tombstone is left. */
+function evictTombstones(records, max) {
+	const excess = records.length - max;
+	if (excess <= 0) return records;
+	const oldest = new Set(records.filter(isTombstone).sort((a, b) => a.updatedAt - b.updatedAt || (a.id < b.id ? -1 : 1)).slice(0, excess).map((r) => r.id));
+	return records.filter((r) => !oldest.has(r.id));
+}
+/** {@link mergeRecords}, also counting the live entries the cap forced out. */
+function mergeWithReport(local, remote, now) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const record of [...local, ...remote]) {
+		const existing = byId.get(record.id);
+		byId.set(record.id, existing === void 0 ? record : pickWinner(existing, record));
+	}
+	const live = /* @__PURE__ */ new Map();
+	const kept = [];
+	for (const record of [...pruneTombstones([...byId.values()], now)].sort(newestFirst)) {
+		if (isTombstone(record)) {
+			kept.push(record);
+			continue;
+		}
+		const key = `${record.family}:${record.address}`;
+		if (!live.has(key)) {
+			live.set(key, record);
+			kept.push(record);
+		}
+	}
+	const evicted = evictTombstones(kept, 128);
+	return {
+		records: [...evicted.slice(0, 128)].sort((a, b) => a.id < b.id ? -1 : 1),
+		droppedLive: evicted.slice(128).filter((r) => !isTombstone(r)).length
+	};
+}
+// src/addresses/controller.ts
+/**
+* Address book: named recipients, validated and normalized per chain family, persisted in the
+* engine store and cleared from memory on lock. Deletions are kept as tombstones so they reach the
+* other devices; `syncEntries`/`merge` are the whole surface the metadata sync needs. Request risk
+* checks treat its addresses as known.
+*/
+const COLLECTION$2 = "contacts";
+const entriesOf = (records) => Object.fromEntries(records.flatMap((r) => isTombstone(r) ? [] : [[r.id, r]]));
+var AddressBookController = class extends Controller {
+	options;
+	engineStore;
+	/** Every record, tombstones included, by id. */
+	records = /* @__PURE__ */ new Map();
+	constructor(options) {
+		super({
+			name: "address-book",
+			defaultState: () => ({ entries: {} })
+		});
+		this.options = options;
+	}
+	async init() {
+		const store = await this.options.openStore();
+		this.engineStore = store;
+		const collection = store.collection(COLLECTION$2);
+		const keys = await collection.list();
+		const rows = await Promise.all(keys.map(async (key) => collection.get(key)));
+		const records = /* @__PURE__ */ new Map();
+		for (const raw of rows) {
+			if (raw === void 0) continue;
+			const record = decodeRecord(JSON.parse(new TextDecoder().decode(raw)));
+			if (record === void 0) this.options.logger.warn("address book record skipped: malformed");
+			else records.set(record.id, record);
+		}
+		this.records = records;
+		this.update(() => ({ entries: entriesOf([...records.values()]) }));
+	}
+	async destroy() {
+		this.lock();
+		await Promise.resolve();
+	}
+	lock() {
+		this.engineStore = void 0;
+		this.records = /* @__PURE__ */ new Map();
+		this.update(() => ({ entries: {} }));
+	}
+	/** Entries and tombstones, for the metadata document. */
+	syncEntries() {
+		return [...this.records.values()].sort((a, b) => a.id < b.id ? -1 : 1);
+	}
+	/**
+	* Merges records from another device (last writer wins, tombstones win over older entries).
+	* Returns whether anything local changed and whether the merged set holds something `remote`
+	* lacks, i.e. whether the remote copy needs a newer publish.
+	*/
+	async merge(remote) {
+		const store = this.requireStore();
+		const before = JSON.stringify(this.syncEntries());
+		const { records: merged, droppedLive } = mergeWithReport(this.syncEntries(), remote, this.options.now());
+		if (droppedLive > 0) this.options.logger.warn(`address book sync: ${droppedLive} contacts dropped, over the 128-record cap`);
+		const remoteSorted = JSON.stringify([...remote].sort((a, b) => a.id < b.id ? -1 : 1));
+		const localNewer = JSON.stringify(merged) !== remoteSorted;
+		if (JSON.stringify(merged) === before) return {
+			changed: false,
+			localNewer
+		};
+		const collection = store.collection(COLLECTION$2);
+		const next = new Map(merged.map((r) => [r.id, r]));
+		await Promise.all([...merged.map(async (r) => collection.put(r.id, new TextEncoder().encode(JSON.stringify(r)))), ...[...this.records.keys()].filter((id) => !next.has(id)).map(async (id) => collection.delete(id))]);
+		this.records = next;
+		this.update(() => ({ entries: entriesOf(merged) }));
+		return {
+			changed: true,
+			localNewer
+		};
+	}
+	async add(params) {
+		const store = this.requireStore();
+		const name = cleanName(params.name);
+		if (name === void 0) throw new AddressBookError("invalid-input", `name must be 1 to 32 characters`);
+		const note = this.checkedNote(params.note);
+		const address = normalizeAddress(params.family, params.address.trim());
+		if (address === void 0) throw new AddressBookError("invalid-input", `not a valid ${params.family} address`);
+		if (Object.values(this.getState().entries).some((e) => e.family === params.family && e.address === address)) throw new AddressBookError("duplicate", "this address is already in the address book");
+		if (this.records.size >= 128) {
+			const kept = evictTombstones([...this.records.values()], 127);
+			if (kept.length >= 128) throw new AddressBookError("limit", `the address book holds at most 128 contacts`);
+			const keptIds = new Set(kept.map((r) => r.id));
+			await Promise.all([...this.records.keys()].filter((id) => !keptIds.has(id)).map(async (id) => store.collection(COLLECTION$2).delete(id)));
+			this.records = new Map(kept.map((r) => [r.id, r]));
+		}
+		const now = this.options.now();
+		const entry = {
+			id: `contact-${[...this.options.random(8)].map((b) => b.toString(16).padStart(2, "0")).join("")}`,
+			name,
+			family: params.family,
+			address,
+			...note === void 0 ? {} : { note },
+			createdAt: now,
+			updatedAt: now
+		};
+		await this.persist(store, entry);
+		return entry;
+	}
+	async rename(id, name) {
+		const store = this.requireStore();
+		const existing = this.requireEntry(id);
+		const cleaned = cleanName(name);
+		if (cleaned === void 0) throw new AddressBookError("invalid-input", `name must be 1 to 32 characters`);
+		const entry = {
+			...existing,
+			name: cleaned,
+			updatedAt: this.options.now()
+		};
+		await this.persist(store, entry);
+		return entry;
+	}
+	/** Sets or clears (empty or `undefined`) the note. */
+	async setNote(id, note) {
+		const store = this.requireStore();
+		const existing = this.requireEntry(id);
+		const cleaned = this.checkedNote(note);
+		const { note: _previous, ...rest } = existing;
+		const entry = {
+			...rest,
+			...cleaned === void 0 ? {} : { note: cleaned },
+			updatedAt: this.options.now()
+		};
+		await this.persist(store, entry);
+		return entry;
 	}
-	async appendLog(entry) {
-		try {
-			await this.log.append(entry);
-		} catch (error) {
-			this.options.logger.warn("sign log write failed", error);
-		}
+	/** Removes the entry, leaving a tombstone so other devices drop it too. */
+	async remove(id) {
+		const store = this.requireStore();
+		this.requireEntry(id);
+		await this.persist(store, {
+			id,
+			deleted: true,
+			updatedAt: this.options.now()
+		});
 	}
-	/**
-	* Addresses the wallet already knows for a family: contacts, plus recipients of tracked chain
-	* sends (Spark payments are not tracked).
-	*/
-	knownAddresses(family) {
-		const contacts = Object.values(this.options.addressBook.getState().entries).filter((e) => e.family === family).map((e) => e.address);
-		if (family === "spark") return contacts;
-		const paid = Object.values(this.options.transactions.getState().txs).filter((tx) => tx.family === family && (tx.state === "submitted" || tx.state === "pending" || tx.state === "confirmed")).flatMap((tx) => tx.intent?.outflows.map((o) => o.to) ?? []);
-		return [...contacts, ...paid];
+	checkedNote(note) {
+		const cleaned = cleanNote(note);
+		if (!cleaned.ok) throw new AddressBookError("invalid-input", `note must be at most 120 characters`);
+		return cleaned.note;
 	}
-	chainRisk(intent) {
-		return assessRecipients(intent.family, intent.outflows.map((o) => o.to), this.knownAddresses(intent.family));
+	requireEntry(id) {
+		const entry = this.getState().entries[id];
+		if (entry === void 0) throw new AddressBookError("not-found", `unknown contact ${id}`);
+		return entry;
 	}
-	/** Only a Spark transfer has a recipient to check; Lightning and exits are not assessed. */
-	sparkRisk(display) {
-		if (display.kind !== "transfer") return [];
-		return assessRecipients("spark", [normalizeAddress("spark", display.receiver) ?? display.receiver], this.knownAddresses("spark"));
+	async persist(store, record) {
+		await store.collection(COLLECTION$2).put(record.id, new TextEncoder().encode(JSON.stringify(record)));
+		this.records.set(record.id, record);
+		this.update(() => ({ entries: entriesOf([...this.records.values()]) }));
+	}
+	requireStore() {
+		if (this.engineStore === void 0) throw new AddressBookError("locked", "the address book requires an unlocked vault");
+		return this.engineStore;
 	}
 };
-//#endregion
-//#region src/chains/bitcoin-scan.ts
+// src/chains/bitcoin-scan.ts
 /**
 * Gap-20 BIP-44/86 account scanning over Esplora — derives /0/* and /1/* from the account xpub,
 * walks each chain in windows until 20 consecutive unused addresses, persists the discovered
@@ -1282,6 +2007,7 @@ var RequestController = class extends Controller {
 * receive/change address.
 */
 const GAP = 20;
+const COLL = "btc-scan";
 const isObject$10 = (v) => typeof v === "object" && v !== null;
 const isUnknownArray = (v) => Array.isArray(v);
 const asArray = (v) => isUnknownArray(v) ? v : [];
@@ -1334,8 +2060,45 @@ const scanUtxos = async (es, addresses, params) => {
 	const candidates = addresses.filter((a) => a.used || a.chain === 1 || a.index < GAP);
 	return Promise.all(candidates.map(async (a) => scanAddressUtxos(es, a, params))).then((r) => r.flat());
 };
+var BitcoinScanStore = class {
+	engineStore;
+	async unlock(store) {
+		this.engineStore = store;
+		const raw = await store.collection(COLL).get("state");
+		const parsed = raw === void 0 ? void 0 : JSON.parse(new TextDecoder().decode(raw));
+		if (!isObject$10(parsed) || !Array.isArray(parsed["addresses"]) || !Array.isArray(parsed["utxos"])) return;
+		return {
+			addresses: asArray(parsed["addresses"]).flatMap((a) => toScanAddress(a)),
+			utxos: asArray(parsed["utxos"]).flatMap((u) => toScanUtxo(u)),
+			scannedAt: typeof parsed["scannedAt"] === "number" ? parsed["scannedAt"] : 0
+		};
+	}
+	async persist(state) {
+		const store = this.engineStore;
+		if (store !== void 0) await store.collection(COLL).put("state", new TextEncoder().encode(JSON.stringify(state)));
+	}
+	nextUnused(state, chain) {
+		return state.addresses.find((a) => a.chain === chain && !a.used);
+	}
+	lock() {
+		this.engineStore = void 0;
+	}
+};
 const str$1 = (v) => typeof v === "string" ? v : void 0;
 const num = (v) => typeof v === "number" ? v : void 0;
+const toScanAddress = (v) => {
+	if (!isObject$10(v)) return [];
+	const chain = num(v["chain"]);
+	const index = num(v["index"]);
+	const address = str$1(v["address"]);
+	const used = v["used"] === true;
+	return chain !== void 0 && index !== void 0 && address !== void 0 && (chain === 0 || chain === 1) ? [{
+		chain: chain === 0 ? 0 : 1,
+		index,
+		address,
+		used
+	}] : [];
+};
 const toScanUtxo = (v) => {
 	if (!isObject$10(v)) return [];
 	const txid = str$1(v["txid"]);
@@ -1452,8 +2215,7 @@ var BtcUtxoStore = class BtcUtxoStore {
 		this.engineStore = void 0;
 	}
 };
-//#endregion
-//#region src/accounts/errors.ts
+// src/accounts/errors.ts
 var AccountTreeError = class extends Error {
 	category;
 	constructor(category, message, cause) {
@@ -1462,8 +2224,7 @@ var AccountTreeError = class extends Error {
 		this.category = category;
 	}
 };
-//#endregion
-//#region src/accounts/controller.ts
+// src/accounts/controller.ts
 const EMPTY_TREE = {
 	wallets: {},
 	groups: {},
@@ -2278,8 +3039,7 @@ function persistedToState(tree) {
 		totals: tree.totals
 	};
 }
-//#endregion
-//#region src/chains/evm.ts
+// src/chains/evm.ts
 /**
 * EVM chain adapter: native transfers through a viem PublicClient injected by NetworkController.
 * Fee tiers come from eth_feeHistory (20 blocks, p10/p50/p90 → slow/normal/fast, maxFee = 2×baseFee +
@@ -2344,6 +3104,15 @@ const checkedAddress = (v) => {
 	return v;
 };
 const hex$1 = (v) => numberToHex(v);
+const evmRpc = async (client, method, params) => client.transport.request({
+	method,
+	params
+});
+const evmRpcHex = async (client, method, params) => {
+	const result = await evmRpc(client, method, params);
+	if (typeof result !== "string") throw new TypeError(`${method} returned a malformed result`);
+	return result;
+};
 var EvmChainAdapter = class {
 	family = "evm";
 	nonces = /* @__PURE__ */ new Map();
@@ -2359,20 +3128,9 @@ var EvmChainAdapter = class {
 		this.nonces.set(key, next);
 		return next;
 	}
-	async rpc(client, method, params) {
-		return client.transport.request({
-			method,
-			params
-		});
-	}
-	async rpcHex(client, method, params) {
-		const result = await this.rpc(client, method, params);
-		if (typeof result !== "string") throw new TypeError(`${method} returned a malformed result`);
-		return result;
-	}
 	/** The endpoint's pending transaction count for `from`. */
 	async pendingCount(client, from) {
-		return Number(await this.rpcHex(client, "eth_getTransactionCount", [from, "pending"]));
+		return Number(await evmRpcHex(client, "eth_getTransactionCount", [from, "pending"]));
 	}
 	/**
 	* The next nonce for (network, from): the larger of the endpoint's pending count and one past the
@@ -2406,14 +3164,16 @@ var EvmChainAdapter = class {
 			abi: ERC20_ABI,
 			functionName: "transfer",
 			args: [checkedAddress(intent.to), intent.value]
-		}) : "0x";
-		const estimate = BigInt(await this.rpcHex(client, "eth_estimateGas", [{
+		}) : intent.kind === "call" ? intent.data : "0x";
+		const estimate = BigInt(await evmRpcHex(client, "eth_estimateGas", [{
 			from,
 			to,
 			value: hex$1(value),
 			data
 		}]));
 		const scale = erc20 ? 11n : 12n;
+		const buffered = estimate * scale / 10n + (estimate * scale % 10n === 0n ? 0n : 1n);
+		const minGas = intent.kind === "call" ? intent.minGas ?? 0n : 0n;
 		return {
 			family: "evm",
 			network,
@@ -2422,12 +3182,12 @@ var EvmChainAdapter = class {
 			value,
 			data,
 			nonce,
-			gas: estimate * scale / 10n + (estimate * scale % 10n === 0n ? 0n : 1n)
+			gas: buffered > minGas ? buffered : minGas
 		};
 	}
 	async estimateFee(client) {
 		try {
-			const history = await this.rpc(client, "eth_feeHistory", [
+			const history = await evmRpc(client, "eth_feeHistory", [
 				"0x14",
 				"latest",
 				[
@@ -2457,7 +3217,7 @@ var EvmChainAdapter = class {
 				tier(2, "fast")
 			];
 		} catch {
-			const price = BigInt(await this.rpcHex(client, "eth_gasPrice", []));
+			const price = BigInt(await evmRpcHex(client, "eth_gasPrice", []));
 			return [
 				"slow",
 				"normal",
@@ -2514,21 +3274,20 @@ var EvmChainAdapter = class {
 		return `0x${[...bytes].map((b) => b.toString(16).padStart(2, "0")).join("")}`;
 	}
 	async broadcast(client, raw) {
-		return this.rpcHex(client, "eth_sendRawTransaction", [raw]);
+		return evmRpcHex(client, "eth_sendRawTransaction", [raw]);
 	}
 	async status(client, hash) {
-		const receipt = await this.rpc(client, "eth_getTransactionReceipt", [hash]);
+		const receipt = await evmRpc(client, "eth_getTransactionReceipt", [hash]);
 		if (receipt === null || typeof receipt !== "object") return "pending";
 		if ("status" in receipt && typeof receipt.status === "string" && BigInt(receipt.status) === 0n) return "failed";
 		try {
-			const finalized = await this.rpc(client, "eth_getBlockByNumber", ["finalized", false]);
+			const finalized = await evmRpc(client, "eth_getBlockByNumber", ["finalized", false]);
 			if (finalized !== null && typeof finalized === "object" && "number" in finalized && typeof finalized.number === "string" && "blockNumber" in receipt && typeof receipt.blockNumber === "string" && BigInt(receipt.blockNumber) <= BigInt(finalized.number)) return "finalized";
 		} catch {}
 		return "confirmed";
 	}
 };
-//#endregion
-//#region src/assets/controller.ts
+// src/assets/controller.ts
 /**
 * EVM balances per (account address, network). Native via eth_getBalance; token balanceOf calls go
 * through the network's Multicall3 (one aggregate eth_call) when the registry declares it,
@@ -2660,7 +3419,7 @@ var AssetsController = class extends Controller {
 			return;
 		}
 		const client = this.options.networks.client(network);
-		const native = BigInt(await this.rpcHex(client, "eth_getBalance", [address, "latest"])).toString();
+		const native = BigInt(await evmRpcHex(client, "eth_getBalance", [address, "latest"])).toString();
 		const custom = this.customTokens.get(network) ?? [];
 		const tokens = await this.readTokens(client, info.multicall3, address, custom.map((t) => ({
 			address: t.address,
@@ -2712,8 +3471,8 @@ var AssetsController = class extends Controller {
 		const balances = multicall3 === void 0 ? await Promise.all(tokens.map(async (t) => this.balanceOf(client, t.address, owner))) : await this.balanceOfBatch(client, multicall3, owner, tokens.map((t) => t.address));
 		return Promise.all(tokens.map(async (t, i) => ({
 			address: t.address,
-			symbol: await this.callString(client, t.address, "symbol") ?? "?",
-			decimals: await this.callNumber(client, t.address, "decimals") ?? 18,
+			symbol: await this.callToken(client, t.address, "symbol") ?? "?",
+			decimals: await this.callToken(client, t.address, "decimals") ?? 18,
 			balance: balances[i]?.toString() ?? "0",
 			verified: t.verified
 		})));
@@ -2732,7 +3491,7 @@ var AssetsController = class extends Controller {
 				})
 			}))]
 		});
-		const result = await this.rpcHex(client, "eth_call", [{
+		const result = await evmRpcHex(client, "eth_call", [{
 			to: multicall3,
 			data
 		}, "latest"]);
@@ -2753,7 +3512,7 @@ var AssetsController = class extends Controller {
 			functionName: "balanceOf",
 			args: [checked(owner)]
 		});
-		const result = await this.rpcHex(client, "eth_call", [{
+		const result = await evmRpcHex(client, "eth_call", [{
 			to: token,
 			data
 		}, "latest"]);
@@ -2764,32 +3523,12 @@ var AssetsController = class extends Controller {
 			data: result
 		});
 	}
-	async callString(client, token, fn) {
-		const data = encodeFunctionData({
-			abi: ERC20_ABI,
-			functionName: fn
-		});
-		const result = await this.rpcHex(client, "eth_call", [{
-			to: token,
-			data
-		}, "latest"]);
-		if (!isHex(result)) return;
-		try {
-			return decodeFunctionResult({
-				abi: ERC20_ABI,
-				functionName: fn,
-				data: result
-			});
-		} catch {
-			return;
-		}
-	}
-	async callNumber(client, token, fn) {
+	async callToken(client, token, fn) {
 		const data = encodeFunctionData({
 			abi: ERC20_ABI,
 			functionName: fn
 		});
-		const result = await this.rpcHex(client, "eth_call", [{
+		const result = await evmRpcHex(client, "eth_call", [{
 			to: token,
 			data
 		}, "latest"]);
@@ -2815,8 +3554,8 @@ var AssetsController = class extends Controller {
 			return;
 		}
 		const client = this.options.networks.client(network);
-		await this.callString(client, address, "symbol");
-		await this.callNumber(client, address, "decimals");
+		await this.callToken(client, address, "symbol");
+		await this.callToken(client, address, "decimals");
 		await this.persistToken(network, address);
 	}
 	async persistToken(network, address) {
@@ -2833,17 +3572,6 @@ var AssetsController = class extends Controller {
 			await this.engineStore.collection(COLLECTION$1).put("customTokens", new TextEncoder().encode(JSON.stringify(merged)));
 		}
 	}
-	async rpc(client, method, params) {
-		return client.transport.request({
-			method,
-			params
-		});
-	}
-	async rpcHex(client, method, params) {
-		const result = await this.rpc(client, method, params);
-		if (typeof result !== "string") throw new TypeError(`${method} returned a malformed result`);
-		return result;
-	}
 	/** BTC balance = confirmed spendable + own unconfirmed change; frozen 546/330 shown separately. */
 	async refreshBitcoin(xpub, network) {
 		const es = this.options.networks.esplora(network);
@@ -2878,8 +3606,7 @@ var AssetsController = class extends Controller {
 		}));
 	}
 };
-//#endregion
-//#region src/backup/errors.ts
+// src/backup/errors.ts
 var BackupControllerError = class extends Error {
 	category;
 	constructor(category, message) {
@@ -2888,8 +3615,7 @@ var BackupControllerError = class extends Error {
 		this.category = category;
 	}
 };
-//#endregion
-//#region src/backup/controller.ts
+// src/backup/controller.ts
 /**
 * The backup reconcile loop (design/backup.mdx "同步"): keeps the cloud file
 * `qntx-wallet-backup-<id>.json` in step with the vault. Single-flight — a trigger during a run
@@ -2928,17 +3654,15 @@ function parseRecord(bytes) {
 		const { digest } = o;
 		const { uploadedAt } = o;
 		const { walletIds } = o;
-		const { nostrKeyIds } = o;
 		if (typeof id !== "string" || !/^[0-9a-f]{32}$/.test(id)) return;
 		if (digest !== void 0 && (typeof digest !== "string" || !/^[0-9a-f]{64}$/.test(digest))) return;
 		if (uploadedAt !== void 0 && (typeof uploadedAt !== "number" || !Number.isSafeInteger(uploadedAt))) return;
-		if (!isStringArray(walletIds) || !isStringArray(nostrKeyIds)) return;
+		if (!isStringArray(walletIds)) return;
 		return {
 			id,
 			digest,
 			uploadedAt,
-			walletIds,
-			nostrKeyIds
+			walletIds
 		};
 	} catch {
 		return;
@@ -3055,8 +3779,7 @@ var BackupController = class extends Controller {
 				id,
 				digest: digestOf(text),
 				uploadedAt: previous?.uploadedAt,
-				walletIds: [],
-				nostrKeyIds: []
+				walletIds: []
 			});
 		}
 		try {
@@ -3086,20 +3809,10 @@ var BackupController = class extends Controller {
 	}
 	unprotected(snapshot, record) {
 		const covered = snapshot.backup !== null && record !== void 0 && record.id === snapshot.backup.id && record.digest !== void 0;
-		const wallets = snapshot.wallets.filter((w) => w.backup !== "mnemonic");
-		const keys = snapshot.nostr.keys.filter((k) => k.ref.kind === "standalone" && k.backedUp === false);
-		const walletIds = wallets.map((w) => w.walletId).filter((id) => !covered || !record.walletIds.includes(id));
-		const nostrKeyIds = keys.map((k) => k.publicKey).filter((id) => !covered || !record.nostrKeyIds.includes(id));
-		return {
-			walletIds: sorted(walletIds),
-			nostrKeyIds: sorted(nostrKeyIds)
-		};
+		return { walletIds: sorted(snapshot.wallets.filter((w) => w.backup !== "mnemonic").map((w) => w.walletId).filter((id) => !covered || !record.walletIds.includes(id))) };
 	}
 	coverage(snapshot) {
-		return {
-			walletIds: sorted(snapshot.wallets.map((w) => w.walletId)),
-			nostrKeyIds: sorted(snapshot.nostr.keys.filter((k) => k.ref.kind === "standalone").map((k) => k.publicKey))
-		};
+		return { walletIds: sorted(snapshot.wallets.map((w) => w.walletId)) };
 	}
 	setStatus(generation, status, error, record) {
 		if (generation !== this.generation) return;
@@ -3151,8 +3864,7 @@ var BackupController = class extends Controller {
 					id: adoption.id,
 					digest: adoption.digest,
 					uploadedAt: void 0,
-					walletIds: [],
-					nostrKeyIds: []
+					walletIds: []
 				};
 				if (generation !== this.generation) return;
 				await this.writeRecord(record);
@@ -3175,7 +3887,7 @@ var BackupController = class extends Controller {
 		}
 		const baseline = record !== void 0 && record.id === backup.id ? record.digest : void 0;
 		const cov = this.coverage(snapshot);
-		if (baseline !== void 0 && record !== void 0 && sameSet(cov.walletIds, record.walletIds) && sameSet(cov.nostrKeyIds, record.nostrKeyIds)) {
+		if (baseline !== void 0 && record !== void 0 && sameSet(cov.walletIds, record.walletIds)) {
 			this.setStatus(generation, "synced", void 0, record);
 			return;
 		}
@@ -3200,8 +3912,7 @@ var BackupController = class extends Controller {
 				id: backup.id,
 				digest,
 				uploadedAt: this.now(),
-				walletIds: cov.walletIds,
-				nostrKeyIds: cov.nostrKeyIds
+				walletIds: cov.walletIds
 			};
 			if (generation !== this.generation) return;
 			await this.writeRecord(next);
@@ -3224,10 +3935,7 @@ function defaultState() {
 		status: "locked",
 		backup: null,
 		uploadedAt: void 0,
-		unprotected: {
-			walletIds: [],
-			nostrKeyIds: []
-		},
+		unprotected: { walletIds: [] },
 		error: void 0
 	};
 }
@@ -3324,8 +4032,7 @@ function decodeMetaDocBytes(bytes) {
 		return;
 	}
 }
-//#endregion
-//#region src/meta/errors.ts
+// src/meta/errors.ts
 var MetaSyncError = class extends Error {
 	category;
 	constructor(category, message, cause) {
@@ -3334,15 +4041,15 @@ var MetaSyncError = class extends Error {
 		this.category = category;
 	}
 };
-//#endregion
-//#region src/meta/controller.ts
+// src/meta/controller.ts
 const META_SYNC_KIND = 30078;
 const PUBLISH_DEBOUNCE_MS = 2e3;
 /**
 * Wallet-metadata sync over kind-30078 addressable events: one NIP-44-encrypted document per
-* wallet, authored by its group-0 derived key. Pull always precedes publish in an unlock session —
-* replaceable events would otherwise let a stale local tree overwrite a newer remote document.
-* Debounced publishes are per wallet; a generation counter cancels in-flight write-backs on lock.
+* wallet, authored by its dedicated sync key (WD-070). Pull always precedes publish in an unlock
+* session — replaceable events would otherwise let a stale local tree overwrite a newer remote
+* document. Debounced publishes are per wallet; a generation counter cancels in-flight write-backs
+* on lock.
 */
 var MetaSyncController = class extends Controller {
 	options;
@@ -3414,19 +4121,6 @@ var MetaSyncController = class extends Controller {
 		const snap = this.options.wallet.getSnapshot();
 		await Promise.all(snap.wallets.map(async (w) => this.pullOne(w.walletId, gen)));
 	}
-	async pubkeyFor(signer) {
-		return signer.getPublicKey();
-	}
-	signerFor(walletId) {
-		const snap = this.options.wallet.getSnapshot();
-		const ref = {
-			kind: "derived",
-			walletId,
-			groupIndex: 0
-		};
-		if (!snap.nostr.keys.some((k) => k.ref.kind === "derived" && k.ref.walletId === walletId && k.ref.groupIndex === 0)) return;
-		return this.options.nostr.signer(ref);
-	}
 	setStatus(walletId, status) {
 		this.update((s) => ({
 			...s,
@@ -3439,15 +4133,11 @@ var MetaSyncController = class extends Controller {
 	async pullOne(walletId, gen) {
 		const config = this.options.metaSync;
 		if (config === void 0 || this.inflight.has(walletId)) return;
-		const signer = this.signerFor(walletId);
-		if (signer === void 0) {
-			if (gen === this.generation) this.setStatus(walletId, { status: "unavailable" });
-			return;
-		}
+		const signer = this.options.nostr.syncSigner(walletId);
 		this.inflight.add(walletId);
 		this.setStatus(walletId, { status: "syncing" });
 		try {
-			const pubkey = await this.pubkeyFor(signer);
+			const pubkey = await signer.getPublicKey();
 			const events = await config.relays.fetch(this.filterFor(pubkey, config.tag));
 			let remote;
 			let remoteSkipped = 0;
@@ -3467,8 +4157,7 @@ var MetaSyncController = class extends Controller {
 				this.setStatus(walletId, { status: "synced" });
 				if (hasEdits) await this.publishNow(walletId, gen);
 			} else {
-				const decrypt = signer.nip44Decrypt;
-				const plaintext = decrypt === void 0 ? void 0 : await decrypt.call(signer, pubkey, remote.content).catch(() => void 0);
+				const plaintext = await signer.decrypt(remote.content).catch(() => void 0);
 				const doc = plaintext === void 0 ? void 0 : decodeMetaDocBytes(new TextEncoder().encode(plaintext));
 				if (doc === void 0) {
 					if (gen !== this.generation) return;
@@ -3551,18 +4240,12 @@ var MetaSyncController = class extends Controller {
 	async publishNow(walletId, gen) {
 		const config = this.options.metaSync;
 		if (config === void 0 || !this.pulled.has(walletId)) return;
-		const signer = this.signerFor(walletId);
-		if (signer === void 0) {
-			this.setStatus(walletId, { status: "unavailable" });
-			return;
-		}
+		const signer = this.options.nostr.syncSigner(walletId);
 		try {
 			const bytes = encodeMetaDoc(this.exportDoc(walletId));
 			if (bytes === void 0) throw new MetaSyncError("internal", "meta doc exceeds 64 KB");
-			const encrypt = signer.nip44Encrypt;
-			if (encrypt === void 0) throw new MetaSyncError("internal", "signer lacks nip44 encryption");
-			const pubkey = await this.pubkeyFor(signer);
-			const content = await encrypt.call(signer, pubkey, new TextDecoder().decode(bytes));
+			const pubkey = await signer.getPublicKey();
+			const content = await signer.encrypt(new TextDecoder().decode(bytes));
 			const lastRemote = this.lastRemoteCreatedAt.get(walletId) ?? 0;
 			const created_at = Math.max(Math.floor(this.options.now() / 1e3), lastRemote + 1);
 			const event = await signer.signEvent({
@@ -3597,8 +4280,7 @@ function isUnsupportedDoc(plaintext) {
 		return false;
 	}
 }
-//#endregion
-//#region src/chains/bitcoin.ts
+// src/chains/bitcoin.ts
 const DUST = {
 	p2wpkh: 294,
 	p2tr: 330,
@@ -3733,8 +4415,8 @@ var BitcoinChainAdapter = class {
 				entry.nonWitnessUtxo = raw;
 			}
 			if (template === "btc.bip86") {
-				entry.tapInternalKey = pub.subarray(1);
-				entry.tapBip32Derivation = [[pub.subarray(1), {
+				entry.tapInternalKey = pub;
+				entry.tapBip32Derivation = [[pub, {
 					hashes: [],
 					der: {
 						fingerprint,
@@ -3790,8 +4472,7 @@ var BitcoinChainAdapter = class {
 		};
 	}
 };
-//#endregion
-//#region src/networks/controller.ts
+// src/networks/controller.ts
 /**
 * EVM network controller: the built-in registry plus host-provided and user-added RPC endpoints.
 * Each network gets a lazily-created viem PublicClient on a `fallback` transport — endpoints are
@@ -4064,8 +4745,7 @@ var NetworkController = class extends Controller {
 		if (store !== void 0) await store.collection("networks").put("customRpc", new TextEncoder().encode(JSON.stringify(customRpc)));
 	}
 };
-//#endregion
-//#region src/payments/parse.ts
+// src/payments/parse.ts
 /** Invoices with less than this much life left are treated as already expired. */
 const BOLT11_EXPIRY_GRACE_MS = 6e4;
 const invalid = (reason) => ({
@@ -4335,8 +5015,7 @@ function parsePayment(input, options) {
 		return invalid("malformed");
 	}
 }
-//#endregion
-//#region src/payments/resolve.ts
+// src/payments/resolve.ts
 /**
 * `parsePayment` plus LNURL dereferencing: an `lnurl` result is fetched and turned into a concrete
 * `lnurl-pay` / `lnurl-withdraw` request (`tag=login` endpoints report as unsupported). Network
@@ -4371,8 +5050,7 @@ async function resolvePayment(input, options) {
 		format: "lnurl-auth"
 	};
 }
-//#endregion
-//#region src/spark/notes.ts
+// src/spark/notes.ts
 const HEX64 = /^[0-9a-f]{64}$/;
 const isObject$4 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 const NOTE_FIELDS = /* @__PURE__ */ new Set([
@@ -4403,8 +5081,7 @@ function parsePaymentNote(value) {
 function encodePaymentNote(note) {
 	return new TextEncoder().encode(JSON.stringify(note));
 }
-//#endregion
-//#region src/spark/exit-chain-codec.ts
+// src/spark/exit-chain-codec.ts
 /**
 * SparkExitChain persistence codec: JSON with Uint8Arrays tagged `{ $b64: "…" }` — small and
 * explicit rather than schema-bound, so upstream field additions survive a round-trip.
@@ -4431,8 +5108,7 @@ function encodeExitChain(chain) {
 function decodeExitChain(bytes) {
 	return decodeValue(JSON.parse(new TextDecoder().decode(bytes)));
 }
-//#endregion
-//#region src/spark/store.ts
+// src/spark/store.ts
 const ALL = "__all__";
 /**
 * SparkStore over one EngineCollection: chains keyed by leafId, plus an index record listing them
@@ -4476,8 +5152,7 @@ function sparkStore(col) {
 		}
 	};
 }
-//#endregion
-//#region src/spark/controller.ts
+// src/spark/controller.ts
 const key = (ref) => `${ref.walletId}:${ref.groupIndex}:${ref.network}`;
 /** TransferId: the client and SO expect a UUIDv7 — mint it from the injected clock+random. */
 const transferId = (random, now) => uuidv7(random, now);
@@ -4894,6 +5569,14 @@ var SparkController = class extends Controller {
 			...params.memo === void 0 ? {} : { memo: params.memo }
 		}));
 	}
+	/** A fresh single-use L1 deposit address (with the SO's proof of possession). */
+	async newDepositAddress(ref) {
+		return this.guarded(async () => this.clientFor(ref).deposits.newAddress());
+	}
+	/** Claims a confirmed L1 deposit paying one of the account's unused deposit addresses. */
+	async claimDeposit(ref, transaction) {
+		await this.guarded(async () => this.clientFor(ref).deposits.claim({ transaction }));
+	}
 	async receiveAddress(ref) {
 		const state = this.getState().accounts[key(ref)];
 		await Promise.resolve();
@@ -4941,10 +5624,77 @@ var SparkController = class extends Controller {
 		});
 	}
 };
-//#endregion
-//#region src/transactions/bitcoin.ts
+// src/spark/deposit-claim.ts
+/**
+* Claims Spark deposits: once a transaction tagged `sparkDeposit` is confirmed, its raw bytes are
+* read from Esplora and handed to the Spark account's `deposits.claim`. Claiming too early (the SO
+* wants enough confirmations) just fails and is retried with backoff; locking stops everything.
+* Works only from the transaction state, so a restart resumes whatever is confirmed and unclaimed.
+*/
+const pending = (tx) => tx.sparkDeposit !== void 0 && tx.state === "confirmed" && tx.sparkDeposit.claimed !== true;
+var DepositClaimer = class {
+	options;
+	active = /* @__PURE__ */ new Map();
+	unsubscribe;
+	constructor(options) {
+		this.options = options;
+	}
+	/** Starts watching; every confirmed, unclaimed deposit already in the state is picked up. */
+	start() {
+		this.stop();
+		this.unsubscribe = this.options.transactions.store.subscribe(() => {
+			this.scan();
+		});
+		this.scan();
+	}
+	stop() {
+		this.unsubscribe?.();
+		this.unsubscribe = void 0;
+		for (const abort of this.active.values()) abort.abort();
+		this.active.clear();
+	}
+	scan() {
+		for (const tx of Object.values(this.options.transactions.getState().txs)) if (pending(tx) && !this.active.has(tx.id)) {
+			const abort = new AbortController();
+			this.active.set(tx.id, abort);
+			this.claim(tx.id, abort.signal);
+		}
+	}
+	async claim(id, signal) {
+		for (let failures = 0; !signal.aborted; failures += 1) {
+			const tx = this.options.transactions.getState().txs[id];
+			if (tx === void 0 || !pending(tx) || tx.sparkDeposit === void 0) break;
+			const { walletId, groupIndex, network: sparkNetwork } = tx.sparkDeposit;
+			try {
+				if (tx.hash === void 0) throw new Error("the deposit has no transaction id");
+				const raw = await this.options.networks.esplora(tx.network).get(`/tx/${tx.hash}/hex`);
+				if (typeof raw !== "string") throw new TypeError("esplora returned a malformed transaction");
+				await this.options.spark.claimDeposit({
+					walletId,
+					groupIndex,
+					network: sparkNetwork
+				}, hex.decode(raw.trim()));
+				if (signal.aborted) break;
+				await this.options.transactions.markDepositClaimed(id);
+				break;
+			} catch (error) {
+				this.options.logger.warn(`spark deposit ${id} not claimed yet`, error);
+				await eventsBackoff(failures, signal);
+			}
+		}
+		if (this.active.get(id)?.signal === signal) this.active.delete(id);
+	}
+};
+// src/transactions/bitcoin.ts
 /** Bitcoin route: scan → coin-select → PSBT → sign → broadcast, plus esplora status poll. */
 const isObject$3 = (v) => typeof v === "object" && v !== null;
+const broadcastPsbt = async (es, result) => {
+	if (result.kind !== "bitcoin.psbt" || !(result.signedPsbt instanceof Uint8Array)) throw new Error("unexpected bitcoin sign result");
+	const signed = Transaction.fromPSBT(result.signedPsbt);
+	signed.finalize();
+	const raw = signed.extract();
+	return String(await es.post("/tx", hex.encode(raw)));
+};
 const fetchRawTxes = async (es, utxos) => {
 	const out = /* @__PURE__ */ new Map();
 	await Promise.all(utxos.map(async (u) => {
@@ -4968,6 +5718,23 @@ const poll = async (ctx, tx) => {
 	if (!(isObject$3(status) && status["confirmed"] === true)) return;
 	return "confirmed";
 };
+const nextReceiveAddress = async (ctx, walletId, groupIndex, network) => {
+	const account = await (ctx.options.chains ?? chains(ctx.options.wallet)).account({
+		walletId,
+		groupIndex,
+		template: "btc.bip84",
+		network
+	});
+	if (!("xpub" in account) || account.xpub === void 0) throw new Error("bitcoin account carries no xpub");
+	const receive = await scanChain(ctx.options.networks.esplora(network), account.xpub, "btc.bip84", network, bitcoinNetwork(network).params, 0);
+	const next = new BitcoinScanStore().nextUnused({
+		addresses: receive,
+		utxos: [],
+		scannedAt: ctx.options.now()
+	}, 0);
+	if (next === void 0) throw new Error("no unused receive address");
+	return next.address;
+};
 /** Per-controller route — the UTXO store and the build stash are engine state. */
 const createBitcoinRoute = () => {
 	const bitcoin = new BitcoinChainAdapter();
@@ -4989,7 +5756,7 @@ const createBitcoinRoute = () => {
 	const releaseReservation = (requestId) => {
 		for (const [key, holder] of reserved) if (holder === requestId) reserved.delete(key);
 	};
-	const prepare = async (ctx, params, requestId) => {
+	const prepare = async (ctx, params, requestId, sparkDeposit) => {
 		const { account, network, to, amount, fee } = params;
 		if (account.kind !== "hd") throw new Error("imported accounts are not yet supported");
 		const es = ctx.options.networks.esplora(network);
@@ -5147,6 +5914,7 @@ const createBitcoinRoute = () => {
 				intent,
 				nonce: 0,
 				btc: record,
+				...sparkDeposit === void 0 ? {} : { sparkDeposit },
 				submittedAt: ctx.options.now(),
 				error: void 0
 			};
@@ -5157,26 +5925,12 @@ const createBitcoinRoute = () => {
 					verify
 				});
 				tx = await ctx.transition(tx, { state: "signed" });
-				if (result.kind !== "bitcoin.psbt" || !(result.signedPsbt instanceof Uint8Array)) throw new Error("unexpected bitcoin sign result");
-				const signed = Transaction.fromPSBT(result.signedPsbt);
-				signed.finalize();
-				const raw = signed.extract();
-				const hash = String(await es.post("/tx", hex.encode(raw)));
+				const hash = await broadcastPsbt(es, result);
 				bitcoinUtxos.lock(selectedUtxos, tx.id);
 				releaseReservation(requestId);
-				tx = await ctx.transition(tx, {
-					state: "submitted",
-					hash,
-					submittedAt: ctx.options.now()
-				});
-				ctx.track(tx.id, hash);
-				return tx;
+				return await submitTx(ctx, tx, hash);
 			} catch (error) {
-				const failed = tx.state === "signed" ? "failed" : "rejected";
-				await ctx.transition(tx, {
-					state: failed,
-					error: errorMessage$1(error)
-				});
+				await failTx(ctx, tx, error);
 				throw error;
 			}
 		};
@@ -5235,11 +5989,7 @@ const createBitcoinRoute = () => {
 					verify
 				});
 				tx = await ctx.transition(tx, { state: "signed" });
-				if (result.kind !== "bitcoin.psbt" || !(result.signedPsbt instanceof Uint8Array)) throw new Error("unexpected bitcoin sign result");
-				const signed = Transaction.fromPSBT(result.signedPsbt);
-				signed.finalize();
-				const raw = signed.extract();
-				const hash = String(await es.post("/tx", hex.encode(raw)));
+				const hash = await broadcastPsbt(es, result);
 				if (link.replaces !== void 0) bitcoinUtxos.endTx(old.id, "dropped");
 				bitcoinUtxos.lock(record.inputs.map((i) => ({
 					...i,
@@ -5247,19 +5997,9 @@ const createBitcoinRoute = () => {
 					height: 0
 				})), tx.id);
 				releaseReservation(requestId);
-				tx = await ctx.transition(tx, {
-					state: "submitted",
-					hash,
-					submittedAt: ctx.options.now()
-				});
-				ctx.track(tx.id, hash);
-				return tx;
+				return await submitTx(ctx, tx, hash);
 			} catch (error) {
-				const failed = tx.state === "signed" ? "failed" : "rejected";
-				await ctx.transition(tx, {
-					state: failed,
-					error: errorMessage$1(error)
-				});
+				await failTx(ctx, tx, error);
 				throw error;
 			}
 		};
@@ -5471,6 +6211,7 @@ const createBitcoinRoute = () => {
 	};
 	return {
 		prepare,
+		nextReceiveAddress,
 		poll: pollAndRelease,
 		prepareReplace,
 		prepareCpfp,
@@ -5481,17 +6222,50 @@ const createBitcoinRoute = () => {
 		}
 	};
 };
-//#endregion
-//#region src/transactions/evm.ts
+// src/transactions/evm.ts
 /** EVM route: native/ERC-20 send build → fee → decode → sign → broadcast, plus status poll. */
 const bump = (v) => (v * 11n + 9n) / 10n;
+const signSubmit = async (ctx, tx, apis, request, verify, broadcast) => {
+	let signed;
+	let tracked = tx;
+	try {
+		const result = await apis.sign({
+			request,
+			verify
+		});
+		tracked = await ctx.transition(tracked, { state: "signed" });
+		signed = result;
+	} catch (error) {
+		await ctx.transition(tracked, {
+			state: "rejected",
+			error: errorMessage$1(error)
+		});
+		throw error;
+	}
+	try {
+		const hash = await broadcast(signed);
+		tracked = await ctx.transition(tracked, {
+			state: "submitted",
+			hash,
+			submittedAt: ctx.options.now()
+		});
+		ctx.track(tracked.id, hash);
+		return tracked;
+	} catch (error) {
+		await ctx.transition(tracked, {
+			state: "failed",
+			error: errorMessage$1(error)
+		});
+		throw error;
+	}
+};
 /** Per-controller route — the adapter's nonce queue and the replace stash are engine state. */
 const createEvmRoute = () => {
 	const evm = new EvmChainAdapter();
 	/** In-memory build context keyed by tx id — the inputs a replace rebuilds from. */
 	const pending = /* @__PURE__ */ new Map();
-	const prepare = async (ctx, params) => {
-		const { account, network, to, amount, fee } = params;
+	const prepareSpec = async (ctx, spec) => {
+		const { account, network, fee } = spec;
 		const { networks } = ctx.options;
 		if (account.kind !== "hd") throw new Error("imported accounts are not yet supported");
 		const info = networks.info(network);
@@ -5514,16 +6288,7 @@ const createEvmRoute = () => {
 		} catch {
 			flags.push("reads-unverified");
 		}
-		const unsigned = await evm.build(client, network, from, params.token === void 0 ? {
-			kind: "native",
-			to,
-			value: amount
-		} : {
-			kind: "erc20",
-			token: params.token,
-			to,
-			value: amount
-		}, nonce);
+		const unsigned = await evm.build(client, network, from, spec.intent, nonce);
 		const quotes = await evm.estimateFee(client);
 		let quote = quotes.find((q) => q.tier === fee) ?? quotes[1];
 		if (quote === void 0) throw new Error("no fee quote");
@@ -5539,7 +6304,7 @@ const createEvmRoute = () => {
 			flags.push("reads-unverified");
 		}
 		const feed = evm.applyFee(unsigned, quote);
-		if (params.token === void 0 && feeReachesAmount(feed.gas * (feed.maxFeePerGas ?? feed.gasPrice ?? 0n), amount)) flags.push("fee-exceeds-amount");
+		if (spec.nativeValue !== void 0 && feeReachesAmount(feed.gas * (feed.maxFeePerGas ?? feed.gasPrice ?? 0n), spec.nativeValue)) flags.push("fee-exceeds-amount");
 		const request = evm.toSignRequest(feed, account, info.chainId);
 		const intent = decodeEvm(request);
 		const txId = newId(ctx.options.random);
@@ -5564,39 +6329,12 @@ const createEvmRoute = () => {
 				error: void 0
 			};
 			tx = await ctx.transition(tx, {});
-			let signed;
-			try {
-				const result = await apis.sign({
-					request,
-					verify
-				});
-				tx = await ctx.transition(tx, { state: "signed" });
-				signed = result;
-			} catch (error) {
-				await ctx.transition(tx, {
-					state: "rejected",
-					error: errorMessage$1(error)
-				});
-				throw error;
-			}
-			try {
+			return signSubmit(ctx, tx, apis, request, verify, async (signed) => {
 				const raw = evm.finalize(feed, signed);
 				const hash = await evm.broadcast(client, raw);
 				evm.commitNonce(network, from, unsigned.nonce);
-				tx = await ctx.transition(tx, {
-					state: "submitted",
-					hash,
-					submittedAt: ctx.options.now()
-				});
-				ctx.track(tx.id, hash);
-				return tx;
-			} catch (error) {
-				await ctx.transition(tx, {
-					state: "failed",
-					error: errorMessage$1(error)
-				});
-				throw error;
-			}
+				return hash;
+			});
 		};
 		return {
 			txId,
@@ -5609,6 +6347,44 @@ const createEvmRoute = () => {
 			release: () => void 0
 		};
 	};
+	const prepare = async (ctx, params) => prepareSpec(ctx, {
+		account: params.account,
+		network: params.network,
+		fee: params.fee,
+		intent: params.token === void 0 ? {
+			kind: "native",
+			to: params.to,
+			value: params.amount
+		} : {
+			kind: "erc20",
+			token: params.token,
+			to: params.to,
+			value: params.amount
+		},
+		nativeValue: params.token === void 0 ? params.amount : void 0
+	});
+	/**
+	* A dApp transaction, already normalized: only `to`, `value` and `data` are kept; nonce and fees
+	* are read again and the dApp's `gas` only raises the floor under our own estimate.
+	*/
+	const prepareCall = async (ctx, request) => {
+		const { tx } = request;
+		if (tx.to === void 0) throw new Error("contract creation is not supported");
+		const value = BigInt(tx.value);
+		return prepareSpec(ctx, {
+			account: request.account,
+			network: request.network,
+			fee: "normal",
+			intent: {
+				kind: "call",
+				to: tx.to,
+				value,
+				data: tx.data,
+				minGas: BigInt(tx.gas)
+			},
+			nativeValue: value > 0n ? value : void 0
+		});
+	};
 	/**
 	* EVM speed-up/cancel — replaces a pending tx at the same nonce with a bumped fee (cancel = a
 	* 0-value transfer to self). The fee is cross-checked and merged first, then the replacement
@@ -5685,38 +6461,7 @@ const createEvmRoute = () => {
 				error: void 0
 			};
 			tx = await ctx.transition(tx, {});
-			let signed;
-			try {
-				const result = await apis.sign({
-					request,
-					verify
-				});
-				tx = await ctx.transition(tx, { state: "signed" });
-				signed = result;
-			} catch (error) {
-				await ctx.transition(tx, {
-					state: "rejected",
-					error: errorMessage$1(error)
-				});
-				throw error;
-			}
-			try {
-				const raw = evm.finalize(unsigned, signed);
-				const hash = await evm.broadcast(client, raw);
-				tx = await ctx.transition(tx, {
-					state: "submitted",
-					hash,
-					submittedAt: ctx.options.now()
-				});
-				ctx.track(tx.id, hash);
-				return tx;
-			} catch (error) {
-				await ctx.transition(tx, {
-					state: "failed",
-					error: errorMessage$1(error)
-				});
-				throw error;
-			}
+			return signSubmit(ctx, tx, apis, request, verify, async (signed) => evm.broadcast(client, evm.finalize(unsigned, signed)));
 		};
 		return {
 			txId,
@@ -5740,6 +6485,7 @@ const createEvmRoute = () => {
 	};
 	return {
 		prepare,
+		prepareCall,
 		poll,
 		prepareReplace
 	};
@@ -5928,8 +6674,7 @@ var SolanaChainAdapter = class {
 		return BigInt(str(result, "0"));
 	}
 };
-//#endregion
-//#region src/transactions/solana.ts
+// src/transactions/solana.ts
 /** Solana route: SOL/SPL send → sign → broadcast, plus status poll with rebroadcast/drop. */
 /** The network's base signature fee, lamports per signature. */
 const BASE_FEE_LAMPORTS = 5000n;
@@ -6038,19 +6783,9 @@ const prepareSolana = async (ctx, params) => {
 			const wire = solana.finalize(messageBytes, [result.signature]);
 			const hash = await solana.broadcast(rpc, wire);
 			wires.set(id, wire);
-			tx = await ctx.transition(tx, {
-				state: "submitted",
-				hash,
-				submittedAt: ctx.options.now()
-			});
-			ctx.track(tx.id, hash);
-			return tx;
+			return await submitTx(ctx, tx, hash);
 		} catch (error) {
-			const failed = tx.state === "signed" ? "failed" : "rejected";
-			await ctx.transition(tx, {
-				state: failed,
-				error: errorMessage$1(error)
-			});
+			await failTx(ctx, tx, error);
 			throw error;
 		}
 	};
@@ -6123,13 +6858,7 @@ const token2022Intent = (intent, ext, mint, amount) => {
 		warnings
 	};
 };
-//#endregion
-//#region src/transactions/controller.ts
-/**
-* Transaction controller: orchestrates lifecycle, persistence and polling; each chain family routes
-* through its own module (`evm.ts`, `solana.ts`, `bitcoin.ts`). A rejected signature (wrong
-* password, cancelled presence) never broadcasts.
-*/
+// src/transactions/controller.ts
 const encode = (tx) => new TextEncoder().encode(JSON.stringify(tx));
 const isObject = (v) => typeof v === "object" && v !== null;
 const TX_STATES = /* @__PURE__ */ new Set([
@@ -6149,11 +6878,12 @@ const isBtcRecord = (v) => {
 	const { inputs, outputs, vsize, fee, feeRate } = v;
 	return Array.isArray(inputs) && Array.isArray(outputs) && typeof vsize === "number" && typeof fee === "number" && typeof feeRate === "number" && inputs.every((i) => isObject(i) && typeof i["txid"] === "string" && typeof i["vout"] === "number" && typeof i["value"] === "number" && typeof i["address"] === "string") && outputs.every((o) => isObject(o) && typeof o["address"] === "string" && typeof o["value"] === "number" && typeof o["own"] === "boolean");
 };
+const isSparkDeposit = (v) => isObject(v) && typeof v["walletId"] === "string" && typeof v["groupIndex"] === "number" && (v["network"] === "mainnet" || v["network"] === "regtest") && (v["claimed"] === void 0 || typeof v["claimed"] === "boolean");
 const isIntent = (v) => isObject(v) && typeof v["summary"] === "string" && Array.isArray(v["outflows"]) && typeof v["verifiability"] === "string";
 const decode = (raw) => {
 	const parsed = JSON.parse(new TextDecoder().decode(raw));
 	if (!isObject(parsed)) return;
-	const { id, family, network, account, hash, state, intent, nonce, replaces, parentId, btc, submittedAt, error } = parsed;
+	const { id, family, network, account, hash, state, intent, nonce, replaces, parentId, btc, sparkDeposit, submittedAt, error } = parsed;
 	if (typeof id !== "string" || family !== "evm" && family !== "solana" && family !== "bitcoin" || typeof network !== "string" || typeof account !== "string" || !isTxState(state) || typeof nonce !== "number" || typeof submittedAt !== "number") return;
 	return {
 		id,
@@ -6167,6 +6897,7 @@ const decode = (raw) => {
 		...typeof replaces === "string" ? { replaces } : {},
 		...typeof parentId === "string" ? { parentId } : {},
 		...isBtcRecord(btc) ? { btc } : {},
+		...isSparkDeposit(sparkDeposit) ? { sparkDeposit } : {},
 		submittedAt,
 		error: typeof error === "string" ? error : void 0
 	};
@@ -6255,16 +6986,77 @@ var TransactionController = class extends Controller {
 	* signing it. Bitcoin outputs it selects stay locked under `requestId` until the returned
 	* `release` runs or the broadcast moves them to the transaction.
 	*/
-	async prepareSend(params, requestId) {
+	async prepareSend(params, requestId, sparkDeposit) {
 		if (this.locked) throw new Error("transactions require an unlocked vault");
 		const { account, network } = params;
 		const info = this.options.networks.info(network);
 		if (account.kind !== "hd") throw new Error("imported accounts are not yet supported");
 		const ctx = this.routeCtx();
 		if (info.family === "solana") return prepareSolana(ctx, params);
-		if (info.family === "bitcoin") return this.bitcoinRoute.prepare(ctx, params, requestId);
+		if (info.family === "bitcoin") return this.bitcoinRoute.prepare(ctx, params, requestId, sparkDeposit);
 		return this.evmRoute.prepare(ctx, params);
 	}
+	/** The group's next unused `btc.bip84` receive address on a bitcoin `network`. */
+	async nextReceiveAddress(walletId, groupIndex, network) {
+		if (this.locked) throw new Error("transactions require an unlocked vault");
+		return this.bitcoinRoute.nextReceiveAddress(this.routeCtx(), walletId, groupIndex, network);
+	}
+	/** Records that a Spark deposit was credited; persisted with the transaction. */
+	async markDepositClaimed(id) {
+		const tx = this.getState().txs[id];
+		if (tx?.sparkDeposit === void 0) throw new Error(`transaction ${id} is not a Spark deposit`);
+		await this.transition(tx, { sparkDeposit: {
+			...tx.sparkDeposit,
+			claimed: true
+		} });
+	}
+	/**
+	* Internal entry for a dApp's EVM signature request: the request is normalized first, a
+	* transaction is rebuilt with fresh nonce and fees (the dApp's own are discarded), and a message
+	* is decoded and signed as is.
+	*/
+	async prepareDapp(account, request) {
+		if (this.locked) throw new Error("transactions require an unlocked vault");
+		const normalized = normalizeEvm(request);
+		if (account.kind !== "hd") throw new Error("imported accounts are not yet supported");
+		if (normalized.kind === "evm.transaction") return this.evmRoute.prepareCall(this.routeCtx(), {
+			account,
+			network: normalized.network,
+			tx: normalized.tx
+		});
+		if (normalized.kind !== "evm.personal-message" && normalized.kind !== "evm.typed-data") throw new Error(`unsupported dApp request ${normalized.kind}`);
+		const { kind, network } = normalized;
+		const apis = this.options.chains ?? chains(this.options.wallet);
+		return {
+			account,
+			network,
+			intent: decodeEvm(normalized),
+			checks: [],
+			staleReason: () => void 0,
+			release: () => void 0,
+			submit: async (verify) => {
+				const result = await apis.sign({
+					request: normalized.kind === "evm.personal-message" ? {
+						kind: normalized.kind,
+						network,
+						account,
+						message: normalized.message
+					} : {
+						kind: normalized.kind,
+						network,
+						account,
+						typedData: normalized.typedData
+					},
+					verify
+				});
+				if (result.kind !== kind || !("signature" in result)) throw new Error("unexpected sign result");
+				return {
+					kind,
+					signature: result.signature
+				};
+			}
+		};
+	}
 	/**
 	* Internal entry for replacements and CPFP: builds, cross-checks and reserves what the
 	* replacement needs without signing it. The original must be `submitted` or `pending`.
@@ -6315,8 +7107,7 @@ var TransactionController = class extends Controller {
 		this.timers.set(id, stop);
 	}
 };
-//#endregion
-//#region src/engine.ts
+// src/engine.ts
 /**
 * Composition root: wires the Wallet's lock state to the SparkController's lifecycle. Unlocked →
 * open the EngineStore and start every declared account; locked → abort event loops, close every
@@ -6409,11 +7200,44 @@ function createWalletEngine(options) {
 		wallet: options.wallet,
 		accounts,
 		addressBook,
-		nostr: { signer: (ref) => nostr(options.wallet).signer(ref) },
+		nostr: { syncSigner: (walletId) => nostr(options.wallet).syncSigner(walletId) },
 		metaSync: options.metaSync,
 		logger: options.logger,
 		now: options.now
 	});
+	const depositClaimer = new DepositClaimer({
+		transactions,
+		spark: controller,
+		networks,
+		logger: options.logger
+	});
+	const connections = new ConnectionController({
+		openStore: options.openStore,
+		random: options.random,
+		now: options.now,
+		logger: options.logger,
+		allowLocalhost: options.allowLocalhostOrigins ?? false,
+		selectedGroup: () => accounts.getState().selected ?? void 0,
+		evmAddress: async (group, network) => {
+			const account = await chains(options.wallet).account({
+				...group,
+				template: "evm.bip44",
+				network
+			});
+			if (!("address" in account)) throw new Error("no EVM address for the group");
+			return account.address;
+		},
+		enabledNetworks: () => networks.enabled("evm"),
+		invalidate: (origin) => {
+			requests.invalidateOrigin(origin);
+		}
+	});
+	const eip1193 = new Eip1193Handler({
+		connections,
+		requests,
+		networks,
+		defaultNetwork: () => networks.enabled("evm")[0] ?? "eip155:1"
+	});
 	let chain = Promise.resolve();
 	let store;
 	let started = false;
@@ -6441,8 +7265,12 @@ function createWalletEngine(options) {
 			await assets.init();
 			await transactions.init();
 			await requests.init();
+			await connections.init();
+			depositClaimer.start();
 		} else if (!unlocked && started) {
 			started = false;
+			depositClaimer.stop();
+			connections.lock();
 			requests.lock();
 			addressBook.lock();
 			transactions.lock();
@@ -6486,6 +7314,8 @@ function createWalletEngine(options) {
 		transactions,
 		requests,
 		addressBook,
+		connections,
+		eip1193,
 		spark: controller,
 		accounts,
 		metaSync,
@@ -6513,8 +7343,7 @@ function createWalletEngine(options) {
 		unsubscribe
 	};
 }
-//#endregion
-//#region src/backup/memory.ts
+// src/backup/memory.ts
 const tick = Promise.resolve();
 /** In-memory CloudStore for tests and the playground; swap the Map for cross-engine sharing. */
 function createMemoryCloudStore(backing) {
@@ -6546,7 +7375,6 @@ function createMemoryCloudStore(backing) {
 		}
 	};
 }
-//#endregion
-export { AccountTreeController, AccountTreeError, AddressBookController, AddressBookError, BackupController, BackupControllerError, Controller, EngineStoreError, MetaSyncController, MetaSyncError, PaymentError, REQUEST_TTL_MS, RequestController, SparkController, SparkControllerError, createEventBus, createMemoryCloudStore, createMemoryEngineStore, createWalletEngine, decodeExitChain, encodeExitChain, parsePayment, prepareZap, resolvePayment, sparkStore };
+export { AccountTreeController, AccountTreeError, AddressBookController, AddressBookError, BackupController, BackupControllerError, ConnectionController, Controller, Eip1193Handler, EngineStoreError, MetaSyncController, MetaSyncError, PaymentError, ProviderError, REQUEST_TTL_MS, RequestController, SparkController, SparkControllerError, createEventBus, createMemoryCloudStore, createMemoryEngineStore, createWalletEngine, decodeExitChain, encodeExitChain, parsePayment, prepareZap, resolvePayment, sparkStore };
 
 //# sourceMappingURL=index.mjs.map