Rename ClaimRemoteDelayedOutputTx

It isn't delayed anymore for v3 transactions. We could use static wallet
public key, but in most cases it wouldn't work and adds extra complexity
so we don't do it. We add a comment in the documentation of this class
to explain why we're always making a 2nd-stage transaction.

Author: t-bast

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

@@ -1170,7 +1170,7 @@ object Helpers {
     object RemoteClose {
 
       /** Transactions spending outputs of a remote commitment transaction. */
-      case class SecondStageTransactions(mainTx_opt: Option[ClaimRemoteDelayedOutputTx], anchorTx_opt: Option[ClaimRemoteAnchorTx], htlcTxs: Seq[ClaimHtlcTx])
+      case class SecondStageTransactions(mainTx_opt: Option[ClaimRemoteMainOutputTx], anchorTx_opt: Option[ClaimRemoteAnchorTx], htlcTxs: Seq[ClaimHtlcTx])
 
       /** Claim all the outputs that belong to us in the remote commitment transaction (which can be either their current or next commitment). */
       def claimCommitTxOutputs(channelKeys: ChannelKeys, commitment: FullCommitment, remoteCommit: RemoteCommit, commitTx: Transaction, closingFeerate: FeeratePerKw, finalScriptPubKey: ByteVector, spendAnchorWithoutHtlcs: Boolean)(implicit log: LoggingAdapter): (RemoteCommitPublished, SecondStageTransactions) = {
@@ -1207,10 +1207,10 @@ object Helpers {
       }
 
       /** Claim our main output from the remote commitment transaction, if available. */
-      def claimMainOutput(commitKeys: RemoteCommitmentKeys, commitTx: Transaction, dustLimit: Satoshi, commitmentFormat: CommitmentFormat, feerate: FeeratePerKw, finalScriptPubKey: ByteVector)(implicit log: LoggingAdapter): Option[ClaimRemoteDelayedOutputTx] = {
+      def claimMainOutput(commitKeys: RemoteCommitmentKeys, commitTx: Transaction, dustLimit: Satoshi, commitmentFormat: CommitmentFormat, feerate: FeeratePerKw, finalScriptPubKey: ByteVector)(implicit log: LoggingAdapter): Option[ClaimRemoteMainOutputTx] = {
         commitmentFormat match {
-          case _: AnchorOutputsCommitmentFormat | _: SimpleTaprootChannelCommitmentFormat | ZeroFeeCommitmentFormat => withTxGenerationLog("remote-main-delayed") {
-            ClaimRemoteDelayedOutputTx.createUnsignedTx(commitKeys, commitTx, dustLimit, finalScriptPubKey, feerate, commitmentFormat)
+          case _: AnchorOutputsCommitmentFormat | _: SimpleTaprootChannelCommitmentFormat | ZeroFeeCommitmentFormat => withTxGenerationLog("remote-main") {
+            ClaimRemoteMainOutputTx.createUnsignedTx(commitKeys, commitTx, dustLimit, finalScriptPubKey, feerate, commitmentFormat)
           }
         }
       }
@@ -1329,7 +1329,7 @@ object Helpers {
     object RevokedClose {
 
       /** Transactions spending outputs of a revoked remote commitment transactions. */
-      case class SecondStageTransactions(mainTx_opt: Option[ClaimRemoteDelayedOutputTx], mainPenaltyTx_opt: Option[MainPenaltyTx], htlcPenaltyTxs: Seq[HtlcPenaltyTx])
+      case class SecondStageTransactions(mainTx_opt: Option[ClaimRemoteMainOutputTx], mainPenaltyTx_opt: Option[MainPenaltyTx], htlcPenaltyTxs: Seq[HtlcPenaltyTx])
 
       /** Transactions spending outputs of confirmed remote HTLC transactions. */
       case class ThirdStageTransactions(htlcDelayedPenaltyTxs: Seq[ClaimHtlcDelayedOutputPenaltyTx])
@@ -1377,8 +1377,8 @@ object Helpers {
 
         // First we will claim our main output right away.
         val mainTx_opt = commitmentFormat match {
-          case _: AnchorOutputsCommitmentFormat | _: SimpleTaprootChannelCommitmentFormat | ZeroFeeCommitmentFormat => withTxGenerationLog("remote-main-delayed") {
-            ClaimRemoteDelayedOutputTx.createUnsignedTx(commitKeys, commitTx, dustLimit, finalScriptPubKey, feerateMain, commitmentFormat)
+          case _: AnchorOutputsCommitmentFormat | _: SimpleTaprootChannelCommitmentFormat | ZeroFeeCommitmentFormat => withTxGenerationLog("remote-main") {
+            ClaimRemoteMainOutputTx.createUnsignedTx(commitKeys, commitTx, dustLimit, finalScriptPubKey, feerateMain, commitmentFormat)
           }
         }
 

eclair-core/src/main/scala/fr/acinq/eclair/transactions/Transactions.scala

@@ -81,7 +81,7 @@ object Transactions {
     def claimHtlcTimeoutWeight: Int
     /** Weight of a fully signed [[ClaimLocalDelayedOutputTx]] transaction. */
     def toLocalDelayedWeight: Int
-    /** Weight of a fully signed [[ClaimRemoteDelayedOutputTx]] transaction. */
+    /** Weight of a fully signed [[ClaimRemoteMainOutputTx]] transaction. */
     def toRemoteWeight: Int
     /** Weight of a fully signed [[HtlcDelayedTx]] 3rd-stage transaction (spending the output of an [[HtlcTx]]). */
     def htlcDelayedWeight: Int
@@ -502,13 +502,13 @@ object Transactions {
    * Transactions spending a remote [[CommitTx]] or one of its descendants.
    *
    * When a current remote [[CommitTx]] is published:
-   *    - When using anchor outputs, [[ClaimRemoteDelayedOutputTx]] spends the to-local output of [[CommitTx]]
+   *    - When using anchor outputs, [[ClaimRemoteMainOutputTx]] spends the to-local output of [[CommitTx]]
    *    - When using anchor outputs, [[ClaimRemoteAnchorTx]] spends the to-local anchor of [[CommitTx]]
    *    - [[ClaimHtlcSuccessTx]] spends received htlc outputs of [[CommitTx]] for which we have the preimage
    *    - [[ClaimHtlcTimeoutTx]] spends sent htlc outputs of [[CommitTx]] after a timeout
    *
    * When a revoked remote [[CommitTx]] is published:
-   *    - When using anchor outputs, [[ClaimRemoteDelayedOutputTx]] spends the to-local output of [[CommitTx]]
+   *    - When using anchor outputs, [[ClaimRemoteMainOutputTx]] spends the to-local output of [[CommitTx]]
    *    - [[MainPenaltyTx]] spends the remote main output using the revocation secret
    *    - [[HtlcPenaltyTx]] spends all htlc outputs using the revocation secret (and competes with [[HtlcSuccessTx]] and [[HtlcTimeoutTx]] published by the remote node)
    *    - [[ClaimHtlcDelayedOutputPenaltyTx]] spends [[HtlcSuccessTx]] transactions published by the remote node using the revocation secret
@@ -984,9 +984,24 @@ object Transactions {
     }
   }
 
-  /** This transaction spends our main balance from the remote commitment with a 1-block relative delay, or immediately when using v3 commitments. */
-  case class ClaimRemoteDelayedOutputTx(commitKeys: RemoteCommitmentKeys, input: InputInfo, tx: Transaction, commitmentFormat: CommitmentFormat) extends RemoteCommitForceCloseTransaction {
-    override val desc: String = "remote-main-delayed"
+  /**
+   * This transaction spends our main balance from the remote commitment.
+   *
+   * When using [[AnchorOutputsCommitmentFormat]] or [[SimpleTaprootChannelCommitmentFormat]], there is a CSV-1 on the
+   * output to allow CPFP carve-out on the anchor outputs.
+   *
+   * Otherwise, it directly sends to a public key (p2wpkh or p2tr). In theory we could avoid making a 2nd-stage transaction
+   * (and directly use a public key from our bitcoin wallet), but it adds complexity and doesn't work in the case where
+   * we upgrade an anchor outputs channel to v3 during a splice (since the public key was generated when the channel was
+   * opened and cannot be changed afterwards). Another reason to use a 2nd-stage transaction is because that's how we
+   * pay the on-chain fees for the commitment transaction (which doesn't pay any fees) by also spending the P2A output
+   * (which avoids the need for external wallet inputs).
+   * The only case where it is wasteful to have this 2nd-stage transaction is if the remote peer paid the fees for the
+   * remote commitment and it confirmed: in that case, we haven't paid any on-chain fees yet for the force-close, and
+   * our peer has paid for the largest transaction, so it's fine even though it's not optimal.
+   */
+  case class ClaimRemoteMainOutputTx(commitKeys: RemoteCommitmentKeys, input: InputInfo, tx: Transaction, commitmentFormat: CommitmentFormat) extends RemoteCommitForceCloseTransaction {
+    override val desc: String = "remote-main"
     override val expectedWeight: Int = commitmentFormat.toRemoteWeight
 
     override def sign(): Transaction = {
@@ -1009,8 +1024,8 @@ object Transactions {
     }
   }
 
-  object ClaimRemoteDelayedOutputTx {
-    def createUnsignedTx(commitKeys: RemoteCommitmentKeys, commitTx: Transaction, localDustLimit: Satoshi, localFinalScriptPubKey: ByteVector, feerate: FeeratePerKw, commitmentFormat: CommitmentFormat): Either[TxGenerationSkipped, ClaimRemoteDelayedOutputTx] = {
+  object ClaimRemoteMainOutputTx {
+    def createUnsignedTx(commitKeys: RemoteCommitmentKeys, commitTx: Transaction, localDustLimit: Satoshi, localFinalScriptPubKey: ByteVector, feerate: FeeratePerKw, commitmentFormat: CommitmentFormat): Either[TxGenerationSkipped, ClaimRemoteMainOutputTx] = {
       val redeemInfo = commitmentFormat match {
         case _: AnchorOutputsCommitmentFormat =>
           val redeemScript = Script.write(toRemoteDelayed(commitKeys.publicKeys))
@@ -1034,7 +1049,7 @@ object Transactions {
             txOut = TxOut(amount, localFinalScriptPubKey) :: Nil,
             lockTime = 0
           )
-          val unsignedTx = ClaimRemoteDelayedOutputTx(commitKeys, input, tx, commitmentFormat)
+          val unsignedTx = ClaimRemoteMainOutputTx(commitKeys, input, tx, commitmentFormat)
           skipTxIfBelowDust(unsignedTx, localDustLimit)
       }
     }
@@ -1638,7 +1653,7 @@ object Transactions {
       val updatedTx = txInfo.tx.copy(txOut = txInfo.tx.txOut.headOption.map(_.copy(amount = txInfo.amountIn - fee)).toSeq)
       txInfo match {
         case txInfo: ClaimLocalDelayedOutputTx => Right(txInfo.copy(tx = updatedTx))
-        case txInfo: ClaimRemoteDelayedOutputTx => Right(txInfo.copy(tx = updatedTx))
+        case txInfo: ClaimRemoteMainOutputTx => Right(txInfo.copy(tx = updatedTx))
         // Anchor transaction don't have any output: wallet inputs must be used to pay fees.
         case txInfo: ClaimAnchorTx => Left(CannotUpdateFee(txInfo))
         // HTLC transactions are pre-signed, we can't update their fee by lowering the output amount.

eclair-core/src/test/scala/fr/acinq/eclair/balance/CheckBalanceSpec.scala

@@ -128,7 +128,7 @@ class CheckBalanceSpec extends TestKitBaseClass with FixtureAnyFunSuiteLike with
     alice ! WatchFundingSpentTriggered(bobCommitTx)
     // In response to that, alice publishes her claim txs.
     alice2blockchain.expectReplaceableTxPublished[ClaimRemoteAnchorTx]
-    val claimMain = alice2blockchain.expectFinalTxPublished("remote-main-delayed")
+    val claimMain = alice2blockchain.expectFinalTxPublished("remote-main")
     val mainAmount = bobCommitTx.txOut(claimMain.input.index.toInt).amount
     val claimHtlcTxs = (1 to 3).map(_ => alice2blockchain.expectMsgType[PublishReplaceableTx].txInfo)
     assert(claimHtlcTxs.collect { case tx: ClaimHtlcSuccessTx => tx }.size == 1)
@@ -185,7 +185,7 @@ class CheckBalanceSpec extends TestKitBaseClass with FixtureAnyFunSuiteLike with
     alice ! WatchFundingSpentTriggered(bobCommitTx)
     // In response to that, alice publishes her claim txs
     alice2blockchain.expectReplaceableTxPublished[ClaimRemoteAnchorTx]
-    val claimMain = alice2blockchain.expectFinalTxPublished("remote-main-delayed")
+    val claimMain = alice2blockchain.expectFinalTxPublished("remote-main")
     val mainAmount = bobCommitTx.txOut(claimMain.input.index.toInt).amount
     (1 to 2).map(_ => alice2blockchain.expectReplaceableTxPublished[ClaimHtlcTimeoutTx])
     alice ! WatchTxConfirmedTriggered(BlockHeight(600_000), 5, bobCommitTx)

eclair-core/src/test/scala/fr/acinq/eclair/channel/HelpersSpec.scala

@@ -114,7 +114,7 @@ class HelpersSpec extends TestKitBaseClass with AnyFunSuiteLike with ChannelStat
 
     val rcp = bob.stateData.asInstanceOf[DATA_CLOSING].remoteCommitPublished.get
     rcp.anchorOutput_opt.foreach(_ => bob2blockchain.expectReplaceableTxPublished[ClaimRemoteAnchorTx])
-    rcp.localOutput_opt.foreach(_ => bob2blockchain.expectFinalTxPublished("remote-main-delayed"))
+    rcp.localOutput_opt.foreach(_ => bob2blockchain.expectFinalTxPublished("remote-main"))
     // Bob is missing the preimage for 2 of the HTLCs she received.
     assert(rcp.htlcOutputs.size == 6)
     val claimHtlcTxs = (0 until 4).map(_ => bob2blockchain.expectMsgType[PublishReplaceableTx])

eclair-core/src/test/scala/fr/acinq/eclair/channel/publish/ReplaceableTxPublisherSpec.scala

@@ -1603,7 +1603,7 @@ class ReplaceableTxPublisherSpec extends TestKitBaseClass with AnyFunSuiteLike w
     generateBlocks(1)
 
     val anchorTx = alice2blockchain.expectReplaceableTxPublished[ClaimRemoteAnchorTx]
-    val mainTx = alice2blockchain.expectFinalTxPublished("remote-main-delayed")
+    val mainTx = alice2blockchain.expectFinalTxPublished("remote-main")
     val claimHtlcSuccess = alice2blockchain.expectMsgType[PublishReplaceableTx].copy(confirmationTarget = ConfirmationTarget.Absolute(overrideHtlcTarget))
     assert(claimHtlcSuccess.txInfo.isInstanceOf[ClaimHtlcSuccessTx])
     val claimHtlcTimeout = alice2blockchain.expectMsgType[PublishReplaceableTx].copy(confirmationTarget = ConfirmationTarget.Absolute(overrideHtlcTarget))

eclair-core/src/test/scala/fr/acinq/eclair/channel/states/ChannelStateTestsHelperMethods.scala

@@ -717,7 +717,7 @@ trait ChannelStateTestsBase extends Assertions with Eventually {
     // If anchor outputs is used, we use the anchor output to bump the fees if necessary.
     val publishedAnchorTx = s2blockchain.expectReplaceableTxPublished[ClaimRemoteAnchorTx].tx
     // if s has a main output in the commit tx (when it has a non-dust balance), it should be claimed
-    val publishedMainTx_opt = remoteCommitPublished.localOutput_opt.map(_ => s2blockchain.expectFinalTxPublished("remote-main-delayed").tx)
+    val publishedMainTx_opt = remoteCommitPublished.localOutput_opt.map(_ => s2blockchain.expectFinalTxPublished("remote-main").tx)
     publishedMainTx_opt.foreach(tx => Transaction.correctlySpends(tx, rCommitTx :: Nil, ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS))
     // all htlcs success/timeout should be claimed
     val publishedClaimHtlcTxs = (0 until htlcSuccessCount + htlcTimeoutCount).map { _ =>

eclair-core/src/test/scala/fr/acinq/eclair/channel/states/c/WaitForDualFundingConfirmedStateSpec.scala

@@ -774,7 +774,7 @@ class WaitForDualFundingConfirmedStateSpec extends TestKitBaseClass with Fixture
     alice ! WatchFundingSpentTriggered(bobCommitTx)
     aliceListener.expectMsgType[TransactionPublished]
     alice2blockchain.expectReplaceableTxPublished[ClaimRemoteAnchorTx]
-    val claimMain = alice2blockchain.expectFinalTxPublished("remote-main-delayed")
+    val claimMain = alice2blockchain.expectFinalTxPublished("remote-main")
     Transaction.correctlySpends(claimMain.tx, Seq(bobCommitTx), ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS)
     alice2blockchain.expectWatchTxConfirmed(bobCommitTx.txid)
     alice2blockchain.expectWatchOutputSpent(claimMain.input)
@@ -810,7 +810,7 @@ class WaitForDualFundingConfirmedStateSpec extends TestKitBaseClass with Fixture
     alice ! WatchFundingSpentTriggered(bobCommitTx1)
     assert(aliceListener.expectMsgType[TransactionPublished].tx.txid == bobCommitTx1.txid)
     alice2blockchain.expectReplaceableTxPublished[ClaimRemoteAnchorTx]
-    val claimMain = alice2blockchain.expectFinalTxPublished("remote-main-delayed")
+    val claimMain = alice2blockchain.expectFinalTxPublished("remote-main")
     Transaction.correctlySpends(claimMain.tx, Seq(bobCommitTx1), ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS)
     alice2blockchain.expectWatchTxConfirmed(bobCommitTx1.txid)
     alice2blockchain.expectWatchOutputSpent(claimMain.input)
@@ -833,7 +833,7 @@ class WaitForDualFundingConfirmedStateSpec extends TestKitBaseClass with Fixture
     assert(alice2blockchain.expectMsgType[WatchFundingSpent].txId == fundingTx.txid)
     alice2 ! WatchFundingSpentTriggered(bobCommitTx)
     alice2blockchain.expectReplaceableTxPublished[ClaimRemoteAnchorTx]
-    val claimMainAlice = alice2blockchain.expectFinalTxPublished("remote-main-delayed")
+    val claimMainAlice = alice2blockchain.expectFinalTxPublished("remote-main")
     Transaction.correctlySpends(claimMainAlice.tx, Seq(bobCommitTx), ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS)
     alice2blockchain.expectWatchTxConfirmed(bobCommitTx.txid)
     alice2blockchain.expectWatchOutputSpent(claimMainAlice.input)
@@ -844,7 +844,7 @@ class WaitForDualFundingConfirmedStateSpec extends TestKitBaseClass with Fixture
     assert(bob2blockchain.expectMsgType[WatchFundingSpent].txId == fundingTx.txid)
     bob2 ! WatchFundingSpentTriggered(aliceCommitTx)
     bob2blockchain.expectReplaceableTxPublished[ClaimRemoteAnchorTx]
-    val claimMainBob = bob2blockchain.expectFinalTxPublished("remote-main-delayed")
+    val claimMainBob = bob2blockchain.expectFinalTxPublished("remote-main")
     Transaction.correctlySpends(claimMainBob.tx, Seq(aliceCommitTx), ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS)
     bob2blockchain.expectWatchTxConfirmed(aliceCommitTx.txid)
     bob2blockchain.expectWatchOutputSpent(claimMainBob.input)
@@ -872,7 +872,7 @@ class WaitForDualFundingConfirmedStateSpec extends TestKitBaseClass with Fixture
     alice2blockchain.expectMsg(UnwatchTxConfirmed(fundingTx2.txId))
     alice2 ! WatchFundingSpentTriggered(bobCommitTx1)
     alice2blockchain.expectReplaceableTxPublished[ClaimRemoteAnchorTx]
-    val claimMainAlice = alice2blockchain.expectFinalTxPublished("remote-main-delayed")
+    val claimMainAlice = alice2blockchain.expectFinalTxPublished("remote-main")
     Transaction.correctlySpends(claimMainAlice.tx, Seq(bobCommitTx1), ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS)
     alice2blockchain.expectWatchTxConfirmed(bobCommitTx1.txid)
     alice2blockchain.expectWatchOutputSpent(claimMainAlice.input)
@@ -885,7 +885,7 @@ class WaitForDualFundingConfirmedStateSpec extends TestKitBaseClass with Fixture
     bob2blockchain.expectMsg(UnwatchTxConfirmed(fundingTx2.txId))
     bob2 ! WatchFundingSpentTriggered(aliceCommitTx1)
     bob2blockchain.expectReplaceableTxPublished[ClaimRemoteAnchorTx]
-    val claimMainBob = bob2blockchain.expectFinalTxPublished("remote-main-delayed")
+    val claimMainBob = bob2blockchain.expectFinalTxPublished("remote-main")
     Transaction.correctlySpends(claimMainBob.tx, Seq(aliceCommitTx1), ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS)
     bob2blockchain.expectWatchTxConfirmed(aliceCommitTx1.txid)
     bob2blockchain.expectWatchOutputSpent(claimMainBob.input)
@@ -1331,7 +1331,7 @@ class WaitForDualFundingConfirmedStateSpec extends TestKitBaseClass with Fixture
     val bobCommitTx = bob.signCommitTx()
     alice ! WatchFundingSpentTriggered(bobCommitTx)
     val anchorTxRemote = alice2blockchain.expectReplaceableTxPublished[ClaimRemoteAnchorTx]
-    val claimMainRemote = alice2blockchain.expectFinalTxPublished("remote-main-delayed")
+    val claimMainRemote = alice2blockchain.expectFinalTxPublished("remote-main")
     Transaction.correctlySpends(claimMainRemote.tx, Seq(bobCommitTx), ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS)
     alice2blockchain.expectWatchTxConfirmed(bobCommitTx.txid)
     alice2blockchain.expectWatchOutputSpent(claimMainRemote.input)
@@ -1379,7 +1379,7 @@ class WaitForDualFundingConfirmedStateSpec extends TestKitBaseClass with Fixture
     // Bob publishes his commit tx, Alice reacts by spending her remote main output.
     alice ! WatchFundingSpentTriggered(bobCommitTx1)
     val anchorRemote = alice2blockchain.expectReplaceableTxPublished[ClaimRemoteAnchorTx]
-    val claimMainRemote = alice2blockchain.expectFinalTxPublished("remote-main-delayed")
+    val claimMainRemote = alice2blockchain.expectFinalTxPublished("remote-main")
     Transaction.correctlySpends(claimMainRemote.tx, Seq(bobCommitTx1), ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS)
     alice2blockchain.expectWatchTxConfirmed(bobCommitTx1.txid)
     alice2blockchain.expectWatchOutputsSpent(Seq(anchorRemote.input.outPoint, claimMainRemote.input))