@usebutr/bitcoin 1.0.1 → 1.1.2

package/CHANGELOG.md

@@ -0,0 +1,222 @@
+# @usebutr/bitcoin
+
+## 1.1.2
+
+### Patch Changes
+
+- Updated dependencies [[`bc5b58c`](https://github.com/pedroapfilho/usebutr/commit/bc5b58cd87601be38dbb77a14e16eaaa36e8f012), [`bc5b58c`](https://github.com/pedroapfilho/usebutr/commit/bc5b58cd87601be38dbb77a14e16eaaa36e8f012)]:
+  - @usebutr/wallet-standard-shared@1.0.0
+  - @usebutr/core@2.0.1
+
+## 1.1.1
+
+### Patch Changes
+
+- Updated dependencies [302ae4a]
+  - @usebutr/wallet-standard-shared@0.5.1
+
+## 1.1.0
+
+### Minor Changes
+
+- 9b1caa2: Correctness pass across the storage, hydration and connector layers. Several of
+  these change observable behaviour; the ones worth knowing about before upgrading:
+
+  **Breaking**
+
+  - `SuiWallet.signTransaction` now returns `{ bytes, signature }` instead of
+    `Uint8Array`. Sui's `executeTransactionBlock` needs both, and each connector
+    previously returned a different half, so the old value could not be broadcast
+    and a consumer could not tell which half they held. SVM and Bitcoin keep their
+    single-`Uint8Array` shape.
+  - `@usebutr/svm`'s `sendTx` returns the signature base58-encoded, matching the
+    WalletConnect namespace, the Ledger app, Solana explorers and
+    `getSignatureStatuses`. It previously returned base64.
+  - `@usebutr/sui`'s feature input types drop the `string` arm from
+    `transaction`; wallets only ever accepted the `toJSON()` form. Strings and BCS
+    bytes are now wrapped for you, so `sendTx` accepts strictly more than before.
+
+  **Behaviour fixes**
+
+  - `WalletStorage.setPool` and `removePoolEntry` could self-deadlock on a corrupt
+    pool payload, leaving `connectWallet` unresolved and every later pool write
+    jammed for the page's life. Both are fixed, and `readWalletSnapshot` now shares
+    one codec with `WalletStorage` so the server and client decodes cannot drift.
+  - A seeded (SSR) entry whose silent reconnect failed used to stay in the pool
+    backed by a placeholder connector forever, so `useSigner`/`useBalance`
+    reported an error and `useConnectionStatus` reported `"reconnecting"`
+    permanently. Those entries are now dropped.
+  - `useSigner` and `useBalance` stay `idle` for a wallet that is still
+    reconnecting instead of surfacing a placeholder rejection as `status: "error"`.
+  - `useConnectionStatus` lets a live `"connecting"`/`"error"` take precedence over
+    the derived `"reconnecting"`, so an in-flight attempt and a connection error
+    are no longer hidden. New `useIsReconnecting(connectorId?)` answers the
+    per-wallet question directly.
+  - A background restore no longer writes the connect-attempt status or steals
+    `activeConnectorId`, and a superseded `CONNECT_FAILED` no longer overwrites the
+    current attempt.
+  - An externally-disconnected connector is now torn down, not just dropped from
+    the pool, so a cached adapter is not reused while still holding a session.
+  - EVM: a malformed provider response is treated as absent rather than `""`, which
+    previously produced chain `eip155:0`, zero-length signatures, empty transaction
+    hashes and a confident `0 ETH`. `switchChain` gained the same-chain
+    short-circuit `sendTxToChain` already had.
+  - WalletConnect: accounts carry their own chain instead of all being stamped with
+    the active one, so a multi-chain session no longer returns a wrong-chain
+    address. One pairing now covers every configured namespace, the pairing URI
+    survives a reconnect, and concurrent connects share one pairing.
+  - Bitcoin: the sats-connect (Xverse) adapter honours `silent`, so a reload no
+    longer triggers an unsolicited approval prompt, and exposes the payment address
+    as its single account instead of also presenting the ordinals address as
+    spendable.
+  - Polkadot: the injected adapter actually delivers events to subscribers,
+    `switchChain` notifies like its Wallet Standard sibling, and chain resolution
+    prefers the mainnets rather than whatever the wallet listed first.
+  - Ledger: the device session is committed atomically, so a locked device no
+    longer leaves an open transport that reports itself connected, and concurrent
+    connects open one transport.
+  - SVM: `sendTxToChain` submits to the chain you asked for instead of the
+    adapter's current one, and rejects a chain the wallet does not advertise.
+  - `@usebutr/svm`'s `switchChain` capability now counts only `solana:` chains, so
+    a multi-namespace wallet no longer advertises a method that always throws.
+
+  **Testing**
+
+  - `createFakePersistence` is now the real `WalletStorage` over memory drivers
+    rather than a parallel implementation, so it inherits upsert semantics,
+    validation and JSON round-tripping. Two divergences are fixed as a result:
+    `setPool` upserts rather than replaces, and `clearAll` leaves the
+    user-disconnected flag alone.
+  - `createFakeConnectedWallet` rejects being given both an `adapter` and explicit
+    `addresses`/`accounts`, a combination whose halves could disagree.
+
+### Patch Changes
+
+- Updated dependencies [9b1caa2]
+  - @usebutr/wallet-standard-shared@0.5.0
+  - @usebutr/core@2.0.0
+
+## 1.0.1
+
+### Patch Changes
+
+- Updated dependencies [8ecaf89]
+  - @usebutr/core@1.1.0
+  - @usebutr/wallet-standard-shared@0.4.1
+
+## 1.0.0
+
+### Major Changes
+
+- f0a5116: **Breaking:** the `platform` field is gone from the `PlatformDiscoverer` type in `@usebutr/core`, and from the `evmDiscoverer`, `svmDiscoverer`, `suiDiscoverer`, `bitcoinDiscoverer` and `polkadotDiscoverer` objects that implement it. Nothing read it: the aggregator keys discoverers by `ChainPlatform` in its own registry, so the field only restated the key.
+
+  Migration: read the platform from the `KNOWN_DISCOVERERS` key in `@usebutr/wallets` (`Object.entries(KNOWN_DISCOVERERS)`), or from `adapter.chainPlatform` on a discovered adapter. Custom `PlatformDiscoverer` implementations must drop the `platform` property; keeping it is now an excess-property error.
+
+- f0a5116: **Breaking:** `slugify` is no longer exported from `@usebutr/svm`, `@usebutr/sui` or `@usebutr/bitcoin`. Each package exported a one-argument wrapper that only bound a platform prefix onto the canonical two-argument helper, so three names shadowed one implementation.
+
+  Migration: import `slugify` from `@usebutr/wallet-standard-shared` and pass the platform prefix as the first argument. `slugify(name)` from `@usebutr/svm` becomes `slugify("svm", name)`; the `@usebutr/sui` prefix is `"sui"` and the `@usebutr/bitcoin` prefix is `"btc"`. Adapter ids are byte-for-byte the same.
+
+### Patch Changes
+
+- 7887cf0: Resolve capabilities through `buildWalletCapabilities` from `@usebutr/wallet-standard-shared` instead of a per-package copy of the same object literal. Resolver names, input types and returned flags are unchanged. The injected Polkadot profile now derives its chain count from `POLKADOT_CHAINS_LIST` rather than asserting `switchChain: true` directly; the result is the same.
+- 7887cf0: Move each package's `discover*Adapters` function next to the adapter builder it wraps and drop the single-function `wallet-standard.ts` module. The functions are still exported from the package root under the same names; only an internal file boundary went away.
+- Updated dependencies [7887cf0]
+- Updated dependencies [7887cf0]
+- Updated dependencies [f0a5116]
+- Updated dependencies [f0a5116]
+- Updated dependencies [7887cf0]
+  - @usebutr/core@1.0.0
+  - @usebutr/wallet-standard-shared@0.4.0
+
+## 0.2.7
+
+### Patch Changes
+
+- efe4550: Share the session plumbing behind the Wallet Standard and WalletConnect CAIP adapters. `@usebutr/wallet-standard-shared` now exports `createWalletStandardCore`, which the Bitcoin, Polkadot, Sui and SVM adapters build on; the WalletConnect Bitcoin, Sui and SVM namespaces share an equivalent CAIP core. Every package's public API is unchanged. The one visible difference is a dev-console warning: a failed SVM disconnect now logs `[butr] SVM Wallet Standard disconnect threw:` instead of `[butr] Wallet Standard disconnect threw:`.
+- Updated dependencies [efe4550]
+- Updated dependencies [4467a5e]
+  - @usebutr/wallet-standard-shared@0.3.0
+  - @usebutr/core@0.5.0
+
+## 0.2.6
+
+### Patch Changes
+
+- 99eaef0: Restore guards that the type-aware lint pass narrowed away.
+
+  - `@usebutr/bitcoin`: the sats-connect `getAccounts` reader dropped its optional
+    chain on the RPC payload. The declared shape is an assertion over an untyped
+    bridge, so a wallet answering without a `result` threw a `TypeError` instead
+    of reporting no accounts.
+  - `@usebutr/walletconnect`: the Sui and Solana signing paths treated an
+    empty-string `transaction` / `transactionBytes` / `bytes` field as a real
+    value and decoded it to zero bytes. They now fall through to the signature
+    path (Sui `signPersonalMessage`) or the original message, matching the
+    previous truthiness checks.
+  - `@usebutr/ledger`: the unknown-platform rejection lost the platform name from
+    its message, which is the only detail that made the error actionable.
+
+- Updated dependencies [c1309ee]
+  - @usebutr/core@0.4.2
+  - @usebutr/wallet-standard-shared@0.2.6
+
+## 0.2.5
+
+### Patch Changes
+
+- 937dfae: Bump runtime dependency floors (`@wallet-standard/app` 1.1.1, `@ledgerhq/*` latest minors, `@walletconnect/universal-provider` 2.23.10) and modernize public type declarations from method signatures to property function types (oxlint `method-signature-style`). Type-level only — no runtime behavior change.
+- Updated dependencies [937dfae]
+  - @usebutr/core@0.4.1
+  - @usebutr/wallet-standard-shared@0.2.5
+
+## 0.2.4
+
+### Patch Changes
+
+- a46eecd: Ship unminified ESM so downstream bundlers (Vite/esbuild dep pre-bundling) process the package correctly; fixes a ReferenceError in consumer dev servers. The consuming app minifies once at its own build.
+- Updated dependencies [b5322ae]
+- Updated dependencies [d5f32c7]
+- Updated dependencies [a46eecd]
+- Updated dependencies [3f26776]
+  - @usebutr/core@0.4.0
+  - @usebutr/wallet-standard-shared@0.2.4
+
+## 0.2.3
+
+### Patch Changes
+
+- Updated dependencies [886ee1d]
+  - @usebutr/core@0.3.0
+  - @usebutr/wallet-standard-shared@0.2.3
+
+## 0.2.2
+
+### Patch Changes
+
+- Updated dependencies [db5d7e9]
+  - @usebutr/core@0.2.2
+  - @usebutr/wallet-standard-shared@0.2.2
+
+## 0.2.1
+
+### Patch Changes
+
+- f846e77: Wallet-announced icons are trimmed of surrounding whitespace on ingestion. Some wallets ship data-URI icons with a leading newline, which strict consumers reject — Next.js's `<Image>` throws because `src` must not start with a control character. `@usebutr/core` exports a `sanitizeIcon` helper; the EIP-6963 and Wallet Standard adapters apply it, and an all-whitespace icon now resolves to `undefined` rather than a blank string.
+- Updated dependencies [f846e77]
+  - @usebutr/core@0.2.1
+  - @usebutr/wallet-standard-shared@0.2.1
+
+## 0.2.0
+
+### Minor Changes
+
+- b77a477: Shared Wallet Standard protocol types (`WalletStandardWallet`, `WalletStandardWalletAccount`, `WalletStandardAppModule`, `WalletsApp`, `StandardConnectFeature`, `StandardDisconnectFeature`, `StandardEventsFeature`, `StandardEventsListener`) are imported from `@usebutr/wallet-standard-shared` directly — they are no longer re-exported from `@usebutr/svm`, `@usebutr/sui`, or `@usebutr/bitcoin`. Platform-specific feature shapes still ship from their own packages.
+
+  `@usebutr/svm` adapter ids are now platform-prefixed (`wallet-standard:svm-<slug>`), consistent with the `sui-` and `btc-` prefixes. `slugify` in `@usebutr/wallet-standard-shared` requires a non-empty platform prefix.
+
+### Patch Changes
+
+- Updated dependencies [b77a477]
+- Updated dependencies [b77a477]
+  - @usebutr/core@0.2.0
+  - @usebutr/wallet-standard-shared@0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pedro Filho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,39 @@
+# @usebutr/bitcoin
+
+Wallet Standard + injected (sats-connect / Unisat / OKX) wallet discovery and adapters for butr (Bitcoin).
+
+Part of [butr](https://www.usebutr.com), a multi-chain wallet discovery and
+connection-state library. Your application owns the picker UI and chain client.
+
+## Install
+
+```bash
+npm install @usebutr/react @usebutr/core @usebutr/bitcoin zustand @wallet-standard/app
+```
+
+React 18+ is a peer dependency of the provider. Discovery does not render a connect modal; add your picker as the provider child. `@wallet-standard/app` is required for Wallet Standard discovery.
+
+## Usage
+
+```tsx
+import type { ReactNode } from "react";
+import { createWalletSource } from "@usebutr/core";
+import { discoverBitcoinAdapters } from "@usebutr/bitcoin";
+import { WalletManagerProvider } from "@usebutr/react";
+
+const discovery = createWalletSource(discoverBitcoinAdapters);
+export const WalletProvider = ({ children }: { children: ReactNode }) => (
+  <WalletManagerProvider discovery={discovery}>{children}</WalletManagerProvider>
+);
+```
+
+## Documentation
+
+- [Package reference](https://docs.usebutr.com/api/bitcoin)
+- [Getting started](https://docs.usebutr.com/getting-started/quickstart)
+- [Examples and source](https://github.com/pedroapfilho/usebutr)
+- [Report an issue](https://github.com/pedroapfilho/usebutr/issues)
+
+## License
+
+[MIT](./LICENSE), copyright 2026 Pedro Filho.

package/dist/index.d.ts

@@ -11,6 +11,7 @@ type BitcoinSignMessageOutput = {
 };
 type BitcoinSignMessageFeature = {
   signMessage: (input: BitcoinSignMessageInput) => Promise<BitcoinSignMessageOutput>;
+  version?: string;
 };
 type BitcoinSignPsbtInput = {
   account: WalletStandardWalletAccount;
@@ -29,6 +30,7 @@ type BitcoinSignPsbtOutput = {
 };
 type BitcoinSignPsbtFeature = {
   signPsbt: (input: BitcoinSignPsbtInput) => Promise<BitcoinSignPsbtOutput>;
+  version?: string;
 };
 type BitcoinSendTransferInput = {
   account: WalletStandardWalletAccount;
@@ -42,73 +44,28 @@ type BitcoinSendTransferOutput = {
 };
 type BitcoinSendTransferFeature = {
   sendTransfer: (input: BitcoinSendTransferInput) => Promise<BitcoinSendTransferOutput>;
+  version?: string;
 };
 //#endregion
 //#region src/wallet-standard-adapter.d.ts
 /**
- * Adapt a Bitcoin Wallet Standard `Wallet` into a butr `WalletAdapter`.
- *
- * Returns `null` if the wallet doesn't advertise any `bip122:` chain or
- * doesn't expose `standard:connect`. Same posture as the SVM/Sui
- * adapters: gate features on what each wallet advertises, return
- * placeholders for RPC reads, forward `subscribe` through
- * `standard:events`.
- *
- * **Known limitations**
- *
- *  - `getBalance` returns `{ value: 0n, symbol: "BTC" }`. Bitcoin
- *    balance lookups require an Esplora/Electrum/RPC client outside
- *    butr's scope.
- *  - `getTransactionReceipt` returns `"Pending"` for the same reason.
- *  - `sendTx` expects the consumer to pass `{ amount: bigint, recipient: string }`
- *    via butr's `unknown` tx parameter; the simplest mental model that
- *    maps onto `bitcoin:sendTransfer`. PSBT-shaped flows go through
- *    `signTransaction`.
- *  - `signTransaction` expects a `Uint8Array` PSBT (raw bytes); the
- *    same shape `bitcoin:signPsbt` accepts. Consumers building with
- *    `bitcoinjs-lib` get bytes via `psbt.toBuffer()`.
- *  - `switchChain` is local-state-only; the capability flag is `false`
- *    when only one chain is advertised. Wallets that ship a real switch
- *    primitive (none today, portably) would need their own adapter.
+ * `sendTx` takes `{ amount, recipient }` for `bitcoin:sendTransfer` and
+ * `signTransaction` takes raw PSBT bytes for `bitcoin:signPsbt`. Balance
+ * and receipt reads would need an Esplora/Electrum client butr doesn't ship.
  */
 declare const buildBitcoinAdapter: (wallet: WalletStandardWallet,
 /** Optional. Called with a function that pushes a synthetic
  *  `disconnected` event to all current subscribers. The discovery
  *  layer invokes it on Wallet Standard `unregister`. */
 registerDisconnector?: (emit: () => void) => void) => WalletAdapter | null;
-/**
- * Subscribe to Bitcoin Wallet Standard announcements.
- *
- * Phantom (Bitcoin), Magic Eden, OKX Wallet (Bitcoin), and Leather
- * advertise `bitcoin:*` features over the same `getWallets()` bus that
- * SVM and Sui consume. `buildBitcoinAdapter` returns `null` for wallets
- * that don't advertise any `bip122:` chain, so multi-chain wallets
- * (Phantom: EVM + SVM + Sui + Bitcoin) produce one adapter per platform.
- *
- * Requires the **optional peer dependency** `@wallet-standard/app`.
- *
- * The discovery loop (dynamic import, dedupe, register / unregister
- * bridge) lives in `@usebutr/wallet-standard-shared`.
- */
+/** Requires the optional `@wallet-standard/app` peer dep. */
 declare const discoverBitcoinAdapters: (onAdapter: (adapter: WalletAdapter) => void) => (() => void);
 //#endregion
 //#region src/chains.d.ts
 /**
- * CAIP-2 Bitcoin chain references use the first 8 bytes (big-endian)
- * of each network's genesis block hash. These string ids are what
- * Bitcoin Wallet Standard wallets (Phantom, Magic Eden, OKX) advertise
- * in `wallet.chains`; the adapter's `switchChain` rejects anything else.
- *
- * - Mainnet:  `bip122:000000000019d6689c085ae165831e93`
- * - Testnet:  `bip122:000000000933ea01ad0ee984209779ba`
- * - Signet:   `bip122:00000008819873e925422c1ff0f99f7c`
- *
- * Bitcoin has no per-call "switch chain" RPC across the major wallets,
- * so butr's adapter treats chain as a wallet-side configuration;
- * `switchChain` updates local state to influence subsequent calls (same
- * posture as SVM). Bitcoin's `switchChain` capability is `false` by
- * default; consumers building on top can opt in if their wallet exposes
- * a switch primitive.
+ * CAIP-2 Bitcoin references are the first 8 bytes of each network's
+ * genesis block hash, which is what wallets advertise in `wallet.chains`.
+ * No major wallet exposes a switch-chain RPC, so chain stays local state.
  */
 declare const BITCOIN_CHAINS: {
   readonly mainnet: {
@@ -143,30 +100,23 @@ type BitcoinCapabilityInput = {
   };
 };
 /**
- * Bitcoin feature → butr capability mapping. The flags that hold for every
- * namespace are documented on `buildWalletCapabilities`.
- *
- * - `sendTransaction = bitcoin:sendTransfer present`. The wallet handles
- *   UTXO selection, fee estimation, signing, and broadcast.
- * - `signTransaction = bitcoin:signPsbt present`. Sign-only PSBT path
- *   for consumers that build their own UTXO-shaped transactions with
- *   `bitcoinjs-lib` and broadcast through their own provider.
- * - `signMessage = bitcoin:signMessage present`.
- * - `signIn = false`. No Sign-In-With-Bitcoin standard yet (BIP-322 is
- *   message-signing oriented, not auth).
- * - `subscribe = events present`. Most Bitcoin wallets don't emit
- *   change events portably; capabilities admits the truth.
+ * `signIn` is false: there is no Sign-In-With-Bitcoin standard, and BIP-322
+ * is message-signing oriented rather than auth. `sendTransfer` leaves UTXO
+ * selection, fees and broadcast to the wallet; `signPsbt` is sign-only.
  */
 declare const resolveBitcoinCapabilities: (input: BitcoinCapabilityInput) => WalletCapabilities;
 //#endregion
 //#region src/injected/sats-connect.d.ts
 /** sats-connect (Xverse) shape; a JSON-RPC-ish `request(method, params)`. */
+type RpcValue = boolean | number | string | null | ReadonlyArray<RpcValue> | {
+  readonly [key: string]: RpcValue | undefined;
+};
 type SatsConnectProvider = {
-  request: (method: string, params?: Record<string, unknown>) => Promise<{
+  request: (method: string, params?: Readonly<Record<string, RpcValue>>) => Promise<{
     error?: {
       message: string;
     };
-    result?: unknown;
+    result?: RpcValue;
   }>;
 };
 //#endregion
@@ -177,24 +127,24 @@ type SatsConnectProvider = {
 type UnisatProvider = {
   getAccounts: () => Promise<ReadonlyArray<string>>;
   getNetwork?: () => Promise<"livenet" | "mainnet" | "testnet" | "signet">;
-  on?: (event: "accountsChanged" | "networkChanged", listener: (...args: Array<unknown>) => void) => void;
+  on?: (event: "accountsChanged" | "networkChanged", listener: (...args: Array<UnisatEventValue>) => void) => void;
   pushPsbt?: (psbtHex: string) => Promise<string>;
-  removeListener?: (event: "accountsChanged" | "networkChanged", listener: (...args: Array<unknown>) => void) => void;
+  removeListener?: (event: "accountsChanged" | "networkChanged", listener: (...args: Array<UnisatEventValue>) => void) => void;
   requestAccounts: () => Promise<ReadonlyArray<string>>;
   sendBitcoin?: (recipient: string, amount: number) => Promise<string>;
   signMessage: (message: string, type?: "ecdsa" | "bip322-simple") => Promise<string>;
-  signPsbt: (psbtHex: string, options?: Record<string, unknown>) => Promise<string>;
+  signPsbt: (psbtHex: string, options?: UnisatSignPsbtOptions) => Promise<string>;
+};
+type UnisatEventItem = number | string | null;
+type UnisatEventValue = ReadonlyArray<UnisatEventItem> | string | undefined;
+type UnisatSignPsbtOptions = {
+  autoFinalized?: boolean;
 };
 //#endregion
 //#region src/injected/icon.d.ts
 /**
- * Generic Bitcoin wallet icon, same purse SVG style as the EVM
- * package, recoloured. Inline so the picker doesn't flash.
- *
- * Lives in its own file because both injected adapters (UniSat-shape
- * and sats-connect) need the same fallback when the wallet doesn't
- * advertise its own icon, and there's no other "shared" thing they
- * both want; a one-line module beats a grab-bag.
+ * Inlined as a data URI so the picker doesn't flash, and shared by both
+ * injected adapters as the fallback when a wallet advertises no icon.
  */
 declare const GENERIC_BITCOIN_ICON = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0iI2Y3OTMxYSIgc3Ryb2tlPSJub25lIj48Y2lyY2xlIGN4PSIxMiIgY3k9IjEyIiByPSIxMCIvPjx0ZXh0IHg9IjEyIiB5PSIxNyIgZm9udC1mYW1pbHk9InNlcmlmIiBmb250LXNpemU9IjE0IiBmb250LXdlaWdodD0iYm9sZCIgZmlsbD0iI2ZmZiIgdGV4dC1hbmNob3I9Im1pZGRsZSI+QjwvdGV4dD48L3N2Zz4=";
 //#endregion
@@ -209,6 +159,18 @@ type InjectedHost = {
     BitcoinProvider?: SatsConnectProvider;
   };
 };
+declare global {
+  interface Window {
+    btc?: UnisatProvider;
+    okxwallet?: {
+      bitcoin?: UnisatProvider;
+    };
+    unisat?: UnisatProvider;
+    XverseProviders?: {
+      BitcoinProvider?: SatsConnectProvider;
+    };
+  }
+}
 type InjectedBitcoinDiscoveryOptions = {
   /** Suppresses emission when Wallet Standard discovery has already
    *  registered a Bitcoin adapter for the same browser session. */
@@ -220,64 +182,29 @@ type InjectedBitcoinDiscoveryOptions = {
   target?: InjectedHost | null;
 };
 /**
- * Last-resort discovery path for Bitcoin wallets that DON'T announce via
- * Wallet Standard. Probes, in order: `window.unisat`,
- * `window.okxwallet.bitcoin`, `window.XverseProviders.BitcoinProvider`,
- * `window.btc`.
- *
- * Wallet Standard wallets (Phantom, Magic Eden, Leather, modern OKX
- * builds) are already handled by `discoverBitcoinAdapters`. This
- * fallback waits `settleMs` (default 150ms), consults
- * `hasAnyWalletStandardAdapter` if provided, and emits adapters for
- * any injected providers that weren't already covered.
- *
- * Each emitted adapter has a stable id prefix (`injected:bitcoin:*`)
- * so consumers can distinguish them in the picker UI.
+ * Last-resort path for wallets that don't announce via Wallet Standard:
+ * `window.unisat`, OKX, Xverse, `window.btc`. The `settleMs` wait lets
+ * Wallet Standard announce first, else a wallet on both channels lists twice.
  */
 declare const discoverInjectedBitcoinAdapter: (onAdapter: (adapter: WalletAdapter) => void, options?: InjectedBitcoinDiscoveryOptions) => (() => void);
 //#endregion
 //#region src/discoverer.d.ts
 /**
- * Bitcoin's `PlatformDiscoverer`: Wallet Standard primary (Phantom,
- * Magic Eden, Leather, OKX); legacy fallback covers sats-connect
- * (Xverse), `window.unisat`, OKX legacy, and `window.btc`. The
- * fallback defers to Wallet Standard via `hasAnyPrimaryAdapter`.
+ * Wallet Standard is primary; the legacy fallback covers sats-connect
+ * (Xverse), `window.unisat`, OKX legacy and `window.btc`, and defers to
+ * the primary channel via `hasAnyPrimaryAdapter`.
  */
 declare const bitcoinDiscoverer: PlatformDiscoverer;
 //#endregion
 //#region src/signer-augmentation.d.ts
 /**
- * Augment `@usebutr/core`'s `SignerForPlatform` registry with the Bitcoin
- * entry. Bitcoin's signer surface is fragmented: `getSigner()` may
- * return one of three shapes depending on which adapter discovered the
- * wallet:
- *
- *  - `WalletStandardWallet`: for Phantom, Magic Eden, Leather, OKX
- *    (modern Wallet Standard path).
- *  - A UniSat-shaped provider; for Unisat, OKX legacy, `window.btc`
- *    (injected path).
- *  - A sats-connect `BitcoinProvider`; for Xverse (sats-connect path).
- *
- * The registry surfaces the union honestly so consumers know they need
- * to runtime-narrow.
+ * Bitcoin's signer surface is fragmented: `getSigner()` returns a
+ * `WalletStandardWallet`, a UniSat-shaped provider, or a sats-connect
+ * `BitcoinProvider` depending on which adapter discovered the wallet.
  */
-type UnisatLike = {
-  getAccounts: () => Promise<ReadonlyArray<string>>;
-  requestAccounts: () => Promise<ReadonlyArray<string>>;
-  signMessage: (message: string, type?: string) => Promise<string>;
-  signPsbt: (psbtHex: string, options?: Record<string, unknown>) => Promise<string>;
-};
-type SatsConnectLike = {
-  request: (method: string, params?: Record<string, unknown>) => Promise<{
-    error?: {
-      message: string;
-    };
-    result?: unknown;
-  }>;
-};
 declare module "@usebutr/core" {
   interface SignerForPlatform {
-    bitcoin: SatsConnectLike | UnisatLike | WalletStandardWallet;
+    bitcoin: SatsConnectProvider | UnisatProvider | WalletStandardWallet;
   }
 }
 //#endregion

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/wallet-standard-types.ts","../src/wallet-standard-adapter.ts","../src/chains.ts","../src/capabilities.ts","../src/injected/sats-connect.ts","../src/injected/unisat.ts","../src/injected/icon.ts","../src/injected/index.ts","../src/discoverer.ts","../src/signer-augmentation.ts"],"mappings":";;;KAgBK;EACH,SAAS;EACT,SAAS;;KAGN;EACH,WAAW;EACX,eAAe;;KAGZ;EACH,cAAc,OAAO,4BAA4B,QAAQ;;KAGtD;EACH,SAAS;;EAET;;EAEA,MAAM;;;EAGN,aAAa;;KAGV;;;EAGH,YAAY;;KAGT;EACH,WAAW,OAAO,yBAAyB,QAAQ;;KAGhD;EACH,SAAS;EACT;EACA;EACA;;KAGG;;EAEH;;KAGG;EACH,eAAe,OAAO,6BAA6B,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cClBvD,sBACJ,QAAQ,sBAIR;;;;AAAA,wBAAwB,8BACvB;;;;;;;;;;;;;;;cAiIG,0BAA2B,YAAY,SAAS;;;;;;;;;;;;;;;;;;;;cClKhD;;;;;;;;;;;;;;;;;;;;cAqBA,qBAAqB,cAAc;;;KCrCpC;EACH;EACA;IACE;IACA;IACA;IACA;;;;;;;;;;;;;;;;;;cAmBE,6BAA8B,OAAO,2BAAyB;;;;KCnB/D;EACH,UACE,gBACA,SAAS,4BACN;IAAU;MAAU;;IAAmB;;;;;;;;KCFzC;EACH,mBAAmB,QAAQ;EAC3B,mBAAmB;EACnB,MACE,6CACA,cAAc,MAAM;EAEtB,YAAY,oBAAoB;EAChC,kBACE,6CACA,cAAc,MAAM;EAEtB,uBAAuB,QAAQ;EAC/B,eAAe,mBAAmB,mBAAmB;EACrD,cAAc,iBAAiB,qCAAqC;EACpE,WAAW,iBAAiB,UAAU,4BAA4B;;;;;;;;;;;;;cCjB9D;;;KCAD;EACH,MAAM;EACN;IAAc,UAAU;;EACxB,SAAS;EACT;IAAoB,kBAAkB;;;KAGnC;;;EAGH;;;EAGA;;EAEA,SAAS;;;;;;;;;;;;;;;;;cA+DL,iCACJ,YAAY,SAAS,wBACrB,UAAS;;;;;;;;;cC9EL,mBAAmB;;;;;;;;;;;;;;;;;;KCMpB;EACH,mBAAmB,QAAQ;EAC3B,uBAAuB,QAAQ;EAC/B,cAAc,iBAAiB,kBAAkB;EACjD,WAAW,iBAAiB,UAAU,4BAA4B;;KAG/D;EACH,UACE,gBACA,SAAS,4BACN;IAAU;MAAU;;IAAmB;;;;YAKlC;IACR,SAAS,kBAAkB,aAAa"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/wallet-standard-types.ts","../src/wallet-standard-adapter.ts","../src/chains.ts","../src/capabilities.ts","../src/injected/sats-connect.ts","../src/injected/unisat.ts","../src/injected/icon.ts","../src/injected/index.ts","../src/discoverer.ts","../src/signer-augmentation.ts"],"mappings":";;;KAQK;EACH,SAAS;EACT,SAAS;;KAGN;EACH,WAAW;EACX,eAAe;;KAGZ;EACH,cAAc,OAAO,4BAA4B,QAAQ;EACzD;;KAGG;EACH,SAAS;;EAET;;EAEA,MAAM;;;EAGN,aAAa;;KAGV;;;EAGH,YAAY;;KAGT;EACH,WAAW,OAAO,yBAAyB,QAAQ;EACnD;;KAGG;EACH,SAAS;EACT;EACA;EACA;;KAGG;;EAEH;;KAGG;EACH,eAAe,OAAO,6BAA6B,QAAQ;EAC3D;;;;;;;;;cCnBI,sBAAmB,QACf,sBAIe;;;;AAAA,wBAAC,8BACvB;;cAuIG,0BAAuB,YAAgB,SAAS;;;;;;;;cC9KhD;;aAEF;aACA;aACA;aACA;;;aAGA;aACA;aACA;aACA;;;aAGA;aACA;aACA;aACA;;;cAIE,qBAAqB,cAAc;;;KCzBpC;EACH;EACA;IACE;IACA;IACA;IACA;;;;;;;;cASE,6BAA0B,OAAW,2BAAyB;;;;KCF/D,8CAKD,cAAc;YACF,cAAc;;KAEzB;EACH,UACE,gBACA,SAAS,SAAS,eAAe,eAC9B;IAAU;MAAU;;IAAmB,SAAS;;;;;;;;KCjBlD;EACH,mBAAmB,QAAQ;EAC3B,mBAAmB;EACnB,MACE,6CACA,cAAc,MAAM,MAAM;EAE5B,YAAY,oBAAoB;EAChC,kBACE,6CACA,cAAc,MAAM,MAAM;EAE5B,uBAAuB,QAAQ;EAC/B,eAAe,mBAAmB,mBAAmB;EACrD,cAAc,iBAAiB,qCAAqC;EACpE,WAAW,iBAAiB,UAAU,0BAA0B;;KAG7D;KACA,mBAAmB,cAAc;KAEjC;EACH;;;;;;;;cC7BI;;;KCKD;EACH,MAAM;EACN;IAAc,UAAU;;EACxB,SAAS;EACT;IAAoB,kBAAkB;;;QAGhC;YAEI;IACR,MAAM;IACN;MAAc,UAAU;;IACxB,SAAS;IACT;MAAoB,kBAAkB;;;;KAIrC;;;EAGH;;;EAGA;;EAEA,SAAS;;;;;;;cAiDL,iCAA8B,YACtB,SAAS,wBAAsB,UAClC;;;;;;;;cC3EL,mBAAmB;;;;;;;;;YCEb;IACR,SAAS,sBAAsB,iBAAiB"}

package/dist/index.js

@@ -1,21 +1,12 @@
 import { buildAccount, buildWalletCapabilities, createWalletStandardCore, discoverWalletStandard, getFeature, slugify } from "@usebutr/wallet-standard-shared";
 import { base64ToBytes, bytesToBase64, bytesToHex, hexToBytes } from "@usebutr/core";
+import { z } from "zod";
 
 //#region src/capabilities.ts
 /**
-* Bitcoin feature → butr capability mapping. The flags that hold for every
-* namespace are documented on `buildWalletCapabilities`.
-*
-* - `sendTransaction = bitcoin:sendTransfer present`. The wallet handles
-*   UTXO selection, fee estimation, signing, and broadcast.
-* - `signTransaction = bitcoin:signPsbt present`. Sign-only PSBT path
-*   for consumers that build their own UTXO-shaped transactions with
-*   `bitcoinjs-lib` and broadcast through their own provider.
-* - `signMessage = bitcoin:signMessage present`.
-* - `signIn = false`. No Sign-In-With-Bitcoin standard yet (BIP-322 is
-*   message-signing oriented, not auth).
-* - `subscribe = events present`. Most Bitcoin wallets don't emit
-*   change events portably; capabilities admits the truth.
+* `signIn` is false: there is no Sign-In-With-Bitcoin standard, and BIP-322
+* is message-signing oriented rather than auth. `sendTransfer` leaves UTXO
+* selection, fees and broadcast to the wallet; `signPsbt` is sign-only.
 */
 const resolveBitcoinCapabilities = (input) => buildWalletCapabilities({
 	chainCount: input.chainCount,
@@ -31,31 +22,13 @@ const resolveBitcoinCapabilities = (input) => buildWalletCapabilities({
 const BITCOIN_PREFIX = "bip122:";
 const BITCOIN_DECIMALS = 8;
 const BITCOIN_MAINNET_ID = "bip122:000000000019d6689c085ae165831e93";
+const isBitcoinSignMessageFeature = (feature) => "signMessage" in feature && typeof feature.signMessage === "function";
+const isBitcoinSignPsbtFeature = (feature) => "signPsbt" in feature && typeof feature.signPsbt === "function";
+const isBitcoinSendTransferFeature = (feature) => "sendTransfer" in feature && typeof feature.sendTransfer === "function";
 /**
-* Adapt a Bitcoin Wallet Standard `Wallet` into a butr `WalletAdapter`.
-*
-* Returns `null` if the wallet doesn't advertise any `bip122:` chain or
-* doesn't expose `standard:connect`. Same posture as the SVM/Sui
-* adapters: gate features on what each wallet advertises, return
-* placeholders for RPC reads, forward `subscribe` through
-* `standard:events`.
-*
-* **Known limitations**
-*
-*  - `getBalance` returns `{ value: 0n, symbol: "BTC" }`. Bitcoin
-*    balance lookups require an Esplora/Electrum/RPC client outside
-*    butr's scope.
-*  - `getTransactionReceipt` returns `"Pending"` for the same reason.
-*  - `sendTx` expects the consumer to pass `{ amount: bigint, recipient: string }`
-*    via butr's `unknown` tx parameter; the simplest mental model that
-*    maps onto `bitcoin:sendTransfer`. PSBT-shaped flows go through
-*    `signTransaction`.
-*  - `signTransaction` expects a `Uint8Array` PSBT (raw bytes); the
-*    same shape `bitcoin:signPsbt` accepts. Consumers building with
-*    `bitcoinjs-lib` get bytes via `psbt.toBuffer()`.
-*  - `switchChain` is local-state-only; the capability flag is `false`
-*    when only one chain is advertised. Wallets that ship a real switch
-*    primitive (none today, portably) would need their own adapter.
+* `sendTx` takes `{ amount, recipient }` for `bitcoin:sendTransfer` and
+* `signTransaction` takes raw PSBT bytes for `bitcoin:signPsbt`. Balance
+* and receipt reads would need an Esplora/Electrum client butr doesn't ship.
 */
 const buildBitcoinAdapter = (wallet, registerDisconnector) => {
 	const core = createWalletStandardCore({
@@ -70,21 +43,28 @@ const buildBitcoinAdapter = (wallet, registerDisconnector) => {
 		wallet
 	});
 	if (core === null) return null;
-	const signMessage = getFeature(wallet, "bitcoin:signMessage");
-	const signPsbt = getFeature(wallet, "bitcoin:signPsbt");
-	const sendTransfer = getFeature(wallet, "bitcoin:sendTransfer");
-	const sendTransferTx = async (tx, account) => {
+	const signMessage = getFeature(wallet, "bitcoin:signMessage", isBitcoinSignMessageFeature);
+	const signPsbt = getFeature(wallet, "bitcoin:signPsbt", isBitcoinSignPsbtFeature);
+	const sendTransfer = getFeature(wallet, "bitcoin:sendTransfer", isBitcoinSendTransferFeature);
+	/** Resolve a caller-supplied target into a chain the wallet advertises,
+	*  accepting either a full CAIP-2 id or a bare genesis-hash reference. */
+	const resolveTargetChain = (targetChainId) => {
+		const candidate = targetChainId.startsWith(BITCOIN_PREFIX) ? targetChainId : `${BITCOIN_PREFIX}${targetChainId}`;
+		if (!wallet.chains.includes(candidate)) throw new Error(`Wallet ${wallet.name} does not advertise chain "${candidate}". Available: ${wallet.chains.join(", ")}`);
+		return candidate;
+	};
+	const sendTransferTx = async (tx, account, chain) => {
 		if (sendTransfer === void 0) throw new Error(`Wallet ${wallet.name} does not advertise bitcoin:sendTransfer`);
 		if (typeof tx !== "object" || tx === null || !("amount" in tx) || typeof tx.amount !== "bigint" || !("recipient" in tx) || typeof tx.recipient !== "string") throw new TypeError("Bitcoin sendTx expects { amount: bigint, recipient: string }: pass the recipient address and an amount in satoshis");
 		const { amount, recipient } = tx;
 		return (await sendTransfer.sendTransfer({
 			account: core.resolveAccount(account),
 			amount,
-			chain: core.currentChainId(),
+			chain: chain ?? core.currentChainId(),
 			recipient
 		})).txid;
 	};
-	return {
+	const adapter = {
 		...core,
 		capabilities: resolveBitcoinCapabilities({
 			chainCount: core.chainCount,
@@ -107,9 +87,10 @@ const buildBitcoinAdapter = (wallet, registerDisconnector) => {
 			await core.connect();
 		},
 		sendTx: (tx, account) => sendTransferTx(tx, account),
-		sendTxToChain: (tx, _targetChainId, account, cb) => {
-			cb?.();
-			return sendTransferTx(tx, account);
+		async sendTxToChain(tx, targetChainId, account, cb) {
+			const target = resolveTargetChain(targetChainId);
+			if (target !== core.currentChainId()) cb?.();
+			return await sendTransferTx(tx, account, target);
 		},
 		async signMessage(msg, account) {
 			if (signMessage === void 0) throw new Error(`Wallet ${wallet.name} does not advertise bitcoin:signMessage`);
@@ -121,52 +102,28 @@ const buildBitcoinAdapter = (wallet, registerDisconnector) => {
 				signature: output.signature,
 				signedMessage: output.signedMessage
 			};
-		},
-		...signPsbt === void 0 ? {} : { async signTransaction(tx, account) {
-			const wsAccount = core.resolveAccount(account);
-			if (!(tx instanceof Uint8Array)) throw new TypeError("Bitcoin signTransaction expects a PSBT as Uint8Array (e.g. psbt.toBuffer())");
-			return (await signPsbt.signPsbt({
-				account: wsAccount,
-				chain: core.currentChainId(),
-				psbt: tx
-			})).signedPsbt;
-		} }
+		}
 	};
+	if (signPsbt !== void 0) adapter.signTransaction = async (tx, account) => {
+		const wsAccount = core.resolveAccount(account);
+		if (!(tx instanceof Uint8Array)) throw new TypeError("Bitcoin signTransaction expects a PSBT as Uint8Array (e.g. psbt.toBuffer())");
+		return (await signPsbt.signPsbt({
+			account: wsAccount,
+			chain: core.currentChainId(),
+			psbt: tx
+		})).signedPsbt;
+	};
+	return adapter;
 };
-/**
-* Subscribe to Bitcoin Wallet Standard announcements.
-*
-* Phantom (Bitcoin), Magic Eden, OKX Wallet (Bitcoin), and Leather
-* advertise `bitcoin:*` features over the same `getWallets()` bus that
-* SVM and Sui consume. `buildBitcoinAdapter` returns `null` for wallets
-* that don't advertise any `bip122:` chain, so multi-chain wallets
-* (Phantom: EVM + SVM + Sui + Bitcoin) produce one adapter per platform.
-*
-* Requires the **optional peer dependency** `@wallet-standard/app`.
-*
-* The discovery loop (dynamic import, dedupe, register / unregister
-* bridge) lives in `@usebutr/wallet-standard-shared`.
-*/
+/** Requires the optional `@wallet-standard/app` peer dep. */
 const discoverBitcoinAdapters = (onAdapter) => discoverWalletStandard(onAdapter, (wallet, registerDisconnector) => buildBitcoinAdapter(wallet, registerDisconnector));
 
 //#endregion
 //#region src/chains.ts
 /**
-* CAIP-2 Bitcoin chain references use the first 8 bytes (big-endian)
-* of each network's genesis block hash. These string ids are what
-* Bitcoin Wallet Standard wallets (Phantom, Magic Eden, OKX) advertise
-* in `wallet.chains`; the adapter's `switchChain` rejects anything else.
-*
-* - Mainnet:  `bip122:000000000019d6689c085ae165831e93`
-* - Testnet:  `bip122:000000000933ea01ad0ee984209779ba`
-* - Signet:   `bip122:00000008819873e925422c1ff0f99f7c`
-*
-* Bitcoin has no per-call "switch chain" RPC across the major wallets,
-* so butr's adapter treats chain as a wallet-side configuration;
-* `switchChain` updates local state to influence subsequent calls (same
-* posture as SVM). Bitcoin's `switchChain` capability is `false` by
-* default; consumers building on top can opt in if their wallet exposes
-* a switch primitive.
+* CAIP-2 Bitcoin references are the first 8 bytes of each network's
+* genesis block hash, which is what wallets advertise in `wallet.chains`.
+* No major wallet exposes a switch-chain RPC, so chain stays local state.
 */
 const BITCOIN_CHAINS = {
 	mainnet: {
@@ -193,13 +150,8 @@ const BITCOIN_CHAINS_LIST = Object.values(BITCOIN_CHAINS);
 //#endregion
 //#region src/injected/icon.ts
 /**
-* Generic Bitcoin wallet icon, same purse SVG style as the EVM
-* package, recoloured. Inline so the picker doesn't flash.
-*
-* Lives in its own file because both injected adapters (UniSat-shape
-* and sats-connect) need the same fallback when the wallet doesn't
-* advertise its own icon, and there's no other "shared" thing they
-* both want; a one-line module beats a grab-bag.
+* Inlined as a data URI so the picker doesn't flash, and shared by both
+* injected adapters as the fallback when a wallet advertises no icon.
 */
 const GENERIC_BITCOIN_ICON = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0iI2Y3OTMxYSIgc3Ryb2tlPSJub25lIj48Y2lyY2xlIGN4PSIxMiIgY3k9IjEyIiByPSIxMCIvPjx0ZXh0IHg9IjEyIiB5PSIxNyIgZm9udC1mYW1pbHk9InNlcmlmIiBmb250LXNpemU9IjE0IiBmb250LXdlaWdodD0iYm9sZCIgZmlsbD0iI2ZmZiIgdGV4dC1hbmNob3I9Im1pZGRsZSI+QjwvdGV4dD48L3N2Zz4=";
 
@@ -217,37 +169,65 @@ const CAPS_SATS_CONNECT = {
 	switchAccount: false,
 	switchChain: false
 };
+const ACCOUNT_PURPOSES = ["payment", "ordinals"];
+const CONNECT_MESSAGE = "Connect to butr";
+const satsAddressSchema = z.object({
+	address: z.string(),
+	publicKey: z.string().optional(),
+	purpose: z.string().optional()
+});
+const accountResultSchema = z.object({ addresses: z.array(satsAddressSchema).optional() }).nullable();
+const sendTransferResultSchema = z.object({ txid: z.string() });
+const signMessageResultSchema = z.object({
+	messageHash: z.string().optional(),
+	signature: z.string()
+});
+const signPsbtResultSchema = z.object({ psbt: z.string() });
+const pickPaymentAddress = (addresses) => addresses.find((a) => a.purpose === "payment") ?? addresses[0];
 /**
-* Wrap an Xverse-style `BitcoinProvider` (sats-connect) into a butr
-* `WalletAdapter`. sats-connect routes everything through a single
-* `request(method, params)` RPC; we shim each butr capability onto the
-* corresponding sats-connect method.
-*
-* Tested against Xverse's `getAccounts`, `signMessage`, `signPsbt`,
-* `sendTransfer` methods.
+* Only the payment address is exposed as an Account: sats-connect's
+* `sendTransfer` takes no sender and always debits it. The taproot ordinals
+* address stays reachable through `getSigner()` and `signMessage`'s account.
 */
 const buildSatsConnectAdapter = (id, name, provider) => {
 	let chain = BITCOIN_CHAINS.mainnet;
-	let cachedAccounts = [];
-	const callRequest = async (method, params) => {
+	let session = { status: "disconnected" };
+	const callRequest = async (method, schema, params) => {
 		const response = await provider.request(method, params);
 		if (response.error) throw new Error(`[butr/bitcoin] sats-connect ${method} failed: ${response.error.message}`);
-		return response.result;
+		return schema.parse(response.result);
+	};
+	const startSession = async (method, params) => {
+		const addresses = (await callRequest(method, accountResultSchema, params))?.addresses ?? [];
+		const payment = pickPaymentAddress(addresses);
+		if (payment === void 0) throw new Error(`Wallet ${name} returned no addresses from ${method}`);
+		session = {
+			addresses,
+			payment: payment.address,
+			status: "connected"
+		};
 	};
-	const loadAccounts = async () => {
-		const result = await callRequest("getAccounts", {
-			message: "Connect to butr",
-			purposes: ["payment", "ordinals"]
-		});
-		if (result?.addresses === void 0) return [];
-		const addresses = result.addresses.map((a) => a.address);
-		cachedAccounts = addresses;
-		return addresses;
+	const requestSession = () => startSession("getAccounts", {
+		message: CONNECT_MESSAGE,
+		purposes: ACCOUNT_PURPOSES
+	});
+	const requireSession = () => {
+		if (session.status !== "connected") throw new Error("No connected account");
+		return session;
 	};
-	const sendTransferTx = async (tx) => {
+	const resolveAddress = (account) => {
+		const active = requireSession();
+		if (account === void 0) return active.payment;
+		const match = active.addresses.find((a) => a.address === account.walletAddress);
+		if (match === void 0) throw new Error(`Account ${account.walletAddress} is not exposed by ${name}`);
+		return match.address;
+	};
+	const sendTransferTx = async (tx, account) => {
+		const sender = resolveAddress(account);
+		if (sender !== requireSession().payment) throw new Error(`Wallet ${name} always debits its payment address; ${sender} cannot be used as the sender.`);
 		if (typeof tx !== "object" || tx === null || !("recipient" in tx) || typeof tx.recipient !== "string" || !("amount" in tx) || typeof tx.amount !== "bigint") throw new TypeError("Bitcoin sendTx expects { amount: bigint, recipient: string }: amount in satoshis");
 		const { amount, recipient } = tx;
-		return (await callRequest("sendTransfer", { recipients: [{
+		return (await callRequest("sendTransfer", sendTransferResultSchema, { recipients: [{
 			address: recipient,
 			amount: amount.toString()
 		}] })).txid;
@@ -255,22 +235,19 @@ const buildSatsConnectAdapter = (id, name, provider) => {
 	return {
 		capabilities: CAPS_SATS_CONNECT,
 		chainPlatform: "bitcoin",
-		async connect() {
-			await loadAccounts();
+		async connect(opts) {
+			if (opts?.silent === true) {
+				await startSession("wallet_getAccount", { addresses: ACCOUNT_PURPOSES });
+				return;
+			}
+			await requestSession();
 		},
 		disconnect: () => {
-			cachedAccounts = [];
+			session = { status: "disconnected" };
 			return Promise.resolve();
 		},
-		async getAccount() {
-			const first = cachedAccounts[0];
-			if (first !== void 0) return buildAccount(first, chain);
-			const firstFresh = (await loadAccounts())[0];
-			return firstFresh === void 0 ? null : buildAccount(firstFresh, chain);
-		},
-		async getAccounts() {
-			return (cachedAccounts.length > 0 ? cachedAccounts : await loadAccounts()).map((a) => buildAccount(a, chain));
-		},
+		getAccount: () => Promise.resolve(session.status === "connected" ? buildAccount(session.payment, chain) : null),
+		getAccounts: () => Promise.resolve(session.status === "connected" ? [buildAccount(session.payment, chain)] : []),
 		getBalance: () => Promise.resolve({
 			decimals: 8,
 			formatted: "0",
@@ -282,18 +259,15 @@ const buildSatsConnectAdapter = (id, name, provider) => {
 		icon: GENERIC_BITCOIN_ICON,
 		id,
 		name,
-		async requestAccounts() {
-			await loadAccounts();
-		},
-		sendTx: (tx) => sendTransferTx(tx),
-		sendTxToChain: (tx, _targetChainId, _account, cb) => {
+		requestAccounts: () => requestSession(),
+		sendTx: (tx, account) => sendTransferTx(tx, account),
+		sendTxToChain: (tx, _targetChainId, account, cb) => {
 			cb?.();
-			return sendTransferTx(tx);
+			return sendTransferTx(tx, account);
 		},
-		async signMessage(msg) {
-			const address = cachedAccounts[0];
-			if (address === void 0) throw new Error("No connected account");
-			const result = await callRequest("signMessage", {
+		async signMessage(msg, account) {
+			const address = resolveAddress(account);
+			const result = await callRequest("signMessage", signMessageResultSchema, {
 				address,
 				message: new TextDecoder().decode(msg)
 			});
@@ -304,7 +278,7 @@ const buildSatsConnectAdapter = (id, name, provider) => {
 		},
 		async signTransaction(tx) {
 			if (!(tx instanceof Uint8Array)) throw new TypeError("Bitcoin signTransaction expects a PSBT as Uint8Array (e.g. psbt.toBuffer())");
-			const result = await callRequest("signPsbt", { psbt: bytesToBase64(tx) });
+			const result = await callRequest("signPsbt", signPsbtResultSchema, { psbt: bytesToBase64(tx) });
 			return base64ToBytes(result.psbt);
 		},
 		switchChain: (target) => {
@@ -329,23 +303,19 @@ const CAPS_UNISAT = {
 	switchAccount: false,
 	switchChain: false
 };
+const toStringArray = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 /**
-* Wrap a UniSat-style provider (`window.unisat`, `window.okxwallet.bitcoin`,
-* `window.btc`) into a butr `WalletAdapter`.
-*
-* The UniSat shape is consistent enough that one adapter handles every
-* derivative. Differences (network names, `sendBitcoin` presence) are
-* gated by feature detection per call.
+* The UniSat shape is consistent enough across `window.unisat`,
+* `window.okxwallet.bitcoin` and `window.btc` that one adapter covers all
+* three; the differences (network names, `sendBitcoin`) are probed per call.
 */
-const toStringArray = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 const buildUnisatAdapter = (id, name, provider) => {
 	let chain = BITCOIN_CHAINS.mainnet;
-	const listenersSet = /* @__PURE__ */ new Set();
-	const sendBitcoinTx = (tx) => {
+	const sendBitcoinTx = async (tx) => {
 		if (typeof provider.sendBitcoin !== "function") throw new TypeError(`Wallet ${name} does not expose sendBitcoin`);
 		if (typeof tx !== "object" || tx === null || !("recipient" in tx) || typeof tx.recipient !== "string" || !("amount" in tx) || typeof tx.amount !== "bigint") throw new TypeError("Bitcoin sendTx expects { amount: bigint, recipient: string }: amount in satoshis");
 		const { amount, recipient } = tx;
-		return provider.sendBitcoin(recipient, Number(amount));
+		return await provider.sendBitcoin(recipient, Number(amount));
 	};
 	const refreshChain = async () => {
 		if (typeof provider.getNetwork !== "function") return;
@@ -415,7 +385,6 @@ const buildUnisatAdapter = (id, name, provider) => {
 			return hexToBytes(signedHex);
 		},
 		subscribe(listener) {
-			listenersSet.add(listener);
 			const onAccountsChanged = (...args) => {
 				const accounts = toStringArray(args[0]);
 				if (accounts.length === 0) {
@@ -439,14 +408,12 @@ const buildUnisatAdapter = (id, name, provider) => {
 			return () => {
 				provider.removeListener?.("accountsChanged", onAccountsChanged);
 				provider.removeListener?.("networkChanged", onNetworkChanged);
-				listenersSet.delete(listener);
 			};
 		},
-		switchChain: (target) => {
+		async switchChain(target) {
 			if (target.namespace !== "bip122") throw new Error(`Bitcoin adapter received non-Bitcoin chain "${target.id}". Pass a chain with namespace "bip122".`);
 			chain = target;
-			refreshChain();
-			return Promise.resolve();
+			await refreshChain();
 		}
 	};
 };
@@ -483,19 +450,9 @@ const probeProviders = (host) => {
 	return adapters;
 };
 /**
-* Last-resort discovery path for Bitcoin wallets that DON'T announce via
-* Wallet Standard. Probes, in order: `window.unisat`,
-* `window.okxwallet.bitcoin`, `window.XverseProviders.BitcoinProvider`,
-* `window.btc`.
-*
-* Wallet Standard wallets (Phantom, Magic Eden, Leather, modern OKX
-* builds) are already handled by `discoverBitcoinAdapters`. This
-* fallback waits `settleMs` (default 150ms), consults
-* `hasAnyWalletStandardAdapter` if provided, and emits adapters for
-* any injected providers that weren't already covered.
-*
-* Each emitted adapter has a stable id prefix (`injected:bitcoin:*`)
-* so consumers can distinguish them in the picker UI.
+* Last-resort path for wallets that don't announce via Wallet Standard:
+* `window.unisat`, OKX, Xverse, `window.btc`. The `settleMs` wait lets
+* Wallet Standard announce first, else a wallet on both channels lists twice.
 */
 const discoverInjectedBitcoinAdapter = (onAdapter, options = {}) => {
 	const settleMs = options.settleMs ?? DEFAULT_SETTLE_MS;
@@ -517,10 +474,9 @@ const discoverInjectedBitcoinAdapter = (onAdapter, options = {}) => {
 //#endregion
 //#region src/discoverer.ts
 /**
-* Bitcoin's `PlatformDiscoverer`: Wallet Standard primary (Phantom,
-* Magic Eden, Leather, OKX); legacy fallback covers sats-connect
-* (Xverse), `window.unisat`, OKX legacy, and `window.btc`. The
-* fallback defers to Wallet Standard via `hasAnyPrimaryAdapter`.
+* Wallet Standard is primary; the legacy fallback covers sats-connect
+* (Xverse), `window.unisat`, OKX legacy and `window.btc`, and defers to
+* the primary channel via `hasAnyPrimaryAdapter`.
 */
 const bitcoinDiscoverer = {
 	fallback: { subscribe: (onAdapter, opts) => discoverInjectedBitcoinAdapter(onAdapter, { hasAnyWalletStandardAdapter: opts.hasAnyPrimaryAdapter }) },

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/capabilities.ts","../src/wallet-standard-adapter.ts","../src/chains.ts","../src/injected/icon.ts","../src/injected/sats-connect.ts","../src/injected/unisat.ts","../src/injected/index.ts","../src/discoverer.ts"],"sourcesContent":["import type { WalletCapabilities } from \"@usebutr/core\";\nimport { buildWalletCapabilities } from \"@usebutr/wallet-standard-shared\";\n\ntype BitcoinCapabilityInput = {\n  chainCount: number;\n  features: {\n    events: boolean;\n    sendTransfer: boolean;\n    signMessage: boolean;\n    signPsbt: boolean;\n  };\n};\n\n/**\n * Bitcoin feature → butr capability mapping. The flags that hold for every\n * namespace are documented on `buildWalletCapabilities`.\n *\n * - `sendTransaction = bitcoin:sendTransfer present`. The wallet handles\n *   UTXO selection, fee estimation, signing, and broadcast.\n * - `signTransaction = bitcoin:signPsbt present`. Sign-only PSBT path\n *   for consumers that build their own UTXO-shaped transactions with\n *   `bitcoinjs-lib` and broadcast through their own provider.\n * - `signMessage = bitcoin:signMessage present`.\n * - `signIn = false`. No Sign-In-With-Bitcoin standard yet (BIP-322 is\n *   message-signing oriented, not auth).\n * - `subscribe = events present`. Most Bitcoin wallets don't emit\n *   change events portably; capabilities admits the truth.\n */\nconst resolveBitcoinCapabilities = (input: BitcoinCapabilityInput): WalletCapabilities =>\n  buildWalletCapabilities({\n    chainCount: input.chainCount,\n    events: input.features.events,\n    sendTransaction: input.features.sendTransfer,\n    signIn: false,\n    signMessage: input.features.signMessage,\n    signTransaction: input.features.signPsbt,\n  });\n\nexport type { BitcoinCapabilityInput };\nexport { resolveBitcoinCapabilities };\n","import type { WalletAdapter } from \"@usebutr/core\";\nimport {\n  createWalletStandardCore,\n  discoverWalletStandard,\n  getFeature,\n  slugify,\n} from \"@usebutr/wallet-standard-shared\";\nimport type { WalletStandardWallet } from \"@usebutr/wallet-standard-shared\";\n\nimport { resolveBitcoinCapabilities } from \"./capabilities\";\nimport type {\n  BitcoinSendTransferFeature,\n  BitcoinSignMessageFeature,\n  BitcoinSignPsbtFeature,\n} from \"./wallet-standard-types\";\n\nconst BITCOIN_PREFIX = \"bip122:\";\nconst BITCOIN_DECIMALS = 8;\nconst BITCOIN_MAINNET_ID = \"bip122:000000000019d6689c085ae165831e93\";\n\n/**\n * Adapt a Bitcoin Wallet Standard `Wallet` into a butr `WalletAdapter`.\n *\n * Returns `null` if the wallet doesn't advertise any `bip122:` chain or\n * doesn't expose `standard:connect`. Same posture as the SVM/Sui\n * adapters: gate features on what each wallet advertises, return\n * placeholders for RPC reads, forward `subscribe` through\n * `standard:events`.\n *\n * **Known limitations**\n *\n *  - `getBalance` returns `{ value: 0n, symbol: \"BTC\" }`. Bitcoin\n *    balance lookups require an Esplora/Electrum/RPC client outside\n *    butr's scope.\n *  - `getTransactionReceipt` returns `\"Pending\"` for the same reason.\n *  - `sendTx` expects the consumer to pass `{ amount: bigint, recipient: string }`\n *    via butr's `unknown` tx parameter; the simplest mental model that\n *    maps onto `bitcoin:sendTransfer`. PSBT-shaped flows go through\n *    `signTransaction`.\n *  - `signTransaction` expects a `Uint8Array` PSBT (raw bytes); the\n *    same shape `bitcoin:signPsbt` accepts. Consumers building with\n *    `bitcoinjs-lib` get bytes via `psbt.toBuffer()`.\n *  - `switchChain` is local-state-only; the capability flag is `false`\n *    when only one chain is advertised. Wallets that ship a real switch\n *    primitive (none today, portably) would need their own adapter.\n */\nconst buildBitcoinAdapter = (\n  wallet: WalletStandardWallet,\n  /** Optional. Called with a function that pushes a synthetic\n   *  `disconnected` event to all current subscribers. The discovery\n   *  layer invokes it on Wallet Standard `unregister`. */\n  registerDisconnector?: (emit: () => void) => void,\n): WalletAdapter | null => {\n  const core = createWalletStandardCore({\n    chainPrefix: BITCOIN_PREFIX,\n    id: slugify(\"btc\", wallet.name),\n    label: \"Bitcoin\",\n    namespace: \"bip122\",\n    platform: \"Bitcoin\",\n    preferredChainIds: [BITCOIN_MAINNET_ID],\n    registerDisconnector,\n    trackChainChanges: true,\n    wallet,\n  });\n  if (core === null) {\n    return null;\n  }\n\n  const signMessage = getFeature<BitcoinSignMessageFeature>(wallet, \"bitcoin:signMessage\");\n  const signPsbt = getFeature<BitcoinSignPsbtFeature>(wallet, \"bitcoin:signPsbt\");\n  const sendTransfer = getFeature<BitcoinSendTransferFeature>(wallet, \"bitcoin:sendTransfer\");\n\n  const sendTransferTx = async (\n    tx: unknown,\n    account?: { walletAddress: string },\n  ): Promise<string> => {\n    if (sendTransfer === undefined) {\n      throw new Error(`Wallet ${wallet.name} does not advertise bitcoin:sendTransfer`);\n    }\n    if (\n      typeof tx !== \"object\" ||\n      tx === null ||\n      !(\"amount\" in tx) ||\n      typeof tx.amount !== \"bigint\" ||\n      !(\"recipient\" in tx) ||\n      typeof tx.recipient !== \"string\"\n    ) {\n      throw new TypeError(\n        \"Bitcoin sendTx expects { amount: bigint, recipient: string }: pass the recipient address and an amount in satoshis\",\n      );\n    }\n    const { amount, recipient } = tx;\n    const output = await sendTransfer.sendTransfer({\n      account: core.resolveAccount(account),\n      amount,\n      chain: core.currentChainId(),\n      recipient,\n    });\n    return output.txid;\n  };\n\n  return {\n    ...core,\n    capabilities: resolveBitcoinCapabilities({\n      chainCount: core.chainCount,\n      features: {\n        events: core.hasEvents,\n        sendTransfer: Boolean(sendTransfer),\n        signMessage: Boolean(signMessage),\n        signPsbt: Boolean(signPsbt),\n      },\n    }),\n    chainPlatform: \"bitcoin\",\n\n    getBalance: () =>\n      Promise.resolve({\n        decimals: BITCOIN_DECIMALS,\n        formatted: \"0\",\n        symbol: \"BTC\",\n        value: 0n,\n      }),\n\n    getTransactionReceipt: () => Promise.resolve({ status: \"Pending\" as const }),\n\n    async requestAccounts() {\n      await core.connect();\n    },\n\n    sendTx: (tx, account) => sendTransferTx(tx, account),\n\n    sendTxToChain: (tx, _targetChainId, account, cb) => {\n      cb?.();\n      return sendTransferTx(tx, account);\n    },\n\n    async signMessage(msg, account) {\n      if (signMessage === undefined) {\n        throw new Error(`Wallet ${wallet.name} does not advertise bitcoin:signMessage`);\n      }\n      const output = await signMessage.signMessage({\n        account: core.resolveAccount(account),\n        message: msg,\n      });\n      return { signature: output.signature, signedMessage: output.signedMessage };\n    },\n\n    ...(signPsbt === undefined\n      ? {}\n      : {\n          async signTransaction(tx, account) {\n            const wsAccount = core.resolveAccount(account);\n            if (!(tx instanceof Uint8Array)) {\n              throw new TypeError(\n                \"Bitcoin signTransaction expects a PSBT as Uint8Array (e.g. psbt.toBuffer())\",\n              );\n            }\n            const output = await signPsbt.signPsbt({\n              account: wsAccount,\n              chain: core.currentChainId(),\n              psbt: tx,\n            });\n            return output.signedPsbt;\n          },\n        }),\n  };\n};\n\n/**\n * Subscribe to Bitcoin Wallet Standard announcements.\n *\n * Phantom (Bitcoin), Magic Eden, OKX Wallet (Bitcoin), and Leather\n * advertise `bitcoin:*` features over the same `getWallets()` bus that\n * SVM and Sui consume. `buildBitcoinAdapter` returns `null` for wallets\n * that don't advertise any `bip122:` chain, so multi-chain wallets\n * (Phantom: EVM + SVM + Sui + Bitcoin) produce one adapter per platform.\n *\n * Requires the **optional peer dependency** `@wallet-standard/app`.\n *\n * The discovery loop (dynamic import, dedupe, register / unregister\n * bridge) lives in `@usebutr/wallet-standard-shared`.\n */\nconst discoverBitcoinAdapters = (onAdapter: (adapter: WalletAdapter) => void): (() => void) =>\n  discoverWalletStandard(onAdapter, (wallet, registerDisconnector) =>\n    buildBitcoinAdapter(wallet, registerDisconnector),\n  );\n\nexport { buildBitcoinAdapter, discoverBitcoinAdapters };\n","import type { ChainBase } from \"@usebutr/core\";\n\n/**\n * CAIP-2 Bitcoin chain references use the first 8 bytes (big-endian)\n * of each network's genesis block hash. These string ids are what\n * Bitcoin Wallet Standard wallets (Phantom, Magic Eden, OKX) advertise\n * in `wallet.chains`; the adapter's `switchChain` rejects anything else.\n *\n * - Mainnet:  `bip122:000000000019d6689c085ae165831e93`\n * - Testnet:  `bip122:000000000933ea01ad0ee984209779ba`\n * - Signet:   `bip122:00000008819873e925422c1ff0f99f7c`\n *\n * Bitcoin has no per-call \"switch chain\" RPC across the major wallets,\n * so butr's adapter treats chain as a wallet-side configuration;\n * `switchChain` updates local state to influence subsequent calls (same\n * posture as SVM). Bitcoin's `switchChain` capability is `false` by\n * default; consumers building on top can opt in if their wallet exposes\n * a switch primitive.\n */\nconst BITCOIN_CHAINS = {\n  mainnet: {\n    id: \"bip122:000000000019d6689c085ae165831e93\",\n    name: \"Bitcoin\",\n    namespace: \"bip122\",\n    reference: \"000000000019d6689c085ae165831e93\",\n  },\n  signet: {\n    id: \"bip122:00000008819873e925422c1ff0f99f7c\",\n    name: \"Bitcoin Signet\",\n    namespace: \"bip122\",\n    reference: \"00000008819873e925422c1ff0f99f7c\",\n  },\n  testnet: {\n    id: \"bip122:000000000933ea01ad0ee984209779ba\",\n    name: \"Bitcoin Testnet\",\n    namespace: \"bip122\",\n    reference: \"000000000933ea01ad0ee984209779ba\",\n  },\n} as const satisfies Record<string, ChainBase>;\n\nconst BITCOIN_CHAINS_LIST: ReadonlyArray<ChainBase> = Object.values(BITCOIN_CHAINS);\n\nexport { BITCOIN_CHAINS, BITCOIN_CHAINS_LIST };\n","/**\n * Generic Bitcoin wallet icon, same purse SVG style as the EVM\n * package, recoloured. Inline so the picker doesn't flash.\n *\n * Lives in its own file because both injected adapters (UniSat-shape\n * and sats-connect) need the same fallback when the wallet doesn't\n * advertise its own icon, and there's no other \"shared\" thing they\n * both want; a one-line module beats a grab-bag.\n */\nconst GENERIC_BITCOIN_ICON =\n  \"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0iI2Y3OTMxYSIgc3Ryb2tlPSJub25lIj48Y2lyY2xlIGN4PSIxMiIgY3k9IjEyIiByPSIxMCIvPjx0ZXh0IHg9IjEyIiB5PSIxNyIgZm9udC1mYW1pbHk9InNlcmlmIiBmb250LXNpemU9IjE0IiBmb250LXdlaWdodD0iYm9sZCIgZmlsbD0iI2ZmZiIgdGV4dC1hbmNob3I9Im1pZGRsZSI+QjwvdGV4dD48L3N2Zz4=\";\n\nexport { GENERIC_BITCOIN_ICON };\n","import type { ChainBase, WalletAdapter, WalletCapabilities } from \"@usebutr/core\";\nimport { base64ToBytes, bytesToBase64 } from \"@usebutr/core\";\nimport { buildAccount } from \"@usebutr/wallet-standard-shared\";\n\nimport { BITCOIN_CHAINS } from \"../chains\";\n\nimport { GENERIC_BITCOIN_ICON } from \"./icon\";\n\n/** sats-connect (Xverse) shape; a JSON-RPC-ish `request(method, params)`. */\ntype SatsConnectProvider = {\n  request: (\n    method: string,\n    params?: Record<string, unknown>,\n  ) => Promise<{ error?: { message: string }; result?: unknown }>;\n};\n\nconst CAPS_SATS_CONNECT: WalletCapabilities = {\n  getBalance: false,\n  getTransactionReceipt: false,\n  requestAccounts: true,\n  sendTransaction: true,\n  signIn: false,\n  signMessage: true,\n  signTransaction: true,\n  subscribe: false,\n  switchAccount: false,\n  switchChain: false,\n};\n\n/**\n * Wrap an Xverse-style `BitcoinProvider` (sats-connect) into a butr\n * `WalletAdapter`. sats-connect routes everything through a single\n * `request(method, params)` RPC; we shim each butr capability onto the\n * corresponding sats-connect method.\n *\n * Tested against Xverse's `getAccounts`, `signMessage`, `signPsbt`,\n * `sendTransfer` methods.\n */\nconst buildSatsConnectAdapter = (\n  id: string,\n  name: string,\n  provider: SatsConnectProvider,\n): WalletAdapter => {\n  let chain: ChainBase = BITCOIN_CHAINS.mainnet;\n  let cachedAccounts: ReadonlyArray<string> = [];\n\n  // oxlint-disable-next-line typescript/no-unnecessary-type-parameters -- caller-supplied result shape for an untyped RPC bridge\n  const callRequest = async <T>(method: string, params?: Record<string, unknown>): Promise<T> => {\n    const response = await provider.request(method, params);\n    if (response.error) {\n      throw new Error(`[butr/bitcoin] sats-connect ${method} failed: ${response.error.message}`);\n    }\n    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- untyped sats-connect RPC result; caller declares the shape\n    return response.result as T;\n  };\n\n  const loadAccounts = async (): Promise<ReadonlyArray<string>> => {\n    // `callRequest` only asserts the caller's shape onto an untyped RPC\n    // payload, so a wallet that answers without a `result` lands here as\n    // null/undefined and has to be read through an optional chain.\n    const result = await callRequest<{\n      addresses?: ReadonlyArray<{ address: string; purpose?: string }>;\n    } | null>(\"getAccounts\", {\n      message: \"Connect to butr\",\n      purposes: [\"payment\", \"ordinals\"],\n    });\n    if (result?.addresses === undefined) {\n      return [];\n    }\n    const addresses = result.addresses.map((a) => a.address);\n    cachedAccounts = addresses;\n    return addresses;\n  };\n\n  const sendTransferTx = async (tx: unknown): Promise<string> => {\n    if (\n      typeof tx !== \"object\" ||\n      tx === null ||\n      !(\"recipient\" in tx) ||\n      typeof tx.recipient !== \"string\" ||\n      !(\"amount\" in tx) ||\n      typeof tx.amount !== \"bigint\"\n    ) {\n      throw new TypeError(\n        \"Bitcoin sendTx expects { amount: bigint, recipient: string }: amount in satoshis\",\n      );\n    }\n    const { amount, recipient } = tx;\n    const result = await callRequest<{ txid: string }>(\"sendTransfer\", {\n      recipients: [{ address: recipient, amount: amount.toString() }],\n    });\n    return result.txid;\n  };\n\n  return {\n    capabilities: CAPS_SATS_CONNECT,\n    chainPlatform: \"bitcoin\",\n\n    async connect() {\n      await loadAccounts();\n    },\n\n    disconnect: () => {\n      cachedAccounts = [];\n      return Promise.resolve();\n    },\n\n    async getAccount() {\n      const first = cachedAccounts[0];\n      if (first !== undefined) {\n        return buildAccount(first, chain);\n      }\n      const accounts = await loadAccounts();\n      const firstFresh = accounts[0];\n      return firstFresh === undefined ? null : buildAccount(firstFresh, chain);\n    },\n\n    async getAccounts() {\n      const accounts = cachedAccounts.length > 0 ? cachedAccounts : await loadAccounts();\n      return accounts.map((a) => buildAccount(a, chain));\n    },\n\n    getBalance: () =>\n      Promise.resolve({\n        decimals: 8,\n        formatted: \"0\",\n        symbol: \"BTC\",\n        value: 0n,\n      }),\n\n    getSigner: () => Promise.resolve(provider),\n\n    getTransactionReceipt: () => Promise.resolve({ status: \"Pending\" as const }),\n\n    icon: GENERIC_BITCOIN_ICON,\n    id,\n    name,\n\n    async requestAccounts() {\n      await loadAccounts();\n    },\n\n    sendTx: (tx) => sendTransferTx(tx),\n\n    sendTxToChain: (tx, _targetChainId, _account, cb) => {\n      cb?.();\n      return sendTransferTx(tx);\n    },\n\n    async signMessage(msg) {\n      const address = cachedAccounts[0];\n      if (address === undefined) {\n        throw new Error(\"No connected account\");\n      }\n      const result = await callRequest<{ messageHash?: string; signature: string }>(\"signMessage\", {\n        address,\n        message: new TextDecoder().decode(msg),\n      });\n      return { signature: base64ToBytes(result.signature), signedMessage: msg };\n    },\n\n    async signTransaction(tx) {\n      if (!(tx instanceof Uint8Array)) {\n        throw new TypeError(\n          \"Bitcoin signTransaction expects a PSBT as Uint8Array (e.g. psbt.toBuffer())\",\n        );\n      }\n      // sats-connect's signPsbt takes a base64 PSBT; encode our bytes\n      // and decode the response back to bytes.\n      const result = await callRequest<{ psbt: string }>(\"signPsbt\", {\n        psbt: bytesToBase64(tx),\n      });\n      return base64ToBytes(result.psbt);\n    },\n\n    switchChain: (target) => {\n      if (target.namespace !== \"bip122\") {\n        throw new Error(\n          `Bitcoin adapter received non-Bitcoin chain \"${target.id}\". Pass a chain with namespace \"bip122\".`,\n        );\n      }\n      chain = target;\n      return Promise.resolve();\n    },\n  };\n};\n\nexport type { SatsConnectProvider };\nexport { buildSatsConnectAdapter };\n","import type { ChainBase, ConnectorEvent, WalletAdapter, WalletCapabilities } from \"@usebutr/core\";\nimport { base64ToBytes, bytesToHex, hexToBytes } from \"@usebutr/core\";\nimport { buildAccount } from \"@usebutr/wallet-standard-shared\";\n\nimport { BITCOIN_CHAINS } from \"../chains\";\n\nimport { GENERIC_BITCOIN_ICON } from \"./icon\";\n\n/** UniSat-style provider: a single object on `window.unisat` with the\n *  same four methods every UniSat-derivative wallet exposes (UniSat\n *  itself, OKX Wallet's Bitcoin path at `window.okxwallet.bitcoin`). */\ntype UnisatProvider = {\n  getAccounts: () => Promise<ReadonlyArray<string>>;\n  getNetwork?: () => Promise<\"livenet\" | \"mainnet\" | \"testnet\" | \"signet\">;\n  on?: (\n    event: \"accountsChanged\" | \"networkChanged\",\n    listener: (...args: Array<unknown>) => void,\n  ) => void;\n  pushPsbt?: (psbtHex: string) => Promise<string>;\n  removeListener?: (\n    event: \"accountsChanged\" | \"networkChanged\",\n    listener: (...args: Array<unknown>) => void,\n  ) => void;\n  requestAccounts: () => Promise<ReadonlyArray<string>>;\n  sendBitcoin?: (recipient: string, amount: number) => Promise<string>;\n  signMessage: (message: string, type?: \"ecdsa\" | \"bip322-simple\") => Promise<string>;\n  signPsbt: (psbtHex: string, options?: Record<string, unknown>) => Promise<string>;\n};\n\nconst CAPS_UNISAT: WalletCapabilities = {\n  getBalance: false,\n  getTransactionReceipt: false,\n  requestAccounts: true,\n  sendTransaction: true,\n  signIn: false,\n  signMessage: true,\n  signTransaction: true,\n  subscribe: true,\n  switchAccount: false,\n  switchChain: false,\n};\n\n/**\n * Wrap a UniSat-style provider (`window.unisat`, `window.okxwallet.bitcoin`,\n * `window.btc`) into a butr `WalletAdapter`.\n *\n * The UniSat shape is consistent enough that one adapter handles every\n * derivative. Differences (network names, `sendBitcoin` presence) are\n * gated by feature detection per call.\n */\nconst toStringArray = (value: unknown): Array<string> =>\n  Array.isArray(value) ? value.filter((item): item is string => typeof item === \"string\") : [];\n\nconst buildUnisatAdapter = (id: string, name: string, provider: UnisatProvider): WalletAdapter => {\n  let chain: ChainBase = BITCOIN_CHAINS.mainnet;\n  const listenersSet = new Set<(event: ConnectorEvent) => void>();\n\n  const sendBitcoinTx = (tx: unknown): Promise<string> => {\n    if (typeof provider.sendBitcoin !== \"function\") {\n      throw new TypeError(`Wallet ${name} does not expose sendBitcoin`);\n    }\n    if (\n      typeof tx !== \"object\" ||\n      tx === null ||\n      !(\"recipient\" in tx) ||\n      typeof tx.recipient !== \"string\" ||\n      !(\"amount\" in tx) ||\n      typeof tx.amount !== \"bigint\"\n    ) {\n      throw new TypeError(\n        \"Bitcoin sendTx expects { amount: bigint, recipient: string }: amount in satoshis\",\n      );\n    }\n    const { amount, recipient } = tx;\n    return provider.sendBitcoin(recipient, Number(amount));\n  };\n\n  const refreshChain = async () => {\n    if (typeof provider.getNetwork !== \"function\") {\n      return;\n    }\n    try {\n      const network = await provider.getNetwork();\n      if (network === \"testnet\") {\n        chain = BITCOIN_CHAINS.testnet;\n      } else if (network === \"signet\") {\n        chain = BITCOIN_CHAINS.signet;\n      } else {\n        chain = BITCOIN_CHAINS.mainnet;\n      }\n    } catch {\n      void 0;\n    }\n  };\n\n  return {\n    capabilities: CAPS_UNISAT,\n    chainPlatform: \"bitcoin\",\n\n    async connect(opts) {\n      if (opts?.silent === true) {\n        const accounts = await provider.getAccounts();\n        if (accounts.length === 0) {\n          throw new Error(\"No authorized accounts for silent reconnect\");\n        }\n        await refreshChain();\n        return;\n      }\n      await provider.requestAccounts();\n      await refreshChain();\n    },\n\n    disconnect: () =>\n      // No portable disconnect across UniSat-shaped wallets. butr's\n      // reducer marks the wallet disconnected on its side regardless.\n      Promise.resolve(),\n\n    async getAccount() {\n      const accounts = await provider.getAccounts();\n      const first = accounts[0];\n      if (first === undefined) {\n        return null;\n      }\n      await refreshChain();\n      return buildAccount(first, chain);\n    },\n\n    async getAccounts() {\n      const accounts = await provider.getAccounts();\n      if (accounts.length === 0) {\n        return [];\n      }\n      await refreshChain();\n      return accounts.map((a) => buildAccount(a, chain));\n    },\n\n    getBalance: () =>\n      Promise.resolve({\n        decimals: 8,\n        formatted: \"0\",\n        symbol: \"BTC\",\n        value: 0n,\n      }),\n\n    getSigner: () => Promise.resolve(provider),\n\n    getTransactionReceipt: () => Promise.resolve({ status: \"Pending\" as const }),\n\n    icon: GENERIC_BITCOIN_ICON,\n    id,\n    name,\n\n    async requestAccounts() {\n      await provider.requestAccounts();\n      await refreshChain();\n    },\n\n    sendTx: (tx) => sendBitcoinTx(tx),\n\n    sendTxToChain: (tx, _targetChainIdDecimal, _account, cb) => {\n      cb?.();\n      return sendBitcoinTx(tx);\n    },\n\n    async signMessage(msg) {\n      // UniSat takes a UTF-8 message and returns a base64 signature.\n      // We return the raw signature bytes (decoded from base64) and the\n      // bytes the wallet signed (pass-through of the input). UniSat\n      // doesn't expose a \"pre-image\" so the input itself is the signed\n      // message from butr's perspective.\n      const text = new TextDecoder().decode(msg);\n      const signatureB64 = await provider.signMessage(text);\n      return { signature: base64ToBytes(signatureB64), signedMessage: msg };\n    },\n\n    async signTransaction(tx) {\n      if (!(tx instanceof Uint8Array)) {\n        throw new TypeError(\n          \"Bitcoin signTransaction expects a PSBT as Uint8Array (e.g. psbt.toBuffer())\",\n        );\n      }\n      const signedHex = await provider.signPsbt(bytesToHex(tx));\n      return hexToBytes(signedHex);\n    },\n\n    subscribe(listener) {\n      listenersSet.add(listener);\n      const onAccountsChanged = (...args: ReadonlyArray<unknown>) => {\n        const accounts = toStringArray(args[0]);\n        if (accounts.length === 0) {\n          listener({ type: \"disconnected\" });\n          return;\n        }\n        const built = accounts.map((a) => buildAccount(a, chain));\n        const first = built[0];\n        if (first === undefined) {\n          return;\n        }\n        listener({ account: first, accounts: built, type: \"accountChanged\" });\n      };\n      const onNetworkChanged = () => {\n        void refreshChain();\n      };\n      provider.on?.(\"accountsChanged\", onAccountsChanged);\n      provider.on?.(\"networkChanged\", onNetworkChanged);\n      return () => {\n        provider.removeListener?.(\"accountsChanged\", onAccountsChanged);\n        provider.removeListener?.(\"networkChanged\", onNetworkChanged);\n        listenersSet.delete(listener);\n      };\n    },\n\n    switchChain: (target) => {\n      if (target.namespace !== \"bip122\") {\n        throw new Error(\n          `Bitcoin adapter received non-Bitcoin chain \"${target.id}\". Pass a chain with namespace \"bip122\".`,\n        );\n      }\n      // UniSat-shaped wallets pick their network via the user's\n      // extension UI; we update local state so consumers see it, but\n      // the wallet itself doesn't switch.\n      chain = target;\n      void refreshChain();\n      return Promise.resolve();\n    },\n  };\n};\n\nexport type { UnisatProvider };\nexport { buildUnisatAdapter };\n","import type { WalletAdapter } from \"@usebutr/core\";\n\nimport type { SatsConnectProvider } from \"./sats-connect\";\nimport { buildSatsConnectAdapter } from \"./sats-connect\";\nimport type { UnisatProvider } from \"./unisat\";\nimport { buildUnisatAdapter } from \"./unisat\";\n\nconst DEFAULT_SETTLE_MS = 150;\n\ntype InjectedHost = {\n  btc?: UnisatProvider;\n  okxwallet?: { bitcoin?: UnisatProvider };\n  unisat?: UnisatProvider;\n  XverseProviders?: { BitcoinProvider?: SatsConnectProvider };\n};\n\ntype InjectedBitcoinDiscoveryOptions = {\n  /** Suppresses emission when Wallet Standard discovery has already\n   *  registered a Bitcoin adapter for the same browser session. */\n  hasAnyWalletStandardAdapter?: () => boolean;\n  /** Settle deadline in ms before the fallback fires. Same default and\n   *  intent as the EVM injected fallback. */\n  settleMs?: number;\n  /** Override the global host (tests, iframes). */\n  target?: InjectedHost | null;\n};\n\nconst readHost = (target: InjectedBitcoinDiscoveryOptions[\"target\"]): InjectedHost | null => {\n  if (target !== undefined) {\n    return target;\n  }\n  if (typeof window === \"undefined\") {\n    return null;\n  }\n  // `window` carries the injected wallet globals (`unisat`, `okxwallet`,\n  // etc.) as an untyped host object; `InjectedHost` names the four keys\n  // butr probes, all optional and read defensively in `probeProviders`.\n  // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- untyped injected-wallet window globals\n  return window as unknown as InjectedHost;\n};\n\nconst probeProviders = (host: InjectedHost): Array<WalletAdapter> => {\n  const adapters: Array<WalletAdapter> = [];\n  const seen = new Set<UnisatProvider | SatsConnectProvider>();\n\n  if (host.unisat && !seen.has(host.unisat)) {\n    seen.add(host.unisat);\n    adapters.push(buildUnisatAdapter(\"injected:bitcoin:unisat\", \"Unisat\", host.unisat));\n  }\n\n  const okxBitcoin = host.okxwallet?.bitcoin;\n  if (okxBitcoin && !seen.has(okxBitcoin)) {\n    seen.add(okxBitcoin);\n    adapters.push(buildUnisatAdapter(\"injected:bitcoin:okx\", \"OKX Wallet (Bitcoin)\", okxBitcoin));\n  }\n\n  const xverse = host.XverseProviders?.BitcoinProvider;\n  if (xverse && !seen.has(xverse)) {\n    seen.add(xverse);\n    adapters.push(buildSatsConnectAdapter(\"injected:bitcoin:xverse\", \"Xverse\", xverse));\n  }\n\n  if (host.btc && !seen.has(host.btc)) {\n    seen.add(host.btc);\n    adapters.push(\n      buildUnisatAdapter(\"injected:bitcoin:legacy\", \"Browser Bitcoin wallet\", host.btc),\n    );\n  }\n\n  return adapters;\n};\n\n/**\n * Last-resort discovery path for Bitcoin wallets that DON'T announce via\n * Wallet Standard. Probes, in order: `window.unisat`,\n * `window.okxwallet.bitcoin`, `window.XverseProviders.BitcoinProvider`,\n * `window.btc`.\n *\n * Wallet Standard wallets (Phantom, Magic Eden, Leather, modern OKX\n * builds) are already handled by `discoverBitcoinAdapters`. This\n * fallback waits `settleMs` (default 150ms), consults\n * `hasAnyWalletStandardAdapter` if provided, and emits adapters for\n * any injected providers that weren't already covered.\n *\n * Each emitted adapter has a stable id prefix (`injected:bitcoin:*`)\n * so consumers can distinguish them in the picker UI.\n */\nconst discoverInjectedBitcoinAdapter = (\n  onAdapter: (adapter: WalletAdapter) => void,\n  options: InjectedBitcoinDiscoveryOptions = {},\n): (() => void) => {\n  const settleMs = options.settleMs ?? DEFAULT_SETTLE_MS;\n  let cancelled = false;\n  const timer = setTimeout(() => {\n    if (cancelled) {\n      return;\n    }\n    if (options.hasAnyWalletStandardAdapter?.() === true) {\n      return;\n    }\n    const host = readHost(options.target);\n    if (host === null) {\n      return;\n    }\n    const adapters = probeProviders(host);\n    for (const adapter of adapters) {\n      onAdapter(adapter);\n    }\n  }, settleMs);\n\n  return () => {\n    cancelled = true;\n    clearTimeout(timer);\n  };\n};\n\nexport type { InjectedBitcoinDiscoveryOptions };\nexport { GENERIC_BITCOIN_ICON } from \"./icon\";\nexport { discoverInjectedBitcoinAdapter };\n","import type { PlatformDiscoverer } from \"@usebutr/core\";\n\nimport { discoverInjectedBitcoinAdapter } from \"./injected\";\nimport { discoverBitcoinAdapters } from \"./wallet-standard-adapter\";\n\n/**\n * Bitcoin's `PlatformDiscoverer`: Wallet Standard primary (Phantom,\n * Magic Eden, Leather, OKX); legacy fallback covers sats-connect\n * (Xverse), `window.unisat`, OKX legacy, and `window.btc`. The\n * fallback defers to Wallet Standard via `hasAnyPrimaryAdapter`.\n */\nconst bitcoinDiscoverer: PlatformDiscoverer = {\n  fallback: {\n    subscribe: (onAdapter, opts) =>\n      discoverInjectedBitcoinAdapter(onAdapter, {\n        hasAnyWalletStandardAdapter: opts.hasAnyPrimaryAdapter,\n      }),\n  },\n  subscribe: discoverBitcoinAdapters,\n};\n\nexport { bitcoinDiscoverer };\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/capabilities.ts","../src/wallet-standard-adapter.ts","../src/chains.ts","../src/injected/icon.ts","../src/injected/sats-connect.ts","../src/injected/unisat.ts","../src/injected/index.ts","../src/discoverer.ts"],"sourcesContent":["import type { WalletCapabilities } from \"@usebutr/core\";\nimport { buildWalletCapabilities } from \"@usebutr/wallet-standard-shared\";\n\ntype BitcoinCapabilityInput = {\n  chainCount: number;\n  features: {\n    events: boolean;\n    sendTransfer: boolean;\n    signMessage: boolean;\n    signPsbt: boolean;\n  };\n};\n\n/**\n * `signIn` is false: there is no Sign-In-With-Bitcoin standard, and BIP-322\n * is message-signing oriented rather than auth. `sendTransfer` leaves UTXO\n * selection, fees and broadcast to the wallet; `signPsbt` is sign-only.\n */\nconst resolveBitcoinCapabilities = (input: BitcoinCapabilityInput): WalletCapabilities =>\n  buildWalletCapabilities({\n    chainCount: input.chainCount,\n    events: input.features.events,\n    sendTransaction: input.features.sendTransfer,\n    signIn: false,\n    signMessage: input.features.signMessage,\n    signTransaction: input.features.signPsbt,\n  });\n\nexport type { BitcoinCapabilityInput };\nexport { resolveBitcoinCapabilities };\n","import type { TransactionInput, WalletAdapter } from \"@usebutr/core\";\nimport {\n  createWalletStandardCore,\n  discoverWalletStandard,\n  getFeature,\n  slugify,\n} from \"@usebutr/wallet-standard-shared\";\nimport type { WalletStandardFeature, WalletStandardWallet } from \"@usebutr/wallet-standard-shared\";\n\nimport { resolveBitcoinCapabilities } from \"./capabilities\";\nimport type {\n  BitcoinSendTransferFeature,\n  BitcoinSignMessageFeature,\n  BitcoinSignPsbtFeature,\n} from \"./wallet-standard-types\";\n\nconst BITCOIN_PREFIX = \"bip122:\";\nconst BITCOIN_DECIMALS = 8;\nconst BITCOIN_MAINNET_ID = \"bip122:000000000019d6689c085ae165831e93\";\n\nconst isBitcoinSignMessageFeature = (\n  feature: WalletStandardFeature,\n): feature is WalletStandardFeature & BitcoinSignMessageFeature =>\n  \"signMessage\" in feature && typeof feature.signMessage === \"function\";\n\nconst isBitcoinSignPsbtFeature = (\n  feature: WalletStandardFeature,\n): feature is WalletStandardFeature & BitcoinSignPsbtFeature =>\n  \"signPsbt\" in feature && typeof feature.signPsbt === \"function\";\n\nconst isBitcoinSendTransferFeature = (\n  feature: WalletStandardFeature,\n): feature is WalletStandardFeature & BitcoinSendTransferFeature =>\n  \"sendTransfer\" in feature && typeof feature.sendTransfer === \"function\";\n\n/**\n * `sendTx` takes `{ amount, recipient }` for `bitcoin:sendTransfer` and\n * `signTransaction` takes raw PSBT bytes for `bitcoin:signPsbt`. Balance\n * and receipt reads would need an Esplora/Electrum client butr doesn't ship.\n */\nconst buildBitcoinAdapter = (\n  wallet: WalletStandardWallet,\n  /** Optional. Called with a function that pushes a synthetic\n   *  `disconnected` event to all current subscribers. The discovery\n   *  layer invokes it on Wallet Standard `unregister`. */\n  registerDisconnector?: (emit: () => void) => void,\n): WalletAdapter | null => {\n  const core = createWalletStandardCore({\n    chainPrefix: BITCOIN_PREFIX,\n    id: slugify(\"btc\", wallet.name),\n    label: \"Bitcoin\",\n    namespace: \"bip122\",\n    platform: \"Bitcoin\",\n    preferredChainIds: [BITCOIN_MAINNET_ID],\n    registerDisconnector,\n    trackChainChanges: true,\n    wallet,\n  });\n  if (core === null) {\n    return null;\n  }\n\n  const signMessage = getFeature(wallet, \"bitcoin:signMessage\", isBitcoinSignMessageFeature);\n  const signPsbt = getFeature(wallet, \"bitcoin:signPsbt\", isBitcoinSignPsbtFeature);\n  const sendTransfer = getFeature(wallet, \"bitcoin:sendTransfer\", isBitcoinSendTransferFeature);\n\n  /** Resolve a caller-supplied target into a chain the wallet advertises,\n   *  accepting either a full CAIP-2 id or a bare genesis-hash reference. */\n  const resolveTargetChain = (targetChainId: string): string => {\n    const candidate = targetChainId.startsWith(BITCOIN_PREFIX)\n      ? targetChainId\n      : `${BITCOIN_PREFIX}${targetChainId}`;\n    if (!wallet.chains.includes(candidate)) {\n      throw new Error(\n        `Wallet ${wallet.name} does not advertise chain \"${candidate}\". Available: ${wallet.chains.join(\", \")}`,\n      );\n    }\n    return candidate;\n  };\n\n  const sendTransferTx = async (\n    tx: TransactionInput,\n    account?: { walletAddress: string },\n    chain?: string,\n  ): Promise<string> => {\n    if (sendTransfer === undefined) {\n      throw new Error(`Wallet ${wallet.name} does not advertise bitcoin:sendTransfer`);\n    }\n    if (\n      typeof tx !== \"object\" ||\n      tx === null ||\n      !(\"amount\" in tx) ||\n      typeof tx.amount !== \"bigint\" ||\n      !(\"recipient\" in tx) ||\n      typeof tx.recipient !== \"string\"\n    ) {\n      throw new TypeError(\n        \"Bitcoin sendTx expects { amount: bigint, recipient: string }: pass the recipient address and an amount in satoshis\",\n      );\n    }\n    const { amount, recipient } = tx;\n    const output = await sendTransfer.sendTransfer({\n      account: core.resolveAccount(account),\n      amount,\n      chain: chain ?? core.currentChainId(),\n      recipient,\n    });\n    return output.txid;\n  };\n\n  const adapter: WalletAdapter = {\n    ...core,\n    capabilities: resolveBitcoinCapabilities({\n      chainCount: core.chainCount,\n      features: {\n        events: core.hasEvents,\n        sendTransfer: Boolean(sendTransfer),\n        signMessage: Boolean(signMessage),\n        signPsbt: Boolean(signPsbt),\n      },\n    }),\n    chainPlatform: \"bitcoin\",\n\n    getBalance: () =>\n      Promise.resolve({\n        decimals: BITCOIN_DECIMALS,\n        formatted: \"0\",\n        symbol: \"BTC\",\n        value: 0n,\n      }),\n\n    getTransactionReceipt: () => Promise.resolve({ status: \"Pending\" as const }),\n\n    async requestAccounts() {\n      await core.connect();\n    },\n\n    sendTx: (tx, account) => sendTransferTx(tx, account),\n\n    async sendTxToChain(tx, targetChainId, account, cb) {\n      const target = resolveTargetChain(targetChainId);\n      if (target !== core.currentChainId()) {\n        cb?.();\n      }\n      const txid = await sendTransferTx(tx, account, target);\n      return txid;\n    },\n\n    async signMessage(msg, account) {\n      if (signMessage === undefined) {\n        throw new Error(`Wallet ${wallet.name} does not advertise bitcoin:signMessage`);\n      }\n      const output = await signMessage.signMessage({\n        account: core.resolveAccount(account),\n        message: msg,\n      });\n      return { signature: output.signature, signedMessage: output.signedMessage };\n    },\n  };\n\n  if (signPsbt !== undefined) {\n    adapter.signTransaction = async (tx, account) => {\n      const wsAccount = core.resolveAccount(account);\n      if (!(tx instanceof Uint8Array)) {\n        throw new TypeError(\n          \"Bitcoin signTransaction expects a PSBT as Uint8Array (e.g. psbt.toBuffer())\",\n        );\n      }\n      const output = await signPsbt.signPsbt({\n        account: wsAccount,\n        chain: core.currentChainId(),\n        psbt: tx,\n      });\n      return output.signedPsbt;\n    };\n  }\n\n  return adapter;\n};\n\n/** Requires the optional `@wallet-standard/app` peer dep. */\nconst discoverBitcoinAdapters = (onAdapter: (adapter: WalletAdapter) => void): (() => void) =>\n  discoverWalletStandard(onAdapter, (wallet, registerDisconnector) =>\n    buildBitcoinAdapter(wallet, registerDisconnector),\n  );\n\nexport { buildBitcoinAdapter, discoverBitcoinAdapters };\n","import type { ChainBase } from \"@usebutr/core\";\n\n/**\n * CAIP-2 Bitcoin references are the first 8 bytes of each network's\n * genesis block hash, which is what wallets advertise in `wallet.chains`.\n * No major wallet exposes a switch-chain RPC, so chain stays local state.\n */\nconst BITCOIN_CHAINS = {\n  mainnet: {\n    id: \"bip122:000000000019d6689c085ae165831e93\",\n    name: \"Bitcoin\",\n    namespace: \"bip122\",\n    reference: \"000000000019d6689c085ae165831e93\",\n  },\n  signet: {\n    id: \"bip122:00000008819873e925422c1ff0f99f7c\",\n    name: \"Bitcoin Signet\",\n    namespace: \"bip122\",\n    reference: \"00000008819873e925422c1ff0f99f7c\",\n  },\n  testnet: {\n    id: \"bip122:000000000933ea01ad0ee984209779ba\",\n    name: \"Bitcoin Testnet\",\n    namespace: \"bip122\",\n    reference: \"000000000933ea01ad0ee984209779ba\",\n  },\n} as const satisfies Record<string, ChainBase>;\n\nconst BITCOIN_CHAINS_LIST: ReadonlyArray<ChainBase> = Object.values(BITCOIN_CHAINS);\n\nexport { BITCOIN_CHAINS, BITCOIN_CHAINS_LIST };\n","/**\n * Inlined as a data URI so the picker doesn't flash, and shared by both\n * injected adapters as the fallback when a wallet advertises no icon.\n */\nconst GENERIC_BITCOIN_ICON =\n  \"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0iI2Y3OTMxYSIgc3Ryb2tlPSJub25lIj48Y2lyY2xlIGN4PSIxMiIgY3k9IjEyIiByPSIxMCIvPjx0ZXh0IHg9IjEyIiB5PSIxNyIgZm9udC1mYW1pbHk9InNlcmlmIiBmb250LXNpemU9IjE0IiBmb250LXdlaWdodD0iYm9sZCIgZmlsbD0iI2ZmZiIgdGV4dC1hbmNob3I9Im1pZGRsZSI+QjwvdGV4dD48L3N2Zz4=\";\n\nexport { GENERIC_BITCOIN_ICON };\n","import type {\n  Account,\n  ChainBase,\n  TransactionInput,\n  WalletAdapter,\n  WalletCapabilities,\n} from \"@usebutr/core\";\nimport { base64ToBytes, bytesToBase64 } from \"@usebutr/core\";\nimport { buildAccount } from \"@usebutr/wallet-standard-shared\";\nimport { z } from \"zod\";\n\nimport { BITCOIN_CHAINS } from \"../chains\";\n\nimport { GENERIC_BITCOIN_ICON } from \"./icon\";\n\n/** sats-connect (Xverse) shape; a JSON-RPC-ish `request(method, params)`. */\ntype RpcValue =\n  | boolean\n  | number\n  | string\n  | null\n  | ReadonlyArray<RpcValue>\n  | { readonly [key: string]: RpcValue | undefined };\n\ntype SatsConnectProvider = {\n  request: (\n    method: string,\n    params?: Readonly<Record<string, RpcValue>>,\n  ) => Promise<{ error?: { message: string }; result?: RpcValue }>;\n};\n\n/** One address entry of a sats-connect account result. `purpose` tags the\n *  role: `\"payment\"` is the spendable address, `\"ordinals\"` is a taproot\n *  address that `sendTransfer` never debits. */\ntype SatsAddress = {\n  address: string;\n  publicKey?: string;\n  purpose?: string;\n};\n\ntype ConnectedSession = {\n  addresses: ReadonlyArray<SatsAddress>;\n  payment: string;\n  status: \"connected\";\n};\n\ntype Session = ConnectedSession | { status: \"disconnected\" };\n\nconst CAPS_SATS_CONNECT: WalletCapabilities = {\n  getBalance: false,\n  getTransactionReceipt: false,\n  requestAccounts: true,\n  sendTransaction: true,\n  signIn: false,\n  signMessage: true,\n  signTransaction: true,\n  subscribe: false,\n  switchAccount: false,\n  switchChain: false,\n};\n\nconst ACCOUNT_PURPOSES = [\"payment\", \"ordinals\"];\nconst CONNECT_MESSAGE = \"Connect to butr\";\n\nconst satsAddressSchema = z.object({\n  address: z.string(),\n  publicKey: z.string().optional(),\n  purpose: z.string().optional(),\n});\n\nconst accountResultSchema = z\n  .object({ addresses: z.array(satsAddressSchema).optional() })\n  .nullable();\nconst sendTransferResultSchema = z.object({ txid: z.string() });\nconst signMessageResultSchema = z.object({\n  messageHash: z.string().optional(),\n  signature: z.string(),\n});\nconst signPsbtResultSchema = z.object({ psbt: z.string() });\n\nconst pickPaymentAddress = (addresses: ReadonlyArray<SatsAddress>): SatsAddress | undefined =>\n  addresses.find((a) => a.purpose === \"payment\") ?? addresses[0];\n\n/**\n * Only the payment address is exposed as an Account: sats-connect's\n * `sendTransfer` takes no sender and always debits it. The taproot ordinals\n * address stays reachable through `getSigner()` and `signMessage`'s account.\n */\nconst buildSatsConnectAdapter = (\n  id: string,\n  name: string,\n  provider: SatsConnectProvider,\n): WalletAdapter => {\n  let chain: ChainBase = BITCOIN_CHAINS.mainnet;\n  let session: Session = { status: \"disconnected\" };\n\n  const callRequest = async <Schema extends z.ZodType>(\n    method: string,\n    schema: Schema,\n    params?: Readonly<Record<string, RpcValue>>,\n  ): Promise<z.output<Schema>> => {\n    const response = await provider.request(method, params);\n    if (response.error) {\n      throw new Error(`[butr/bitcoin] sats-connect ${method} failed: ${response.error.message}`);\n    }\n    return schema.parse(response.result);\n  };\n\n  const startSession = async (\n    method: string,\n    params: Readonly<Record<string, RpcValue>>,\n  ): Promise<void> => {\n    const result = await callRequest(method, accountResultSchema, params);\n    const addresses = result?.addresses ?? [];\n    const payment = pickPaymentAddress(addresses);\n    if (payment === undefined) {\n      throw new Error(`Wallet ${name} returned no addresses from ${method}`);\n    }\n    session = { addresses, payment: payment.address, status: \"connected\" };\n  };\n\n  const requestSession = () =>\n    startSession(\"getAccounts\", { message: CONNECT_MESSAGE, purposes: ACCOUNT_PURPOSES });\n\n  const requireSession = (): ConnectedSession => {\n    if (session.status !== \"connected\") {\n      throw new Error(\"No connected account\");\n    }\n    return session;\n  };\n\n  const resolveAddress = (account?: Account): string => {\n    const active = requireSession();\n    if (account === undefined) {\n      return active.payment;\n    }\n    const match = active.addresses.find((a) => a.address === account.walletAddress);\n    if (match === undefined) {\n      throw new Error(`Account ${account.walletAddress} is not exposed by ${name}`);\n    }\n    return match.address;\n  };\n\n  const sendTransferTx = async (tx: TransactionInput, account?: Account): Promise<string> => {\n    const sender = resolveAddress(account);\n    if (sender !== requireSession().payment) {\n      throw new Error(\n        `Wallet ${name} always debits its payment address; ${sender} cannot be used as the sender.`,\n      );\n    }\n    if (\n      typeof tx !== \"object\" ||\n      tx === null ||\n      !(\"recipient\" in tx) ||\n      typeof tx.recipient !== \"string\" ||\n      !(\"amount\" in tx) ||\n      typeof tx.amount !== \"bigint\"\n    ) {\n      throw new TypeError(\n        \"Bitcoin sendTx expects { amount: bigint, recipient: string }: amount in satoshis\",\n      );\n    }\n    const { amount, recipient } = tx;\n    const result = await callRequest(\"sendTransfer\", sendTransferResultSchema, {\n      recipients: [{ address: recipient, amount: amount.toString() }],\n    });\n    return result.txid;\n  };\n\n  return {\n    capabilities: CAPS_SATS_CONNECT,\n    chainPlatform: \"bitcoin\",\n\n    async connect(opts) {\n      if (opts?.silent === true) {\n        // `wallet_getAccount` reads already-granted permissions without\n        // showing wallet UI; `getAccounts` IS Xverse's approval prompt.\n        // Builds predating `wallet_getAccount` reject here, which butr's\n        // hydration treats as a clean restore failure.\n        await startSession(\"wallet_getAccount\", { addresses: ACCOUNT_PURPOSES });\n        return;\n      }\n      await requestSession();\n    },\n\n    disconnect: () => {\n      session = { status: \"disconnected\" };\n      return Promise.resolve();\n    },\n\n    getAccount: () =>\n      Promise.resolve(session.status === \"connected\" ? buildAccount(session.payment, chain) : null),\n\n    getAccounts: () =>\n      Promise.resolve(session.status === \"connected\" ? [buildAccount(session.payment, chain)] : []),\n\n    getBalance: () =>\n      Promise.resolve({\n        decimals: 8,\n        formatted: \"0\",\n        symbol: \"BTC\",\n        value: 0n,\n      }),\n\n    getSigner: () => Promise.resolve(provider),\n\n    getTransactionReceipt: () => Promise.resolve({ status: \"Pending\" as const }),\n\n    icon: GENERIC_BITCOIN_ICON,\n    id,\n    name,\n\n    requestAccounts: () => requestSession(),\n\n    sendTx: (tx, account) => sendTransferTx(tx, account),\n\n    sendTxToChain: (tx, _targetChainId, account, cb) => {\n      cb?.();\n      return sendTransferTx(tx, account);\n    },\n\n    async signMessage(msg, account) {\n      const address = resolveAddress(account);\n      const result = await callRequest(\"signMessage\", signMessageResultSchema, {\n        address,\n        message: new TextDecoder().decode(msg),\n      });\n      return { signature: base64ToBytes(result.signature), signedMessage: msg };\n    },\n\n    async signTransaction(tx) {\n      if (!(tx instanceof Uint8Array)) {\n        throw new TypeError(\n          \"Bitcoin signTransaction expects a PSBT as Uint8Array (e.g. psbt.toBuffer())\",\n        );\n      }\n      const result = await callRequest(\"signPsbt\", signPsbtResultSchema, {\n        psbt: bytesToBase64(tx),\n      });\n      return base64ToBytes(result.psbt);\n    },\n\n    switchChain: (target) => {\n      if (target.namespace !== \"bip122\") {\n        throw new Error(\n          `Bitcoin adapter received non-Bitcoin chain \"${target.id}\". Pass a chain with namespace \"bip122\".`,\n        );\n      }\n      chain = target;\n      return Promise.resolve();\n    },\n  };\n};\n\nexport type { RpcValue, SatsConnectProvider };\nexport { buildSatsConnectAdapter };\n","import type { ChainBase, TransactionInput, WalletAdapter, WalletCapabilities } from \"@usebutr/core\";\nimport { base64ToBytes, bytesToHex, hexToBytes } from \"@usebutr/core\";\nimport { buildAccount } from \"@usebutr/wallet-standard-shared\";\n\nimport { BITCOIN_CHAINS } from \"../chains\";\n\nimport { GENERIC_BITCOIN_ICON } from \"./icon\";\n\n/** UniSat-style provider: a single object on `window.unisat` with the\n *  same four methods every UniSat-derivative wallet exposes (UniSat\n *  itself, OKX Wallet's Bitcoin path at `window.okxwallet.bitcoin`). */\ntype UnisatProvider = {\n  getAccounts: () => Promise<ReadonlyArray<string>>;\n  getNetwork?: () => Promise<\"livenet\" | \"mainnet\" | \"testnet\" | \"signet\">;\n  on?: (\n    event: \"accountsChanged\" | \"networkChanged\",\n    listener: (...args: Array<UnisatEventValue>) => void,\n  ) => void;\n  pushPsbt?: (psbtHex: string) => Promise<string>;\n  removeListener?: (\n    event: \"accountsChanged\" | \"networkChanged\",\n    listener: (...args: Array<UnisatEventValue>) => void,\n  ) => void;\n  requestAccounts: () => Promise<ReadonlyArray<string>>;\n  sendBitcoin?: (recipient: string, amount: number) => Promise<string>;\n  signMessage: (message: string, type?: \"ecdsa\" | \"bip322-simple\") => Promise<string>;\n  signPsbt: (psbtHex: string, options?: UnisatSignPsbtOptions) => Promise<string>;\n};\n\ntype UnisatEventItem = number | string | null;\ntype UnisatEventValue = ReadonlyArray<UnisatEventItem> | string | undefined;\n\ntype UnisatSignPsbtOptions = {\n  autoFinalized?: boolean;\n};\n\nconst CAPS_UNISAT: WalletCapabilities = {\n  getBalance: false,\n  getTransactionReceipt: false,\n  requestAccounts: true,\n  sendTransaction: true,\n  signIn: false,\n  signMessage: true,\n  signTransaction: true,\n  subscribe: true,\n  switchAccount: false,\n  switchChain: false,\n};\n\nconst toStringArray = (value: UnisatEventValue | undefined): Array<string> =>\n  Array.isArray(value) ? value.filter((item): item is string => typeof item === \"string\") : [];\n\n/**\n * The UniSat shape is consistent enough across `window.unisat`,\n * `window.okxwallet.bitcoin` and `window.btc` that one adapter covers all\n * three; the differences (network names, `sendBitcoin`) are probed per call.\n */\nconst buildUnisatAdapter = (id: string, name: string, provider: UnisatProvider): WalletAdapter => {\n  let chain: ChainBase = BITCOIN_CHAINS.mainnet;\n\n  const sendBitcoinTx = async (tx: TransactionInput): Promise<string> => {\n    if (typeof provider.sendBitcoin !== \"function\") {\n      throw new TypeError(`Wallet ${name} does not expose sendBitcoin`);\n    }\n    if (\n      typeof tx !== \"object\" ||\n      tx === null ||\n      !(\"recipient\" in tx) ||\n      typeof tx.recipient !== \"string\" ||\n      !(\"amount\" in tx) ||\n      typeof tx.amount !== \"bigint\"\n    ) {\n      throw new TypeError(\n        \"Bitcoin sendTx expects { amount: bigint, recipient: string }: amount in satoshis\",\n      );\n    }\n    const { amount, recipient } = tx;\n    const txid = await provider.sendBitcoin(recipient, Number(amount));\n    return txid;\n  };\n\n  const refreshChain = async () => {\n    if (typeof provider.getNetwork !== \"function\") {\n      return;\n    }\n    try {\n      const network = await provider.getNetwork();\n      if (network === \"testnet\") {\n        chain = BITCOIN_CHAINS.testnet;\n      } else if (network === \"signet\") {\n        chain = BITCOIN_CHAINS.signet;\n      } else {\n        chain = BITCOIN_CHAINS.mainnet;\n      }\n    } catch {\n      void 0;\n    }\n  };\n\n  return {\n    capabilities: CAPS_UNISAT,\n    chainPlatform: \"bitcoin\",\n\n    async connect(opts) {\n      if (opts?.silent === true) {\n        const accounts = await provider.getAccounts();\n        if (accounts.length === 0) {\n          throw new Error(\"No authorized accounts for silent reconnect\");\n        }\n        await refreshChain();\n        return;\n      }\n      await provider.requestAccounts();\n      await refreshChain();\n    },\n\n    disconnect: () => Promise.resolve(),\n\n    async getAccount() {\n      const accounts = await provider.getAccounts();\n      const first = accounts[0];\n      if (first === undefined) {\n        return null;\n      }\n      await refreshChain();\n      return buildAccount(first, chain);\n    },\n\n    async getAccounts() {\n      const accounts = await provider.getAccounts();\n      if (accounts.length === 0) {\n        return [];\n      }\n      await refreshChain();\n      return accounts.map((a) => buildAccount(a, chain));\n    },\n\n    getBalance: () =>\n      Promise.resolve({\n        decimals: 8,\n        formatted: \"0\",\n        symbol: \"BTC\",\n        value: 0n,\n      }),\n\n    getSigner: () => Promise.resolve(provider),\n\n    getTransactionReceipt: () => Promise.resolve({ status: \"Pending\" as const }),\n\n    icon: GENERIC_BITCOIN_ICON,\n    id,\n    name,\n\n    async requestAccounts() {\n      await provider.requestAccounts();\n      await refreshChain();\n    },\n\n    sendTx: (tx) => sendBitcoinTx(tx),\n\n    sendTxToChain: (tx, _targetChainIdDecimal, _account, cb) => {\n      cb?.();\n      return sendBitcoinTx(tx);\n    },\n\n    async signMessage(msg) {\n      const text = new TextDecoder().decode(msg);\n      const signatureB64 = await provider.signMessage(text);\n      return { signature: base64ToBytes(signatureB64), signedMessage: msg };\n    },\n\n    async signTransaction(tx) {\n      if (!(tx instanceof Uint8Array)) {\n        throw new TypeError(\n          \"Bitcoin signTransaction expects a PSBT as Uint8Array (e.g. psbt.toBuffer())\",\n        );\n      }\n      const signedHex = await provider.signPsbt(bytesToHex(tx));\n      return hexToBytes(signedHex);\n    },\n\n    subscribe(listener) {\n      const onAccountsChanged = (...args: ReadonlyArray<UnisatEventValue>) => {\n        const accounts = toStringArray(args[0]);\n        if (accounts.length === 0) {\n          listener({ type: \"disconnected\" });\n          return;\n        }\n        const built = accounts.map((a) => buildAccount(a, chain));\n        const first = built[0];\n        if (first === undefined) {\n          return;\n        }\n        listener({ account: first, accounts: built, type: \"accountChanged\" });\n      };\n      const onNetworkChanged = () => {\n        void refreshChain();\n      };\n      provider.on?.(\"accountsChanged\", onAccountsChanged);\n      provider.on?.(\"networkChanged\", onNetworkChanged);\n      return () => {\n        provider.removeListener?.(\"accountsChanged\", onAccountsChanged);\n        provider.removeListener?.(\"networkChanged\", onNetworkChanged);\n      };\n    },\n\n    // `capabilities.switchChain` is false: UniSat exposes no way to ask the\n    // wallet to change network, so the wallet's own setting is authoritative\n    // and every account read re-reads it. This validates the request and then\n    // reports what the wallet actually says, rather than assigning the target\n    // locally and having the next read silently contradict it.\n    async switchChain(target) {\n      if (target.namespace !== \"bip122\") {\n        throw new Error(\n          `Bitcoin adapter received non-Bitcoin chain \"${target.id}\". Pass a chain with namespace \"bip122\".`,\n        );\n      }\n      chain = target;\n      await refreshChain();\n    },\n  };\n};\n\nexport type { UnisatProvider };\nexport { buildUnisatAdapter };\n","import type { WalletAdapter } from \"@usebutr/core\";\n\nimport type { SatsConnectProvider } from \"./sats-connect\";\nimport { buildSatsConnectAdapter } from \"./sats-connect\";\nimport type { UnisatProvider } from \"./unisat\";\nimport { buildUnisatAdapter } from \"./unisat\";\n\nconst DEFAULT_SETTLE_MS = 150;\n\ntype InjectedHost = {\n  btc?: UnisatProvider;\n  okxwallet?: { bitcoin?: UnisatProvider };\n  unisat?: UnisatProvider;\n  XverseProviders?: { BitcoinProvider?: SatsConnectProvider };\n};\n\ndeclare global {\n  // oxlint-disable-next-line typescript/consistent-type-definitions -- DOM globals require interface merging.\n  interface Window {\n    btc?: UnisatProvider;\n    okxwallet?: { bitcoin?: UnisatProvider };\n    unisat?: UnisatProvider;\n    XverseProviders?: { BitcoinProvider?: SatsConnectProvider };\n  }\n}\n\ntype InjectedBitcoinDiscoveryOptions = {\n  /** Suppresses emission when Wallet Standard discovery has already\n   *  registered a Bitcoin adapter for the same browser session. */\n  hasAnyWalletStandardAdapter?: () => boolean;\n  /** Settle deadline in ms before the fallback fires. Same default and\n   *  intent as the EVM injected fallback. */\n  settleMs?: number;\n  /** Override the global host (tests, iframes). */\n  target?: InjectedHost | null;\n};\n\nconst readHost = (target: InjectedBitcoinDiscoveryOptions[\"target\"]): InjectedHost | null => {\n  if (target !== undefined) {\n    return target;\n  }\n  if (typeof window === \"undefined\") {\n    return null;\n  }\n  return window;\n};\n\nconst probeProviders = (host: InjectedHost): Array<WalletAdapter> => {\n  const adapters: Array<WalletAdapter> = [];\n  const seen = new Set<UnisatProvider | SatsConnectProvider>();\n\n  if (host.unisat && !seen.has(host.unisat)) {\n    seen.add(host.unisat);\n    adapters.push(buildUnisatAdapter(\"injected:bitcoin:unisat\", \"Unisat\", host.unisat));\n  }\n\n  const okxBitcoin = host.okxwallet?.bitcoin;\n  if (okxBitcoin && !seen.has(okxBitcoin)) {\n    seen.add(okxBitcoin);\n    adapters.push(buildUnisatAdapter(\"injected:bitcoin:okx\", \"OKX Wallet (Bitcoin)\", okxBitcoin));\n  }\n\n  const xverse = host.XverseProviders?.BitcoinProvider;\n  if (xverse && !seen.has(xverse)) {\n    seen.add(xverse);\n    adapters.push(buildSatsConnectAdapter(\"injected:bitcoin:xverse\", \"Xverse\", xverse));\n  }\n\n  if (host.btc && !seen.has(host.btc)) {\n    seen.add(host.btc);\n    adapters.push(\n      buildUnisatAdapter(\"injected:bitcoin:legacy\", \"Browser Bitcoin wallet\", host.btc),\n    );\n  }\n\n  return adapters;\n};\n\n/**\n * Last-resort path for wallets that don't announce via Wallet Standard:\n * `window.unisat`, OKX, Xverse, `window.btc`. The `settleMs` wait lets\n * Wallet Standard announce first, else a wallet on both channels lists twice.\n */\nconst discoverInjectedBitcoinAdapter = (\n  onAdapter: (adapter: WalletAdapter) => void,\n  options: InjectedBitcoinDiscoveryOptions = {},\n): (() => void) => {\n  const settleMs = options.settleMs ?? DEFAULT_SETTLE_MS;\n  let cancelled = false;\n  const timer = setTimeout(() => {\n    if (cancelled) {\n      return;\n    }\n    if (options.hasAnyWalletStandardAdapter?.() === true) {\n      return;\n    }\n    const host = readHost(options.target);\n    if (host === null) {\n      return;\n    }\n    const adapters = probeProviders(host);\n    for (const adapter of adapters) {\n      onAdapter(adapter);\n    }\n  }, settleMs);\n\n  return () => {\n    cancelled = true;\n    clearTimeout(timer);\n  };\n};\n\nexport type { InjectedBitcoinDiscoveryOptions };\nexport { GENERIC_BITCOIN_ICON } from \"./icon\";\nexport { discoverInjectedBitcoinAdapter };\n","import type { PlatformDiscoverer } from \"@usebutr/core\";\n\nimport { discoverInjectedBitcoinAdapter } from \"./injected\";\nimport { discoverBitcoinAdapters } from \"./wallet-standard-adapter\";\n\n/**\n * Wallet Standard is primary; the legacy fallback covers sats-connect\n * (Xverse), `window.unisat`, OKX legacy and `window.btc`, and defers to\n * the primary channel via `hasAnyPrimaryAdapter`.\n */\nconst bitcoinDiscoverer: PlatformDiscoverer = {\n  fallback: {\n    subscribe: (onAdapter, opts) =>\n      discoverInjectedBitcoinAdapter(onAdapter, {\n        hasAnyWalletStandardAdapter: opts.hasAnyPrimaryAdapter,\n      }),\n  },\n  subscribe: discoverBitcoinAdapters,\n};\n\nexport { bitcoinDiscoverer };\n"],"mappings":"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"}

package/package.json

@@ -1,7 +1,23 @@
 {
   "name": "@usebutr/bitcoin",
-  "version": "1.0.1",
+  "version": "1.1.2",
   "description": "Wallet Standard + injected (sats-connect / Unisat / OKX) wallet discovery and adapters for butr (Bitcoin).",
+  "keywords": [
+    "bitcoin",
+    "butr",
+    "dapp",
+    "psbt",
+    "react",
+    "typescript",
+    "unisat",
+    "wallet",
+    "web3",
+    "xverse"
+  ],
+  "homepage": "https://docs.usebutr.com/api/bitcoin",
+  "bugs": {
+    "url": "https://github.com/pedroapfilho/usebutr/issues"
+  },
   "license": "MIT",
   "author": "Pedro Filho <pedro@filho.me>",
   "repository": {
@@ -10,7 +26,8 @@
     "directory": "packages/bitcoin"
   },
   "files": [
-    "dist"
+    "dist",
+    "CHANGELOG.md"
   ],
   "type": "module",
   "sideEffects": false,
@@ -25,12 +42,13 @@
     "access": "public"
   },
   "dependencies": {
-    "@usebutr/core": "1.1.0",
-    "@usebutr/wallet-standard-shared": "0.4.1"
+    "zod": "^4.4.3",
+    "@usebutr/core": "2.0.1",
+    "@usebutr/wallet-standard-shared": "1.0.0"
   },
   "devDependencies": {
     "@wallet-standard/app": "^1.1.1",
-    "typescript": "^6.0.3",
+    "typescript": "^7.0.2",
     "vitest": "^4.1.10",
     "@repo/config-vitest": "0.0.0",
     "@repo/typescript-config": "0.0.0"
@@ -47,7 +65,6 @@
     "build": "tsdown",
     "clean": "rm -rf dist",
     "dev": "tsdown --watch",
-    "lint": "oxlint src",
     "test": "vitest run --passWithNoTests",
     "test:coverage": "vitest run --coverage --passWithNoTests",
     "typecheck": "tsc -p tsconfig.json --noEmit"