Replaceable txs fee bumping

eclair-core/src/main/scala/fr/acinq/eclair/channel/Channel.scala

@@ -2467,8 +2467,21 @@ class Channel(val nodeParams: NodeParams, val wallet: OnChainChannelFunder, remo
         val redeemableHtlcTxs = htlcTxs.values.flatten.map(tx => PublishFinalTx(tx, tx.fee, Some(commitTx.txid)))
         List(PublishFinalTx(commitTx, commitInput, "commit-tx", Closing.commitTxFee(commitments.commitInput, commitTx, isFunder), None)) ++ (claimMainDelayedOutputTx.map(tx => PublishFinalTx(tx, tx.fee, None)) ++ redeemableHtlcTxs ++ claimHtlcDelayedTxs.map(tx => PublishFinalTx(tx, tx.fee, None)))
       case _: Transactions.AnchorOutputsCommitmentFormat =>
-        val claimLocalAnchor = claimAnchorTxs.collect { case tx: Transactions.ClaimLocalAnchorOutputTx => PublishReplaceableTx(tx, commitments) }
-        val redeemableHtlcTxs = htlcTxs.values.collect { case Some(tx) => PublishReplaceableTx(tx, commitments) }
+        val redeemableHtlcTxs = htlcTxs.values.collect {
+          case Some(tx) =>
+            val htlc_opt = tx match {
+              case _: Transactions.HtlcSuccessTx => commitments.localCommit.spec.findIncomingHtlcById(tx.htlcId).map(_.add)
+              case _: Transactions.HtlcTimeoutTx => commitments.localCommit.spec.findOutgoingHtlcById(tx.htlcId).map(_.add)
+            }
+            val deadline = htlc_opt.map(_.cltvExpiry.toLong).getOrElse(nodeParams.currentBlockHeight + nodeParams.onChainFeeConf.feeTargets.commitmentBlockTarget)
+            PublishReplaceableTx(tx, commitments, deadline)
+        }
+        val claimLocalAnchor = claimAnchorTxs.collect {
+          case tx: Transactions.ClaimLocalAnchorOutputTx =>
+            // NB: if we don't have pending HTLCs, we don't have funds at risk, so we can use a longer deadline.
+            val deadline = redeemableHtlcTxs.map(_.deadline).minOption.getOrElse(nodeParams.currentBlockHeight + nodeParams.onChainFeeConf.feeTargets.claimMainBlockTarget)
+            PublishReplaceableTx(tx, commitments, deadline)
+        }
         List(PublishFinalTx(commitTx, commitInput, "commit-tx", Closing.commitTxFee(commitments.commitInput, commitTx, isFunder), None)) ++ claimLocalAnchor ++ claimMainDelayedOutputTx.map(tx => PublishFinalTx(tx, tx.fee, None)) ++ redeemableHtlcTxs ++ claimHtlcDelayedTxs.map(tx => PublishFinalTx(tx, tx.fee, None))
     }
     publishIfNeeded(publishQueue, irrevocablySpent)
@@ -2538,7 +2551,17 @@ class Channel(val nodeParams: NodeParams, val wallet: OnChainChannelFunder, remo
   private def doPublish(remoteCommitPublished: RemoteCommitPublished, commitments: Commitments): Unit = {
     import remoteCommitPublished._
 
-    val publishQueue = claimMainOutputTx.map(tx => PublishFinalTx(tx, tx.fee, None)).toSeq ++ claimHtlcTxs.values.flatten.map(tx => PublishReplaceableTx(tx, commitments))
+    val redeemableHtlcTxs = claimHtlcTxs.values.collect {
+      case Some(tx) =>
+        val htlc_opt = tx match {
+          case _: Transactions.LegacyClaimHtlcSuccessTx => commitments.remoteNextCommitInfo.left.toOption.flatMap(_.nextRemoteCommit.spec.findOutgoingHtlcById(tx.htlcId)).orElse(commitments.remoteCommit.spec.findOutgoingHtlcById(tx.htlcId)).map(_.add)
+          case _: Transactions.ClaimHtlcSuccessTx => commitments.remoteNextCommitInfo.left.toOption.flatMap(_.nextRemoteCommit.spec.findOutgoingHtlcById(tx.htlcId)).orElse(commitments.remoteCommit.spec.findOutgoingHtlcById(tx.htlcId)).map(_.add)
+          case _: Transactions.ClaimHtlcTimeoutTx => commitments.remoteNextCommitInfo.left.toOption.flatMap(_.nextRemoteCommit.spec.findIncomingHtlcById(tx.htlcId)).orElse(commitments.remoteCommit.spec.findIncomingHtlcById(tx.htlcId)).map(_.add)
+        }
+        val deadline = htlc_opt.map(_.cltvExpiry.toLong).getOrElse(nodeParams.currentBlockHeight + nodeParams.onChainFeeConf.feeTargets.commitmentBlockTarget)
+        PublishReplaceableTx(tx, commitments, deadline)
+    }
+    val publishQueue = claimMainOutputTx.map(tx => PublishFinalTx(tx, tx.fee, None)).toSeq ++ redeemableHtlcTxs
     publishIfNeeded(publishQueue, irrevocablySpent)
 
     // we watch:

eclair-core/src/main/scala/fr/acinq/eclair/channel/ChannelData.scala

@@ -455,39 +455,39 @@ final case class DATA_WAIT_FOR_REMOTE_PUBLISH_FUTURE_COMMITMENT(commitments: Com
 
 /**
  * @param initFeatures current connection features, or last features used if the channel is disconnected. Note that these
- *                 features are updated at each reconnection and may be different from the channel permanent features
- *                 (see [[ChannelFeatures]]).
+ *                     features are updated at each reconnection and may be different from the channel permanent features
+ *                     (see [[ChannelFeatures]]).
  */
-final case class LocalParams(nodeId: PublicKey,
-                             fundingKeyPath: DeterministicWallet.KeyPath,
-                             dustLimit: Satoshi,
-                             maxHtlcValueInFlightMsat: UInt64, // this is not MilliSatoshi because it can exceed the total amount of MilliSatoshi
-                             channelReserve: Satoshi,
-                             htlcMinimum: MilliSatoshi,
-                             toSelfDelay: CltvExpiryDelta,
-                             maxAcceptedHtlcs: Int,
-                             isFunder: Boolean,
-                             defaultFinalScriptPubKey: ByteVector,
-                             walletStaticPaymentBasepoint: Option[PublicKey],
-                             initFeatures: Features)
+case class LocalParams(nodeId: PublicKey,
+                       fundingKeyPath: DeterministicWallet.KeyPath,
+                       dustLimit: Satoshi,
+                       maxHtlcValueInFlightMsat: UInt64, // this is not MilliSatoshi because it can exceed the total amount of MilliSatoshi
+                       channelReserve: Satoshi,
+                       htlcMinimum: MilliSatoshi,
+                       toSelfDelay: CltvExpiryDelta,
+                       maxAcceptedHtlcs: Int,
+                       isFunder: Boolean,
+                       defaultFinalScriptPubKey: ByteVector,
+                       walletStaticPaymentBasepoint: Option[PublicKey],
+                       initFeatures: Features)
 
 /**
  * @param initFeatures see [[LocalParams.initFeatures]]
  */
-final case class RemoteParams(nodeId: PublicKey,
-                              dustLimit: Satoshi,
-                              maxHtlcValueInFlightMsat: UInt64, // this is not MilliSatoshi because it can exceed the total amount of MilliSatoshi
-                              channelReserve: Satoshi,
-                              htlcMinimum: MilliSatoshi,
-                              toSelfDelay: CltvExpiryDelta,
-                              maxAcceptedHtlcs: Int,
-                              fundingPubKey: PublicKey,
-                              revocationBasepoint: PublicKey,
-                              paymentBasepoint: PublicKey,
-                              delayedPaymentBasepoint: PublicKey,
-                              htlcBasepoint: PublicKey,
-                              initFeatures: Features,
-                              shutdownScript: Option[ByteVector])
+case class RemoteParams(nodeId: PublicKey,
+                        dustLimit: Satoshi,
+                        maxHtlcValueInFlightMsat: UInt64, // this is not MilliSatoshi because it can exceed the total amount of MilliSatoshi
+                        channelReserve: Satoshi,
+                        htlcMinimum: MilliSatoshi,
+                        toSelfDelay: CltvExpiryDelta,
+                        maxAcceptedHtlcs: Int,
+                        fundingPubKey: PublicKey,
+                        revocationBasepoint: PublicKey,
+                        paymentBasepoint: PublicKey,
+                        delayedPaymentBasepoint: PublicKey,
+                        htlcBasepoint: PublicKey,
+                        initFeatures: Features,
+                        shutdownScript: Option[ByteVector])
 
 object ChannelFlags {
   val AnnounceChannel = 0x01.toByte

eclair-core/src/main/scala/fr/acinq/eclair/channel/Helpers.scala

@@ -1078,7 +1078,11 @@ object Helpers {
         log.error(s"some htlcs don't have a corresponding timeout transaction: tx=$tx, htlcs=$matchingHtlcs, timeout-txs=$matchingTxs")
       }
       matchingHtlcs.zip(matchingTxs).collectFirst {
+        // HTLC transactions cannot change when anchor outputs is unused, so we directly check the txid
         case (add, timeoutTx) if timeoutTx.txid == tx.txid => add
+        // Claim-HTLC transactions can be updated to pay more or less fees by changing the output amount, so we cannot
+        // rely on txid equality: we instead check that the input is the same and the output goes to the same address.
+        case (add, timeoutTx) if timeoutTx.txIn.head.outPoint == tx.txIn.head.outPoint && timeoutTx.txOut.head.publicKeyScript == tx.txOut.head.publicKeyScript => add
       }
     }
 

eclair-core/src/main/scala/fr/acinq/eclair/channel/publish/FinalTxPublisher.scala

@@ -121,8 +121,8 @@ private class FinalTxPublisher(nodeParams: NodeParams,
     val txMonitor = context.spawn(MempoolTxMonitor(nodeParams, bitcoinClient, loggingInfo), "mempool-tx-monitor")
     txMonitor ! MempoolTxMonitor.Publish(context.messageAdapter[MempoolTxMonitor.TxResult](WrappedTxResult), cmd.tx, cmd.input, cmd.desc, cmd.fee)
     Behaviors.receiveMessagePartial {
-      case WrappedTxResult(MempoolTxMonitor.TxConfirmed) => sendResult(replyTo, TxPublisher.TxConfirmed(cmd, cmd.tx))
-      case WrappedTxResult(MempoolTxMonitor.TxRejected(reason)) => sendResult(replyTo, TxPublisher.TxRejected(loggingInfo.id, cmd, reason))
+      case WrappedTxResult(MempoolTxMonitor.TxConfirmed(tx)) => sendResult(replyTo, TxPublisher.TxConfirmed(cmd, tx))
+      case WrappedTxResult(MempoolTxMonitor.TxRejected(_, reason)) => sendResult(replyTo, TxPublisher.TxRejected(loggingInfo.id, cmd, reason))
       case Stop =>
         txMonitor ! MempoolTxMonitor.Stop
         Behaviors.stopped

eclair-core/src/main/scala/fr/acinq/eclair/channel/publish/MempoolTxMonitor.scala

@@ -51,8 +51,8 @@ object MempoolTxMonitor {
 
   // @formatter:off
   sealed trait TxResult
-  case object TxConfirmed extends TxResult
-  case class TxRejected(reason: TxPublisher.TxRejectedReason) extends TxResult
+  case class TxConfirmed(tx: Transaction) extends TxResult
+  case class TxRejected(txid: ByteVector32, reason: TxPublisher.TxRejectedReason) extends TxResult
   // @formatter:on
 
   def apply(nodeParams: NodeParams, bitcoinClient: BitcoinCoreClient, loggingInfo: TxPublishLogContext): Behavior[Command] = {
@@ -90,29 +90,29 @@ private class MempoolTxMonitor(nodeParams: NodeParams, bitcoinClient: BitcoinCor
         waitForConfirmation(replyTo, tx, input)
       case PublishFailed(reason) if reason.getMessage.contains("rejecting replacement") =>
         log.info("could not publish tx: a conflicting mempool transaction is already in the mempool")
-        sendResult(replyTo, TxRejected(TxRejectedReason.ConflictingTxUnconfirmed))
+        sendResult(replyTo, TxRejected(tx.txid, TxRejectedReason.ConflictingTxUnconfirmed))
       case PublishFailed(reason) if reason.getMessage.contains("bad-txns-inputs-missingorspent") =>
         // This can only happen if one of our inputs is already spent by a confirmed transaction or doesn't exist (e.g.
         // unconfirmed wallet input that has been replaced).
         checkInputStatus(input)
         Behaviors.same
       case PublishFailed(reason) =>
         log.error("could not publish transaction", reason)
-        sendResult(replyTo, TxRejected(TxRejectedReason.UnknownTxFailure))
+        sendResult(replyTo, TxRejected(tx.txid, TxRejectedReason.UnknownTxFailure))
       case status: InputStatus =>
         if (status.spentConfirmed) {
           log.info("could not publish tx: a conflicting transaction is already confirmed")
-          sendResult(replyTo, TxRejected(TxRejectedReason.ConflictingTxConfirmed))
+          sendResult(replyTo, TxRejected(tx.txid, TxRejectedReason.ConflictingTxConfirmed))
         } else if (status.spentUnconfirmed) {
           log.info("could not publish tx: a conflicting mempool transaction is already in the mempool")
-          sendResult(replyTo, TxRejected(TxRejectedReason.ConflictingTxUnconfirmed))
+          sendResult(replyTo, TxRejected(tx.txid, TxRejectedReason.ConflictingTxUnconfirmed))
         } else {
           log.info("could not publish tx: one of our wallet inputs is not available")
-          sendResult(replyTo, TxRejected(TxRejectedReason.WalletInputGone))
+          sendResult(replyTo, TxRejected(tx.txid, TxRejectedReason.WalletInputGone))
         }
       case CheckInputFailed(reason) =>
         log.error("could not check input status", reason)
-        sendResult(replyTo, TxRejected(TxRejectedReason.TxSkipped(retryNextBlock = true))) // we act as if the input is potentially still spendable
+        sendResult(replyTo, TxRejected(tx.txid, TxRejectedReason.TxSkipped(retryNextBlock = true))) // we act as if the input is potentially still spendable
       case Stop =>
         Behaviors.stopped
     }
@@ -136,7 +136,7 @@ private class MempoolTxMonitor(nodeParams: NodeParams, bitcoinClient: BitcoinCor
         if (nodeParams.minDepthBlocks <= confirmations) {
           log.info("txid={} has reached min depth", tx.txid)
           context.system.eventStream ! EventStream.Publish(TransactionConfirmed(loggingInfo.channelId_opt.getOrElse(ByteVector32.Zeroes), loggingInfo.remoteNodeId, tx))
-          sendResult(replyTo, TxConfirmed, Some(messageAdapter))
+          sendResult(replyTo, TxConfirmed(tx), Some(messageAdapter))
         } else {
           Behaviors.same
         }
@@ -151,17 +151,17 @@ private class MempoolTxMonitor(nodeParams: NodeParams, bitcoinClient: BitcoinCor
       case status: InputStatus =>
         if (status.spentConfirmed) {
           log.info("tx was evicted from the mempool: a conflicting transaction has been confirmed")
-          sendResult(replyTo, TxRejected(TxRejectedReason.ConflictingTxConfirmed))
+          sendResult(replyTo, TxRejected(tx.txid, TxRejectedReason.ConflictingTxConfirmed))
         } else if (status.spentUnconfirmed) {
           log.info("tx was evicted from the mempool: a conflicting transaction replaced it")
-          sendResult(replyTo, TxRejected(TxRejectedReason.ConflictingTxUnconfirmed))
+          sendResult(replyTo, TxRejected(tx.txid, TxRejectedReason.ConflictingTxUnconfirmed))
         } else {
           log.info("tx was evicted from the mempool: one of our wallet inputs disappeared")
-          sendResult(replyTo, TxRejected(TxRejectedReason.WalletInputGone))
+          sendResult(replyTo, TxRejected(tx.txid, TxRejectedReason.WalletInputGone))
         }
       case CheckInputFailed(reason) =>
         log.error("could not check input status", reason)
-        sendResult(replyTo, TxRejected(TxRejectedReason.TxSkipped(retryNextBlock = true)), Some(messageAdapter))
+        sendResult(replyTo, TxRejected(tx.txid, TxRejectedReason.TxSkipped(retryNextBlock = true)), Some(messageAdapter))
       case Stop =>
         context.system.eventStream ! EventStream.Unsubscribe(messageAdapter)
         Behaviors.stopped