Add retransmit flags to next_funding TLV

Instead of using the `next_commitment_number` to let our peer know that
we haven't received their `commit_sig` for a partially signed funding
transaction, we add retransmit flags to the `next_funding` TLV in the
`channel_reestablish` message.

This is similar to what was done in the previous commit for announcement
signatures with the `my_current_funding_locked` TLV.

Author: t-bast

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

@@ -651,7 +651,7 @@ class Channel(val nodeParams: NodeParams, val channelKeys: ChannelKeys, val wall
         case (s: SpliceStatus.SpliceInProgress, sig: CommitSig) =>
           log.debug("received their commit_sig, deferring message")
           stay() using d.copy(spliceStatus = s.copy(remoteCommitSig = Some(sig)))
-        case (SpliceStatus.SpliceAborted, sig: CommitSig) =>
+        case (SpliceStatus.SpliceAborted, _: CommitSig) =>
           log.warning("received commit_sig after sending tx_abort, they probably sent it before receiving our tx_abort, ignoring...")
           stay()
         case (SpliceStatus.SpliceWaitingForSigs(signingSession), sig: CommitSig) =>
@@ -1456,7 +1456,7 @@ class Channel(val nodeParams: NodeParams, val channelKeys: ChannelKeys, val wall
     case Event(w: WatchPublishedTriggered, d: DATA_NORMAL) =>
       val fundingStatus = LocalFundingStatus.ZeroconfPublishedFundingTx(w.tx, d.commitments.localFundingSigs(w.tx.txid), d.commitments.liquidityPurchase(w.tx.txid))
       d.commitments.updateLocalFundingStatus(w.tx.txid, fundingStatus, d.lastAnnouncedFundingTxId_opt) match {
-        case Right((commitments1, commitment)) =>
+        case Right((commitments1, _)) =>
           watchFundingConfirmed(w.tx.txid, Some(nodeParams.channelConf.minDepth), delay_opt = None)
           maybeEmitEventsPostSplice(d.aliases, d.commitments, commitments1, d.lastAnnouncement_opt)
           maybeUpdateMaxHtlcAmount(d.channelUpdate.htlcMaximumMsat, commitments1)
@@ -2370,7 +2370,7 @@ class Channel(val nodeParams: NodeParams, val channelKeys: ChannelKeys, val wall
     case Event(INPUT_RECONNECTED(r, localInit, remoteInit), d: DATA_WAIT_FOR_DUAL_FUNDING_SIGNED) =>
       activeConnection = r
       val myFirstPerCommitmentPoint = channelKeys.commitmentPoint(0)
-      val nextFundingTlv: Set[ChannelReestablishTlv] = Set(ChannelReestablishTlv.NextFundingTlv(d.signingSession.fundingTxId))
+      val nextFundingTlv = Set[ChannelReestablishTlv](ChannelReestablishTlv.NextFundingTlv(d.signingSession.fundingTxId, d.signingSession.retransmitRemoteCommitSig))
       val nonceTlvs = d.signingSession.fundingParams.commitmentFormat match {
         case _: SegwitV0CommitmentFormat => Set.empty
         case _: SimpleTaprootChannelCommitmentFormat =>
@@ -2388,7 +2388,7 @@ class Channel(val nodeParams: NodeParams, val channelKeys: ChannelKeys, val wall
       }
       val channelReestablish = ChannelReestablish(
         channelId = d.channelId,
-        nextLocalCommitmentNumber = d.signingSession.nextLocalCommitmentNumber,
+        nextLocalCommitmentNumber = 1,
         nextRemoteRevocationNumber = 0,
         yourLastPerCommitmentSecret = PrivateKey(ByteVector32.Zeroes),
         myCurrentPerCommitmentPoint = myFirstPerCommitmentPoint,
@@ -2402,31 +2402,19 @@ class Channel(val nodeParams: NodeParams, val channelKeys: ChannelKeys, val wall
       val remotePerCommitmentSecrets = d.commitments.remotePerCommitmentSecrets
       val yourLastPerCommitmentSecret = remotePerCommitmentSecrets.lastIndex.flatMap(remotePerCommitmentSecrets.getHash).getOrElse(ByteVector32.Zeroes)
       val myCurrentPerCommitmentPoint = channelKeys.commitmentPoint(d.commitments.localCommitIndex)
-      // If we disconnected while signing a funding transaction, we may need our peer to retransmit their commit_sig.
-      val nextLocalCommitmentNumber = d match {
-        case d: DATA_WAIT_FOR_DUAL_FUNDING_CONFIRMED => d.status match {
-          case DualFundingStatus.RbfWaitingForSigs(status) => status.nextLocalCommitmentNumber
-          case _ => d.commitments.localCommitIndex + 1
-        }
-        case d: DATA_NORMAL => d.spliceStatus match {
-          case SpliceStatus.SpliceWaitingForSigs(status) => status.nextLocalCommitmentNumber
-          case _ => d.commitments.localCommitIndex + 1
-        }
-        case _ => d.commitments.localCommitIndex + 1
-      }
-      // If we disconnected while signing a funding transaction, we may need our peer to (re)transmit their tx_signatures.
+      // If we disconnected while signing a funding transaction, we may need our peer to (re)transmit their tx_signatures and commit_sig.
       val rbfTlv: Set[ChannelReestablishTlv] = d match {
         case d: DATA_WAIT_FOR_DUAL_FUNDING_CONFIRMED => d.status match {
-          case DualFundingStatus.RbfWaitingForSigs(status) => Set(ChannelReestablishTlv.NextFundingTlv(status.fundingTx.txId))
+          case DualFundingStatus.RbfWaitingForSigs(status) => Set(ChannelReestablishTlv.NextFundingTlv(status.fundingTx.txId, status.retransmitRemoteCommitSig))
           case _ => d.latestFundingTx.sharedTx match {
-            case _: InteractiveTxBuilder.PartiallySignedSharedTransaction => Set(ChannelReestablishTlv.NextFundingTlv(d.latestFundingTx.sharedTx.txId))
+            case _: InteractiveTxBuilder.PartiallySignedSharedTransaction => Set(ChannelReestablishTlv.NextFundingTlv(d.latestFundingTx.sharedTx.txId, retransmitCommitSig = false))
             case _: InteractiveTxBuilder.FullySignedSharedTransaction => Set.empty
           }
         }
         case d: DATA_NORMAL => d.spliceStatus match {
-          case SpliceStatus.SpliceWaitingForSigs(status) => Set(ChannelReestablishTlv.NextFundingTlv(status.fundingTx.txId))
+          case SpliceStatus.SpliceWaitingForSigs(status) => Set(ChannelReestablishTlv.NextFundingTlv(status.fundingTx.txId, status.retransmitRemoteCommitSig))
           case _ => d.commitments.latest.localFundingStatus match {
-            case LocalFundingStatus.DualFundedUnconfirmedFundingTx(fundingTx: PartiallySignedSharedTransaction, _, _, _) => Set(ChannelReestablishTlv.NextFundingTlv(fundingTx.txId))
+            case LocalFundingStatus.DualFundedUnconfirmedFundingTx(fundingTx: PartiallySignedSharedTransaction, _, _, _) => Set(ChannelReestablishTlv.NextFundingTlv(fundingTx.txId, retransmitCommitSig = false))
             case _ => Set.empty
           }
         }
@@ -2476,7 +2464,7 @@ class Channel(val nodeParams: NodeParams, val channelKeys: ChannelKeys, val wall
 
       val channelReestablish = ChannelReestablish(
         channelId = d.channelId,
-        nextLocalCommitmentNumber = nextLocalCommitmentNumber,
+        nextLocalCommitmentNumber = d.commitments.localCommitIndex + 1,
         nextRemoteRevocationNumber = d.commitments.remoteCommitIndex,
         yourLastPerCommitmentSecret = PrivateKey(yourLastPerCommitmentSecret),
         myCurrentPerCommitmentPoint = myCurrentPerCommitmentPoint,
@@ -2528,7 +2516,7 @@ class Channel(val nodeParams: NodeParams, val channelKeys: ChannelKeys, val wall
         case _ =>
           remoteNextCommitNonces = channelReestablish.nextCommitNonces
           channelReestablish.nextFundingTxId_opt match {
-            case Some(fundingTxId) if fundingTxId == d.signingSession.fundingTx.txId && channelReestablish.nextLocalCommitmentNumber == 0 =>
+            case Some(fundingTxId) if fundingTxId == d.signingSession.fundingTx.txId && channelReestablish.retransmitInteractiveTxCommitSig =>
               // They haven't received our commit_sig: we retransmit it, and will send our tx_signatures once we've received
               // their commit_sig or their tx_signatures (depending on who must send tx_signatures first).
               val fundingParams = d.signingSession.fundingParams
@@ -2556,7 +2544,7 @@ class Channel(val nodeParams: NodeParams, val channelKeys: ChannelKeys, val wall
             case Some(fundingTxId) =>
               d.status match {
                 case DualFundingStatus.RbfWaitingForSigs(signingSession) if signingSession.fundingTx.txId == fundingTxId =>
-                  if (channelReestablish.nextLocalCommitmentNumber == 0) {
+                  if (channelReestablish.retransmitInteractiveTxCommitSig) {
                     // They haven't received our commit_sig: we retransmit it.
                     // We're also waiting for signatures from them, and will send our tx_signatures once we receive them.
                     val fundingParams = signingSession.fundingParams
@@ -2573,7 +2561,7 @@ class Channel(val nodeParams: NodeParams, val channelKeys: ChannelKeys, val wall
                 case _ if d.latestFundingTx.sharedTx.txId == fundingTxId =>
                   // We've already received their commit_sig and sent our tx_signatures. We retransmit our tx_signatures
                   // and our commit_sig if they haven't received it already.
-                  if (channelReestablish.nextLocalCommitmentNumber == 0) {
+                  if (channelReestablish.retransmitInteractiveTxCommitSig) {
                     val remoteNonce_opt = channelReestablish.currentCommitNonce_opt
                     d.commitments.latest.remoteCommit.sign(d.commitments.channelParams, d.commitments.latest.remoteCommitParams, channelKeys, d.commitments.latest.fundingTxIndex, d.commitments.latest.remoteFundingPubKey, d.commitments.latest.commitInput(channelKeys), d.commitments.latest.commitmentFormat, remoteNonce_opt) match {
                       case Left(e) => handleLocalError(e, d, Some(channelReestablish))
@@ -2611,7 +2599,7 @@ class Channel(val nodeParams: NodeParams, val channelKeys: ChannelKeys, val wall
           channelReestablish.nextFundingTxId_opt match {
             case Some(fundingTxId) if fundingTxId == d.commitments.latest.fundingTxId =>
               d.commitments.latest.localFundingStatus.localSigs_opt match {
-                case Some(txSigs) if channelReestablish.nextLocalCommitmentNumber == 0 =>
+                case Some(txSigs) if channelReestablish.retransmitInteractiveTxCommitSig =>
                   log.info("re-sending commit_sig and tx_signatures for fundingTxIndex={} fundingTxId={}", d.commitments.latest.fundingTxIndex, d.commitments.latest.fundingTxId)
                   val remoteNonce_opt = channelReestablish.currentCommitNonce_opt
                   d.commitments.latest.remoteCommit.sign(d.commitments.channelParams, d.commitments.latest.remoteCommitParams, channelKeys, d.commitments.latest.fundingTxIndex, d.commitments.latest.remoteFundingPubKey, d.commitments.latest.commitInput(channelKeys), d.commitments.latest.commitmentFormat, remoteNonce_opt) match {
@@ -2672,9 +2660,8 @@ class Channel(val nodeParams: NodeParams, val channelKeys: ChannelKeys, val wall
               sendQueue = sendQueue ++ syncSuccess.retransmit
 
               commitments1.remoteNextCommitInfo match {
-                case Left(_) =>
-                  // we expect them to (re-)send the revocation immediately
-                  startSingleTimer(RevocationTimeout.toString, RevocationTimeout(commitments1.remoteCommitIndex, peer), nodeParams.channelConf.revocationTimeout)
+                // we expect them to (re-)send their revocation immediately
+                case Left(_) => startSingleTimer(RevocationTimeout.toString, RevocationTimeout(commitments1.remoteCommitIndex, peer), nodeParams.channelConf.revocationTimeout)
                 case _ => ()
               }
 
@@ -3423,7 +3410,7 @@ class Channel(val nodeParams: NodeParams, val channelKeys: ChannelKeys, val wall
       case Some(fundingTxId) =>
         d.spliceStatus match {
           case SpliceStatus.SpliceWaitingForSigs(signingSession) if signingSession.fundingTx.txId == fundingTxId =>
-            if (channelReestablish.nextLocalCommitmentNumber == d.commitments.remoteCommitIndex) {
+            if (channelReestablish.retransmitInteractiveTxCommitSig) {
               // They haven't received our commit_sig: we retransmit it.
               // We're also waiting for signatures from them, and will send our tx_signatures once we receive them.
               log.info("re-sending commit_sig for splice attempt with fundingTxIndex={} fundingTxId={}", signingSession.fundingTxIndex, signingSession.fundingTx.txId)
@@ -3440,7 +3427,7 @@ class Channel(val nodeParams: NodeParams, val channelKeys: ChannelKeys, val wall
               case dfu: LocalFundingStatus.DualFundedUnconfirmedFundingTx =>
                 // We've already received their commit_sig and sent our tx_signatures. We retransmit our
                 // tx_signatures and our commit_sig if they haven't received it already.
-                if (channelReestablish.nextLocalCommitmentNumber == d.commitments.remoteCommitIndex) {
+                if (channelReestablish.retransmitInteractiveTxCommitSig) {
                   log.info("re-sending commit_sig and tx_signatures for fundingTxIndex={} fundingTxId={}", d.commitments.latest.fundingTxIndex, d.commitments.latest.fundingTxId)
                   val remoteNonce_opt = channelReestablish.currentCommitNonce_opt
                   d.commitments.latest.remoteCommit.sign(d.commitments.channelParams, d.commitments.latest.remoteCommitParams, channelKeys, d.commitments.latest.fundingTxIndex, d.commitments.latest.remoteFundingPubKey, d.commitments.latest.commitInput(channelKeys), d.commitments.latest.commitmentFormat, remoteNonce_opt) match {

eclair-core/src/main/scala/fr/acinq/eclair/channel/fund/InteractiveTxBuilder.scala

@@ -1187,11 +1187,8 @@ object InteractiveTxSigningSession {
                             liquidityPurchase_opt: Option[LiquidityAds.PurchaseBasicInfo]) extends InteractiveTxSigningSession {
     val fundingTxId: TxId = fundingTx.txId
     val localCommitIndex: Long = localCommit.fold(_.index, _.index)
-    // This value tells our peer whether we need them to retransmit their commit_sig on reconnection or not.
-    val nextLocalCommitmentNumber: Long = localCommit match {
-      case Left(unsignedCommit) => unsignedCommit.index
-      case Right(commit) => commit.index + 1
-    }
+    // If we haven't received the remote commit_sig, we will request a retransmission on reconnection.
+    val retransmitRemoteCommitSig: Boolean = localCommit.isLeft
 
     def localFundingKey(channelKeys: ChannelKeys): PrivateKey = channelKeys.fundingKey(fundingTxIndex)
 

eclair-core/src/main/scala/fr/acinq/eclair/wire/protocol/ChannelTlv.scala

@@ -258,8 +258,11 @@ object ChannelReestablishTlv {
   /**
    * When disconnected in the middle of an interactive-tx session, this field is used to request a retransmission of
    * [[TxSignatures]] for the given [[txId]].
+   *
+   * @param txId                the txid of the partially signed funding transaction.
+   * @param retransmitCommitSig true if [[CommitSig]] must be retransmitted before [[TxSignatures]].
    */
-  case class NextFundingTlv(txId: TxId) extends ChannelReestablishTlv
+  case class NextFundingTlv(txId: TxId, retransmitCommitSig: Boolean) extends ChannelReestablishTlv
 
   /**
    * @param txId              the txid of our latest outgoing [[ChannelReady]] or [[SpliceLocked]] for this channel.
@@ -281,7 +284,7 @@ object ChannelReestablishTlv {
   case class NextLocalNoncesTlv(nonces: Seq[(TxId, IndividualNonce)]) extends ChannelReestablishTlv
 
   object NextFundingTlv {
-    val codec: Codec[NextFundingTlv] = tlvField(txIdAsHash)
+    val codec: Codec[NextFundingTlv] = tlvField(("next_funding_txid" | txIdAsHash) :: ("retransmit_flags" | (ignore(7) :: bool)))
   }
 
   object MyCurrentFundingLockedTlv {
@@ -297,7 +300,7 @@ object ChannelReestablishTlv {
   }
 
   val channelReestablishTlvCodec: Codec[TlvStream[ChannelReestablishTlv]] = tlvStream(discriminated[ChannelReestablishTlv].by(varint)
-    .typecase(UInt64(0), NextFundingTlv.codec)
+    .typecase(UInt64(1), NextFundingTlv.codec)
     .typecase(UInt64(5), MyCurrentFundingLockedTlv.codec)
     .typecase(UInt64(22), NextLocalNoncesTlv.codec)
     .typecase(UInt64(24), CurrentCommitNonceTlv.codec)

eclair-core/src/main/scala/fr/acinq/eclair/wire/protocol/LightningMessageTypes.scala

@@ -204,6 +204,7 @@ case class ChannelReestablish(channelId: ByteVector32,
                               myCurrentPerCommitmentPoint: PublicKey,
                               tlvStream: TlvStream[ChannelReestablishTlv] = TlvStream.empty) extends ChannelMessage with HasChannelId {
   val nextFundingTxId_opt: Option[TxId] = tlvStream.get[ChannelReestablishTlv.NextFundingTlv].map(_.txId)
+  val retransmitInteractiveTxCommitSig: Boolean = tlvStream.get[ChannelReestablishTlv.NextFundingTlv].exists(_.retransmitCommitSig)
   val myCurrentFundingLocked_opt: Option[TxId] = tlvStream.get[ChannelReestablishTlv.MyCurrentFundingLockedTlv].map(_.txId)
   val retransmitAnnSigs: Boolean = tlvStream.get[ChannelReestablishTlv.MyCurrentFundingLockedTlv].exists(_.retransmitAnnSigs)
   val nextCommitNonces: Map[TxId, IndividualNonce] = tlvStream.get[ChannelReestablishTlv.NextLocalNoncesTlv].map(_.nonces.toMap).getOrElse(Map.empty)

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

@@ -425,13 +425,15 @@ class WaitForDualFundingSignedStateSpec extends TestKitBaseClass with FixtureAny
 
     alice ! INPUT_RECONNECTED(bob, aliceInit, bobInit)
     val channelReestablishAlice = alice2bob.expectMsgType[ChannelReestablish]
-    assert(channelReestablishAlice.nextLocalCommitmentNumber == 0)
+    assert(channelReestablishAlice.nextLocalCommitmentNumber == 1)
+    assert(channelReestablishAlice.retransmitInteractiveTxCommitSig)
     assert(channelReestablishAlice.currentCommitNonce_opt.nonEmpty)
     assert(channelReestablishAlice.nextCommitNonces.contains(fundingTxId))
 
     bob ! INPUT_RECONNECTED(alice, bobInit, aliceInit)
     val channelReestablishBob = bob2alice.expectMsgType[ChannelReestablish]
-    assert(channelReestablishBob.nextLocalCommitmentNumber == 0)
+    assert(channelReestablishBob.nextLocalCommitmentNumber == 1)
+    assert(channelReestablishBob.retransmitInteractiveTxCommitSig)
     assert(channelReestablishBob.currentCommitNonce_opt.nonEmpty)
     assert(channelReestablishBob.nextCommitNonces.contains(fundingTxId))
 
@@ -530,12 +532,14 @@ class WaitForDualFundingSignedStateSpec extends TestKitBaseClass with FixtureAny
     assert(channelReestablishAlice.nextCommitNonces.contains(fundingTx.txid))
     assert(channelReestablishAlice.nextCommitNonces.get(fundingTx.txid) != channelReestablishAlice.currentCommitNonce_opt)
     assert(channelReestablishAlice.nextFundingTxId_opt.contains(fundingTx.txid))
-    assert(channelReestablishAlice.nextLocalCommitmentNumber == 0)
+    assert(channelReestablishAlice.retransmitInteractiveTxCommitSig)
+    assert(channelReestablishAlice.nextLocalCommitmentNumber == 1)
     alice2bob.forward(bob, channelReestablishAlice)
     val channelReestablishBob = bob2alice.expectMsgType[ChannelReestablish]
     assert(channelReestablishBob.currentCommitNonce_opt.isEmpty)
     assert(channelReestablishBob.nextCommitNonces.get(fundingTx.txid) == channelReadyB.nextCommitNonce_opt)
     assert(channelReestablishBob.nextFundingTxId_opt.isEmpty)
+    assert(!channelReestablishBob.retransmitInteractiveTxCommitSig)
     assert(channelReestablishBob.nextLocalCommitmentNumber == 1)
     bob2alice.forward(alice, channelReestablishBob)
 
@@ -673,14 +677,14 @@ class WaitForDualFundingSignedStateSpec extends TestKitBaseClass with FixtureAny
     alice ! INPUT_RECONNECTED(bob, aliceInit, bobInit)
     bob ! INPUT_RECONNECTED(alice, bobInit, aliceInit)
     val channelReestablishAlice = alice2bob.expectMsgType[ChannelReestablish]
-    val nextLocalCommitmentNumberAlice = if (aliceExpectsCommitSig) 0 else 1
     assert(channelReestablishAlice.nextFundingTxId_opt.contains(fundingTxId))
-    assert(channelReestablishAlice.nextLocalCommitmentNumber == nextLocalCommitmentNumberAlice)
+    assert(channelReestablishAlice.retransmitInteractiveTxCommitSig == aliceExpectsCommitSig)
+    assert(channelReestablishAlice.nextLocalCommitmentNumber == 1)
     alice2bob.forward(bob, channelReestablishAlice)
     val channelReestablishBob = bob2alice.expectMsgType[ChannelReestablish]
-    val nextLocalCommitmentNumberBob = if (bobExpectsCommitSig) 0 else 1
     assert(channelReestablishBob.nextFundingTxId_opt.contains(fundingTxId))
-    assert(channelReestablishBob.nextLocalCommitmentNumber == nextLocalCommitmentNumberBob)
+    assert(channelReestablishBob.retransmitInteractiveTxCommitSig == bobExpectsCommitSig)
+    assert(channelReestablishBob.nextLocalCommitmentNumber == 1)
     bob2alice.forward(alice, channelReestablishBob)
 
     // When using taproot, we must provide nonces for the partial signatures.