beignet 0.26.0 → 0.28.0

package/dist/cli/beignet-node.js

@@ -43,6 +43,7 @@ const helpers_1 = require("../utils/helpers");
 const conversion_1 = require("../utils/conversion");
 const wallet_3 = require("../types/wallet");
 const wallet_storage_1 = require("./wallet-storage");
+const onchain_sweep_1 = require("./onchain-sweep");
 const fs_utils_1 = require("./fs-utils");
 const backup_mac_1 = require("./backup-mac");
 const node_storage_view_1 = require("./node-storage-view");
@@ -174,6 +175,9 @@ function parseScid(scid) {
 }
 exports.parseScid = parseScid;
 exports.ENGINE_PAYMENT_ERROR_CODES = {
+    PAY_ALL_REVIEW_EXPIRED: 'PAY_ALL_REVIEW_EXPIRED',
+    PAY_ALL_REMAINDER: 'PAY_ALL_REMAINDER',
+    PAY_ALL_BUDGET_MISMATCH: 'PAY_ALL_BUDGET_MISMATCH',
     NO_ROUTE: 'NO_ROUTE',
     DUPLICATE_PAYMENT: 'DUPLICATE_PAYMENT',
     NO_CHANNEL_TO_HOP: 'PEER_NOT_CONNECTED',
@@ -718,6 +722,7 @@ class BeignetNode extends events_1.EventEmitter {
         this.rapidGossipSync = true;
         this._initialGossipPrime = null;
         this._releaseBootRgs = null;
+        this._rapidGossipSync = null;
         this._deferredGossipSyncs = new Set();
         this.electrumServerCount = 1;
         this._failoverInProgress = false;
@@ -861,6 +866,10 @@ class BeignetNode extends events_1.EventEmitter {
                 throw new errors_1.BeignetError('INVALID_PARAMS', `leaseRates: ${refusal}`);
             }
         }
+        if (opts.waiveClientReserve !== undefined &&
+            typeof opts.waiveClientReserve !== 'boolean') {
+            throw new errors_1.BeignetError('INVALID_PARAMS', 'waiveClientReserve must be a boolean');
+        }
         if (opts.jitReceive !== undefined) {
             const refusal = jitReceiveRefusal(opts.jitReceive);
             if (refusal !== null) {
@@ -908,7 +917,7 @@ class BeignetNode extends events_1.EventEmitter {
         }
         let encryptionKey;
         if (opts.storageEncryption ?? true) {
-            encryptionKey = (0, encryption_1.deriveStorageKey)(bip39.mnemonicToSeedSync(this.mnemonic));
+            encryptionKey = (0, encryption_1.deriveStorageKey)(this.walletSeed());
         }
         this._storageEncryptionKey = encryptionKey;
         this.finishStagedCapsuleRestore(dbPath);
@@ -969,6 +978,7 @@ class BeignetNode extends events_1.EventEmitter {
         };
         const walletResult = await wallet_1.Wallet.create({
             mnemonic: this.mnemonic,
+            seed: this.walletSeed(),
             network: beignetNetwork,
             disableRefreshOnCreate: true,
             ...(opts.addressType
@@ -1086,6 +1096,7 @@ class BeignetNode extends events_1.EventEmitter {
         this._nodeStorageView = (0, node_storage_view_1.nodeStorageView)(this.storage);
         this.node = lightning_node_1.LightningNode.fromMnemonic(this.mnemonic, {
             coinType,
+            seed: this.walletSeed(),
             network: lnNetwork,
             storage: this._nodeStorageView,
             newChannelsRefused: () => this.newChannelRefusal(),
@@ -1135,6 +1146,11 @@ class BeignetNode extends events_1.EventEmitter {
                 }
                 : {}),
             ...(opts.fforIssuer === true ? { fforIssuer: { enabled: true } } : {}),
+            zeroReserve: {
+                role: 'primary',
+                advertise: opts.waiveClientReserve === true,
+                waiveClientReserve: opts.waiveClientReserve === true
+            },
             jitReceive: opts.jitReceive?.enabled === true
                 ? {
                     enabled: true,
@@ -1770,6 +1786,10 @@ class BeignetNode extends events_1.EventEmitter {
         }
         if (this.rapidGossipSync && this.networkName === 'mainnet') {
             const rgs = this.syncRapidGossip().catch((err) => {
+                if (err instanceof rapid_sync_1.RapidGossipCancelledError && this.destroyed) {
+                    this.log('debug', 'Rapid gossip sync cancelled by shutdown', {});
+                    return;
+                }
                 this.log('warn', 'Rapid gossip sync failed', {
                     error: err instanceof Error ? err.message : String(err)
                 });
@@ -2700,6 +2720,7 @@ class BeignetNode extends events_1.EventEmitter {
         return path.join(this.dataDir, `${this.networkName}.capsule-restore.json`);
     }
     carryDaemonState(from, to) {
+        this.onchainSweeps().carryTo(to);
         const overrides = from.loadWalletData(auth_1.AUTH_KEY_OVERRIDES_STORAGE_KEY);
         if (overrides !== null) {
             to.saveWalletData(auth_1.AUTH_KEY_OVERRIDES_STORAGE_KEY, overrides);
@@ -3078,10 +3099,19 @@ class BeignetNode extends events_1.EventEmitter {
     }
     nodeSecret() {
         if (!this._nodeSecret) {
-            this._nodeSecret = (0, wallet_keys_1.deriveLightningKeysFromMnemonic)(this.mnemonic, undefined, this.toCoinType(this.networkName)).nodePrivateKey;
+            if (!bip39.validateMnemonic(this.mnemonic)) {
+                throw new Error('Invalid BIP39 mnemonic');
+            }
+            this._nodeSecret = (0, wallet_keys_1.deriveLightningKeysFromSeed)(this.walletSeed(), this.toCoinType(this.networkName)).nodePrivateKey;
         }
         return this._nodeSecret;
     }
+    walletSeed() {
+        if (!this._walletSeed) {
+            this._walletSeed = bip39.mnemonicToSeedSync(this.mnemonic);
+        }
+        return Buffer.from(this._walletSeed);
+    }
     async restoreFromGuardians() {
         if (this._restoreInFlight) {
             throw new errors_1.BeignetError('RESTORE_IN_PROGRESS', 'A guardian restore is already running; watch ' +
@@ -3286,9 +3316,15 @@ class BeignetNode extends events_1.EventEmitter {
         ]);
         let totalMsat = 0n;
         for (const ch of this.node.listChannels()) {
-            if (!recovering.has(ch.state))
+            const effectiveState = ch.state === types_7.ChannelState.AWAITING_REESTABLISH
+                ? this.node
+                    .getChannelManager()
+                    .getChannel(ch.channelId)
+                    ?.getFullState().preReestablishState ?? ch.state
+                : ch.state;
+            if (!recovering.has(effectiveState))
                 continue;
-            if (ch.state === types_7.ChannelState.FORCE_CLOSED &&
+            if (effectiveState === types_7.ChannelState.FORCE_CLOSED &&
                 this.isForceCloseBalanceInWallet(ch.channelId)) {
                 continue;
             }
@@ -3730,6 +3766,50 @@ class BeignetNode extends events_1.EventEmitter {
             }
         });
     }
+    onchainSweeps() {
+        return new onchain_sweep_1.OnchainSweeps({
+            storage: this.storage,
+            wallet: this.wallet,
+            network: this.getBitcoinNetwork(),
+            broadcast: (hex) => this._broadcastRawTx(hex),
+            admitAndSave: (debitSats, save) => {
+                this._checkMaxPayment(debitSats);
+                this._checkSpendLimit(debitSats);
+                const before = {
+                    total: this._dailySpentSats,
+                    onchain: this._dailySpentOnchainSats,
+                    lightning: this._dailySpentLightningSats,
+                    reset: this._dailySpendResetTime
+                };
+                try {
+                    this.storage.transaction(() => {
+                        this._recordSpend(debitSats, 'onchain');
+                        this._persistSpendState(true);
+                        save();
+                    });
+                }
+                catch (error) {
+                    this._dailySpentSats = before.total;
+                    this._dailySpentOnchainSats = before.onchain;
+                    this._dailySpentLightningSats = before.lightning;
+                    this._dailySpendResetTime = before.reset;
+                    throw error;
+                }
+            }
+        });
+    }
+    prepareOnchainSweep(request) {
+        return this._runOnchainSend(() => this.onchainSweeps().prepare(request));
+    }
+    submitOnchainSweep(requestId) {
+        return this._runOnchainSend(() => this.onchainSweeps().submit(requestId));
+    }
+    getOnchainSweep(requestId) {
+        return this.onchainSweeps().get(requestId);
+    }
+    cancelOnchainSweep(requestId) {
+        return this._runOnchainSend(() => this.onchainSweeps().cancel(requestId));
+    }
     async bumpFeeOnchain(txid, satsPerVbyte) {
         this._validateTxid(txid);
         this._validateFeeRate(satsPerVbyte, true);
@@ -3942,9 +4022,48 @@ class BeignetNode extends events_1.EventEmitter {
         };
     }
     listOnchainTransactions() {
-        return Object.values(this.wallet.transactions)
-            .map((tx) => this.toOnchainTxInfo(tx))
-            .sort((a, b) => b.timestamp - a.timestamp);
+        const transactions = new Map(Object.values(this.wallet.transactions).map((tx) => {
+            const info = this.toOnchainTxInfo(tx);
+            return [info.txid, info];
+        }));
+        for (const close of this.node.listExternalClosePayments()) {
+            const bitcoin = require('bitcoinjs-lib');
+            transactions.set(close.txid, {
+                txid: close.txid,
+                type: 'sent',
+                valueSats: close.amountSats,
+                feeSats: close.feeSats,
+                satsPerVbyte: close.satsPerVbyte,
+                address: bitcoin.address.fromOutputScript(Buffer.from(close.scriptHex, 'hex'), this.getBitcoinNetwork()),
+                confirmed: close.confirmationHeight > 0,
+                ...(close.confirmationHeight > 0
+                    ? { height: close.confirmationHeight }
+                    : {}),
+                timestamp: close.timestamp,
+                source: 'cooperative-close',
+                channelId: close.channelId
+            });
+        }
+        if (typeof this.storage?.loadWalletData === 'function') {
+            for (const sweep of this.onchainSweeps().list()) {
+                if (!sweep.txid ||
+                    !['submitted', 'confirmed'].includes(sweep.status) ||
+                    transactions.has(sweep.txid))
+                    continue;
+                transactions.set(sweep.txid, {
+                    txid: sweep.txid,
+                    type: 'sent',
+                    valueSats: sweep.amountSats,
+                    feeSats: sweep.feeSats,
+                    satsPerVbyte: sweep.satsPerVbyte,
+                    address: sweep.address,
+                    confirmed: sweep.status === 'confirmed',
+                    timestamp: sweep.createdAt,
+                    source: 'onchain-sweep'
+                });
+            }
+        }
+        return [...transactions.values()].sort((a, b) => b.timestamp - a.timestamp);
     }
     listUtxos() {
         return this.wallet.listUtxos().map((utxo) => ({
@@ -3958,19 +4077,23 @@ class BeignetNode extends events_1.EventEmitter {
     }
     async freezeUtxo(txid, index) {
         this._validateTxid(txid);
-        const res = await this.wallet.freezeUtxo({ txid, index });
-        if (res.isErr()) {
-            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, res.error.message);
-        }
-        return { frozen: `${txid}:${index}` };
+        return this._runOnchainSend(async () => {
+            this.onchainSweeps().assertInputMutable(txid, index);
+            const res = await this.wallet.freezeUtxo({ txid, index });
+            if (res.isErr())
+                throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, res.error.message);
+            return { frozen: `${txid}:${index}` };
+        });
     }
     async unfreezeUtxo(txid, index) {
         this._validateTxid(txid);
-        const res = await this.wallet.unfreezeUtxo({ txid, index });
-        if (res.isErr()) {
-            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, res.error.message);
-        }
-        return { unfrozen: `${txid}:${index}` };
+        return this._runOnchainSend(async () => {
+            this.onchainSweeps().assertInputMutable(txid, index);
+            const res = await this.wallet.unfreezeUtxo({ txid, index });
+            if (res.isErr())
+                throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, res.error.message);
+            return { unfrozen: `${txid}:${index}` };
+        });
     }
     async setAddressLabel(address, label) {
         const res = await this.wallet.setAddressLabel(address, label);
@@ -4085,24 +4208,58 @@ class BeignetNode extends events_1.EventEmitter {
             this._lastGraphSyncAt = Date.now();
         return synced;
     }
-    async syncRapidGossip() {
+    syncRapidGossip() {
+        if (this._rapidGossipSync)
+            return this._rapidGossipSync;
+        const run = this.runRapidGossipSync();
+        this._rapidGossipSync = run;
+        const clear = () => {
+            if (this._rapidGossipSync === run)
+                this._rapidGossipSync = null;
+        };
+        void run.then(clear, clear);
+        return run;
+    }
+    async runRapidGossipSync() {
         if (this.networkName !== 'mainnet') {
             this.log('warn', 'Rapid gossip sync is only available on mainnet', {});
             return null;
         }
         const url = this.rapidGossipSyncUrl ?? rapid_sync_1.DEFAULT_RGS_URL;
         this.log('info', 'Rapid gossip sync: downloading snapshot', { url });
+        const downloadStart = Date.now();
         const data = await (0, rapid_sync_1.fetchRapidGossipSnapshot)(url);
-        const result = this.node.loadRapidGossipSnapshot(data);
+        const downloadMs = Date.now() - downloadStart;
+        if (this.destroyed)
+            throw new rapid_sync_1.RapidGossipCancelledError();
+        let slices = 0;
+        let busyMs = 0;
+        const applyStart = Date.now();
+        const result = await this.node.loadRapidGossipSnapshotAsync(data, {
+            cancelled: () => this.destroyed,
+            onSlice: (ms) => {
+                slices++;
+                busyMs += ms;
+            }
+        });
+        const applyMs = Date.now() - applyStart;
         this._lastGraphSyncAt = Date.now();
         this.log('info', 'Rapid gossip sync complete', {
             channelsAdded: result.channelsAdded,
             updatesApplied: result.updatesApplied,
-            nodes: result.nodeCount
+            nodes: result.nodeCount,
+            downloadMs,
+            applyMs,
+            busyMs,
+            slices
         });
         this.emit('gossip:synced', {
             channelsAdded: result.channelsAdded,
-            updatesApplied: result.updatesApplied
+            updatesApplied: result.updatesApplied,
+            downloadMs,
+            applyMs,
+            busyMs,
+            slices
         });
         return {
             channelsAdded: result.channelsAdded,
@@ -4182,11 +4339,45 @@ class BeignetNode extends events_1.EventEmitter {
         await Promise.all(openPromises);
         return opened;
     }
-    async closeChannel(channelId, acceptStaleStateRisk = false) {
+    async closeQuote(channelId, address, acceptStaleStateRisk = false) {
         const idBuf = requireChannelIdHex(channelId);
+        const script = this._decodeSpliceDestination(address);
+        if (!this.node.getChannel(idBuf))
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.CHANNEL_NOT_FOUND, `Channel not found: ${channelId}`);
+        const destination = script ?? (await this.cooperativeCloseDestination());
+        try {
+            return this.node.closeQuote(idBuf, destination, acceptStaleStateRisk);
+        }
+        catch (error) {
+            throw new errors_1.BeignetError('CLOSE_UNAVAILABLE', error.message);
+        }
+    }
+    async closeChannel(channelId, acceptStaleStateRisk = false, address) {
+        const idBuf = requireChannelIdHex(channelId);
+        const destination = this._decodeSpliceDestination(address);
         if (!this.node.getChannel(idBuf)) {
             throw new errors_1.BeignetError(errors_1.BeignetErrorCode.CHANNEL_NOT_FOUND, `Channel not found: ${idBuf.toString('hex')}`);
         }
+        const scriptPubkey = destination ?? (await this.cooperativeCloseDestination());
+        let externalSpendSats;
+        if (destination) {
+            let quote;
+            try {
+                quote = this.node.closeQuote(idBuf, destination, acceptStaleStateRisk);
+            }
+            catch (error) {
+                throw new errors_1.BeignetError('CLOSE_UNAVAILABLE', error.message);
+            }
+            externalSpendSats = quote.amountSats + quote.feeSats;
+            this._checkMaxPayment(externalSpendSats);
+            this._checkSpendLimit(externalSpendSats);
+        }
+        const result = this.node.closeChannel(idBuf, scriptPubkey, acceptStaleStateRisk, destination !== undefined);
+        if (result.ok && externalSpendSats !== undefined)
+            this._recordSpend(externalSpendSats, 'onchain');
+        return result;
+    }
+    async cooperativeCloseDestination() {
         let scriptPubkey = await this.boundedCurrentWalletAddressScript();
         if (!scriptPubkey)
             scriptPubkey = this.sweepDestinationScript;
@@ -4194,7 +4385,7 @@ class BeignetNode extends events_1.EventEmitter {
             const bitcoin = require('bitcoinjs-lib');
             scriptPubkey = bitcoin.address.toOutputScript(this.node.getFundingAddress(), this.getBitcoinNetwork());
         }
-        return this.node.closeChannel(idBuf, scriptPubkey, acceptStaleStateRisk);
+        return scriptPubkey;
     }
     async boundedCurrentWalletAddressScript() {
         return this.raceWithTimeout(this.resolveCurrentWalletAddressScript().catch(() => undefined), this._closeAddressLookupTimeoutMs);
@@ -4814,6 +5005,12 @@ class BeignetNode extends events_1.EventEmitter {
             peerPubkey,
             state: ch.state,
             localBalanceSats: Number(ch.localBalanceMsat / 1000n),
+            maxSendableSats: Number((ch.spendableOutboundMsat ?? 0n) / 1000n),
+            localReserveWaived: ch.localReserveWaived === true,
+            remoteReserveWaived: ch.remoteReserveWaived === true,
+            isOpener: ch.isOpener,
+            localReserveSats: Number((ch.localReserveMsat ?? 0n) / 1000n),
+            remoteReserveSats: Number((ch.remoteReserveMsat ?? 0n) / 1000n),
             remoteBalanceSats: Number(ch.remoteBalanceMsat / 1000n),
             capacitySats: Number(ch.fundingSatoshis),
             isAnchor: (0, types_7.isAnchorChannel)(ch.channelType ?? null)
@@ -5680,7 +5877,7 @@ class BeignetNode extends events_1.EventEmitter {
             this._persistSpendState();
         return count;
     }
-    _persistSpendState() {
+    _persistSpendState(strict = false) {
         if (this._dailySpendLimitSats === undefined)
             return;
         const storage = this.storage;
@@ -5702,6 +5899,8 @@ class BeignetNode extends events_1.EventEmitter {
             storage.saveMetadata(exports.DAILY_SPEND_STATE_KEY, JSON.stringify(state));
         }
         catch (err) {
+            if (strict)
+                throw err;
             this.log('warn', 'Could not persist the daily spend ledger', {
                 error: err instanceof Error ? err.message : String(err)
             });
@@ -6161,6 +6360,39 @@ class BeignetNode extends events_1.EventEmitter {
         }
         return new errors_1.BeignetError(code, msg);
     }
+    quotePayAll(bolt11, maxFeeMsat) {
+        try {
+            const quote = this.node.quotePayAll(bolt11, requireMsatValue(maxFeeMsat, 'maxFeeMsat'));
+            return {
+                ...quote,
+                debitMsat: quote.debitMsat.toString(),
+                maxFeeMsat: quote.maxFeeMsat.toString(),
+                minRecipientMsat: quote.minRecipientMsat.toString(),
+                remainderMsat: quote.remainderMsat.toString()
+            };
+        }
+        catch (err) {
+            throw this._toBeignetPaymentError(err);
+        }
+    }
+    async payInvoiceAll(bolt11, debitMsat, maxFeeMsat, timeoutMs = 60000) {
+        this._checkDraining();
+        const decoded = decodeInvoiceInput(bolt11);
+        const debit = requireMsatValue(debitMsat, 'debitMsat');
+        const feeCap = requireMsatValue(maxFeeMsat, 'maxFeeMsat');
+        if (debit <= 0n || debit > 0xffffffffffffffffn || feeCap >= debit) {
+            throw new errors_1.BeignetError('INVALID_PARAMS', 'Pay-all requires a positive u64 debitMsat and maxFeeMsat below it');
+        }
+        if (!Number.isSafeInteger(timeoutMs) ||
+            timeoutMs < 1 ||
+            timeoutMs > 2147483647) {
+            throw new errors_1.BeignetError('INVALID_PARAMS', 'timeoutMs must be a positive timer duration');
+        }
+        const claim = this._admitLightningSpend(decoded.paymentHash.toString('hex'), debit, 0n);
+        return this.waitForInvoicePayment(decoded.paymentHash, timeoutMs, claim, () => {
+            this.node.sendPayAll(bolt11, debit, feeCap);
+        });
+    }
     async payInvoice(bolt11, timeoutMs = 60000, maxFeeSats, amountSats, metadata, cltvLimit, maxFeeMsatCap) {
         this._checkDraining();
         const decoded = decodeInvoiceInput(bolt11);
@@ -6173,10 +6405,16 @@ class BeignetNode extends events_1.EventEmitter {
         const maxFeeMsat = resolveMaxFeeMsat(maxFeeSats, maxFeeMsatCap, payAmountMsat);
         const maxCltvExpiryHeight = this._cltvCeiling(cltvLimit);
         const claim = this._admitLightningSpend(paymentHashHex, payAmountMsat, maxFeeMsat);
+        return this.waitForInvoicePayment(decoded.paymentHash, timeoutMs, claim, () => {
+            this.node.sendPayment(bolt11, undefined, maxFeeMsat, amountMsat, maxCltvExpiryHeight, undefined, metadata);
+        });
+    }
+    waitForInvoicePayment(paymentHash, timeoutMs, claim, dispatch) {
+        const paymentHashHex = paymentHash.toString('hex');
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 cleanup();
-                reject(this._paymentTimeout(decoded.paymentHash, 'Payment', timeoutMs, claim));
+                reject(this._paymentTimeout(paymentHash, 'Payment', timeoutMs, claim));
             }, timeoutMs);
             const cleanup = () => {
                 clearTimeout(timer);
@@ -6200,13 +6438,19 @@ class BeignetNode extends events_1.EventEmitter {
             };
             this.node.on('payment:sent', onSent);
             this.node.on('payment:failed', onFailed);
+            const beforeDispatch = this.node.getPayment(paymentHash);
             try {
-                this.node.sendPayment(bolt11, undefined, maxFeeMsat, amountMsat, maxCltvExpiryHeight, undefined, metadata);
+                dispatch();
             }
             catch (err) {
                 cleanup();
-                if (claim)
+                const dispatched = this.node.getPayment(paymentHash) !== beforeDispatch;
+                if (dispatched && this.node.hasHtlcInFlight(paymentHash)) {
+                    this.node.failPaymentUnlessInFlight(paymentHash);
+                }
+                else if (claim) {
                     this._closeAsyncSpendClaim(paymentHashHex, claim);
+                }
                 reject(this._toBeignetPaymentError(err));
             }
         });
@@ -6621,6 +6865,7 @@ class BeignetNode extends events_1.EventEmitter {
             return null;
         const feeMsat = paymentFeeMsat(record);
         return {
+            ...(record.payAll ? { payAll: this.toPaymentInfo(record).payAll } : {}),
             paymentHash: proof.paymentHash.toString('hex'),
             preimage: proof.preimage.toString('hex'),
             amountSats: paymentAmountSats(record),
@@ -6711,6 +6956,17 @@ class BeignetNode extends events_1.EventEmitter {
     }
     toPaymentInfo(p) {
         const info = {
+            ...(p.payAll
+                ? {
+                    payAll: {
+                        debitMsat: p.payAll.debitMsat.toString(),
+                        maxFeeMsat: p.payAll.maxFeeMsat.toString(),
+                        deliveredMsat: p.payAll.deliveredMsat.toString(),
+                        feeMsat: p.payAll.feeMsat.toString(),
+                        remainderMsat: p.payAll.remainderMsat.toString()
+                    }
+                }
+                : {}),
             paymentHash: p.paymentHash.toString('hex'),
             amountSats: paymentAmountSats(p),
             status: p.status,
@@ -6853,10 +7109,10 @@ class BeignetNode extends events_1.EventEmitter {
             isAnchor: (0, types_7.isAnchorChannel)(state.channelType)
         };
     }
-    spliceQuote(channelId, direction, feeratePerkw) {
+    spliceQuote(channelId, direction, feeratePerkw, destinationAddress) {
         const idBuf = requireChannelIdHex(channelId);
         requireU32(feeratePerkw, 'feeratePerkw', 1, splice_weight_1.MAX_SPLICE_FEERATE_PERKW);
-        return fundingOrRefuse(() => this.node.spliceQuote(idBuf, direction, feeratePerkw));
+        return fundingOrRefuse(() => this.node.spliceQuote(idBuf, direction, feeratePerkw, this._decodeSpliceDestination(destinationAddress)));
     }
     spliceIn(channelId, amountSats, feeratePerkw, fundingUtxos) {
         const idBuf = requireChannelIdHex(channelId);
@@ -6865,10 +7121,7 @@ class BeignetNode extends events_1.EventEmitter {
         const result = fundingOrRefuse(() => this.node.spliceIn(idBuf, BigInt(amountSats), feeratePerkw, fundingUtxos));
         return result;
     }
-    spliceOut(channelId, amountSats, feeratePerkw, destinationAddress) {
-        const idBuf = requireChannelIdHex(channelId);
-        requirePositiveSafeInteger(amountSats, 'amountSats');
-        requireU32(feeratePerkw, 'feeratePerkw', 1, splice_weight_1.MAX_SPLICE_FEERATE_PERKW);
+    _decodeSpliceDestination(destinationAddress) {
         let destinationScript;
         if (destinationAddress !== undefined) {
             if (typeof destinationAddress !== 'string' ||
@@ -6883,6 +7136,13 @@ class BeignetNode extends events_1.EventEmitter {
                 throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, `destinationAddress is not a valid address for this network: ${err instanceof Error ? err.message : 'failed to decode'}`);
             }
         }
+        return destinationScript;
+    }
+    spliceOut(channelId, amountSats, feeratePerkw, destinationAddress) {
+        const idBuf = requireChannelIdHex(channelId);
+        requirePositiveSafeInteger(amountSats, 'amountSats');
+        requireU32(feeratePerkw, 'feeratePerkw', 1, splice_weight_1.MAX_SPLICE_FEERATE_PERKW);
+        const destinationScript = this._decodeSpliceDestination(destinationAddress);
         let externalSpendSats;
         if (destinationScript !== undefined) {
             const feeSats = Number((0, splice_weight_1.spliceFeeSats)((0, splice_weight_1.estimateSpliceTxWeight)({
@@ -7327,7 +7587,9 @@ class BeignetNode extends events_1.EventEmitter {
         const snapshot = this.node.getLiquiditySnapshot();
         let reserveMsat = 0n;
         let sendableMsat = 0n;
+        let maxSendableMsat = 0n;
         for (const ch of this.node.listChannels()) {
+            maxSendableMsat += ch.spendableOutboundMsat ?? 0n;
             if (isHeldRestore(ch))
                 continue;
             if (ch.state !== types_7.ChannelState.NORMAL && !ch.htlcUsable)
@@ -7351,6 +7613,7 @@ class BeignetNode extends events_1.EventEmitter {
             inboundLiquidityPct: snapshot.inboundLiquidityPct,
             reserveSats: Number(reserveMsat / 1000n),
             sendableSats: Number(sendableMsat / 1000n),
+            maxSendableSats: Number(maxSendableMsat / 1000n),
             recommendations: snapshot.recommendations
         };
     }
@@ -7986,7 +8249,7 @@ class BeignetNode extends events_1.EventEmitter {
     }
     async backup(destPath) {
         await this.storage.backup(destPath);
-        await (0, backup_mac_1.writeBackupMac)((0, backup_mac_1.deriveBackupMacKey)(bip39.mnemonicToSeedSync(this.mnemonic)), destPath);
+        await (0, backup_mac_1.writeBackupMac)((0, backup_mac_1.deriveBackupMacKey)(this.walletSeed()), destPath);
     }
     storageFiles() {
         const dbPath = fs.realpathSync.native(path.join(this.dataDir, `${this.networkName}.db`));
@@ -8037,14 +8300,14 @@ class BeignetNode extends events_1.EventEmitter {
             createdAt: Date.now(),
             channels: data.channels
         };
-        const seed = bip39.mnemonicToSeedSync(this.mnemonic);
+        const seed = this.walletSeed();
         const encoded = (0, scb_1.encodeScb)(backup, seed);
         const scbPath = path.join(this.dataDir, 'channels.scb');
         (0, fs_utils_1.writeFileAtomic)(scbPath, encoded);
         return { encoded, channelCount: data.channels.length, path: scbPath };
     }
     async restoreFromScb(encoded) {
-        const seed = bip39.mnemonicToSeedSync(this.mnemonic);
+        const seed = this.walletSeed();
         const backup = (0, scb_1.decodeScb)(encoded.trim(), seed);
         const expectedNetwork = this.toLnNetwork(this.networkName);
         if (backup.network !== expectedNetwork) {
@@ -8165,14 +8428,14 @@ class BeignetNode extends events_1.EventEmitter {
                     });
                 }
             }
-            const seed = bip39.mnemonicToSeedSync(this.mnemonic);
+            const seed = this.walletSeed();
             this.offerRetrievedScb((0, scb_1.encodeScb)(embedded, seed), embedded, peerPubkey, 'capsule');
             return;
         }
         let backup;
         const encoded = blob.toString('utf8');
         try {
-            const seed = bip39.mnemonicToSeedSync(this.mnemonic);
+            const seed = this.walletSeed();
             backup = (0, scb_1.decodeScb)(encoded, seed);
         }
         catch {