Add support for zero-conf and scid-alias

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

@@ -57,9 +57,13 @@ eclair {
     option_dual_fund = disabled
     option_onion_messages = optional
     option_channel_type = optional
+    option_scid_alias = optional
     option_payment_metadata = optional
-    trampoline_payment_prototype = disabled
+    // By enabling option_zeroconf, you will be trusting your peers as fundee. You will lose funds if they double spend
+    // their funding tx.
+    option_zeroconf = disabled
     keysend = disabled
+    trampoline_payment_prototype = disabled
   }
   override-init-features = [ // optional per-node features
     #  {

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

@@ -36,6 +36,8 @@ case class BlockHeight(private val underlying: Long) extends Ordered[BlockHeight
   def toInt: Int = underlying.toInt
   def toLong: Long = underlying
   def toDouble: Double = underlying.toDouble
+
+  override def toString() = underlying.toString
   // @formatter:on
 }
 

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

@@ -182,14 +182,18 @@ class EclairImpl(appKit: Kit) extends Eclair with Logging {
   override def open(nodeId: PublicKey, fundingAmount: Satoshi, pushAmount_opt: Option[MilliSatoshi], channelType_opt: Option[SupportedChannelType], fundingFeeratePerByte_opt: Option[FeeratePerByte], announceChannel_opt: Option[Boolean], openTimeout_opt: Option[Timeout])(implicit timeout: Timeout): Future[ChannelOpenResponse] = {
     // we want the open timeout to expire *before* the default ask timeout, otherwise user will get a generic response
     val openTimeout = openTimeout_opt.getOrElse(Timeout(20 seconds))
-    (appKit.switchboard ? Peer.OpenChannel(
-      remoteNodeId = nodeId,
-      fundingSatoshis = fundingAmount,
-      pushMsat = pushAmount_opt.getOrElse(0 msat),
-      channelType_opt = channelType_opt,
-      fundingTxFeeratePerKw_opt = fundingFeeratePerByte_opt.map(FeeratePerKw(_)),
-      channelFlags = announceChannel_opt.map(announceChannel => ChannelFlags(announceChannel = announceChannel)),
-      timeout_opt = Some(openTimeout))).mapTo[ChannelOpenResponse]
+    for {
+      _ <- Future.successful(0)
+      open = Peer.OpenChannel(
+        remoteNodeId = nodeId,
+        fundingSatoshis = fundingAmount,
+        pushMsat = pushAmount_opt.getOrElse(0 msat),
+        channelType_opt = channelType_opt,
+        fundingTxFeeratePerKw_opt = fundingFeeratePerByte_opt.map(FeeratePerKw(_)),
+        channelFlags = announceChannel_opt.map(announceChannel => ChannelFlags(announceChannel = announceChannel)),
+        timeout_opt = Some(openTimeout))
+      res <- (appKit.switchboard ? open).mapTo[ChannelOpenResponse]
+    } yield res
   }
 
   override def close(channels: List[ApiTypes.ChannelIdentifier], scriptPubKey_opt: Option[ByteVector], closingFeerates_opt: Option[ClosingFeerates])(implicit timeout: Timeout): Future[Map[ApiTypes.ChannelIdentifier, Either[Throwable, CommandResponse[CMD_CLOSE]]]] = {

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

@@ -240,11 +240,21 @@ object Features {
     val mandatory = 44
   }
 
+  case object ScidAlias extends Feature with InitFeature with NodeFeature with ChannelTypeFeature {
+    val rfcName = "option_scid_alias"
+    val mandatory = 46
+  }
+
   case object PaymentMetadata extends Feature with InvoiceFeature {
     val rfcName = "option_payment_metadata"
     val mandatory = 48
   }
 
+  case object ZeroConf extends Feature with InitFeature with NodeFeature with ChannelTypeFeature {
+    val rfcName = "option_zeroconf"
+    val mandatory = 50
+  }
+
   case object KeySend extends Feature with NodeFeature {
     val rfcName = "keysend"
     val mandatory = 54
@@ -278,9 +288,11 @@ object Features {
     DualFunding,
     OnionMessages,
     ChannelType,
+    ScidAlias,
     PaymentMetadata,
-    TrampolinePaymentPrototype,
-    KeySend
+    ZeroConf,
+    KeySend,
+    TrampolinePaymentPrototype
   )
 
   // Features may depend on other features, as specified in Bolt 9.

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

@@ -16,6 +16,9 @@
 
 package fr.acinq.eclair
 
+trait RealShortChannelId extends ShortChannelId
+trait LocalAlias extends ShortChannelId
+
 /**
  * A short channel id uniquely identifies a channel by the coordinates of its funding tx output in the blockchain.
  * See BOLT 7: https://github.com/lightningnetwork/lightning-rfc/blob/master/07-routing-gossip.md#requirements
@@ -24,6 +27,12 @@ case class ShortChannelId(private val id: Long) extends Ordered[ShortChannelId]
 
   def toLong: Long = id
 
+  /** Careful: only call this if you are sure that this scid is actually a real scid */
+  def toReal: RealShortChannelId = new ShortChannelId(id) with RealShortChannelId
+
+  /** Careful: only call this if you are sure that this scid is actually a local alias */
+  def toAlias: LocalAlias = new ShortChannelId(id) with LocalAlias
+
   def blockHeight = ShortChannelId.blockHeight(this)
 
   override def toString: String = {
@@ -42,7 +51,7 @@ object ShortChannelId {
     case _ => throw new IllegalArgumentException(s"Invalid short channel id: $s")
   }
 
-  def apply(blockHeight: BlockHeight, txIndex: Int, outputIndex: Int): ShortChannelId = ShortChannelId(toShortId(blockHeight.toInt, txIndex, outputIndex))
+  def apply(blockHeight: BlockHeight, txIndex: Int, outputIndex: Int): RealShortChannelId = ShortChannelId(toShortId(blockHeight.toInt, txIndex, outputIndex)).toReal
 
   def toShortId(blockHeight: Int, txIndex: Int, outputIndex: Int): Long = ((blockHeight & 0xFFFFFFL) << 40) | ((txIndex & 0xFFFFFFL) << 16) | (outputIndex & 0xFFFFL)
 
@@ -56,6 +65,8 @@ object ShortChannelId {
   def outputIndex(shortChannelId: ShortChannelId): Int = (shortChannelId.id & 0xFFFF).toInt
 
   def coordinates(shortChannelId: ShortChannelId): TxCoordinates = TxCoordinates(blockHeight(shortChannelId), txIndex(shortChannelId), outputIndex(shortChannelId))
+
+  def generateLocalAlias(): LocalAlias = new ShortChannelId(System.nanoTime()) with LocalAlias // TODO: fixme (duplicate, etc.)
 }
 
 case class TxCoordinates(blockHeight: BlockHeight, txIndex: Int, outputIndex: Int)

eclair-core/src/main/scala/fr/acinq/eclair/balance/BalanceActor.scala

@@ -105,7 +105,7 @@ private class BalanceActor(context: ActorContext[Command],
           Metrics.GlobalBalanceDetailed.withTag(Tags.BalanceType, Tags.BalanceTypes.OnchainConfirmed).update(result.onChain.confirmed.toMilliBtc.toDouble)
           Metrics.GlobalBalanceDetailed.withTag(Tags.BalanceType, Tags.BalanceTypes.OnchainUnconfirmed).update(result.onChain.unconfirmed.toMilliBtc.toDouble)
           Metrics.GlobalBalanceDetailed.withTag(Tags.BalanceType, Tags.BalanceTypes.Offchain).withTag(Tags.OffchainState, Tags.OffchainStates.waitForFundingConfirmed).update(result.offChain.waitForFundingConfirmed.toMilliBtc.toDouble)
-          Metrics.GlobalBalanceDetailed.withTag(Tags.BalanceType, Tags.BalanceTypes.Offchain).withTag(Tags.OffchainState, Tags.OffchainStates.waitForFundingLocked).update(result.offChain.waitForFundingLocked.toMilliBtc.toDouble)
+          Metrics.GlobalBalanceDetailed.withTag(Tags.BalanceType, Tags.BalanceTypes.Offchain).withTag(Tags.OffchainState, Tags.OffchainStates.waitForChannelReady).update(result.offChain.waitForChannelReady.toMilliBtc.toDouble)
           Metrics.GlobalBalanceDetailed.withTag(Tags.BalanceType, Tags.BalanceTypes.Offchain).withTag(Tags.OffchainState, Tags.OffchainStates.normal).update(result.offChain.normal.total.toMilliBtc.toDouble)
           Metrics.GlobalBalanceDetailed.withTag(Tags.BalanceType, Tags.BalanceTypes.Offchain).withTag(Tags.OffchainState, Tags.OffchainStates.shutdown).update(result.offChain.shutdown.total.toMilliBtc.toDouble)
           Metrics.GlobalBalanceDetailed.withTag(Tags.BalanceType, Tags.BalanceTypes.Offchain).withTag(Tags.OffchainState, Tags.OffchainStates.closingLocal).update(result.offChain.closing.localCloseBalance.total.toMilliBtc.toDouble)

eclair-core/src/main/scala/fr/acinq/eclair/balance/CheckBalance.scala

@@ -77,13 +77,13 @@ object CheckBalance {
    * The overall balance among all channels in all states.
    */
   case class OffChainBalance(waitForFundingConfirmed: Btc = 0.sat,
-                             waitForFundingLocked: Btc = 0.sat,
+                             waitForChannelReady: Btc = 0.sat,
                              normal: MainAndHtlcBalance = MainAndHtlcBalance(),
                              shutdown: MainAndHtlcBalance = MainAndHtlcBalance(),
                              negotiating: Btc = 0.sat,
                              closing: ClosingBalance = ClosingBalance(),
                              waitForPublishFutureCommitment: Btc = 0.sat) {
-    val total: Btc = waitForFundingConfirmed + waitForFundingLocked + normal.total + shutdown.total + negotiating + closing.total + waitForPublishFutureCommitment
+    val total: Btc = waitForFundingConfirmed + waitForChannelReady + normal.total + shutdown.total + negotiating + closing.total + waitForPublishFutureCommitment
   }
 
   def updateMainBalance(localCommit: LocalCommit): Btc => Btc = { v: Btc =>
@@ -201,7 +201,7 @@ object CheckBalance {
     channels
       .foldLeft(OffChainBalance()) {
         case (r, d: DATA_WAIT_FOR_FUNDING_CONFIRMED) => r.modify(_.waitForFundingConfirmed).using(updateMainBalance(d.commitments.localCommit))
-        case (r, d: DATA_WAIT_FOR_FUNDING_LOCKED) => r.modify(_.waitForFundingLocked).using(updateMainBalance(d.commitments.localCommit))
+        case (r, d: DATA_WAIT_FOR_CHANNEL_READY) => r.modify(_.waitForChannelReady).using(updateMainBalance(d.commitments.localCommit))
         case (r, d: DATA_NORMAL) => r.modify(_.normal).using(updateMainAndHtlcBalance(d.commitments, knownPreimages))
         case (r, d: DATA_SHUTDOWN) => r.modify(_.shutdown).using(updateMainAndHtlcBalance(d.commitments, knownPreimages))
         case (r, d: DATA_NEGOTIATING) => r.modify(_.negotiating).using(updateMainBalance(d.commitments.localCommit))

eclair-core/src/main/scala/fr/acinq/eclair/balance/Monitoring.scala

@@ -44,7 +44,7 @@ object Monitoring {
 
     object OffchainStates {
       val waitForFundingConfirmed = "waitForFundingConfirmed"
-      val waitForFundingLocked = "waitForFundingLocked"
+      val waitForChannelReady = "waitForChannelReady"
       val normal = "normal"
       val shutdown = "shutdown"
       val negotiating = "negotiating"

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

@@ -20,6 +20,7 @@ import akka.actor.typed.eventstream.EventStream
 import akka.actor.typed.scaladsl.{ActorContext, Behaviors, TimerScheduler}
 import akka.actor.typed.{ActorRef, Behavior, SupervisorStrategy}
 import fr.acinq.bitcoin.scalacompat._
+import fr.acinq.eclair.RealShortChannelId
 import fr.acinq.eclair.blockchain.Monitoring.Metrics
 import fr.acinq.eclair.blockchain._
 import fr.acinq.eclair.blockchain.bitcoind.rpc.BitcoinCoreClient
@@ -30,7 +31,7 @@ import fr.acinq.eclair.{BlockHeight, KamonExt, NodeParams, ShortChannelId, Times
 import java.util.concurrent.atomic.AtomicLong
 import scala.concurrent.duration._
 import scala.concurrent.{ExecutionContext, Future}
-import scala.util.{Failure, Success}
+import scala.util.{Failure, Random, Success}
 
 /**
  * Created by PM on 21/02/2016.
@@ -136,8 +137,8 @@ object ZmqWatcher {
   /** This event is sent when a [[WatchSpentBasic]] condition is met. */
   sealed trait WatchSpentBasicTriggered extends WatchTriggered
 
-  case class WatchExternalChannelSpent(replyTo: ActorRef[WatchExternalChannelSpentTriggered], txId: ByteVector32, outputIndex: Int, shortChannelId: ShortChannelId) extends WatchSpentBasic[WatchExternalChannelSpentTriggered]
-  case class WatchExternalChannelSpentTriggered(shortChannelId: ShortChannelId) extends WatchSpentBasicTriggered
+  case class WatchExternalChannelSpent(replyTo: ActorRef[WatchExternalChannelSpentTriggered], txId: ByteVector32, outputIndex: Int, shortChannelId: RealShortChannelId) extends WatchSpentBasic[WatchExternalChannelSpentTriggered]
+  case class WatchExternalChannelSpentTriggered(shortChannelId: RealShortChannelId) extends WatchSpentBasicTriggered
 
   case class WatchFundingSpent(replyTo: ActorRef[WatchFundingSpentTriggered], txId: ByteVector32, outputIndex: Int, hints: Set[ByteVector32]) extends WatchSpent[WatchFundingSpentTriggered]
   case class WatchFundingSpentTriggered(spendingTx: Transaction) extends WatchSpentTriggered
@@ -236,6 +237,11 @@ private class ZmqWatcher(nodeParams: NodeParams, blockHeight: AtomicLong, client
             case _: WatchConfirmed[_] => // nothing to do
             case _: WatchFundingLost => // nothing to do
           }
+        watches
+          .collect {
+            case w: WatchFundingConfirmed if w.minDepth == 0 && w.txId == tx.txid =>
+              checkConfirmed(w)
+          }
         Behaviors.same
 
       case ProcessNewBlock(blockHash) =>
@@ -406,13 +412,21 @@ private class ZmqWatcher(nodeParams: NodeParams, blockHeight: AtomicLong, client
     client.getTxConfirmations(w.txId).flatMap {
       case Some(confirmations) if confirmations >= w.minDepth =>
         client.getTransaction(w.txId).flatMap { tx =>
-          client.getTransactionShortId(w.txId).map {
-            case (height, index) => w match {
-              case w: WatchFundingConfirmed => context.self ! TriggerEvent(w.replyTo, w, WatchFundingConfirmedTriggered(height, index, tx))
-              case w: WatchFundingDeeplyBuried => context.self ! TriggerEvent(w.replyTo, w, WatchFundingDeeplyBuriedTriggered(height, index, tx))
-              case w: WatchTxConfirmed => context.self ! TriggerEvent(w.replyTo, w, WatchTxConfirmedTriggered(height, index, tx))
-              case w: WatchParentTxConfirmed => context.self ! TriggerEvent(w.replyTo, w, WatchParentTxConfirmedTriggered(height, index, tx))
-            }
+          w match {
+            case w: WatchFundingConfirmed if confirmations == 0 =>
+              // if the tx doesn't have confirmations but we don't require any, we reply with a fake block index
+              // otherwise, we get the real short id
+              context.self ! TriggerEvent(w.replyTo, w, WatchFundingConfirmedTriggered(BlockHeight(0), 0, tx))
+              Future.successful((): Unit)
+            case _ =>
+              client.getTransactionShortId(w.txId).map {
+                case (height, index) => w match {
+                  case w: WatchFundingConfirmed => context.self ! TriggerEvent(w.replyTo, w, WatchFundingConfirmedTriggered(height, index, tx))
+                  case w: WatchFundingDeeplyBuried => context.self ! TriggerEvent(w.replyTo, w, WatchFundingDeeplyBuriedTriggered(height, index, tx))
+                  case w: WatchTxConfirmed => context.self ! TriggerEvent(w.replyTo, w, WatchTxConfirmedTriggered(height, index, tx))
+                  case w: WatchParentTxConfirmed => context.self ! TriggerEvent(w.replyTo, w, WatchParentTxConfirmedTriggered(height, index, tx))
+                }
+              }
           }
         }
       case _ => Future.successful((): Unit)

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

@@ -49,7 +49,7 @@ case class FeerateTolerance(ratioLow: Double, ratioHigh: Double, anchorOutputMax
     channelType match {
       case ChannelTypes.Standard | ChannelTypes.StaticRemoteKey =>
         proposedFeerate < networkFeerate * ratioLow || networkFeerate * ratioHigh < proposedFeerate
-      case ChannelTypes.AnchorOutputs | ChannelTypes.AnchorOutputsZeroFeeHtlcTx =>
+      case ChannelTypes.AnchorOutputs | _: ChannelTypes.AnchorOutputsZeroFeeHtlcTx =>
         // when using anchor outputs, we allow any feerate: fees will be set with CPFP and RBF at broadcast time
         false
     }

eclair-core/src/main/scala/fr/acinq/eclair/blockchain/watchdogs/BlockchainWatchdog.scala

@@ -104,10 +104,10 @@ object BlockchainWatchdog {
           case CheckLatestHeaders(blockHeight) =>
             val id = UUID.randomUUID()
             if (headersOverDnsEnabled) {
-              context.spawn(HeadersOverDns(nodeParams.chainHash, blockHeight), s"${HeadersOverDns.Source}-${blockHeight.toLong}-$id") ! HeadersOverDns.CheckLatestHeaders(context.self)
+              context.spawn(HeadersOverDns(nodeParams.chainHash, blockHeight), s"${HeadersOverDns.Source}-${blockHeight}-$id") ! HeadersOverDns.CheckLatestHeaders(context.self)
             }
             explorers.foreach { explorer =>
-              context.spawn(ExplorerApi(nodeParams.chainHash, blockHeight, explorer), s"${explorer.name}-${blockHeight.toLong}-$id") ! ExplorerApi.CheckLatestHeaders(context.self)
+              context.spawn(ExplorerApi(nodeParams.chainHash, blockHeight, explorer), s"${explorer.name}-${blockHeight}-$id") ! ExplorerApi.CheckLatestHeaders(context.self)
             }
             Behaviors.same
           case headers@LatestHeaders(blockHeight, blockHeaders, source) =>