beignet 0.21.2 → 0.21.3

package/dist/lightning/node/lightning-node.js

@@ -199,6 +199,7 @@ class LightningNode extends events_1.EventEmitter {
         this.heldInvoiceHashes = new Set();
         this.heldHtlcs = new Map();
         this.resolvingHeldHtlcs = new Set();
+        this.heldResolutions = new Map();
         this.holdInvoiceEventQueue = [];
         this.emittingHoldInvoiceEvent = false;
         this.announcedAddresses = [];
@@ -1172,6 +1173,21 @@ class LightningNode extends events_1.EventEmitter {
                         amountMsat: BigInt(h.amountMsat),
                         cltvExpiry: h.cltvExpiry
                     })));
+                    const r = entry.resolution;
+                    if (!r)
+                        continue;
+                    const resolved = r.resolved.map((h) => ({
+                        amountMsat: BigInt(h.amountMsat),
+                        cltvExpiry: h.cltvExpiry
+                    }));
+                    this.heldResolutions.set(entry.hashHex, r.outcome === 'settle'
+                        ? { outcome: 'settle', resolved }
+                        : {
+                            outcome: 'cancel',
+                            failureCode: r.failureCode ?? types_3.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS,
+                            reason: r.reason ?? 'api',
+                            resolved
+                        });
                 }
             }
             catch {
@@ -1723,6 +1739,7 @@ class LightningNode extends events_1.EventEmitter {
             this.drainParkedQuiescentHtlcs(channelId.toString('hex'));
             this.asyncPaymentManager.onChannelUsable(channelId.toString('hex'));
             this.retryOwedHeldForwardFailures(channelId.toString('hex'));
+            this.retryHeldResolutions(channelId);
             const peer = this.channelManager.getPeerForChannel(channelId);
             if (peer)
                 this.asyncPaymentManager.sendNotice(peer);
@@ -9372,9 +9389,10 @@ class LightningNode extends events_1.EventEmitter {
             const alreadyParked = parked.some((h) => h.channelId.equals(channelId) && h.htlcId === htlcId);
             const parkedMsat = parked.reduce((sum, h) => sum + h.amountMsat, 0n);
             if (!alreadyParked &&
-                finalInvoice?.amountMsat &&
-                finalInvoice.amountMsat > 0n &&
-                parkedMsat >= finalInvoice.amountMsat) {
+                (this.heldResolutions.has(hashHex) ||
+                    (finalInvoice?.amountMsat &&
+                        finalInvoice.amountMsat > 0n &&
+                        parkedMsat >= finalInvoice.amountMsat))) {
                 this.emitStructuredLog('htlc', 'held_set_complete', {
                     paymentHash: hashHex,
                     parkedMsat: parkedMsat.toString(),
@@ -9496,6 +9514,8 @@ class LightningNode extends events_1.EventEmitter {
             return false;
         if (this.resolvingHeldHtlcs.has(hashHex))
             return false;
+        if (this.heldResolutions.get(hashHex)?.outcome === 'cancel')
+            return false;
         const pre = preimage ?? this.preimages.get(hashHex);
         if (!pre) {
             throw new Error('settleHeldHtlc: no preimage available for hold invoice');
@@ -9512,30 +9532,42 @@ class LightningNode extends events_1.EventEmitter {
         this.preimages.set(hashHex, pre);
         this.channelManager.recordPreimage(paymentHash, pre);
         this.resolvingHeldHtlcs.add(hashHex);
-        let fulfilled = 0;
+        const prior = this.heldResolutions.get(hashHex);
+        const refused = [];
         try {
+            this.heldResolutions.set(hashHex, {
+                outcome: 'settle',
+                resolved: prior?.resolved ?? []
+            });
+            this.persistHeldHtlcs();
             for (const h of held) {
                 const key = `${h.channelId.toString('hex')}:${h.htlcId}`;
                 if (!this.channelManager.fulfillHtlc(h.channelId, h.htlcId, pre).ok) {
+                    refused.push(h);
                     continue;
                 }
-                fulfilled++;
                 this.cleanupHtlcSharedSecret(key);
             }
         }
         finally {
             this.resolvingHeldHtlcs.delete(hashHex);
         }
-        if (fulfilled === 0) {
+        if (refused.length === held.length) {
+            if (!prior) {
+                this.heldResolutions.delete(hashHex);
+                this.persistHeldHtlcs();
+            }
             this.emitStructuredLog('htlc', 'held_settle_refused', {
                 paymentHash: hashHex,
                 htlcCount: held.length
             });
             return false;
         }
-        this.heldHtlcs.delete(hashHex);
-        this.heldInvoiceHashes.delete(hashHex);
-        this.persistHeldHtlcs();
+        const settledSet = this.advanceHeldResolution(hashHex, held, refused, {
+            outcome: 'settle'
+        });
+        if (!settledSet)
+            return false;
         const payment = this.payments.get(hashHex);
         if (payment) {
             payment.status = types_7.PaymentStatus.COMPLETED;
@@ -9553,13 +9585,59 @@ class LightningNode extends events_1.EventEmitter {
         const event = {
             paymentHash,
             state: 'SETTLED',
-            heldAmountMsat: held.reduce((sum, h) => sum + h.amountMsat, 0n),
-            htlcCount: held.length,
-            ...this.heldSetExpiry(hashHex, held)
+            heldAmountMsat: settledSet.reduce((sum, h) => sum + h.amountMsat, 0n),
+            htlcCount: settledSet.length,
+            ...this.heldSetExpiry(hashHex, settledSet)
         };
         this.emitHoldInvoiceEvent('hold:settled', event);
         return true;
     }
+    advanceHeldResolution(hashHex, held, refused, chosen) {
+        const resolved = [
+            ...(this.heldResolutions.get(hashHex)?.resolved ?? []),
+            ...held
+                .filter((h) => !refused.includes(h))
+                .map((h) => ({ amountMsat: h.amountMsat, cltvExpiry: h.cltvExpiry }))
+        ];
+        if (refused.length === 0) {
+            this.heldHtlcs.delete(hashHex);
+            this.heldResolutions.delete(hashHex);
+            this.heldInvoiceHashes.delete(hashHex);
+            this.persistHeldHtlcs();
+            return resolved;
+        }
+        this.heldHtlcs.set(hashHex, refused);
+        this.heldResolutions.set(hashHex, { ...chosen, resolved });
+        this.persistHeldHtlcs();
+        this.emitStructuredLog('htlc', `held_${chosen.outcome}_partial`, {
+            paymentHash: hashHex,
+            resolvedCount: resolved.length,
+            refusedCount: refused.length
+        });
+        return null;
+    }
+    retryHeldResolutions(channelId) {
+        for (const [hashHex, resolution] of [...this.heldResolutions]) {
+            const held = this.heldHtlcs.get(hashHex) ?? [];
+            if (channelId && !held.some((h) => h.channelId.equals(channelId))) {
+                continue;
+            }
+            const paymentHash = Buffer.from(hashHex, 'hex');
+            try {
+                if (resolution.outcome === 'cancel')
+                    this.cancelHeldHtlc(paymentHash);
+                else
+                    this.settleHeldHtlc(paymentHash);
+            }
+            catch (error) {
+                this.emitStructuredLog('htlc', 'held_resolution_retry_failed', {
+                    paymentHash: hashHex,
+                    outcome: resolution.outcome,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+    }
     emitInvoiceSettled(paymentHash, payment) {
         const invoice = this.invoices.get(paymentHash.toString('hex'));
         if (!invoice)
@@ -9581,9 +9659,23 @@ class LightningNode extends events_1.EventEmitter {
             return false;
         if (this.resolvingHeldHtlcs.has(hashHex))
             return false;
+        const chosen = this.heldResolutions.get(hashHex);
+        if (chosen?.outcome === 'settle')
+            return false;
+        if (chosen) {
+            failureCode = chosen.failureCode;
+            cancelReason = chosen.reason;
+        }
         this.resolvingHeldHtlcs.add(hashHex);
-        let failed = 0;
+        const refused = [];
         try {
+            this.heldResolutions.set(hashHex, {
+                outcome: 'cancel',
+                failureCode,
+                reason: cancelReason,
+                resolved: chosen?.resolved ?? []
+            });
+            this.persistHeldHtlcs();
             for (const h of held) {
                 const key = `${h.channelId.toString('hex')}:${h.htlcId}`;
                 const ss = this.receivedHtlcSharedSecrets.get(key);
@@ -9593,16 +9685,20 @@ class LightningNode extends events_1.EventEmitter {
                         : undefined)
                     : Buffer.alloc(failures_1.FAILURE_MESSAGE_LENGTH);
                 if (!this.channelManager.failHtlc(h.channelId, h.htlcId, reason).ok) {
+                    refused.push(h);
                     continue;
                 }
-                failed++;
                 this.cleanupHtlcSharedSecret(key);
             }
         }
         finally {
             this.resolvingHeldHtlcs.delete(hashHex);
         }
-        if (failed === 0) {
+        if (refused.length === held.length) {
+            if (!chosen) {
+                this.heldResolutions.delete(hashHex);
+                this.persistHeldHtlcs();
+            }
             this.emitStructuredLog('htlc', 'held_cancel_refused', {
                 paymentHash: hashHex,
                 reason: cancelReason,
@@ -9610,10 +9706,14 @@ class LightningNode extends events_1.EventEmitter {
             });
             return false;
         }
-        this.heldHtlcs.delete(hashHex);
-        this.heldInvoiceHashes.delete(hashHex);
-        this.persistHeldHtlcs();
-        this.markHoldInvoiceCancelled(hashHex, cancelReason, held.length, held.reduce((sum, h) => sum + h.amountMsat, 0n), held);
+        const failedSet = this.advanceHeldResolution(hashHex, held, refused, {
+            outcome: 'cancel',
+            failureCode,
+            reason: cancelReason
+        });
+        if (!failedSet)
+            return false;
+        this.markHoldInvoiceCancelled(hashHex, cancelReason, failedSet.length, failedSet.reduce((sum, h) => sum + h.amountMsat, 0n), failedSet);
         this.emitStructuredLog('htlc', 'held_cancelled', {
             paymentHash: hashHex,
             reason: cancelReason
@@ -9660,7 +9760,7 @@ class LightningNode extends events_1.EventEmitter {
         const hashHex = paymentHash.toString('hex');
         const held = this.heldHtlcs.get(hashHex);
         if (held && held.length > 0) {
-            const count = held.length;
+            const count = held.length + (this.heldResolutions.get(hashHex)?.resolved.length ?? 0);
             if (!this.cancelHeldHtlc(paymentHash))
                 return null;
             return { htlcsFailed: count };
@@ -9704,7 +9804,10 @@ class LightningNode extends events_1.EventEmitter {
     scanExpiringHeldHtlcs(height) {
         if (height <= 0)
             return;
+        this.retryHeldResolutions();
         for (const [hashHex, held] of this.heldHtlcs) {
+            if (this.heldResolutions.has(hashHex))
+                continue;
             const soon = held.some((h) => h.cltvExpiry > 0 && h.cltvExpiry - height <= exports.HELD_HTLC_EXPIRY_MARGIN);
             if (soon) {
                 this.cancelHeldHtlc(Buffer.from(hashHex, 'hex'), types_3.INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS, 'expiry-scan');
@@ -9716,6 +9819,7 @@ class LightningNode extends events_1.EventEmitter {
             return;
         const serial = [];
         for (const [hashHex, held] of this.heldHtlcs) {
+            const r = this.heldResolutions.get(hashHex);
             serial.push({
                 hashHex,
                 htlcs: held.map((h) => ({
@@ -9723,7 +9827,16 @@ class LightningNode extends events_1.EventEmitter {
                     htlcId: h.htlcId.toString(),
                     amountMsat: h.amountMsat.toString(),
                     cltvExpiry: h.cltvExpiry
-                }))
+                })),
+                ...(r && {
+                    resolution: {
+                        ...r,
+                        resolved: r.resolved.map((h) => ({
+                            amountMsat: h.amountMsat.toString(),
+                            cltvExpiry: h.cltvExpiry
+                        }))
+                    }
+                })
             });
         }
         this.safeStorage(() => this.storage.saveMetadata('held_htlcs', JSON.stringify(serial)), 'persistHeldHtlcs');
@@ -13226,9 +13339,13 @@ class LightningNode extends events_1.EventEmitter {
                 if (!key.startsWith('received-'))
                     continue;
                 const paymentHashHex = htlc.paymentHash?.toString('hex');
+                const resolution = paymentHashHex !== undefined
+                    ? this.heldResolutions.get(paymentHashHex)
+                    : undefined;
                 const parkedHold = htlc.state !== types_1.HtlcState.FULFILLED &&
                     paymentHashHex !== undefined &&
-                    this.heldInvoiceHashes.has(paymentHashHex);
+                    this.heldInvoiceHashes.has(paymentHashHex) &&
+                    resolution?.outcome !== 'settle';
                 const haveClaim = !parkedHold &&
                     (htlc.state === types_1.HtlcState.FULFILLED ||
                         (paymentHashHex !== undefined &&
@@ -13277,6 +13394,12 @@ class LightningNode extends events_1.EventEmitter {
                         this._forceCloseWithReason(channelId, this.getSweepDestinationScript(), this.resolveForceCloseFeeRatePerVbyte(), 'FORWARD_TIMEOUT_FORCE_CLOSE');
                         break;
                     }
+                    if (resolution?.outcome === 'cancel' &&
+                        this.heldHtlcs
+                            .get(paymentHashHex)
+                            ?.some((h) => h.channelId.equals(channelId) && h.htlcId === htlc.id)) {
+                        continue;
+                    }
                     const htlcSecretKey = `${channelId.toString('hex')}:${htlc.id}`;
                     const blindedRole = this.blindedRoleFor(channelId, htlc.id);
                     if (blindedRole) {