beignet 0.2.0 → 0.3.0

package/dist/lightning/channel/channel.js

@@ -13,6 +13,7 @@ const channel_commitment_1 = require("../message/channel-commitment");
 const channel_close_1 = require("../message/channel-close");
 const closing_1 = require("../chain/closing");
 const channel_reestablish_1 = require("../message/channel-reestablish");
+const error_1 = require("../message/error");
 const channel_actions_1 = require("./channel-actions");
 const types_2 = require("./types");
 const channel_state_1 = require("./channel-state");
@@ -83,6 +84,7 @@ class Channel {
         this._spliceRemoteCommitmentSig = null;
         this._pendingBatch = null;
         this._lastSentBatch = null;
+        this._remoteCommitmentTxCache = new Map();
         this._forgottenSplice = false;
         this._spliceAbortPending = false;
         this._reestablishRetransmitted = false;
@@ -95,9 +97,13 @@ class Channel {
         this._taprootClosingCache = null;
         this._currentBlockHeight = 0;
         this._channelKeyIndex = null;
+        this._maxFundingSatoshis = types_2.MAX_FUNDING_SATOSHIS;
         this._state = state;
         this._signer = signer || null;
     }
+    setMaxFundingSatoshis(max) {
+        this._maxFundingSatoshis = max;
+    }
     get channelKeyIndex() {
         return this._channelKeyIndex;
     }
@@ -200,7 +206,7 @@ class Channel {
             ...this._state.localBasepoints,
             firstPerCommitmentPoint: firstPoint
         };
-        const error = (0, validation_1.validateOpenChannelParams)(msg);
+        const error = (0, validation_1.validateOpenChannelParams)(msg, this._maxFundingSatoshis);
         if (error) {
             return [{ type: channel_actions_1.ChannelActionType.ERROR, message: error }];
         }
@@ -433,7 +439,7 @@ class Channel {
                 { type: channel_actions_1.ChannelActionType.ERROR, message: 'Unexpected open_channel' }
             ];
         }
-        const error = (0, validation_1.validateOpenChannelParams)(msg);
+        const error = (0, validation_1.validateOpenChannelParams)(msg, this._maxFundingSatoshis);
         if (error) {
             return [{ type: channel_actions_1.ChannelActionType.ERROR, message: error }];
         }
@@ -476,6 +482,15 @@ class Channel {
                     }
                 ];
             }
+            if (proposedFlags.hasFeature(flags_1.Feature.ZERO_CONF) &&
+                !(this._state.zeroConfEnabled && this._state.trustedPeer)) {
+                return [
+                    {
+                        type: channel_actions_1.ChannelActionType.ERROR,
+                        message: 'Proposed zero_conf channel type requires a trusted peer'
+                    }
+                ];
+            }
             this._state.channelType = msg.channelType;
         }
         else {
@@ -1063,6 +1078,36 @@ class Channel {
         }
         this._state.revokedHtlcSnapshots.set(commitmentNumber.toString(), entries);
     }
+    _cacheRemoteCommitmentForWatchtower() {
+        try {
+            if ((0, types_3.isTaprootChannel)(this._state.channelType))
+                return;
+            if (!this._state.remoteBasepoints || !this._state.fundingTxid)
+                return;
+            const point = this._state.remoteNextPerCommitmentPoint ||
+                this._state.remoteCurrentPerCommitmentPoint;
+            if (!point)
+                return;
+            const built = (0, commitment_builder_1.buildRemoteCommitment)(this._state, point, this._state.remoteCommitmentNumber + 1n);
+            this._remoteCommitmentTxCache.set(point.toString('hex'), built.result.tx.toBuffer().toString('hex'));
+            while (this._remoteCommitmentTxCache.size > Channel.REVOKED_TX_CACHE_MAX) {
+                const oldest = this._remoteCommitmentTxCache.keys().next().value;
+                if (oldest === undefined)
+                    break;
+                this._remoteCommitmentTxCache.delete(oldest);
+            }
+        }
+        catch {
+        }
+    }
+    takeRevokedCommitmentTx(perCommitmentSecret) {
+        const pointHex = (0, derivation_1.perCommitmentPointFromSecret)(perCommitmentSecret).toString('hex');
+        const txHex = this._remoteCommitmentTxCache.get(pointHex);
+        if (!txHex)
+            return null;
+        this._remoteCommitmentTxCache.delete(pointHex);
+        return Buffer.from(txHex, 'hex');
+    }
     signCommitment(signature, htlcSignatures, partialSignatureWithNonce, spliceBatch) {
         if (this._state.state !== types_2.ChannelState.NORMAL &&
             this._state.state !== types_2.ChannelState.SHUTTING_DOWN &&
@@ -1108,6 +1153,7 @@ class Channel {
                 : null;
         this._state.lastSentHtlcSignatures = htlcSignatures.map((s) => Buffer.from(s));
         this._snapshotRemoteCommitmentHtlcs(this._state.remoteCommitmentNumber);
+        this._cacheRemoteCommitmentForWatchtower();
         this._state.remoteCommitmentNumber++;
         this._state.needsCommitment = false;
         this._state.pendingLocalUpdatesSignedCount =
@@ -1488,6 +1534,14 @@ class Channel {
         return true;
     }
     forceClose(signer) {
+        if (this._state.dataLossDetected) {
+            return [
+                {
+                    type: channel_actions_1.ChannelActionType.ERROR,
+                    message: 'Refusing to broadcast stale commitment after data loss'
+                }
+            ];
+        }
         if (this._state.state !== types_2.ChannelState.NORMAL &&
             this._state.state !== types_2.ChannelState.SHUTTING_DOWN &&
             this._state.state !== types_2.ChannelState.AWAITING_FUNDING_CONFIRMED &&
@@ -2465,6 +2519,25 @@ class Channel {
                 ];
             }
         }
+        if ((msg.nextCommitmentNumber > this._state.remoteCommitmentNumber + 1n ||
+            msg.nextRevocationNumber > this._state.localCommitmentNumber + 1n) &&
+            msg.nextRevocationNumber > this._state.localCommitmentNumber &&
+            !msg.yourLastPerCommitmentSecret.equals(Buffer.alloc(32))) {
+            this._state.dataLossDetected = true;
+            this._state.dlpRemotePerCommitmentPoint = msg.myCurrentPerCommitmentPoint;
+            this._state.state = types_2.ChannelState.ERRORED;
+            return [
+                { type: channel_actions_1.ChannelActionType.PERSIST_STATE },
+                sendMsg(types_1.MessageType.ERROR, (0, error_1.encodeErrorMessage)({
+                    channelId: this._state.channelId,
+                    data: Buffer.from('peer proved our channel state is stale (data loss); awaiting your force close', 'ascii')
+                })),
+                {
+                    type: channel_actions_1.ChannelActionType.ERROR,
+                    message: 'Channel fell behind: peer proved our state is stale (data loss); refusing to broadcast, awaiting peer force close'
+                }
+            ];
+        }
         if (msg.nextCommitmentNumber > this._state.remoteCommitmentNumber + 1n) {
             return [
                 {
@@ -2671,6 +2744,15 @@ class Channel {
                 }
             ];
         }
+        if (relativeSatoshis > 0n &&
+            this._state.fundingSatoshis + relativeSatoshis > this._maxFundingSatoshis) {
+            return [
+                {
+                    type: channel_actions_1.ChannelActionType.ERROR,
+                    message: `Cannot splice-in: post-splice capacity ${this._state.fundingSatoshis + relativeSatoshis} exceeds maximum ${this._maxFundingSatoshis}`
+                }
+            ];
+        }
         if (relativeSatoshis < 0n) {
             const withdrawSats = -relativeSatoshis;
             const localBalanceSats = this._state.localBalanceMsat / 1000n;
@@ -2755,6 +2837,16 @@ class Channel {
             this._spliceSession = null;
             return [{ type: channel_actions_1.ChannelActionType.ERROR, message: result.error }];
         }
+        const postSpliceCapacity = this._state.fundingSatoshis + this._spliceSession.getNetCapacityChange();
+        if (postSpliceCapacity > this._maxFundingSatoshis) {
+            this._spliceSession = null;
+            return [
+                {
+                    type: channel_actions_1.ChannelActionType.ERROR,
+                    message: `Cannot accept splice: post-splice capacity ${postSpliceCapacity} exceeds maximum ${this._maxFundingSatoshis}`
+                }
+            ];
+        }
         this._state.preSpliceState = this._state.state;
         this._state.state = types_2.ChannelState.SPLICING;
         const ackMsg = result.message;
@@ -2781,6 +2873,21 @@ class Channel {
         if (!result.ok) {
             return [{ type: channel_actions_1.ChannelActionType.ERROR, message: result.error }];
         }
+        const postSpliceCapacity = this._state.fundingSatoshis + this._spliceSession.getNetCapacityChange();
+        if (postSpliceCapacity > this._maxFundingSatoshis) {
+            const actions = [
+                sendMsg(types_1.MessageType.TX_ABORT, (0, interactive_tx_1.encodeTxAbortMessage)({
+                    channelId: this._state.channelId,
+                    data: Buffer.from('post-splice capacity exceeds maximum', 'utf8')
+                }))
+            ];
+            actions.push(...this.abortSplice(`post-splice capacity ${postSpliceCapacity} exceeds maximum ${this._maxFundingSatoshis}`));
+            actions.push({
+                type: channel_actions_1.ChannelActionType.ERROR,
+                message: `splice aborted: post-splice capacity ${postSpliceCapacity} exceeds maximum ${this._maxFundingSatoshis}`
+            });
+            return actions;
+        }
         if (this._spliceSession.getRequireConfirmedInputs() &&
             this._spliceInInputs?.inputs.some((i) => i.confirmed === false)) {
             const actions = [
@@ -3951,7 +4058,7 @@ class Channel {
             this._state.channelType = defaultType.toBuffer();
         }
         this._state.temporaryChannelId = (0, validation_1.deriveV2TemporaryChannelId)(params.localBasepoints.revocationBasepoint);
-        const session = new dual_funding_2.DualFundingSession(true, this._state.temporaryChannelId);
+        const session = new dual_funding_2.DualFundingSession(true, this._state.temporaryChannelId, this._maxFundingSatoshis);
         const result = session.initiateOpen(params);
         if (!result.ok || !result.message) {
             return [
@@ -3976,6 +4083,18 @@ class Channel {
         this._state.fundingVersion = 2;
         this._state.commitmentFeeratePerkw = msg.commitmentFeeratePerkw;
         this._state.fundingLocktime = msg.locktime;
+        if (msg.channelType) {
+            const proposedFlags = flags_1.FeatureFlags.fromBuffer(msg.channelType);
+            if (proposedFlags.hasFeature(flags_1.Feature.ZERO_CONF) &&
+                !(this._state.zeroConfEnabled && this._state.trustedPeer)) {
+                return [
+                    {
+                        type: channel_actions_1.ChannelActionType.ERROR,
+                        message: 'Proposed zero_conf channel type requires a trusted peer'
+                    }
+                ];
+            }
+        }
         localParams = {
             ...localParams,
             localBasepoints: {
@@ -3983,7 +4102,7 @@ class Channel {
                 firstPerCommitmentPoint: getPerCommitmentPoint(this._state.localPerCommitmentSeed, 0n)
             }
         };
-        const session = new dual_funding_2.DualFundingSession(false, this._state.temporaryChannelId);
+        const session = new dual_funding_2.DualFundingSession(false, this._state.temporaryChannelId, this._maxFundingSatoshis);
         const result = session.handleOpenChannel2(msg, localParams);
         if (!result.ok || !result.message) {
             return [
@@ -4864,6 +4983,7 @@ class Channel {
     }
 }
 exports.Channel = Channel;
+Channel.REVOKED_TX_CACHE_MAX = 8;
 Channel.MAX_DUST_HTLC_EXPOSURE_MSAT = 5000000n;
 function createOpenerChannel(params) {
     const { DEFAULT_CHANNEL_CONFIG } = require('./types');