Remove support for non-anchor channels

We remove support for `static_remotekey` channels and `default`
channels, as advertised in the v0.13 release. This lets us remove
some code related to feerate management and simplifies the test
matrix.

Node operators that still have such channels must not run this
version of `eclair`, which will otherwise fail to start.

Note that for now, we keep sending `update_fee` whenever necessary.
We could remove that now that package relay allows 1p1c packages to
propagate even when the parent is below the mempool minimum feerate,
but we defer that to a later PR for simplicity.

Author: t-bast

docs/release-notes/eclair-vnext.md

@@ -27,6 +27,12 @@ We now store closed channels in a dedicated table, where we only keep relevant i
 When restarting your node, the channels table will automatically be cleaned up and closed channels will move to the new table.
 This may take some time depending on your channels history, but will only happen once.
 
+### Remove support for non-anchor channels
+
+We remove the code used to support legacy channels that don't use anchor outputs or taproot.
+If you still have such channels, you MUST NOT update to this version of eclair.
+You must instead close those channels, and will only be able to update eclair once they have been successfully closed.
+
 ### Update minimal version of Bitcoin Core
 
 With this release, eclair requires using Bitcoin Core 29.1.

eclair-core/src/main/resources/reference.conf

@@ -39,7 +39,7 @@ eclair {
     //  - unlock: eclair will automatically unlock the corresponding utxos
     //  - ignore: eclair will leave these utxos locked and start
     startup-locked-utxos-behavior = "stop"
-    final-pubkey-refresh-delay = 3 seconds
+    final-address-refresh-delay = 3 seconds
     // If true, eclair will poll bitcoind for 30 seconds at start-up before giving up.
     wait-for-bitcoind-up = true
     // The txid of a transaction that exists in your custom signet network or "" to skip this check.
@@ -87,7 +87,7 @@ eclair {
     // node that you trust using override-init-features (see below).
     option_zeroconf = disabled
     keysend = disabled
-    option_simple_close=optional
+    option_simple_close = optional
     trampoline_payment_prototype = disabled
     async_payment_prototype = disabled
     on_the_fly_funding = disabled
@@ -177,8 +177,6 @@ eclair {
       channel-opener-whitelist = [] // a list of public keys; we will ignore rate limits on pending channels from these peers
     }
 
-    accept-incoming-static-remote-key-channels = false // whether we accept new incoming static_remote_key channels (which are obsolete, nodes should use anchor_output now)
-
     quiescence-timeout = 1 minutes // maximum time we will stay quiescent (or wait to reach quiescence) before disconnecting
 
     channel-update {
@@ -292,8 +290,8 @@ eclair {
     max-closing-feerate = 10
 
     feerate-tolerance {
-      ratio-low = 0.5 // will allow remote fee rates as low as half our local feerate (only enforced when not using anchor outputs)
-      ratio-high = 10.0 // will allow remote fee rates as high as 10 times our local feerate (for all commitment formats)
+      ratio-low = 0.5 // will allow remote fee rates as low as half our local feerate for funding/splice transactions
+      ratio-high = 10.0 // will allow remote fee rates as high as 10 times our local feerate for commitment transactions and funding/splice transactions
       // when using anchor outputs, we only need to use a commitment feerate that allows the tx to propagate: we will use CPFP to speed up confirmation if needed.
       // the following value is the maximum feerate we'll use for our commit tx (in sat/byte)
       anchor-output-max-commit-feerate = 10

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

@@ -21,9 +21,9 @@ import fr.acinq.bitcoin.scalacompat.Crypto.PublicKey
 import fr.acinq.bitcoin.scalacompat.{Block, BlockHash, Crypto, Satoshi, SatoshiLong}
 import fr.acinq.eclair.Setup.Seeds
 import fr.acinq.eclair.blockchain.fee._
+import fr.acinq.eclair.channel.ChannelFlags
 import fr.acinq.eclair.channel.fsm.Channel
 import fr.acinq.eclair.channel.fsm.Channel.{BalanceThreshold, ChannelConf, UnhandledExceptionStrategy}
-import fr.acinq.eclair.channel.{ChannelFlags, ChannelTypes}
 import fr.acinq.eclair.crypto.Noise.KeyPair
 import fr.acinq.eclair.crypto.keymanager.{ChannelKeyManager, NodeKeyManager, OnChainKeyManager}
 import fr.acinq.eclair.db._
@@ -39,7 +39,7 @@ import fr.acinq.eclair.router.Graph.HeuristicsConstants
 import fr.acinq.eclair.router.Router._
 import fr.acinq.eclair.router.{Graph, PathFindingExperimentConf, Router}
 import fr.acinq.eclair.tor.Socks5ProxyParams
-import fr.acinq.eclair.transactions.Transactions
+import fr.acinq.eclair.transactions.Transactions.{PhoenixSimpleTaprootChannelCommitmentFormat, ZeroFeeHtlcTxAnchorOutputsCommitmentFormat, ZeroFeeHtlcTxSimpleTaprootChannelCommitmentFormat}
 import fr.acinq.eclair.wire.protocol._
 import grizzled.slf4j.Logging
 import scodec.bits.ByteVector
@@ -129,14 +129,17 @@ case class NodeParams(nodeKeyManager: NodeKeyManager,
       max = (fundingFeerate * feerateTolerance.ratioHigh).max(minimumFeerate),
     )
     // We use the most likely commitment format, even though there is no guarantee that this is the one that will be used.
-    val commitmentFormat = ChannelTypes.defaultFromFeatures(localFeatures, remoteFeatures, announceChannel = false).commitmentFormat
+    val commitmentFormat = if (Features.canUseFeature(localFeatures, remoteFeatures, Features.SimpleTaprootChannelsPhoenix)) {
+      PhoenixSimpleTaprootChannelCommitmentFormat
+    } else if (Features.canUseFeature(localFeatures, remoteFeatures, Features.SimpleTaprootChannelsStaging)) {
+      ZeroFeeHtlcTxSimpleTaprootChannelCommitmentFormat
+    } else {
+      ZeroFeeHtlcTxAnchorOutputsCommitmentFormat
+    }
     val commitmentFeerate = onChainFeeConf.getCommitmentFeerate(currentBitcoinCoreFeerates, remoteNodeId, commitmentFormat)
     val commitmentRange = RecommendedFeeratesTlv.CommitmentFeerateRange(
-      min = (commitmentFeerate * feerateTolerance.ratioLow).max(minimumFeerate),
-      max = (commitmentFormat match {
-        case Transactions.DefaultCommitmentFormat => commitmentFeerate * feerateTolerance.ratioHigh
-        case _: Transactions.AnchorOutputsCommitmentFormat | _: Transactions.SimpleTaprootChannelCommitmentFormat => (commitmentFeerate * feerateTolerance.ratioHigh).max(feerateTolerance.anchorOutputMaxCommitFeerate)
-      }).max(minimumFeerate),
+      min = Seq(commitmentFeerate * feerateTolerance.ratioLow, minimumFeerate).max,
+      max = Seq(commitmentFeerate * feerateTolerance.ratioHigh, feerateTolerance.anchorOutputMaxCommitFeerate, minimumFeerate).max,
     )
     RecommendedFeerates(chainHash, fundingFeerate, commitmentFeerate, TlvStream(fundingRange, commitmentRange))
   }
@@ -599,7 +602,6 @@ object NodeParams extends Logging {
         quiescenceTimeout = FiniteDuration(config.getDuration("channel.quiescence-timeout").getSeconds, TimeUnit.SECONDS),
         balanceThresholds = config.getConfigList("channel.channel-update.balance-thresholds").asScala.map(conf => BalanceThreshold(Satoshi(conf.getLong("available-sat")), Satoshi(conf.getLong("max-htlc-sat")))).toSeq,
         minTimeBetweenUpdates = FiniteDuration(config.getDuration("channel.channel-update.min-time-between-updates").getSeconds, TimeUnit.SECONDS),
-        acceptIncomingStaticRemoteKeyChannels = config.getBoolean("channel.accept-incoming-static-remote-key-channels")
       ),
       onChainFeeConf = OnChainFeeConf(
         feeTargets = feeTargets,

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

@@ -268,24 +268,17 @@ class Setup(val datadir: File,
       })
       _ <- feeratesRetrieved.future
 
-      finalPubkey = new AtomicReference[PublicKey](null)
       finalPubkeyScript = new AtomicReference[Seq[ScriptElt]](null)
-      pubkeyRefreshDelay = FiniteDuration(config.getDuration("bitcoind.final-pubkey-refresh-delay").getSeconds, TimeUnit.SECONDS)
+      finalAddressRefreshDelay = FiniteDuration(config.getDuration("bitcoind.final-address-refresh-delay").getSeconds, TimeUnit.SECONDS)
       // there are 3 possibilities regarding onchain key management:
       // 1) there is no `eclair-signer.conf` file in Eclair's data directory, Eclair will not manage Bitcoin core keys, and Eclair's API will not return bitcoin core descriptors. This is the default mode.
       // 2) there is an `eclair-signer.conf` file in Eclair's data directory, but the name of the wallet set in `eclair-signer.conf` does not match the `eclair.bitcoind.wallet` setting in `eclair.conf`.
       // Eclair will use the wallet set in `eclair.conf` and will not manage Bitcoin core keys (here we don't set an optional onchain key manager in our bitcoin client) BUT its API will return bitcoin core descriptors.
       // This is how you would create a new bitcoin wallet whose private keys are managed by Eclair.
       // 3) there is an `eclair-signer.conf` file in Eclair's data directory, and the name of the wallet set in `eclair-signer.conf` matches the `eclair.bitcoind.wallet` setting in `eclair.conf`.
       // Eclair will assume that this is a watch-only bitcoin wallet that has been created from descriptors generated by Eclair, and will manage its private keys, and here we pass the onchain key manager to our bitcoin client.
-      bitcoinClient = new BitcoinCoreClient(bitcoin, nodeParams.liquidityAdsConfig.lockUtxos, if (bitcoin.wallet == onChainKeyManager_opt.map(_.walletName)) onChainKeyManager_opt else None) with OnChainPubkeyCache {
-        val refresher: typed.ActorRef[OnChainAddressRefresher.Command] = system.spawn(Behaviors.supervise(OnChainAddressRefresher(this, finalPubkey, finalPubkeyScript, pubkeyRefreshDelay)).onFailure(typed.SupervisorStrategy.restart), name = "onchain-address-manager")
-
-        override def getP2wpkhPubkey(renew: Boolean): PublicKey = {
-          val key = finalPubkey.get()
-          if (renew) refresher ! OnChainAddressRefresher.RenewPubkey
-          key
-        }
+      bitcoinClient = new BitcoinCoreClient(bitcoin, nodeParams.liquidityAdsConfig.lockUtxos, if (bitcoin.wallet == onChainKeyManager_opt.map(_.walletName)) onChainKeyManager_opt else None) with OnChainAddressCache {
+        val refresher: typed.ActorRef[OnChainAddressRefresher.Command] = system.spawn(Behaviors.supervise(OnChainAddressRefresher(this, finalPubkeyScript, finalAddressRefreshDelay)).onFailure(typed.SupervisorStrategy.restart), name = "on-chain-address-manager")
 
         override def getReceivePublicKeyScript(renew: Boolean): Seq[ScriptElt] = {
           val script = finalPubkeyScript.get()
@@ -294,8 +287,6 @@ class Setup(val datadir: File,
         }
       }
       _ = if (bitcoinClient.useEclairSigner) logger.info("using eclair to sign bitcoin core transactions")
-      initialPubkey <- bitcoinClient.getP2wpkhPubkey()
-      _ = finalPubkey.set(initialPubkey)
       // We use the default address type configured on the Bitcoin Core node.
       initialPubkeyScript <- bitcoinClient.getReceivePublicKeyScript(addressType_opt = None)
       _ = finalPubkeyScript.set(initialPubkeyScript)
@@ -494,7 +485,7 @@ case class Kit(nodeParams: NodeParams,
                postman: typed.ActorRef[Postman.Command],
                offerManager: typed.ActorRef[OfferManager.Command],
                defaultOfferHandler: typed.ActorRef[OfferManager.HandlerCommand],
-               wallet: OnChainWallet with OnChainPubkeyCache)
+               wallet: OnChainWallet with OnChainAddressCache)
 
 object Kit {
 

eclair-core/src/main/scala/fr/acinq/eclair/blockchain/OnChainWallet.scala

@@ -17,7 +17,6 @@
 package fr.acinq.eclair.blockchain
 
 import fr.acinq.bitcoin.psbt.Psbt
-import fr.acinq.bitcoin.scalacompat.Crypto.PublicKey
 import fr.acinq.bitcoin.scalacompat.{OutPoint, Satoshi, ScriptElt, Transaction, TxId}
 import fr.acinq.eclair.blockchain.bitcoind.rpc.BitcoinCoreClient.AddressType
 import fr.acinq.eclair.blockchain.fee.FeeratePerKw
@@ -120,18 +119,10 @@ trait OnChainAddressGenerator {
   /** Generate the public key script for a new wallet address. */
   def getReceivePublicKeyScript(addressType_opt: Option[AddressType] = None)(implicit ec: ExecutionContext): Future[Seq[ScriptElt]]
 
-  /** Generate a p2wpkh wallet address and return the corresponding public key. */
-  def getP2wpkhPubkey()(implicit ec: ExecutionContext): Future[PublicKey]
-
 }
 
 /** A caching layer for [[OnChainAddressGenerator]] that provides synchronous access to wallet addresses and keys. */
-trait OnChainPubkeyCache {
-
-  /**
-   * @param renew applies after requesting the current pubkey, and is asynchronous.
-   */
-  def getP2wpkhPubkey(renew: Boolean): PublicKey
+trait OnChainAddressCache {
 
   /**
    * @param renew applies after requesting the current script, and is asynchronous.

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

@@ -3,7 +3,6 @@ package fr.acinq.eclair.blockchain.bitcoind
 
 import akka.actor.typed.Behavior
 import akka.actor.typed.scaladsl.{ActorContext, Behaviors, TimerScheduler}
-import fr.acinq.bitcoin.scalacompat.Crypto.PublicKey
 import fr.acinq.bitcoin.scalacompat.{Script, ScriptElt}
 import fr.acinq.eclair.blockchain.OnChainAddressGenerator
 
@@ -19,26 +18,23 @@ object OnChainAddressRefresher {
 
   // @formatter:off
   sealed trait Command
-  case object RenewPubkey extends Command
   case object RenewPubkeyScript extends Command
-  private case class SetPubkey(pubkey: PublicKey) extends Command
   private case class SetPubkeyScript(script: Seq[ScriptElt]) extends Command
   private case class Error(reason: Throwable) extends Command
   private case object Done extends Command
   // @formatter:on
 
-  def apply(generator: OnChainAddressGenerator, finalPubkey: AtomicReference[PublicKey], finalPubkeyScript: AtomicReference[Seq[ScriptElt]], delay: FiniteDuration): Behavior[Command] = {
+  def apply(generator: OnChainAddressGenerator, finalPubkeyScript: AtomicReference[Seq[ScriptElt]], delay: FiniteDuration): Behavior[Command] = {
     Behaviors.setup { context =>
       Behaviors.withTimers { timers =>
-        val refresher = new OnChainAddressRefresher(generator, finalPubkey, finalPubkeyScript, context, timers, delay)
+        val refresher = new OnChainAddressRefresher(generator, finalPubkeyScript, context, timers, delay)
         refresher.idle()
       }
     }
   }
 }
 
 private class OnChainAddressRefresher(generator: OnChainAddressGenerator,
-                                      finalPubkey: AtomicReference[PublicKey],
                                       finalPubkeyScript: AtomicReference[Seq[ScriptElt]],
                                       context: ActorContext[OnChainAddressRefresher.Command],
                                       timers: TimerScheduler[OnChainAddressRefresher.Command], delay: FiniteDuration) {
@@ -47,13 +43,6 @@ private class OnChainAddressRefresher(generator: OnChainAddressGenerator,
 
   /** In that state, we're ready to renew our on-chain address whenever requested. */
   def idle(): Behavior[Command] = Behaviors.receiveMessage {
-    case RenewPubkey =>
-      context.log.debug("renewing pubkey (current={})", finalPubkey.get())
-      context.pipeToSelf(generator.getP2wpkhPubkey()) {
-        case Success(pubkey) => SetPubkey(pubkey)
-        case Failure(reason) => Error(reason)
-      }
-      renewing()
     case RenewPubkeyScript =>
       context.log.debug("renewing script (current={})", Script.write(finalPubkeyScript.get()).toHex)
       context.pipeToSelf(generator.getReceivePublicKeyScript()) {
@@ -68,44 +57,28 @@ private class OnChainAddressRefresher(generator: OnChainAddressGenerator,
 
   /** We ignore concurrent requests while waiting for bitcoind to respond. */
   private def renewing(): Behavior[Command] = Behaviors.receiveMessage {
-    case SetPubkey(pubkey) =>
-      timers.startSingleTimer(Done, delay)
-      delaying(Some(pubkey), None)
     case SetPubkeyScript(script) =>
       timers.startSingleTimer(Done, delay)
-      delaying(None, Some(script))
+      delaying(script)
     case Error(reason) =>
-      context.log.error("cannot renew public key or script", reason)
+      context.log.error("cannot renew script", reason)
       idle()
     case cmd =>
       context.log.debug("ignoring command={} while waiting for bitcoin core's response", cmd)
       Behaviors.same
   }
 
   /**
-   * After receiving our new script or pubkey from bitcoind, we wait before updating our current values.
+   * After receiving our new address from bitcoind, we wait before updating our current value.
    * While waiting, we ignore additional requests to renew.
    *
    * This ensures that a burst of requests during a mass force-close use the same final on-chain address instead of
    * creating a lot of address churn on our bitcoin wallet.
-   *
-   * Note that while we're updating our final script, we will ignore requests to update our final public key (and the
-   * other way around). This is fine, since the public key is only used:
-   *  - when opening static_remotekey channels, which is disabled by default
-   *  - when closing channels with peers that don't support shutdown_anysegwit (which should be widely supported)
-   *
-   * In practice, we most likely always use [[RenewPubkeyScript]].
    */
-  private def delaying(nextPubkey_opt: Option[PublicKey], nextScript_opt: Option[Seq[ScriptElt]]): Behavior[Command] = Behaviors.receiveMessage {
+  private def delaying(nextScript: Seq[ScriptElt]): Behavior[Command] = Behaviors.receiveMessage {
     case Done =>
-      nextPubkey_opt.foreach { nextPubkey =>
-        context.log.info("setting pubkey to {}", nextPubkey)
-        finalPubkey.set(nextPubkey)
-      }
-      nextScript_opt.foreach { nextScript =>
-        context.log.info("setting script to {}", Script.write(nextScript).toHex)
-        finalPubkeyScript.set(nextScript)
-      }
+      context.log.info("setting script to {}", Script.write(nextScript).toHex)
+      finalPubkeyScript.set(nextScript)
       idle()
     case cmd =>
       context.log.debug("rate-limiting command={}", cmd)

eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/OnChainFeeConf.scala

@@ -65,29 +65,11 @@ case class DustTolerance(maxExposure: Satoshi, closeOnUpdateFeeOverflow: Boolean
 
 case class FeerateTolerance(ratioLow: Double, ratioHigh: Double, anchorOutputMaxCommitFeerate: FeeratePerKw, dustTolerance: DustTolerance) {
   /**
-   * @param commitmentFormat commitment format (anchor outputs allows a much higher tolerance since fees can be adjusted after tx is published)
    * @param networkFeerate   reference fee rate (value we estimate from our view of the network)
    * @param proposedFeerate  fee rate proposed (new proposal through update_fee or previous proposal used in our current commit tx)
    * @return true if the difference between proposed and reference fee rates is too high.
    */
-  def isFeeDiffTooHigh(commitmentFormat: CommitmentFormat, networkFeerate: FeeratePerKw, proposedFeerate: FeeratePerKw): Boolean = {
-    isProposedFeerateTooLow(commitmentFormat, networkFeerate, proposedFeerate) || isProposedFeerateTooHigh(commitmentFormat, networkFeerate, proposedFeerate)
-  }
-
-  def isProposedFeerateTooHigh(commitmentFormat: CommitmentFormat, networkFeerate: FeeratePerKw, proposedFeerate: FeeratePerKw): Boolean = {
-    commitmentFormat match {
-      case Transactions.DefaultCommitmentFormat => networkFeerate * ratioHigh < proposedFeerate
-      case ZeroFeeHtlcTxAnchorOutputsCommitmentFormat | UnsafeLegacyAnchorOutputsCommitmentFormat | PhoenixSimpleTaprootChannelCommitmentFormat | ZeroFeeHtlcTxSimpleTaprootChannelCommitmentFormat => networkFeerate * ratioHigh < proposedFeerate
-    }
-  }
-
-  def isProposedFeerateTooLow(commitmentFormat: CommitmentFormat, networkFeerate: FeeratePerKw, proposedFeerate: FeeratePerKw): Boolean = {
-    commitmentFormat match {
-      case Transactions.DefaultCommitmentFormat => proposedFeerate < networkFeerate * ratioLow
-      // When using anchor outputs, we allow low feerates: fees will be set with CPFP and RBF at broadcast time.
-      case ZeroFeeHtlcTxAnchorOutputsCommitmentFormat | UnsafeLegacyAnchorOutputsCommitmentFormat | PhoenixSimpleTaprootChannelCommitmentFormat | ZeroFeeHtlcTxSimpleTaprootChannelCommitmentFormat => false
-    }
-  }
+  def isProposedCommitFeerateTooHigh(networkFeerate: FeeratePerKw, proposedFeerate: FeeratePerKw): Boolean = networkFeerate * ratioHigh < proposedFeerate
 }
 
 case class OnChainFeeConf(feeTargets: FeeTargets,
@@ -120,7 +102,6 @@ case class OnChainFeeConf(feeTargets: FeeTargets,
     val networkFeerate = feerates.fast
     val networkMinFee = feerates.minimum
     commitmentFormat match {
-      case Transactions.DefaultCommitmentFormat => networkFeerate
       case _: Transactions.AnchorOutputsCommitmentFormat | _: Transactions.SimpleTaprootChannelCommitmentFormat =>
         val targetFeerate = networkFeerate.min(feerateToleranceFor(remoteNodeId).anchorOutputMaxCommitFeerate)
         // We make sure the feerate is always greater than the propagation threshold.