Implement dual funding (#368)

In this PR, we change the funding flow to use dual-funding
(see spec here: lightning/bolts#851)
We completely remove the previous funding flow, as dual
funding is a super-set of it.

A few notes:

- we implicitly move existing channels to use a 1% reserve
  (for the side that does have a reserve): this is ok since this
  is already the setting used by Phoenix
- we support restoring unconfirmed channels that used the
  single-funded flow: there won't be any backwards compat
  issue for existing users
- we change the zero-conf behavior to directly go to the
  WaitingForFundingLocked state without using a hacky
  depth-0 watch
- we currently don't detect when an unconfirmed channel
  will never confirm because the funding candidates have
  been double-spent: such channels will stay stuck in the
  WaitingForFundingConfirmed state

Author: ebonyschneider462359

src/commonMain/kotlin/fr/acinq/lightning/Features.kt

@@ -112,6 +112,13 @@ sealed class Feature {
         override val scopes: Set<FeatureScope> get() = setOf(FeatureScope.Init, FeatureScope.Node)
     }
 
+    @Serializable
+    object DualFunding : Feature() {
+        override val rfcName get() = "option_dual_fund"
+        override val mandatory get() = 28
+        override val scopes: Set<FeatureScope> get() = setOf(FeatureScope.Init, FeatureScope.Node)
+    }
+
     @Serializable
     object ChannelType : Feature() {
         override val rfcName get() = "option_channel_type"
@@ -290,6 +297,7 @@ data class Features(val activated: Map<Feature, FeatureSupport>, val unknown: Se
             Feature.Wumbo,
             Feature.AnchorOutputs,
             Feature.ShutdownAnySegwit,
+            Feature.DualFunding,
             Feature.ChannelType,
             Feature.PaymentMetadata,
             Feature.TrampolinePayment,

src/commonMain/kotlin/fr/acinq/lightning/NodeParams.kt

@@ -56,8 +56,6 @@ data class WalletParams(
  * @param minDepthBlocks minimum depth of a transaction before we consider it safely confirmed.
  * @param feeBase base fee used in our channel_update: since our channels are private and we don't relay payments, this will be basically ignored.
  * @param feeProportionalMillionth proportional fee used in our channel_update: since our channels are private and we don't relay payments, this will be basically ignored.
- * @param reserveToFundingRatio size of the channel reserve we required from our peer.
- * @param maxReserveToFundingRatio maximum size of the channel reserve our peer can require from us.
  * @param revocationTimeoutSeconds delay after which we disconnect from our peer if they don't send us a revocation after a new commitment is signed.
  * @param authTimeoutSeconds timeout for the connection authentication phase.
  * @param initTimeoutSeconds timeout for the connection initialization phase.
@@ -95,8 +93,6 @@ data class NodeParams(
     val minDepthBlocks: Int,
     val feeBase: MilliSatoshi,
     val feeProportionalMillionth: Int,
-    val reserveToFundingRatio: Double,
-    val maxReserveToFundingRatio: Double,
     val revocationTimeoutSeconds: Long,
     val authTimeoutSeconds: Long,
     val initTimeoutSeconds: Long,
@@ -122,6 +118,7 @@ data class NodeParams(
         require(features.hasFeature(Feature.VariableLengthOnion, FeatureSupport.Mandatory)) { "${Feature.VariableLengthOnion.rfcName} should be mandatory" }
         require(features.hasFeature(Feature.PaymentSecret, FeatureSupport.Mandatory)) { "${Feature.PaymentSecret.rfcName} should be mandatory" }
         require(features.hasFeature(Feature.ChannelType, FeatureSupport.Mandatory)) { "${Feature.ChannelType.rfcName} should be mandatory" }
+        require(features.hasFeature(Feature.DualFunding, FeatureSupport.Mandatory)) { "${Feature.DualFunding.rfcName} should be mandatory" }
         Features.validateFeatureGraph(features)
     }
 }

src/commonMain/kotlin/fr/acinq/lightning/blockchain/WatcherTypes.kt

@@ -1,21 +1,15 @@
 package fr.acinq.lightning.blockchain
 
 import fr.acinq.bitcoin.*
-import fr.acinq.lightning.ShortChannelId
 import fr.acinq.lightning.utils.Try
 import fr.acinq.lightning.utils.runTrying
-import kotlinx.coroutines.CompletableDeferred
 
 sealed class BitcoinEvent
-object BITCOIN_FUNDING_PUBLISH_FAILED : BitcoinEvent()
 object BITCOIN_FUNDING_DEPTHOK : BitcoinEvent()
 object BITCOIN_FUNDING_DEEPLYBURIED : BitcoinEvent()
-object BITCOIN_FUNDING_LOST : BitcoinEvent()
-object BITCOIN_FUNDING_TIMEOUT : BitcoinEvent()
 object BITCOIN_FUNDING_SPENT : BitcoinEvent()
 object BITCOIN_OUTPUT_SPENT : BitcoinEvent()
 data class BITCOIN_TX_CONFIRMED(val tx: Transaction) : BitcoinEvent()
-data class BITCOIN_FUNDING_EXTERNAL_CHANNEL_SPENT(val shortChannelId: ShortChannelId) : BitcoinEvent()
 data class BITCOIN_PARENT_TX_CONFIRMED(val childTx: Transaction) : BitcoinEvent()
 
 /**
@@ -45,6 +39,10 @@ data class WatchConfirmed(
         event
     )
 
+    init {
+        require(minDepth > 0) { "minimum depth must be greater than 0 when watching transaction confirmation" }
+    }
+
     companion object {
         fun extractPublicKeyScript(witness: ScriptWitness): ByteVector {
             val result = runTrying {
@@ -75,8 +73,6 @@ data class WatchSpent(
     )
 }
 
-data class WatchLost(override val channelId: ByteVector32, val txId: ByteVector32, val minDepth: Long, override val event: BitcoinEvent) : Watch()
-
 /**
  * generic "watch" event
  */
@@ -87,8 +83,6 @@ sealed class WatchEvent {
 
 data class WatchEventConfirmed(override val channelId: ByteVector32, override val event: BitcoinEvent, val blockHeight: Int, val txIndex: Int, val tx: Transaction) : WatchEvent()
 data class WatchEventSpent(override val channelId: ByteVector32, override val event: BitcoinEvent, val tx: Transaction) : WatchEvent()
-data class WatchEventSpentBasic(override val channelId: ByteVector32, override val event: BitcoinEvent) : WatchEvent()
-data class WatchEventLost(override val channelId: ByteVector32, override val event: BitcoinEvent) : WatchEvent()
 
 data class PublishAsap(val tx: Transaction)
 data class GetTxWithMeta(val channelId: ByteVector32, val txid: ByteVector32)

src/commonMain/kotlin/fr/acinq/lightning/blockchain/electrum/ElectrumMiniWallet.kt

@@ -5,7 +5,10 @@ import fr.acinq.lightning.utils.Connection
 import fr.acinq.lightning.utils.sat
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.consumeAsFlow
+import kotlinx.coroutines.flow.filterIsInstance
 import kotlinx.coroutines.launch
 import org.kodein.log.LoggerFactory
 import org.kodein.log.newLogger
@@ -30,38 +33,39 @@ data class WalletState(val addresses: Map<String, List<UnspentItem>>, val privat
     private val outPoint2Address = addresses.entries.flatMap { entry -> entry.value.map { it.outPoint to entry.key } }.toMap()
 
     /** Sign the inputs owned by this wallet (only works for P2WPKH scripts) */
-    fun sign(tx: Transaction): Transaction {
-        return tx.txIn.foldIndexed(tx) { index, wipTx, txIn ->
-            val witness = outPoint2Address[txIn.outPoint]?.let { address ->
-                addresses[address]?.find { it.outPoint == txIn.outPoint }?.let { utxo ->
-                    privateKeys[address]?.let { privateKey ->
-                        // mind this: the pubkey script used for signing is not the prevout pubscript (which is just a push
-                        // of the pubkey hash), but the actual script that is evaluated by the script engine, in this case a PAY2PKH script
-                        val publicKey = privateKey.publicKey()
-                        val pubKeyScript = Script.pay2pkh(publicKey)
-                        val sig = Transaction.signInput(
-                            tx,
-                            index,
-                            pubKeyScript,
-                            SigHash.SIGHASH_ALL,
-                            utxo.value.sat,
-                            SigVersion.SIGVERSION_WITNESS_V0,
-                            privateKey
-                        )
-                        Script.witnessPay2wpkh(publicKey, sig.byteVector())
-                    }
+    fun sign(tx: Transaction): Transaction = tx.txIn.foldIndexed(tx) { index, wipTx, _ -> signInput(wipTx, index).first }
+
+    fun signInput(tx: Transaction, index: Int): Pair<Transaction, ScriptWitness?> {
+        val txIn = tx.txIn[index]
+        val witness = outPoint2Address[txIn.outPoint]?.let { address ->
+            addresses[address]?.find { it.outPoint == txIn.outPoint }?.let { utxo ->
+                privateKeys[address]?.let { privateKey ->
+                    // mind this: the pubkey script used for signing is not the prevout pubscript (which is just a push
+                    // of the pubkey hash), but the actual script that is evaluated by the script engine, in this case a PAY2PKH script
+                    val publicKey = privateKey.publicKey()
+                    val pubKeyScript = Script.pay2pkh(publicKey)
+                    val sig = Transaction.signInput(
+                        tx,
+                        index,
+                        pubKeyScript,
+                        SigHash.SIGHASH_ALL,
+                        utxo.value.sat,
+                        SigVersion.SIGVERSION_WITNESS_V0,
+                        privateKey
+                    )
+                    Script.witnessPay2wpkh(publicKey, sig.byteVector())
                 }
             }
-            when (witness) {
-                is ScriptWitness ->
-                    // update the signature for the corresponding input
-                    wipTx.updateWitness(index, witness)
-                else ->
-                    // we don't know how to sign this input
-                    wipTx
-            }
+        }
+        return when (witness) {
+            is ScriptWitness -> Pair(tx.updateWitness(index, witness), witness)
+            else -> Pair(tx, null)
         }
     }
+
+    companion object {
+        val empty: WalletState = WalletState(mapOf(), mapOf(), mapOf())
+    }
 }
 
 private sealed interface WalletCommand {
@@ -72,7 +76,6 @@ private sealed interface WalletCommand {
     }
 }
 
-
 /**
  * A very simple wallet that only watches one address and publishes its utxos.
  */

src/commonMain/kotlin/fr/acinq/lightning/blockchain/electrum/ElectrumWatcher.kt

@@ -4,10 +4,8 @@ import fr.acinq.bitcoin.BlockHeader
 import fr.acinq.bitcoin.ByteVector32
 import fr.acinq.bitcoin.Transaction
 import fr.acinq.bitcoin.TxIn
-import fr.acinq.bitcoin.crypto.Pack
 import fr.acinq.lightning.blockchain.*
 import fr.acinq.lightning.blockchain.electrum.ElectrumClient.Companion.computeScriptHash
-import fr.acinq.lightning.blockchain.electrum.ElectrumWatcher.Companion.makeDummyShortChannelId
 import fr.acinq.lightning.blockchain.electrum.ElectrumWatcher.Companion.registerToScriptHash
 import fr.acinq.lightning.transactions.Scripts
 import fr.acinq.lightning.utils.Connection
@@ -21,7 +19,6 @@ import kotlinx.coroutines.flow.*
 import org.kodein.log.Logger
 import org.kodein.log.LoggerFactory
 import org.kodein.log.newLogger
-import kotlin.math.absoluteValue
 import kotlin.math.max
 
 sealed class WatcherEvent
@@ -85,7 +82,7 @@ private data class WatcherDisconnected(
                 is HeaderSubscriptionResponse -> {
                     newState {
                         actions = buildList {
-                            watches.mapNotNull { registerToScriptHash(it, logger) }.forEach { add(it) }
+                            watches.map { registerToScriptHash(it, logger) }.forEach { add(it) }
                             publishQueue.forEach { add(PublishAsapAction(it.tx)) }
                             getTxQueue.forEach { add(AskForTransaction(it.txid, it.channelId)) }
                         }
@@ -194,9 +191,7 @@ internal data class WatcherRunning(
                                             .filter { it.txId == outPoint.txid && it.outputIndex == outPoint.index.toInt() }
                                             .map { w ->
                                                 logger.info { "output ${w.txId}:${w.outputIndex} spent by transaction ${tx.txid}" }
-                                                NotifyWatch(
-                                                    WatchEventSpent(w.channelId, w.event, tx)
-                                                )
+                                                NotifyWatch(WatchEventSpent(w.channelId, w.event, tx))
                                             }
                                     }
 
@@ -207,37 +202,20 @@ internal data class WatcherRunning(
                                 watches.filterIsInstance<WatchConfirmed>()
                                     .filter { it.txId == tx.txid }
                                     .forEach { w ->
-                                        if (w.event is BITCOIN_FUNDING_DEPTHOK && w.minDepth == 0L) {
-                                            // special case for mempool watches (min depth = 0)
-                                            val (dummyHeight, dummyTxIndex) = makeDummyShortChannelId(w.txId)
-                                            notifyWatchConfirmedList.add(
-                                                NotifyWatch(
-                                                    watchEvent = WatchEventConfirmed(
-                                                        w.channelId,
-                                                        BITCOIN_FUNDING_DEPTHOK,
-                                                        dummyHeight,
-                                                        dummyTxIndex,
-                                                        tx
-                                                    ),
-                                                    broadcastNotification = w.channelNotification
-                                                )
-                                            )
-                                            watchConfirmedTriggered.add(w)
-                                        } else if (w.minDepth > 0L && item.blockHeight > 0) {
-                                            val txHeight = item.blockHeight
-                                            val confirmations = height - txHeight + 1
-                                            logger.info { "txid=${w.txId} was confirmed at height=$txHeight and now has confirmations=$confirmations (currentHeight=$height)" }
+                                        if (item.blockHeight > 0) {
+                                            val confirmations = height - item.blockHeight + 1
+                                            logger.info { "txid=${w.txId} was confirmed at blockHeight=${item.blockHeight} and now has confirmations=$confirmations (currentHeight=$height)" }
                                             if (confirmations >= w.minDepth) {
                                                 // we need to get the tx position in the block
-                                                getMerkleList.add(AskForMerkle(w.txId, txHeight, tx))
+                                                getMerkleList.add(AskForMerkle(w.txId, item.blockHeight, tx))
                                             }
                                         }
                                     }
 
                                 newState {
                                     // NB: WatchSpent are permanent because we need to detect multiple spending of the funding tx
                                     // They are never cleaned up but it is not a big deal for now (1 channel == 1 watch)
-                                    state = copy(watches = watches - watchConfirmedTriggered)
+                                    state = copy(watches = watches - watchConfirmedTriggered.toSet())
                                     actions = notifyWatchSpentList + notifyWatchConfirmedList + getMerkleList
                                 }
                             }
@@ -279,7 +257,7 @@ internal data class WatcherRunning(
                         } ?: emptyList()
 
                         newState {
-                            state = copy(watches = watches - triggered)
+                            state = copy(watches = watches - triggered.toSet())
                             actions = notifyWatchConfirmedList
                         }
                     }
@@ -364,27 +342,22 @@ internal data class WatcherRunning(
         }
 
     private fun setupWatch(watch: Watch, logger: Logger) = when (watch) {
-        is WatchLost -> returnState() // ignore WatchLost for now
         in watches -> returnState()
         else -> {
             val action = registerToScriptHash(watch, logger)
             newState {
                 state = copy(
                     watches = watches + watch,
-                    scriptHashSubscriptions = action?.let {
-                        scriptHashSubscriptions + it.scriptHash
-                    } ?: scriptHashSubscriptions
+                    scriptHashSubscriptions = scriptHashSubscriptions + action.scriptHash
                 )
-                actions = action?.let {
-                    if (scriptHashSubscriptions.contains(it.scriptHash)) {
-                        // We've already registered to subscriptions from this scriptHash.
-                        // Both WatchSpent & WatchConfirmed can be translated into the exact same
-                        // electrum request, so we filter the duplicates here.
-                        actions
-                    } else {
-                        actions + it
-                    }
-                } ?: actions
+                actions = if (scriptHashSubscriptions.contains(action.scriptHash)) {
+                    // We've already registered to subscriptions from this scriptHash.
+                    // Both WatchSpent & WatchConfirmed can be translated into the exact same
+                    // electrum request, so we filter the duplicates here.
+                    actions
+                } else {
+                    actions + action
+                }
             }
         }
     }
@@ -532,7 +505,7 @@ class ElectrumWatcher(
         timerJob = null
     }
 
-    private suspend fun checkIsUpToDate(): Unit {
+    private suspend fun checkIsUpToDate() {
 
         // Get a list of timestamps from the client for all outgoing requests.
         // This returns an array of `RequestResponseTimestamp` instances, which includes:
@@ -609,7 +582,7 @@ class ElectrumWatcher(
 
     companion object {
 
-        internal fun registerToScriptHash(watch: Watch, logger: Logger): RegisterToScriptHashNotification? = when (watch) {
+        internal fun registerToScriptHash(watch: Watch, logger: Logger): RegisterToScriptHashNotification = when (watch) {
             is WatchSpent -> {
                 val (_, txid, outputIndex, publicKeyScript, _) = watch
                 val scriptHash = computeScriptHash(publicKeyScript)
@@ -622,20 +595,6 @@ class ElectrumWatcher(
                 logger.info { "added watch-confirmed on txid=$txid scriptHash=$scriptHash" }
                 RegisterToScriptHashNotification(scriptHash)
             }
-            else -> null
-        }
-
-        internal fun makeDummyShortChannelId(txid: ByteVector32): Pair<Int, Int> {
-            // we use a height of 0
-            // - to make sure that the tx will be marked as "confirmed"
-            // - to easily identify scids linked to 0-conf channels
-            //
-            // this gives us a probability of collisions of 0.1% for 5 0-conf channels and 1% for 20
-            // collisions mean that users may temporarily see incorrect numbers for their 0-conf channels (until they've been confirmed)
-            // if this ever becomes a problem we could just extract some bits for our dummy height instead of just returning 0
-            val height = 0
-            val txIndex = Pack.int32BE(txid.slice(0, 16).toByteArray()).absoluteValue
-            return height to txIndex
         }
     }
 }

src/commonMain/kotlin/fr/acinq/lightning/blockchain/fee/FeeEstimator.kt

@@ -25,6 +25,8 @@ data class OnChainFeeConf(val closeOnOfflineMismatch: Boolean, val updateFeeMinD
 /** Fee rate in satoshi-per-bytes. */
 data class FeeratePerByte(val feerate: Satoshi) {
     constructor(feeratePerKw: FeeratePerKw) : this(FeeratePerKB(feeratePerKw).feerate / 1000)
+
+    override fun toString(): String = "$feerate/byte"
 }
 
 /** Fee rate in satoshi-per-kilo-bytes (1 kB = 1000 bytes). */
@@ -36,6 +38,8 @@ data class FeeratePerKB(val feerate: Satoshi) : Comparable<FeeratePerKB> {
     fun max(other: FeeratePerKB): FeeratePerKB = if (this > other) this else other
     fun min(other: FeeratePerKB): FeeratePerKB = if (this < other) this else other
     fun toLong(): Long = feerate.toLong()
+
+    override fun toString(): String = "$feerate/kB"
 }
 
 @Serializable
@@ -53,6 +57,8 @@ data class FeeratePerKw(@Contextual val feerate: Satoshi) : Comparable<FeeratePe
     operator fun div(l: Long): FeeratePerKw = FeeratePerKw(feerate / l)
     fun toLong(): Long = feerate.toLong()
 
+    override fun toString(): String = "$feerate/kw"
+
     companion object {
         /**
          * Minimum relay fee rate in satoshi per kilo-vbyte (taken from Bitcoin Core).