Allow force-closing in Syncing and Offline states (#223)

It makes sense to allow users to force-close channels that may be stuck in
syncing or offline.

Fixes #216

Author: t-bast

src/commonMain/kotlin/fr/acinq/eclair/channel/Channel.kt

@@ -749,6 +749,15 @@ data class Offline(val state: ChannelStateWithCommitments) : ChannelState() {
                     else -> Pair(Offline(newState as ChannelStateWithCommitments), actions)
                 }
             }
+            event is ChannelEvent.ExecuteCommand && event.command is CMD_FORCECLOSE -> {
+                val (newState, actions) = state.process(event)
+                when (newState) {
+                    // NB: it doesn't make sense to try to send outgoing messages if we're offline.
+                    is Closing -> Pair(newState, actions.filterNot { it is ChannelAction.Message.Send })
+                    is Closed -> Pair(newState, actions.filterNot { it is ChannelAction.Message.Send })
+                    else -> Pair(Offline(newState as ChannelStateWithCommitments), actions)
+                }
+            }
             else -> unhandled(event)
         }
     }
@@ -1011,6 +1020,14 @@ data class Syncing(val state: ChannelStateWithCommitments, val waitForTheirReest
                 }
             }
             event is ChannelEvent.Disconnected -> Pair(Offline(state), listOf())
+            event is ChannelEvent.ExecuteCommand && event.command is CMD_FORCECLOSE -> {
+                val (newState, actions) = state.process(event)
+                when (newState) {
+                    is Closing -> Pair(newState, actions)
+                    is Closed -> Pair(newState, actions)
+                    else -> Pair(Syncing(newState as ChannelStateWithCommitments, waitForTheirReestablishMessage), actions)
+                }
+            }
             else -> unhandled(event)
         }
     }

src/commonTest/kotlin/fr/acinq/eclair/channel/states/OfflineTestsCommon.kt

@@ -504,6 +504,18 @@ class OfflineTestsCommon : EclairTestSuite() {
         assertEquals(watchSpent, actions4.findWatches<WatchSpent>().map { OutPoint(lcp.commitTx, it.outputIndex.toLong()) }.toSet())
     }
 
+    @Test
+    fun `recv CMD_FORCECLOSE`() {
+        val (alice, _) = TestsHelper.reachNormal()
+        val (alice1, _) = alice.processEx(ChannelEvent.Disconnected)
+        assertTrue(alice1 is Offline)
+        val commitTx = alice1.state.commitments.localCommit.publishableTxs.commitTx.tx
+        val (alice2, actions2) = alice1.process(ChannelEvent.ExecuteCommand(CMD_FORCECLOSE))
+        assertTrue(alice2 is Closing)
+        actions2.hasTx(commitTx)
+        assertNull(actions2.findOutgoingMessageOpt<Error>()) // we're offline so we shouldn't try to send messages
+    }
+
     @Test
     fun `restore closing channel`() {
         val bob = run {

src/commonTest/kotlin/fr/acinq/eclair/channel/states/SyncingTestsCommon.kt

@@ -1,6 +1,5 @@
 package fr.acinq.eclair.channel.states
 
-import fr.acinq.bitcoin.Block
 import fr.acinq.bitcoin.ByteVector
 import fr.acinq.bitcoin.ScriptFlags
 import fr.acinq.bitcoin.Transaction
@@ -14,9 +13,11 @@ import fr.acinq.eclair.tests.TestConstants
 import fr.acinq.eclair.tests.utils.EclairTestSuite
 import fr.acinq.eclair.utils.msat
 import fr.acinq.eclair.wire.ChannelReestablish
+import fr.acinq.eclair.wire.Error
 import fr.acinq.eclair.wire.Init
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertNull
 import kotlin.test.assertTrue
 
 class SyncingTestsCommon : EclairTestSuite() {
@@ -58,6 +59,17 @@ class SyncingTestsCommon : EclairTestSuite() {
         assertEquals(watches.map { it.txId }.toSet(), setOf(revokedTx.txid, bob1.revokedCommitPublished.first().claimMainOutputTx!!.txid))
     }
 
+    @Test
+    fun `recv CMD_FORCECLOSE`() {
+        val (alice, _, _) = run {
+            val (alice, bob) = reachNormal()
+            disconnect(alice, bob)
+        }
+        val (alice1, actions1) = alice.process(ChannelEvent.ExecuteCommand(CMD_FORCECLOSE))
+        assertTrue(alice1 is Closing)
+        actions1.hasOutgoingMessage<Error>()
+    }
+
     companion object {
         fun disconnect(alice: Normal, bob: Normal): Triple<Syncing, Syncing, Pair<ChannelReestablish, ChannelReestablish>> {
             val (alice1, _) = alice.processEx(ChannelEvent.Disconnected)