Use package relay for anchor force-close (#2963)

We use bitcoin core's `submitpackage` RPC to publish commit txs with
their anchor transaction. We do this for both local and remote commit
txs, and prefer the remote commit when it is available.

Thanks to package relay, this allows the commit and anchor package to
propagate even if the commit feerate is below the mempool minimum
feerate, as long as enough nodes run bitcoin core v28 or higher.

Author: t-bast

docs/release-notes/eclair-vnext.md

@@ -6,6 +6,13 @@
 
 <insert changes>
 
+### Package relay
+
+With Bitcoin Core 28.1, eclair starts relying on the `submitpackage` RPC during channel force-close.
+When using anchor outputs, allows propagating our local commitment transaction to peers who are also running Bitcoin Core 28.x or newer, even if the commitment feerate is low (package relay).
+
+This removes the need for increasing the commitment feerate based on mempool conditions, which ensures that channels won't be force-closed anymore when nodes disagree on the current feerate.
+
 ### API changes
 
 - `listoffers` now returns more details about each offer.

eclair-core/src/main/scala/fr/acinq/eclair/blockchain/bitcoind/rpc/BitcoinCoreClient.scala

@@ -498,6 +498,25 @@ class BitcoinCoreClient(val rpcClient: BitcoinJsonRPCClient, val lockUtxos: Bool
         getRawTransaction(tx.txid).map(_ => tx.txid).recoverWith { case _ => Future.failed(e) }
     }
 
+  /**
+   * Publish a 1-parent-1-child transaction package, which allows replacing a conflicting parent transaction that has
+   * the same (or a higher) feerate by leveraging CPFP. The child transaction cannot have other unconfirmed parents.
+   */
+  def publishPackage(parentTx: Transaction, childTx: Transaction)(implicit ec: ExecutionContext): Future[TxId] = {
+    rpcClient.invoke("submitpackage", Seq(parentTx, childTx).map(_.toString())).flatMap(json => {
+      val JString(msg) = json \ "package_msg"
+      if (msg == "success") {
+        // All transactions were accepted into or are already in the mempool.
+        Future.successful(childTx.txid)
+      } else {
+        val childError = (json \ "tx-results" \ childTx.wtxid.toHex \ "error").extractOpt[String]
+        val parentError = (json \ "tx-results" \ parentTx.wtxid.toHex \ "error").extractOpt[String]
+        val error = childError.orElse(parentError).getOrElse("unknown failure")
+        Future.failed(new IllegalArgumentException(error))
+      }
+    })
+  }
+
   override def abandon(txId: TxId)(implicit ec: ExecutionContext): Future[Boolean] = {
     rpcClient.invoke("abandontransaction", txId).map(_ => true).recover(_ => false)
   }

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

@@ -933,7 +933,7 @@ object Helpers {
 
         // We collect all the preimages we wanted to reveal to our peer.
         val hash2Preimage: Map[ByteVector32, ByteVector32] = commitment.changes.localChanges.all.collect { case u: UpdateFulfillHtlc => u.paymentPreimage }.map(r => Crypto.sha256(r) -> r).toMap
-        // We collect incoming HTLCs that we starting failing but didn't cross-sign.
+        // We collect incoming HTLCs that we started failing but didn't cross-sign.
         val failedIncomingHtlcs: Set[Long] = commitment.changes.localChanges.all.collect {
           case u: UpdateFailHtlc => u.id
           case u: UpdateFailMalformedHtlc => u.id
@@ -1107,7 +1107,7 @@ object Helpers {
 
         // We collect all the preimages we wanted to reveal to our peer.
         val hash2Preimage: Map[ByteVector32, ByteVector32] = commitment.changes.localChanges.all.collect { case u: UpdateFulfillHtlc => u.paymentPreimage }.map(r => Crypto.sha256(r) -> r).toMap
-        // We collect incoming HTLCs that we starting failing but didn't cross-sign.
+        // We collect incoming HTLCs that we started failing but didn't cross-sign.
         val failedIncomingHtlcs: Set[Long] = commitment.changes.localChanges.all.collect {
           case u: UpdateFailHtlc => u.id
           case u: UpdateFailMalformedHtlc => u.id

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

@@ -2002,7 +2002,7 @@ class Channel(val nodeParams: NodeParams, val wallet: OnChainChannelFunder with
           } else {
             // Our counterparty is trying to broadcast a revoked commit tx (cheating attempt).
             // We need to fail pending outgoing HTLCs, otherwise they will timeout upstream.
-            // We must do it here because since we're overwriting the commitments data, we will lose all information
+            // We must do it here because we're overwriting the commitments data, so we will lose all information
             // about HTLCs that are in the current commitments but were not in the revoked one.
             // We fail *all* outgoing HTLCs:
             //  - those that are not in the revoked commitment will never settle on-chain

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

@@ -113,7 +113,7 @@ private class FinalTxPublisher(nodeParams: NodeParams,
 
   def publish(): Behavior[Command] = {
     val txMonitor = context.spawn(MempoolTxMonitor(nodeParams, bitcoinClient, txPublishContext), "mempool-tx-monitor")
-    txMonitor ! MempoolTxMonitor.Publish(context.messageAdapter[MempoolTxMonitor.TxResult](WrappedTxResult), cmd.tx, cmd.input, nodeParams.channelConf.minDepth, cmd.desc, cmd.fee)
+    txMonitor ! MempoolTxMonitor.Publish(context.messageAdapter[MempoolTxMonitor.TxResult](WrappedTxResult), cmd.tx, None, cmd.input, nodeParams.channelConf.minDepth, cmd.desc, cmd.fee)
     Behaviors.receiveMessagePartial {
       case WrappedTxResult(txResult) =>
         txResult match {

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

@@ -38,7 +38,7 @@ object MempoolTxMonitor {
 
   // @formatter:off
   sealed trait Command
-  case class Publish(replyTo: ActorRef[TxResult], tx: Transaction, input: OutPoint, minDepth: Int, desc: String, fee: Satoshi) extends Command
+  case class Publish(replyTo: ActorRef[TxResult], tx: Transaction, parentTx_opt: Option[Transaction], input: OutPoint, minDepth: Int, desc: String, fee: Satoshi) extends Command
   private case object PublishOk extends Command
   private case class PublishFailed(reason: Throwable) extends Command
   private case class InputStatus(spentConfirmed: Boolean, spentUnconfirmed: Boolean) extends Command
@@ -95,7 +95,10 @@ private class MempoolTxMonitor(nodeParams: NodeParams,
   private val log = context.log
 
   def publish(): Behavior[Command] = {
-    context.pipeToSelf(bitcoinClient.publishTransaction(cmd.tx)) {
+    context.pipeToSelf(cmd.parentTx_opt match {
+      case Some(parentTx) => bitcoinClient.publishPackage(parentTx, cmd.tx)
+      case None => bitcoinClient.publishTransaction(cmd.tx)
+    }) {
       case Success(_) => PublishOk
       case Failure(reason) => PublishFailed(reason)
     }

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

@@ -20,7 +20,7 @@ import akka.actor.typed.eventstream.EventStream
 import akka.actor.typed.scaladsl.{ActorContext, Behaviors}
 import akka.actor.typed.{ActorRef, Behavior}
 import fr.acinq.bitcoin.psbt.Psbt
-import fr.acinq.bitcoin.scalacompat.{ByteVector32, Satoshi, Script, Transaction, TxOut}
+import fr.acinq.bitcoin.scalacompat.{ByteVector32, Satoshi, Transaction, TxOut}
 import fr.acinq.eclair.NotificationsLogger.NotifyNodeOperator
 import fr.acinq.eclair.blockchain.bitcoind.rpc.BitcoinCoreClient
 import fr.acinq.eclair.blockchain.fee.{FeeratePerKw, FeeratesPerKw, OnChainFeeConf}
@@ -74,7 +74,7 @@ object ReplaceableTxFunder {
       Behaviors.withMdc(txPublishContext.mdc()) {
         Behaviors.receiveMessagePartial {
           case FundTransaction(replyTo, cmd, tx, requestedFeerate) =>
-            val targetFeerate = requestedFeerate.min(maxFeerate(cmd.txInfo, cmd.commitment, nodeParams.currentBitcoinCoreFeerates, nodeParams.onChainFeeConf))
+            val targetFeerate = requestedFeerate.min(maxFeerate(cmd.txInfo, cmd.commitment, cmd.commitTx, nodeParams.currentBitcoinCoreFeerates, nodeParams.onChainFeeConf))
             val txFunder = new ReplaceableTxFunder(nodeParams, replyTo, cmd, bitcoinClient, context)
             tx match {
               case Right(txWithWitnessData) => txFunder.fund(txWithWitnessData, targetFeerate)
@@ -85,17 +85,11 @@ object ReplaceableTxFunder {
     }
   }
 
-  private def commitWeight(commitment: FullCommitment): Int = {
-    val unsignedCommitTx = commitment.localCommit.commitTxAndRemoteSig.commitTx
-    val dummySignedCommitTx = addSigs(unsignedCommitTx, PlaceHolderPubKey, PlaceHolderPubKey, PlaceHolderSig, PlaceHolderSig)
-    dummySignedCommitTx.tx.weight()
-  }
-
   /**
    * The on-chain feerate can be arbitrarily high, but it wouldn't make sense to pay more fees than the amount we're
    * trying to claim on-chain. We compute how much funds we have at risk and the feerate that matches this amount.
    */
-  def maxFeerate(txInfo: ReplaceableTransactionWithInputInfo, commitment: FullCommitment, currentFeerates: FeeratesPerKw, feeConf: OnChainFeeConf): FeeratePerKw = {
+  def maxFeerate(txInfo: ReplaceableTransactionWithInputInfo, commitment: FullCommitment, commitTx: Transaction, currentFeerates: FeeratesPerKw, feeConf: OnChainFeeConf): FeeratePerKw = {
     // We don't want to pay more in fees than the amount at risk in untrimmed pending HTLCs.
     val maxFee = txInfo match {
       case tx: HtlcTx => tx.input.txOut.amount
@@ -116,7 +110,7 @@ object ReplaceableTxFunder {
       case _: ClaimHtlcSuccessTx => Transactions.claimHtlcSuccessWeight
       case _: LegacyClaimHtlcSuccessTx => Transactions.claimHtlcSuccessWeight
       case _: ClaimHtlcTimeoutTx => Transactions.claimHtlcTimeoutWeight
-      case _: ClaimLocalAnchorOutputTx => commitWeight(commitment) + Transactions.claimAnchorOutputMinWeight
+      case _: ClaimLocalAnchorOutputTx => commitTx.weight() + Transactions.claimAnchorOutputMinWeight
     }
     // It doesn't make sense to use a feerate that is much higher than the current feerate for inclusion into the next block.
     Transactions.fee2rate(maxFee, weight).min(currentFeerates.fastest * 1.25)
@@ -161,12 +155,12 @@ object ReplaceableTxFunder {
    * Adjust the outputs of a transaction that was previously published at a lower feerate.
    * If the current set of inputs doesn't let us to reach the target feerate, we should request new wallet inputs from bitcoind.
    */
-  def adjustPreviousTxOutput(previousTx: FundedTx, targetFeerate: FeeratePerKw, commitment: FullCommitment): AdjustPreviousTxOutputResult = {
+  def adjustPreviousTxOutput(previousTx: FundedTx, targetFeerate: FeeratePerKw, commitment: FullCommitment, commitTx: Transaction): AdjustPreviousTxOutputResult = {
     val dustLimit = commitment.localParams.dustLimit
     val targetFee = previousTx.signedTxWithWitnessData match {
       case _: ClaimLocalAnchorWithWitnessData =>
         val commitFee = commitment.localCommit.commitTxAndRemoteSig.commitTx.fee
-        val totalWeight = previousTx.signedTx.weight() + commitWeight(commitment)
+        val totalWeight = previousTx.signedTx.weight() + commitTx.weight()
         weight2fee(targetFeerate, totalWeight) - commitFee
       case _ =>
         weight2fee(targetFeerate, previousTx.signedTx.weight())
@@ -273,7 +267,7 @@ private class ReplaceableTxFunder(nodeParams: NodeParams,
 
   private def bump(previousTx: FundedTx, targetFeerate: FeeratePerKw): Behavior[Command] = {
     log.info("bumping {} tx (targetFeerate={})", previousTx.signedTxWithWitnessData.txInfo.desc, targetFeerate)
-    adjustPreviousTxOutput(previousTx, targetFeerate, cmd.commitment) match {
+    adjustPreviousTxOutput(previousTx, targetFeerate, cmd.commitment, cmd.commitTx) match {
       case AdjustPreviousTxOutputResult.Skip(reason) =>
         log.warn("skipping {} fee bumping: {} (feerate={})", cmd.desc, reason, targetFeerate)
         replyTo ! FundingFailed(TxPublisher.TxRejectedReason.TxSkipped(retryNextBlock = true))
@@ -392,7 +386,7 @@ private class ReplaceableTxFunder(nodeParams: NodeParams,
               case Right(signedTx) =>
                 val actualFees = kmp2scala(processPsbtResponse.psbt.computeFees())
                 val actualWeight = locallySignedTx match {
-                  case _: ClaimLocalAnchorWithWitnessData => signedTx.weight() + commitWeight(cmd.commitment)
+                  case _: ClaimLocalAnchorWithWitnessData => signedTx.weight() + cmd.commitTx.weight()
                   case _ => signedTx.weight()
                 }
                 val actualFeerate = Transactions.fee2rate(actualFees, actualWeight)
@@ -439,30 +433,34 @@ private class ReplaceableTxFunder(nodeParams: NodeParams,
   }
 
   private def addInputs(anchorTx: ClaimLocalAnchorWithWitnessData, targetFeerate: FeeratePerKw, commitment: FullCommitment): Future[(ClaimLocalAnchorWithWitnessData, Satoshi)] = {
-    val dustLimit = commitment.localParams.dustLimit
-    // NB: fundrawtransaction requires at least one output, and may add at most one additional change output.
-    // Since the purpose of this transaction is just to do a CPFP, the resulting tx should have a single change output
-    // (note that bitcoind doesn't let us publish a transaction with no outputs). To work around these limitations, we
-    // start with a dummy output and later merge that dummy output with the optional change output added by bitcoind.
-    val txNotFunded = anchorTx.txInfo.tx.copy(txOut = TxOut(dustLimit, Script.pay2wpkh(PlaceHolderPubKey)) :: Nil)
-    val anchorWeight = Map(anchorTx.txInfo.input.outPoint -> anchorInputWeight.toLong)
-    // We only use confirmed inputs for anchor transactions to be able to leverage 1-parent-1-child package relay.
-    bitcoinClient.fundTransaction(txNotFunded, targetFeerate, externalInputsWeight = anchorWeight, minInputConfirmations_opt = Some(1)).flatMap { fundTxResponse =>
-      // Bitcoin Core may not preserve the order of inputs, we need to make sure the anchor is the first input.
-      val txIn = anchorTx.txInfo.tx.txIn ++ fundTxResponse.tx.txIn.filterNot(_.outPoint == anchorTx.txInfo.input.outPoint)
-      // We merge our dummy change output with the one added by Bitcoin Core, if any.
-      fundTxResponse.changePosition match {
-        case Some(changePos) =>
-          val changeOutput = fundTxResponse.tx.txOut(changePos).copy(amount = fundTxResponse.tx.txOut.map(_.amount).sum)
-          val txSingleOutput = fundTxResponse.tx.copy(txIn = txIn, txOut = Seq(changeOutput))
-          Future.successful(anchorTx.updateTx(txSingleOutput), fundTxResponse.amountIn)
-        case None =>
-          bitcoinClient.getChangePublicKeyScript().map(changeScript => {
-            // We must have a change output, otherwise the transaction is invalid: we replace the PlaceHolderPubKey with a real wallet key.
-            val txSingleOutput = fundTxResponse.tx.copy(txIn = txIn, txOut = Seq(TxOut(dustLimit, changeScript)))
-            (anchorTx.updateTx(txSingleOutput), fundTxResponse.amountIn)
-          })
+    // We want to pay the commit fees using CPFP. Since the commit tx may not be in the mempool yet (its feerate may be
+    // below the minimum acceptable mempool feerate), we cannot ask bitcoind to fund a transaction that spends that
+    // commit tx: it would fail because it cannot find the input in the utxo set. So we instead ask bitcoind to fund an
+    // empty transaction that pays the fees we must add to the transaction package, and we then add the input spending
+    // the commit tx and adjust the change output.
+    val expectedCommitFee = Transactions.weight2fee(targetFeerate, cmd.commitTx.weight())
+    val actualCommitFee = commitment.commitInput.txOut.amount - cmd.commitTx.txOut.map(_.amount).sum
+    val anchorInputFee = Transactions.weight2fee(targetFeerate, anchorInputWeight)
+    val missingFee = expectedCommitFee - actualCommitFee + anchorInputFee
+    for {
+      changeScript <- bitcoinClient.getChangePublicKeyScript()
+      txNotFunded = Transaction(2, Nil, TxOut(commitment.localParams.dustLimit + missingFee, changeScript) :: Nil, 0)
+      // We only use confirmed inputs for anchor transactions to be able to leverage 1-parent-1-child package relay.
+      fundTxResponse <- bitcoinClient.fundTransaction(txNotFunded, targetFeerate, minInputConfirmations_opt = Some(1))
+    } yield {
+      // We merge our dummy change output with the one added by Bitcoin Core, if any, and adjust the change amount to
+      // pay the expected package feerate.
+      val txIn = anchorTx.txInfo.tx.txIn ++ fundTxResponse.tx.txIn
+      val packageWeight = cmd.commitTx.weight() + anchorInputWeight + fundTxResponse.tx.weight()
+      val expectedFee = Transactions.weight2fee(targetFeerate, packageWeight)
+      val currentFee = actualCommitFee + fundTxResponse.fee
+      val changeAmount = (fundTxResponse.tx.txOut.map(_.amount).sum - expectedFee + currentFee).max(commitment.localParams.dustLimit)
+      val changeOutput = fundTxResponse.changePosition match {
+        case Some(changePos) => fundTxResponse.tx.txOut(changePos).copy(amount = changeAmount)
+        case None => TxOut(changeAmount, changeScript)
       }
+      val txSingleOutput = fundTxResponse.tx.copy(txIn = txIn, txOut = Seq(changeOutput))
+      (anchorTx.updateTx(txSingleOutput), fundTxResponse.amountIn)
     }
   }
 

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

@@ -130,7 +130,6 @@ private class ReplaceableTxPrePublisher(nodeParams: NodeParams,
     // We verify that:
     //  - our commit is not confirmed (if it is, no need to claim our anchor)
     //  - their commit is not confirmed (if it is, no need to claim our anchor either)
-    //  - the local or remote commit tx is in the mempool (otherwise we can't claim our anchor)
     val fundingOutpoint = cmd.commitment.commitInput.outPoint
     context.pipeToSelf(bitcoinClient.getTxConfirmations(fundingOutpoint.txid).flatMap {
       case Some(_) =>
@@ -143,13 +142,12 @@ private class ReplaceableTxPrePublisher(nodeParams: NodeParams,
             // have any CSV delays and don't need 2nd-stage HTLC transactions).
             getRemoteCommitConfirmations(cmd.commitment).flatMap {
               case Some(_) => Future.failed(RemoteCommitTxPublished)
-              // Otherwise, we must ensure our local commit tx is in the mempool before publishing the anchor transaction.
-              // If it's already published, this call will be a no-op.
-              case None => bitcoinClient.publishTransaction(cmd.commitTx)
+              // We're trying to bump the local commit tx: no need to do anything, we will publish it alongside the anchor transaction.
+              case None => Future.successful(cmd.commitTx.txid)
             }
           case true =>
-            // We're trying to bump a remote commitment: we must make sure it is in our mempool first.
-            bitcoinClient.publishTransaction(cmd.commitTx)
+            // We're trying to bump a remote commitment: no need to do anything, we will publish it alongside the anchor transaction.
+            Future.successful(cmd.commitTx.txid)
         }
       case None =>
         // If the funding transaction cannot be found (e.g. when using 0-conf), we should retry later.