Add more fields to DATA_CLOSED

We also introduce a dedicated `ClosedData` trait for the `CLOSED` state,
which provides a cleaner mapping between state and data.

Author: t-bast

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

@@ -561,6 +561,8 @@ sealed trait ChannelDataWithCommitments extends PersistentChannelData {
   def commitments: Commitments
 }
 
+sealed trait ClosedData extends ChannelData
+
 final case class DATA_WAIT_FOR_OPEN_CHANNEL(initFundee: INPUT_INIT_CHANNEL_NON_INITIATOR) extends TransientChannelData {
   val channelId: ByteVector32 = initFundee.temporaryChannelId
 }
@@ -697,6 +699,11 @@ final case class DATA_CLOSING(commitments: Commitments,
 
 final case class DATA_WAIT_FOR_REMOTE_PUBLISH_FUTURE_COMMITMENT(commitments: Commitments, remoteChannelReestablish: ChannelReestablish) extends ChannelDataWithCommitments
 
+/** We use this class when a channel shouldn't be stored in the DB (e.g. because it never confirmed). */
+case object IgnoreClosedData extends ClosedData {
+  val channelId: ByteVector32 = ByteVector32.Zeroes
+}
+
 /**
  * This class contains the data we will keep in our DB for every closed channel.
  * It shouldn't contain data we may wish to remove in the future, otherwise we'll have backwards-compatibility issues.
@@ -711,14 +718,18 @@ final case class DATA_CLOSED(channelId: ByteVector32,
                              fundingTxId: TxId,
                              fundingOutputIndex: Long,
                              fundingTxIndex: Long,
+                             fundingKeyPath: String,
+                             channelFeatures: String,
                              isChannelOpener: Boolean,
                              commitmentFormat: String,
                              announced: Boolean,
                              capacity: Satoshi,
                              closingTxId: TxId,
                              closingType: String,
                              closingScript: ByteVector,
-                             closingAmount: Satoshi) extends ChannelData
+                             localBalance: MilliSatoshi,
+                             remoteBalance: MilliSatoshi,
+                             closingAmount: Satoshi) extends ClosedData
 
 object DATA_CLOSED {
   def apply(d: DATA_NEGOTIATING_SIMPLE, closingTx: ClosingTx): DATA_CLOSED = DATA_CLOSED(
@@ -727,13 +738,17 @@ object DATA_CLOSED {
     fundingTxId = d.commitments.latest.fundingTxId,
     fundingOutputIndex = d.commitments.latest.fundingInput.index,
     fundingTxIndex = d.commitments.latest.fundingTxIndex,
+    fundingKeyPath = d.commitments.channelParams.localParams.fundingKeyPath.toString(),
+    channelFeatures = d.commitments.channelParams.channelFeatures.toString,
     isChannelOpener = d.commitments.latest.channelParams.localParams.isChannelOpener,
     commitmentFormat = d.commitments.latest.commitmentFormat.toString,
     announced = d.commitments.latest.channelParams.announceChannel,
     capacity = d.commitments.latest.capacity,
     closingTxId = closingTx.tx.txid,
     closingType = Helpers.Closing.MutualClose(closingTx).toString,
     closingScript = d.localScriptPubKey,
+    localBalance = d.commitments.latest.localCommit.spec.toLocal,
+    remoteBalance = d.commitments.latest.localCommit.spec.toRemote,
     closingAmount = closingTx.toLocalOutput_opt.map(_.amount).getOrElse(0 sat)
   )
 
@@ -743,6 +758,8 @@ object DATA_CLOSED {
     fundingTxId = d.commitments.latest.fundingTxId,
     fundingOutputIndex = d.commitments.latest.fundingInput.index,
     fundingTxIndex = d.commitments.latest.fundingTxIndex,
+    fundingKeyPath = d.commitments.channelParams.localParams.fundingKeyPath.toString(),
+    channelFeatures = d.commitments.channelParams.channelFeatures.toString,
     isChannelOpener = d.commitments.latest.channelParams.localParams.isChannelOpener,
     commitmentFormat = d.commitments.latest.commitmentFormat.toString,
     announced = d.commitments.latest.channelParams.announceChannel,
@@ -757,6 +774,16 @@ object DATA_CLOSED {
     },
     closingType = closingType.toString,
     closingScript = d.finalScriptPubKey,
+    localBalance = closingType match {
+      case _: Closing.CurrentRemoteClose => d.commitments.latest.remoteCommit.spec.toRemote
+      case _: Closing.NextRemoteClose => d.commitments.latest.nextRemoteCommit_opt.getOrElse(d.commitments.latest.remoteCommit).spec.toRemote
+      case _ => d.commitments.latest.localCommit.spec.toLocal
+    },
+    remoteBalance = closingType match {
+      case _: Closing.CurrentRemoteClose => d.commitments.latest.remoteCommit.spec.toLocal
+      case _: Closing.NextRemoteClose => d.commitments.latest.nextRemoteCommit_opt.getOrElse(d.commitments.latest.remoteCommit).spec.toLocal
+      case _ => d.commitments.latest.localCommit.spec.toRemote
+    },
     closingAmount = closingType match {
       case Closing.MutualClose(closingTx) => closingTx.toLocalOutput_opt.map(_.amount).getOrElse(0 sat)
       case Closing.LocalClose(_, localCommitPublished) => Closing.closingBalance(d.channelParams, d.commitments.latest.commitmentFormat, d.finalScriptPubKey, localCommitPublished)

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

@@ -384,7 +384,7 @@ class Channel(val nodeParams: NodeParams, val channelKeys: ChannelKeys, val wall
         case closing: DATA_CLOSING if Closing.nothingAtStake(closing) =>
           log.info("we have nothing at stake, going straight to CLOSED")
           context.system.eventStream.publish(ChannelAborted(self, remoteNodeId, closing.channelId))
-          goto(CLOSED) using closing
+          goto(CLOSED) using IgnoreClosedData
         case closing: DATA_CLOSING =>
           val localPaysClosingFees = closing.commitments.localChannelParams.paysClosingFees
           val closingType_opt = Closing.isClosingTypeAlreadyKnown(closing)
@@ -2288,8 +2288,7 @@ class Channel(val nodeParams: NodeParams, val channelKeys: ChannelKeys, val wall
         case Some(closingType) =>
           log.info("channel closed (type={})", EventType.Closed(closingType).label)
           context.system.eventStream.publish(ChannelClosed(self, d.channelId, closingType, d.commitments))
-          val closed = DATA_CLOSED(d1, closingType)
-          goto(CLOSED) using closed
+          goto(CLOSED) using DATA_CLOSED(d1, closingType)
         case None =>
           stay() using d1 storing()
       }
@@ -2369,9 +2368,9 @@ class Channel(val nodeParams: NodeParams, val channelKeys: ChannelKeys, val wall
         case d: DATA_CLOSED =>
           log.info(s"moving channelId=${d.channelId} to the closed channels DB")
           nodeParams.db.channels.removeChannel(d.channelId, Some(d))
-        case d: PersistentChannelData =>
-          log.info("deleting database record for channelId={}", d.channelId)
-          nodeParams.db.channels.removeChannel(d.channelId, None)
+        case _: PersistentChannelData | IgnoreClosedData =>
+          log.info("deleting database record for channelId={}", stateData.channelId)
+          nodeParams.db.channels.removeChannel(stateData.channelId, None)
         case _: TransientChannelData => // nothing was stored in the DB
       }
       log.info("shutting down")
@@ -3074,7 +3073,7 @@ class Channel(val nodeParams: NodeParams, val channelKeys: ChannelKeys, val wall
           case d: ChannelDataWithCommitments => Some(d.commitments)
           case _: ChannelDataWithoutCommitments => None
           case _: TransientChannelData => None
-          case _: DATA_CLOSED => None
+          case _: ClosedData => None
         }
         context.system.eventStream.publish(ChannelStateChanged(self, nextStateData.channelId, peer, remoteNodeId, state, nextState, commitments_opt))
       }

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

@@ -285,11 +285,11 @@ trait ChannelOpenDualFunded extends DualFundingHandlers with ErrorHandlers {
 
     case Event(INPUT_DISCONNECTED, d: DATA_WAIT_FOR_ACCEPT_DUAL_FUNDED_CHANNEL) =>
       d.init.replyTo ! OpenChannelResponse.Disconnected
-      goto(CLOSED)
+      goto(CLOSED) using IgnoreClosedData
 
     case Event(TickChannelOpenTimeout, d: DATA_WAIT_FOR_ACCEPT_DUAL_FUNDED_CHANNEL) =>
       d.init.replyTo ! OpenChannelResponse.TimedOut
-      goto(CLOSED)
+      goto(CLOSED) using IgnoreClosedData
   })
 
   when(WAIT_FOR_DUAL_FUNDING_CREATED)(handleExceptions {
@@ -302,12 +302,12 @@ trait ChannelOpenDualFunded extends DualFundingHandlers with ErrorHandlers {
           log.info("our peer aborted the dual funding flow: ascii='{}' bin={}", msg.toAscii, msg.data)
           d.txBuilder ! InteractiveTxBuilder.Abort
           d.replyTo_opt.foreach(_ ! OpenChannelResponse.RemoteError(msg.toAscii))
-          goto(CLOSED) sending TxAbort(d.channelId, DualFundingAborted(d.channelId).getMessage)
+          goto(CLOSED) using IgnoreClosedData sending TxAbort(d.channelId, DualFundingAborted(d.channelId).getMessage)
         case _: TxSignatures =>
           log.info("received unexpected tx_signatures")
           d.txBuilder ! InteractiveTxBuilder.Abort
           d.replyTo_opt.foreach(_ ! OpenChannelResponse.Rejected(UnexpectedFundingSignatures(d.channelId).getMessage))
-          goto(CLOSED) sending TxAbort(d.channelId, UnexpectedFundingSignatures(d.channelId).getMessage)
+          goto(CLOSED) using IgnoreClosedData sending TxAbort(d.channelId, UnexpectedFundingSignatures(d.channelId).getMessage)
         case _: TxInitRbf =>
           log.info("ignoring unexpected tx_init_rbf message")
           stay() sending Warning(d.channelId, InvalidRbfAttempt(d.channelId).getMessage)
@@ -333,7 +333,7 @@ trait ChannelOpenDualFunded extends DualFundingHandlers with ErrorHandlers {
         goto(WAIT_FOR_DUAL_FUNDING_SIGNED) using d1 storing() sending commitSig
       case f: InteractiveTxBuilder.Failed =>
         d.replyTo_opt.foreach(_ ! OpenChannelResponse.Rejected(f.cause.getMessage))
-        goto(CLOSED) sending TxAbort(d.channelId, f.cause.getMessage)
+        goto(CLOSED) using IgnoreClosedData sending TxAbort(d.channelId, f.cause.getMessage)
     }
 
     case Event(c: CloseCommand, d: DATA_WAIT_FOR_DUAL_FUNDING_CREATED) =>
@@ -349,20 +349,20 @@ trait ChannelOpenDualFunded extends DualFundingHandlers with ErrorHandlers {
     case Event(INPUT_DISCONNECTED, d: DATA_WAIT_FOR_DUAL_FUNDING_CREATED) =>
       d.txBuilder ! InteractiveTxBuilder.Abort
       d.replyTo_opt.foreach(_ ! OpenChannelResponse.Disconnected)
-      goto(CLOSED)
+      goto(CLOSED) using IgnoreClosedData
 
     case Event(TickChannelOpenTimeout, d: DATA_WAIT_FOR_DUAL_FUNDING_CREATED) =>
       d.txBuilder ! InteractiveTxBuilder.Abort
       d.replyTo_opt.foreach(_ ! OpenChannelResponse.TimedOut)
-      goto(CLOSED)
+      goto(CLOSED) using IgnoreClosedData
   })
 
   when(WAIT_FOR_DUAL_FUNDING_SIGNED)(handleExceptions {
     case Event(commitSig: CommitSig, d: DATA_WAIT_FOR_DUAL_FUNDING_SIGNED) =>
       d.signingSession.receiveCommitSig(d.channelParams, channelKeys, commitSig, nodeParams.currentBlockHeight) match {
         case Left(f) =>
           rollbackFundingAttempt(d.signingSession.fundingTx.tx, Nil)
-          goto(CLOSED) sending Error(d.channelId, f.getMessage)
+          goto(CLOSED) using IgnoreClosedData sending Error(d.channelId, f.getMessage)
         case Right(signingSession1) => signingSession1 match {
           case signingSession1: InteractiveTxSigningSession.WaitingForSigs =>
             // In theory we don't have to store their commit_sig here, as they would re-send it if we disconnect, but
@@ -394,7 +394,7 @@ trait ChannelOpenDualFunded extends DualFundingHandlers with ErrorHandlers {
           d.signingSession.receiveTxSigs(channelKeys, txSigs, nodeParams.currentBlockHeight) match {
             case Left(f) =>
               rollbackFundingAttempt(d.signingSession.fundingTx.tx, Nil)
-              goto(CLOSED) sending Error(d.channelId, f.getMessage)
+              goto(CLOSED) using IgnoreClosedData sending Error(d.channelId, f.getMessage)
             case Right(signingSession) =>
               val minDepth_opt = d.channelParams.minDepth(nodeParams.channelConf.minDepth)
               watchFundingConfirmed(d.signingSession.fundingTx.txId, minDepth_opt, delay_opt = None)
@@ -412,7 +412,7 @@ trait ChannelOpenDualFunded extends DualFundingHandlers with ErrorHandlers {
         case msg: TxAbort =>
           log.info("our peer aborted the dual funding flow: ascii='{}' bin={}", msg.toAscii, msg.data)
           rollbackFundingAttempt(d.signingSession.fundingTx.tx, Nil)
-          goto(CLOSED) sending TxAbort(d.channelId, DualFundingAborted(d.channelId).getMessage)
+          goto(CLOSED) using IgnoreClosedData sending TxAbort(d.channelId, DualFundingAborted(d.channelId).getMessage)
         case msg: InteractiveTxConstructionMessage =>
           log.info("received unexpected interactive-tx message: {}", msg.getClass.getSimpleName)
           stay() sending Warning(d.channelId, UnexpectedInteractiveTxMessage(d.channelId, msg).getMessage)

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

@@ -163,7 +163,7 @@ trait ChannelOpenSingleFunded extends SingleFundingHandlers with ErrorHandlers {
 
     case Event(e: Error, d: DATA_WAIT_FOR_OPEN_CHANNEL) => handleRemoteError(e, d)
 
-    case Event(INPUT_DISCONNECTED, _) => goto(CLOSED)
+    case Event(INPUT_DISCONNECTED, _) => goto(CLOSED) using IgnoreClosedData
   })
 
   when(WAIT_FOR_ACCEPT_CHANNEL)(handleExceptions {
@@ -203,11 +203,11 @@ trait ChannelOpenSingleFunded extends SingleFundingHandlers with ErrorHandlers {
 
     case Event(INPUT_DISCONNECTED, d: DATA_WAIT_FOR_ACCEPT_CHANNEL) =>
       d.initFunder.replyTo ! OpenChannelResponse.Disconnected
-      goto(CLOSED)
+      goto(CLOSED) using IgnoreClosedData
 
     case Event(TickChannelOpenTimeout, d: DATA_WAIT_FOR_ACCEPT_CHANNEL) =>
       d.initFunder.replyTo ! OpenChannelResponse.TimedOut
-      goto(CLOSED)
+      goto(CLOSED) using IgnoreClosedData
   })
 
   when(WAIT_FOR_FUNDING_INTERNAL)(handleExceptions {
@@ -264,11 +264,11 @@ trait ChannelOpenSingleFunded extends SingleFundingHandlers with ErrorHandlers {
 
     case Event(INPUT_DISCONNECTED, d: DATA_WAIT_FOR_FUNDING_INTERNAL) =>
       d.replyTo ! OpenChannelResponse.Disconnected
-      goto(CLOSED)
+      goto(CLOSED) using IgnoreClosedData
 
     case Event(TickChannelOpenTimeout, d: DATA_WAIT_FOR_FUNDING_INTERNAL) =>
       d.replyTo ! OpenChannelResponse.TimedOut
-      goto(CLOSED)
+      goto(CLOSED) using IgnoreClosedData
   })
 
   when(WAIT_FOR_FUNDING_CREATED)(handleExceptions {
@@ -346,7 +346,7 @@ trait ChannelOpenSingleFunded extends SingleFundingHandlers with ErrorHandlers {
 
     case Event(e: Error, d: DATA_WAIT_FOR_FUNDING_CREATED) => handleRemoteError(e, d)
 
-    case Event(INPUT_DISCONNECTED, _) => goto(CLOSED)
+    case Event(INPUT_DISCONNECTED, _) => goto(CLOSED) using IgnoreClosedData
   })
 
   when(WAIT_FOR_FUNDING_SIGNED)(handleExceptions {
@@ -414,13 +414,13 @@ trait ChannelOpenSingleFunded extends SingleFundingHandlers with ErrorHandlers {
       // we rollback the funding tx, it will never be published
       wallet.rollback(d.fundingTx)
       d.replyTo ! OpenChannelResponse.Disconnected
-      goto(CLOSED)
+      goto(CLOSED) using IgnoreClosedData
 
     case Event(TickChannelOpenTimeout, d: DATA_WAIT_FOR_FUNDING_SIGNED) =>
       // we rollback the funding tx, it will never be published
       wallet.rollback(d.fundingTx)
       d.replyTo ! OpenChannelResponse.TimedOut
-      goto(CLOSED)
+      goto(CLOSED) using IgnoreClosedData
   })
 
   when(WAIT_FOR_FUNDING_CONFIRMED)(handleExceptions {

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

@@ -59,7 +59,7 @@ trait CommonHandlers {
           nodeParams.db.channels.addOrUpdateChannel(d)
           context.system.eventStream.publish(ChannelPersisted(self, remoteNodeId, d.channelId, d))
           state
-        case _: TransientChannelData | _: DATA_CLOSED =>
+        case _: TransientChannelData | _: ClosedData =>
           log.error(s"can't store data=${state.stateData} in state=${state.stateName}")
           state
       }

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

@@ -110,7 +110,7 @@ trait DualFundingHandlers extends CommonFundingHandlers {
     if (fundingTxIds.subsetOf(e.fundingTxIds)) {
       log.warning("{} funding attempts have been double-spent, forgetting channel", fundingTxIds.size)
       d.allFundingTxs.map(_.sharedTx.tx.buildUnsignedTx()).foreach(tx => wallet.rollback(tx))
-      goto(CLOSED) sending Error(d.channelId, FundingTxDoubleSpent(d.channelId).getMessage)
+      goto(CLOSED) using IgnoreClosedData sending Error(d.channelId, FundingTxDoubleSpent(d.channelId).getMessage)
     } else {
       // Not all funding attempts have been double-spent, the channel may still confirm.
       // For example, we may have published an RBF attempt while we were checking if funding attempts were double-spent.

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

@@ -46,7 +46,7 @@ trait ErrorHandlers extends CommonHandlers {
   def handleFastClose(c: CloseCommand, channelId: ByteVector32) = {
     val replyTo = if (c.replyTo == ActorRef.noSender) sender() else c.replyTo
     replyTo ! RES_SUCCESS(c, channelId)
-    goto(CLOSED)
+    goto(CLOSED) using IgnoreClosedData
   }
 
   def handleMutualClose(closingTx: ClosingTx, d: Either[DATA_NEGOTIATING, DATA_CLOSING]) = {
@@ -100,7 +100,7 @@ trait ErrorHandlers extends CommonHandlers {
         cause match {
           case _: InvalidFundingTx =>
             // invalid funding tx in the single-funding case: we just close the channel
-            goto(CLOSED)
+            goto(CLOSED) using IgnoreClosedData
           case _: ChannelException =>
             // known channel exception: we force close using our current commitment
             spendLocalCurrent(dd, maxClosingFeerate_opt) sending error
@@ -125,9 +125,9 @@ trait ErrorHandlers extends CommonHandlers {
             }
         }
       // When there is no commitment yet, we just send an error to our peer and go to CLOSED state.
-      case _: ChannelDataWithoutCommitments => goto(CLOSED) sending error
-      case _: TransientChannelData => goto(CLOSED) sending error
-      case _: DATA_CLOSED => stay()
+      case _: ChannelDataWithoutCommitments => goto(CLOSED) using IgnoreClosedData sending error
+      case _: TransientChannelData => goto(CLOSED) using IgnoreClosedData sending error
+      case _: ClosedData => stay()
     }
   }
 
@@ -166,9 +166,9 @@ trait ErrorHandlers extends CommonHandlers {
       // When there is no commitment yet, we just go to CLOSED state in case an error occurs.
       case waitForDualFundingSigned: DATA_WAIT_FOR_DUAL_FUNDING_SIGNED =>
         rollbackFundingAttempt(waitForDualFundingSigned.signingSession.fundingTx.tx, Nil)
-        goto(CLOSED)
-      case _: TransientChannelData => goto(CLOSED)
-      case _: DATA_CLOSED => stay()
+        goto(CLOSED) using IgnoreClosedData
+      case _: TransientChannelData => goto(CLOSED) using IgnoreClosedData
+      case _: ClosedData => stay()
     }
   }
 

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

@@ -97,13 +97,13 @@ trait SingleFundingHandlers extends CommonFundingHandlers {
   }
 
   def handleFundingPublishFailed(d: PersistentChannelData) = {
-    log.error(s"failed to publish funding tx")
+    log.error("failed to publish funding tx")
     val exc = ChannelFundingError(d.channelId)
     val error = Error(d.channelId, exc.getMessage)
     // NB: we don't use the handleLocalError handler because it would result in the commit tx being published, which we don't want:
     // implementation *guarantees* that in case of BITCOIN_FUNDING_PUBLISH_FAILED, the funding tx hasn't and will never be published, so we can close the channel right away
     context.system.eventStream.publish(ChannelErrorOccurred(self, stateData.channelId, remoteNodeId, LocalError(exc), isFatal = true))
-    goto(CLOSED) sending error
+    goto(CLOSED) using IgnoreClosedData sending error
   }
 
   def handleFundingTimeout(d: PersistentChannelData) = {
@@ -116,7 +116,7 @@ trait SingleFundingHandlers extends CommonFundingHandlers {
     val exc = FundingTxTimedout(d.channelId)
     val error = Error(d.channelId, exc.getMessage)
     context.system.eventStream.publish(ChannelErrorOccurred(self, stateData.channelId, remoteNodeId, LocalError(exc), isFatal = true))
-    goto(CLOSED) sending error
+    goto(CLOSED) using IgnoreClosedData sending error
   }
 
 }