@qntx/wallet-engine 0.5.2 → 0.7.0

package/dist/index.d.mts

@@ -1,19 +1,19 @@
+import { r as NetworkInfo } from "./registry-LcFSPrE1.mjs";
 import { StoreApi } from "zustand/vanilla";
-import { CooperativeExitResult, LightningInvoice, LightningPayment, SparkClient, SparkExitChain, SparkNetwork, SparkPayment, SparkStore, SparkTransfer } from "@qntx/spark";
-import { NostrKeyRef, WalletSigner } from "@qntx/wallet/nostr";
-import { SparkSigner } from "@qntx/wallet/spark";
-import { PublicClient } from "viem";
-import { chains } from "@qntx/wallet/chains";
+import { SignRequest } from "@qntx/wallet-chains";
+import { BackupHeader, BackupInfo, InitialFactor, UnlockFactor, Wallet, WalletInfo } from "@qntx/wallet";
 import "@scure/btc-signer";
+import { CooperativeExitResult, LightningInvoice, LightningPayment, SparkClient, SparkExitChain, SparkNetwork, SparkPayment, SparkStore, SparkTransfer } from "@qntx/spark";
 import { decodeEvm } from "@qntx/wallet-chains/evm";
-import { BackupHeader, BackupInfo, InitialFactor, UnlockFactor, Wallet, WalletInfo } from "@qntx/wallet";
-import { Event, Filter, NostrSigner } from "@qntx/nostr";
 import { LnurlPayRequest, LnurlWithdrawRequest } from "@qntx/spark/lnurl";
+import { Event, Filter, NostrSigner } from "@qntx/nostr";
+import { chains } from "@qntx/wallet/chains";
+import { WalletSyncSigner } from "@qntx/wallet/nostr";
+import { SparkSigner } from "@qntx/wallet/spark";
+import { PublicClient } from "viem";
 import "@solana/kit";
-import { SparkAccountRef, SparkApproveIntent } from "@qntx/wallet/protocol";
 import "@scure/btc-signer/psbt.js";
-import "@qntx/wallet-chains";
-//#region src/controller.d.ts
+import { SparkAccountRef, SparkApproveIntent } from "@qntx/wallet/protocol";
 type ControllerOptions<S> = {
   readonly name: string;
   readonly defaultState: () => S;
@@ -32,8 +32,6 @@ export declare abstract class Controller<S extends Record<string, unknown>> {
   abstract init(): Promise<void>;
   abstract destroy(): Promise<void>;
 }
-//#endregion
-//#region src/events.d.ts
 /** Log port: listener failures are reported here and never reach the emitter or peers. */
 type EngineLogger = {
   readonly warn: (message: string, error?: unknown) => void;
@@ -44,16 +42,12 @@ type EventBus<E> = {
   on: <K extends keyof E>(type: K, listener: (payload: E[K]) => void) => () => void;
 };
 export declare function createEventBus<E>(logger: EngineLogger): EventBus<E>;
-//#endregion
-//#region src/errors.d.ts
 type EngineErrorCode = "closed" | "integrity" | "invalid-input";
 /** Typed engine errors: store codes are `closed` and `integrity` (decrypt or bind failure). */
 export declare class EngineStoreError extends Error {
   readonly code: EngineErrorCode;
   constructor(code: EngineErrorCode, message: string);
 }
-//#endregion
-//#region src/store/port.d.ts
 /**
  * Engine storage port: named collections of byte values. `collection` is synchronous and cheap —
  * the same collection object backs every call, so guards (closed) live on the store.
@@ -69,42 +63,247 @@ type EngineStore = {
   readonly collection: (name: string) => EngineCollection;
   readonly close: () => Promise<void>;
 };
-//#endregion
-//#region src/store/memory.d.ts
 /** In-memory EngineStore: the Node/test implementation — same contract, no durability. */
 export declare function createMemoryEngineStore(backing?: {
   readonly collections?: Map<string, Map<string, Uint8Array>>;
 }): EngineStore;
-//#endregion
-//#region src/chains/bitcoin.d.ts
+type ConnectionOrigin = {
+  readonly kind: "browser";
+  readonly origin: string;
+};
+type ConnectionScope = {
+  /** CAIP-10 */
+  readonly accounts: ReadonlyArray<string>;
+  readonly methods: ReadonlyArray<string>;
+  readonly notifications: ReadonlyArray<string>;
+};
+type ConnectionSession = {
+  readonly id: string;
+  readonly origin: ConnectionOrigin;
+  /** Keyed by CAIP-2. */
+  readonly scopes: Readonly<Record<string, ConnectionScope>>;
+  /** The session's current EVM network; only dApp sessions have one. */
+  readonly currentNetwork: string;
+  readonly createdAt: number;
+  readonly lastUsedAt: number;
+};
+/** `connect` asks for accounts; `network` asks to add a network the session does not cover. */
+type PendingConnection = {
+  readonly id: string;
+  readonly origin: ConnectionOrigin;
+  readonly kind: "connect" | "network";
+  readonly network?: string;
+  readonly createdAt: number;
+};
+type AccountGroup$1 = {
+  readonly walletId: string;
+  readonly groupIndex: number;
+};
+type ConnectionState = {
+  readonly sessions: Readonly<Record<string, ConnectionSession>>;
+  readonly pending: Readonly<Record<string, PendingConnection>>;
+};
+type ConnectionControllerOptions = {
+  readonly openStore: () => Promise<EngineStore>;
+  readonly random: (n: number) => Uint8Array;
+  readonly now: () => number;
+  readonly logger: EngineLogger;
+  /** Development builds also accept `http://localhost`. */
+  readonly allowLocalhost: boolean;
+  /** The group the app currently shows; sessions are bound to it. */
+  readonly selectedGroup: () => AccountGroup$1 | undefined;
+  /** The group's EVM address on `network`. */
+  readonly evmAddress: (group: AccountGroup$1, network: string) => Promise<string>;
+  readonly enabledNetworks: () => ReadonlyArray<string>;
+  /** Voids a page's unfinished requests (revoked, or its network changed). */
+  readonly invalidate: (origin: string) => void;
+};
+export declare class ConnectionController extends Controller<ConnectionState> {
+  private readonly options;
+  private engineStore;
+  private readonly waiters;
+  private group;
+  constructor(options: ConnectionControllerOptions);
+  init(): Promise<void>;
+  destroy(): Promise<void>;
+  /** Locking is not consent: every pending connection is rejected. */
+  lock(): void;
+  /** Throws `4100` unless `origin` is `https://host[:port]` (or localhost in development). */
+  checkOrigin(origin: string): ConnectionOrigin;
+  session(origin: string): ConnectionSession | undefined;
+  pending(): ReadonlyArray<PendingConnection>;
+  /** The group sessions are bound to: the host's last `setActiveGroup`, else the app's selection. */
+  activeGroup(): AccountGroup$1 | undefined;
+  /** Whether `network` is an EVM network the wallet has enabled. */
+  isEnabled(network: string): boolean;
+  /** The origin's authorized addresses on its current network; empty when not connected. */
+  accounts(origin: string): ReadonlyArray<string>;
+  /** Throws `4100` unless the origin's session covers `method` on `network`. */
+  authorize(origin: string, network: string, method: string): ConnectionSession;
+  /** Resolves with the session once the host approves; rejects with `4001` when it refuses. */
+  request(origin: string, kind: PendingConnection["kind"], network?: string): Promise<ConnectionSession>;
+  /**
+   * The host's approval, by id: the accounts granted (EVM addresses of the active group) and the
+   * network.
+   */
+  approveConnection(id: string, grant: {
+    readonly accounts: ReadonlyArray<string>;
+    readonly network: string;
+  }): Promise<ConnectionSession>;
+  rejectConnection(id: string): void;
+  /** Ends the origin's session; its pending connection and unfinished requests are void. */
+  revoke(origin: string): Promise<void>;
+  /** Switches within the session's scope; the origin's unfinished requests are void. */
+  setCurrentNetwork(origin: string, network: string): Promise<void>;
+  touch(origin: string): Promise<void>;
+  /**
+   * The host switched account group: every session's accounts become the new group's addresses. A
+   * session that cannot get one (no address derivable) is left with an empty list and has to be
+   * authorized again.
+   */
+  setActiveGroup(walletId: string, groupIndex: number): Promise<void>;
+  private dropPending;
+  private persist;
+  private requireStore;
+}
 type Esplora = {
   readonly get: (path: string) => Promise<unknown>;
   readonly post: (path: string, body: string) => Promise<unknown>;
 };
-//#endregion
-//#region src/meta/doc.d.ts
+type SolanaRpc = {
+  readonly call: (method: string, params: unknown[]) => Promise<unknown>;
+};
 /**
- * Wallet metadata document — the plaintext exchanged over kind-30078 events between this wallet's
- * own devices. One document per wallet; entry-level last-writer-wins on `updatedAt`.
+ * A host-endpoint-only client for cross-checking pre-signing reads. `not-needed`: the gateway is
+ * not this network's first endpoint, so the primary reads already come from the host.
+ * `unavailable`: a cross-check is needed but the network has no host endpoint.
  */
-type MetaDocWallet = {
-  readonly name?: string;
+type Independent<T> = {
+  readonly kind: "not-needed";
+} | {
+  readonly kind: "unavailable";
+} | {
+  readonly kind: "available";
+  readonly client: T;
+};
+type NetworkControllerState = {
+  readonly customRpc: Record<string, ReadonlyArray<string>>;
+};
+type Options$2 = {
+  readonly fetch: typeof globalThis.fetch;
+  readonly rpc: Readonly<Record<string, ReadonlyArray<string>>>;
+  readonly openStore: () => Promise<EngineStore>;
+  readonly logger: EngineLogger;
+  readonly gateway?: {
+    readonly url: string;
+    readonly installId: string;
+  } | undefined;
+};
+declare class NetworkController extends Controller<NetworkControllerState> {
+  private readonly options;
+  private engineStore?;
+  private readonly clients;
+  private readonly gatewayBase;
+  private readonly gatewayOrigin;
+  /** Networks the gateway reported at unlock; empty while locked or when the read failed. */
+  private gatewayServed;
+  constructor(options: Options$2);
+  init(): Promise<void>;
+  private loadCustomRpc;
+  /** Reads the gateway's served networks; any failure leaves the gateway unused until next unlock. */
+  private loadGatewayNetworks;
+  /** `fetch` that adds the install id to requests bound for the gateway's origin only. */
+  private readonly gatewayFetch;
+  destroy(): Promise<void>;
+  lock(): void;
+  /**
+   * Ordered endpoints: a network with custom endpoints uses custom → host and never the gateway;
+   * otherwise a gateway-served network uses gateway → host; else host only.
+   */
+  endpoints(network: string): ReadonlyArray<string>;
+  info(network: string): NetworkInfo;
+  client(network: string): PublicClient;
+  /** True when the gateway heads this network's endpoint list (no custom endpoints, gateway-served). */
+  private gatewayFirst;
+  private independent;
+  /** Host-endpoint EVM client for cross-checking reads; never sends the install id. */
+  independentClient(network: string): Independent<PublicClient>;
+  independentSolanaRpc(network: string): Independent<SolanaRpc>;
+  independentEsplora(network: string): Independent<Esplora>;
+  /** Networks with at least one configured endpoint or served by the gateway, by family. */
+  enabled(family: "evm" | "solana" | "bitcoin"): ReadonlyArray<string>;
+  /** Solana JSON-RPC over the ordered endpoint list — kit's transport is single-endpoint. */
+  solanaRpc(network: string): SolanaRpc;
+  /** Bounded-concurrency + 429-aware ordered-failover Esplora client. */
+  esplora(network: string): Esplora;
+  /** Validate a custom endpoint's reported chain id, then persist it first in the list. */
+  addRpc(network: string, url: string): Promise<void>;
+}
+type AddressFamily = "evm" | "solana" | "bitcoin" | "spark";
+type AddressBookEntry = {
+  readonly id: string;
+  readonly name: string;
+  readonly family: AddressFamily;
+  readonly address: string;
+  readonly note?: string;
+  readonly createdAt: number;
   readonly updatedAt: number;
 };
-type MetaDocGroup = {
-  readonly index: number;
-  readonly name?: string;
-  readonly hidden: boolean;
-  readonly boundPubkey?: string;
+type AddressBookTombstone = {
+  readonly id: string;
+  readonly deleted: true;
   readonly updatedAt: number;
 };
-type MetaDoc = {
-  readonly v: 1;
-  readonly wallet: MetaDocWallet;
-  readonly groups: ReadonlyArray<MetaDocGroup>;
+type AddressBookRecord = AddressBookEntry | AddressBookTombstone;
+type AddressBookState = {
+  /** Live entries only; tombstones stay internal. */
+  readonly entries: Record<string, AddressBookEntry>;
+};
+type AddressBookOptions = {
+  readonly openStore: () => Promise<EngineStore>;
+  readonly random: (n: number) => Uint8Array;
+  readonly now: () => number;
+  readonly logger: EngineLogger;
 };
-//#endregion
-//#region src/spark/notes.d.ts
+export declare class AddressBookController extends Controller<AddressBookState> {
+  private readonly options;
+  private engineStore;
+  /** Every record, tombstones included, by id. */
+  private records;
+  constructor(options: AddressBookOptions);
+  init(): Promise<void>;
+  destroy(): Promise<void>;
+  lock(): void;
+  /** Entries and tombstones, for the metadata document. */
+  syncEntries(): ReadonlyArray<AddressBookRecord>;
+  /**
+   * Merges records from another device (last writer wins, tombstones win over older entries).
+   * Returns whether anything local changed and whether the merged set holds something `remote`
+   * lacks, i.e. whether the remote copy needs a newer publish.
+   */
+  merge(remote: ReadonlyArray<AddressBookRecord>): Promise<{
+    readonly changed: boolean;
+    readonly localNewer: boolean;
+  }>;
+  add(params: {
+    readonly name: string;
+    readonly family: AddressFamily;
+    readonly address: string;
+    readonly note?: string;
+  }): Promise<AddressBookEntry>;
+  rename(id: string, name: string): Promise<AddressBookEntry>;
+  /** Sets or clears (empty or `undefined`) the note. */
+  setNote(id: string, note: string | undefined): Promise<AddressBookEntry>;
+  /** Removes the entry, leaving a tombstone so other devices drop it too. */
+  remove(id: string): Promise<void>;
+  private checkedNote;
+  private requireEntry;
+  private persist;
+  private requireStore;
+}
+type EvmFeeTier = "slow" | "normal" | "fast";
+type SolanaFeeTier = "slow" | "normal" | "fast";
+type RequestCheckCode = "decode-partial" | "nonce-mismatch" | "fee-mismatch" | "reads-unverified" | "fee-above-network" | "fee-exceeds-amount";
 /**
  * Local, engine-side metadata pinned to a history entry by transfer id. Written after the payment
  * it annotates has already succeeded — a missing or malformed note must never affect the payment
@@ -124,15 +323,11 @@ type PaymentNote = {
 type SparkActivity = SparkPayment & {
   readonly note?: PaymentNote;
 };
-//#endregion
-//#region src/spark/store.d.ts
 /**
  * SparkStore over one EngineCollection: chains keyed by leafId, plus an index record listing them
  * (`exitChains` is a full listing — the port has no secondary index).
  */
 export declare function sparkStore(col: EngineCollection): SparkStore;
-//#endregion
-//#region src/spark/controller.d.ts
 type SparkAccountState = {
   readonly status: "locked" | "connecting" | "ready" | "error";
   readonly balanceSats?: number;
@@ -260,6 +455,10 @@ export declare class SparkController extends Controller<SparkControllerState> {
     amountSats: number;
     memo?: string;
   }): Promise<LightningInvoice>;
+  /** A fresh single-use L1 deposit address (with the SO's proof of possession). */
+  newDepositAddress(ref: SparkAccountRef): Promise<string>;
+  /** Claims a confirmed L1 deposit paying one of the account's unused deposit addresses. */
+  claimDeposit(ref: SparkAccountRef, transaction: Uint8Array): Promise<void>;
   receiveAddress(ref: SparkAccountRef): Promise<string | undefined>;
   /**
    * Cooperative exit to an L1 address. The client exits `amountSats` of leaves and the payout is
@@ -274,198 +473,707 @@ export declare class SparkController extends Controller<SparkControllerState> {
     verify: UnlockFactor;
   }): Promise<CooperativeExitResult>;
 }
-//#endregion
-//#region src/accounts/controller.d.ts
-type AccountGroup = {
-  readonly walletId: string;
-  readonly index: number;
-  /** `discoverGroups` result — family key → used; a family error lives under `errors`. */
-  readonly used?: Readonly<Record<string, boolean>>;
-  readonly errors?: Readonly<Record<string, string>>;
-  readonly name?: string;
-  readonly hidden: boolean;
-  /** A social identity (64 lowercase hex) bound to this group; one identity binds one group. */
-  readonly boundPubkey?: string;
-  /** Last local modification time (ms); reconcile-created entries start at 0. */
-  readonly updatedAt: number;
-};
-type AccountTreeState = {
-  readonly status: "locked" | "ready";
-  readonly wallets: ReadonlyArray<{
-    readonly walletId: string;
-    readonly name?: string;
-    readonly updatedAt: number;
-  }>;
-  readonly groups: Readonly<Record<string, ReadonlyArray<AccountGroup>>>;
-  readonly selected: {
-    readonly walletId: string;
-    readonly groupIndex: number;
-  } | null;
-  readonly totals: Readonly<Record<string, number>>;
-};
-type DiscoveryNetworks = {
-  readonly client: (network: string) => {
-    readonly getTransactionCount: (p: {
-      readonly address: `0x${string}`;
-      readonly blockTag: "latest";
-    }) => Promise<number>;
-    readonly getBalance: (p: {
-      readonly address: `0x${string}`;
-    }) => Promise<bigint>;
-  };
-  readonly solanaRpc: (network: string) => {
-    readonly call: (method: string, params: unknown[]) => Promise<unknown>;
-  };
-  readonly esplora: (network: string) => Esplora;
-  readonly enabled: (family: "evm" | "solana" | "bitcoin") => ReadonlyArray<string>;
+/**
+ * What the host shows for a Spark, Lightning or exit request; `family` tells it apart from a chain
+ * intent.
+ */
+type SparkDisplay = {
+  readonly family: "spark";
+  readonly network: SparkNetwork;
+  readonly kind: "transfer" | "lightning" | "exit";
+  readonly amountSats: number;
+  readonly maxFeeSats?: number;
+  /** Spark address, Lightning payee public key (hex) or bitcoin address. */
+  readonly receiver: string;
+  /** Invoice description or the LNURL metadata text. */
+  readonly description?: string;
 };
-type AccountTreeControllerOptions = {
-  readonly wallet: Wallet;
-  readonly spark: SparkController;
-  readonly sparkNetwork: SparkNetwork;
-  readonly networks?: DiscoveryNetworks;
-  readonly chains?: {
-    readonly account: (params: {
-      readonly walletId: string;
-      readonly groupIndex: number;
-      readonly template: string;
-      readonly network: string;
-    }) => Promise<{
-      readonly address?: string;
-      readonly xpub?: string;
-    }>;
-  };
-  readonly logger: EngineLogger;
-  readonly now: () => number;
+type SparkResult = {
+  readonly kind: "spark";
+  readonly transfer: SparkTransfer;
+} | {
+  readonly kind: "lightning";
+  readonly payment: LightningPayment;
+} | {
+  readonly kind: "withdraw";
+  readonly exit: CooperativeExitResult;
 };
-export declare class AccountTreeController extends Controller<AccountTreeState> {
-  private readonly options;
-  private col;
-  private sparkUnsubscribe;
-  private totalsTimer;
-  private persistChain;
-  constructor(options: AccountTreeControllerOptions);
-  setStore(store: EngineStore | undefined): void;
-  /** Load persisted state, reconcile with the snapshot, start driving Spark. */
-  init(): Promise<void>;
-  destroy(): Promise<void>;
-  /** Locked: stop every Spark client, flush pending persists, then drop to the empty state. */
-  lock(): Promise<void>;
-  /** Reconcile groups/names/selected with `wallet.getSnapshot().wallets`; persists on change. */
-  reconcile(): void;
-  addGroup(walletId: string): number;
-  addGroups(walletId: string, indices: ReadonlyArray<number>): void;
-  renameWallet(walletId: string, name: string): void;
-  renameGroup(walletId: string, index: number, name: string): void;
-  setHidden(walletId: string, index: number, hidden: boolean): void;
-  select(walletId: string, index: number): void;
-  /**
-   * Binds a social identity to one group. The identity is unique across the whole tree — every
-   * group in every wallet carrying it loses the binding (each entry re-stamped).
-   */
-  bind(walletId: string, index: number, pubkey: string): void;
-  unbind(walletId: string, index: number): void;
-  /**
-   * Which group currently holds a pubkey — merges can leave the same identity on groups in two
-   * wallets; the newest `updatedAt` wins, ties resolve by snapshot wallet order then lower index.
-   */
-  bindingOf(pubkey: string): {
-    walletId: string;
-    groupIndex: number;
-  } | undefined;
-  /** The wallet's metadata document — every group, hidden included. */
-  exportMeta(walletId: string): MetaDoc;
-  /**
-   * Entry-level last-writer-wins merge: a newer remote `updatedAt` replaces the local entry, a tie
-   * keeps local; remote-only groups are added. `selected`/hidden rules are re-validated — if the
-   * merge hides the selected group it is re-selected, and a merge may never leave every group
-   * hidden (the selected one stays visible and is re-stamped so the fix propagates).
-   */
-  mergeMeta(walletId: string, doc: MetaDoc): {
-    changed: boolean;
-    localNewer: boolean;
-  };
-  /** Sequential inspect from 0 upward; index 0 always included; stop after 2 consecutive unused. */
-  discoverSpark(walletId: string): Promise<number[]>;
-  /**
-   * 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).
-   */
-  discoverGroups(walletId: string): Promise<number[]>;
-  /** Refresh `totals` for every other visible group; per-group failures are logged and skipped. */
-  refreshTotals(): Promise<void>;
-  private onSparkState;
-  private setTotal;
-  private driveSpark;
-  private visibleGroups;
-  private validSelection;
-  private selectFallback;
-  private mutateGroups;
-  private mustWallet;
-  private mustGroup;
-  private checkedName;
-  private load;
-  /** Queues a store write behind the previous one — the last queued write always lands last. */
-  private persist;
-  private scheduleTotalsPersist;
-  private flushTotals;
-}
-//#endregion
-//#region src/networks/registry.d.ts
 /**
- * Built-in EVM network registry: the 8 mainnets from chains.mdx plus their main testnets. Each
- * chain id was checked against the chain's official documentation (source URL per entry).
- * Signing-time chainId always comes from this table, never from an RPC endpoint.
+ * A validated, fixed Spark payment: everything that does not need the user's verification has
+ * happened (including any LNURL invoice fetch), so approval only re-checks expiry and executes.
  */
-type NetworkInfo = {
-  readonly id: string;
-  readonly chainId: number;
-  readonly name: string;
-  readonly symbol: string;
-  readonly multicall3?: string;
-  /** CAIP-2 family — `solana:<ref>` networks are validated against genesis-hash, not chainId. */
-  readonly family: "evm" | "solana" | "bitcoin";
-  readonly genesisHash?: string;
-  readonly decimals: number;
-  readonly testnet: boolean;
+type PreparedSparkAction = {
+  readonly display: SparkDisplay;
+  readonly checks: ReadonlyArray<RequestCheckCode>;
+  /** Why the action can no longer be paid at `now` (an expiring invoice), if so. */
+  readonly staleReason: (now: number) => string | undefined;
+  /** Runs the controller's approve-first payment call. */
+  readonly execute: (spark: SparkController, verify: UnlockFactor) => Promise<SparkResult>;
 };
-//#endregion
-//#region src/networks/controller.d.ts
-type SolanaRpc = {
-  readonly call: (method: string, params: unknown[]) => Promise<unknown>;
+type PaymentOption = {
+  readonly kind: "spark";
+  readonly address: string;
+} | {
+  readonly kind: "spark-invoice";
+  readonly invoice: string;
+  readonly amountSats?: number;
+  readonly memo?: string;
+  readonly expiresAt?: number;
+} | {
+  readonly kind: "lightning";
+  readonly invoice: string;
+  readonly amountSats?: number;
+  readonly paymentHash: string;
+  readonly description?: string;
+  readonly expiresAt: number;
+} | {
+  readonly kind: "lnurl-pay";
+  readonly request: LnurlPayRequest;
+  readonly address?: string;
+} | {
+  readonly kind: "lnurl-withdraw";
+  readonly request: LnurlWithdrawRequest;
+} | {
+  readonly kind: "bitcoin";
+  readonly address: string;
 };
-type NetworkControllerState = {
-  readonly customRpc: Record<string, ReadonlyArray<string>>;
+type PaymentRequest = {
+  readonly options: ReadonlyArray<PaymentOption>;
+  readonly amountSats?: number;
+  readonly label?: string;
+  readonly message?: string;
 };
-type Options$2 = {
+type PaymentParse = {
+  readonly kind: "request";
+  readonly request: PaymentRequest;
+} | {
+  readonly kind: "lnurl";
+  readonly url: string;
+  readonly address?: string;
+} | {
+  readonly kind: "unsupported";
+  readonly format: "bolt12" | "silent-payment" | "lnurl-auth" | "spark-token-invoice" | "nostr-wallet-connect";
+} | {
+  readonly kind: "invalid";
+  readonly reason: "network" | "expired" | "amount-mismatch" | "malformed";
+} | {
+  readonly kind: "unrecognized";
+};
+type ParseOptions = {
+  readonly network: SparkNetwork;
+  readonly now: number;
+};
+/** `input` → PaymentParse. Never throws: every failure is a structured result. */
+export declare function parsePayment(input: string, options: ParseOptions): PaymentParse;
+type PayParams = {
+  readonly account: SparkAccountRef;
+  readonly option: PaymentOption;
+  /** Caller-supplied amount — required by open invoices, the `spark` option, and LNURL flows. */
+  readonly amountSats?: number;
+  readonly comment?: string;
+  readonly maxFeeSats?: number;
+  readonly speed?: "FAST" | "MEDIUM" | "SLOW";
+};
+type WithdrawLnurlParams = {
+  readonly account: SparkAccountRef;
+  readonly option: Extract<PaymentOption, {
+    kind: "lnurl-withdraw";
+  }>;
+  readonly amountSats: number;
+};
+/** A profile zap names the recipient pubkey; an event zap carries the event it zaps. */
+type ZapRecipient = {
+  readonly pubkey: string;
+  readonly lightning: string;
+} | {
+  readonly event: Event;
+  readonly lightning: string;
+};
+type PrepareZapParams = {
+  /** Any `NostrSigner` — wallet key, external key, NIP-07/46 — signs the 9734. */
+  readonly signer: NostrSigner;
+  readonly recipient: ZapRecipient;
+  readonly amountSats: number;
+  readonly comment?: string | undefined;
+  readonly relays: ReadonlyArray<string>;
+  readonly network: SparkNetwork;
+};
+type PrepareZapContext = {
   readonly fetch: typeof globalThis.fetch;
-  readonly rpc: Readonly<Record<string, ReadonlyArray<string>>>;
+  readonly now: () => number;
+};
+/** Everything a payer needs: the signed 9734, the invoice, and the note fields. */
+type PreparedZap = {
+  readonly zapRequest: Event;
+  readonly invoice: string;
+  /** Hex payment hash decoded from the invoice. */
+  readonly paymentHash: string;
+  /** Millisecond expiry decoded from the invoice. */
+  readonly expiresAt: number;
+  readonly amountSats: number;
+  /** The LNURL service's 9735 signing pubkey. */
+  readonly receiptPubkey: string;
+  readonly recipientPubkey: string;
+  readonly eventId?: string;
+  readonly comment?: string;
+  /** The lud16 or LNURL as given. */
+  readonly lightning: string;
+};
+/** Everything up to payment: resolve LNURL, sign the 9734, request the invoice. */
+export declare function prepareZap(params: PrepareZapParams, context: PrepareZapContext): Promise<PreparedZap>;
+type ChainApis = ReturnType<typeof chains>;
+type SignParams = Parameters<ChainApis["sign"]>[0];
+type AccountRef = SignParams["request"]["account"];
+type DisplayIntent = ReturnType<typeof decodeEvm>;
+type TxState = "draft" | "signed" | "submitted" | "pending" | "confirmed" | "failed" | "rejected" | "dropped" | "replaced";
+/** A bitcoin transaction that funds the wallet's own Spark account; it is claimed once confirmed. */
+type SparkDepositTag = {
+  readonly walletId: string;
+  readonly groupIndex: number;
+  readonly network: SparkNetwork;
+  readonly claimed?: boolean;
+};
+type TrackedTransaction = {
+  readonly id: string;
+  readonly family: "evm" | "solana" | "bitcoin";
+  readonly network: string;
+  readonly account: string;
+  readonly hash: string | undefined;
+  readonly state: TxState;
+  readonly intent: DisplayIntent | undefined;
+  readonly nonce: number;
+  /** Solana only — the blockhash expiry that turns an unconfirmed tx `dropped`. */
+  readonly lastValidBlockHeight?: number;
+  /** EVM replacement — the earlier transaction this one bumps or cancels. */
+  readonly replaces?: string;
+  /** CPFP — the unconfirmed parent this child pushes. */
+  readonly parentId?: string;
+  /** Set on a Spark deposit; `claimed` flips once the deposit is credited on Spark. */
+  readonly sparkDeposit?: SparkDepositTag;
+  /** Bitcoin build record persisted at send for RBF/CPFP rebuilds. */
+  readonly btc?: {
+    readonly inputs: ReadonlyArray<{
+      readonly txid: string;
+      readonly vout: number;
+      readonly value: number;
+      readonly address: string;
+    }>;
+    readonly outputs: ReadonlyArray<{
+      readonly address: string;
+      readonly value: number;
+      readonly own: boolean;
+    }>;
+    readonly vsize: number;
+    readonly fee: number;
+    readonly feeRate: number;
+  };
+  readonly submittedAt: number;
+  readonly error: string | undefined;
+};
+type SendParams = {
+  readonly account: AccountRef;
+  readonly network: string;
+  readonly to: string;
+  readonly amount: bigint;
+  /** ERC-20 contract — when set, `to`/`amount` are the transfer recipient/units and value is 0. */
+  readonly token?: string;
+  readonly fee: EvmFeeTier | SolanaFeeTier;
+  /** SPL mint decimals — required when `token` is a Solana mint. */
+  readonly decimals?: number;
+  readonly verify: SignParams["verify"];
+};
+type PrepareParams = Omit<SendParams, "verify">;
+type ChainRequestMethod = "send" | "speed-up" | "cancel" | "cpfp";
+/** What a request asks for; replacements and CPFP name the original transaction. */
+type ChainRequestInput = ({
+  readonly method: "send";
+} & PrepareParams) | {
+  readonly method: "speed-up" | "cancel";
+  readonly txId: string;
+} | {
+  readonly method: "cpfp";
+  readonly txId: string;
+  readonly feeRate: number;
+};
+/**
+ * A fully built, estimated and cross-checked send that has not been signed. The unsigned content
+ * lives in the closures and cannot change after `prepare` returns.
+ */
+type PreparedRequest = {
+  /** Id of the tracked transaction `submit` creates. */
+  readonly txId: string;
+  readonly account: AccountRef;
+  readonly network: string;
+  /** The transaction being replaced or accelerated; absent for a plain send. */
+  readonly target?: string;
+  readonly intent: DisplayIntent;
+  readonly checks: ReadonlyArray<RequestCheckCode>;
+  /** Why the build can no longer be signed (nonce taken, blockhash expired), if so. */
+  readonly staleReason: () => string | undefined | Promise<string | undefined>;
+  /** Signs, finalizes, broadcasts and hands the transaction to tracking. */
+  readonly submit: (verify: SendParams["verify"]) => Promise<TrackedTransaction>;
+  /** Frees what `prepare` reserved; safe to call more than once. */
+  readonly release: () => void;
+};
+type SignatureResult = {
+  readonly kind: "evm.personal-message" | "evm.typed-data";
+  readonly signature: Uint8Array;
+};
+/** A prepared message signature: nothing is broadcast or tracked, `submit` returns the signature. */
+type PreparedMessage = Omit<PreparedRequest, "submit" | "txId"> & {
+  readonly submit: (verify: SendParams["verify"]) => Promise<SignatureResult>;
+};
+type Options$1 = {
+  readonly wallet: Wallet;
+  readonly networks: NetworkController;
   readonly openStore: () => Promise<EngineStore>;
+  readonly random: (n: number) => Uint8Array;
+  readonly setTimer: (ms: number, fn: () => unknown) => () => void;
+  readonly now: () => number;
   readonly logger: EngineLogger;
+  readonly pollMs?: number;
+  /** Test seam — defaults to the wallet's real chains proxy. */
+  readonly chains?: ReturnType<typeof chains>;
 };
-declare class NetworkController extends Controller<NetworkControllerState> {
+type TransactionControllerState = {
+  readonly txs: Record<string, TrackedTransaction>;
+};
+declare class TransactionController extends Controller<TransactionControllerState> {
   private readonly options;
   private engineStore?;
-  private readonly clients;
-  constructor(options: Options$2);
+  private readonly timers;
+  private evmRoute;
+  private bitcoinRoute;
+  private locked;
+  constructor(options: Options$1);
   init(): Promise<void>;
   destroy(): Promise<void>;
   lock(): void;
-  endpoints(network: string): ReadonlyArray<string>;
-  info(network: string): NetworkInfo;
-  client(network: string): PublicClient;
-  /** 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: "evm" | "solana" | "bitcoin"): ReadonlyArray<string>;
-  solanaRpc(network: string): SolanaRpc;
-  /** Bounded-concurrency + 429-aware ordered-failover Esplora client. */
-  esplora(network: string): Esplora;
-  addRpc(network: string, url: string): Promise<void>;
+  private persist;
+  private transition;
+  private routeCtx;
+  /**
+   * Internal entry for the request pipeline: builds, estimates and cross-checks a send without
+   * signing it. Bitcoin outputs it selects stay locked under `requestId` until the returned
+   * `release` runs or the broadcast moves them to the transaction.
+   */
+  prepareSend(params: PrepareParams, requestId: string, sparkDeposit?: SparkDepositTag): Promise<PreparedRequest>;
+  /** The group's next unused `btc.bip84` receive address on a bitcoin `network`. */
+  nextReceiveAddress(walletId: string, groupIndex: number, network: string): Promise<string>;
+  /** Records that a Spark deposit was credited; persisted with the transaction. */
+  markDepositClaimed(id: string): Promise<void>;
+  /**
+   * Internal entry for a dApp's EVM signature request: the request is normalized first, a
+   * transaction is rebuilt with fresh nonce and fees (the dApp's own are discarded), and a message
+   * is decoded and signed as is.
+   */
+  prepareDapp(account: AccountRef, request: SignRequest): Promise<PreparedRequest | PreparedMessage>;
+  /**
+   * Internal entry for replacements and CPFP: builds, cross-checks and reserves what the
+   * replacement needs without signing it. The original must be `submitted` or `pending`.
+   */
+  prepareReplacement(input: Exclude<ChainRequestInput, {
+    method: "send";
+  }>, requestId: string): Promise<PreparedRequest>;
+  private track;
+}
+/**
+ * Recipient risk, pure: a recipient the wallet has never paid or saved is a `warning`; one that
+ * looks like a known address (same first and last four characters, different address) is a `danger`
+ * — the shape of an address-poisoning lookalike. Both can apply to one recipient.
+ */
+type RiskFinding = {
+  readonly code: "first-recipient" | "address-poisoning";
+  readonly level: "warning" | "danger";
+};
+/** A web page; `origin` is `scheme://host[:port]`, computed by the host from the top-level URL. */
+type BrowserOrigin = {
+  readonly kind: "browser";
+  readonly origin: string;
+};
+type RequestOrigin = {
+  readonly kind: "internal";
+} | BrowserOrigin;
+type RequestMethod = ChainRequestMethod | "pay" | "zap" | "evm-sign" | "spark-deposit" | "spark-exit";
+type SignLogOutcome = "submitted" | "rejected" | "failed" | "expired" | "invalidated";
+type SignLogEntry = {
+  readonly id: string;
+  readonly at: number;
+  readonly origin: RequestOrigin;
+  readonly method: RequestMethod;
+  readonly account: AccountRef | SparkAccountRef;
+  readonly network: string;
+  readonly summary: string;
+  readonly verification: "verified" | "unverifiable";
+  readonly checks: ReadonlyArray<RequestCheckCode>;
+  readonly risk: ReadonlyArray<RiskFinding>;
+  readonly outcome: SignLogOutcome;
+  readonly error?: string;
+};
+/** A Spark, Lightning (including LNURL-pay and lightning addresses) or cooperative-exit payment. */
+type PayInput = {
+  readonly method: "pay";
+} & PayParams;
+/** A prepared zap; its invoice was fetched by `engine.zaps.prepare` and is paid as-is. */
+type ZapInput = {
+  readonly method: "zap";
+  readonly account: SparkAccountRef;
+  readonly zap: PreparedZap;
+  readonly maxFeeSats: number;
+};
+/**
+ * A dApp's EVM request: a transaction (rebuilt here with fresh nonce and fees), a personal message
+ * or EIP-712 typed data.
+ */
+type EvmSignInput = {
+  readonly method: "evm-sign";
+  readonly origin: BrowserOrigin;
+  readonly account: AccountRef;
+  readonly network: string;
+  readonly request: SignRequest;
+};
+/**
+ * Funds the wallet's own Spark account from a bitcoin account of the same wallet; the transaction
+ * is an ordinary bitcoin send to a fresh Spark deposit address and is claimed once confirmed.
+ */
+type SparkDepositInput = {
+  readonly method: "spark-deposit";
+  readonly account: SparkAccountRef;
+  readonly from: AccountRef;
+  readonly amountSats: number;
+  readonly fee: PrepareParams["fee"];
+};
+/** A cooperative exit to the group's own next unused `btc.bip84` receive address. */
+type SparkExitInput = {
+  readonly method: "spark-exit";
+  readonly account: SparkAccountRef;
+  readonly amountSats: number;
+  readonly maxFeeSats: number;
+  readonly speed?: "FAST" | "MEDIUM" | "SLOW";
+};
+type RequestInput = ChainRequestInput | PayInput | ZapInput | EvmSignInput | SparkDepositInput | SparkExitInput;
+type RequestStage = "awaiting-approval" | "signing" | "submitted" | "rejected" | "failed" | "expired" | "invalidated";
+type PendingRequest = {
+  readonly id: string;
+  readonly origin: RequestOrigin;
+  readonly method: RequestMethod;
+  readonly account: AccountRef | SparkAccountRef;
+  readonly network: string;
+  readonly stage: RequestStage;
+  /** Decoded locally from the exact content that will be signed; `family` tells the shapes apart. */
+  readonly display: DisplayIntent | SparkDisplay;
+  /** `unverifiable` as soon as any check is recorded; the host must ask for explicit confirmation. */
+  readonly verification: "verified" | "unverifiable";
+  readonly checks: ReadonlyArray<RequestCheckCode>;
+  /**
+   * Recipient risk; independent of `verification`. A `danger` needs the user's explicit
+   * acknowledgement.
+   */
+  readonly risk: ReadonlyArray<RiskFinding>;
+  readonly createdAt: number;
+  readonly expiresAt: number;
+  /** The transaction being replaced or accelerated; absent for a plain send. */
+  readonly target?: string;
+  /** The tracked transaction once submitted. */
+  readonly txId?: string;
+  readonly error?: string;
+};
+type RequestControllerState = {
+  readonly requests: Record<string, PendingRequest>;
+};
+type RequestControllerOptions = {
+  readonly transactions: TransactionController;
+  /** The full controller: its payment methods are reachable only through this pipeline. */
+  readonly spark: SparkController;
+  readonly addressBook: AddressBookController;
+  readonly openStore: () => Promise<EngineStore>;
+  readonly fetch: typeof globalThis.fetch;
+  readonly random: (n: number) => Uint8Array;
+  readonly now: () => number;
+  readonly setTimer: (ms: number, fn: () => unknown) => () => void;
+  readonly logger: EngineLogger;
+};
+/** Requests expire this long after creation. */
+export declare const REQUEST_TTL_MS: number;
+export declare class RequestController extends Controller<RequestControllerState> {
+  private readonly options;
+  private readonly entries;
+  private readonly log;
+  private readonly settlers;
+  /** Original transaction id → the unfinished request replacing or accelerating it. */
+  private readonly targets;
+  private locked;
+  /** Bumped on every unlock and lock so work that outlives a session never touches the next one. */
+  private session;
+  constructor(options: RequestControllerOptions);
+  init(): Promise<void>;
+  destroy(): Promise<void>;
+  /** Locking is not consent: every unfinished request becomes `invalidated` and frees its resources. */
+  lock(): void;
+  /** A page navigated away, was revoked or changed network: its unfinished requests are void. */
+  invalidateOrigin(origin: string): void;
+  /** The signature record, newest first. */
+  signLog(): Promise<ReadonlyArray<SignLogEntry>>;
+  clearSignLog(): Promise<void>;
+  prepare(input: RequestInput): Promise<PendingRequest>;
+  /**
+   * Resolves with what `approve` returned, or rejects with `RequestEndedError` when the request
+   * ends any other way — how a dApp's pending call learns the outcome.
+   */
+  outcome(id: string): Promise<TrackedTransaction | SparkResult | SignatureResult>;
+  private openSettler;
+  private settle;
+  /** The bitcoin network `account`'s Spark network settles on; any other pairing is refused. */
+  private l1Network;
+  private sparkBuilt;
+  private build;
+  /**
+   * Signs and submits a request. Anything but a live, unexpired `send` request with this id throws
+   * before any signing; a stale build (nonce taken, blockhash expired) fails without signing.
+   */
+  approve(id: string, method: ChainRequestMethod | "spark-deposit", verify: SendParams["verify"]): Promise<TrackedTransaction>;
+  approve(id: string, method: "pay" | "zap" | "spark-exit", verify: SendParams["verify"]): Promise<SparkResult>;
+  approve(id: string, method: "evm-sign", verify: SendParams["verify"]): Promise<TrackedTransaction | SignatureResult>;
+  /**
+   * A cancelled or refused verification is `rejected`; anything after it is `failed`. Chain
+   * requests record which step failed on the tracked transaction; for Spark, the approval round is
+   * the only source of `WalletError`.
+   */
+  private failureStage;
+  reject(id: string): void;
+  private requireRequest;
+  private put;
+  private unclaim;
+  /** Ends a request in a terminal stage and frees what it reserved. */
+  private finish;
+  /** Appends the final stage to the signature record; a failed write is a warning, not an error. */
+  private record;
+  private appendLog;
+  /**
+   * Addresses the wallet already knows for a family: contacts, plus recipients of tracked chain
+   * sends (Spark payments are not tracked).
+   */
+  private knownAddresses;
+  private chainRisk;
+  /** Only a Spark transfer has a recipient to check; Lightning and exits are not assessed. */
+  private sparkRisk;
+}
+type Eip1193Request = {
+  readonly method: string;
+  readonly params?: unknown;
+};
+type Eip1193Event = {
+  readonly name: "connect";
+  readonly origin: string;
+  readonly chainId: string;
+} | {
+  readonly name: "accountsChanged";
+  readonly origin: string;
+  readonly accounts: ReadonlyArray<string>;
+} | {
+  readonly name: "chainChanged";
+  readonly origin: string;
+  readonly chainId: string;
+} | {
+  readonly name: "disconnect";
+  readonly origin: string;
+};
+type Eip1193HandlerOptions = {
+  readonly connections: ConnectionController;
+  readonly requests: RequestController;
+  readonly networks: NetworkController;
+  /** The network an unconnected page sees. */
+  readonly defaultNetwork: () => string;
+};
+export declare class Eip1193Handler {
+  private readonly options;
+  private readonly listeners;
+  private unsubscribe;
+  constructor(options: Eip1193HandlerOptions);
+  /** Events for the host to forward to pages; derived from changes to the sessions. */
+  subscribe(listener: (event: Eip1193Event) => void): () => void;
+  handle(origin: string, request: Eip1193Request): Promise<unknown>;
+  private requestAccounts;
+  private permissions;
+  private switchChain;
+  private authorizedAccount;
+  private personalSign;
+  private typedData;
+  private sendTransaction;
+  private signingSession;
+  private sign;
+  private read;
+}
+/** EIP-1193 / EIP-1474 / EIP-3326 error: `code` is what the page's promise rejects with. */
+export declare class ProviderError extends Error {
+  readonly code: number;
+  constructor(code: number, message: string);
+}
+type AddressBookErrorCategory = "invalid-input" | "duplicate" | "not-found" | "locked" | "limit";
+export declare class AddressBookError extends Error {
+  readonly category: AddressBookErrorCategory;
+  constructor(category: AddressBookErrorCategory, message: string);
+}
+/**
+ * Wallet metadata document — the plaintext exchanged over kind-30078 events between this wallet's
+ * own devices. One document per wallet; entry-level last-writer-wins on `updatedAt`.
+ */
+type MetaDocWallet = {
+  readonly name?: string;
+  readonly updatedAt: number;
+};
+type MetaDocGroup = {
+  readonly index: number;
+  readonly name?: string;
+  readonly hidden: boolean;
+  readonly boundPubkey?: string;
+  readonly updatedAt: number;
+};
+/** The per-wallet part of the document: this wallet's name and account groups. */
+type MetaDocTree = {
+  readonly wallet: MetaDocWallet;
+  readonly groups: ReadonlyArray<MetaDocGroup>;
+};
+/** Every wallet's document also carries the whole address book, which is shared across wallets. */
+type MetaDoc = MetaDocTree & {
+  readonly v: 2;
+  readonly contacts: ReadonlyArray<AddressBookRecord>;
+};
+type AccountGroup = {
+  readonly walletId: string;
+  readonly index: number;
+  /** `discoverGroups` result — family key → used; a family error lives under `errors`. */
+  readonly used?: Readonly<Record<string, boolean>>;
+  readonly errors?: Readonly<Record<string, string>>;
+  readonly name?: string;
+  readonly hidden: boolean;
+  /** A social identity (64 lowercase hex) bound to this group; one identity binds one group. */
+  readonly boundPubkey?: string;
+  /** Last local modification time (ms); reconcile-created entries start at 0. */
+  readonly updatedAt: number;
+};
+type AccountTreeState = {
+  readonly status: "locked" | "ready";
+  readonly wallets: ReadonlyArray<{
+    readonly walletId: string;
+    readonly name?: string;
+    readonly updatedAt: number;
+  }>;
+  readonly groups: Readonly<Record<string, ReadonlyArray<AccountGroup>>>;
+  readonly selected: {
+    readonly walletId: string;
+    readonly groupIndex: number;
+  } | null;
+  readonly totals: Readonly<Record<string, number>>;
+};
+type DiscoveryNetworks = {
+  readonly client: (network: string) => {
+    readonly getTransactionCount: (p: {
+      readonly address: `0x${string}`;
+      readonly blockTag: "latest";
+    }) => Promise<number>;
+    readonly getBalance: (p: {
+      readonly address: `0x${string}`;
+    }) => Promise<bigint>;
+  };
+  readonly solanaRpc: (network: string) => {
+    readonly call: (method: string, params: unknown[]) => Promise<unknown>;
+  };
+  readonly esplora: (network: string) => Esplora;
+  readonly enabled: (family: "evm" | "solana" | "bitcoin") => ReadonlyArray<string>;
+};
+type AccountTreeControllerOptions = {
+  readonly wallet: Wallet;
+  readonly spark: SparkController;
+  readonly sparkNetwork: SparkNetwork;
+  readonly networks?: DiscoveryNetworks;
+  readonly chains?: {
+    readonly account: (params: {
+      readonly walletId: string;
+      readonly groupIndex: number;
+      readonly template: string;
+      readonly network: string;
+    }) => Promise<{
+      readonly address?: string;
+      readonly xpub?: string;
+    }>;
+  };
+  readonly logger: EngineLogger;
+  readonly now: () => number;
+};
+export declare class AccountTreeController extends Controller<AccountTreeState> {
+  private readonly options;
+  private col;
+  private sparkUnsubscribe;
+  private totalsTimer;
+  private persistChain;
+  constructor(options: AccountTreeControllerOptions);
+  setStore(store: EngineStore | undefined): void;
+  /** Load persisted state, reconcile with the snapshot, start driving Spark. */
+  init(): Promise<void>;
+  destroy(): Promise<void>;
+  /** Locked: stop every Spark client, flush pending persists, then drop to the empty state. */
+  lock(): Promise<void>;
+  /** Reconcile groups/names/selected with `wallet.getSnapshot().wallets`; persists on change. */
+  reconcile(): void;
+  addGroup(walletId: string): number;
+  addGroups(walletId: string, indices: ReadonlyArray<number>): void;
+  renameWallet(walletId: string, name: string): void;
+  renameGroup(walletId: string, index: number, name: string): void;
+  setHidden(walletId: string, index: number, hidden: boolean): void;
+  select(walletId: string, index: number): void;
+  /**
+   * Binds a social identity to one group. The identity is unique across the whole tree — every
+   * group in every wallet carrying it loses the binding (each entry re-stamped).
+   */
+  bind(walletId: string, index: number, pubkey: string): void;
+  unbind(walletId: string, index: number): void;
+  /**
+   * Which group currently holds a pubkey — merges can leave the same identity on groups in two
+   * wallets; the newest `updatedAt` wins, ties resolve by snapshot wallet order then lower index.
+   */
+  bindingOf(pubkey: string): {
+    walletId: string;
+    groupIndex: number;
+  } | undefined;
+  /** The wallet's metadata document — every group, hidden included. */
+  exportMeta(walletId: string): MetaDocTree;
+  /**
+   * Entry-level last-writer-wins merge: a newer remote `updatedAt` replaces the local entry, a tie
+   * keeps local; remote-only groups are added. `selected`/hidden rules are re-validated — if the
+   * merge hides the selected group it is re-selected, and a merge may never leave every group
+   * hidden (the selected one stays visible and is re-stamped so the fix propagates).
+   */
+  mergeMeta(walletId: string, doc: MetaDocTree): {
+    changed: boolean;
+    localNewer: boolean;
+  };
+  /** Sequential inspect from 0 upward; index 0 always included; stop after 2 consecutive unused. */
+  discoverSpark(walletId: string): Promise<number[]>;
+  /**
+   * 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).
+   */
+  discoverGroups(walletId: string): Promise<number[]>;
+  /** Refresh `totals` for every other visible group; per-group failures are logged and skipped. */
+  refreshTotals(): Promise<void>;
+  private onSparkState;
+  private setTotal;
+  private driveSpark;
+  private visibleGroups;
+  private validSelection;
+  private selectFallback;
+  private mutateGroups;
+  private mustWallet;
+  private mustGroup;
+  private checkedName;
+  private load;
+  /** Queues a store write behind the previous one — the last queued write always lands last. */
+  private persist;
+  private scheduleTotalsPersist;
+  private flushTotals;
 }
-//#endregion
-//#region src/assets/controller.d.ts
 type TokenBalance = {
   readonly address: string;
   readonly symbol: string;
@@ -484,7 +1192,7 @@ type AccountBalances = {
 type AssetsControllerState = {
   readonly balances: Record<string, AccountBalances>;
 };
-type Options$1 = {
+type Options = {
   readonly networks: NetworkController;
   readonly openStore: () => Promise<EngineStore>;
   readonly setTimer: (ms: number, fn: () => unknown) => () => void;
@@ -497,7 +1205,7 @@ declare class AssetsController extends Controller<AssetsControllerState> {
   private visible;
   private cancelPoll;
   private readonly customTokens;
-  constructor(options: Options$1);
+  constructor(options: Options);
   init(): Promise<void>;
   lock(): void;
   destroy(): Promise<void>;
@@ -510,26 +1218,19 @@ declare class AssetsController extends Controller<AssetsControllerState> {
   private readTokens;
   private balanceOfBatch;
   private balanceOf;
-  private callString;
-  private callNumber;
+  private callToken;
   /** Reads symbol/decimals on-chain, marks unverified, persists; throws when the calls fail. */
   addToken(network: string, address: string): Promise<void>;
   private persistToken;
-  private rpc;
-  private rpcHex;
   /** BTC balance = confirmed spendable + own unconfirmed change; frozen 546/330 shown separately. */
   refreshBitcoin(xpub: string, network: string): Promise<void>;
 }
-//#endregion
-//#region src/backup/errors.d.ts
 /** BackupController error categories — never carry file contents, digests or secrets. */
 type BackupErrorCategory = "cloud" | "conflict" | "unavailable";
 export declare class BackupControllerError extends Error {
   readonly category: BackupErrorCategory;
   constructor(category: BackupErrorCategory, message: string);
 }
-//#endregion
-//#region src/backup/port.d.ts
 /**
  * Cloud-file storage port (design/backup.mdx "存储"): the cloud is an opaque key-value namespace —
  * names are file names (`qntx-wallet-backup-<id>.json`), contents are envelope texts. The kernel
@@ -547,8 +1248,6 @@ type CloudStore = {
   /** Deleting a missing file succeeds. */
   readonly delete: (name: string) => Promise<void>;
 };
-//#endregion
-//#region src/backup/controller.d.ts
 type BackupControllerState = {
   readonly status: "locked" | "unavailable" | "off" | "syncing" | "synced" | "conflict" | "error";
   /** The retained backup key's public summary from the wallet snapshot. */
@@ -556,7 +1255,6 @@ type BackupControllerState = {
   readonly uploadedAt: number | undefined;
   readonly unprotected: {
     readonly walletIds: ReadonlyArray<string>;
-    readonly nostrKeyIds: ReadonlyArray<string>;
   };
   readonly error: BackupErrorCategory | undefined;
 };
@@ -618,16 +1316,12 @@ export declare class BackupController extends Controller<BackupControllerState>
   private reconcile;
   private pass;
 }
-//#endregion
-//#region src/meta/errors.d.ts
 /** Meta-sync error categories — messages never carry event or document content. */
 type MetaSyncErrorCategory = "network" | "internal" | "unsupported" | "corrupt";
 export declare class MetaSyncError extends Error {
   readonly category: MetaSyncErrorCategory;
   constructor(category: MetaSyncErrorCategory, message: string, cause?: unknown);
 }
-//#endregion
-//#region src/meta/controller.d.ts
 type MetaSyncRelayPort = {
   readonly fetch: (filter: Filter) => Promise<ReadonlyArray<Event>>;
   readonly publish: (event: Event) => Promise<void>;
@@ -638,18 +1332,30 @@ type MetaSyncConfig = {
   readonly relays: MetaSyncRelayPort;
 };
 type MetaSyncWalletStatus = {
-  readonly status: "unavailable" | "syncing" | "synced" | "error";
+  readonly status: "syncing" | "synced" | "error";
   readonly error?: MetaSyncErrorCategory;
 };
 type MetaSyncState = {
   readonly wallets: Readonly<Record<string, MetaSyncWalletStatus>>;
 };
+/** What the sync needs from the address book: its records, a merge, and a change subscription. */
+type AddressBookSync = {
+  readonly syncEntries: () => ReadonlyArray<AddressBookRecord>;
+  readonly merge: (remote: ReadonlyArray<AddressBookRecord>) => Promise<{
+    readonly changed: boolean;
+    readonly localNewer: boolean;
+  }>;
+  readonly store: {
+    readonly subscribe: (listener: () => void) => () => void;
+  };
+};
 type MetaSyncControllerOptions = {
   readonly wallet: Wallet;
   readonly accounts: AccountTreeController;
-  /** `nostr(wallet)` — the signer is requested per wallet for its group-0 derived key. */
+  readonly addressBook: AddressBookSync;
+  /** `nostr(wallet).syncSigner` — each wallet signs metadata with its dedicated sync key. */
   readonly nostr: {
-    readonly signer: (ref: NostrKeyRef) => WalletSigner;
+    readonly syncSigner: (walletId: string) => WalletSyncSigner;
   };
   readonly metaSync: MetaSyncConfig | undefined;
   readonly logger: EngineLogger;
@@ -657,9 +1363,10 @@ type MetaSyncControllerOptions = {
 };
 /**
  * Wallet-metadata sync over kind-30078 addressable events: one NIP-44-encrypted document per
- * wallet, authored by its group-0 derived key. Pull always precedes publish in an unlock session —
- * replaceable events would otherwise let a stale local tree overwrite a newer remote document.
- * Debounced publishes are per wallet; a generation counter cancels in-flight write-backs on lock.
+ * wallet, authored by its dedicated sync key (WD-070). Pull always precedes publish in an unlock
+ * session — replaceable events would otherwise let a stale local tree overwrite a newer remote
+ * document. Debounced publishes are per wallet; a generation counter cancels in-flight write-backs
+ * on lock.
  */
 export declare class MetaSyncController extends Controller<MetaSyncState> {
   private readonly options;
@@ -670,6 +1377,7 @@ export declare class MetaSyncController extends Controller<MetaSyncState> {
   private readonly timers;
   private readonly inflight;
   private accountsUnsubscribe;
+  private addressBookUnsubscribe;
   constructor(options: MetaSyncControllerOptions);
   /** Unlocked: pull every wallet whose group-0 identity exists, then watch the tree. */
   init(): Promise<void>;
@@ -681,10 +1389,10 @@ export declare class MetaSyncController extends Controller<MetaSyncState> {
   /** Manual re-pull of every wallet that can sync. */
   sync(): Promise<void>;
   private pullAll;
-  private pubkeyFor;
-  private signerFor;
   private setStatus;
   private pullOne;
+  /** The wallet's tree plus the shared address book — every wallet's document carries both. */
+  private exportDoc;
   private filterFor;
   private acceptableEvent;
   /** Snapshot the wallet's exported doc — the debounce publishes only on a real change. */
@@ -692,245 +1400,6 @@ export declare class MetaSyncController extends Controller<MetaSyncState> {
   private onTreeChange;
   private publishNow;
 }
-//#endregion
-//#region src/payments/parse.d.ts
-type PaymentOption = {
-  readonly kind: "spark";
-  readonly address: string;
-} | {
-  readonly kind: "spark-invoice";
-  readonly invoice: string;
-  readonly amountSats?: number;
-  readonly memo?: string;
-  readonly expiresAt?: number;
-} | {
-  readonly kind: "lightning";
-  readonly invoice: string;
-  readonly amountSats?: number;
-  readonly paymentHash: string;
-  readonly description?: string;
-  readonly expiresAt: number;
-} | {
-  readonly kind: "lnurl-pay";
-  readonly request: LnurlPayRequest;
-  readonly address?: string;
-} | {
-  readonly kind: "lnurl-withdraw";
-  readonly request: LnurlWithdrawRequest;
-} | {
-  readonly kind: "bitcoin";
-  readonly address: string;
-};
-type PaymentRequest = {
-  readonly options: ReadonlyArray<PaymentOption>;
-  readonly amountSats?: number;
-  readonly label?: string;
-  readonly message?: string;
-};
-type PaymentParse = {
-  readonly kind: "request";
-  readonly request: PaymentRequest;
-} | {
-  readonly kind: "lnurl";
-  readonly url: string;
-  readonly address?: string;
-} | {
-  readonly kind: "unsupported";
-  readonly format: "bolt12" | "silent-payment" | "lnurl-auth" | "spark-token-invoice" | "nostr-wallet-connect";
-} | {
-  readonly kind: "invalid";
-  readonly reason: "network" | "expired" | "amount-mismatch" | "malformed";
-} | {
-  readonly kind: "unrecognized";
-};
-type ParseOptions = {
-  readonly network: SparkNetwork;
-  readonly now: number;
-};
-/** `input` → PaymentParse. Never throws: every failure is a structured result. */
-export declare function parsePayment(input: string, options: ParseOptions): PaymentParse;
-//#endregion
-//#region src/payments/pay.d.ts
-type PayParams = {
-  readonly account: SparkAccountRef;
-  readonly option: PaymentOption;
-  /** Caller-supplied amount — required by open invoices, the `spark` option, and LNURL flows. */
-  readonly amountSats?: number;
-  readonly comment?: string;
-  readonly maxFeeSats?: number;
-  readonly speed?: "FAST" | "MEDIUM" | "SLOW";
-  readonly verify: UnlockFactor;
-};
-type PayResult = {
-  readonly kind: "spark";
-  readonly transfer: SparkTransfer;
-} | {
-  readonly kind: "lightning";
-  readonly payment: LightningPayment;
-} | {
-  readonly kind: "withdraw";
-  readonly exit: CooperativeExitResult;
-} | {
-  readonly kind: "lnurl-withdraw";
-  readonly invoice: LightningInvoice;
-};
-//#endregion
-//#region src/payments/zap.d.ts
-/** A profile zap names the recipient pubkey; an event zap carries the event it zaps. */
-type ZapRecipient = {
-  readonly pubkey: string;
-  readonly lightning: string;
-} | {
-  readonly event: Event;
-  readonly lightning: string;
-};
-type PrepareZapParams = {
-  /** Any `NostrSigner` — wallet key, external key, NIP-07/46 — signs the 9734. */
-  readonly signer: NostrSigner;
-  readonly recipient: ZapRecipient;
-  readonly amountSats: number;
-  readonly comment?: string | undefined;
-  readonly relays: ReadonlyArray<string>;
-  readonly network: SparkNetwork;
-};
-type PrepareZapContext = {
-  readonly fetch: typeof globalThis.fetch;
-  readonly now: () => number;
-};
-/** Everything a payer needs: the signed 9734, the invoice, and the note fields. */
-type PreparedZap = {
-  readonly zapRequest: Event;
-  readonly invoice: string;
-  /** Hex payment hash decoded from the invoice. */
-  readonly paymentHash: string;
-  /** Millisecond expiry decoded from the invoice. */
-  readonly expiresAt: number;
-  readonly amountSats: number;
-  /** The LNURL service's 9735 signing pubkey. */
-  readonly receiptPubkey: string;
-  readonly recipientPubkey: string;
-  readonly eventId?: string;
-  readonly comment?: string;
-  /** The lud16 or LNURL as given. */
-  readonly lightning: string;
-};
-type PayZapOptions = {
-  readonly maxFeeSats: number;
-  readonly verify: UnlockFactor;
-  readonly now: () => number;
-};
-/** Everything up to payment: resolve LNURL, sign the 9734, request the invoice. */
-export declare function prepareZap(params: PrepareZapParams, context: PrepareZapContext): Promise<PreparedZap>;
-/**
- * Pays a prepared zap through the controller's approve-first path. A nearly-expired invoice is
- * rejected before approval — the user may have sat on the confirm screen since `prepareZap`.
- */
-export declare function payZap(spark: SparkController, account: SparkAccountRef, prepared: PreparedZap, options: PayZapOptions): Promise<LightningPayment>;
-//#endregion
-//#region src/chains/evm.d.ts
-type EvmFeeTier = "slow" | "normal" | "fast";
-//#endregion
-//#region src/chains/solana.d.ts
-type SolanaFeeTier = "slow" | "normal" | "fast";
-//#endregion
-//#region src/transactions/route.d.ts
-type SignParams = Parameters<ReturnType<typeof chains>["sign"]>[0];
-type AccountRef = SignParams["request"]["account"];
-type DisplayIntent = ReturnType<typeof decodeEvm>;
-type TxState = "draft" | "signed" | "submitted" | "pending" | "confirmed" | "failed" | "rejected" | "dropped" | "replaced";
-type TrackedTransaction = {
-  readonly id: string;
-  readonly family: "evm" | "solana" | "bitcoin";
-  readonly network: string;
-  readonly account: string;
-  readonly hash: string | undefined;
-  readonly state: TxState;
-  readonly intent: DisplayIntent | undefined;
-  readonly nonce: number;
-  /** Solana only — the blockhash expiry that turns an unconfirmed tx `dropped`. */
-  readonly lastValidBlockHeight?: number;
-  /** EVM replacement — the earlier transaction this one bumps or cancels. */
-  readonly replaces?: string;
-  /** CPFP — the unconfirmed parent this child pushes. */
-  readonly parentId?: string;
-  /** Bitcoin build record persisted at send for RBF/CPFP rebuilds. */
-  readonly btc?: {
-    readonly inputs: ReadonlyArray<{
-      readonly txid: string;
-      readonly vout: number;
-      readonly value: number;
-      readonly address: string;
-    }>;
-    readonly outputs: ReadonlyArray<{
-      readonly address: string;
-      readonly value: number;
-      readonly own: boolean;
-    }>;
-    readonly vsize: number;
-    readonly fee: number;
-    readonly feeRate: number;
-  };
-  readonly submittedAt: number;
-  readonly error: string | undefined;
-};
-type SendParams = {
-  readonly account: AccountRef;
-  readonly network: string;
-  readonly to: string;
-  readonly amount: bigint;
-  /** ERC-20 contract — when set, `to`/`amount` are the transfer recipient/units and value is 0. */
-  readonly token?: string;
-  readonly fee: EvmFeeTier | SolanaFeeTier;
-  /** SPL mint decimals — required when `token` is a Solana mint. */
-  readonly decimals?: number;
-  readonly verify: SignParams["verify"];
-};
-type Options = {
-  readonly wallet: Wallet;
-  readonly networks: NetworkController;
-  readonly openStore: () => Promise<EngineStore>;
-  readonly random: (n: number) => Uint8Array;
-  readonly setTimer: (ms: number, fn: () => unknown) => () => void;
-  readonly now: () => number;
-  readonly logger: EngineLogger;
-  readonly pollMs?: number;
-  /** Test seam — defaults to the wallet's real chains proxy. */
-  readonly chains?: ReturnType<typeof chains>;
-};
-//#endregion
-//#region src/transactions/controller.d.ts
-type TransactionControllerState = {
-  readonly txs: Record<string, TrackedTransaction>;
-};
-declare class TransactionController extends Controller<TransactionControllerState> {
-  private readonly options;
-  private engineStore?;
-  private readonly timers;
-  private evmRoute;
-  private readonly bitcoinRoute;
-  private locked;
-  constructor(options: Options);
-  init(): Promise<void>;
-  destroy(): Promise<void>;
-  lock(): void;
-  private persist;
-  private transition;
-  private routeCtx;
-  send(params: SendParams): Promise<TrackedTransaction>;
-  /**
-   * 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.
-   */
-  replace(id: string, mode: "speed-up" | "cancel", verify: SendParams["verify"]): Promise<TrackedTransaction>;
-  /**
-   * 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`.
-   */
-  bumpChild(id: string, targetRate: number, verify: SendParams["verify"]): Promise<TrackedTransaction>;
-  private track;
-}
-//#endregion
-//#region src/engine.d.ts
 type EngineOptions = {
   readonly wallet: Wallet;
   /** Every Spark account the engine touches lives on this network. */
@@ -942,11 +1411,24 @@ type EngineOptions = {
   readonly openStore: () => Promise<EngineStore>;
   /** Cloud file transport for the backup controller; absent → `unavailable`. */
   readonly cloud?: CloudStore;
-  /** RPC endpoints per network (CAIP-2), ordered by preference for the viem fallback transport. */
+  /**
+   * Host endpoints per network (CAIP-2), ordered by preference, for all three chain families: EVM
+   * and Solana JSON-RPC URLs, and for Bitcoin the Esplora base URL.
+   */
   readonly rpc?: Readonly<Record<string, ReadonlyArray<string>>>;
+  /**
+   * The wallet gateway: tried first for the networks it serves (read at each unlock) unless a
+   * network has custom endpoints. The install id is sent only to the gateway's origin.
+   */
+  readonly gateway?: {
+    readonly url: string;
+    readonly installId: string;
+  };
   /** Injected timer for transaction polling; defaults to setTimeout. */
+  /** Development builds: also accept `http://localhost` as a dApp origin. */
+  readonly allowLocalhostOrigins?: boolean;
   readonly setTimer?: (ms: number, fn: () => void) => () => void;
-  /** Kind-30078 wallet-metadata sync; absent → every wallet reports `unavailable`. */
+  /** Kind-30078 wallet-metadata sync; absent → no wallet metadata is synced. */
   readonly metaSync?: MetaSyncConfig;
   /** Test seam — defaults to the wallet's real spark proxy. */
   readonly sparkApis?: SparkControllerOptions["spark"];
@@ -955,52 +1437,50 @@ type WalletEngine = {
   readonly networks: NetworkController;
   readonly assets: AssetsController;
   readonly transactions: TransactionController;
-  readonly spark: SparkController;
+  readonly requests: RequestController;
+  readonly addressBook: AddressBookController;
+  readonly connections: ConnectionController;
+  readonly eip1193: Eip1193Handler;
+  /** Read and receive surface; every payment goes through `requests`. */
+  readonly spark: Omit<SparkController, "send" | "payInvoice" | "paySparkInvoice" | "withdraw">;
   readonly accounts: AccountTreeController;
   readonly metaSync: MetaSyncController;
   readonly backup: BackupController;
   readonly zaps: {
     readonly prepare: (params: PrepareZapParams) => Promise<PreparedZap>;
-    readonly pay: (account: SparkAccountRef, prepared: PreparedZap, options: Omit<PayZapOptions, "now">) => Promise<LightningPayment>;
   };
   readonly payments: {
     readonly parse: (input: string, network: SparkNetwork) => PaymentParse;
     readonly resolve: (input: string, network: SparkNetwork) => Promise<PaymentParse>;
-    readonly pay: (params: PayParams) => Promise<PayResult>;
+    /** Receives funds from an LNURL-withdraw service; needs no verification factor. */
+    readonly withdrawLnurl: (params: WithdrawLnurlParams) => Promise<{
+      readonly kind: "lnurl-withdraw";
+      readonly invoice: LightningInvoice;
+    }>;
   };
   readonly unsubscribe: () => void;
 };
 export declare function createWalletEngine(options: EngineOptions): WalletEngine;
-//#endregion
-//#region src/backup/memory.d.ts
 /** In-memory CloudStore for tests and the playground; swap the Map for cross-engine sharing. */
 export declare function createMemoryCloudStore(backing?: Map<string, string>): CloudStore;
-//#endregion
-//#region src/spark/errors.d.ts
 /** SparkController error categories — never carry request bytes or secrets. */
 type SparkErrorCategory = "network" | "approval-required" | "insufficient-funds" | "rejected" | "internal";
 export declare class SparkControllerError extends Error {
   readonly category: SparkErrorCategory;
   constructor(category: SparkErrorCategory, message: string, cause?: unknown);
 }
-//#endregion
-//#region src/accounts/errors.d.ts
 /** Account-tree error categories — messages never carry secrets. */
 type AccountTreeErrorCategory = "invalid-input" | "rejected" | "not-found" | "locked";
 export declare class AccountTreeError extends Error {
   readonly category: AccountTreeErrorCategory;
   constructor(category: AccountTreeErrorCategory, message: string, cause?: unknown);
 }
-//#endregion
-//#region src/payments/errors.d.ts
 /** Payment layer error categories — messages never carry remote or secret content. */
 type PaymentErrorCategory = "invalid-input" | "network" | "rejected";
 export declare class PaymentError extends Error {
   readonly category: PaymentErrorCategory;
   constructor(category: PaymentErrorCategory, message: string, cause?: unknown);
 }
-//#endregion
-//#region src/payments/resolve.d.ts
 type ResolveOptions = ParseOptions & {
   readonly fetch: typeof globalThis.fetch;
 };
@@ -1010,10 +1490,7 @@ type ResolveOptions = ParseOptions & {
  * failures throw `PaymentError("network")` — remote error bodies never enter the message.
  */
 export declare function resolvePayment(input: string, options: ResolveOptions): Promise<PaymentParse>;
-//#endregion
-//#region src/spark/exit-chain-codec.d.ts
 export declare function encodeExitChain(chain: SparkExitChain): Uint8Array;
 export declare function decodeExitChain(bytes: Uint8Array): SparkExitChain;
-//#endregion
-export type { AccountGroup, AccountTreeState, BackupControllerState, BackupErrorCategory, CloudStore, ControllerOptions, EngineCollection, EngineErrorCode, EngineLogger, EngineOptions, EngineStore, EventBus, MetaDoc, MetaDocGroup, MetaDocWallet, MetaSyncConfig, MetaSyncRelayPort, MetaSyncState, MetaSyncWalletStatus, PayParams, PayResult, PayZapOptions, PaymentNote, PaymentOption, PaymentParse, PaymentRequest, PrepareZapContext, PrepareZapParams, PreparedZap, SparkAccountState, SparkActivity, SparkClientFactory, SparkControllerOptions, SparkControllerState, SparkErrorCategory, WalletEngine, ZapRecipient };
+export type { AccountGroup, AccountTreeState, AddressBookEntry, AddressBookErrorCategory, AddressBookState, AddressFamily, BackupControllerState, BackupErrorCategory, BrowserOrigin, CloudStore, AccountGroup$1 as ConnectionAccountGroup, ConnectionOrigin, ConnectionScope, ConnectionSession, ConnectionState, ControllerOptions, Eip1193Event, Eip1193Request, EngineCollection, EngineErrorCode, EngineLogger, EngineOptions, EngineStore, EventBus, EvmSignInput, MetaDoc, MetaDocGroup, MetaDocTree, MetaDocWallet, MetaSyncConfig, MetaSyncRelayPort, MetaSyncState, MetaSyncWalletStatus, PayInput, PayParams, PaymentNote, PaymentOption, PaymentParse, PaymentRequest, PendingConnection, PendingRequest, PrepareZapContext, PrepareZapParams, PreparedSparkAction, PreparedZap, RequestCheckCode, RequestControllerState, RequestInput, RequestMethod, RequestOrigin, RequestStage, RiskFinding, SignLogEntry, SignLogOutcome, SignatureResult, SparkAccountState, SparkActivity, SparkClientFactory, SparkControllerOptions, SparkControllerState, SparkDepositInput, SparkDisplay, SparkErrorCategory, SparkExitInput, SparkResult, WalletEngine, WithdrawLnurlParams, ZapRecipient };
 //# sourceMappingURL=index.d.mts.map