@usebutr/bitcoin 1.1.0 → 2.0.0

package/dist/index.js

@@ -1,146 +1,69 @@
-import { buildAccount, buildWalletCapabilities, createWalletStandardCore, discoverWalletStandard, getFeature, slugify } from "@usebutr/wallet-standard-shared";
-import { base64ToBytes, bytesToBase64, bytesToHex, hexToBytes } from "@usebutr/core";
+import { BITCOIN_CHAINS, BITCOIN_CHAINS_LIST, ConnectionError, base64ToBytes, buildAccount, bytesToBase64, bytesToHex, hexToBytes, logWarn, resolveChain } from "@usebutr/core";
+import { createWalletStandardCore, discoverWalletStandard, getFeature, slugify } from "@usebutr/wallet-standard-shared";
+import { z } from "zod";
 
-//#region src/capabilities.ts
-/**
-* `signIn` is false: there is no Sign-In-With-Bitcoin standard, and BIP-322
-* is message-signing oriented rather than auth. `sendTransfer` leaves UTXO
-* selection, fees and broadcast to the wallet; `signPsbt` is sign-only.
-*/
-const resolveBitcoinCapabilities = (input) => buildWalletCapabilities({
-	chainCount: input.chainCount,
-	events: input.features.events,
-	sendTransaction: input.features.sendTransfer,
-	signIn: false,
-	signMessage: input.features.signMessage,
-	signTransaction: input.features.signPsbt
-});
-
-//#endregion
 //#region src/wallet-standard-adapter.ts
-const BITCOIN_PREFIX = "bip122:";
-const BITCOIN_DECIMALS = 8;
-const BITCOIN_MAINNET_ID = "bip122:000000000019d6689c085ae165831e93";
 /**
-* `sendTx` takes `{ amount, recipient }` for `bitcoin:sendTransfer` and
-* `signTransaction` takes raw PSBT bytes for `bitcoin:signPsbt`. Balance
-* and receipt reads would need an Esplora/Electrum client butr doesn't ship.
+* `bitcoin:sendTransfer` backs `sendTx` and `bitcoin:signPsbt` backs
+* `signTransaction`, both routing `options.chain` per call. Balance and
+* receipt reads would need an Esplora/Electrum client butr doesn't ship.
 */
 const buildBitcoinAdapter = (wallet, registerDisconnector) => {
 	const core = createWalletStandardCore({
-		chainPrefix: BITCOIN_PREFIX,
+		chains: BITCOIN_CHAINS_LIST,
 		id: slugify("btc", wallet.name),
 		label: "Bitcoin",
 		namespace: "bip122",
-		platform: "Bitcoin",
-		preferredChainIds: [BITCOIN_MAINNET_ID],
+		preferredChainIds: [BITCOIN_CHAINS.mainnet.id],
 		registerDisconnector,
 		trackChainChanges: true,
 		wallet
 	});
 	if (core === null) return null;
-	const signMessage = getFeature(wallet, "bitcoin:signMessage");
-	const signPsbt = getFeature(wallet, "bitcoin:signPsbt");
-	const sendTransfer = getFeature(wallet, "bitcoin:sendTransfer");
-	/** Resolve a caller-supplied target into a chain the wallet advertises,
-	*  accepting either a full CAIP-2 id or a bare genesis-hash reference. */
-	const resolveTargetChain = (targetChainId) => {
-		const candidate = targetChainId.startsWith(BITCOIN_PREFIX) ? targetChainId : `${BITCOIN_PREFIX}${targetChainId}`;
-		if (!wallet.chains.includes(candidate)) throw new Error(`Wallet ${wallet.name} does not advertise chain "${candidate}". Available: ${wallet.chains.join(", ")}`);
-		return candidate;
-	};
-	const sendTransferTx = async (tx, account, chain) => {
-		if (sendTransfer === void 0) throw new Error(`Wallet ${wallet.name} does not advertise bitcoin:sendTransfer`);
-		if (typeof tx !== "object" || tx === null || !("amount" in tx) || typeof tx.amount !== "bigint" || !("recipient" in tx) || typeof tx.recipient !== "string") throw new TypeError("Bitcoin sendTx expects { amount: bigint, recipient: string }: pass the recipient address and an amount in satoshis");
-		const { amount, recipient } = tx;
-		return (await sendTransfer.sendTransfer({
-			account: core.resolveAccount(account),
-			amount,
-			chain: chain ?? core.currentChainId(),
-			recipient
-		})).txid;
-	};
+	const sendTransfer = getFeature(wallet, "bitcoin:sendTransfer", "sendTransfer");
+	const signMessage = getFeature(wallet, "bitcoin:signMessage", "signMessage");
+	const signPsbt = getFeature(wallet, "bitcoin:signPsbt", "signPsbt");
 	return {
-		...core,
-		capabilities: resolveBitcoinCapabilities({
-			chainCount: core.chainCount,
-			features: {
-				events: core.hasEvents,
-				sendTransfer: Boolean(sendTransfer),
-				signMessage: Boolean(signMessage),
-				signPsbt: Boolean(signPsbt)
-			}
-		}),
+		...core.base,
 		chainPlatform: "bitcoin",
-		getBalance: () => Promise.resolve({
-			decimals: BITCOIN_DECIMALS,
-			formatted: "0",
-			symbol: "BTC",
-			value: 0n
-		}),
-		getTransactionReceipt: () => Promise.resolve({ status: "Pending" }),
-		async requestAccounts() {
-			await core.connect();
-		},
-		sendTx: (tx, account) => sendTransferTx(tx, account),
-		async sendTxToChain(tx, targetChainId, account, cb) {
-			const target = resolveTargetChain(targetChainId);
-			if (target !== core.currentChainId()) cb?.();
-			return await sendTransferTx(tx, account, target);
-		},
-		async signMessage(msg, account) {
-			if (signMessage === void 0) throw new Error(`Wallet ${wallet.name} does not advertise bitcoin:signMessage`);
+		...sendTransfer !== void 0 && { async sendTx({ amount, recipient }, options) {
+			return (await sendTransfer.sendTransfer({
+				account: core.resolveAccount(options?.account),
+				amount,
+				chain: core.resolveChainId(options?.chain),
+				recipient
+			})).txid;
+		} },
+		...signMessage !== void 0 && { async signMessage(message, options) {
 			const output = await signMessage.signMessage({
-				account: core.resolveAccount(account),
-				message: msg
+				account: core.resolveAccount(options?.account),
+				message
 			});
 			return {
 				signature: output.signature,
 				signedMessage: output.signedMessage
 			};
-		},
-		...signPsbt === void 0 ? {} : { async signTransaction(tx, account) {
-			const wsAccount = core.resolveAccount(account);
-			if (!(tx instanceof Uint8Array)) throw new TypeError("Bitcoin signTransaction expects a PSBT as Uint8Array (e.g. psbt.toBuffer())");
+		} },
+		...signPsbt !== void 0 && { async signTransaction(psbt, options) {
 			return (await signPsbt.signPsbt({
-				account: wsAccount,
-				chain: core.currentChainId(),
-				psbt: tx
+				account: core.resolveAccount(options?.account),
+				chain: core.resolveChainId(options?.chain),
+				psbt
 			})).signedPsbt;
 		} }
 	};
 };
 /** Requires the optional `@wallet-standard/app` peer dep. */
-const discoverBitcoinAdapters = (onAdapter) => discoverWalletStandard(onAdapter, (wallet, registerDisconnector) => buildBitcoinAdapter(wallet, registerDisconnector));
+const discoverBitcoinAdapters = (onAdapter) => discoverWalletStandard(onAdapter, buildBitcoinAdapter);
 
 //#endregion
-//#region src/chains.ts
-/**
-* CAIP-2 Bitcoin references are the first 8 bytes of each network's
-* genesis block hash, which is what wallets advertise in `wallet.chains`.
-* No major wallet exposes a switch-chain RPC, so chain stays local state.
-*/
-const BITCOIN_CHAINS = {
-	mainnet: {
-		id: "bip122:000000000019d6689c085ae165831e93",
-		name: "Bitcoin",
-		namespace: "bip122",
-		reference: "000000000019d6689c085ae165831e93"
-	},
-	signet: {
-		id: "bip122:00000008819873e925422c1ff0f99f7c",
-		name: "Bitcoin Signet",
-		namespace: "bip122",
-		reference: "00000008819873e925422c1ff0f99f7c"
-	},
-	testnet: {
-		id: "bip122:000000000933ea01ad0ee984209779ba",
-		name: "Bitcoin Testnet",
-		namespace: "bip122",
-		reference: "000000000933ea01ad0ee984209779ba"
-	}
+//#region src/injected/chain.ts
+const assertBitcoinChain = (chain) => {
+	if (chain.namespace !== "bip122") throw new Error(`Bitcoin adapter received non-Bitcoin chain "${chain.id}". Pass a chain with namespace "bip122".`);
 };
-const BITCOIN_CHAINS_LIST = Object.values(BITCOIN_CHAINS);
+/** An injected wallet has one network for every call, so a target it cannot
+*  move to is refused rather than sent on the network it happens to be on. */
+const chainMismatch = (wallet, current, target) => new ConnectionError("ChainMismatch", `Wallet ${wallet} is on ${current.name} and cannot switch to ${target.name}`);
 
 //#endregion
 //#region src/injected/icon.ts
@@ -152,36 +75,56 @@ const GENERIC_BITCOIN_ICON = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDov
 
 //#endregion
 //#region src/injected/sats-connect.ts
-const CAPS_SATS_CONNECT = {
-	getBalance: false,
-	getTransactionReceipt: false,
-	requestAccounts: true,
-	sendTransaction: true,
-	signIn: false,
-	signMessage: true,
-	signTransaction: true,
-	subscribe: false,
-	switchAccount: false,
-	switchChain: false
-};
 const ACCOUNT_PURPOSES = ["payment", "ordinals"];
 const CONNECT_MESSAGE = "Connect to butr";
+const networkNameSchema = z.enum([
+	"Mainnet",
+	"Regtest",
+	"Signet",
+	"Testnet",
+	"Testnet4"
+]);
+/** sats-connect names networks, not chains. Regtest sits outside butr's
+*  registry, so `resolveChain` names it by its CAIP-2 id. */
+const NETWORK_CHAIN_IDS = {
+	Mainnet: BITCOIN_CHAINS.mainnet.id,
+	Regtest: "bip122:0f9188f13cb7b2c71f2a335e3a4fc328",
+	Signet: BITCOIN_CHAINS.signet.id,
+	Testnet: BITCOIN_CHAINS.testnet.id,
+	Testnet4: BITCOIN_CHAINS.testnet4.id
+};
+const satsAddressSchema = z.object({
+	address: z.string(),
+	publicKey: z.string().optional(),
+	purpose: z.string().optional()
+});
+const accountResultSchema = z.union([z.array(satsAddressSchema), z.object({ addresses: z.array(satsAddressSchema) }).transform((result) => result.addresses)]);
+const networkResultSchema = z.object({ bitcoin: z.object({ name: networkNameSchema }) });
+const sendTransferResultSchema = z.object({ txid: z.string() });
+const signMessageResultSchema = z.object({
+	messageHash: z.string().optional(),
+	signature: z.string()
+});
+const signPsbtResultSchema = z.object({ psbt: z.string() });
+const changeNetworkResultSchema = z.unknown();
 const pickPaymentAddress = (addresses) => addresses.find((a) => a.purpose === "payment") ?? addresses[0];
+const networkFor = (chain) => Object.entries(NETWORK_CHAIN_IDS).find(([, chainId]) => chainId === chain.id)?.[0];
 /**
-* Only the payment address is exposed as an Account: sats-connect's
-* `sendTransfer` takes no sender and always debits it. The taproot ordinals
-* address stays reachable through `getSigner()` and `signMessage`'s account.
+* Only the payment address is an Account (`sendTransfer` always debits it); `signMessage` also
+* takes the ordinals address. The network is wallet-wide, so a call targeting another chain
+* moves it with `wallet_changeNetwork` first.
 */
 const buildSatsConnectAdapter = (id, name, provider) => {
 	let chain = BITCOIN_CHAINS.mainnet;
 	let session = { status: "disconnected" };
-	const callRequest = async (method, params) => {
+	const listeners = /* @__PURE__ */ new Set();
+	const callRequest = async (method, schema, params) => {
 		const response = await provider.request(method, params);
 		if (response.error) throw new Error(`[butr/bitcoin] sats-connect ${method} failed: ${response.error.message}`);
-		return response.result;
+		return schema.parse(response.result);
 	};
 	const startSession = async (method, params) => {
-		const addresses = (await callRequest(method, params))?.addresses ?? [];
+		const addresses = await callRequest(method, accountResultSchema, params);
 		const payment = pickPaymentAddress(addresses);
 		if (payment === void 0) throw new Error(`Wallet ${name} returned no addresses from ${method}`);
 		session = {
@@ -190,10 +133,12 @@ const buildSatsConnectAdapter = (id, name, provider) => {
 			status: "connected"
 		};
 	};
-	const requestSession = () => startSession("getAccounts", {
-		message: CONNECT_MESSAGE,
-		purposes: ACCOUNT_PURPOSES
-	});
+	const readSession = () => startSession("wallet_getAccount", { addresses: ACCOUNT_PURPOSES });
+	const readChain = async () => {
+		const result = await callRequest("wallet_getNetwork", networkResultSchema);
+		return resolveChain(NETWORK_CHAIN_IDS[result.bitcoin.name], BITCOIN_CHAINS_LIST);
+	};
+	const exposedAccounts = () => session.status === "connected" ? [buildAccount(session.payment, chain)] : [];
 	const requireSession = () => {
 		if (session.status !== "connected") throw new Error("No connected account");
 		return session;
@@ -205,199 +150,199 @@ const buildSatsConnectAdapter = (id, name, provider) => {
 		if (match === void 0) throw new Error(`Account ${account.walletAddress} is not exposed by ${name}`);
 		return match.address;
 	};
-	const sendTransferTx = async (tx, account) => {
-		const sender = resolveAddress(account);
-		if (sender !== requireSession().payment) throw new Error(`Wallet ${name} always debits its payment address; ${sender} cannot be used as the sender.`);
-		if (typeof tx !== "object" || tx === null || !("recipient" in tx) || typeof tx.recipient !== "string" || !("amount" in tx) || typeof tx.amount !== "bigint") throw new TypeError("Bitcoin sendTx expects { amount: bigint, recipient: string }: amount in satoshis");
-		const { amount, recipient } = tx;
-		return (await callRequest("sendTransfer", { recipients: [{
-			address: recipient,
-			amount: amount.toString()
-		}] })).txid;
+	const moveTo = async (target) => {
+		assertBitcoinChain(target);
+		const current = await readChain();
+		if (current.id !== target.id) {
+			const network = networkFor(target);
+			if (network === void 0) throw chainMismatch(name, current, target);
+			await callRequest("wallet_changeNetwork", changeNetworkResultSchema, { name: network });
+		}
+		if (chain.id === target.id) return;
+		await readSession();
+		chain = resolveChain(target.id, BITCOIN_CHAINS_LIST);
+		const accounts = exposedAccounts();
+		for (const listener of listeners) listener({
+			accounts,
+			type: "accountsChanged"
+		});
+	};
+	const prepare = async (options) => {
+		if (options?.chain !== void 0) await moveTo(options.chain);
+		return resolveAddress(options?.account);
 	};
 	return {
-		capabilities: CAPS_SATS_CONNECT,
 		chainPlatform: "bitcoin",
-		async connect(opts) {
-			if (opts?.silent === true) {
-				await startSession("wallet_getAccount", { addresses: ACCOUNT_PURPOSES });
-				return;
-			}
-			await requestSession();
+		async connect(options) {
+			await (options?.silent === true ? readSession() : startSession("getAccounts", {
+				message: CONNECT_MESSAGE,
+				purposes: ACCOUNT_PURPOSES
+			}));
+			try {
+				chain = await readChain();
+			} catch {}
 		},
 		disconnect: () => {
 			session = { status: "disconnected" };
 			return Promise.resolve();
 		},
-		getAccount: () => Promise.resolve(session.status === "connected" ? buildAccount(session.payment, chain) : null),
-		getAccounts: () => Promise.resolve(session.status === "connected" ? [buildAccount(session.payment, chain)] : []),
-		getBalance: () => Promise.resolve({
-			decimals: 8,
-			formatted: "0",
-			symbol: "BTC",
-			value: 0n
+		getAccounts: () => Promise.resolve(exposedAccounts()),
+		getSigner: () => Promise.resolve({
+			kind: "sats-connect",
+			provider
 		}),
-		getSigner: () => Promise.resolve(provider),
-		getTransactionReceipt: () => Promise.resolve({ status: "Pending" }),
 		icon: GENERIC_BITCOIN_ICON,
 		id,
 		name,
-		requestAccounts: () => requestSession(),
-		sendTx: (tx, account) => sendTransferTx(tx, account),
-		sendTxToChain: (tx, _targetChainId, account, cb) => {
-			cb?.();
-			return sendTransferTx(tx, account);
+		async sendTx({ amount, recipient }, options) {
+			const sender = await prepare(options);
+			if (sender !== requireSession().payment) throw new Error(`Wallet ${name} always debits its payment address; ${sender} cannot be used as the sender.`);
+			return (await callRequest("sendTransfer", sendTransferResultSchema, { recipients: [{
+				address: recipient,
+				amount: Number(amount)
+			}] })).txid;
 		},
-		async signMessage(msg, account) {
-			const address = resolveAddress(account);
-			const result = await callRequest("signMessage", {
+		async signMessage(message, options) {
+			const address = resolveAddress(options?.account);
+			const result = await callRequest("signMessage", signMessageResultSchema, {
 				address,
-				message: new TextDecoder().decode(msg)
+				message: new TextDecoder().decode(message)
 			});
 			return {
 				signature: base64ToBytes(result.signature),
-				signedMessage: msg
+				signedMessage: message
 			};
 		},
-		async signTransaction(tx) {
-			if (!(tx instanceof Uint8Array)) throw new TypeError("Bitcoin signTransaction expects a PSBT as Uint8Array (e.g. psbt.toBuffer())");
-			const result = await callRequest("signPsbt", { psbt: bytesToBase64(tx) });
+		async signTransaction(psbt, options) {
+			await prepare(options);
+			const result = await callRequest("signPsbt", signPsbtResultSchema, { psbt: bytesToBase64(psbt) });
 			return base64ToBytes(result.psbt);
 		},
-		switchChain: (target) => {
-			if (target.namespace !== "bip122") throw new Error(`Bitcoin adapter received non-Bitcoin chain "${target.id}". Pass a chain with namespace "bip122".`);
-			chain = target;
-			return Promise.resolve();
-		}
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		switchChain: moveTo
 	};
 };
 
 //#endregion
 //#region src/injected/unisat.ts
-const CAPS_UNISAT = {
-	getBalance: false,
-	getTransactionReceipt: false,
-	requestAccounts: true,
-	sendTransaction: true,
-	signIn: false,
-	signMessage: true,
-	signTransaction: true,
-	subscribe: true,
-	switchAccount: false,
-	switchChain: false
-};
+const NETWORK_CHAINS = /* @__PURE__ */ new Map([
+	["livenet", BITCOIN_CHAINS.mainnet],
+	["mainnet", BITCOIN_CHAINS.mainnet],
+	["signet", BITCOIN_CHAINS.signet],
+	["testnet", BITCOIN_CHAINS.testnet]
+]);
+const SWITCH_NETWORKS = /* @__PURE__ */ new Map([[BITCOIN_CHAINS.mainnet.id, "livenet"], [BITCOIN_CHAINS.testnet.id, "testnet"]]);
 const toStringArray = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 /**
-* The UniSat shape is consistent enough across `window.unisat`,
-* `window.okxwallet.bitcoin` and `window.btc` that one adapter covers all
-* three; the differences (network names, `sendBitcoin`) are probed per call.
+* One adapter covers `window.unisat`, `window.okxwallet.bitcoin` and `window.btc`.
+* The network is wallet-wide, so a call targeting another chain switches it
+* first, or rejects when the provider cannot switch.
 */
 const buildUnisatAdapter = (id, name, provider) => {
+	const getNetwork = provider.getNetwork?.bind(provider);
+	const on = provider.on?.bind(provider);
+	const sendBitcoin = provider.sendBitcoin?.bind(provider);
+	const switchNetwork = provider.switchNetwork?.bind(provider);
 	let chain = BITCOIN_CHAINS.mainnet;
-	const sendBitcoinTx = async (tx) => {
-		if (typeof provider.sendBitcoin !== "function") throw new TypeError(`Wallet ${name} does not expose sendBitcoin`);
-		if (typeof tx !== "object" || tx === null || !("recipient" in tx) || typeof tx.recipient !== "string" || !("amount" in tx) || typeof tx.amount !== "bigint") throw new TypeError("Bitcoin sendTx expects { amount: bigint, recipient: string }: amount in satoshis");
-		const { amount, recipient } = tx;
-		return await provider.sendBitcoin(recipient, Number(amount));
+	const readChain = async () => {
+		if (getNetwork === void 0) return chain;
+		const network = await getNetwork();
+		const match = NETWORK_CHAINS.get(network);
+		if (match === void 0) throw new Error(`Wallet ${name} reported an unknown network "${network}"`);
+		return match;
 	};
-	const refreshChain = async () => {
-		if (typeof provider.getNetwork !== "function") return;
+	const readAccounts = async () => {
+		const addresses = await provider.getAccounts();
+		if (addresses.length === 0) return [];
 		try {
-			const network = await provider.getNetwork();
-			if (network === "testnet") chain = BITCOIN_CHAINS.testnet;
-			else if (network === "signet") chain = BITCOIN_CHAINS.signet;
-			else chain = BITCOIN_CHAINS.mainnet;
+			chain = await readChain();
 		} catch {}
+		return addresses.map((address) => buildAccount(address, chain));
+	};
+	const assertActive = async (account) => {
+		if (account === void 0) return;
+		const [active] = await provider.getAccounts();
+		if (account.walletAddress !== active) throw new Error(`Wallet ${name} signs only with its active account, and ${account.walletAddress} is not it`);
+	};
+	const moveTo = async (target) => {
+		assertBitcoinChain(target);
+		chain = await readChain();
+		if (chain.id === target.id) return;
+		const network = SWITCH_NETWORKS.get(target.id);
+		if (switchNetwork === void 0 || network === void 0) throw chainMismatch(name, chain, target);
+		await switchNetwork(network);
+		chain = resolveChain(target.id, BITCOIN_CHAINS_LIST);
+	};
+	const prepare = async (options) => {
+		if (options?.chain !== void 0) await moveTo(options.chain);
+		await assertActive(options?.account);
 	};
 	return {
-		capabilities: CAPS_UNISAT,
 		chainPlatform: "bitcoin",
-		async connect(opts) {
-			if (opts?.silent === true) {
-				if ((await provider.getAccounts()).length === 0) throw new Error("No authorized accounts for silent reconnect");
-				await refreshChain();
+		async connect(options) {
+			if (options?.silent !== true) {
+				await provider.requestAccounts();
 				return;
 			}
-			await provider.requestAccounts();
-			await refreshChain();
-		},
-		disconnect: () => Promise.resolve(),
-		async getAccount() {
-			const first = (await provider.getAccounts())[0];
-			if (first === void 0) return null;
-			await refreshChain();
-			return buildAccount(first, chain);
+			if ((await provider.getAccounts()).length === 0) throw new Error("No authorized accounts for silent reconnect");
 		},
-		async getAccounts() {
-			const accounts = await provider.getAccounts();
-			if (accounts.length === 0) return [];
-			await refreshChain();
-			return accounts.map((a) => buildAccount(a, chain));
-		},
-		getBalance: () => Promise.resolve({
-			decimals: 8,
-			formatted: "0",
-			symbol: "BTC",
-			value: 0n
+		getAccounts: readAccounts,
+		getSigner: () => Promise.resolve({
+			kind: "unisat",
+			provider
 		}),
-		getSigner: () => Promise.resolve(provider),
-		getTransactionReceipt: () => Promise.resolve({ status: "Pending" }),
 		icon: GENERIC_BITCOIN_ICON,
 		id,
 		name,
-		async requestAccounts() {
-			await provider.requestAccounts();
-			await refreshChain();
-		},
-		sendTx: (tx) => sendBitcoinTx(tx),
-		sendTxToChain: (tx, _targetChainIdDecimal, _account, cb) => {
-			cb?.();
-			return sendBitcoinTx(tx);
-		},
-		async signMessage(msg) {
-			const text = new TextDecoder().decode(msg);
-			const signatureB64 = await provider.signMessage(text);
+		async signMessage(message, options) {
+			await assertActive(options?.account);
+			const signature = await provider.signMessage(new TextDecoder().decode(message));
 			return {
-				signature: base64ToBytes(signatureB64),
-				signedMessage: msg
+				signature: base64ToBytes(signature),
+				signedMessage: message
 			};
 		},
-		async signTransaction(tx) {
-			if (!(tx instanceof Uint8Array)) throw new TypeError("Bitcoin signTransaction expects a PSBT as Uint8Array (e.g. psbt.toBuffer())");
-			const signedHex = await provider.signPsbt(bytesToHex(tx));
-			return hexToBytes(signedHex);
+		async signTransaction(psbt, options) {
+			await prepare(options);
+			return hexToBytes(await provider.signPsbt(bytesToHex(psbt)));
 		},
-		subscribe(listener) {
+		...sendBitcoin !== void 0 && { async sendTx({ amount, recipient }, options) {
+			await prepare(options);
+			return sendBitcoin(recipient, Number(amount));
+		} },
+		...on !== void 0 && { subscribe: (listener) => {
+			const emit = (accounts) => {
+				listener(accounts.length === 0 ? { type: "disconnected" } : {
+					accounts,
+					type: "accountsChanged"
+				});
+			};
 			const onAccountsChanged = (...args) => {
-				const accounts = toStringArray(args[0]);
-				if (accounts.length === 0) {
-					listener({ type: "disconnected" });
-					return;
+				emit(toStringArray(args[0]).map((address) => buildAccount(address, chain)));
+			};
+			const reemitAccounts = async () => {
+				try {
+					emit(await readAccounts());
+				} catch (error) {
+					logWarn(`[butr] ${name} accounts could not be re-read after a network change:`, error);
 				}
-				const built = accounts.map((a) => buildAccount(a, chain));
-				const first = built[0];
-				if (first === void 0) return;
-				listener({
-					account: first,
-					accounts: built,
-					type: "accountChanged"
-				});
 			};
 			const onNetworkChanged = () => {
-				refreshChain();
+				reemitAccounts();
 			};
-			provider.on?.("accountsChanged", onAccountsChanged);
-			provider.on?.("networkChanged", onNetworkChanged);
+			on("accountsChanged", onAccountsChanged);
+			on("networkChanged", onNetworkChanged);
 			return () => {
 				provider.removeListener?.("accountsChanged", onAccountsChanged);
 				provider.removeListener?.("networkChanged", onNetworkChanged);
 			};
-		},
-		async switchChain(target) {
-			if (target.namespace !== "bip122") throw new Error(`Bitcoin adapter received non-Bitcoin chain "${target.id}". Pass a chain with namespace "bip122".`);
-			chain = target;
-			await refreshChain();
-		}
+		} },
+		...switchNetwork !== void 0 && { switchChain: moveTo }
 	};
 };
 
@@ -467,5 +412,5 @@ const bitcoinDiscoverer = {
 };
 
 //#endregion
-export { BITCOIN_CHAINS, BITCOIN_CHAINS_LIST, GENERIC_BITCOIN_ICON, bitcoinDiscoverer, buildBitcoinAdapter, discoverBitcoinAdapters, discoverInjectedBitcoinAdapter, resolveBitcoinCapabilities };
+export { GENERIC_BITCOIN_ICON, bitcoinDiscoverer, buildBitcoinAdapter, discoverBitcoinAdapters, discoverInjectedBitcoinAdapter };
 //# sourceMappingURL=index.js.map