beignet 0.30.2 → 0.31.1

package/README.md

@@ -7,7 +7,7 @@ Two layers, one mnemonic:
 - **On-chain wallet:** HD keys, address generation, UTXO tracking, transaction building, PSBT/hardware signing, multisig, watch-only, Electrum connectivity.
 - **Lightning:** channel lifecycle, onion-routed payments, BOLT 11 invoices, BOLT 12 offers, gossip and pathfinding, anchors, splicing, taproot channels, watchtower client. Interop-tested against LND, Core Lightning and Eclair on regtest.
 
-Requires **Node.js 18+**. MIT licensed.
+Requires **Node.js 22.23.4+, 24.22.1+ or 26.12.1+**. Earlier releases on those lines, and all of Node.js 18 and 20, lack the October 21, 2026 Node.js security fixes; the daemon warns at startup when it runs on one. MIT licensed.
 
 **Jump to:** [Install](#install) · [Examples](#try-the-examples) · [On-chain wallet](#on-chain-wallet) · [Lightning](#lightning) · [Daemon & CLI](#http-daemon--cli) · [Protocol layer](#protocol-layer-advanced) · [Tests](#tests) · [Status & limitations](#status--limitations)
 
@@ -52,16 +52,16 @@ npm install
 npm run example
 ```
 
-Creates a mainnet wallet (a fresh mnemonic unless you pass one), syncs it against a public Electrum server, prints the balance and a receive address, then drops you at a `>` prompt with the wallet bound to `wallet`. Type `help()` for the command list.
+Creates a regtest wallet (a fresh mnemonic unless you pass one), syncs it against a public Electrum server, prints the balance and a receive address, then drops you at a `>` prompt with the wallet bound to `wallet`. Type `help()` for the command list.
 
 ```js
 > wallet.getBalance()
 > await wallet.getAddress()
 > await wallet.refreshWallet()
-> await wallet.send({ address: 'bc1q...', amount: 10000, satsPerByte: 2 })
+> await wallet.send({ address: 'bcrt1q...', amount: 10000, satsPerByte: 2 })
 ```
 
-State persists as JSON under `example/walletData/`. Pass a mnemonic as the first argument to reuse a wallet: `npm run example -- "abandon abandon ... about"`.
+State persists as JSON under `example/walletData/`. Pass a mnemonic to reuse a wallet: `npm run example -- "abandon abandon ... about"`. Pass `testnet` or `mainnet` to change the network.
 
 ### 2. Lightning node REPL
 
@@ -69,7 +69,7 @@ State persists as JSON under `example/walletData/`. Pass a mnemonic as the first
 npm run example:lightning
 ```
 
-Boots a real Lightning node (`BeignetNode`) with an auto-created wallet, storage and funding provider, waits for it to become operational, prints info/balance/health, and drops you at a `beignet>` prompt with the node bound to `node`. Type `help()` for the command list. Top-level `await` works.
+Boots a real regtest Lightning node (`BeignetNode`) with an auto-created wallet, storage and funding provider, waits for it to become operational, prints info/balance/health, and drops you at a `beignet>` prompt with the node bound to `node`. Type `help()` for the command list. Top-level `await` works.
 
 ```js
 beignet> await node.getNewAddress()          // fund this on-chain, then:
@@ -83,7 +83,7 @@ The flags you will actually reach for (everything after `--`):
 
 | Flag | Effect |
 |------|--------|
-| `mainnet` \| `testnet` \| `regtest` | Network, as a bare positional arg (default `mainnet`) |
+| `mainnet` \| `testnet` \| `regtest` | Network, as a bare positional arg (default `regtest`) |
 | `<12 or 24 words>` | Reuse a mnemonic, as bare positional args (default generates one) |
 | `--electrum-host <h>` `--electrum-port <p>` | Point at your own Electrum server |
 | `--alias <name>` | Node alias in `node_announcement` |
@@ -93,6 +93,8 @@ The flags you will actually reach for (everything after `--`):
 npm run example:lightning -- regtest --electrum-host 127.0.0.1 --electrum-port 60001 --alias mynode
 ```
 
+Both examples print the network and the mnemonic before anything else. A generated mnemonic exists only in that output, so write it down before funding the wallet, and pass your own on mainnet.
+
 Tor, full-graph gossip, the low-level `LightningNode` variant and the non-interactive payment-API walkthrough have flags too: see [the flag reference](example/REPL_TESTING.md#repl-flags).
 
 Node state lives in a SQLite DB under `~/.beignet/data/<hash-of-mnemonic>/` (the `--low-level` example uses `example/lightningData/node.db`).
@@ -160,7 +162,7 @@ const res = await Wallet.create({
 ```
 
 - **Failover:** with multiple servers the wallet rotates through them in order on connect/reconnect failure, then through hardcoded fallback peers for the network, with a per-server cooldown so dead servers are not hammered. Inspect `wallet.electrum.currentServer` and `wallet.electrum.rotationCount`.
-- **Certificate verification:** by default a TLS Electrum connection is encrypted but the server certificate is not checked, because the client library dials with `rejectUnauthorized: false`. An on-path attacker can therefore stand in for the server. On Node, pass `tls: withTlsVerification(tls)` to accept only certificates that chain to a trusted CA and match the host, and add `{ fingerprints: ['AB:CD:…'] }` to also accept self-signed servers by SHA-256 fingerprint (`openssl x509 -noout -fingerprint -sha256`). The CLI/daemon and React Native do not verify yet.
+- **Certificate verification:** by default a TLS Electrum connection is encrypted but the server certificate is not checked, because the client library dials with `rejectUnauthorized: false`. An on-path attacker can therefore stand in for the server. On Node, pass `tls: withTlsVerification(tls)` to accept only certificates that chain to a trusted CA and match the host, and add `{ fingerprints: ['AB:CD:…'] }` to also accept self-signed servers by SHA-256 fingerprint (`openssl x509 -noout -fingerprint -sha256`). A caller that resolves the host itself and dials the address passes `{ servernames: { [address]: hostName } }` so the check still uses the name. The client library keeps one connection per network for the whole process, shared by every wallet on that network, so wallets in one process should all pass the same `tls`. The daemon verifies when `BEIGNET_ELECTRUM_TLS_VERIFY=true` (see `src/cli/README.md`); it is off by default. React Native does not verify yet.
 - **Fee source:** `'electrum'` queries only the connected server via `blockchain.estimatefee`, so fee lookups never leak to mempool.space/blocktank over clearnet. `'auto'` prefers Electrum and falls back to HTTP. All remote rates are clamped to 5000 sat/vB.
 - **Networks:** mainnet, testnet, regtest and signet work end to end (wallet, Electrum, CLI/daemon `--network signet`, Lightning chain hash and `tbs` invoice prefix). Signet shares testnet address formats and coin type 1.
 - **BIP21:** `encodeBip21({ address, amountSats?, label?, message? })` builds a `bitcoin:` URI.
@@ -291,6 +293,8 @@ coordinator.exportDescriptors();
 
 The wallet persists through the host-injected `TStorage` interface (`storage: { getData, setData }`), and values are handed over as-is, so by default they are stored in plaintext. Persisted data is addresses, indexes, UTXOs, transactions, balance and fee estimates: no private keys and no mnemonic are ever written, so exposure is a privacy concern (full wallet history), not fund loss. The staged send (`transaction`) is written without signing keys, so a key pair handed to `sweepPrivateKey` or `addExternalInputs` never reaches storage, and `send`, `sendMany`, `sendMax`, `buildPsbt` and `sweepPrivateKey` reset the staged send when they return, so a restart never replays an earlier call's recipients.
 
+`getData` must return `ok(undefined)` for a key it does not hold and `err` only when the read fails. `Wallet.create` returns an error on a failed read rather than start from defaults and save them over the data it could not read; pass `resetOnReadFailure: true` to start from defaults anyway.
+
 Wrap any `TStorage` with `createEncryptedStorage` to encrypt at rest with AES-256-GCM under an HKDF-derived key from the seed. Pre-existing plaintext values pass through unchanged and migrate lazily as they are rewritten.
 
 ```typescript
@@ -403,6 +407,7 @@ Automatic modes, opt-in via `BeignetNodeOptions` / `INodeConfig`:
 ```typescript
 const node = await BeignetNode.create({
   mnemonic,
+  network: 'mainnet',
   // Periodically executes the rebalance plan. Routing fees spent on rebalances
   // are capped per UTC day and the running spend is persisted, so restarts
   // never overspend the same day. Resets at midnight UTC.
@@ -428,6 +433,7 @@ Penalty enforcement normally needs this node's chain monitor to be online: if a
 ```typescript
 const node = await BeignetNode.create({
   mnemonic,
+  network: 'mainnet',
   watchtowers: ['03abc...@tower.example.com:9911'] // off when empty
 });
 ```
@@ -670,9 +676,8 @@ LightningNode              High-level API (EventEmitter)
 
 ## Tests
 
-Use **Node.js 20 (20.19+)** for development and `npm ci` to install the locked tools.
-The linter and test runner have newer Node requirements than the library API.
-CI uses Node.js 20.
+Use **Node.js 24 (24.22.1+)** for development and `npm ci` to install the locked tools.
+CI uses Node.js 24.22.1.
 
 The lint configuration keeps the established CommonJS imports, enum aliases,
 unused catch bindings, `any` warnings and Chai assertion style. Rules removed

package/dist/cli/beignet-node.js

@@ -25,13 +25,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BeignetNode = exports.jitInvoiceError = exports.holdInvoiceEvent = exports.jsonSafeEvent = exports.jitReceiveRefusal = exports.leaseRatesRefusal = exports.defaultMaxFeeMsat = exports.DEFAULT_MAX_FEE_FLOOR_SATS = exports.DEFAULT_MAX_FEE_PPM = exports.clampDirectFundingMinimum = exports.DAILY_SPEND_STATE_KEY = exports.MAX_ASYNC_SPEND_CLAIMS = exports.ASYNC_SPEND_CLAIM_TTL_MS = exports.jsonToRouteHops = exports.routeHopsToJson = exports.spliceRefusalError = exports.decodeOfferInput = exports.paymentAdmissionSats = exports.paymentSpendSats = exports.hopFeeMsat = exports.spendLimitSats = exports.decodeInvoiceInput = exports.ENGINE_PAYMENT_ERROR_CODES = exports.parseScid = exports.formatScid = exports.gossipPrimeLatch = exports.defaultDataDirForMnemonic = exports.parseRecoveryMode = void 0;
 const iroh_config_1 = require("./iroh-config");
+const electrum_tls_config_1 = require("./electrum-tls-config");
 const iroh_node_1 = require("../lightning/transport/iroh-node");
 const offline_receive_1 = require("./offline-receive");
 const ffor_receive_1 = require("./ffor-receive");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
-const tls = __importStar(require("tls"));
 const dns_1 = require("dns");
 const instance_lock_1 = require("./instance-lock");
 const crypto = __importStar(require("crypto"));
@@ -41,6 +41,7 @@ const wallet_2 = require("../shapes/wallet");
 const logger_1 = require("../logger");
 const helpers_1 = require("../utils/helpers");
 const conversion_1 = require("../utils/conversion");
+const boost_1 = require("../utils/boost");
 const wallet_3 = require("../types/wallet");
 const wallet_storage_1 = require("./wallet-storage");
 const onchain_sweep_1 = require("./onchain-sweep");
@@ -347,6 +348,10 @@ const nextUtcMidnight = () => {
 };
 const MAX_DIRECT_FUNDING_CHARGES = 1024;
 const DEFAULT_L402_MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
+const NETWORK_NAMES = ['mainnet', 'testnet', 'signet', 'regtest'];
+function unknownNetwork(network) {
+    throw new errors_1.BeignetError('INVALID_PARAMS', `unknown network '${String(network)}'`);
+}
 const DEFAULT_ELECTRUM = {
     mainnet: { host: 'fulcrum.bitkit.blocktank.to', port: 8900, useTls: true },
     testnet: { host: 'electrum.blockstream.info', port: 60002, useTls: true },
@@ -764,12 +769,25 @@ class BeignetNode extends events_1.EventEmitter {
     static async create(opts = {}) {
         try {
             (0, iroh_config_1.validateIrohConfig)(opts);
+            (0, electrum_tls_config_1.validateElectrumTlsConfig)(opts);
         }
         catch (err) {
             throw new errors_1.BeignetError('INVALID_PARAMS', err.message);
         }
+        if (!opts.network) {
+            throw new errors_1.BeignetError('INVALID_PARAMS', "network is required: 'mainnet', 'testnet', 'signet' or 'regtest'");
+        }
+        if (!NETWORK_NAMES.includes(opts.network)) {
+            throw new errors_1.BeignetError('INVALID_PARAMS', `unknown network '${opts.network}': expected 'mainnet', 'testnet', 'signet' or 'regtest'`);
+        }
         const mnemonic = opts.mnemonic || (0, helpers_1.generateMnemonic)();
-        const networkName = opts.network || 'mainnet';
+        const networkName = opts.network;
+        try {
+            (0, electrum_tls_config_1.checkElectrumTls)(networkName, opts);
+        }
+        catch (err) {
+            throw new errors_1.BeignetError('INVALID_PARAMS', err.message);
+        }
         const dataDir = opts.dataDir || defaultDataDirForMnemonic(mnemonic);
         const dirMode = (0, fs_utils_1.ensurePrivateDir)(dataDir);
         const instance = new BeignetNode(mnemonic, networkName, dataDir);
@@ -973,6 +991,24 @@ class BeignetNode extends events_1.EventEmitter {
                 ipv4: electrumHost
             });
         }
+        const walletTls = (0, electrum_tls_config_1.electrumTlsModule)(opts, electrumHost, rawElectrumHost);
+        try {
+            (0, electrum_tls_config_1.claimElectrumTls)(this, networkName, opts);
+        }
+        catch (err) {
+            throw new errors_1.BeignetError('INVALID_PARAMS', err.message);
+        }
+        if (opts.electrumTlsVerify === true) {
+            const pinnedFingerprints = opts.electrumTlsFingerprints?.length ?? 0;
+            this.log('info', 'Verifying Electrum TLS certificates', {
+                pinnedFingerprints
+            });
+            if (!electrumTls) {
+                this.log('warn', 'The configured Electrum server is plain TCP, so its certificate is ' +
+                    'never checked and pinned fingerprints are not used for it; only ' +
+                    'the TLS fallback servers are verified', { host: rawElectrumHost, port: electrumPort, pinnedFingerprints });
+            }
+        }
         const beignetNetwork = this.toBeignetNetwork(networkName);
         const lnNetwork = this.toLnNetwork(networkName);
         const coinType = this.toCoinType(networkName);
@@ -996,7 +1032,7 @@ class BeignetNode extends events_1.EventEmitter {
                 : {}),
             electrumOptions: {
                 net,
-                tls,
+                tls: walletTls,
                 servers: electrumServer
             },
             disableMessagesOnCreate: true,
@@ -1006,6 +1042,7 @@ class BeignetNode extends events_1.EventEmitter {
             storage: (0, wallet_storage_1.createWalletStorage)(this.storage)
         });
         if (walletResult.isErr()) {
+            (0, electrum_tls_config_1.releaseElectrumTls)(this);
             throw new errors_1.BeignetError('WALLET_CREATE_FAILED', walletResult.error.message);
         }
         this.wallet = walletResult.value;
@@ -3488,12 +3525,15 @@ class BeignetNode extends events_1.EventEmitter {
         this._onchainSendLock = run.catch(() => undefined);
         return run;
     }
+    _runWalletSend(fn) {
+        return this._runOnchainSend(() => this.wallet.withSendLock(fn));
+    }
     async sendOnchain(address, amountSats, satsPerVbyte) {
         this._checkMaxPayment(amountSats);
         this._checkSpendLimit(amountSats);
-        return this._runOnchainSend(async () => {
+        return this._runWalletSend(async (locked) => {
             try {
-                const result = await this.wallet.send({
+                const result = await locked.send({
                     address,
                     amount: amountSats,
                     broadcast: false,
@@ -3541,9 +3581,9 @@ class BeignetNode extends events_1.EventEmitter {
             }
         }
         this._validateFeeRate(satsPerVbyte);
-        return this._runOnchainSend(async () => {
+        return this._runWalletSend(async (locked) => {
             try {
-                const result = await this.wallet.buildPsbt({
+                const result = await locked.buildPsbt({
                     txs: outputs.map((o) => ({
                         address: o.address,
                         amount: o.amountSats
@@ -3740,9 +3780,9 @@ class BeignetNode extends events_1.EventEmitter {
             throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, `Invalid ${this.networkName} address: ${address}`);
         }
         this._validateFeeRate(satsPerVbyte);
-        return this._runOnchainSend(async () => {
+        return this._runWalletSend(async (locked) => {
             try {
-                const result = await this.wallet.sendMax({
+                const result = await locked.sendMax({
                     address,
                     satsPerByte: satsPerVbyte ?? this.wallet.feeEstimates.normal,
                     rbf: this.wallet.rbf,
@@ -3814,7 +3854,7 @@ class BeignetNode extends events_1.EventEmitter {
         });
     }
     prepareOnchainSweep(request) {
-        return this._runOnchainSend(() => this.onchainSweeps().prepare(request));
+        return this._runWalletSend(() => this.onchainSweeps().prepare(request));
     }
     submitOnchainSweep(requestId) {
         return this._runOnchainSend(() => this.onchainSweeps().submit(requestId));
@@ -3834,7 +3874,7 @@ class BeignetNode extends events_1.EventEmitter {
                 ? `Transaction ${txid} cannot be replaced via RBF; use POST /tx/boost (CPFP) instead`
                 : `Transaction ${txid} is not boostable (unknown, already confirmed, or balance too low)`);
         }
-        return this._boostRbf(txid, satsPerVbyte);
+        return this._boost(txid, wallet_3.EBoostType.rbf, satsPerVbyte);
     }
     async boostOnchain(txid, satsPerVbyte) {
         this._validateTxid(txid);
@@ -3845,7 +3885,7 @@ class BeignetNode extends events_1.EventEmitter {
         }
         if (can.rbf) {
             try {
-                return await this._boostRbf(txid, satsPerVbyte);
+                return await this._boost(txid, wallet_3.EBoostType.rbf, satsPerVbyte);
             }
             catch (e) {
                 const rbfImpossible = e instanceof errors_1.BeignetError &&
@@ -3854,94 +3894,34 @@ class BeignetNode extends events_1.EventEmitter {
                     throw e;
             }
         }
-        return this._boostCpfp(txid, satsPerVbyte);
-    }
-    async _boostRbf(txid, satsPerVbyte) {
-        return this._runOnchainSend(async () => {
-            const setup = await this.wallet.transaction.setupRbf({ txid });
-            if (setup.isErr()) {
-                await this.wallet.resetSendTransaction();
-                throw new errors_1.BeignetError(errors_1.BeignetErrorCode.NOT_BOOSTABLE, setup.error.message);
-            }
-            try {
-                if (satsPerVbyte !== undefined) {
-                    const feeRes = this.wallet.transaction.updateFee({
-                        satsPerByte: satsPerVbyte
-                    });
-                    if (feeRes.isErr()) {
-                        throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, feeRes.error.message);
-                    }
-                }
-                const original = this.wallet.unconfirmedTransactions[txid] ??
-                    this.wallet.transactions[txid];
-                const originalFeeSats = original ? (0, conversion_1.btcToSats)(original.fee) : 0;
-                const newFeeSats = this.wallet.transaction.data.fee;
-                if (newFeeSats <= originalFeeSats) {
-                    throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, `Replacement fee ${newFeeSats} sats does not exceed the original fee ${originalFeeSats} sats; raise satsPerVbyte`);
-                }
-                const createRes = await this.wallet.transaction.createTransaction();
-                if (createRes.isErr()) {
-                    throw new errors_1.BeignetError('SEND_FAILED', createRes.error.message);
-                }
-                const info = await this._broadcastRawTx(createRes.value.hex);
-                await this._recordBoost(txid, info.txid, wallet_3.EBoostType.rbf, newFeeSats);
-                return {
-                    ...info,
-                    boostType: 'rbf',
-                    feeSats: newFeeSats,
-                    originalTxid: txid
-                };
-            }
-            finally {
-                await this.wallet.resetSendTransaction();
-            }
-        });
+        return this._boost(txid, wallet_3.EBoostType.cpfp, satsPerVbyte);
     }
-    async _boostCpfp(txid, satsPerVbyte) {
+    _boost(txid, type, satsPerVbyte) {
         return this._runOnchainSend(async () => {
-            const setup = await this.wallet.transaction.setupCpfp({
+            const res = await this.wallet.boost({
                 txid,
+                type,
                 ...(satsPerVbyte !== undefined ? { satsPerByte: satsPerVbyte } : {})
             });
-            if (setup.isErr()) {
-                await this.wallet.resetSendTransaction();
-                throw new errors_1.BeignetError(errors_1.BeignetErrorCode.NOT_BOOSTABLE, setup.error.message);
-            }
-            try {
-                const feeSats = setup.value.fee;
-                const createRes = await this.wallet.transaction.createTransaction();
-                if (createRes.isErr()) {
-                    throw new errors_1.BeignetError('SEND_FAILED', createRes.error.message);
-                }
-                const info = await this._broadcastRawTx(createRes.value.hex);
-                await this._recordBoost(txid, info.txid, wallet_3.EBoostType.cpfp, feeSats);
-                return {
-                    ...info,
-                    boostType: 'cpfp',
-                    feeSats,
-                    originalTxid: txid
-                };
-            }
-            finally {
-                await this.wallet.resetSendTransaction();
+            if (res.isErr()) {
+                const code = res.error instanceof boost_1.BoostError
+                    ? {
+                        NOT_BOOSTABLE: errors_1.BeignetErrorCode.NOT_BOOSTABLE,
+                        INVALID_FEE: errors_1.BeignetErrorCode.INVALID_PARAMS,
+                        SEND_FAILED: errors_1.BeignetErrorCode.SEND_FAILED
+                    }[res.error.code]
+                    : errors_1.BeignetErrorCode.SEND_FAILED;
+                throw new errors_1.BeignetError(code, res.error.message);
             }
+            return {
+                txid: res.value.id,
+                hex: res.value.hex,
+                boostType: type === wallet_3.EBoostType.rbf ? 'rbf' : 'cpfp',
+                feeSats: res.value.fee,
+                originalTxid: txid
+            };
         });
     }
-    async _recordBoost(oldTxId, newTxId, type, fee) {
-        const res = await this.wallet.addBoostedTransaction({
-            oldTxId,
-            newTxId,
-            type,
-            fee
-        });
-        if (res.isErr()) {
-            this.log('warn', 'Failed to record boosted transaction', {
-                oldTxId,
-                newTxId,
-                error: res.error.message
-            });
-        }
-    }
     listBoostableTransactions() {
         const { rbf, cpfp } = this.wallet.getBoostableTransactions();
         return {
@@ -3958,9 +3938,9 @@ class BeignetNode extends events_1.EventEmitter {
             throw new errors_1.BeignetError(errors_1.BeignetErrorCode.NOTHING_TO_CONSOLIDATE, `Nothing to consolidate: wallet has ${utxoCount} spendable UTXO(s), need at least 2`);
         }
         const address = await this.getNewAddress();
-        return this._runOnchainSend(async () => {
+        return this._runWalletSend(async (locked) => {
             try {
-                const result = await this.wallet.sendMax({
+                const result = await locked.sendMax({
                     address,
                     satsPerByte: satsPerVbyte ?? this.wallet.feeEstimates.normal,
                     rbf: this.wallet.rbf,
@@ -3992,6 +3972,15 @@ class BeignetNode extends events_1.EventEmitter {
             this.emit('onchain:rbf', { txids: data });
             return;
         }
+        if (key === 'storageWriteFailed') {
+            const failure = data;
+            this.log('error', 'Wallet storage write failed', {
+                key: failure.key,
+                storageKey: failure.storageKey,
+                error: failure.error
+            });
+            return;
+        }
         const relayed = {
             transactionReceived: {
                 event: 'transaction:received',
@@ -4412,10 +4401,7 @@ class BeignetNode extends events_1.EventEmitter {
         return this.raceWithTimeout(this.resolveCurrentWalletAddressScript().catch(() => undefined), this._closeAddressLookupTimeoutMs);
     }
     fforChannelId(channelId) {
-        if (typeof channelId !== 'string' || !/^[0-9a-fA-F]{64}$/.test(channelId)) {
-            throw new errors_1.BeignetError('INVALID_PARAMS', 'channelId must be 64 hex characters');
-        }
-        const idBuf = Buffer.from(channelId, 'hex');
+        const idBuf = requireChannelIdHex(channelId);
         if (!this.node.getChannel(idBuf)) {
             throw new errors_1.BeignetError(errors_1.BeignetErrorCode.CHANNEL_NOT_FOUND, `Channel not found: ${idBuf.toString('hex')}`);
         }
@@ -4747,6 +4733,9 @@ class BeignetNode extends events_1.EventEmitter {
             }
             throw err;
         });
+        if (r.action === 'force-close-refused') {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.FORCE_CLOSE_FAILED, r.error ?? 'Force close failed');
+        }
         return {
             action: r.action,
             preimagesKnown: r.preimagesKnown,
@@ -4857,10 +4846,7 @@ class BeignetNode extends events_1.EventEmitter {
         };
     }
     forceCloseChannel(channelId, acceptStaleStateRisk = false) {
-        if (!/^[0-9a-fA-F]{64}$/.test(channelId)) {
-            throw new errors_1.BeignetError('INVALID_PARAMS', 'channelId must be 64 hex characters');
-        }
-        const idBuf = Buffer.from(channelId, 'hex');
+        const idBuf = requireChannelIdHex(channelId);
         if (!this.node.getChannel(idBuf)) {
             throw new errors_1.BeignetError(errors_1.BeignetErrorCode.CHANNEL_NOT_FOUND, `Channel not found: ${idBuf.toString('hex')}`);
         }
@@ -4921,23 +4907,23 @@ class BeignetNode extends events_1.EventEmitter {
                 : REESTABLISH_FORCE_CLOSE_REFUSAL);
         }
     }
-    rebroadcastClose(channelId) {
-        return this.node.rebroadcastClose(Buffer.from(channelId, 'hex'));
+    async rebroadcastClose(channelId) {
+        return this.node.rebroadcastClose(requireChannelIdHex(channelId));
     }
     listChannels() {
         return this.node.listChannels().map((ch) => this.toChannelInfo(ch));
     }
     getChannel(channelId) {
-        const ch = this.node.getChannel(Buffer.from(channelId, 'hex'));
+        const ch = this.node.getChannel(requireChannelIdHex(channelId));
         if (!ch)
             return null;
         return this.toChannelInfo(ch);
     }
     getChannelHealth(channelId) {
-        return this.node.getChannelHealth(Buffer.from(channelId, 'hex'));
+        return this.node.getChannelHealth(requireChannelIdHex(channelId));
     }
     getChannelDiagnostics(channelId) {
-        const channelIdBuf = Buffer.from(channelId, 'hex');
+        const channelIdBuf = requireChannelIdHex(channelId);
         const channel = this.node.getChannelManager().getChannel(channelIdBuf);
         if (!channel)
             return null;
@@ -6958,9 +6944,15 @@ class BeignetNode extends events_1.EventEmitter {
         return { valid: true, proof };
     }
     updateChannelFee(channelId, feeratePerKw) {
-        return this.node.updateChannelFee(Buffer.from(channelId, 'hex'), feeratePerKw);
+        return this.node.updateChannelFee(requireChannelIdHex(channelId), feeratePerKw);
     }
     updateChannelPolicy(channelId, policy) {
+        return this.applyChannelPolicy(requireChannelIdHex(channelId), [channelId], policy);
+    }
+    updateAllChannelPolicies(policy) {
+        return this.applyChannelPolicy('all', this.node.listChannels().map((ch) => ch.channelId.toString('hex')), policy);
+    }
+    applyChannelPolicy(target, channelIds, policy) {
         const update = {};
         if (policy.feeBaseMsat !== undefined)
             update.feeBaseMsat = policy.feeBaseMsat;
@@ -6972,17 +6964,14 @@ class BeignetNode extends events_1.EventEmitter {
             update.htlcMinimumMsat = requireMsatValue(policy.htlcMinimumMsat, 'htlcMinimumMsat');
         if (policy.htlcMaximumMsat !== undefined)
             update.htlcMaximumMsat = requireMsatValue(policy.htlcMaximumMsat, 'htlcMaximumMsat');
-        const targets = channelId === 'all'
-            ? this.node.listChannels().map((ch) => ch.channelId.toString('hex'))
-            : [channelId];
-        this.node.setChannelPolicy(channelId === 'all' ? 'all' : Buffer.from(channelId, 'hex'), update);
-        const policies = targets
+        this.node.setChannelPolicy(target, update);
+        const policies = channelIds
             .map((id) => this.getChannelPolicy(id))
             .filter((p) => p !== null);
         return { updated: policies.length, policies };
     }
     getChannelPolicy(channelId) {
-        const policy = this.node.getChannelPolicy(Buffer.from(channelId, 'hex'));
+        const policy = this.node.getChannelPolicy(requireChannelIdHex(channelId));
         if (!policy)
             return null;
         return {
@@ -7069,7 +7058,7 @@ class BeignetNode extends events_1.EventEmitter {
         return info;
     }
     async waitForChannelReady(channelId, timeoutMs = 60000) {
-        return this.node.waitForChannelReady(Buffer.from(channelId, 'hex'), timeoutMs);
+        return this.node.waitForChannelReady(requireChannelIdHex(channelId), timeoutMs);
     }
     async waitForReady(timeoutMs = 30000) {
         return this.node.waitForReady(timeoutMs);
@@ -7373,21 +7362,17 @@ class BeignetNode extends events_1.EventEmitter {
                 paid = settlesInvoice(live);
             }
             else {
-                if (!durablePaid)
-                    durablePaid = this.durablePaidHashes();
+                if (!durablePaid) {
+                    durablePaid = this.storage.paymentHashesWith({
+                        status: 'COMPLETED',
+                        direction: 'INCOMING'
+                    });
+                }
                 paid = durablePaid.has(inv.paymentHash);
             }
             return this.toInvoiceInfo(inv, paid);
         });
     }
-    durablePaidHashes() {
-        const paid = new Set();
-        for (const { paymentHash, payment } of this.storage.loadAllPayments()) {
-            if (settlesInvoice(payment))
-                paid.add(paymentHash);
-        }
-        return paid;
-    }
     toInvoiceInfo(inv, paid) {
         const info = {
             bolt11: inv.bolt11,
@@ -7698,10 +7683,8 @@ class BeignetNode extends events_1.EventEmitter {
     async rebalanceChannel(fromChannelId, toChannelId, amountSats, maxFeeSats) {
         if (this.isGraphRestoring())
             await this.whenGraphRestored();
-        if (!/^[0-9a-fA-F]{64}$/.test(fromChannelId))
-            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'fromChannelId must be 64 hex chars');
-        if (!/^[0-9a-fA-F]{64}$/.test(toChannelId))
-            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'toChannelId must be 64 hex chars');
+        const fromIdBuf = requireChannelIdHex(fromChannelId, 'fromChannelId');
+        const toIdBuf = requireChannelIdHex(toChannelId, 'toChannelId');
         if (!Number.isInteger(amountSats) || amountSats <= 0)
             throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'amountSats must be a positive integer');
         if (!Number.isInteger(maxFeeSats) || maxFeeSats < 0)
@@ -7717,8 +7700,8 @@ class BeignetNode extends events_1.EventEmitter {
         let result;
         try {
             result = await this.node.rebalanceChannel({
-                fromChannelId: Buffer.from(fromChannelId, 'hex'),
-                toChannelId: Buffer.from(toChannelId, 'hex'),
+                fromChannelId: fromIdBuf,
+                toChannelId: toIdBuf,
                 amountSats: BigInt(amountSats),
                 maxFeeSats: BigInt(maxFeeSats)
             });
@@ -7907,13 +7890,13 @@ class BeignetNode extends events_1.EventEmitter {
     describeGraph(limit, offset) {
         const cappedLimit = Math.min(Math.max(1, Math.floor(limit ?? GRAPH_DESCRIBE_MAX_LIMIT)), GRAPH_DESCRIBE_MAX_LIMIT);
         const safeOffset = Math.max(0, Math.floor(offset ?? 0));
-        const all = this.node.getGraph().getAllChannels();
+        const graph = this.node.getGraph();
         return {
-            totalChannels: all.length,
+            totalChannels: graph.getChannelCount(),
             limit: cappedLimit,
             offset: safeOffset,
-            channels: all
-                .slice(safeOffset, safeOffset + cappedLimit)
+            channels: graph
+                .getChannelPage(safeOffset, cappedLimit)
                 .map((ch) => this.toGraphChannelInfo(ch))
         };
     }
@@ -8849,7 +8832,9 @@ class BeignetNode extends events_1.EventEmitter {
         this._nodeStorageView?.close();
         this.removeAllListeners();
         try {
-            await this.wallet?.stop();
+            const stopped = await this.wallet?.stop();
+            if (!stopped?.isErr())
+                (0, electrum_tls_config_1.releaseElectrumTls)(this);
         }
         catch {
         }
@@ -8881,7 +8866,7 @@ class BeignetNode extends events_1.EventEmitter {
             case 'signet':
                 return wallet_3.EAvailableNetworks.signet;
             default:
-                return wallet_3.EAvailableNetworks.bitcoin;
+                return unknownNetwork(network);
         }
     }
     toLnNetwork(network) {
@@ -8895,7 +8880,7 @@ class BeignetNode extends events_1.EventEmitter {
             case 'signet':
                 return types_5.Network.SIGNET;
             default:
-                return types_5.Network.MAINNET;
+                return unknownNetwork(network);
         }
     }
     toCoinType(network) {
@@ -8909,7 +8894,7 @@ class BeignetNode extends events_1.EventEmitter {
             case 'signet':
                 return wallet_keys_1.LnCoinType.SIGNET;
             default:
-                return wallet_keys_1.LnCoinType.BITCOIN;
+                return unknownNetwork(network);
         }
     }
     getBitcoinNetwork() {