@qntx/wallet-engine 0.4.0 → 0.5.2

package/dist/index.mjs

@@ -2,11 +2,25 @@ import { createStore } from "zustand/vanilla";
 import { SparkInputError, bitcoinAddressScript, createSparkClient, decodeBolt11, decodeSparkAddress, encodeSparkAddress, parseSparkInvoice, uuidv7 } from "@qntx/spark";
 import { nostr } from "@qntx/wallet/nostr";
 import { spark } from "@qntx/wallet/spark";
+import { createPublicClient, decodeFunctionResult, encodeFunctionData, fallback, http, isAddress, isHex, numberToHex } from "viem";
+import { bitcoinAddressFromXpub, bitcoinNetwork, bitcoinPubkeyFromXpub, decodeBitcoinPsbt } from "@qntx/wallet-chains/bitcoin";
+import { chains } from "@qntx/wallet/chains";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { Address, OutScript, Transaction } from "@scure/btc-signer";
+import { checksumEvmAddress, decodeEvm } from "@qntx/wallet-chains/evm";
+import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";
 import { parseBackupHeader } from "@qntx/wallet";
 import { signedMatchesUnsigned, verifyEvent } from "@qntx/nostr";
+import { base64, hex } from "@scure/base";
+import { p2wpkh } from "@scure/btc-signer/payment.js";
+import { selectUTXO } from "@scure/btc-signer/utxo.js";
 import { decodeLnurl, encodeLnurl, lightningAddressUrl, registerLightningAddress, requestInvoice, resolveLnurl, submitWithdraw, unregisterLightningAddress } from "@qntx/spark/lnurl";
 import { makeZapRequest } from "@qntx/nostr/nips/nip57";
-import { base64 } from "@scure/base";
+import { PROGRAM_IDS, decodeSolana, netAfterTransferFee, parseMintExtensions } from "@qntx/wallet-chains/solana";
+import { getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction } from "@solana-program/compute-budget";
+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
 /**
 * Controller base: a zustand vanilla store plus lifecycle. `update` applies a recipe that must
@@ -119,6 +133,185 @@ function createMemoryEngineStore(backing) {
 	};
 }
 //#endregion
+//#region 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
+* addresses/txs/UTXOs in EngineStore (rebuildable from a rescan), and exposes the next unused
+* receive/change address.
+*/
+const GAP = 20;
+const isObject$10 = (v) => typeof v === "object" && v !== null;
+const isUnknownArray = (v) => Array.isArray(v);
+const asArray = (v) => isUnknownArray(v) ? v : [];
+/** The scriptPubKey bytes of a bech32/base58 address on `network`. */
+const scriptPubKey = (address, network) => OutScript.encode(Address(network).decode(address));
+/** Esplora scripthash: sha256 of the scriptPubKey, digest hex as-is (verified vs electrs REST). */
+const scripthash = (address, network) => [...sha256(OutScript.encode(Address(network).decode(address)))].map((b) => b.toString(16).padStart(2, "0")).join("");
+const windowUsed = async (es, params, addrs) => Promise.all(addrs.map(async (a) => {
+	const txs = await es.get(`/scripthash/${scripthash(a.address, params)}/txs`);
+	return isUnknownArray(txs) && txs.length > 0;
+}));
+const scanChain = async (es, xpub, template, network, params, chain, start = 0) => {
+	const batch = Array.from({ length: GAP }, (_, i) => {
+		const index = start + i;
+		return {
+			chain,
+			index,
+			address: bitcoinAddressFromXpub(xpub, template, network, chain, index),
+			used: false
+		};
+	});
+	const used = await windowUsed(es, params, batch);
+	const marked = batch.map((a, i) => ({
+		chain: a.chain,
+		index: a.index,
+		address: a.address,
+		used: used[i] === true
+	}));
+	if (!marked.some((a) => a.used)) return marked;
+	const rest = await scanChain(es, xpub, template, network, params, chain, start + GAP);
+	return [...marked, ...rest];
+};
+const scanAddressUtxos = async (es, a, params) => {
+	const utxos = await es.get(`/scripthash/${scripthash(a.address, params)}/utxo`);
+	return asArray(utxos).flatMap((u) => {
+		const o = isObject$10(u) ? u : {};
+		const status = isObject$10(o["status"]) ? o["status"] : {};
+		const txid = typeof o["txid"] === "string" ? o["txid"] : "";
+		if (txid === "") return [];
+		return [{
+			txid,
+			vout: typeof o["vout"] === "number" ? o["vout"] : 0,
+			value: typeof o["value"] === "number" ? o["value"] : 0,
+			address: a.address,
+			height: typeof status["block_height"] === "number" ? status["block_height"] : 0
+		}];
+	});
+};
+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());
+};
+const str$1 = (v) => typeof v === "string" ? v : void 0;
+const num = (v) => typeof v === "number" ? v : void 0;
+const toScanUtxo = (v) => {
+	if (!isObject$10(v)) return [];
+	const txid = str$1(v["txid"]);
+	const vout = num(v["vout"]);
+	const value = num(v["value"]);
+	const address = str$1(v["address"]);
+	const height = num(v["height"]);
+	return txid !== void 0 && vout !== void 0 && value !== void 0 && address !== void 0 ? [{
+		txid,
+		vout,
+		value,
+		address,
+		height: height ?? 0
+	}] : [];
+};
+const toLockedUtxo = (v) => {
+	const [base] = toScanUtxo(v);
+	if (base === void 0 || !isObject$10(v)) return;
+	const status = str$1(v["status"]);
+	const txId = str$1(v["txId"]);
+	if (status !== "confirmed" && status !== "locked" && status !== "frozen") return;
+	return txId === void 0 ? {
+		txid: base.txid,
+		vout: base.vout,
+		value: base.value,
+		address: base.address,
+		height: base.height,
+		status
+	} : {
+		txid: base.txid,
+		vout: base.vout,
+		value: base.value,
+		address: base.address,
+		height: base.height,
+		status,
+		txId
+	};
+};
+var BtcUtxoStore = class BtcUtxoStore {
+	engineStore;
+	utxos = /* @__PURE__ */ new Map();
+	async unlock(store) {
+		this.engineStore = store;
+		const raw = await store.collection("btc-utxos").get("state");
+		this.utxos = raw === void 0 ? /* @__PURE__ */ new Map() : new Map(Object.entries((() => {
+			const rawParsed = JSON.parse(new TextDecoder().decode(raw));
+			const parsed = isObject$10(rawParsed) ? rawParsed : {};
+			const pairs = Object.entries(parsed).flatMap(([k, v]) => {
+				const u = toLockedUtxo(v);
+				return u === void 0 ? [] : [[k, u]];
+			});
+			return Object.fromEntries(pairs);
+		})()));
+	}
+	async persist() {
+		const store = this.engineStore;
+		if (store !== void 0) await store.collection("btc-utxos").put("state", new TextEncoder().encode(JSON.stringify(Object.fromEntries(this.utxos))));
+	}
+	static key(u) {
+		return `${u.txid}:${u.vout}`;
+	}
+	replace(utxos) {
+		const locked = [...this.utxos.entries()].filter(([, u]) => u.status === "locked" || u.status === "frozen");
+		this.utxos = new Map(utxos.map((u) => [BtcUtxoStore.key(u), {
+			txid: u.txid,
+			vout: u.vout,
+			value: u.value,
+			address: u.address,
+			height: u.height,
+			status: "confirmed"
+		}]));
+		for (const [k, u] of locked) this.utxos.set(k, u);
+	}
+	lock(utxos, txId) {
+		for (const u of utxos) this.utxos.set(BtcUtxoStore.key(u), {
+			txid: u.txid,
+			vout: u.vout,
+			value: u.value,
+			address: u.address,
+			height: u.height,
+			status: "locked",
+			txId
+		});
+		this.persist();
+	}
+	/** Released on failed/rejected/dropped; spent-removed on confirmed. */
+	endTx(txId, final) {
+		if (final === "confirmed") {
+			for (const [k, u] of this.utxos) if (u.txId === txId) this.utxos.delete(k);
+		} else for (const [k, u] of this.utxos) if (u.txId === txId && u.status === "locked") this.utxos.set(k, {
+			txid: u.txid,
+			vout: u.vout,
+			value: u.value,
+			address: u.address,
+			height: u.height,
+			status: "confirmed"
+		});
+		this.persist();
+	}
+	spendable() {
+		return [...this.utxos.values()].filter((u) => u.status === "confirmed" && !(u.value === 546 || u.value === 330));
+	}
+	frozen() {
+		return [...this.utxos.values()].filter((u) => u.status === "frozen" || u.value === 546 || u.value === 330);
+	}
+	all() {
+		return [...this.utxos.values()];
+	}
+	lockStore() {
+		this.engineStore = void 0;
+	}
+};
+//#endregion
+//#region src/transactions/route.ts
+const newId = (random) => `tx-${[...random(8)].map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+const errorMessage = (error) => error instanceof Error ? error.message : String(error);
+//#endregion
 //#region src/accounts/errors.ts
 var AccountTreeError = class extends Error {
 	category;
@@ -262,6 +455,18 @@ function encodeTree(tree) {
 * selected again). The active account's `balanceSats` feeds `totals`, debounced 1 s before
 * persist.
 */
+const check = async (family, run) => {
+	try {
+		return [family, { used: await run() }];
+	} catch (error) {
+		return [family, {
+			used: false,
+			error: errorMessage(error)
+		}];
+	}
+};
+const evmAddress = (v) => typeof v === "string" && isAddress(v) ? v : void 0;
+const addressOf = (v) => typeof v === "string" ? v : void 0;
 var AccountTreeController = class extends Controller {
 	options;
 	col;
@@ -646,6 +851,125 @@ var AccountTreeController = class extends Controller {
 		}
 		return found;
 	}
+	/**
+	* Per-group chain-family discovery — same stop rule as `discoverSpark`: group 0 always, stop
+	* after two consecutive fully-unused groups. A family error is reported on the group and does NOT
+	* count as unused (the group stays in `found` — it can't be proven empty).
+	*/
+	async discoverGroups(walletId) {
+		this.mustWallet(walletId);
+		const apis = this.options.chains ?? chains(this.options.wallet);
+		const nets = this.options.networks;
+		const found = [0];
+		let index = 0;
+		let unused = 0;
+		while (index < 65) {
+			const groupIndex = index;
+			const evm = async () => {
+				if (nets === void 0) return false;
+				return (await Promise.all(nets.enabled("evm").map(async (network) => {
+					const acct = await apis.account({
+						walletId,
+						groupIndex,
+						template: "evm.bip44",
+						network
+					});
+					const address = "address" in acct ? evmAddress(acct.address) : void 0;
+					if (address === void 0) return false;
+					const client = nets.client(network);
+					const [nonce, balance] = await Promise.all([client.getTransactionCount({
+						address,
+						blockTag: "latest"
+					}), client.getBalance({ address })]);
+					return nonce > 0 || balance > 0n;
+				}))).some(Boolean);
+			};
+			const solana = async () => {
+				if (nets === void 0) return false;
+				return (await Promise.all(nets.enabled("solana").map(async (network) => {
+					const acct = await apis.account({
+						walletId,
+						groupIndex,
+						template: "solana.bip44-change",
+						network
+					});
+					const address = "address" in acct ? addressOf(acct.address) : void 0;
+					if (address === void 0) return false;
+					const sigs = await nets.solanaRpc(network).call("getSignaturesForAddress", [address, { limit: 1 }]);
+					return Array.isArray(sigs) && sigs.length > 0;
+				}))).some(Boolean);
+			};
+			const bitcoin = async () => {
+				if (nets === void 0) return false;
+				const combos = nets.enabled("bitcoin").flatMap((network) => [
+					"btc.bip44",
+					"btc.bip49",
+					"btc.bip84",
+					"btc.bip86"
+				].map((template) => [network, template]));
+				return (await Promise.all(combos.map(async ([network, template]) => {
+					const net = bitcoinNetwork(network);
+					const es = nets.esplora(network);
+					const acct = await apis.account({
+						walletId,
+						groupIndex,
+						template,
+						network
+					});
+					const xpub = "xpub" in acct ? acct.xpub : void 0;
+					if (xpub === void 0) return false;
+					const [receive, change] = await Promise.all([scanChain(es, xpub, template, network, net.params, 0), scanChain(es, xpub, template, network, net.params, 1)]);
+					return receive.some((a) => a.used) || change.some((a) => a.used);
+				}))).some(Boolean);
+			};
+			const spark = async () => {
+				const ref = {
+					walletId,
+					groupIndex,
+					network: this.options.sparkNetwork
+				};
+				const { used } = await this.options.spark.inspect(ref);
+				return used;
+			};
+			const results = await Promise.all([
+				check("spark", spark),
+				check("evm", evm),
+				check("solana", solana),
+				check("bitcoin", bitcoin)
+			]);
+			const usedMap = Object.fromEntries(results.map(([k, v]) => [k, v.used]));
+			const errorMap = Object.fromEntries(results.flatMap(([k, v]) => v.error === void 0 ? [] : [[k, v.error]]));
+			const anyUsed = results.some(([, v]) => v.used);
+			const anyError = results.some(([, v]) => v.error !== void 0);
+			this.mutateGroups(walletId, (list) => {
+				const have = list.some((g) => g.index === groupIndex);
+				const updatedAt = this.options.now();
+				if (!have) return [...list, {
+					walletId,
+					index: groupIndex,
+					hidden: false,
+					used: usedMap,
+					errors: errorMap,
+					updatedAt
+				}].sort((a, b) => a.index - b.index);
+				return list.map((g) => g.index === groupIndex ? {
+					...g,
+					used: usedMap,
+					errors: errorMap,
+					updatedAt
+				} : g);
+			});
+			if (anyUsed || anyError) {
+				if (index !== 0 && anyUsed) found.push(index);
+				unused = 0;
+			} else {
+				unused += 1;
+				if (index !== 0 && unused >= 2) break;
+			}
+			index += 1;
+		}
+		return found;
+	}
 	/** Refresh `totals` for every other visible group; per-group failures are logged and skipped. */
 	async refreshTotals() {
 		const state = this.getState();
@@ -815,635 +1139,589 @@ function persistedToState(tree) {
 	};
 }
 //#endregion
-//#region ../../node_modules/.bun/@noble+hashes@2.4.0/node_modules/@noble/hashes/_u64.js
-const fromNumH = (n) => n / 2 ** 32 | 0;
-const fromNumL = (n) => n >>> 0;
-function setU64FromNum(view, byteOffset, n, isLE) {
-	const h = fromNumH(n);
-	const l = fromNumL(n);
-	view.setUint32(byteOffset, isLE ? l : h, isLE);
-	view.setUint32(byteOffset + 4, isLE ? h : l, isLE);
-}
-//#endregion
-//#region ../../node_modules/.bun/@noble+hashes@2.4.0/node_modules/@noble/hashes/utils.js
-/**
-* Checks if something is Uint8Array. Be careful: nodejs Buffer will return true.
-* @param a - value to test
-* @returns `true` when the value is a Uint8Array-compatible view.
-* @example
-* Check whether a value is a Uint8Array-compatible view.
-* ```ts
-* isBytes(new Uint8Array([1, 2, 3]));
-* ```
-*/
-function isBytes(a) {
-	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
-}
-const atitle = (title) => title ? `"${title}" ` : "";
-/**
-* Asserts something is a non-negative integer.
-* @param n - number to validate
-* @param title - label included in thrown errors
-* @returns The validated number.
-* @throws On wrong argument types. {@link TypeError}
-* @throws On wrong argument ranges or values. {@link RangeError}
-* @example
-* Validate a non-negative integer option.
-* ```ts
-* anumber(32, 'length');
-* ```
-*/
-function anumber(n, title = "") {
-	if (typeof n !== "number") throw new TypeError(atitle(title) + "expected number, got " + typeof n);
-	if (!Number.isSafeInteger(n) || n < 0) throw new RangeError(atitle(title) + "expected integer >= 0, got " + n);
-	return n;
-}
+//#region src/chains/evm.ts
 /**
-* Asserts something is Uint8Array.
-* @param value - value to validate
-* @param length - optional exact length constraint
-* @param title - label included in thrown errors
-* @returns The validated byte array.
-* @throws On wrong argument types. {@link TypeError}
-* @throws On wrong argument ranges or values. {@link RangeError}
-* @example
-* Validate that a value is a byte array.
-* ```ts
-* abytes(new Uint8Array([1, 2, 3]));
-* ```
+* 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 +
+* priority); networks that cannot answer feeHistory fall back to eth_gasPrice. gas = estimateGas ×
+* 1.2 (ceil). Nonces are allocated on a per-(network, from) serial queue as max(pending count, last
+* submitted + 1). Finalization uses the `finalized` block tag; receipts with status 0 fail.
 */
-function abytes(value, length, title = "") {
-	if (isBytes(value) && (length === void 0 || value.length === length)) return value;
-	if (length !== void 0) anumber(length, "length");
-	const bytes = isBytes(value);
-	const ofLen = length !== void 0 ? ` of length ${length}` : "";
-	const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
-	const message = atitle(title) + "expected Uint8Array" + ofLen + ", got " + got;
-	if (!bytes) throw new TypeError(message);
-	throw new RangeError(message);
-}
-const aobject = (value, label) => {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError((label === "object" ? "" : `"${label}" `) + "expected object, got type=" + typeof value);
+const ERC20_ABI = [
+	{
+		type: "function",
+		name: "transfer",
+		inputs: [{
+			name: "to",
+			type: "address"
+		}, {
+			name: "value",
+			type: "uint256"
+		}],
+		outputs: [{
+			name: "",
+			type: "bool"
+		}],
+		stateMutability: "nonpayable"
+	},
+	{
+		type: "function",
+		name: "balanceOf",
+		inputs: [{
+			name: "account",
+			type: "address"
+		}],
+		outputs: [{
+			name: "",
+			type: "uint256"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "symbol",
+		inputs: [],
+		outputs: [{
+			name: "",
+			type: "string"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "decimals",
+		inputs: [],
+		outputs: [{
+			name: "",
+			type: "uint8"
+		}],
+		stateMutability: "view"
+	}
+];
+const checkedAddress = (v) => {
+	if (!isAddress(v)) throw new TypeError(`malformed evm address: ${v}`);
+	return v;
 };
-const aopts = (value, label) => {
-	aobject(value, label);
-	const proto = Object.getPrototypeOf(value);
-	if (proto !== Object.prototype && proto !== null) throw new TypeError(`"${label}" expected plain object`);
-	if (Object.hasOwn(value, "__proto__")) throw new TypeError(`"${label}.__proto__" is not allowed`);
-};
-/**
-* Asserts a hash instance has not been destroyed or finished.
-* @param instance - hash instance to validate
-* @param checkFinished - whether to reject finalized instances
-* @throws If the hash instance has already been destroyed or finalized. {@link Error}
-* @example
-* Validate that a hash instance is still usable.
-* ```ts
-* import { aexists } from '@noble/hashes/utils.js';
-* import { sha256 } from '@noble/hashes/sha2.js';
-* const hash = sha256.create();
-* aexists(hash);
-* ```
-*/
-function aexists(instance, checkFinished = true) {
-	if (instance.destroyed) throw new Error("hash was destroyed");
-	if (checkFinished && instance.finished) throw new Error("digest() was already called");
-}
-/**
-* Asserts output is a sufficiently-sized byte array.
-* @param out - destination buffer
-* @param instance - hash instance providing output length
-* Oversized buffers are allowed; downstream code only promises to fill the first `outputLen` bytes.
-* @throws On wrong argument types. {@link TypeError}
-* @throws On wrong argument ranges or values. {@link RangeError}
-* @example
-* Validate a caller-provided digest buffer.
-* ```ts
-* import { aoutput } from '@noble/hashes/utils.js';
-* import { sha256 } from '@noble/hashes/sha2.js';
-* const hash = sha256.create();
-* aoutput(new Uint8Array(hash.outputLen), hash);
-* ```
-*/
-function aoutput(out, instance) {
-	abytes(out, void 0, "output");
-	const min = instance.outputLen;
-	if (!(out.length >= min)) throw new RangeError("\"output\" expected length >= " + min);
-}
-/**
-* Zeroizes typed arrays in place. Warning: JS provides no guarantees.
-* @param arrays - arrays to overwrite with zeros
-* @example
-* Zeroize sensitive buffers in place.
-* ```ts
-* clean(new Uint8Array([1, 2, 3]));
-* ```
-*/
-function clean(...arrays) {
-	for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
-}
-/**
-* Creates a DataView for byte-level manipulation.
-* @param arr - source typed array
-* @returns DataView over the same buffer region.
-* @example
-* Create a DataView over an existing buffer.
-* ```ts
-* createView(new Uint8Array(4));
-* ```
-*/
-function createView(arr) {
-	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-/**
-* Rotate-right operation for uint32 values.
-* @param word - source word
-* @param shift - shift amount in bits
-* @returns Rotated word.
-* @example
-* Rotate a 32-bit word to the right.
-* ```ts
-* rotr(0x12345678, 8);
-* ```
-*/
-function rotr(word, shift) {
-	return word << 32 - shift | word >>> shift;
-}
-const hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
-const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-/**
-* Convert byte array to hex string.
-* Uses the built-in function when available and assumes it matches the tested
-* fallback semantics.
-* @param bytes - bytes to encode
-* @returns Lowercase hexadecimal string.
-* @throws On wrong argument types. {@link TypeError}
-* @example
-* Convert bytes to lowercase hexadecimal.
-* ```ts
-* bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])); // 'cafe0123'
-* ```
-*/
-function bytesToHex(bytes) {
-	abytes(bytes);
-	if (hasHexBuiltin) return bytes.toHex();
-	let hex = "";
-	for (let i = 0; i < bytes.length; i++) hex += hexes[bytes[i]];
-	return hex;
-}
-/**
-* Converts string to bytes using UTF8 encoding.
-* Built-in doesn't validate input to be string: we do the check.
-* Non-ASCII details are delegated to the platform `TextEncoder`.
-* @param str - string to encode
-* @returns UTF-8 encoded bytes.
-* @throws On wrong argument types. {@link TypeError}
-* @example
-* Encode a string as UTF-8 bytes.
-* ```ts
-* utf8ToBytes('abc'); // Uint8Array.from([97, 98, 99])
-* ```
-*/
-function utf8ToBytes(str) {
-	if (typeof str !== "string") throw new TypeError("string expected");
-	const encoded = new TextEncoder().encode(str);
-	try {
-		return new Uint8Array(encoded);
-	} finally {
-		clean(encoded);
+const hex$1 = (v) => numberToHex(v);
+var EvmChainAdapter = class {
+	family = "evm";
+	nonces = /* @__PURE__ */ new Map();
+	lastNonce = /* @__PURE__ */ new Map();
+	async serial(key, run) {
+		const prior = this.nonces.get(key) ?? Promise.resolve();
+		const next = (async () => {
+			try {
+				await prior;
+			} catch {}
+			return run();
+		})();
+		this.nonces.set(key, next);
+		return next;
 	}
-}
-/**
-* Merges default options and passed options.
-* @param defaults - base option object
-* @param opts - user overrides
-* @param title - label included in thrown override errors
-* @returns Fresh merged option object with a null prototype.
-* @throws On wrong argument types. {@link TypeError}
-* @example
-* Merge user overrides onto default options.
-* ```ts
-* checkOpts({ dkLen: 32 }, { asyncTick: 10 });
-* ```
-*/
-function checkOpts(defaults, opts, title = "opts") {
-	aopts(defaults, "defaults");
-	if (opts !== void 0) aopts(opts, title);
-	return Object.assign(Object.create(null), defaults, opts);
-}
-/**
-* Creates a callable hash function from a stateful class constructor.
-* @param hashCons - hash constructor or factory
-* @param info - optional metadata such as DER OID
-* @returns Frozen callable hash wrapper with `.create()`.
-*   Wrapper construction eagerly calls `hashCons(undefined)` once to read
-*   `outputLen` / `blockLen`, so constructor side effects happen at module
-*   init time.
-* @throws On wrong argument types. {@link TypeError}
-* @example
-* Wrap a stateful hash constructor into a callable helper.
-* ```ts
-* import { createHasher } from '@noble/hashes/utils.js';
-* import { sha256 } from '@noble/hashes/sha2.js';
-* const wrapped = createHasher(sha256.create, { oid: sha256.oid });
-* wrapped(new Uint8Array([1]));
-* ```
-*/
-function createHasher(hashCons, info = {}) {
-	if (typeof hashCons !== "function") throw new TypeError("\"hashCons\" expected function, got type=" + typeof hashCons);
-	info = checkOpts({}, info, "info");
-	const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
-	const tmp = hashCons(void 0);
-	hashC.outputLen = tmp.outputLen;
-	hashC.blockLen = tmp.blockLen;
-	hashC.canXOF = tmp.canXOF;
-	hashC.create = (opts) => hashCons(opts);
-	Object.assign(hashC, info);
-	return Object.freeze(hashC);
-}
-/**
-* Creates OID metadata for NIST hashes with prefix `06 09 60 86 48 01 65 03 04 02`.
-* @param suffix - final OID byte for the selected hash.
-*   The helper accepts any byte even though only the documented NIST hash
-*   suffixes are meaningful downstream.
-* @returns Object containing the DER-encoded OID.
-* @example
-* Build OID metadata for a NIST hash.
-* ```ts
-* oidNist(0x01);
-* ```
-*/
-const oidNist = (suffix) => ({ oid: Uint8Array.from([
-	6,
-	9,
-	96,
-	134,
-	72,
-	1,
-	101,
-	3,
-	4,
-	2,
-	suffix
-]) });
+	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;
+	}
+	/** Allocate the next nonce for (network, from) — serial per key. */
+	async nonce(client, network, from) {
+		const key = `${network}:${from}`;
+		return this.serial(key, async () => {
+			const pending = Number(await this.rpcHex(client, "eth_getTransactionCount", [from, "pending"]));
+			const local = this.lastNonce.get(key);
+			const nonce = Math.max(pending, local === void 0 ? 0 : local + 1);
+			this.lastNonce.set(key, nonce);
+			return nonce;
+		});
+	}
+	/** ERC-20 gas is buffered ×1.1 instead of the native ×1.2 (chains.mdx "EVM"). */
+	async build(client, network, from, intent) {
+		const nonce = await this.nonce(client, network, from);
+		const erc20 = intent.kind === "erc20";
+		const to = checksumEvmAddress(erc20 ? intent.token : intent.to);
+		const value = erc20 ? 0n : intent.value;
+		const data = erc20 ? encodeFunctionData({
+			abi: ERC20_ABI,
+			functionName: "transfer",
+			args: [checkedAddress(intent.to), intent.value]
+		}) : "0x";
+		const estimate = BigInt(await this.rpcHex(client, "eth_estimateGas", [{
+			from,
+			to,
+			value: hex$1(value),
+			data
+		}]));
+		const scale = erc20 ? 11n : 12n;
+		return {
+			family: "evm",
+			network,
+			from,
+			to,
+			value,
+			data,
+			nonce,
+			gas: estimate * scale / 10n + (estimate * scale % 10n === 0n ? 0n : 1n)
+		};
+	}
+	async estimateFee(client) {
+		try {
+			const history = await this.rpc(client, "eth_feeHistory", [
+				"0x14",
+				"latest",
+				[
+					10,
+					50,
+					90
+				]
+			]);
+			if (typeof history !== "object" || history === null || !("baseFeePerGas" in history) || !Array.isArray(history.baseFeePerGas) || !("reward" in history) || !Array.isArray(history.reward)) throw new TypeError("eth_feeHistory returned a malformed result");
+			const { baseFeePerGas, reward } = history;
+			if (!Array.isArray(baseFeePerGas) || !baseFeePerGas.every((v) => typeof v === "string") || !Array.isArray(reward) || !reward.every((r) => Array.isArray(r) && r.every((v) => typeof v === "string"))) throw new TypeError("eth_feeHistory returned a malformed result");
+			const baseFee = BigInt(baseFeePerGas.at(-1) ?? "0x0");
+			const tier = (i, name) => {
+				const last = reward.at(-1);
+				const priority = last === void 0 ? 0n : BigInt(last[i] ?? "0x0");
+				const maxFeePerGas = baseFee * 2n + priority;
+				return {
+					tier: name,
+					wei: maxFeePerGas,
+					maxFeePerGas,
+					maxPriorityFeePerGas: priority
+				};
+			};
+			return [
+				tier(0, "slow"),
+				tier(1, "normal"),
+				tier(2, "fast")
+			];
+		} catch {
+			const price = BigInt(await this.rpcHex(client, "eth_gasPrice", []));
+			return [
+				"slow",
+				"normal",
+				"fast"
+			].map((name) => ({
+				tier: name,
+				wei: price,
+				maxFeePerGas: price,
+				maxPriorityFeePerGas: void 0
+			}));
+		}
+	}
+	applyFee(tx, fee) {
+		if (fee.maxPriorityFeePerGas === void 0) return {
+			...tx,
+			gasPrice: fee.maxFeePerGas
+		};
+		return {
+			...tx,
+			maxFeePerGas: fee.maxFeePerGas,
+			maxPriorityFeePerGas: fee.maxPriorityFeePerGas
+		};
+	}
+	toSignRequest(tx, account, chainId) {
+		const base = {
+			chainId,
+			nonce: tx.nonce,
+			gas: hex$1(tx.gas),
+			to: tx.to,
+			value: hex$1(tx.value),
+			data: tx.data
+		};
+		const transaction = tx.gasPrice === void 0 ? {
+			...base,
+			type: "eip1559",
+			accessList: [],
+			maxFeePerGas: hex$1(tx.maxFeePerGas ?? 0n),
+			maxPriorityFeePerGas: hex$1(tx.maxPriorityFeePerGas ?? 0n)
+		} : {
+			...base,
+			type: "legacy",
+			gasPrice: hex$1(tx.gasPrice)
+		};
+		return {
+			kind: "evm.transaction",
+			network: tx.network,
+			account,
+			tx: transaction
+		};
+	}
+	finalize(_tx, signed) {
+		const bytes = signed.signedTransaction;
+		if (signed.kind !== "evm.transaction" || bytes === void 0) throw new Error(`unexpected sign result ${signed.kind}`);
+		return `0x${[...bytes].map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+	}
+	async broadcast(client, raw) {
+		return this.rpcHex(client, "eth_sendRawTransaction", [raw]);
+	}
+	async status(client, hash) {
+		const receipt = await this.rpc(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]);
+			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 ../../node_modules/.bun/@noble+hashes@2.4.0/node_modules/@noble/hashes/_md.js
-/**
-* Internal Merkle-Damgard hash utils.
-* @module
-*/
-/**
-* Shared 32-bit conditional boolean primitive reused by SHA-256, SHA-1, and MD5 `F`.
-* Returns bits from `b` when `a` is set, otherwise from `c`.
-* The XOR form is equivalent to MD5's `F(X,Y,Z) = XY v not(X)Z` because the masked terms never
-* set the same bit.
-* @param a - selector word
-* @param b - word chosen when selector bit is set
-* @param c - word chosen when selector bit is clear
-* @returns Mixed 32-bit word.
-* @example
-* Combine three words with the shared 32-bit choice primitive.
-* ```ts
-* Chi(0xffffffff, 0x12345678, 0x87654321);
-* ```
-*/
-function Chi(a, b, c) {
-	return a & b ^ ~a & c;
-}
-/**
-* Shared 32-bit majority primitive reused by SHA-256 and SHA-1.
-* Returns bits shared by at least two inputs.
-* @param a - first input word
-* @param b - second input word
-* @param c - third input word
-* @returns Mixed 32-bit word.
-* @example
-* Combine three words with the shared 32-bit majority primitive.
-* ```ts
-* Maj(0xffffffff, 0x12345678, 0x87654321);
-* ```
-*/
-function Maj(a, b, c) {
-	return a & b ^ a & c ^ b & c;
-}
+//#region src/assets/controller.ts
 /**
-* Merkle-Damgard hash construction base class.
-* Could be used to create MD5, RIPEMD, SHA1, SHA2.
-* Accepts only byte-aligned `Uint8Array` input, even when the underlying spec describes bit
-* strings with partial-byte tails.
-* @param blockLen - internal block size in bytes
-* @param outputLen - digest size in bytes
-* @param padOffset - trailing length field size in bytes
-* @param isLE - whether length and state words are encoded in little-endian
-* @example
-* Use a concrete subclass to get the shared Merkle-Damgard update/digest flow.
-* ```ts
-* import { _SHA1 } from '@noble/hashes/legacy.js';
-* const hash = new _SHA1();
-* hash.update(new Uint8Array([97, 98, 99]));
-* hash.digest();
-* ```
+* 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,
+* otherwise one eth_call per token. Custom tokens persist in the EngineStore as unverified until a
+* built-in-table merge marks them otherwise. State values are display-only: transaction build
+* always re-reads the chain.
 */
-var HashMD = class {
-	blockLen;
-	outputLen;
-	canXOF = false;
-	padOffset;
-	isLE;
-	buffer;
-	view;
-	finished = false;
-	length = 0;
-	pos = 0;
-	destroyed = false;
-	constructor(blockLen, outputLen, padOffset, isLE) {
-		this.blockLen = blockLen;
-		this.outputLen = outputLen;
-		this.padOffset = padOffset;
-		this.isLE = isLE;
-		this.buffer = new Uint8Array(blockLen);
-		this.view = createView(this.buffer);
-	}
-	update(data) {
-		aexists(this);
-		abytes(data);
-		const { view, buffer, blockLen } = this;
-		const len = data.length;
-		let processed = false;
-		for (let pos = 0; pos < len;) {
-			const take = Math.min(blockLen - this.pos, len - pos);
-			if (take === blockLen) {
-				const dataView = createView(data);
-				for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
-				processed = true;
-				continue;
+const obj$2 = (v) => isObject$9(v) ? v : void 0;
+const arr$1 = (v) => Array.isArray(v);
+const COLLECTION$1 = "assets-custom-tokens";
+const POLL_MS = 6e4;
+const isObject$9 = (v) => typeof v === "object" && v !== null;
+const checked = (v) => {
+	if (!isAddress(v)) throw new TypeError(`malformed evm address: ${v}`);
+	return v;
+};
+const key$1 = (network, address) => `${network}:${address}`;
+const MULTICALL3_ABI = [{
+	type: "function",
+	name: "aggregate3",
+	inputs: [{
+		name: "calls",
+		type: "tuple[]",
+		components: [
+			{
+				name: "target",
+				type: "address"
+			},
+			{
+				name: "allowFailure",
+				type: "bool"
+			},
+			{
+				name: "callData",
+				type: "bytes"
 			}
-			buffer.set(pos === 0 && take === len ? data : data.subarray(pos, pos + take), this.pos);
-			this.pos += take;
-			pos += take;
-			if (this.pos === blockLen) {
-				this.process(view, 0);
-				this.pos = 0;
-				processed = true;
+		]
+	}],
+	outputs: [{
+		name: "returnData",
+		type: "tuple[]",
+		components: [{
+			name: "success",
+			type: "bool"
+		}, {
+			name: "returnData",
+			type: "bytes"
+		}]
+	}],
+	stateMutability: "payable"
+}];
+var AssetsController = class extends Controller {
+	options;
+	engineStore;
+	bitcoinUtxos = new BtcUtxoStore();
+	visible = false;
+	cancelPoll;
+	customTokens = /* @__PURE__ */ new Map();
+	constructor(options) {
+		super({
+			name: "assets",
+			defaultState: () => ({ balances: {} })
+		});
+		this.options = options;
+	}
+	async init() {
+		this.engineStore = await this.options.openStore();
+		const listed = await this.engineStore.collection(COLLECTION$1).get("customTokens");
+		if (listed !== void 0) {
+			const parsed = JSON.parse(new TextDecoder().decode(listed));
+			if (isObject$9(parsed)) {
+				for (const [network, arr] of Object.entries(parsed)) if (Array.isArray(arr)) {
+					const tokens = arr.flatMap((t) => isObject$9(t) && typeof t["address"] === "string" && typeof t["verified"] === "boolean" ? [{
+						address: t["address"],
+						verified: t["verified"]
+					}] : []);
+					this.customTokens.set(network, tokens);
+				}
 			}
 		}
-		this.length += data.length;
-		if (processed) this.roundClean();
-		return this;
-	}
-	digestInto(out) {
-		aexists(this);
-		aoutput(out, this);
-		this.finished = true;
-		const { buffer, view, blockLen, isLE } = this;
-		let { pos } = this;
-		buffer[pos++] = 128;
-		buffer.fill(0, pos);
-		if (this.padOffset > blockLen - pos) {
-			this.process(view, 0);
-			buffer.fill(0);
-		}
-		setU64FromNum(view, blockLen - 8, this.length * 8, isLE);
-		this.process(view, 0);
-		this.roundClean();
-		const oview = out === buffer ? view : createView(out);
-		const len = this.outputLen;
-		const outLen = len / 4;
-		const state = this.get();
-		if (len % 4 || outLen > state.length) throw new Error("invalid outputLen");
-		for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
-	}
-	digest() {
-		const { buffer, outputLen } = this;
-		this.digestInto(buffer);
-		const res = buffer.slice(0, outputLen);
-		this.destroy();
-		return res;
-	}
-	_cloneIntoMeta(to) {
-		const { buffer, length, finished, destroyed, pos } = this;
-		to.destroyed = destroyed;
-		to.finished = finished;
-		to.length = length;
-		to.pos = pos;
-		if (pos) to.buffer.set(buffer);
-		return to;
-	}
-	clone() {
-		return this._cloneInto();
+		if (this.visible) this.armPoll();
 	}
-};
-/**
-* Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
-* Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
-*/
-/** Initial SHA256 state from RFC 6234 §6.1: the first 32 bits of the fractional parts of the
-* square roots of the first eight prime numbers. Exported as a shared table; callers must treat
-* it as read-only because constructors copy words from it by index. */
-const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
-	1779033703,
-	3144134277,
-	1013904242,
-	2773480762,
-	1359893119,
-	2600822924,
-	528734635,
-	1541459225
-]);
-//#endregion
-//#region ../../node_modules/.bun/@noble+hashes@2.4.0/node_modules/@noble/hashes/sha2.js
-/**
-* SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
-* SHA256 is the fastest hash implementable in JS, even faster than Blake3.
-* Check out {@link https://www.rfc-editor.org/rfc/rfc4634 | RFC 4634} and
-* {@link https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf | FIPS 180-4}.
-* @module
-*/
-/**
-* SHA-224 / SHA-256 round constants from RFC 6234 §5.1: the first 32 bits
-* of the cube roots of the first 64 primes (2..311).
-*/
-const SHA256_K = /* @__PURE__ */ Uint32Array.from([
-	1116352408,
-	1899447441,
-	3049323471,
-	3921009573,
-	961987163,
-	1508970993,
-	2453635748,
-	2870763221,
-	3624381080,
-	310598401,
-	607225278,
-	1426881987,
-	1925078388,
-	2162078206,
-	2614888103,
-	3248222580,
-	3835390401,
-	4022224774,
-	264347078,
-	604807628,
-	770255983,
-	1249150122,
-	1555081692,
-	1996064986,
-	2554220882,
-	2821834349,
-	2952996808,
-	3210313671,
-	3336571891,
-	3584528711,
-	113926993,
-	338241895,
-	666307205,
-	773529912,
-	1294757372,
-	1396182291,
-	1695183700,
-	1986661051,
-	2177026350,
-	2456956037,
-	2730485921,
-	2820302411,
-	3259730800,
-	3345764771,
-	3516065817,
-	3600352804,
-	4094571909,
-	275423344,
-	430227734,
-	506948616,
-	659060556,
-	883997877,
-	958139571,
-	1322822218,
-	1537002063,
-	1747873779,
-	1955562222,
-	2024104815,
-	2227730452,
-	2361852424,
-	2428436474,
-	2756734187,
-	3204031479,
-	3329325298
-]);
-/** Reusable SHA-224 / SHA-256 message schedule buffer `W_t` from RFC 6234 §6.2 step 1. */
-const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-/** Internal SHA-224 / SHA-256 compression engine from RFC 6234 §6.2. */
-var SHA2_32B = class extends HashMD {
-	A = 0;
-	B = 0;
-	C = 0;
-	D = 0;
-	E = 0;
-	F = 0;
-	G = 0;
-	H = 0;
-	constructor(outputLen, IV) {
-		super(64, outputLen, 8, false);
-		this.A = IV[0] | 0;
-		this.B = IV[1] | 0;
-		this.C = IV[2] | 0;
-		this.D = IV[3] | 0;
-		this.E = IV[4] | 0;
-		this.F = IV[5] | 0;
-		this.G = IV[6] | 0;
-		this.H = IV[7] | 0;
-	}
-	get() {
-		const { A, B, C, D, E, F, G, H } = this;
-		return [
-			A,
-			B,
-			C,
-			D,
-			E,
-			F,
-			G,
-			H
-		];
+	lock() {
+		this.cancelPoll?.();
+		this.cancelPoll = void 0;
+		this.customTokens.clear();
+		this.engineStore = void 0;
+		this.update(() => ({ balances: {} }));
 	}
-	set(A, B, C, D, E, F, G, H) {
-		this.A = A | 0;
-		this.B = B | 0;
-		this.C = C | 0;
-		this.D = D | 0;
-		this.E = E | 0;
-		this.F = F | 0;
-		this.G = G | 0;
-		this.H = H | 0;
-	}
-	_cloneInto(to) {
-		(to ||= new this.constructor()).set(...this.get());
-		return this._cloneIntoMeta(to);
-	}
-	process(view, offset) {
-		for (let i = 0; i < 16; i++, offset += 4) SHA256_W[i] = view.getUint32(offset, false);
-		for (let i = 16; i < 64; i++) {
-			const W15 = SHA256_W[i - 15];
-			const W2 = SHA256_W[i - 2];
-			const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
-			const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
-			SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
-		}
-		let { A, B, C, D, E, F, G, H } = this;
-		for (let i = 0; i < 64; i++) {
-			const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
-			const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
-			const T2 = (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Maj(A, B, C) | 0;
-			H = G;
-			G = F;
-			F = E;
-			E = D + T1 | 0;
-			D = C;
-			C = B;
-			B = A;
-			A = T1 + T2 | 0;
-		}
-		A = A + this.A | 0;
-		B = B + this.B | 0;
-		C = C + this.C | 0;
-		D = D + this.D | 0;
-		E = E + this.E | 0;
-		F = F + this.F | 0;
-		G = G + this.G | 0;
-		H = H + this.H | 0;
-		this.set(A, B, C, D, E, F, G, H);
-	}
-	roundClean() {
-		clean(SHA256_W);
-	}
-	destroy() {
-		this.destroyed = true;
-		this.set(0, 0, 0, 0, 0, 0, 0, 0);
-		clean(this.buffer);
+	async destroy() {
+		this.lock();
+		await Promise.resolve();
 	}
-};
-/** Internal SHA-256 hash class grounded in RFC 6234 §6.2. */
-var _SHA256 = class extends SHA2_32B {
-	constructor() {
-		super(32, SHA256_IV);
+	setVisible(visible) {
+		this.visible = visible;
+		if (!visible) {
+			this.cancelPoll?.();
+			this.cancelPoll = void 0;
+			return;
+		}
+		this.armPoll();
+	}
+	armPoll() {
+		if (this.cancelPoll !== void 0) return;
+		this.cancelPoll = this.options.setTimer(POLL_MS, () => {
+			(async () => {
+				try {
+					await this.refreshAll();
+				} catch (error) {
+					this.options.logger.warn("assets refresh failed", error);
+				}
+			})();
+		});
+	}
+	async refreshAll() {
+		await Promise.all(Object.keys(this.getState().balances).flatMap((entry) => {
+			const [network, address] = entry.split(":");
+			return network === void 0 || address === void 0 ? [] : [this.refresh(address, network)];
+		}));
+	}
+	async refresh(address, network) {
+		const info = this.options.networks.info(network);
+		if (info.family === "solana") {
+			await this.refreshSolana(address, network);
+			return;
+		}
+		if (info.family === "bitcoin") {
+			await this.refreshBitcoin(address, network);
+			return;
+		}
+		const client = this.options.networks.client(network);
+		const native = BigInt(await this.rpcHex(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,
+			verified: t.verified
+		})));
+		this.update((s) => ({ balances: {
+			...s.balances,
+			[key$1(network, address)]: {
+				native,
+				tokens
+			}
+		} }));
+	}
+	/** SOL via getBalance; SPL via getTokenAccountsByOwner (jsonParsed) for known mints. */
+	async refreshSolana(owner, network) {
+		const rpc = this.options.networks.solanaRpc(network);
+		const balValue = obj$2(await rpc.call("getBalance", [owner, { commitment: "confirmed" }]))?.["value"];
+		const native = typeof balValue === "string" ? balValue : typeof balValue === "number" ? String(balValue) : "0";
+		const custom = this.customTokens.get(network) ?? [];
+		const tokens = await Promise.all(custom.map(async (t) => {
+			const accounts = obj$2(await rpc.call("getTokenAccountsByOwner", [
+				owner,
+				{ mint: t.address },
+				{ encoding: "jsonParsed" }
+			]));
+			const first = arr$1(accounts?.["value"]) ? accounts?.["value"][0] : void 0;
+			const parsed = obj$2(obj$2(obj$2(obj$2(obj$2(first)?.["account"])?.["data"])?.["parsed"])?.["info"]);
+			const amount = obj$2(parsed?.["tokenAmount"]);
+			const mintInfo = obj$2(await rpc.call("getAccountInfo", [t.address, { encoding: "jsonParsed" }]));
+			const mintParsed = obj$2(obj$2(obj$2(obj$2(mintInfo?.["value"])?.["data"])?.["parsed"])?.["info"]);
+			return {
+				address: t.address,
+				symbol: "?",
+				decimals: typeof mintParsed?.["decimals"] === "number" ? mintParsed["decimals"] : 9,
+				balance: typeof amount?.["amount"] === "string" ? amount["amount"] : "0",
+				verified: t.verified
+			};
+		}));
+		this.update((s) => ({ balances: {
+			...s.balances,
+			[key$1(network, owner)]: {
+				native,
+				tokens
+			}
+		} }));
+	}
+	async readTokens(client, multicall3, owner, tokens) {
+		if (tokens.length === 0) return [];
+		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,
+			balance: balances[i]?.toString() ?? "0",
+			verified: t.verified
+		})));
+	}
+	async balanceOfBatch(client, multicall3, owner, tokens) {
+		const data = encodeFunctionData({
+			abi: MULTICALL3_ABI,
+			functionName: "aggregate3",
+			args: [tokens.map((token) => ({
+				target: checked(token),
+				allowFailure: true,
+				callData: encodeFunctionData({
+					abi: ERC20_ABI,
+					functionName: "balanceOf",
+					args: [checked(owner)]
+				})
+			}))]
+		});
+		const result = await this.rpcHex(client, "eth_call", [{
+			to: multicall3,
+			data
+		}, "latest"]);
+		if (!isHex(result)) throw new TypeError("eth_call returned malformed data");
+		return decodeFunctionResult({
+			abi: MULTICALL3_ABI,
+			functionName: "aggregate3",
+			data: result
+		}).map((r) => r.success ? decodeFunctionResult({
+			abi: ERC20_ABI,
+			functionName: "balanceOf",
+			data: r.returnData
+		}) : void 0);
+	}
+	async balanceOf(client, token, owner) {
+		const data = encodeFunctionData({
+			abi: ERC20_ABI,
+			functionName: "balanceOf",
+			args: [checked(owner)]
+		});
+		const result = await this.rpcHex(client, "eth_call", [{
+			to: token,
+			data
+		}, "latest"]);
+		if (!isHex(result)) throw new TypeError("eth_call returned malformed data");
+		return decodeFunctionResult({
+			abi: ERC20_ABI,
+			functionName: "balanceOf",
+			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) {
+		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;
+		}
+	}
+	/** Reads symbol/decimals on-chain, marks unverified, persists; throws when the calls fail. */
+	async addToken(network, address) {
+		if (this.options.networks.info(network).family === "solana") {
+			const rpc = this.options.networks.solanaRpc(network);
+			const mint = obj$2(await rpc.call("getAccountInfo", [address, { encoding: "jsonParsed" }]));
+			const decimals = obj$2(obj$2(obj$2(mint?.["value"])?.["data"])?.["parsed"])?.["info"];
+			if (typeof obj$2(decimals)?.["decimals"] !== "number") throw new TypeError(`${address} is not a readable SPL mint on ${network}`);
+			await this.persistToken(network, address);
+			return;
+		}
+		const client = this.options.networks.client(network);
+		await this.callString(client, address, "symbol");
+		await this.callNumber(client, address, "decimals");
+		await this.persistToken(network, address);
+	}
+	async persistToken(network, address) {
+		const existing = this.customTokens.get(network) ?? [];
+		if (existing.some((t) => t.address === address)) return;
+		const next = [...existing, {
+			address,
+			verified: false
+		}];
+		this.customTokens.set(network, next);
+		if (this.engineStore !== void 0) {
+			const merged = { [network]: next };
+			for (const [n, list] of this.customTokens) if (n !== network) merged[n] = list;
+			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);
+		const net = bitcoinNetwork(network);
+		const template = "btc.bip84";
+		const receive = await scanChain(es, xpub, template, network, net.params, 0);
+		const change = await scanChain(es, xpub, template, network, net.params, 1);
+		const addresses = [...receive, ...change];
+		const scanned = await scanUtxos(es, addresses, net.params);
+		this.bitcoinUtxos.replace(scanned);
+		const changeSet = new Set(change.map((a) => a.address));
+		let confirmed = 0n;
+		let ownUnconfirmed = 0n;
+		let frozen = 0n;
+		for (const u of this.bitcoinUtxos.all()) {
+			const v = BigInt(u.value);
+			if (u.status === "frozen" || u.value === 546 || u.value === 330) frozen += v;
+			else if (u.height > 0) confirmed += v;
+			else if (changeSet.has(u.address)) ownUnconfirmed += v;
+		}
+		this.update((s) => ({
+			...s,
+			balances: {
+				...s.balances,
+				[`${xpub}:${network}:BTC`]: {
+					native: confirmed.toString(),
+					tokens: [],
+					unconfirmed: ownUnconfirmed.toString(),
+					frozen: frozen.toString()
+				}
+			}
+		}));
 	}
 };
-/**
-* SHA2-256 hash function from RFC 4634. In JS it's the fastest: even faster than Blake3. Some info:
-*
-* - Trying 2^128 hashes would get 50% chance of collision, using birthday attack.
-* - BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
-* - Each sha256 hash is executing 2^18 bit operations.
-* - Good 2024 ASICs can do 200Th/sec with 3500 watts of power, corresponding to 2^36 hashes/joule.
-* @param msg - message bytes to hash
-* @param opts - Reserved hash options.
-* @returns Digest bytes.
-* @example
-* Hash a message with SHA2-256.
-* ```ts
-* sha256(new Uint8Array([97, 98, 99]));
-* ```
-*/
-const sha256 = /* @__PURE__ */ createHasher(() => new _SHA256(), /* @__PURE__ */ oidNist(1));
 //#endregion
 //#region src/backup/errors.ts
 var BackupControllerError = class extends Error {
@@ -1481,14 +1759,14 @@ function sorted(values) {
 function sameSet(a, b) {
 	return a.length === b.length && a.every((v, i) => v === b[i]);
 }
-const isObject$2 = (v) => typeof v === "object" && v !== null;
+const isObject$8 = (v) => typeof v === "object" && v !== null;
 const isStringArray = (v) => Array.isArray(v) && v.every((e) => typeof e === "string");
 /** Strict record validation — anything malformed reads as absent (and is logged). */
 function parseRecord(bytes) {
 	if (bytes === void 0) return;
 	try {
 		const value = JSON.parse(new TextDecoder().decode(bytes));
-		if (!isObject$2(value)) return;
+		if (!isObject$8(value)) return;
 		const o = value;
 		const { id } = o;
 		const { digest } = o;
@@ -1817,17 +2095,17 @@ const KNOWN_GROUP_KEYS = /* @__PURE__ */ new Set([
 	"boundPubkey",
 	"updatedAt"
 ]);
-const isObject$1 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const isObject$7 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 const isNonNegativeInt = (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
 const validName = (v) => v === void 0 || typeof v === "string" && v.trim().length > 0 && v.trim().length <= NAME_MAX;
 const trimmedName = (v) => typeof v === "string" ? v.trim() : void 0;
 /** Strict decode — any malformed shape, unknown key or duplicate index returns `undefined`. */
 function decodeMetaDoc(value) {
-	if (!isObject$1(value)) return;
+	if (!isObject$7(value)) return;
 	for (const k of Object.keys(value)) if (!KNOWN_DOC_KEYS.has(k)) return;
 	if (value["v"] !== 1) return;
 	const { wallet } = value;
-	if (!isObject$1(wallet)) return;
+	if (!isObject$7(wallet)) return;
 	for (const k of Object.keys(wallet)) if (!KNOWN_WALLET_KEYS.has(k)) return;
 	if (!validName(wallet["name"]) || !isNonNegativeInt(wallet["updatedAt"])) return;
 	const { groups } = value;
@@ -1835,7 +2113,7 @@ function decodeMetaDoc(value) {
 	const seen = /* @__PURE__ */ new Set();
 	const out = [];
 	for (const item of groups) {
-		if (!isObject$1(item)) return;
+		if (!isObject$7(item)) return;
 		for (const k of Object.keys(item)) if (!KNOWN_GROUP_KEYS.has(k)) return;
 		const { index } = item;
 		if (!isNonNegativeInt(index) || seen.has(index)) return;
@@ -2137,32 +2415,512 @@ function isUnsupportedDoc(plaintext) {
 	}
 }
 //#endregion
-//#region 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) => ({
-	kind: "invalid",
-	reason
-});
-/** BTC decimal `amount` → sats. At most 8 decimal places; must fit a safe integer. */
-function btcAmountSats(text) {
-	const match = /^(\d+)(?:\.(\d{1,8}))?$/.exec(text);
-	if (match === null) return;
-	const [, whole] = match;
-	if (whole === void 0) return;
-	const sats = BigInt(whole) * 100000000n + BigInt((match[2] ?? "").padEnd(8, "0") || "0");
-	return sats <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(sats) : void 0;
-}
-/**
-* BOLT11 → fields, network- and expiry-checked. `undefined` = not a bolt11 string; `"network"` /
-* `"expired"` / `"malformed"` are the failure modes.
-*/
-function bolt11Fields(text, options) {
-	let decoded;
-	try {
-		decoded = decodeBolt11(text);
-	} catch {
-		return;
+//#region src/chains/bitcoin.ts
+const DUST = {
+	p2wpkh: 294,
+	p2tr: 330,
+	p2pkh: 546
+};
+const FROZEN_AMOUNTS = /* @__PURE__ */ new Set([546, 330]);
+const isObject$6 = (v) => typeof v === "object" && v !== null;
+var EsploraError = class extends Error {
+	/** True for request timeout/abort, network failure, 429-after-retries and 5xx — safe to retry. */
+	transient;
+	constructor(message, transient) {
+		super(message);
+		this.name = "EsploraError";
+		this.transient = transient;
+	}
+};
+const MAX_IN_FLIGHT = 4;
+const MAX_RETRIES = 3;
+const MAX_BACKOFF_MS = 2e3;
+const REQUEST_TIMEOUT_MS = 1e4;
+/** Bounded-concurrency + 429-aware ordered failover over the endpoint list. */
+const esplora = (endpoints, fetchFn, sleep, timeoutMs = REQUEST_TIMEOUT_MS) => {
+	let inFlight = 0;
+	const waiters = [];
+	const acquire = async () => {
+		if (inFlight >= MAX_IN_FLIGHT) await new Promise((resolve) => {
+			waiters.push(resolve);
+		});
+		inFlight += 1;
+	};
+	const release = () => {
+		inFlight -= 1;
+		waiters.shift()?.();
+	};
+	const backoff = async (headers, retry) => {
+		const ra = headers.get("retry-after");
+		const retryAfterMs = ra !== null && ra !== "" && !Number.isNaN(Number(ra)) ? Number(ra) * 1e3 : void 0;
+		const jitter = Math.floor(Math.random() * 100);
+		await sleep(retryAfterMs ?? Math.min(100 * 2 ** retry + jitter, MAX_BACKOFF_MS));
+	};
+	const request = async (base, path, body) => {
+		await acquire();
+		try {
+			let res;
+			try {
+				res = await fetchFn(`${base.replace(/\/$/, "")}${path}`, {
+					...body === void 0 ? { method: "GET" } : {
+						method: "POST",
+						headers: { "content-type": "text/plain" },
+						body
+					},
+					signal: AbortSignal.timeout(timeoutMs)
+				});
+			} catch (error) {
+				throw new EsploraError(`esplora ${base}${path}: request failed (${error instanceof Error ? error.name : "unknown"})`, true);
+			}
+			if (res.status === 429) return { throttled: res.headers };
+			if (!res.ok) throw new EsploraError(`esplora ${base}${path}: ${res.status}`, res.status >= 500);
+			const text = await res.text();
+			try {
+				return { value: JSON.parse(text) };
+			} catch {
+				return { value: text };
+			}
+		} finally {
+			release();
+		}
+	};
+	const call = async (base, path, body, retry) => {
+		const outcome = await request(base, path, body);
+		if ("value" in outcome) return outcome.value;
+		if (retry >= MAX_RETRIES) throw new EsploraError(`esplora ${base}${path}: 429 after ${MAX_RETRIES} retries`, true);
+		await backoff(outcome.throttled, retry);
+		return call(base, path, body, retry + 1);
+	};
+	const attempt = async (rest, path, body, last) => {
+		const [base, ...next] = rest;
+		if (base === void 0) throw last instanceof Error ? last : /* @__PURE__ */ new Error("all esplora endpoints failed");
+		try {
+			return await call(base, path, body, 0);
+		} catch (error) {
+			return attempt(next, path, body, error);
+		}
+	};
+	return {
+		get: async (path) => attempt(endpoints, path, void 0, void 0),
+		post: async (path, body) => attempt(endpoints, path, body, void 0)
+	};
+};
+const feeTiers = async (es) => {
+	const res = await es.get("/fee-estimates");
+	const estimates = isObject$6(res) ? res : {};
+	const pick = (target) => Math.max(1, Math.ceil(Number(estimates[target] ?? 1)));
+	return [
+		{
+			tier: "fast",
+			satPerByte: pick("1")
+		},
+		{
+			tier: "normal",
+			satPerByte: pick("3")
+		},
+		{
+			tier: "slow",
+			satPerByte: pick("6")
+		},
+		{
+			tier: "economy",
+			satPerByte: pick("144")
+		}
+	];
+};
+const dustFor = (scriptType) => DUST[scriptType] ?? 546;
+const isFrozen = (value) => FROZEN_AMOUNTS.has(value);
+var BitcoinChainAdapter = class {
+	/** Inputs for selectUTXO — the same TransactionInputUpdate objects added to the PSBT. */
+	toInputs(utxos, fingerprint, pathOf, pubkeyOf, scriptOf, template, rawTxOf) {
+		return utxos.filter((u) => u.status === "confirmed" && !isFrozen(u.value)).map((u) => {
+			const pub = pubkeyOf(u);
+			const entry = {
+				txid: u.txid,
+				index: u.vout,
+				sequence: 4294967293
+			};
+			if (template !== "btc.bip44") entry.witnessUtxo = {
+				amount: BigInt(u.value),
+				script: scriptOf(u)
+			};
+			if (template === "btc.bip44") {
+				const raw = rawTxOf === void 0 ? void 0 : rawTxOf(u);
+				if (raw === void 0) throw new Error(`no raw transaction for bip44 input ${u.txid}`);
+				entry.nonWitnessUtxo = raw;
+			}
+			if (template === "btc.bip86") {
+				entry.tapInternalKey = pub.subarray(1);
+				entry.tapBip32Derivation = [[pub.subarray(1), {
+					hashes: [],
+					der: {
+						fingerprint,
+						path: pathOf(u)
+					}
+				}]];
+			} else {
+				entry.bip32Derivation = [[pub, {
+					fingerprint,
+					path: pathOf(u)
+				}]];
+				if (template === "btc.bip49") entry.redeemScript = p2wpkh(pub).script;
+			}
+			return entry;
+		});
+	}
+	buildPsbt(inputs, to, amount, feePerByte, changeAddress, network) {
+		const selection = selectUTXO([...inputs], [{
+			address: to,
+			amount
+		}], "default", {
+			feePerByte,
+			changeAddress,
+			bip69: true,
+			dust: BigInt(dustFor("p2wpkh")),
+			network,
+			createTx: true
+		});
+		if (selection === void 0 || selection.tx === void 0) throw new Error("insufficient confirmed utxo for the amount + fee");
+		const wanted = new Set((selection.inputs ?? []).flatMap((sel) => {
+			const raw = sel.txid;
+			if (!(raw instanceof Uint8Array)) return [];
+			const forward = hex.encode(raw);
+			const reverse = hex.encode(Uint8Array.from(raw).reverse());
+			return [`${forward}:${String(sel.index ?? -1)}`, `${reverse}:${String(sel.index ?? -1)}`];
+		}));
+		const chosen = inputs.filter((i) => wanted.has(`${String(i.txid)}:${String(i.index)}`));
+		return {
+			psbt: selection.tx.toPSBT(),
+			inputs: chosen
+		};
+	}
+	/** Fixed-input/output PSBT — the RBF/CPFP path, which chooses nothing itself. */
+	buildExactPsbt(inputs, outputs, network) {
+		const tx = new Transaction();
+		for (const input of inputs) tx.addInput(input);
+		for (const out of outputs) tx.addOutputAddress(out.address, out.amount, network);
+		const tap = inputs.every((i) => i.tapInternalKey !== void 0);
+		const vsize = Math.ceil(10.5 + inputs.length * (tap ? 57.5 : 68) + outputs.length * (tap ? 43 : 31));
+		return {
+			psbt: tx.toPSBT(),
+			vsize
+		};
+	}
+};
+//#endregion
+//#region src/networks/registry.ts
+const entry = (chainId, name, symbol, testnet, _source) => ({
+	id: `eip155:${chainId}`,
+	chainId,
+	name,
+	symbol,
+	decimals: 18,
+	testnet,
+	family: "evm",
+	multicall3: "0xcA11bde05977b3631167028862bE2a173976CA11"
+});
+const NETWORKS = [
+	entry(1, "Ethereum", "ETH", false, "https://ethereum.org/en/developers/docs/networks/"),
+	entry(8453, "Base", "ETH", false, "https://docs.base.org/docs/network-information"),
+	entry(42161, "Arbitrum One", "ETH", false, "https://docs.arbitrum.io/for-devs/dev-tools-and-resources/chain-info"),
+	entry(10, "OP Mainnet", "ETH", false, "https://docs.optimism.io/chain/networks"),
+	entry(137, "Polygon", "POL", false, "https://docs.polygon.technology/pos/reference/rpc-endpoints/"),
+	entry(56, "BNB Smart Chain", "BNB", false, "https://docs.bnbchain.org/bnb-smart-chain/developers/json_rpc/"),
+	entry(999, "HyperEVM", "HYPE", false, "https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/hyperevm"),
+	entry(43114, "Avalanche C-Chain", "AVAX", false, "https://build.avax.network/docs/tooling/rpc-providers"),
+	entry(11155111, "Sepolia", "ETH", true, "https://ethereum.org/en/developers/docs/networks/"),
+	entry(84532, "Base Sepolia", "ETH", true, "https://docs.base.org/docs/network-information"),
+	entry(421614, "Arbitrum Sepolia", "ETH", true, "https://docs.arbitrum.io/for-devs/dev-tools-and-resources/chain-info"),
+	entry(11155420, "OP Sepolia", "ETH", true, "https://docs.optimism.io/chain/networks"),
+	entry(80002, "Polygon Amoy", "POL", true, "https://docs.polygon.technology/pos/reference/rpc-endpoints/"),
+	entry(97, "BNB Smart Chain Testnet", "tBNB", true, "https://docs.bnbchain.org/bnb-smart-chain/developers/json_rpc/"),
+	entry(998, "HyperEVM Testnet", "HYPE", true, "https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/hyperevm"),
+	entry(43113, "Avalanche Fuji", "AVAX", true, "https://build.avax.network/docs/tooling/rpc-providers")
+];
+const networkById = (id) => [
+	...NETWORKS,
+	...SOLANA_NETWORKS,
+	...BITCOIN_NETWORKS
+].find((n) => n.id === id);
+const BITCOIN_NETWORKS = [
+	{
+		id: "bip122:000000000019d6689c085ae165831e93",
+		chainId: 0,
+		name: "Bitcoin",
+		symbol: "BTC",
+		decimals: 8,
+		testnet: false,
+		family: "bitcoin",
+		genesisHash: "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
+	},
+	{
+		id: "bip122:00000000da84f2bafbbc53dee25a72ae",
+		chainId: 0,
+		name: "Bitcoin Testnet4",
+		symbol: "tBTC",
+		decimals: 8,
+		testnet: true,
+		family: "bitcoin",
+		genesisHash: "00000000da84f2bafbbc53dee25a72ae507ff4914b867c565be350b0da8bf043"
+	},
+	{
+		id: "bip122:00000008819873e925422c1ff0f99f7c",
+		chainId: 0,
+		name: "Bitcoin Signet",
+		symbol: "sBTC",
+		decimals: 8,
+		testnet: true,
+		family: "bitcoin",
+		genesisHash: "00000008819873e925422c1ff0f99f7cc9bbb232af63a077a480a3633bee1ef6"
+	},
+	{
+		id: "bip122:0f9188f13cb7b2c71f2a335e3a4fc328",
+		chainId: 0,
+		name: "Bitcoin Regtest",
+		symbol: "rBTC",
+		decimals: 8,
+		testnet: true,
+		family: "bitcoin",
+		genesisHash: "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"
+	}
+];
+const SOLANA_NETWORKS = [{
+	id: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+	chainId: 0,
+	name: "Solana",
+	symbol: "SOL",
+	decimals: 9,
+	testnet: false,
+	family: "solana",
+	genesisHash: "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpWvDVGok8cUQPCbq9AzdTQvpNbNvyq4qDvMNTrDDezsFapSihepu2eQEdje"
+}, {
+	id: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+	chainId: 0,
+	name: "Solana Devnet",
+	symbol: "SOL",
+	decimals: 9,
+	testnet: true,
+	family: "solana",
+	genesisHash: "EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBGGSWgX4GwCJRmgdcvRaRmFbXfw3nDZBTqsr"
+}];
+//#endregion
+//#region 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
+* tried in order (custom → host), each with the injected fetch, so a dead endpoint fails over
+* without code here. Custom RPC URLs are validated against the registry chain id with `eth_chainId`
+* and persisted in the EngineStore.
+*/
+const esploraSleep = async (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+const isObject$5 = (v) => typeof v === "object" && v !== null;
+var NetworkController = class extends Controller {
+	options;
+	engineStore;
+	clients = /* @__PURE__ */ new Map();
+	constructor(options) {
+		super({
+			name: "networks",
+			defaultState: () => ({ customRpc: {} })
+		});
+		this.options = options;
+	}
+	async init() {
+		this.engineStore = await this.options.openStore();
+		const raw = await this.engineStore.collection("networks").get("customRpc");
+		if (raw === void 0) return;
+		const parsed = JSON.parse(new TextDecoder().decode(raw));
+		if (typeof parsed === "object" && parsed !== null) {
+			const map = {};
+			for (const [k, v] of Object.entries(parsed)) if (Array.isArray(v) && v.every((u) => typeof u === "string")) map[k] = v;
+			this.update((s) => ({
+				...s,
+				customRpc: map
+			}));
+		}
+	}
+	async destroy() {
+		this.lock();
+		await Promise.resolve();
+	}
+	lock() {
+		this.clients.clear();
+		this.engineStore = void 0;
+	}
+	endpoints(network) {
+		return [...this.getState().customRpc[network] ?? [], ...this.options.rpc[network] ?? []];
+	}
+	info(network) {
+		const info = networkById(network);
+		if (info === void 0) throw new Error(`unknown network ${network}`);
+		return info;
+	}
+	client(network) {
+		const info = this.info(network);
+		const cached = this.clients.get(network);
+		if (cached !== void 0) return cached;
+		const urls = this.endpoints(network);
+		if (urls.length === 0) throw new Error(`no rpc endpoint for ${network}`);
+		const client = createPublicClient({
+			chain: {
+				id: info.chainId,
+				name: info.name,
+				nativeCurrency: {
+					name: info.symbol,
+					symbol: info.symbol,
+					decimals: info.decimals
+				},
+				rpcUrls: { default: { http: urls } }
+			},
+			transport: fallback(urls.map((url) => http(url, { fetchFn: this.options.fetch }))),
+			batch: { multicall: true }
+		});
+		this.clients.set(network, client);
+		return client;
+	}
+	/** Validate a custom endpoint's reported chain id, then persist it first in the list. */
+	/** Solana JSON-RPC over the ordered endpoint list — kit's transport is single-endpoint. */
+	/** Networks with at least one configured endpoint, filtered by family. */
+	enabled(family) {
+		return [.../* @__PURE__ */ new Set([...Object.keys(this.options.rpc), ...Object.keys(this.getState().customRpc)])].filter((id) => {
+			const info = networkById(id);
+			return info !== void 0 && info.family === family;
+		});
+	}
+	solanaRpc(network) {
+		const urls = this.endpoints(network);
+		if (urls.length === 0) throw new Error(`no rpc endpoint for ${network}`);
+		return { call: async (method, params) => {
+			const attempt = async (rest, last) => {
+				const [url, ...next] = rest;
+				if (url === void 0) throw last instanceof Error ? last : new Error(typeof last === "string" ? last : method);
+				try {
+					const body = await (await this.options.fetch(url, {
+						method: "POST",
+						headers: { "content-type": "application/json" },
+						body: JSON.stringify({
+							jsonrpc: "2.0",
+							id: 1,
+							method,
+							params
+						})
+					})).json();
+					if (!isObject$5(body)) return await attempt(next, /* @__PURE__ */ new Error(`malformed response from ${url}`));
+					if (body["error"] !== void 0) {
+						const msg = isObject$5(body["error"]) ? body["error"]["message"] : void 0;
+						return await attempt(next, new Error(typeof msg === "string" ? msg : method));
+					}
+					return body["result"];
+				} catch (error) {
+					return attempt(next, error);
+				}
+			};
+			return attempt(urls, void 0);
+		} };
+	}
+	/** Bounded-concurrency + 429-aware ordered-failover Esplora client. */
+	esplora(network) {
+		const urls = this.endpoints(network);
+		if (urls.length === 0) throw new Error(`no esplora endpoint for ${network}`);
+		return esplora(urls, async (url, init) => {
+			const r = await this.options.fetch(url, init);
+			return {
+				ok: r.ok,
+				status: r.status,
+				headers: { get: (h) => r.headers.get(h) ?? void 0 },
+				json: async () => r.json(),
+				text: async () => r.text()
+			};
+		}, esploraSleep);
+	}
+	async addRpc(network, url) {
+		const info = this.info(network);
+		if (info.family === "bitcoin") {
+			const genesis = (await (await this.options.fetch(`${url.replace(/\/$/, "")}/block-height/0`)).text()).trim();
+			if (genesis !== info.genesisHash) throw new Error(`${url} reports genesis ${genesis}, expected ${info.genesisHash ?? ""}`);
+		} else if (info.family === "solana") {
+			const body = await (await this.options.fetch(url, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify({
+					jsonrpc: "2.0",
+					id: 1,
+					method: "getGenesisHash",
+					params: []
+				})
+			})).json();
+			const genesis = isObject$5(body) ? body["result"] : void 0;
+			if (genesis !== info.genesisHash) throw new Error(`${url} reports genesis hash ${String(genesis)}, expected ${info.genesisHash ?? ""}`);
+			const current = this.getState().customRpc[network] ?? [];
+			const customRpc = {
+				...this.getState().customRpc,
+				[network]: [url, ...current]
+			};
+			this.update((s) => ({
+				...s,
+				customRpc
+			}));
+			const store = this.engineStore;
+			if (store !== void 0) await store.collection("networks").put("customRpc", new TextEncoder().encode(JSON.stringify(customRpc)));
+			return;
+		}
+		const body = await (await this.options.fetch(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				jsonrpc: "2.0",
+				id: 1,
+				method: "eth_chainId",
+				params: []
+			})
+		})).json();
+		const result = typeof body === "object" && body !== null && "result" in body ? body.result : void 0;
+		if (typeof result !== "string") throw new TypeError(`eth_chainId returned a malformed response from ${url}`);
+		const chainId = Number.parseInt(result, 16);
+		if (chainId !== info.chainId) throw new Error(`${url} reports chain id ${chainId}, expected ${info.chainId}`);
+		const current = this.getState().customRpc[network] ?? [];
+		const customRpc = {
+			...this.getState().customRpc,
+			[network]: [url, ...current]
+		};
+		this.update((s) => ({
+			...s,
+			customRpc
+		}));
+		this.clients.delete(network);
+		const store = this.engineStore;
+		if (store !== void 0) await store.collection("networks").put("customRpc", new TextEncoder().encode(JSON.stringify(customRpc)));
+	}
+};
+//#endregion
+//#region 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) => ({
+	kind: "invalid",
+	reason
+});
+/** BTC decimal `amount` → sats. At most 8 decimal places; must fit a safe integer. */
+function btcAmountSats(text) {
+	const match = /^(\d+)(?:\.(\d{1,8}))?$/.exec(text);
+	if (match === null) return;
+	const [, whole] = match;
+	if (whole === void 0) return;
+	const sats = BigInt(whole) * 100000000n + BigInt((match[2] ?? "").padEnd(8, "0") || "0");
+	return sats <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(sats) : void 0;
+}
+/**
+* BOLT11 → fields, network- and expiry-checked. `undefined` = not a bolt11 string; `"network"` /
+* `"expired"` / `"malformed"` are the failure modes.
+*/
+function bolt11Fields(text, options) {
+	let decoded;
+	try {
+		decoded = decodeBolt11(text);
+	} catch {
+		return;
 	}
 	const network = decoded.network === "mainnet" ? "mainnet" : decoded.network === "regtest" ? "regtest" : void 0;
 	if (network === void 0) return "network";
@@ -2681,7 +3439,7 @@ function categorizePayment(error) {
 //#endregion
 //#region src/spark/notes.ts
 const HEX64 = /^[0-9a-f]{64}$/;
-const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const isObject$4 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 const NOTE_FIELDS = /* @__PURE__ */ new Set([
 	"kind",
 	"recipientPubkey",
@@ -2691,7 +3449,7 @@ const NOTE_FIELDS = /* @__PURE__ */ new Set([
 ]);
 /** Strict read-side validation: anything off-shape is `undefined`, never a throw. */
 function parsePaymentNote(value) {
-	if (!isObject(value)) return;
+	if (!isObject$4(value)) return;
 	for (const field of Object.keys(value)) if (!NOTE_FIELDS.has(field)) return;
 	const { kind, recipientPubkey, eventId, comment, lightning } = value;
 	if (kind !== "zap") return;
@@ -3249,6 +4007,1161 @@ var SparkController = class extends Controller {
 	}
 };
 //#endregion
+//#region 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 fetchRawTxes = async (es, utxos) => {
+	const out = /* @__PURE__ */ new Map();
+	await Promise.all(utxos.map(async (u) => {
+		const raw = await es.get(`/tx/${u.txid}/hex`);
+		if (typeof raw !== "string") throw new TypeError(`esplora /tx/${u.txid}/hex: not a string`);
+		const bytes = hex.decode(raw);
+		if (Transaction.fromRaw(bytes, { allowUnknownInputs: true }).id !== u.txid) throw new Error(`esplora /tx/${u.txid}/hex: txid mismatch`);
+		out.set(u.txid, bytes);
+	}));
+	return out;
+};
+/** The account-relative full path `purpose'/coin'/group'/change/index` for a PSBT entry. */
+const accountPath = (accountPath) => accountPath.replace(/^m\//, "").split("/").map((p) => {
+	const hardened = p.endsWith("'");
+	const n = Number(hardened ? p.slice(0, -1) : p);
+	return hardened ? n + 2147483648 : n;
+});
+const poll = async (ctx, tx) => {
+	if (tx.hash === void 0) return "failed";
+	const status = await ctx.options.networks.esplora(tx.network).get(`/tx/${tx.hash}/status`);
+	if (!(isObject$3(status) && status["confirmed"] === true)) return;
+	return "confirmed";
+};
+/** Per-controller route — the UTXO store and the build stash are engine state. */
+const createBitcoinRoute = () => {
+	const bitcoin = new BitcoinChainAdapter();
+	const bitcoinUtxos = new BtcUtxoStore();
+	const pending = /* @__PURE__ */ new Map();
+	const send = async (ctx, params) => {
+		const { account, network, to, amount, fee, verify } = params;
+		if (account.kind !== "hd") throw new Error("imported accounts are not yet supported");
+		const es = ctx.options.networks.esplora(network);
+		const apis = ctx.options.chains ?? chains(ctx.options.wallet);
+		const template = [
+			"btc.bip44",
+			"btc.bip49",
+			"btc.bip84",
+			"btc.bip86"
+		].find((x) => x === account.template) ?? "btc.bip84";
+		const btcAccount = await apis.account({
+			walletId: account.walletId,
+			groupIndex: account.groupIndex,
+			template,
+			network
+		});
+		if (!("xpub" in btcAccount) || btcAccount.xpub === void 0) throw new Error("bitcoin account carries no xpub");
+		const { xpub, fingerprint, path } = btcAccount;
+		const fp = Number.parseInt(fingerprint, 16);
+		const net = bitcoinNetwork(network);
+		const tap = template === "btc.bip86";
+		const rawTxOf = (u) => rawTxes.get(u.txid);
+		const receive = await scanChain(es, xpub, template, network, net.params, 0);
+		const change = await scanChain(es, xpub, template, network, net.params, 1);
+		const addresses = [...receive, ...change];
+		const utxos = (await scanUtxos(es, addresses, net.params)).map((u) => ({
+			txid: u.txid,
+			vout: u.vout,
+			value: u.value,
+			address: u.address,
+			status: "confirmed",
+			height: u.height
+		}));
+		const byAddr = new Map(addresses.map((a) => [a.address, a]));
+		const base = accountPath(path);
+		const rawTxes = template === "btc.bip44" ? await fetchRawTxes(es, utxos) : /* @__PURE__ */ new Map();
+		const inputs = bitcoin.toInputs(utxos, fp, (u) => {
+			const a = byAddr.get(u.address);
+			return a === void 0 ? [] : [
+				...base,
+				a.chain,
+				a.index
+			];
+		}, (u) => {
+			const a = byAddr.get(u.address);
+			if (a === void 0) throw new Error(`utxo ${u.txid} on an unknown address`);
+			return bitcoinPubkeyFromXpub(xpub, template, network, a.chain, a.index);
+		}, (u) => scriptPubKey(u.address, net.params), template, template === "btc.bip44" ? rawTxOf : void 0);
+		let changeAddr = change.find((a) => !a.used)?.address;
+		if (template === "btc.bip49" || template === "btc.bip44") {
+			const acct84 = await apis.account({
+				walletId: account.walletId,
+				groupIndex: account.groupIndex,
+				template: "btc.bip84",
+				network
+			});
+			const xpub84 = "xpub" in acct84 ? acct84.xpub : void 0;
+			if (xpub84 === void 0) throw new Error("no bip84 account for the legacy-template change chain");
+			changeAddr = (await scanChain(es, xpub84, "btc.bip84", network, net.params, 1)).find((a) => !a.used)?.address;
+		}
+		if (changeAddr === void 0) throw new Error("no unused change address");
+		const quotes = await feeTiers(es);
+		const quote = quotes.find((q) => q.tier === (fee === "fast" ? "fast" : fee === "slow" ? "slow" : "normal")) ?? quotes[1];
+		if (quote === void 0) throw new Error("no fee quote");
+		const { psbt, inputs: selected } = bitcoin.buildPsbt(inputs, to, amount, BigInt(quote.satPerByte), changeAddr, net.params);
+		const selectedKeys = new Set(selected.map((i) => `${String(i.txid ?? "")}:${String(i.index ?? 0)}`));
+		const selectedUtxos = utxos.filter((u) => selectedKeys.has(`${u.txid}:${u.vout}`));
+		const txP = Transaction.fromPSBT(psbt);
+		const ownScripts = new Set(change.filter((a) => !a.used).map((a) => hex.encode(scriptPubKey(a.address, net.params))));
+		const request = {
+			kind: "bitcoin.psbt",
+			network,
+			account,
+			psbt,
+			sign: Array.from({ length: txP.inputsLength }, (_, i) => i)
+		};
+		const intent = decodeBitcoinPsbt(request, ownScripts);
+		const vsize = Math.ceil(10.5 + txP.inputsLength * (tap ? 57.5 : 68) + txP.outputsLength * (tap ? 43 : 31));
+		const outValues = Array.from({ length: txP.outputsLength }, (_, i) => {
+			const o = txP.getOutput(i);
+			const scriptHex = "script" in o && o.script instanceof Uint8Array ? o.script : /* @__PURE__ */ new Uint8Array();
+			return {
+				address: scriptHex.length > 0 ? Address(net.params).encode(OutScript.decode(scriptHex)) : "",
+				value: Number(o.amount ?? 0n),
+				own: false
+			};
+		});
+		for (const o of outValues) if (o.address !== "" && ownScripts.has(hex.encode(scriptPubKey(o.address, net.params)))) o.own = true;
+		const inTotal = selectedUtxos.reduce((a, u) => a + u.value, 0);
+		const outTotal = outValues.reduce((a, o) => a + o.value, 0);
+		const id0 = newId(ctx.options.random);
+		pending.set(id0, {
+			inputs,
+			allUtxos: utxos,
+			pathOf: (u) => {
+				const a = byAddr.get(u.address);
+				return a === void 0 ? [] : [
+					...base,
+					a.chain,
+					a.index
+				];
+			},
+			pubkeyOf: (u) => {
+				const a = byAddr.get(u.address);
+				if (a === void 0) throw new Error(`utxo ${String(u.txid)} on an unknown address`);
+				return bitcoinPubkeyFromXpub(xpub, template, network, a.chain, a.index);
+			},
+			scriptOf: (u) => scriptPubKey(u.address, net.params),
+			changeAddresses: change.filter((a) => !a.used).map((a) => a.address),
+			fp,
+			tier: fee === "fast" ? "fast" : fee === "slow" ? "slow" : "normal",
+			template,
+			network
+		});
+		let tx = {
+			id: id0,
+			family: "bitcoin",
+			network,
+			account: account.walletId,
+			hash: void 0,
+			state: "draft",
+			intent,
+			nonce: 0,
+			btc: {
+				inputs: selectedUtxos.map((u) => ({
+					txid: u.txid,
+					vout: u.vout,
+					value: u.value,
+					address: u.address
+				})),
+				outputs: outValues,
+				vsize,
+				fee: inTotal - outTotal,
+				feeRate: Math.ceil((inTotal - outTotal) / vsize)
+			},
+			submittedAt: ctx.options.now(),
+			error: void 0
+		};
+		tx = await ctx.transition(tx, {});
+		try {
+			const result = await apis.sign({
+				request,
+				verify
+			});
+			tx = await ctx.transition(tx, { state: "signed" });
+			if (result.kind !== "bitcoin.psbt" || !(result.signedPsbt instanceof Uint8Array)) throw new Error("unexpected bitcoin sign result");
+			bitcoinUtxos.lock(selectedUtxos, tx.id);
+			const signed = Transaction.fromPSBT(result.signedPsbt);
+			signed.finalize();
+			const raw = signed.extract();
+			const hash = String(await es.post("/tx", hex.encode(raw)));
+			tx = await ctx.transition(tx, {
+				state: "submitted",
+				hash,
+				submittedAt: ctx.options.now()
+			});
+			ctx.track(tx.id, hash);
+			return tx;
+		} catch (error) {
+			const failed = tx.state === "signed" ? "failed" : "rejected";
+			await ctx.transition(tx, {
+				state: failed,
+				error: errorMessage(error)
+			});
+			throw error;
+		}
+	};
+	/** Esplora `/tx/:txid/status` → terminal state or `undefined` to keep polling. */
+	const finish = async (ctx, stash, es, account, old, psbt, record, link, verify) => {
+		const apis = ctx.options.chains ?? chains(ctx.options.wallet);
+		const txP = Transaction.fromPSBT(psbt);
+		const request = {
+			kind: "bitcoin.psbt",
+			network: old.network,
+			account,
+			psbt,
+			sign: Array.from({ length: txP.inputsLength }, (_, i) => i)
+		};
+		const ownScripts = new Set(stash.changeAddresses.map((a) => hex.encode(scriptPubKey(a, bitcoinNetwork(stash.network).params))));
+		const intent = decodeBitcoinPsbt(request, ownScripts);
+		let tx = {
+			id: newId(ctx.options.random),
+			family: "bitcoin",
+			network: old.network,
+			account: old.account,
+			hash: void 0,
+			state: "draft",
+			intent,
+			nonce: 0,
+			btc: record,
+			submittedAt: ctx.options.now(),
+			error: void 0,
+			...link
+		};
+		tx = await ctx.transition(tx, {});
+		try {
+			const result = await apis.sign({
+				request,
+				verify
+			});
+			tx = await ctx.transition(tx, { state: "signed" });
+			if (result.kind !== "bitcoin.psbt" || !(result.signedPsbt instanceof Uint8Array)) throw new Error("unexpected bitcoin sign result");
+			bitcoinUtxos.endTx(old.id, "dropped");
+			const signed = Transaction.fromPSBT(result.signedPsbt);
+			signed.finalize();
+			const raw = signed.extract();
+			const hash = String(await es.post("/tx", hex.encode(raw)));
+			bitcoinUtxos.lock(record.inputs.map((i) => ({
+				...i,
+				status: "confirmed",
+				height: 0
+			})), tx.id);
+			tx = await ctx.transition(tx, {
+				state: "submitted",
+				hash,
+				submittedAt: ctx.options.now()
+			});
+			ctx.track(tx.id, hash);
+			return tx;
+		} catch (error) {
+			const failed = tx.state === "signed" ? "failed" : "rejected";
+			await ctx.transition(tx, {
+				state: failed,
+				error: errorMessage(error)
+			});
+			throw error;
+		}
+	};
+	const replace = async (ctx, old, mode, verify) => {
+		const stash = pending.get(old.id);
+		const { btc } = old;
+		if (stash === void 0 || btc === void 0) throw new Error("the original build context is gone — cannot replace after restart");
+		const es = ctx.options.networks.esplora(old.network);
+		const apis = ctx.options.chains ?? chains(ctx.options.wallet);
+		const { template } = stash;
+		if (!("xpub" in await apis.account({
+			walletId: old.account,
+			groupIndex: 0,
+			template,
+			network: old.network
+		}))) throw new Error("bitcoin account carries no xpub");
+		const account = {
+			kind: "hd",
+			walletId: old.account,
+			groupIndex: 0,
+			template
+		};
+		const tiers = await feeTiers(es);
+		const tierQuote = tiers.find((t) => t.tier === stash.tier) ?? tiers[1];
+		const rate = tierQuote === void 0 ? 1 : tierQuote.satPerByte;
+		const newFee = Math.max(btc.fee + btc.vsize, Math.ceil(btc.vsize * rate));
+		const [changeAddr] = stash.changeAddresses;
+		if (changeAddr === void 0) throw new Error("no unused change address");
+		const net = bitcoinNetwork(old.network);
+		const inTotal = btc.inputs.reduce((a, i) => a + i.value, 0);
+		const dust = 546;
+		const payee = btc.outputs.filter((o) => !o.own).map((o) => ({
+			address: o.address,
+			amount: BigInt(o.value)
+		}));
+		const usedKeys = new Set(btc.inputs.map((i) => `${i.txid}:${i.vout}`));
+		const spare = stash.allUtxos.filter((u) => !usedKeys.has(`${u.txid}:${u.vout}`));
+		const extraInputs = [];
+		const extraUtxos = [];
+		const feeNeeded = (o) => BigInt(newFee) - (BigInt(inTotal) + extraUtxos.reduce((a, u) => a + BigInt(u.value), 0n) - o.reduce((a, x) => a + x.amount, 0n));
+		let outputs;
+		if (mode === "cancel") outputs = [{
+			address: changeAddr,
+			amount: BigInt(inTotal - newFee)
+		}];
+		else {
+			const shrunk = btc.outputs.find((o) => o.own);
+			const changeAfter = shrunk === void 0 ? 0 : shrunk.value - (newFee - btc.fee);
+			outputs = changeAfter >= dust ? [...payee, {
+				address: changeAddr,
+				amount: BigInt(changeAfter)
+			}] : payee;
+			while (feeNeeded(outputs) > 0n && spare.length > extraUtxos.length) {
+				const next = spare[extraUtxos.length];
+				if (next === void 0) break;
+				extraUtxos.push(next);
+				extraInputs.push(...bitcoin.toInputs([{
+					...next,
+					status: "confirmed"
+				}], stash.fp, stash.pathOf, stash.pubkeyOf, stash.scriptOf, stash.template));
+			}
+			if (feeNeeded(outputs) > 0n) {
+				const keepChange = [...outputs, {
+					address: changeAddr,
+					amount: BigInt(dust)
+				}];
+				while (feeNeeded(keepChange) > 0n && spare.length > extraUtxos.length) {
+					const next = spare[extraUtxos.length];
+					if (next === void 0) break;
+					extraUtxos.push(next);
+					extraInputs.push(...bitcoin.toInputs([{
+						...next,
+						status: "confirmed"
+					}], 0, stash.pathOf, stash.pubkeyOf, stash.scriptOf, stash.template));
+				}
+				if (feeNeeded(keepChange) > 0n) throw new Error("insufficient confirmed utxo to fund the replacement fee");
+				const changeValue = inTotal + extraUtxos.reduce((a, u) => a + u.value, 0) - payee.reduce((a, o) => a + Number(o.amount), 0) - newFee;
+				outputs = [...payee, {
+					address: changeAddr,
+					amount: BigInt(changeValue)
+				}];
+			} else {
+				const changeValue = inTotal + extraUtxos.reduce((a, u) => a + u.value, 0) - payee.reduce((a, o) => a + Number(o.amount), 0) - newFee;
+				if (changeValue >= dust) outputs = [...payee, {
+					address: changeAddr,
+					amount: BigInt(changeValue)
+				}];
+			}
+		}
+		const allInputs = [...stash.inputs, ...extraInputs];
+		const { psbt, vsize } = bitcoin.buildExactPsbt(allInputs, outputs, net.params);
+		const record = {
+			inputs: [...btc.inputs, ...extraUtxos.map((u) => ({
+				txid: u.txid,
+				vout: u.vout,
+				value: u.value,
+				address: u.address
+			}))],
+			outputs: outputs.map((o) => ({
+				address: o.address,
+				value: Number(o.amount),
+				own: o.address === changeAddr
+			})),
+			vsize,
+			fee: newFee,
+			feeRate: Math.ceil(newFee / vsize)
+		};
+		return finish(ctx, stash, es, account, old, psbt, record, { replaces: old.id }, verify);
+	};
+	const bumpChild = async (ctx, old, targetRate, verify) => {
+		const stash = pending.get(old.id);
+		const { btc } = old;
+		if (stash === void 0 || btc === void 0) throw new Error("the parent build context is gone — cannot bump after restart");
+		const es = ctx.options.networks.esplora(old.network);
+		const { template } = stash;
+		const account = {
+			kind: "hd",
+			walletId: old.account,
+			groupIndex: 0,
+			template
+		};
+		const own = btc.outputs.flatMap((o, vout) => o.own ? [{
+			...o,
+			vout
+		}] : []);
+		if (own.length === 0) throw new Error("parent has no own outputs to bump");
+		const childInputs = bitcoin.toInputs(own.map((o) => ({
+			txid: old.hash ?? "",
+			vout: o.vout,
+			value: o.value,
+			address: o.address,
+			status: "confirmed",
+			height: 0
+		})), stash.fp, stash.pathOf, stash.pubkeyOf, stash.scriptOf, stash.template);
+		const [changeAddr] = stash.changeAddresses;
+		if (changeAddr === void 0) throw new Error("no unused change address");
+		const net = bitcoinNetwork(old.network);
+		const inTotal = own.reduce((a, o) => a + o.value, 0);
+		const probe = bitcoin.buildExactPsbt(childInputs, [{
+			address: changeAddr,
+			amount: BigInt(inTotal)
+		}], net.params);
+		const childFee = Math.max(Math.ceil(targetRate * (btc.vsize + probe.vsize)) - btc.fee, probe.vsize);
+		const { psbt, vsize } = bitcoin.buildExactPsbt(childInputs, [{
+			address: changeAddr,
+			amount: BigInt(inTotal - childFee)
+		}], net.params);
+		const record = {
+			inputs: own.map((o, i) => ({
+				txid: old.hash ?? "",
+				vout: i,
+				value: o.value,
+				address: o.address
+			})),
+			outputs: [{
+				address: changeAddr,
+				value: inTotal - childFee,
+				own: true
+			}],
+			vsize,
+			fee: childFee,
+			feeRate: Math.ceil(childFee / vsize)
+		};
+		return finish(ctx, stash, es, account, old, psbt, record, { parentId: old.id }, verify);
+	};
+	return {
+		send,
+		poll,
+		replace,
+		bumpChild
+	};
+};
+//#endregion
+//#region 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;
+/** 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 send = async (ctx, params) => {
+		const { account, network, to, amount, fee, verify } = params;
+		const { networks } = ctx.options;
+		if (account.kind !== "hd") throw new Error("imported accounts are not yet supported");
+		const info = networks.info(network);
+		const client = networks.client(network);
+		const apis = ctx.options.chains ?? chains(ctx.options.wallet);
+		const evmAccount = await apis.account({
+			walletId: account.walletId,
+			groupIndex: account.groupIndex,
+			template: "evm.bip44",
+			network
+		});
+		const from = "address" in evmAccount ? evmAccount.address : "";
+		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
+		});
+		const quotes = await evm.estimateFee(client);
+		const quote = quotes.find((q) => q.tier === fee) ?? quotes[1];
+		if (quote === void 0) throw new Error("no fee quote");
+		const feed = evm.applyFee(unsigned, quote);
+		const request = evm.toSignRequest(feed, account, info.chainId);
+		const intent = decodeEvm(request);
+		const id = newId(ctx.options.random);
+		pending.set(id, {
+			unsigned: feed,
+			request,
+			quote,
+			chainId: info.chainId
+		});
+		let tx = {
+			id,
+			family: "evm",
+			network,
+			account: account.walletId,
+			hash: void 0,
+			state: "draft",
+			intent,
+			nonce: unsigned.nonce,
+			submittedAt: ctx.options.now(),
+			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(error)
+			});
+			throw error;
+		}
+		try {
+			const raw = evm.finalize(feed, 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(error)
+			});
+			throw error;
+		}
+	};
+	/**
+	* EVM speed-up/cancel — replaces a pending tx at the same nonce with a bumped fee (cancel = a
+	* 0-value transfer to self). The new tx carries `replaces` and needs a fresh signature; a
+	* rejected one never reaches the network and leaves the original.
+	*/
+	const replace = async (ctx, old, mode, verify) => {
+		const stash = pending.get(old.id);
+		if (stash === void 0) throw new Error("the original build context is gone — cannot replace after restart");
+		const { networks } = ctx.options;
+		const client = networks.client(old.network);
+		const apis = ctx.options.chains ?? chains(ctx.options.wallet);
+		const { tier } = stash.quote;
+		const estimates = await evm.estimateFee(client);
+		const estimate = estimates.find((q) => q.tier === tier) ?? estimates[1];
+		if (estimate === void 0) throw new Error("no fee quote");
+		const oldFee = stash.unsigned;
+		const bumpedFee = bump(oldFee.maxFeePerGas ?? oldFee.gasPrice ?? 0n);
+		const maxFeePerGas = bumpedFee > estimate.maxFeePerGas ? bumpedFee : estimate.maxFeePerGas;
+		const priorityBump = oldFee.maxPriorityFeePerGas === void 0 && estimate.maxPriorityFeePerGas === void 0 ? void 0 : bump(oldFee.maxPriorityFeePerGas ?? 0n) > (estimate.maxPriorityFeePerGas ?? 0n) ? bump(oldFee.maxPriorityFeePerGas ?? 0n) : estimate.maxPriorityFeePerGas ?? 0n;
+		const feeFields = priorityBump === void 0 ? { maxFeePerGas } : {
+			maxFeePerGas,
+			maxPriorityFeePerGas: priorityBump
+		};
+		const unsigned = mode === "cancel" ? {
+			...stash.unsigned,
+			to: stash.unsigned.from,
+			value: 0n,
+			data: "0x",
+			gas: 21000n,
+			...feeFields
+		} : {
+			...stash.unsigned,
+			...feeFields
+		};
+		const request = evm.toSignRequest(unsigned, stash.request.account, stash.chainId);
+		const intent = decodeEvm(request);
+		const id = newId(ctx.options.random);
+		pending.set(id, {
+			unsigned,
+			request,
+			quote: stash.quote,
+			chainId: stash.chainId
+		});
+		let tx = {
+			id,
+			family: "evm",
+			network: old.network,
+			account: old.account,
+			hash: void 0,
+			state: "draft",
+			intent,
+			nonce: old.nonce,
+			replaces: old.id,
+			submittedAt: ctx.options.now(),
+			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(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(error)
+			});
+			throw error;
+		}
+	};
+	/** Returns the terminal state once the receipt lands, or `undefined` to keep polling. */
+	const poll = async (ctx, tx) => {
+		if (tx.hash === void 0) return "failed";
+		const state = await evm.status(ctx.options.networks.client(tx.network), tx.hash);
+		if (state === "pending") return;
+		pending.delete(tx.id);
+		return state === "finalized" ? "confirmed" : state;
+	};
+	return {
+		send,
+		poll,
+		replace
+	};
+};
+PROGRAM_IDS.token2022;
+const MAX_MESSAGE_BYTES = 1232;
+const CU_SIMULATE_LIMIT = 14e5;
+const b64 = (bytes) => base64.encode(bytes);
+const isObject$2 = (v) => typeof v === "object" && v !== null;
+const obj$1 = (v) => isObject$2(v) ? v : void 0;
+const str = (v, fallback = "0") => {
+	if (typeof v === "string") return v;
+	return typeof v === "number" || typeof v === "bigint" ? String(v) : fallback;
+};
+var SolanaChainAdapter = class {
+	async rpc(rpc, method, params) {
+		return rpc.call(method, params);
+	}
+	async instructions(rpc, from, intent) {
+		if (intent.kind === "sol") return [getTransferSolInstruction({
+			source: createNoopSigner(address(from)),
+			destination: address(intent.to),
+			amount: intent.lamports
+		})];
+		const tokenProgram = intent.tokenProgram === void 0 ? TOKEN_PROGRAM_ADDRESS : address(intent.tokenProgram);
+		const [sourceAta] = await findAssociatedTokenPda({
+			mint: address(intent.mint),
+			owner: address(from),
+			tokenProgram
+		});
+		const [destAta] = await findAssociatedTokenPda({
+			mint: address(intent.mint),
+			owner: address(intent.to),
+			tokenProgram
+		});
+		const ixs = [];
+		const destInfo = await this.rpc(rpc, "getAccountInfo", [destAta, {
+			encoding: "base64",
+			commitment: "confirmed"
+		}]);
+		if (obj$1(obj$1(destInfo)?.["value"]) === void 0) ixs.push(getCreateAssociatedTokenIdempotentInstruction({
+			ata: destAta,
+			mint: address(intent.mint),
+			owner: address(intent.to),
+			payer: createNoopSigner(address(from)),
+			tokenProgram
+		}));
+		ixs.push(getTransferCheckedInstruction({
+			source: sourceAta,
+			mint: address(intent.mint),
+			destination: destAta,
+			authority: address(from),
+			amount: intent.amount,
+			decimals: intent.decimals
+		}, { programAddress: tokenProgram }));
+		return ixs;
+	}
+	/** Instruction set, simulated compute units, and a fresh blockhash — fee fields come later. */
+	async build(rpc, network, from, intent) {
+		const instructions = await this.instructions(rpc, from, intent);
+		const hashResult = obj$1(await this.rpc(rpc, "getLatestBlockhash", [{ commitment: "confirmed" }]));
+		const value = obj$1(hashResult?.["value"]);
+		const blockhashValue = typeof value?.["blockhash"] === "string" ? value["blockhash"] : "";
+		const lastValidBlockHeight = BigInt(str(value?.["lastValidBlockHeight"], "0"));
+		const compiled = this.compile(from, instructions, blockhashValue, lastValidBlockHeight);
+		const units = await this.simulate(rpc, compiled.messageBytes);
+		return {
+			family: "solana",
+			network,
+			from,
+			instructions,
+			writable: this.writableAccounts(instructions),
+			unitsConsumed: units,
+			blockhash: blockhashValue,
+			lastValidBlockHeight
+		};
+	}
+	writableAccounts(instructions) {
+		const out = /* @__PURE__ */ new Set();
+		for (const ix of instructions) {
+			const accounts = obj$1(ix)?.["accounts"];
+			if (!Array.isArray(accounts)) continue;
+			for (const a of accounts) {
+				const record = obj$1(a);
+				const role = Number(record?.["role"] ?? 0);
+				if (typeof record?.["address"] === "string" && role >= 2) out.add(record["address"]);
+			}
+		}
+		return [...out];
+	}
+	/** Unsigned wire bytes: shortvec(1) sig count + 64-byte zero sig + message (for simulate). */
+	wireBytes(messageBytes) {
+		const out = new Uint8Array(65 + messageBytes.length);
+		out[0] = 1;
+		out.set(messageBytes, 65);
+		return out;
+	}
+	async simulate(rpc, messageBytes) {
+		const result = obj$1(await this.rpc(rpc, "simulateTransaction", [b64(this.wireBytes(messageBytes)), {
+			encoding: "base64",
+			sigVerify: false,
+			replaceRecentBlockhash: false
+		}]));
+		const value = obj$1(result?.["value"]);
+		const units = Number(value?.["unitsConsumed"] ?? 0);
+		return units > 0 ? units : CU_SIMULATE_LIMIT;
+	}
+	compile(from, instructions, blockhashValue, lastValidBlockHeight) {
+		const message = createTransactionMessage({ version: 0 });
+		const withPayer = setTransactionMessageFeePayer(address(from), message);
+		const withLifetime = setTransactionMessageLifetimeUsingBlockhash({
+			blockhash: blockhash(blockhashValue),
+			lastValidBlockHeight
+		}, withPayer);
+		const withIxs = appendTransactionMessageInstructions([...instructions], withLifetime);
+		const compiled = compileTransactionMessage(withIxs);
+		const messageBytes = new Uint8Array(getCompiledTransactionMessageEncoder().encode(compiled));
+		if (messageBytes.length > MAX_MESSAGE_BYTES) throw new Error(`compiled message is ${messageBytes.length} bytes (max ${MAX_MESSAGE_BYTES})`);
+		return {
+			messageBytes,
+			instructions
+		};
+	}
+	/** Percentile-tiered prioritization fees over the writable accounts of this transaction. */
+	async estimateFee(rpc, writable) {
+		const result = await this.rpc(rpc, "getRecentPrioritizationFees", [[...writable]]);
+		const fees = (Array.isArray(result) ? result : []).flatMap((r) => {
+			const fee = obj$1(r)?.["prioritizationFee"];
+			return fee === void 0 ? [] : [Number(fee)];
+		}).sort((a, b) => a - b);
+		const pick = (p) => BigInt(fees[Math.min(fees.length - 1, Math.floor(fees.length * p / 100))] ?? 0);
+		return [
+			{
+				tier: "slow",
+				microLamportsPerCu: pick(50)
+			},
+			{
+				tier: "normal",
+				microLamportsPerCu: pick(75)
+			},
+			{
+				tier: "fast",
+				microLamportsPerCu: pick(90)
+			}
+		];
+	}
+	/** Prepend CU-limit + CU-price budget instructions; returns message bytes for the sign request. */
+	applyFee(tx, fee) {
+		const units = Math.ceil((tx.unitsConsumed === 0 ? CU_SIMULATE_LIMIT : tx.unitsConsumed) * 1.1);
+		return this.compile(tx.from, [
+			getSetComputeUnitLimitInstruction({ units }),
+			getSetComputeUnitPriceInstruction({ microLamports: fee.microLamportsPerCu }),
+			...tx.instructions
+		], tx.blockhash, tx.lastValidBlockHeight).messageBytes;
+	}
+	/** Wire transaction bytes — sigCount shortvec + each 64-byte sig + message. */
+	finalize(messageBytes, signatures) {
+		for (const sig of signatures) if (sig.length !== 64) throw new Error(`solana signature must be 64 bytes, got ${sig.length}`);
+		const out = new Uint8Array(1 + 64 * signatures.length + messageBytes.length);
+		out[0] = signatures.length;
+		for (const [i, sig] of signatures.entries()) out.set(sig, 1 + 64 * i);
+		out.set(messageBytes, 1 + 64 * signatures.length);
+		return out;
+	}
+	async broadcast(rpc, wireBytes) {
+		const result = await this.rpc(rpc, "sendTransaction", [b64(wireBytes), {
+			encoding: "base64",
+			skipPreflight: false,
+			maxRetries: 0,
+			preflightCommitment: "confirmed"
+		}]);
+		if (typeof result !== "string") throw new TypeError("sendTransaction returned a malformed signature");
+		return result;
+	}
+	/** Processed → confirmed → finalized; an error on the status means the tx failed on-chain. */
+	async status(rpc, signature) {
+		const result = obj$1(await this.rpc(rpc, "getSignatureStatuses", [[signature], { searchTransactionHistory: true }]));
+		const entry = Array.isArray(result?.["value"]) ? obj$1(result["value"][0]) : void 0;
+		if (entry === void 0) return "pending";
+		if (entry["err"] !== null && entry["err"] !== void 0) return "failed";
+		const c = entry["confirmationStatus"];
+		return c === "finalized" ? "finalized" : c === "confirmed" ? "confirmed" : "pending";
+	}
+	async blockHeight(rpc) {
+		const result = await this.rpc(rpc, "getBlockHeight", [{ commitment: "confirmed" }]);
+		return BigInt(str(result, "0"));
+	}
+};
+//#endregion
+//#region src/transactions/solana.ts
+/** Solana route: SOL/SPL send → sign → broadcast, plus status poll with rebroadcast/drop. */
+const isObject$1 = (v) => typeof v === "object" && v !== null;
+const obj = (v) => isObject$1(v) ? v : void 0;
+const arr = (v) => Array.isArray(v) ? v : void 0;
+const solana = new SolanaChainAdapter();
+/** Signed wire transactions kept for re-broadcast until the tx confirms or drops. */
+const wires = /* @__PURE__ */ new Map();
+const sendSolana = async (ctx, params) => {
+	const { account, network, to, amount, fee, verify } = params;
+	if (account.kind !== "hd") throw new Error("imported accounts are not yet supported");
+	const rpc = ctx.options.networks.solanaRpc(network);
+	const apis = ctx.options.chains ?? chains(ctx.options.wallet);
+	const solAccount = await apis.account({
+		walletId: account.walletId,
+		groupIndex: account.groupIndex,
+		template: "solana.bip44-change",
+		network
+	});
+	const from = "address" in solAccount ? solAccount.address : "";
+	let tokenProgram;
+	let ext;
+	if (params.token !== void 0) {
+		const mintInfo = await rpc.call("getAccountInfo", [params.token, {
+			encoding: "base64",
+			commitment: "confirmed"
+		}]);
+		const owner = obj(mintInfo)?.["value"];
+		if (obj(owner)?.["owner"] === PROGRAM_IDS.token2022) {
+			tokenProgram = PROGRAM_IDS.token2022;
+			const mintBytes = arr(obj(owner)?.["data"])?.[0];
+			const raw = typeof mintBytes === "string" ? base64.decode(mintBytes) : void 0;
+			if (raw !== void 0 && raw.length > 166) {
+				const epoch = obj(await rpc.call("getEpochInfo", []))?.["epoch"];
+				ext = parseMintExtensions(raw, BigInt(typeof epoch === "number" ? epoch : 0));
+				if (ext.nonTransferable === true) throw new Error("token is non-transferable");
+				if (ext.confidential === true) throw new Error("confidential transfer extensions are not supported");
+			}
+		}
+	}
+	const unsigned = await solana.build(rpc, network, from, params.token === void 0 ? {
+		kind: "sol",
+		to,
+		lamports: amount
+	} : {
+		kind: "spl",
+		mint: params.token,
+		to,
+		amount,
+		decimals: params.decimals ?? 0,
+		...tokenProgram === void 0 ? {} : { tokenProgram }
+	});
+	const quotes = await solana.estimateFee(rpc, unsigned.writable);
+	const quote = quotes.find((q) => q.tier === fee) ?? quotes[1];
+	if (quote === void 0) throw new Error("no fee quote");
+	const messageBytes = solana.applyFee(unsigned, quote);
+	const request = {
+		kind: "solana.transaction",
+		network,
+		account,
+		message: messageBytes
+	};
+	const intent = ext === void 0 || params.token === void 0 ? decodeSolana(request, from) : token2022Intent(decodeSolana(request, from), ext, params.token, amount);
+	const id = newId(ctx.options.random);
+	let tx = {
+		id,
+		family: "solana",
+		network,
+		account: account.walletId,
+		hash: void 0,
+		state: "draft",
+		intent,
+		nonce: 0,
+		lastValidBlockHeight: Number(unsigned.lastValidBlockHeight),
+		submittedAt: ctx.options.now(),
+		error: void 0
+	};
+	tx = await ctx.transition(tx, {});
+	try {
+		const result = await apis.sign({
+			request,
+			verify
+		});
+		tx = await ctx.transition(tx, { state: "signed" });
+		if (result.kind !== "solana.transaction" || !(result.signature instanceof Uint8Array)) throw new Error("unexpected solana sign result");
+		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;
+	} catch (error) {
+		const failed = tx.state === "signed" ? "failed" : "rejected";
+		await ctx.transition(tx, {
+			state: failed,
+			error: errorMessage(error)
+		});
+		throw error;
+	}
+};
+/** Returns the terminal state, `dropped` on blockhash expiry, or `undefined` to keep polling. */
+const pollSolana = async (ctx, tx) => {
+	if (tx.hash === void 0) return "failed";
+	const rpc = ctx.options.networks.solanaRpc(tx.network);
+	const state = await solana.status(rpc, tx.hash);
+	if (state !== "pending") {
+		wires.delete(tx.id);
+		return state === "finalized" ? "confirmed" : state;
+	}
+	if (tx.lastValidBlockHeight !== void 0 && await solana.blockHeight(rpc) > BigInt(tx.lastValidBlockHeight)) {
+		wires.delete(tx.id);
+		return "dropped";
+	}
+	const wire = wires.get(tx.id);
+	if (wire !== void 0) await solana.broadcast(rpc, wire).catch(() => "");
+};
+/**
+* Folds Token-2022 mint extensions into the decoded intent: a TransferFee mint shows the
+* recipient's net amount (amount − min(amount×bps/10000, maximum)); a TransferHook or
+* PermanentDelegate marks the intent `partial` with a warning. The mint's extension data is not
+* part of the message, so the route attaches what it fetched — decode alone cannot see it.
+*/
+const token2022Intent = (intent, ext, mint, amount) => {
+	const warnings = [...intent.warnings];
+	let { outflows } = intent;
+	if (ext.transferFee !== void 0) {
+		const net = netAfterTransferFee(amount, ext.transferFee.basisPoints, ext.transferFee.maximumFee);
+		const withheld = amount - net;
+		warnings.push({
+			kind: "token-2022-transfer-fee",
+			message: `transfer fee withheld ${withheld.toString(10)} base units`
+		});
+		outflows = outflows.map((o) => o.amount.asset === mint ? {
+			...o,
+			amount: {
+				...o.amount,
+				amount: net.toString(10)
+			}
+		} : o);
+	}
+	if (ext.transferHook !== void 0 || ext.permanentDelegate !== void 0) {
+		warnings.push({
+			kind: "token-2022-extension",
+			message: "mint carries a transfer-hook or permanent-delegate extension"
+		});
+		return {
+			...intent,
+			outflows,
+			warnings,
+			verifiability: "partial"
+		};
+	}
+	return {
+		...intent,
+		outflows,
+		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.
+*/
+const encode = (tx) => new TextEncoder().encode(JSON.stringify(tx));
+const isObject = (v) => typeof v === "object" && v !== null;
+const TX_STATES = /* @__PURE__ */ new Set([
+	"draft",
+	"signed",
+	"submitted",
+	"pending",
+	"confirmed",
+	"failed",
+	"rejected",
+	"dropped",
+	"replaced"
+]);
+const isTxState = (v) => typeof v === "string" && TX_STATES.has(v);
+const isBtcRecord = (v) => {
+	if (!isObject(v)) return false;
+	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 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;
+	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,
+		family,
+		network,
+		account,
+		hash: typeof hash === "string" ? hash : void 0,
+		state,
+		intent: isIntent(intent) ? intent : void 0,
+		nonce,
+		...typeof replaces === "string" ? { replaces } : {},
+		...typeof parentId === "string" ? { parentId } : {},
+		...isBtcRecord(btc) ? { btc } : {},
+		submittedAt,
+		error: typeof error === "string" ? error : void 0
+	};
+};
+var TransactionController = class extends Controller {
+	options;
+	engineStore;
+	timers = /* @__PURE__ */ new Map();
+	evmRoute = createEvmRoute();
+	bitcoinRoute = createBitcoinRoute();
+	locked = true;
+	constructor(options) {
+		super({
+			name: "transactions",
+			defaultState: () => ({ txs: {} })
+		});
+		this.options = options;
+	}
+	async init() {
+		this.locked = false;
+		this.engineStore = await this.options.openStore();
+		const collection = this.engineStore.collection("transactions");
+		const keys = await collection.list();
+		const rows = await Promise.all(keys.map(async (key) => collection.get(key)));
+		for (const raw of rows) {
+			const tx = raw === void 0 ? void 0 : decode(raw);
+			if (tx === void 0) continue;
+			this.update((s) => ({
+				...s,
+				txs: {
+					...s.txs,
+					[tx.id]: tx
+				}
+			}));
+			if ((tx.state === "submitted" || tx.state === "pending") && tx.hash !== void 0) this.track(tx.id, tx.hash);
+		}
+	}
+	async destroy() {
+		this.lock();
+		await Promise.resolve();
+	}
+	lock() {
+		this.locked = true;
+		for (const stop of this.timers.values()) stop();
+		this.timers.clear();
+		this.engineStore = void 0;
+		this.evmRoute = createEvmRoute();
+	}
+	async persist(tx) {
+		const store = this.engineStore;
+		if (store !== void 0) await store.collection("transactions").put(tx.id, encode(tx));
+	}
+	async transition(tx, next) {
+		const updated = {
+			...tx,
+			...next
+		};
+		this.update((s) => ({
+			...s,
+			txs: {
+				...s.txs,
+				[tx.id]: updated
+			}
+		}));
+		await this.persist(updated);
+		return updated;
+	}
+	routeCtx() {
+		return {
+			options: this.options,
+			transition: async (tx, next) => this.transition(tx, next),
+			track: (id, hash) => this.track(id, hash),
+			newId: () => newId(this.options.random)
+		};
+	}
+	async send(params) {
+		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 sendSolana(ctx, params);
+		if (info.family === "bitcoin") return this.bitcoinRoute.send(ctx, params);
+		return this.evmRoute.send(ctx, params);
+	}
+	/**
+	* Speed up or cancel a pending/submitted EVM transaction at the same nonce — a fresh signature is
+	* required and a rejection leaves the original untouched.
+	*/
+	async replace(id, mode, verify) {
+		if (this.locked) throw new Error("transactions require an unlocked vault");
+		const old = this.getState().txs[id];
+		if (old === void 0) throw new Error(`unknown transaction ${id}`);
+		if (old.family === "bitcoin") return this.bitcoinRoute.replace(this.routeCtx(), old, mode, verify);
+		if (old.family !== "evm") throw new Error("replace is EVM-only in this layer");
+		if (old.state !== "pending" && old.state !== "submitted") throw new Error(`cannot replace a ${old.state} transaction`);
+		return this.evmRoute.replace(this.routeCtx(), old, mode, verify);
+	}
+	/**
+	* CPFP — spend an unconfirmed tx's own outputs into a higher-fee child so the package mines.
+	* Bitcoin only; the child is linked via `parentId`.
+	*/
+	async bumpChild(id, targetRate, verify) {
+		if (this.locked) throw new Error("transactions require an unlocked vault");
+		const old = this.getState().txs[id];
+		if (old === void 0) throw new Error(`unknown transaction ${id}`);
+		if (old.family !== "bitcoin") throw new Error("bumpChild is Bitcoin-only in this layer");
+		if (old.state !== "pending" && old.state !== "submitted") throw new Error(`cannot bump a ${old.state} transaction`);
+		return this.bitcoinRoute.bumpChild(this.routeCtx(), old, targetRate, verify);
+	}
+	track(id, hash) {
+		if (this.timers.has(id) || hash === "") return;
+		const poll = this.options.pollMs ?? 4e3;
+		const stop = this.options.setTimer(poll, async () => {
+			if (this.locked) return;
+			try {
+				const tx = this.getState().txs[id];
+				if (tx === void 0) return;
+				const ctx = this.routeCtx();
+				const next = tx.family === "solana" ? await pollSolana(ctx, tx) : tx.family === "bitcoin" ? await this.bitcoinRoute.poll(ctx, tx) : await this.evmRoute.poll(ctx, tx);
+				if (next === void 0) return;
+				const updated = await this.transition(tx, { state: next });
+				this.timers.delete(id);
+				stop();
+				const siblings = Object.values(this.getState().txs).filter((t) => t.id !== updated.id && t.hash !== void 0 && t.state !== "replaced" && (updated.replaces !== void 0 && t.id === updated.replaces || t.replaces !== void 0 && t.replaces === updated.id) && (t.state === "submitted" || t.state === "pending"));
+				await Promise.all(siblings.map(async (sibling) => {
+					await this.transition(sibling, { state: "replaced" });
+					const siblingStop = this.timers.get(sibling.id);
+					this.timers.delete(sibling.id);
+					siblingStop?.();
+				}));
+			} catch (error) {
+				this.options.logger.warn("tx status poll failed", error);
+			}
+		});
+		this.timers.set(id, stop);
+	}
+};
+//#endregion
 //#region src/engine.ts
 /**
 * Composition root: wires the Wallet's lock state to the SparkController's lifecycle. Unlocked →
@@ -3276,10 +5189,42 @@ function createWalletEngine(options) {
 			fetch
 		})
 	});
+	const networks = new NetworkController({
+		fetch: options.fetch,
+		rpc: options.rpc ?? {},
+		openStore: options.openStore,
+		logger: options.logger
+	});
+	const assets = new AssetsController({
+		networks,
+		openStore: options.openStore,
+		setTimer: options.setTimer ?? ((ms, fn) => {
+			const id = setTimeout(() => {
+				fn();
+			}, ms);
+			return () => clearTimeout(id);
+		}),
+		logger: options.logger
+	});
+	const transactions = new TransactionController({
+		wallet: options.wallet,
+		networks,
+		openStore: options.openStore,
+		random: options.random,
+		setTimer: options.setTimer ?? ((ms, fn) => {
+			const id = setTimeout(() => {
+				fn();
+			}, ms);
+			return () => clearTimeout(id);
+		}),
+		now: options.now,
+		logger: options.logger
+	});
 	const accounts = new AccountTreeController({
 		wallet: options.wallet,
 		spark: controller,
 		sparkNetwork: options.sparkNetwork,
+		networks,
 		logger: options.logger,
 		now: options.now
 	});
@@ -3313,8 +5258,14 @@ function createWalletEngine(options) {
 			await accounts.init();
 			await controller.init();
 			await metaSync.init();
+			await networks.init();
+			await assets.init();
+			await transactions.init();
 		} else if (!unlocked && started) {
 			started = false;
+			transactions.lock();
+			assets.lock();
+			networks.lock();
 			await metaSync.lock();
 			await accounts.lock();
 			await controller.lockAll();
@@ -3348,6 +5299,9 @@ function createWalletEngine(options) {
 	});
 	schedule();
 	return {
+		networks,
+		assets,
+		transactions,
 		spark: controller,
 		accounts,
 		metaSync,