Make channel type features non-permanent

We want to be able to update channel types during splices, which means
that channel type features will not be permanent anymore. We decouple
permanent channel features (that apply to the lifetime of the channel)
from channel type features to allow this.

Author: t-bast

eclair-core/src/main/scala/fr/acinq/eclair/Features.scala

@@ -36,17 +36,15 @@ object FeatureSupport {
 
 /** Not a sealed trait, so it can be extended by plugins. */
 trait Feature {
-
   def rfcName: String
   def mandatory: Int
   def optional: Int = mandatory + 1
-
   def supportBit(support: FeatureSupport): Int = support match {
     case Mandatory => mandatory
     case Optional => optional
   }
 
-  override def toString = rfcName
+  override def toString: String = rfcName
 }
 
 /** Feature scope as defined in Bolt 9. */
@@ -68,11 +66,9 @@ trait Bolt12Feature extends InvoiceFeature
  */
 trait PermanentChannelFeature extends InitFeature // <- not in the spec
 /**
- * Permanent channel feature negotiated in the channel type. Those features take precedence over permanent channel
- * features negotiated in init messages. For example, if the channel type is option_static_remotekey, then even if
- * the option_anchor_outputs feature is supported by both peers, it won't apply to the channel.
+ * Features that can be included in the [[fr.acinq.eclair.wire.protocol.ChannelTlv.ChannelTypeTlv]].
  */
-trait ChannelTypeFeature extends PermanentChannelFeature
+trait ChannelTypeFeature extends InitFeature
 // @formatter:on
 
 case class UnknownFeature(bitIndex: Int)
@@ -275,6 +271,7 @@ object Features {
     val rfcName = "option_attribution_data"
     val mandatory = 36
   }
+
   case object OnionMessages extends Feature with InitFeature with NodeFeature {
     val rfcName = "option_onion_messages"
     val mandatory = 38
@@ -290,7 +287,7 @@ object Features {
     val mandatory = 44
   }
 
-  case object ScidAlias extends Feature with InitFeature with NodeFeature with ChannelTypeFeature {
+  case object ScidAlias extends Feature with InitFeature with NodeFeature with ChannelTypeFeature with PermanentChannelFeature {
     val rfcName = "option_scid_alias"
     val mandatory = 46
   }
@@ -300,7 +297,7 @@ object Features {
     val mandatory = 48
   }
 
-  case object ZeroConf extends Feature with InitFeature with NodeFeature with ChannelTypeFeature {
+  case object ZeroConf extends Feature with InitFeature with NodeFeature with ChannelTypeFeature with PermanentChannelFeature {
     val rfcName = "option_zeroconf"
     val mandatory = 50
   }

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

@@ -557,6 +557,7 @@ final case class DATA_WAIT_FOR_ACCEPT_CHANNEL(initFunder: INPUT_INIT_CHANNEL_INI
   val channelId: ByteVector32 = initFunder.temporaryChannelId
 }
 final case class DATA_WAIT_FOR_FUNDING_INTERNAL(channelParams: ChannelParams,
+                                                channelType: SupportedChannelType,
                                                 localCommitParams: CommitParams,
                                                 remoteCommitParams: CommitParams,
                                                 fundingAmount: Satoshi,
@@ -566,9 +567,10 @@ final case class DATA_WAIT_FOR_FUNDING_INTERNAL(channelParams: ChannelParams,
                                                 remoteFirstPerCommitmentPoint: PublicKey,
                                                 replyTo: akka.actor.typed.ActorRef[Peer.OpenChannelResponse]) extends TransientChannelData {
   val channelId: ByteVector32 = channelParams.channelId
-  val commitmentFormat: CommitmentFormat = channelParams.channelFeatures.commitmentFormat
+  val commitmentFormat: CommitmentFormat = channelType.commitmentFormat
 }
 final case class DATA_WAIT_FOR_FUNDING_CREATED(channelParams: ChannelParams,
+                                               channelType: SupportedChannelType,
                                                localCommitParams: CommitParams,
                                                remoteCommitParams: CommitParams,
                                                fundingAmount: Satoshi,
@@ -577,9 +579,10 @@ final case class DATA_WAIT_FOR_FUNDING_CREATED(channelParams: ChannelParams,
                                                remoteFundingPubKey: PublicKey,
                                                remoteFirstPerCommitmentPoint: PublicKey) extends TransientChannelData {
   val channelId: ByteVector32 = channelParams.channelId
-  val commitmentFormat: CommitmentFormat = channelParams.channelFeatures.commitmentFormat
+  val commitmentFormat: CommitmentFormat = channelType.commitmentFormat
 }
 final case class DATA_WAIT_FOR_FUNDING_SIGNED(channelParams: ChannelParams,
+                                              channelType: SupportedChannelType,
                                               localCommitParams: CommitParams,
                                               remoteCommitParams: CommitParams,
                                               remoteFundingPubKey: PublicKey,
@@ -591,7 +594,7 @@ final case class DATA_WAIT_FOR_FUNDING_SIGNED(channelParams: ChannelParams,
                                               lastSent: FundingCreated,
                                               replyTo: akka.actor.typed.ActorRef[Peer.OpenChannelResponse]) extends TransientChannelData {
   val channelId: ByteVector32 = channelParams.channelId
-  val commitmentFormat: CommitmentFormat = channelParams.channelFeatures.commitmentFormat
+  val commitmentFormat: CommitmentFormat = channelType.commitmentFormat
 }
 final case class DATA_WAIT_FOR_FUNDING_CONFIRMED(commitments: Commitments,
                                                  waitingSince: BlockHeight, // how long have we been waiting for the funding tx to confirm

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

@@ -25,22 +25,10 @@ import fr.acinq.eclair.{ChannelTypeFeature, FeatureSupport, Features, InitFeatur
 
 /**
  * Subset of Bolt 9 features used to configure a channel and applicable over the lifetime of that channel.
- * Even if one of these features is later disabled at the connection level, it will still apply to the channel until the
- * channel is upgraded or closed.
+ * Even if one of these features is later disabled at the connection level, it will still apply to the channel.
  */
 case class ChannelFeatures(features: Set[PermanentChannelFeature]) {
 
-  /** True if our main output in the remote commitment is directly sent (without any delay) to one of our wallet addresses. */
-  val paysDirectlyToWallet: Boolean = hasFeature(Features.StaticRemoteKey) && !hasFeature(Features.AnchorOutputs) && !hasFeature(Features.AnchorOutputsZeroFeeHtlcTx)
-  /** Legacy option_anchor_outputs is used for Phoenix, because Phoenix doesn't have an on-chain wallet to pay for fees. */
-  val commitmentFormat: CommitmentFormat = if (hasFeature(Features.AnchorOutputs)) {
-    UnsafeLegacyAnchorOutputsCommitmentFormat
-  } else if (hasFeature(Features.AnchorOutputsZeroFeeHtlcTx)) {
-    ZeroFeeHtlcTxAnchorOutputsCommitmentFormat
-  } else {
-    DefaultCommitmentFormat
-  }
-
   def hasFeature(feature: PermanentChannelFeature): Boolean = features.contains(feature)
 
   override def toString: String = features.mkString(",")
@@ -51,19 +39,24 @@ object ChannelFeatures {
 
   def apply(features: PermanentChannelFeature*): ChannelFeatures = ChannelFeatures(Set.from(features))
 
-  /** Enrich the channel type with other permanent features that will be applied to the channel. */
+  /** Configure permanent channel features based on local and remote feature. */
   def apply(channelType: SupportedChannelType, localFeatures: Features[InitFeature], remoteFeatures: Features[InitFeature], announceChannel: Boolean): ChannelFeatures = {
-    val additionalPermanentFeatures = Features.knownFeatures.collect {
+    val permanentFeatures = Features.knownFeatures.collect {
       // If we both support 0-conf or scid_alias, we use it even if it wasn't in the channel-type.
-      case Features.ScidAlias if Features.canUseFeature(localFeatures, remoteFeatures, Features.ScidAlias) && !announceChannel => Some(Features.ScidAlias)
+      // Note that we cannot use scid_alias if the channel is announced.
+      case Features.ScidAlias =>
+        if (Features.canUseFeature(localFeatures, remoteFeatures, Features.ScidAlias) && !announceChannel) {
+          Some(Features.ScidAlias)
+        } else {
+          None
+        }
       case Features.ZeroConf if Features.canUseFeature(localFeatures, remoteFeatures, Features.ZeroConf) => Some(Features.ZeroConf)
-      // Other channel-type features are negotiated in the channel-type, we ignore their value from the init message.
-      case _: ChannelTypeFeature => None
-      // We add all other permanent channel features that aren't negotiated as part of the channel-type.
+      // We add all other permanent channel features that we both support.
       case f: PermanentChannelFeature if Features.canUseFeature(localFeatures, remoteFeatures, f) => Some(f)
     }.flatten
-    val allPermanentFeatures = channelType.features.toSeq ++ additionalPermanentFeatures
-    ChannelFeatures(allPermanentFeatures: _*)
+    // Some permanent features can be negotiated as part of the channel-type.
+    val channelTypeFeatures = channelType.features.collect { case f: PermanentChannelFeature => f }
+    ChannelFeatures(permanentFeatures ++ channelTypeFeatures)
   }
 
 }

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

@@ -25,7 +25,6 @@ case class ChannelParams(channelId: ByteVector32,
                          channelFeatures: ChannelFeatures,
                          localParams: LocalChannelParams, remoteParams: RemoteChannelParams,
                          channelFlags: ChannelFlags) {
-  require(channelFeatures.paysDirectlyToWallet == localParams.walletStaticPaymentBasepoint.isDefined, s"localParams.walletStaticPaymentBasepoint must be defined only for commitments that pay directly to our wallet (channel features: $channelFeatures")
   require(channelFeatures.hasFeature(Features.DualFunding) == localParams.initialRequestedChannelReserve_opt.isEmpty, "custom local channel reserve is incompatible with dual-funded channels")
   require(channelFeatures.hasFeature(Features.DualFunding) == remoteParams.initialRequestedChannelReserve_opt.isEmpty, "custom remote channel reserve is incompatible with dual-funded channels")
 

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

@@ -133,8 +133,8 @@ object Helpers {
     val channelFeatures = ChannelFeatures(channelType, localFeatures, remoteFeatures, open.channelFlags.announceChannel)
 
     // BOLT #2: The receiving node MUST fail the channel if: it considers feerate_per_kw too small for timely processing or unreasonably large.
-    val localFeeratePerKw = nodeParams.onChainFeeConf.getCommitmentFeerate(nodeParams.currentBitcoinCoreFeerates, remoteNodeId, channelFeatures.commitmentFormat, open.fundingSatoshis)
-    if (nodeParams.onChainFeeConf.feerateToleranceFor(remoteNodeId).isFeeDiffTooHigh(channelFeatures.commitmentFormat, localFeeratePerKw, open.feeratePerKw)) return Left(FeerateTooDifferent(open.temporaryChannelId, localFeeratePerKw, open.feeratePerKw))
+    val localFeeratePerKw = nodeParams.onChainFeeConf.getCommitmentFeerate(nodeParams.currentBitcoinCoreFeerates, remoteNodeId, channelType.commitmentFormat, open.fundingSatoshis)
+    if (nodeParams.onChainFeeConf.feerateToleranceFor(remoteNodeId).isFeeDiffTooHigh(channelType.commitmentFormat, localFeeratePerKw, open.feeratePerKw)) return Left(FeerateTooDifferent(open.temporaryChannelId, localFeeratePerKw, open.feeratePerKw))
 
     // we don't check that the funder's amount for the initial commitment transaction is sufficient for full fee payment
     // now, but it will be done later when we receive `funding_created`
@@ -180,8 +180,8 @@ object Helpers {
     val channelFeatures = ChannelFeatures(channelType, localFeatures, remoteFeatures, open.channelFlags.announceChannel)
 
     // BOLT #2: The receiving node MUST fail the channel if: it considers feerate_per_kw too small for timely processing or unreasonably large.
-    val localFeeratePerKw = nodeParams.onChainFeeConf.getCommitmentFeerate(nodeParams.currentBitcoinCoreFeerates, remoteNodeId, channelFeatures.commitmentFormat, open.fundingAmount)
-    if (nodeParams.onChainFeeConf.feerateToleranceFor(remoteNodeId).isFeeDiffTooHigh(channelFeatures.commitmentFormat, localFeeratePerKw, open.commitmentFeerate)) return Left(FeerateTooDifferent(open.temporaryChannelId, localFeeratePerKw, open.commitmentFeerate))
+    val localFeeratePerKw = nodeParams.onChainFeeConf.getCommitmentFeerate(nodeParams.currentBitcoinCoreFeerates, remoteNodeId, channelType.commitmentFormat, open.fundingAmount)
+    if (nodeParams.onChainFeeConf.feerateToleranceFor(remoteNodeId).isFeeDiffTooHigh(channelType.commitmentFormat, localFeeratePerKw, open.commitmentFeerate)) return Left(FeerateTooDifferent(open.temporaryChannelId, localFeeratePerKw, open.commitmentFeerate))
 
     for {
       script_opt <- extractShutdownScript(open.temporaryChannelId, localFeatures, remoteFeatures, open.upfrontShutdownScript_opt)

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

@@ -142,7 +142,7 @@ trait ChannelOpenSingleFunded extends SingleFundingHandlers with ErrorHandlers {
               ChannelTlv.UpfrontShutdownScriptTlv(localShutdownScript),
               ChannelTlv.ChannelTypeTlv(d.initFundee.channelType)
             ))
-          goto(WAIT_FOR_FUNDING_CREATED) using DATA_WAIT_FOR_FUNDING_CREATED(channelParams, localCommitParams, remoteCommitParams, open.fundingSatoshis, open.pushMsat, open.feeratePerKw, open.fundingPubkey, open.firstPerCommitmentPoint) sending accept
+          goto(WAIT_FOR_FUNDING_CREATED) using DATA_WAIT_FOR_FUNDING_CREATED(channelParams, d.initFundee.channelType, localCommitParams, remoteCommitParams, open.fundingSatoshis, open.pushMsat, open.feeratePerKw, open.fundingPubkey, open.firstPerCommitmentPoint) sending accept
       }
 
     case Event(c: CloseCommand, d) => handleFastClose(c, d.channelId)
@@ -175,7 +175,7 @@ trait ChannelOpenSingleFunded extends SingleFundingHandlers with ErrorHandlers {
           val channelParams = ChannelParams(d.initFunder.temporaryChannelId, d.initFunder.channelConfig, channelFeatures, d.initFunder.localChannelParams, remoteChannelParams, d.lastSent.channelFlags)
           val localCommitParams = CommitParams(d.initFunder.proposedCommitParams.localDustLimit, d.initFunder.proposedCommitParams.localHtlcMinimum, d.initFunder.proposedCommitParams.localMaxHtlcValueInFlight, d.initFunder.proposedCommitParams.localMaxAcceptedHtlcs, accept.toSelfDelay)
           val remoteCommitParams = CommitParams(accept.dustLimitSatoshis, accept.htlcMinimumMsat, accept.maxHtlcValueInFlightMsat, accept.maxAcceptedHtlcs, d.initFunder.proposedCommitParams.toRemoteDelay)
-          goto(WAIT_FOR_FUNDING_INTERNAL) using DATA_WAIT_FOR_FUNDING_INTERNAL(channelParams, localCommitParams, remoteCommitParams, d.initFunder.fundingAmount, d.initFunder.pushAmount_opt.getOrElse(0 msat), d.initFunder.commitTxFeerate, accept.fundingPubkey, accept.firstPerCommitmentPoint, d.initFunder.replyTo)
+          goto(WAIT_FOR_FUNDING_INTERNAL) using DATA_WAIT_FOR_FUNDING_INTERNAL(channelParams, d.initFunder.channelType, localCommitParams, remoteCommitParams, d.initFunder.fundingAmount, d.initFunder.pushAmount_opt.getOrElse(0 msat), d.initFunder.commitTxFeerate, accept.fundingPubkey, accept.firstPerCommitmentPoint, d.initFunder.replyTo)
       }
 
     case Event(c: CloseCommand, d: DATA_WAIT_FOR_ACCEPT_CHANNEL) =>
@@ -224,7 +224,7 @@ trait ChannelOpenSingleFunded extends SingleFundingHandlers with ErrorHandlers {
           txPublisher ! SetChannelId(remoteNodeId, channelId)
           context.system.eventStream.publish(ChannelIdAssigned(self, remoteNodeId, temporaryChannelId, channelId))
           // NB: we don't send a ChannelSignatureSent for the first commit
-          goto(WAIT_FOR_FUNDING_SIGNED) using DATA_WAIT_FOR_FUNDING_SIGNED(channelParams1, d.localCommitParams, d.remoteCommitParams, d.remoteFundingPubKey, fundingTx, fundingTxFee, localSpec, localCommitTx, remoteCommit, fundingCreated, d.replyTo) sending fundingCreated
+          goto(WAIT_FOR_FUNDING_SIGNED) using DATA_WAIT_FOR_FUNDING_SIGNED(channelParams1, d.channelType, d.localCommitParams, d.remoteCommitParams, d.remoteFundingPubKey, fundingTx, fundingTxFee, localSpec, localCommitTx, remoteCommit, fundingCreated, d.replyTo) sending fundingCreated
       }
 
     case Event(Status.Failure(t), d: DATA_WAIT_FOR_FUNDING_INTERNAL) =>

eclair-core/src/main/scala/fr/acinq/eclair/crypto/keymanager/CommitmentKeys.scala

@@ -72,7 +72,7 @@ object LocalCommitmentKeys {
     LocalCommitmentKeys(
       ourDelayedPaymentKey = channelKeys.delayedPaymentKey(localPerCommitmentPoint),
       theirPaymentPublicKey = commitmentFormat match {
-        case DefaultCommitmentFormat if params.channelFeatures.hasFeature(Features.StaticRemoteKey) => params.remoteParams.paymentBasepoint
+        case DefaultCommitmentFormat if params.localParams.walletStaticPaymentBasepoint.nonEmpty => params.remoteParams.paymentBasepoint
         case DefaultCommitmentFormat => ChannelKeys.remotePerCommitmentPublicKey(params.remoteParams.paymentBasepoint, localPerCommitmentPoint)
         case _: AnchorOutputsCommitmentFormat | _: SimpleTaprootChannelCommitmentFormat => params.remoteParams.paymentBasepoint
       },

eclair-core/src/main/scala/fr/acinq/eclair/wire/internal/channel/version0/ChannelTypes0.scala

@@ -230,12 +230,10 @@ private[channel] object ChannelTypes0 {
       } else {
         ChannelConfig()
       }
-      val channelFeatures = if (channelVersion.hasAnchorOutputs) {
-        ChannelFeatures(Features.StaticRemoteKey, Features.AnchorOutputs)
-      } else if (channelVersion.hasStaticRemotekey) {
-        ChannelFeatures(Features.StaticRemoteKey)
+      val commitmentFormat = if (channelVersion.hasAnchorOutputs) {
+        UnsafeLegacyAnchorOutputsCommitmentFormat
       } else {
-        ChannelFeatures()
+        DefaultCommitmentFormat
       }
       val (localCommit1, commitInput) = localCommit.migrate(remoteParams.fundingPubKey)
       val localCommitParams = CommitParams(localParams.dustLimit, localParams.htlcMinimum, localParams.maxHtlcValueInFlightMsat, localParams.maxAcceptedHtlcs, remoteParams.toRemoteDelay)
@@ -251,15 +249,15 @@ private[channel] object ChannelTypes0 {
         // funding tx when the channel is instantiated, and update the status (possibly immediately if it was confirmed).
         localFundingStatus = LocalFundingStatus.SingleFundedUnconfirmedFundingTx(None),
         remoteFundingStatus = RemoteFundingStatus.Locked,
-        commitmentFormat = channelFeatures.commitmentFormat,
+        commitmentFormat = commitmentFormat,
         localCommitParams = localCommitParams,
         localCommit = localCommit1,
         remoteCommitParams = remoteCommitParams,
         remoteCommit = remoteCommit,
         nextRemoteCommit_opt = remoteNextCommitInfo.left.toOption.map(w => NextRemoteCommit(w.sent, w.nextRemoteCommit))
       )
       channel.Commitments(
-        ChannelParams(channelId, channelConfig, channelFeatures, localParams.migrate(), remoteParams.migrate(), channelFlags),
+        ChannelParams(channelId, channelConfig, ChannelFeatures(), localParams.migrate(), remoteParams.migrate(), channelFlags),
         CommitmentChanges(localChanges, remoteChanges, localNextHtlcId, remoteNextHtlcId),
         Seq(commitment),
         inactive = Nil,