beignet 0.21.12 → 0.22.0

package/dist/cli/beignet-node.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BeignetNode = exports.jitInvoiceError = exports.holdInvoiceEvent = exports.jsonSafeEvent = exports.jitReceiveRefusal = exports.leaseRatesRefusal = exports.clampDirectFundingMinimum = exports.MAX_ASYNC_SPEND_CLAIMS = exports.ASYNC_SPEND_CLAIM_TTL_MS = exports.jsonToRouteHops = exports.routeHopsToJson = exports.spliceRefusalError = exports.decodeOfferInput = exports.paymentSpendSats = exports.spendLimitSats = exports.decodeInvoiceInput = exports.parseScid = exports.formatScid = exports.gossipPrimeLatch = exports.defaultDataDirForMnemonic = exports.parseRecoveryMode = void 0;
+exports.BeignetNode = exports.jitInvoiceError = exports.holdInvoiceEvent = exports.jsonSafeEvent = exports.jitReceiveRefusal = exports.leaseRatesRefusal = 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.paymentSpendSats = exports.spendLimitSats = exports.decodeInvoiceInput = exports.ENGINE_PAYMENT_ERROR_CODES = exports.parseScid = exports.formatScid = exports.gossipPrimeLatch = exports.defaultDataDirForMnemonic = exports.parseRecoveryMode = void 0;
 const offline_receive_1 = require("./offline-receive");
 const ffor_receive_1 = require("./ffor-receive");
 const path = __importStar(require("path"));
@@ -41,6 +41,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 node_storage_view_1 = require("./node-storage-view");
 const electrum_1 = require("../types/electrum");
 const lightning_node_1 = require("../lightning/node/lightning-node");
 const types_1 = require("../lightning/direct-funding/receiver/types");
@@ -69,6 +70,7 @@ const direct_funding_2 = require("./direct-funding");
 const auth_1 = require("./auth");
 const types_5 = require("../lightning/node/types");
 const types_6 = require("../lightning/channel/types");
+const channel_state_1 = require("../lightning/channel/channel-state");
 const decode_1 = require("../lightning/invoice/decode");
 const decode_2 = require("../lightning/offer/decode");
 const errors_1 = require("./errors");
@@ -169,6 +171,17 @@ function parseScid(scid) {
     throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, `Invalid short channel id: ${scid} (expected <block>x<txIndex>x<output> or 16-char hex)`);
 }
 exports.parseScid = parseScid;
+exports.ENGINE_PAYMENT_ERROR_CODES = {
+    NO_ROUTE: 'NO_ROUTE',
+    DUPLICATE_PAYMENT: 'DUPLICATE_PAYMENT',
+    NO_CHANNEL_TO_HOP: 'PEER_NOT_CONNECTED',
+    FEE_EXCEEDS_MAX: 'PAYMENT_FAILED',
+    CLTV_EXCEEDS_MAX: 'CLTV_EXCEEDS_MAX',
+    MISSING_AMOUNT: 'INVALID_PARAMS',
+    INVALID_INVOICE: 'INVALID_PARAMS',
+    INVALID_KEYSEND: 'INVALID_PARAMS',
+    INVOICE_EXPIRED: 'INVOICE_EXPIRED'
+};
 function decodeInvoiceInput(bolt11) {
     try {
         return (0, decode_1.decode)(bolt11);
@@ -279,6 +292,12 @@ exports.jsonToRouteHops = jsonToRouteHops;
 const GRAPH_DESCRIBE_MAX_LIMIT = 500;
 exports.ASYNC_SPEND_CLAIM_TTL_MS = 24 * 60 * 60 * 1000;
 exports.MAX_ASYNC_SPEND_CLAIMS = 4096;
+exports.DAILY_SPEND_STATE_KEY = 'daemon:daily-spend:v1';
+const nextUtcMidnight = () => {
+    const next = new Date();
+    next.setUTCHours(24, 0, 0, 0);
+    return next.getTime();
+};
 const MAX_DIRECT_FUNDING_CHARGES = 1024;
 const DEFAULT_L402_MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
 const DEFAULT_ELECTRUM = {
@@ -478,6 +497,21 @@ function isHeldRestore(ch) {
         ch.reestablishSecretMissing === true ||
         ch.restoreRevokedRisk === true);
 }
+const CLOSING_CHANNEL_STATES = new Set([
+    types_6.ChannelState.SHUTTING_DOWN,
+    types_6.ChannelState.NEGOTIATING_CLOSING,
+    types_6.ChannelState.CLOSED,
+    types_6.ChannelState.FORCE_CLOSED,
+    types_6.ChannelState.ERRORED
+]);
+function canBecomeUsable(channel) {
+    const st = channel.getFullState();
+    const effective = st.state === types_6.ChannelState.AWAITING_REESTABLISH && st.preReestablishState
+        ? st.preReestablishState
+        : st.state;
+    return !CLOSING_CHANNEL_STATES.has(effective) && !(0, channel_state_1.isRecencyUnproven)(st);
+}
+const CHANNELS_CHANGED = Symbol('channels-changed');
 const STALE_STATE_FORCE_CLOSE_REFUSAL = 'This channel was restored from a Recovery Capsule and its state ' +
     'cannot be proven current, so the node will not broadcast its ' +
     'commitment on its own initiative. If the peer holds a newer ' +
@@ -583,7 +617,6 @@ class BeignetNode extends events_1.EventEmitter {
         this._dailySpendResetTime = 0;
         this._pendingSpendSats = 0;
         this._asyncSpendClaims = new Map();
-        this._blockingPaymentHashes = new Map();
         this._l402Credentials = new l402_1.MemoryL402CredentialStore();
         this._draining = false;
         this.peerStorageEnabled = true;
@@ -706,6 +739,9 @@ class BeignetNode extends events_1.EventEmitter {
                 throw new errors_1.BeignetError('INVALID_PARAMS', `jitReceive: ${refusal}`);
             }
         }
+        if (opts.torProxyOnionOnly && !opts.torProxy) {
+            throw new errors_1.BeignetError('INVALID_PARAMS', 'torProxyOnionOnly needs torProxy: it only chooses which hosts use the configured proxy');
+        }
         const networkName = this.networkName;
         if (!opts.allowMultipleInstances) {
             const lockPath = path.join(this.dataDir, `${networkName}.lock`);
@@ -897,10 +933,13 @@ class BeignetNode extends events_1.EventEmitter {
             const [proxyHost, proxyPort] = opts.torProxy.split(':');
             const port = parseInt(proxyPort, 10);
             if (!proxyHost || !Number.isFinite(port)) {
-                throw new errors_1.BeignetError('INVALID_PARAMS', `Invalid torProxy "${opts.torProxy}" — expected "host:port"`);
+                throw new errors_1.BeignetError('INVALID_PARAMS', `Invalid torProxy "${opts.torProxy}": expected "host:port"`);
             }
             socks5Proxy = { host: proxyHost, port };
         }
+        const socks5ProxyScope = opts.torProxyOnionOnly
+            ? 'onion'
+            : 'all';
         let announcedAddresses;
         if (opts.announceAddresses && opts.announceAddresses.length > 0) {
             announcedAddresses = opts.announceAddresses.map((addr) => {
@@ -920,10 +959,11 @@ class BeignetNode extends events_1.EventEmitter {
                 this._initialGossipPrime = null;
             });
         }
+        this._nodeStorageView = (0, node_storage_view_1.nodeStorageView)(this.storage);
         this.node = lightning_node_1.LightningNode.fromMnemonic(this.mnemonic, {
             coinType,
             network: lnNetwork,
-            storage: this.storage,
+            storage: this._nodeStorageView,
             newChannelsRefused: () => this.newChannelRefusal(),
             enableNetworking: true,
             autoReconnect: opts.autoReconnect ?? true,
@@ -1088,6 +1128,7 @@ class BeignetNode extends events_1.EventEmitter {
             logger: this.logger,
             sweepDestinationScript,
             socks5Proxy,
+            socks5ProxyScope,
             ...(opts.guardianServe
                 ? {
                     guardianHost: {
@@ -1168,6 +1209,7 @@ class BeignetNode extends events_1.EventEmitter {
         });
         this.node.on('payment:failed', (info) => {
             const pi = this.toPaymentInfo(info);
+            this._releaseAsyncSpendClaimsUnlessInFlight(info.paymentHash);
             this.log('warn', 'Payment failed', {
                 paymentHash: pi.paymentHash,
                 failureCode: pi.failureCode,
@@ -1182,6 +1224,61 @@ class BeignetNode extends events_1.EventEmitter {
             this.refreshStaticChannelBackup();
             this.emit('channel:ready', { channelId });
         });
+        const usableNode = this.node;
+        const deferEmit = (emit) => {
+            setImmediate(() => {
+                if (this.destroyed || this._resuming || this.node !== usableNode) {
+                    return;
+                }
+                try {
+                    emit();
+                }
+                catch (err) {
+                    try {
+                        this.log('warn', 'A payment-readiness listener failed', {
+                            error: err instanceof Error ? err.message : String(err)
+                        });
+                    }
+                    catch {
+                    }
+                }
+            });
+        };
+        const announceUsable = (channelId) => deferEmit(() => {
+            const channel = usableNode.getChannelManager().getChannel(channelId);
+            if (!channel?.acceptsNewHtlcs())
+                return;
+            this.emit('channel:usable', { channelId: channelId.toString('hex') });
+        });
+        this.node.on('channel:ready', (data) => announceUsable(data.channelId));
+        this.node
+            .getChannelManager()
+            .on('channel:reestablished', (channelId) => announceUsable(channelId));
+        for (const event of [
+            'splice:complete',
+            'splice:aborted',
+            'splice:reverted'
+        ]) {
+            this.node.on(event, (data) => announceUsable(data.channelId));
+        }
+        this.node.on('log', (entry) => {
+            if (entry?.action !== 'funding_missing_quarantine_lifted')
+                return;
+            const idHex = entry.data?.channelId;
+            if (typeof idHex === 'string')
+                announceUsable(Buffer.from(idHex, 'hex'));
+        });
+        const channelsChanged = () => deferEmit(() => this.emit(CHANNELS_CHANGED));
+        for (const event of [
+            'channel:pending-close',
+            'channel:force-closing',
+            'channel:closed',
+            'channel:voided',
+            'channel:aborted'
+        ]) {
+            this.node.on(event, channelsChanged);
+        }
+        this.node.getChannelManager().on('channel:errored', channelsChanged);
         this.node.on('channel:closed', (data) => {
             const channelId = data.channelId.toString('hex');
             this.log('info', 'Channel closed', { channelId });
@@ -1531,7 +1628,7 @@ class BeignetNode extends events_1.EventEmitter {
         if (opts.dailySpendLimitSats !== undefined &&
             opts.dailySpendLimitSats > 0) {
             this._dailySpendLimitSats = opts.dailySpendLimitSats;
-            this._resetDailySpendIfNeeded();
+            this._loadSpendState();
         }
         if (opts.maxPaymentSats !== undefined && opts.maxPaymentSats > 0) {
             this._maxPaymentSats = opts.maxPaymentSats;
@@ -2207,6 +2304,13 @@ class BeignetNode extends events_1.EventEmitter {
             }
             this._resuming = false;
             this._bootTargetEmpty = false;
+            if (this.paymentQueue) {
+                this.whenReadyToPay(() => {
+                    this.paymentQueue?.start();
+                    this.paymentQueue?.resettle();
+                    this.paymentQueue?.poke();
+                });
+            }
             this._peerRetrievedCapsules.clear();
             const uncovered = uncoveredEntries.map((e) => e.channelId);
             if (uncovered.length > 0) {
@@ -2426,6 +2530,11 @@ class BeignetNode extends events_1.EventEmitter {
         }
         this.paymentQueue?.removeAllListeners();
         this.node.destroy();
+        try {
+            this.storage.close();
+        }
+        catch {
+        }
         void this.wallet?.stop().catch(() => {
         });
     }
@@ -2447,6 +2556,19 @@ class BeignetNode extends events_1.EventEmitter {
                 error: err instanceof Error ? err.message : String(err)
             });
         }
+        try {
+            for (const row of from.loadAllQueueEntries()) {
+                to.saveQueueEntry(row);
+                if (row.error !== undefined || row.completedAt !== undefined) {
+                    to.updateQueueEntryStatus(row.id, row.status, row.error, row.completedAt);
+                }
+            }
+        }
+        catch (err) {
+            this.log('warn', 'Could not carry the payment queue into the restore', {
+                error: err instanceof Error ? err.message : String(err)
+            });
+        }
         try {
             for (const peer of from.loadAllPeerAddresses()) {
                 to.savePeerAddress(peer.pubkey, peer.host, peer.port);
@@ -2457,6 +2579,14 @@ class BeignetNode extends events_1.EventEmitter {
                 error: err instanceof Error ? err.message : String(err)
             });
         }
+        try {
+            const spend = from.loadMetadata(exports.DAILY_SPEND_STATE_KEY);
+            if (spend !== null)
+                to.saveMetadata(exports.DAILY_SPEND_STATE_KEY, spend);
+        }
+        catch (err) {
+            this.log('warn', 'Could not carry the daily spend ledger into the restore', { error: err instanceof Error ? err.message : String(err) });
+        }
     }
     finishStagedCapsuleRestore(dbPath) {
         const markerPath = this.capsuleRestoreMarkerPath();
@@ -4937,15 +5067,14 @@ class BeignetNode extends events_1.EventEmitter {
         }
         return result;
     }
-    _resetDailySpendIfNeeded() {
-        const now = Date.now();
-        if (now >= this._dailySpendResetTime) {
-            const tomorrow = new Date();
-            tomorrow.setUTCHours(24, 0, 0, 0);
-            this._dailySpendResetTime = tomorrow.getTime();
+    _resetDailySpendIfNeeded(persist = true) {
+        if (Date.now() >= this._dailySpendResetTime) {
+            this._dailySpendResetTime = nextUtcMidnight();
             this._dailySpentSats = 0;
             this._dailySpentLightningSats = 0;
             this._dailySpentOnchainSats = 0;
+            if (persist)
+                this._persistSpendState();
         }
     }
     _checkSpendLimit(amountSats) {
@@ -4969,7 +5098,7 @@ class BeignetNode extends events_1.EventEmitter {
     _recordSpend(amountSats, source = 'lightning') {
         if (this._dailySpendLimitSats === undefined)
             return;
-        this._resetDailySpendIfNeeded();
+        this._resetDailySpendIfNeeded(false);
         this._dailySpentSats += amountSats;
         if (source === 'onchain') {
             this._dailySpentOnchainSats += amountSats;
@@ -4977,6 +5106,7 @@ class BeignetNode extends events_1.EventEmitter {
         else {
             this._dailySpentLightningSats += amountSats;
         }
+        this._persistSpendState();
     }
     _openAsyncSpendClaim(paymentHashHex, amountSats) {
         if (this._dailySpendLimitSats === undefined)
@@ -5001,8 +5131,25 @@ class BeignetNode extends events_1.EventEmitter {
         else
             this._asyncSpendClaims.set(paymentHashHex, [claim]);
         this._pendingSpendSats += amountSats;
+        this._persistSpendState();
         return claim;
     }
+    _rekeyAsyncSpendClaim(fromKey, toKey, claim) {
+        const from = this._asyncSpendClaims.get(fromKey);
+        if (from) {
+            const index = from.indexOf(claim);
+            if (index !== -1)
+                from.splice(index, 1);
+            if (from.length === 0)
+                this._asyncSpendClaims.delete(fromKey);
+        }
+        const to = this._asyncSpendClaims.get(toKey);
+        if (to)
+            to.push(claim);
+        else
+            this._asyncSpendClaims.set(toKey, [claim]);
+        this._persistSpendState();
+    }
     _closeAsyncSpendClaim(paymentHashHex, claim) {
         const claims = this._asyncSpendClaims.get(paymentHashHex);
         if (!claims)
@@ -5013,49 +5160,74 @@ class BeignetNode extends events_1.EventEmitter {
         claims.splice(index, 1);
         if (claims.length === 0)
             this._asyncSpendClaims.delete(paymentHashHex);
-        this._releaseAsyncSpendClaim(claim);
+        this._releaseClaimReservation(claim);
+        this._persistSpendState();
     }
     _releaseAsyncSpendClaim(claim) {
+        if (this._releaseClaimReservation(claim))
+            this._persistSpendState();
+    }
+    _releaseClaimReservation(claim) {
         if (!claim.reserved)
-            return;
+            return false;
         claim.reserved = false;
         this._pendingSpendSats -= claim.sats;
+        return true;
     }
-    _chargeAsyncSpendClaim(paymentHashHex) {
-        if (this._blockingPaymentHashes.has(paymentHashHex))
+    _releaseAsyncSpendClaimsUnlessInFlight(paymentHash) {
+        const claims = this._asyncSpendClaims.get(paymentHash.toString('hex'));
+        if (!claims || !claims.some((claim) => claim.reserved))
             return;
+        if (this.node.hasHtlcInFlight(paymentHash))
+            return;
+        let released = false;
+        for (const claim of claims) {
+            released = this._releaseClaimReservation(claim) || released;
+        }
+        if (released)
+            this._persistSpendState();
+    }
+    _chargeAsyncSpendClaim(paymentHashHex, claim) {
         this._expireAsyncSpendClaims();
         const claims = this._asyncSpendClaims.get(paymentHashHex);
         if (!claims || claims.length === 0)
             return;
-        const reserved = claims.findIndex((entry) => entry.reserved);
-        const [claim] = claims.splice(reserved === -1 ? 0 : reserved, 1);
+        let index;
+        if (claim) {
+            index = claims.indexOf(claim);
+            if (index === -1)
+                return;
+        }
+        else {
+            const rank = (entry) => (entry.reserved ? 0 : 2) + (entry.settled ? 1 : 0);
+            index = 0;
+            for (let i = 1; i < claims.length; i++) {
+                if (rank(claims[i]) < rank(claims[index]))
+                    index = i;
+            }
+        }
+        const [charged] = claims.splice(index, 1);
+        for (const rest of claims) {
+            rest.settled = true;
+            this._releaseClaimReservation(rest);
+        }
         if (claims.length === 0)
             this._asyncSpendClaims.delete(paymentHashHex);
-        this._releaseAsyncSpendClaim(claim);
-        this._recordSpend(claim.sats);
-    }
-    _acquireBlockingPayment(paymentHashHex) {
-        this._blockingPaymentHashes.set(paymentHashHex, (this._blockingPaymentHashes.get(paymentHashHex) ?? 0) + 1);
-    }
-    _releaseBlockingPayment(paymentHashHex) {
-        const held = this._blockingPaymentHashes.get(paymentHashHex);
-        if (held === undefined)
-            return;
-        if (held > 1)
-            this._blockingPaymentHashes.set(paymentHashHex, held - 1);
-        else
-            this._blockingPaymentHashes.delete(paymentHashHex);
+        this._releaseClaimReservation(charged);
+        this._recordSpend(charged.sats);
     }
-    _expireAsyncSpendClaims() {
+    _expireAsyncSpendClaims(persist = true) {
         const now = Date.now();
+        let released = false;
         for (const claims of this._asyncSpendClaims.values()) {
             for (const claim of claims) {
                 if (claim.reserved && claim.expiresAt <= now) {
-                    this._releaseAsyncSpendClaim(claim);
+                    released = this._releaseClaimReservation(claim) || released;
                 }
             }
         }
+        if (released && persist)
+            this._persistSpendState();
     }
     _countAsyncSpendClaims() {
         let total = 0;
@@ -5067,6 +5239,7 @@ class BeignetNode extends events_1.EventEmitter {
         let count = this._countAsyncSpendClaims();
         if (count <= target)
             return count;
+        const before = count;
         for (const [paymentHashHex, claims] of this._asyncSpendClaims) {
             for (let i = 0; i < claims.length && count > target;) {
                 if (claims[i].reserved) {
@@ -5081,8 +5254,164 @@ class BeignetNode extends events_1.EventEmitter {
             if (count <= target)
                 break;
         }
+        if (count < before)
+            this._persistSpendState();
         return count;
     }
+    _persistSpendState() {
+        if (this._dailySpendLimitSats === undefined)
+            return;
+        const storage = this.storage;
+        if (!storage)
+            return;
+        const claims = {};
+        for (const [paymentHashHex, list] of this._asyncSpendClaims) {
+            if (list.length > 0)
+                claims[paymentHashHex] = list;
+        }
+        const state = {
+            resetTime: this._dailySpendResetTime,
+            totalSats: this._dailySpentSats,
+            lightningSats: this._dailySpentLightningSats,
+            onchainSats: this._dailySpentOnchainSats,
+            claims
+        };
+        try {
+            storage.saveMetadata(exports.DAILY_SPEND_STATE_KEY, JSON.stringify(state));
+        }
+        catch (err) {
+            this.log('warn', 'Could not persist the daily spend ledger', {
+                error: err instanceof Error ? err.message : String(err)
+            });
+        }
+    }
+    _loadSpendState() {
+        for (const claims of this._asyncSpendClaims.values()) {
+            for (const claim of claims)
+                this._releaseClaimReservation(claim);
+        }
+        this._asyncSpendClaims.clear();
+        this._dailySpendResetTime = 0;
+        this._dailySpentSats = 0;
+        this._dailySpentLightningSats = 0;
+        this._dailySpentOnchainSats = 0;
+        let stored;
+        try {
+            const raw = this.storage.loadMetadata(exports.DAILY_SPEND_STATE_KEY);
+            if (raw)
+                stored = JSON.parse(raw);
+        }
+        catch (err) {
+            this.log('warn', 'Could not read the persisted daily spend ledger; the day starts at zero', { error: err instanceof Error ? err.message : String(err) });
+        }
+        const nonNegative = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0;
+        if (stored &&
+            nonNegative(stored.resetTime) &&
+            Date.now() < stored.resetTime &&
+            stored.resetTime <= nextUtcMidnight() &&
+            nonNegative(stored.totalSats) &&
+            nonNegative(stored.lightningSats) &&
+            nonNegative(stored.onchainSats)) {
+            this._dailySpendResetTime = stored.resetTime;
+            this._dailySpentSats = stored.totalSats;
+            this._dailySpentLightningSats = stored.lightningSats;
+            this._dailySpentOnchainSats = stored.onchainSats;
+        }
+        else {
+            this._resetDailySpendIfNeeded(false);
+        }
+        const isClaim = (value) => {
+            const entry = value;
+            return (typeof entry === 'object' &&
+                entry !== null &&
+                nonNegative(entry.sats) &&
+                typeof entry.expiresAt === 'number' &&
+                Number.isFinite(entry.expiresAt) &&
+                typeof entry.reserved === 'boolean' &&
+                (entry.settled === undefined || typeof entry.settled === 'boolean'));
+        };
+        let restored = 0;
+        let charged = 0;
+        let dropped = 0;
+        const toCharge = [];
+        const rows = stored?.claims && typeof stored.claims === 'object'
+            ? Object.entries(stored.claims)
+            : [];
+        for (const [paymentHashHex, list] of rows) {
+            const total = Array.isArray(list) ? list.length : 0;
+            const claims = Array.isArray(list) ? list.filter(isClaim) : [];
+            dropped += total - claims.length;
+            if (claims.length === 0)
+                continue;
+            if (!/^[0-9a-f]{64}$/.test(paymentHashHex)) {
+                dropped += claims.length;
+                continue;
+            }
+            const paymentHash = Buffer.from(paymentHashHex, 'hex');
+            const outcome = this._spendClaimOutcomeAtBoot(paymentHash, paymentHashHex);
+            if (outcome === 'gone') {
+                dropped += claims.length;
+                continue;
+            }
+            const kept = claims.map((entry) => ({
+                sats: entry.sats,
+                expiresAt: entry.expiresAt,
+                reserved: entry.reserved && outcome !== 'settled',
+                ...(entry.settled ? { settled: true } : {})
+            }));
+            this._asyncSpendClaims.set(paymentHashHex, kept);
+            for (const entry of kept) {
+                if (entry.reserved)
+                    this._pendingSpendSats += entry.sats;
+            }
+            restored += kept.length;
+            if (outcome === 'settled' && kept.some((entry) => !entry.settled)) {
+                toCharge.push(paymentHashHex);
+            }
+        }
+        for (const paymentHashHex of toCharge) {
+            this._chargeAsyncSpendClaim(paymentHashHex);
+            charged++;
+        }
+        this._expireAsyncSpendClaims(false);
+        this._persistSpendState();
+        if (stored) {
+            this.log('info', 'Daily spend ledger restored', {
+                spentSats: this._dailySpentSats,
+                resetsAt: this._dailySpendResetTime,
+                claimsRestored: restored,
+                settledWhileDown: charged,
+                claimsDropped: dropped
+            });
+        }
+    }
+    _spendClaimOutcomeAtBoot(paymentHash, paymentHashHex) {
+        const view = this.node.getOutgoingHtlcs(paymentHash);
+        if (view.preimage || view.status === types_5.PaymentStatus.COMPLETED) {
+            return 'settled';
+        }
+        try {
+            const durable = this.storage.loadPayment(paymentHashHex);
+            if (durable?.direction === types_5.PaymentDirection.OUTGOING &&
+                (durable.status === types_5.PaymentStatus.COMPLETED ||
+                    durable.preimage !== undefined ||
+                    this.storage.loadPreimage(paymentHashHex) !== null)) {
+                return 'settled';
+            }
+        }
+        catch (err) {
+            this.log('warn', 'Could not read a payment record for the daily spend ledger; keeping its claim', {
+                paymentHash: paymentHashHex,
+                error: err instanceof Error ? err.message : String(err)
+            });
+            return 'live';
+        }
+        if (view.status === types_5.PaymentStatus.PENDING ||
+            this.node.hasHtlcInFlight(paymentHash)) {
+            return 'live';
+        }
+        return 'gone';
+    }
     _builtOnchainTotalSats(amountSats) {
         const feeSats = this.wallet.transaction?.data?.fee;
         if (!Number.isFinite(feeSats) || feeSats < 0) {
@@ -5095,11 +5424,16 @@ class BeignetNode extends events_1.EventEmitter {
     }
     getDailySpendInfo() {
         this._resetDailySpendIfNeeded();
+        this._expireAsyncSpendClaims();
         const limit = this._dailySpendLimitSats ?? null;
+        const pendingSats = this._pendingSpendSats;
         return {
             limitSats: limit,
             spentSats: this._dailySpentSats,
-            remainingSats: limit !== null ? Math.max(0, limit - this._dailySpentSats) : Infinity,
+            remainingSats: limit !== null
+                ? Math.max(0, limit - this._dailySpentSats - pendingSats)
+                : Infinity,
+            pendingSats,
             resetsAt: this._dailySpendResetTime,
             totalSats: this._dailySpentSats,
             lightningSats: this._dailySpentLightningSats,
@@ -5326,6 +5660,35 @@ class BeignetNode extends events_1.EventEmitter {
         }
         return height + cltvLimit;
     }
+    _paymentTimeout(paymentHash, what, timeoutMs, claim) {
+        const failed = this.node.failPaymentUnlessInFlight(paymentHash);
+        if (failed && claim)
+            this._releaseAsyncSpendClaim(claim);
+        return new errors_1.BeignetError('PAYMENT_TIMEOUT', failed
+            ? `${what} timed out after ${timeoutMs}ms`
+            : `${what} timed out after ${timeoutMs}ms; an HTLC is still in flight and the payment stays PENDING until it resolves; no further route is tried after the timeout`);
+    }
+    _toBeignetPaymentError(err) {
+        if (err instanceof errors_1.BeignetError)
+            return err;
+        const msg = err instanceof Error ? err.message : String(err);
+        let code = 'PAYMENT_FAILED';
+        if (err instanceof Error && 'code' in err) {
+            const lpErr = err;
+            code = exports.ENGINE_PAYMENT_ERROR_CODES[lpErr.code] || 'PAYMENT_FAILED';
+        }
+        else if (msg.includes('No route found')) {
+            code = 'NO_ROUTE';
+        }
+        else if (msg.includes('already in flight')) {
+            code = 'DUPLICATE_PAYMENT';
+        }
+        else if (msg.includes('No channel to first hop') ||
+            msg.includes('Peer not found')) {
+            code = 'PEER_NOT_CONNECTED';
+        }
+        return new errors_1.BeignetError(code, msg);
+    }
     async payInvoice(bolt11, timeoutMs = 60000, maxFeeSats, amountSats, metadata, cltvLimit) {
         this._checkDraining();
         const decoded = decodeInvoiceInput(bolt11);
@@ -5340,62 +5703,41 @@ class BeignetNode extends events_1.EventEmitter {
                 1000n
             : undefined;
         const maxCltvExpiryHeight = this._cltvCeiling(cltvLimit);
+        let claim;
         if (spendAmountSats > 0) {
             this._checkMaxPayment(spendAmountSats);
             this._checkSpendLimit(spendAmountSats);
-            this._pendingSpendSats += spendAmountSats;
+            claim = this._openAsyncSpendClaim(paymentHashHex, spendAmountSats);
         }
-        this._acquireBlockingPayment(paymentHashHex);
-        let blockingReleased = false;
-        const releaseBlockingPayment = () => {
-            if (blockingReleased)
-                return;
-            blockingReleased = true;
-            this._releaseBlockingPayment(paymentHashHex);
-        };
-        let released = false;
-        const releaseReservation = () => {
-            if (spendAmountSats <= 0 || released)
-                return;
-            released = true;
-            this._pendingSpendSats -= spendAmountSats;
-        };
         try {
             if (metadata) {
                 this.node.setPaymentMetadata(decoded.paymentHash, metadata);
             }
         }
         catch (err) {
-            releaseReservation();
-            releaseBlockingPayment();
+            if (claim)
+                this._closeAsyncSpendClaim(paymentHashHex, claim);
             throw err;
         }
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 cleanup();
-                releaseReservation();
-                this.node.failPayment(decoded.paymentHash);
-                reject(new errors_1.BeignetError('PAYMENT_TIMEOUT', `Payment timed out after ${timeoutMs}ms`));
+                reject(this._paymentTimeout(decoded.paymentHash, 'Payment', timeoutMs, claim));
             }, timeoutMs);
             const cleanup = () => {
                 clearTimeout(timer);
                 this.node.removeListener('payment:sent', onSent);
                 this.node.removeListener('payment:failed', onFailed);
-                releaseBlockingPayment();
             };
             const onSent = (info) => {
                 if (info.paymentHash.toString('hex') === paymentHashHex) {
                     cleanup();
-                    releaseReservation();
-                    if (spendAmountSats > 0)
-                        this._recordSpend(spendAmountSats);
                     resolve(this.toPaymentInfo(info));
                 }
             };
             const onFailed = (info) => {
                 if (info.paymentHash.toString('hex') === paymentHashHex) {
                     cleanup();
-                    releaseReservation();
                     const failDesc = info.failureCode !== undefined
                         ? (0, errors_1.describeFailureCode)(info.failureCode)
                         : 'unknown';
@@ -5409,33 +5751,9 @@ class BeignetNode extends events_1.EventEmitter {
             }
             catch (err) {
                 cleanup();
-                releaseReservation();
-                const msg = err instanceof Error ? err.message : String(err);
-                let code = 'PAYMENT_FAILED';
-                if (err instanceof Error && 'code' in err) {
-                    const lpErr = err;
-                    const codeMap = {
-                        NO_ROUTE: 'NO_ROUTE',
-                        DUPLICATE_PAYMENT: 'DUPLICATE_PAYMENT',
-                        NO_CHANNEL_TO_HOP: 'PEER_NOT_CONNECTED',
-                        FEE_EXCEEDS_MAX: 'PAYMENT_FAILED',
-                        CLTV_EXCEEDS_MAX: 'CLTV_EXCEEDS_MAX',
-                        MISSING_AMOUNT: 'INVALID_PARAMS',
-                        INVALID_INVOICE: 'INVALID_PARAMS',
-                        INVOICE_EXPIRED: 'INVOICE_EXPIRED'
-                    };
-                    code = codeMap[lpErr.code] || 'PAYMENT_FAILED';
-                }
-                else {
-                    if (msg.includes('No route found'))
-                        code = 'NO_ROUTE';
-                    else if (msg.includes('already in flight'))
-                        code = 'DUPLICATE_PAYMENT';
-                    else if (msg.includes('No channel to first hop') ||
-                        msg.includes('Peer not found'))
-                        code = 'PEER_NOT_CONNECTED';
-                }
-                reject(new errors_1.BeignetError(code, msg));
+                if (claim)
+                    this._closeAsyncSpendClaim(paymentHashHex, claim);
+                reject(this._toBeignetPaymentError(err));
             }
         });
     }
@@ -5457,7 +5775,7 @@ class BeignetNode extends events_1.EventEmitter {
             catch {
             }
             if (hashHex !== 'unknown') {
-                const existing = this.getPayment(hashHex);
+                const existing = this.getPayment(hashHex) ?? this.durablePaymentFor(err, hashHex);
                 if (existing)
                     return existing;
             }
@@ -5489,7 +5807,8 @@ class BeignetNode extends events_1.EventEmitter {
                     throw err;
                 lastError = err;
                 if (!(0, errors_1.isRetryableError)(err)) {
-                    const pi = this.getPayment(paymentHashHex);
+                    const pi = this.getPayment(paymentHashHex) ??
+                        this.durablePaymentFor(err, paymentHashHex);
                     if (pi)
                         return { ...pi, attempts: attempt };
                     return {
@@ -5601,11 +5920,7 @@ class BeignetNode extends events_1.EventEmitter {
         catch (err) {
             if (claim)
                 this._closeAsyncSpendClaim(paymentHashHex, claim);
-            if (err instanceof Error &&
-                err.code === 'CLTV_EXCEEDS_MAX') {
-                throw new errors_1.BeignetError('CLTV_EXCEEDS_MAX', err.message);
-            }
-            throw err;
+            throw this._toBeignetPaymentError(err);
         }
         if (claim && result.status === 'FAILED') {
             this._releaseAsyncSpendClaim(claim);
@@ -5624,14 +5939,8 @@ class BeignetNode extends events_1.EventEmitter {
             : undefined;
         this._checkMaxPayment(amountSats);
         this._checkSpendLimit(amountSats);
-        this._pendingSpendSats += amountSats;
-        let released = false;
-        const releaseReservation = () => {
-            if (released)
-                return;
-            released = true;
-            this._pendingSpendSats -= amountSats;
-        };
+        const provisionalKey = `keysend:${crypto.randomBytes(8).toString('hex')}`;
+        const claim = this._openAsyncSpendClaim(provisionalKey, amountSats);
         const destination = Buffer.from(pubkey, 'hex');
         let result;
         try {
@@ -5643,22 +5952,29 @@ class BeignetNode extends events_1.EventEmitter {
             });
         }
         catch (err) {
-            releaseReservation();
-            throw err;
+            if (claim)
+                this._closeAsyncSpendClaim(provisionalKey, claim);
+            throw this._toBeignetPaymentError(err);
         }
         const paymentHashHex = result.paymentHash.toString('hex');
+        if (claim) {
+            this._rekeyAsyncSpendClaim(provisionalKey, paymentHashHex, claim);
+        }
         if (result.status !== 'PENDING') {
-            releaseReservation();
-            if (result.status === 'COMPLETED')
-                this._recordSpend(amountSats);
+            if (claim) {
+                if (result.status === 'COMPLETED') {
+                    this._chargeAsyncSpendClaim(paymentHashHex, claim);
+                }
+                else {
+                    this._releaseAsyncSpendClaim(claim);
+                }
+            }
             return this.toPaymentInfo(result);
         }
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 cleanup();
-                releaseReservation();
-                this.node.failPayment(result.paymentHash);
-                reject(new errors_1.BeignetError('PAYMENT_TIMEOUT', `Keysend timed out after ${timeoutMs}ms`));
+                reject(this._paymentTimeout(result.paymentHash, 'Keysend', timeoutMs, claim));
             }, timeoutMs);
             const cleanup = () => {
                 clearTimeout(timer);
@@ -5668,15 +5984,12 @@ class BeignetNode extends events_1.EventEmitter {
             const onSent = (info) => {
                 if (info.paymentHash.toString('hex') === paymentHashHex) {
                     cleanup();
-                    releaseReservation();
-                    this._recordSpend(amountSats);
                     resolve(this.toPaymentInfo(info));
                 }
             };
             const onFailed = (info) => {
                 if (info.paymentHash.toString('hex') === paymentHashHex) {
                     cleanup();
-                    releaseReservation();
                     const failDesc = info.failureCode !== undefined
                         ? (0, errors_1.describeFailureCode)(info.failureCode)
                         : 'unknown';
@@ -5740,6 +6053,19 @@ class BeignetNode extends events_1.EventEmitter {
             return null;
         return this.toPaymentInfo(p);
     }
+    durablePaymentFor(err, hashHex) {
+        if (!(err instanceof errors_1.BeignetError) ||
+            err.code !== errors_1.BeignetErrorCode.DUPLICATE_PAYMENT) {
+            return null;
+        }
+        try {
+            const durable = this.storage.loadPayment(hashHex);
+            return durable ? this.toPaymentInfo(durable) : null;
+        }
+        catch {
+            return null;
+        }
+    }
     listForwards(filter) {
         return this.node.listForwards(filter).map((f) => ({
             id: f.id,
@@ -6166,45 +6492,31 @@ class BeignetNode extends events_1.EventEmitter {
         this._checkDraining();
         const paymentHashHex = bolt12Invoice.paymentHash.toString('hex');
         const spendAmountSats = paymentSpendSats(bolt12Invoice.amount, amountSats);
+        let claim;
         if (spendAmountSats > 0) {
             this._checkMaxPayment(spendAmountSats);
             this._checkSpendLimit(spendAmountSats);
-            this._pendingSpendSats += spendAmountSats;
+            claim = this._openAsyncSpendClaim(paymentHashHex, spendAmountSats);
         }
-        this._acquireBlockingPayment(paymentHashHex);
-        let released = false;
-        const releaseReservation = () => {
-            if (spendAmountSats <= 0 || released)
-                return;
-            released = true;
-            this._pendingSpendSats -= spendAmountSats;
-        };
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 cleanup();
-                releaseReservation();
-                this.node.failPayment(bolt12Invoice.paymentHash);
-                reject(new errors_1.BeignetError('PAYMENT_TIMEOUT', `Payment timed out after ${timeoutMs}ms`));
+                reject(this._paymentTimeout(bolt12Invoice.paymentHash, 'Payment', timeoutMs, claim));
             }, timeoutMs);
             const cleanup = () => {
                 clearTimeout(timer);
                 this.node.removeListener('payment:sent', onSent);
                 this.node.removeListener('payment:failed', onFailed);
-                this._releaseBlockingPayment(paymentHashHex);
             };
             const onSent = (info) => {
                 if (info.paymentHash.toString('hex') === paymentHashHex) {
                     cleanup();
-                    releaseReservation();
-                    if (spendAmountSats > 0)
-                        this._recordSpend(spendAmountSats);
                     resolve(this.toPaymentInfo(info));
                 }
             };
             const onFailed = (info) => {
                 if (info.paymentHash.toString('hex') === paymentHashHex) {
                     cleanup();
-                    releaseReservation();
                     const failDesc = info.failureCode !== undefined
                         ? (0, errors_1.describeFailureCode)(info.failureCode)
                         : 'unknown';
@@ -6218,9 +6530,9 @@ class BeignetNode extends events_1.EventEmitter {
             }
             catch (err) {
                 cleanup();
-                releaseReservation();
-                const msg = err instanceof Error ? err.message : String(err);
-                reject(new errors_1.BeignetError('PAYMENT_FAILED', msg));
+                if (claim)
+                    this._closeAsyncSpendClaim(paymentHashHex, claim);
+                reject(this._toBeignetPaymentError(err));
             }
         });
     }
@@ -6873,12 +7185,121 @@ class BeignetNode extends events_1.EventEmitter {
     setPaymentMetadata(paymentHash, metadata) {
         this.node.setPaymentMetadata(Buffer.from(paymentHash, 'hex'), metadata);
     }
+    async resolveInterruptedPayment(bolt11) {
+        if (this.destroyed) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.NODE_DESTROYED, 'Node is shut down; an interrupted payment is settled at the next start');
+        }
+        if (this._restorePending || this._resuming) {
+            throw new errors_1.BeignetError('NODE_RESTORE_PENDING', 'No node is running yet to settle an interrupted payment against');
+        }
+        if (this._restartRequired) {
+            throw new errors_1.BeignetError('NODE_RESTART_REQUIRED', 'A capsule restore replaced this database; an interrupted payment ' +
+                'is settled after the restart');
+        }
+        let paymentHash;
+        try {
+            paymentHash = (0, decode_1.decode)(bolt11).paymentHash;
+        }
+        catch {
+            return { status: 'unpaid' };
+        }
+        const hashHex = paymentHash.toString('hex');
+        const view = await this.node.awaitPaymentResolution(paymentHash);
+        if (view.preimage || view.status === types_5.PaymentStatus.COMPLETED) {
+            return { status: 'completed', paymentHash: hashHex };
+        }
+        const durable = this.storage.loadPayment(hashHex);
+        if (durable?.direction === types_5.PaymentDirection.OUTGOING &&
+            (durable.status === types_5.PaymentStatus.COMPLETED ||
+                durable.preimage !== undefined)) {
+            return { status: 'completed', paymentHash: hashHex };
+        }
+        return { status: 'unpaid' };
+    }
+    canCarryHtlc() {
+        const live = this.node
+            .getChannelManager()
+            .listChannels()
+            .filter(canBecomeUsable);
+        return live.length === 0 || live.some((ch) => ch.acceptsNewHtlcs());
+    }
+    whenReadyToPay(run) {
+        if (this.destroyed)
+            return;
+        if (this._restorePending) {
+            this.once('recovery:restored', () => this.whenReadyToPay(run));
+            return;
+        }
+        if (this._resuming || this._restartRequired)
+            return;
+        const node = this.node;
+        const live = () => !this.destroyed &&
+            !this._resuming &&
+            !this._restartRequired &&
+            this.node === node;
+        let ready;
+        try {
+            ready = node.waitForReady(BeignetNode.MAX_TIMER_MS);
+        }
+        catch {
+            return;
+        }
+        ready
+            .then(() => {
+            if (!live())
+                return;
+            if (this.canCarryHtlc()) {
+                run();
+                return;
+            }
+            const recheck = () => {
+                if (live() && !this.canCarryHtlc())
+                    return;
+                this.removeListener('channel:usable', recheck);
+                this.removeListener(CHANNELS_CHANGED, recheck);
+                if (live())
+                    run();
+            };
+            this.on('channel:usable', recheck);
+            this.on(CHANNELS_CHANGED, recheck);
+        }, () => {
+        })
+            .catch((err) => {
+            try {
+                this.log('warn', 'Starting the payment queue failed', {
+                    error: err instanceof Error ? err.message : String(err)
+                });
+            }
+            catch {
+            }
+        });
+    }
     getPaymentQueue() {
         if (!this.paymentQueue) {
-            this.paymentQueue = new payment_queue_1.PaymentQueue((bolt11, timeout, maxFee, amount, meta) => this.payInvoiceSafe(bolt11, timeout, maxFee, amount, meta), (amount) => this.canSend(amount), undefined, this.storage);
+            this.paymentQueue = new payment_queue_1.PaymentQueue((bolt11, timeout, maxFee, amount, meta) => this.payInvoiceSafe(bolt11, timeout, maxFee, amount, meta), (amount) => this.node
+                ? this.canSend(amount)
+                : { canSend: false, availableSats: 0 }, {
+                resolveInterrupted: (b) => this.resolveInterruptedPayment(b),
+                invoiceAmountSats: (b) => paymentSpendSats(decodeInvoiceInput(b).amountMsat)
+            }, this.liveQueueStorage());
+            if (this.destroyed) {
+                this.paymentQueue.stop();
+            }
+            else {
+                this.whenReadyToPay(() => this.paymentQueue?.start());
+                this.on('channel:usable', () => this.paymentQueue?.poke());
+            }
         }
         return this.paymentQueue;
     }
+    liveQueueStorage() {
+        return {
+            saveQueueEntry: (entry) => this.storage.saveQueueEntry(entry),
+            updateQueueEntryStatus: (id, status, error, completedAt) => this.storage.updateQueueEntryStatus(id, status, error, completedAt),
+            deleteQueueEntry: (id) => this.storage.deleteQueueEntry(id),
+            loadAllQueueEntries: () => this.storage.loadAllQueueEntries()
+        };
+    }
     enqueuePayment(bolt11, priority, opts) {
         return this.getPaymentQueue().enqueue(bolt11, priority, opts);
     }
@@ -7274,6 +7695,7 @@ class BeignetNode extends events_1.EventEmitter {
             clearInterval(this._fallbackRecoveryTimer);
             this._fallbackRecoveryTimer = undefined;
         }
+        this.paymentQueue?.stop();
         this.paymentQueue?.removeAllListeners();
         this.directFundingSender?.stop();
         if (this._confirmTimer) {
@@ -7286,15 +7708,12 @@ class BeignetNode extends events_1.EventEmitter {
             await this._backupPromise.catch(() => {
             });
         }
-        await this.node?.gracefulShutdown(timeoutMs);
-        this.storage.close();
-        this.removeAllListeners();
         try {
-            await this.wallet?.stop();
+            await this.node?.gracefulShutdown(timeoutMs);
         }
-        catch {
+        finally {
+            await this.stopWalletAndCloseStorage();
         }
-        this.releaseLock();
     }
     async destroy() {
         this.stopOfflineReceive();
@@ -7326,16 +7745,29 @@ class BeignetNode extends events_1.EventEmitter {
         }
         this.stopRecoveryLeaseCheck();
         this.clearAutoApplyTimers();
+        this.paymentQueue?.stop();
         this.paymentQueue?.removeAllListeners();
         this.directFundingSender?.stop();
-        this.node?.destroy();
-        this.storage.close();
+        try {
+            this.node?.destroy();
+        }
+        finally {
+            await this.stopWalletAndCloseStorage();
+        }
+    }
+    async stopWalletAndCloseStorage() {
+        this._nodeStorageView?.close();
         this.removeAllListeners();
         try {
             await this.wallet?.stop();
         }
         catch {
         }
+        try {
+            this.storage.close();
+        }
+        catch {
+        }
         this.releaseLock();
     }
     releaseLock() {