@anywalletkit/wallet-btc 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,101 @@
-# Temporary Holding Version
+# @anywalletkit/wallet-btc
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Bitcoin accounts on [`@scure/btc-signer`](https://github.com/paulmillr/scure-btc-signer)
+(audited by Cure53; pure `Uint8Array`, no `Buffer`, no Node shims):
+
+| `addressType` | Path | Address | Standard |
+|---|---|---|---|
+| `p2wpkh` (default) | `m/84'/0'/0'/0/i` | `bc1q…` | BIP-84 native segwit |
+| `p2tr` | `m/86'/0'/0'/0/i` | `bc1p…` | BIP-86 key-path taproot |
+
+Test networks use coin type `1'` (`tb1…` / `bcrt1…`). Both paths are pinned by the
+official BIP-84 / BIP-86 test vectors.
+
+```ts
+import WalletManagerBtc from '@anywalletkit/wallet-btc'
+
+const wallet = new WalletManagerBtc(seedPhrase, {
+  network: 'bitcoin',
+  addressType: 'p2wpkh',                       // or 'p2tr'
+  client: [
+    { type: 'blockbook-http', clientConfig: { url: 'https://btc1.trezor.io' } },
+    { type: 'esplora-http', clientConfig: { url: 'https://mempool.space/api' } }, // fails over in order
+  ],
+  maxFeeRate: 200,                             // sat/vB ceiling (default 500)
+})
+const account = await wallet.getAccount(0)
+
+const preview = await account.describeTransaction({ to: 'bc1q…', value: 50_000n })
+//   { kind: 'btc-transfer', inputs, outputs: [{ role: 'recipient' | 'change' }], fee, feeRate, vsize, rbf, lockTime, warnings }
+
+await account.transfer({ recipient: 'bc1q…', amount: 50_000n })             // sats
+await account.sendTransaction({ to: 'bc1q…', value: 50_000n, feeRate: 12n }) // explicit sat/vB
+const hex = await account.signTransaction({ to: 'bc1q…', value: 50_000n })   // sign only
+const max = await account.getMaxSpendable()                                  // sweep amount after fee
+wallet.dispose()
+```
+
+## What a spend is
+
+Coin selection is our own (`selectCoins`, `coinselect.ts`): effective-value
+accumulation, largest first; inputs that cannot pay for themselves are skipped;
+change below dust (294 sat p2wpkh / 330 sat p2tr) is folded into the fee; at most
+`maxInputs` (200) inputs. Fees are `feeRate × vsize` with the standard segwit
+weights, estimated with 72-byte signatures so the quote is never below the fee
+actually paid.
+
+Transactions signal replace-by-fee (`rbf`, default on) and set `nLockTime` to the
+current tip (`antiFeeSniping`, default on when the transport can report the height).
+
+## Safety checks
+
+Before signing **and** before broadcasting — also for caller-supplied raw hex —
+every transaction is resolved into a `BtcTxDescription` and must pass:
+
+- fee rate ≤ `maxFeeRate` (`UnsafeTransactionError('fee-rate-too-high')`);
+- exactly one output equals the requested recipient + amount, every other output
+  is our own change (`'unexpected-output'`, `'recipient-mismatch'`, `'change-not-ours'`);
+- `transactionMaxFee` / `transferMaxFee` absolute caps.
+
+Warnings that do not block: `high-fee-rate`, `fee-over-10pct-of-amount`,
+`dust-output`, `no-change`.
+
+## Message signing
+
+`sign()` / `verify()` are BIP-137 for p2wpkh accounts (header `39 + recovery`,
+base64 — the Electrum / Bitcoin Core encoding). Taproot accounts have no BIP-137
+form; `sign()` throws `UnsupportedAddressTypeError` (BIP-322 is not implemented).
+
+## Transports
+
+`blockbook-http` (Trezor Blockbook REST, QuickNode's add-on) and `esplora-http`
+(mempool.space, blockstream.info). Requests time out after `timeoutMs` (15 s) and
+responses are shape-checked (`NetworkError` otherwise). Pass your own object
+implementing `BtcClient` for anything else.
+
+## Activity history
+
+`createBtcHistory` is the chain's `HistorySource` (`@anywalletkit/core`) over Blockbook, reusing `BlockbookClient` (`getAddressPage`, `getTransactionDetails`).
+
+```ts
+import { createBtcHistory } from '@anywalletkit/wallet-btc/history'
+
+const history = createBtcHistory({ blockbookUrls: ['https://btc1.trezor.io', 'https://bitcoin.atomicwallet.io'] })
+const page = await history.listActivity('bc1q3x8yszvcvjjxqragsh0l6j8rxnhk7pay9hnj5h', { limit: 25 })
+const older = await history.listActivity(address, { cursor: page.cursor })
+const one = await history.getTransaction(page.items[0].hash, address)
+history.explorerTxUrl(one.hash) // https://mempool.space/tx/…
+```
+
+| option | default | notes |
+|---|---|---|
+| `blockbookUrl` / `blockbookUrls` | — | Blockbook roots, tried in order (Cloudflare 403, 5xx, network → next). The Trezor instances (`btc1…5.trezor.io`) sit behind a Cloudflare challenge that blocks non-browser user agents; `bitcoin.atomicwallet.io` and `blockbook.btc.zelcore.io` answered on 2026-10-14. QuickNode's Blockbook add-on speaks the same API. |
+| `network` | `bitcoin` | `testnet` / `regtest` CAIP-2 ids; mempool.space testnet links. |
+| `pageSize` | the query `limit`, ≤ 100 | Rows per Blockbook page (its max is 1000). |
+| `fetch`, `timeoutMs` | global, 15 000 | |
+
+**Endpoint.** `GET /api/v2/address/{a}?details=txs&page=&pageSize=` — Blockbook returns transactions newest first with inputs and outputs (`hex` is dropped). The cursor is base64 JSON `{ v: 1, p, s }`: the next page and the page size the pagination started with (Blockbook clamps out-of-range pages to the last one, so paging stops at `totalPages`). `since` is applied client-side; unconfirmed rows are always kept.
+
+**Mapping.** Inputs the address spent (`ownIn`) and outputs it received (`ownOut`) are summed. Spent inputs → a send: `from` = address, `to` = the first output that is not ours, `nativeValue` = what left to non-own outputs (change ignored, fee separate); every output ours → a consolidation to itself. No spent inputs → a receive: `from` = the first input address (`coinbase` when none), `nativeValue` = `ownOut`. `transfers` is that one native leg, `fee` = `fees`, `status` = `confirmed` once `confirmations ≥ 1` (else `pending`, no `block`), `block` = `blockHeight`, `raw` = the Blockbook transaction plus `ownIn` / `ownOut`.
+
+Fixtures in `test/fixtures/history/` were captured on 2026-10-14 from `bitcoin.atomicwallet.io` for the test address (its 4 transactions: two receives, two sends with change) and `GET /api/v2/tx/{txid}` of one send. No protocol module recognizes Bitcoin transactions, so there is no recognizer cross-check.

package/dist/chunk-KAAQYL5X.js

@@ -0,0 +1,318 @@
+// src/blockbook.ts
+import { NetworkError as NetworkError2 } from "@anywalletkit/core";
+
+// src/http.ts
+import { NetworkError } from "@anywalletkit/core";
+var DEFAULT_TIMEOUT_MS = 15e3;
+async function fetchWithTimeout(fetchFn, url, init, timeoutMs, provider) {
+  const signal = typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(timeoutMs) : void 0;
+  try {
+    return await fetchFn(url, { ...init, ...signal ? { signal } : {} });
+  } catch (e) {
+    throw new NetworkError(`Request failed: ${url}`, { provider, cause: e });
+  }
+}
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isHex64 = (v) => typeof v === "string" && /^[0-9a-fA-F]{64}$/.test(v);
+var isIntString = (v) => typeof v === "string" && /^-?\d+$/.test(v);
+
+// src/blockbook.ts
+var MEMPOOL_SPACE_URL = "https://mempool.space";
+function unconfirmedOutgoing(transactions, address) {
+  const pending = (transactions ?? []).filter((tx) => tx.blockHeight === -1);
+  const pendingIds = new Set(pending.map((t) => t.txid));
+  const byId = new Map(pending.map((t) => [t.txid, t]));
+  const trusted = /* @__PURE__ */ new Map();
+  const owned = (entries) => (entries ?? []).filter((e) => e.isAddress && e.addresses?.includes(address)).reduce((s, e) => s + BigInt(e.value ?? 0), 0n);
+  const isTrusted = (tx) => {
+    if (trusted.has(tx.txid)) return trusted.get(tx.txid);
+    trusted.set(tx.txid, false);
+    const vins = tx.vin ?? [];
+    const ours = vins.filter((v) => v.isAddress && v.addresses?.includes(address));
+    const ok = vins.length > 0 && ours.length === vins.length && ours.every((v) => !v.txid || !pendingIds.has(v.txid) || isTrusted(byId.get(v.txid)));
+    trusted.set(tx.txid, ok);
+    return ok;
+  };
+  const consumed = /* @__PURE__ */ new Set();
+  for (const tx of pending) for (const v of tx.vin ?? []) if (v.txid && pendingIds.has(v.txid)) consumed.add(`${v.txid}:${v.vout}`);
+  return pending.reduce((total, tx) => {
+    const spent = owned((tx.vin ?? []).filter((v) => !v.txid || !pendingIds.has(v.txid)));
+    const change = isTrusted(tx) ? owned((tx.vout ?? []).filter((o) => !consumed.has(`${tx.txid}:${o.n}`))) : 0n;
+    return total + (spent - change);
+  }, 0n);
+}
+var BlockbookClient = class _BlockbookClient {
+  base;
+  fetchFn;
+  timeoutMs;
+  constructor(config, fetchFn = globalThis.fetch, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    this.base = config.url.replace(/\/+$/, "").replace(/\/api$/, "");
+    this.fetchFn = fetchFn;
+    this.timeoutMs = timeoutMs;
+  }
+  async connect() {
+  }
+  async close() {
+  }
+  async get(path, check) {
+    const url = `${this.base}/api${path}`;
+    const res = await fetchWithTimeout(this.fetchFn, url, void 0, this.timeoutMs, this.base);
+    if (!res.ok) throw new NetworkError2(`Blockbook request failed: ${res.status} ${res.statusText} (${url})`, { provider: this.base });
+    let body;
+    try {
+      body = await res.json();
+    } catch (e) {
+      throw new NetworkError2(`Blockbook returned non-JSON for ${url}`, { provider: this.base, cause: e });
+    }
+    if (!check(body)) throw new NetworkError2(`Blockbook returned an unexpected shape for ${url}`, { provider: this.base });
+    return body;
+  }
+  async getBalance(address) {
+    const data = await this.get(`/v2/address/${address}?details=txs`, (v) => isRecord(v) && isIntString(v.balance) && isIntString(v.unconfirmedBalance) && (v.transactions === void 0 || Array.isArray(v.transactions)));
+    return { confirmed: BigInt(data.balance), unconfirmed: BigInt(data.unconfirmedBalance), unconfirmedOutgoing: unconfirmedOutgoing(data.transactions, address) };
+  }
+  async listUnspent(address) {
+    const data = await this.get(`/v2/utxo/${address}`, (v) => Array.isArray(v) && v.every((u) => isRecord(u) && typeof u.txid === "string" && typeof u.vout === "number" && isIntString(u.value)));
+    return data.map((u) => ({ txid: u.txid, vout: u.vout, value: BigInt(u.value), height: u.height ?? -1 }));
+  }
+  async getHistory(address) {
+    const items = [];
+    for (let page = 1; ; page++) {
+      const data = await this.get(`/v2/address/${address}?details=txslight&pageSize=1000&page=${page}`, (v) => isRecord(v) && (v.transactions === void 0 || Array.isArray(v.transactions)));
+      for (const tx of data.transactions ?? []) items.push({ txid: tx.txid, height: tx.blockHeight });
+      if (page >= (data.totalPages ?? 1)) break;
+    }
+    return items;
+  }
+  /** One page of the address's transactions, newest first, with inputs / outputs (what the activity history reads). */
+  async getAddressPage(address, page = 1, pageSize = 25) {
+    const data = await this.get(`/v2/address/${address}?details=txs&page=${page}&pageSize=${pageSize}`, (v) => isRecord(v) && (v.transactions === void 0 || Array.isArray(v.transactions) && v.transactions.every(_BlockbookClient.isTx)));
+    const out = { ...data };
+    for (const tx of out.transactions ?? []) delete tx.hex;
+    return out;
+  }
+  /** A transaction with its inputs / outputs; undefined when Blockbook does not know it. */
+  async getTransactionDetails(txid) {
+    try {
+      const tx = await this.get(`/v2/tx/${txid}`, (v) => _BlockbookClient.isTx(v));
+      const out = { ...tx };
+      delete out.hex;
+      return out;
+    } catch (e) {
+      if (e instanceof NetworkError2 && /\b(400|404)\b/.test(e.message)) return void 0;
+      throw e;
+    }
+  }
+  static isTx(v) {
+    return isRecord(v) && typeof v.txid === "string" && typeof v.blockHeight === "number" && typeof v.confirmations === "number";
+  }
+  async getTransactionInfo(txid) {
+    try {
+      return await this.get(`/v2/tx/${txid}`, _BlockbookClient.isTx);
+    } catch (e) {
+      if (e instanceof NetworkError2 && /\b(400|404)\b/.test(e.message)) return void 0;
+      throw e;
+    }
+  }
+  async getTransaction(txid) {
+    const data = await this.get(`/v2/tx/${txid}`, _BlockbookClient.isTx);
+    if (typeof data.hex !== "string" || !data.hex) throw new NetworkError2(`Transaction ${txid} has no hex data`, { provider: this.base });
+    return data.hex;
+  }
+  async broadcast(rawTx) {
+    const data = await this.get(`/v2/sendtx/${rawTx}`, (v) => isRecord(v));
+    if (data.error) throw new Error(typeof data.error === "string" ? data.error : data.error.message ?? "broadcast failed");
+    if (!data.result) throw new NetworkError2("Blockbook returned no txid", { provider: this.base });
+    return data.result;
+  }
+  /** sat/vB. Blockbook reports BTC/kB (×1e5 → sat/vB); falls back to mempool.space when it has no estimate. */
+  async estimateFee(blocks) {
+    try {
+      const data = await this.get(`/v1/estimatefee/${blocks}`, (v) => typeof v === "string" || isRecord(v));
+      const rate = Number(typeof data === "string" ? data : data.result);
+      if (rate > 0) return Math.max(rate * 1e5, 1);
+    } catch {
+    }
+    const res = await fetchWithTimeout(this.fetchFn, `${MEMPOOL_SPACE_URL}/api/v1/fees/recommended`, void 0, this.timeoutMs, MEMPOOL_SPACE_URL);
+    if (!res.ok) throw new NetworkError2("Fee estimation request failed", { provider: MEMPOOL_SPACE_URL });
+    const d = await res.json();
+    const satPerVb = blocks <= 1 ? d.fastestFee : blocks <= 3 ? d.halfHourFee : blocks <= 6 ? d.hourFee : d.economyFee;
+    if (!satPerVb || satPerVb <= 0) throw new NetworkError2("Fee estimation is unavailable", { provider: MEMPOOL_SPACE_URL });
+    return satPerVb;
+  }
+  async getBlockHeight() {
+    const data = await this.get("/v2", (v) => isRecord(v));
+    const h = data.blockbook?.bestHeight;
+    if (typeof h !== "number" || h <= 0) throw new NetworkError2("Blockbook did not report a block height", { provider: this.base });
+    return h;
+  }
+};
+
+// src/types.ts
+var CAIP2_GENESIS = {
+  bitcoin: "bip122:000000000019d6689c085ae165831e93",
+  testnet: "bip122:000000000933ea01ad0ee984209779ba",
+  regtest: "bip122:0f9188f13cb7b2c71f2a335e3a4fc328"
+};
+
+// src/history.ts
+var HistoryUnavailableError = class extends Error {
+  chain;
+  reason;
+  attempts;
+  constructor(chain, reason, attempts = []) {
+    super(`History unavailable for ${chain}: ${reason}`);
+    this.name = "HistoryUnavailableError";
+    this.chain = chain;
+    this.reason = reason;
+    this.attempts = attempts;
+  }
+};
+var DEFAULT_LIMIT = 25;
+var MAX_PAGE_SIZE = 100;
+var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function b64encode(s) {
+  let out = "";
+  for (let i = 0; i < s.length; i += 3) {
+    const c = [s.charCodeAt(i), s.charCodeAt(i + 1), s.charCodeAt(i + 2)];
+    const n = c[0] << 16 | (c[1] || 0) << 8 | (c[2] || 0);
+    out += B64[n >> 18 & 63] + B64[n >> 12 & 63] + (Number.isNaN(c[1]) ? "=" : B64[n >> 6 & 63]) + (Number.isNaN(c[2]) ? "=" : B64[n & 63]);
+  }
+  return out;
+}
+function b64decode(s) {
+  const clean = s.replace(/[^A-Za-z0-9+/]/g, "");
+  let out = "";
+  for (let i = 0; i < clean.length; i += 4) {
+    const c = [0, 1, 2, 3].map((k) => i + k < clean.length ? B64.indexOf(clean[i + k]) : -1);
+    if (c[0] < 0 || c[1] < 0) throw new Error("bad base64");
+    const n = c[0] << 18 | c[1] << 12 | (c[2] < 0 ? 0 : c[2]) << 6 | (c[3] < 0 ? 0 : c[3]);
+    out += String.fromCharCode(n >> 16 & 255);
+    if (c[2] >= 0) out += String.fromCharCode(n >> 8 & 255);
+    if (c[3] >= 0) out += String.fromCharCode(n & 255);
+  }
+  return out;
+}
+function encodeCursor(c) {
+  return b64encode(JSON.stringify(c));
+}
+function decodeCursor(s) {
+  let parsed;
+  try {
+    parsed = JSON.parse(b64decode(s));
+  } catch {
+    throw new Error("@anywalletkit/wallet-btc: malformed history cursor");
+  }
+  const c = parsed;
+  if (!c || c.v !== 1 || !Number.isInteger(c.p) || c.p < 1 || !Number.isInteger(c.s) || c.s < 1) throw new Error("@anywalletkit/wallet-btc: malformed history cursor");
+  return { v: 1, p: c.p, s: c.s };
+}
+var big = (v) => typeof v === "string" && /^-?\d+$/.test(v) ? BigInt(v) : typeof v === "number" ? BigInt(Math.trunc(v)) : 0n;
+function mapBlockbookTx(chain, address, tx) {
+  const owns = (e) => e.isAddress !== false && (e.addresses ?? []).includes(address);
+  let ownIn = 0n, ownOut = 0n, sentToOthers = 0n;
+  for (const vin of tx.vin ?? []) if (owns(vin)) ownIn += big(vin.value);
+  for (const vout of tx.vout ?? []) {
+    if (owns(vout)) ownOut += big(vout.value);
+    else sentToOthers += big(vout.value);
+  }
+  const firstInput = (tx.vin ?? []).find((v) => v.isAddress !== false && v.addresses?.[0])?.addresses?.[0];
+  const firstOtherOutput = (tx.vout ?? []).find((v) => v.isAddress !== false && !owns(v) && v.addresses?.[0])?.addresses?.[0];
+  const transfers = [];
+  let from, to, nativeValue;
+  if (ownIn > 0n) {
+    from = address;
+    to = firstOtherOutput ?? address;
+    nativeValue = firstOtherOutput ? sentToOthers : ownOut;
+    if (nativeValue > 0n) transfers.push({ token: null, from: address, to, amount: nativeValue });
+  } else {
+    from = firstInput ?? "coinbase";
+    to = address;
+    nativeValue = ownOut;
+    if (nativeValue > 0n) transfers.push({ token: null, from, to: address, amount: nativeValue });
+  }
+  const confirmed = tx.confirmations > 0 && tx.blockHeight > 0;
+  const out = {
+    chain,
+    hash: tx.txid,
+    time: tx.blockTime ?? 0,
+    status: confirmed ? "confirmed" : "pending",
+    address,
+    from,
+    to,
+    nativeValue,
+    transfers,
+    raw: { tx, ownIn, ownOut }
+  };
+  if (tx.fees !== void 0) out.fee = big(tx.fees);
+  if (confirmed) out.block = BigInt(tx.blockHeight);
+  return out;
+}
+function btcExplorerTxUrl(hash, network = "bitcoin") {
+  return `https://mempool.space/${network === "testnet" ? "testnet/" : ""}tx/${hash}`;
+}
+function createBtcHistory(options = {}) {
+  const network = options.network ?? "bitcoin";
+  const chain = CAIP2_GENESIS[network];
+  const urls = [...options.blockbookUrls ?? [], ...options.blockbookUrl ? [options.blockbookUrl] : []];
+  if (urls.length === 0) throw new Error("@anywalletkit/wallet-btc: createBtcHistory needs blockbookUrl or blockbookUrls");
+  const fetchFn = options.fetch ?? globalThis.fetch;
+  if (typeof fetchFn !== "function") throw new Error("@anywalletkit/wallet-btc: no global fetch; pass `fetch` in the options");
+  const clients = urls.map((url) => ({ url, client: new BlockbookClient({ url }, fetchFn, options.timeoutMs ?? DEFAULT_TIMEOUT_MS) }));
+  async function failover(run) {
+    const attempts = [];
+    for (const { url, client } of clients) {
+      try {
+        return await run(client);
+      } catch (e) {
+        attempts.push(`${url}: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    throw new HistoryUnavailableError(chain, attempts[attempts.length - 1] ?? "every Blockbook failed", attempts);
+  }
+  return {
+    chain,
+    async listActivity(address, query = {}) {
+      const cursor = query.cursor ? decodeCursor(query.cursor) : void 0;
+      const pageSize = cursor?.s ?? Math.min(MAX_PAGE_SIZE, Math.max(1, Math.floor(options.pageSize ?? query.limit ?? DEFAULT_LIMIT)));
+      const pageNo = cursor?.p ?? 1;
+      const data = await failover((c) => c.getAddressPage(address, pageNo, pageSize));
+      let items = (data.transactions ?? []).map((tx) => mapBlockbookTx(chain, address, tx));
+      items.sort((a, b) => (b.block === void 0 ? 1 : a.block === void 0 ? -1 : Number(b.block - a.block)) || b.time - a.time);
+      const totalPages = data.totalPages ?? 1;
+      let more = pageNo < totalPages;
+      if (query.since !== void 0) {
+        const since = query.since;
+        if (items.some((t) => t.status === "confirmed" && t.time < since)) more = false;
+        items = items.filter((t) => t.status !== "confirmed" || t.time >= since);
+      }
+      const page = { items, page: pageNo, totalPages };
+      if (more) page.cursor = encodeCursor({ v: 1, p: pageNo + 1, s: pageSize });
+      return page;
+    },
+    async getTransaction(hash, address) {
+      const tx = await failover((c) => c.getTransactionDetails(hash));
+      return tx ? mapBlockbookTx(chain, address, tx) : void 0;
+    },
+    explorerTxUrl(hash) {
+      return btcExplorerTxUrl(hash, network);
+    }
+  };
+}
+
+export {
+  CAIP2_GENESIS,
+  DEFAULT_TIMEOUT_MS,
+  fetchWithTimeout,
+  isRecord,
+  isHex64,
+  unconfirmedOutgoing,
+  BlockbookClient,
+  HistoryUnavailableError,
+  encodeCursor,
+  decodeCursor,
+  mapBlockbookTx,
+  btcExplorerTxUrl,
+  createBtcHistory
+};
+//# sourceMappingURL=chunk-KAAQYL5X.js.map