From dceb6b9b068ef2b99dccbd3ee1a76a7b3351ac9f Mon Sep 17 00:00:00 2001
From: Pierre-Marie Padiou <pm47@users.noreply.github.com>
Date: Thu, 15 Mar 2018 18:53:14 +0100
Subject: [PATCH 1/3] Better handling of force-closing of channels (#483)

As soon as we receive a valid closing signature, we will publish the
resulting closing tx instead of our commitment tx if we need to
immediately close the channel (before end of negotiation, e.g. in case
of errors, or in case the counterparty goes OFFLINE).

When the closing signature didn't correspond to one we sent ourselves, we
weren't properly recognizing the publishing tx and went into
`ERR_INFORMATION_LEAK` state.

CMD_CLOSE is now split it to commands:
* `CMD_CLOSE`: this command will succeed only if the current
channel state is in NORMAL, or if the channel hasn't yet been created.
* `CMD_FORCECLOSE`: the channel will publish its current local
commitment (or its best signed closing tx if it has one).

Using `CMD_FORCECLOSE` is more expensive and it incurs a delay before
funds are spendable, but this can be useful in some situations, for
example when the counterparty isn't responding anymore.

Added a new `forceclose` method to the API and a force close button in
the GUI.
---
 README.md                                     |  1 +
 .../scala/fr/acinq/eclair/api/Service.scala   |  9 +++-
 .../fr/acinq/eclair/channel/Channel.scala     | 41 +++++++++++--------
 .../eclair/channel/ChannelExceptions.scala    |  1 +
 .../acinq/eclair/channel/ChannelTypes.scala   | 11 +++--
 .../b/WaitForFundingSignedStateSpec.scala     | 13 ++++--
 .../c/WaitForFundingConfirmedStateSpec.scala  | 13 +++++-
 .../c/WaitForFundingLockedStateSpec.scala     | 14 ++++++-
 .../channel/states/e/NormalStateSpec.scala    |  6 +--
 .../channel/states/h/ClosingStateSpec.scala   | 34 ++++++++++++++-
 .../eclair/integration/IntegrationSpec.scala  |  9 ++--
 .../main/resources/gui/main/channelPane.fxml  |  7 +++-
 .../src/main/resources/gui/main/main.css      |  4 ++
 .../fr/acinq/eclair/gui/GUIUpdater.scala      | 26 ++++++++----
 .../controllers/ChannelPaneController.scala   |  1 +
 15 files changed, 139 insertions(+), 51 deletions(-)

diff --git a/README.md b/README.md
index e0e2e026a..76793a79d 100644
--- a/README.md
+++ b/README.md
@@ -154,6 +154,7 @@ java -Declair.datadir=/tmp/node1 -jar eclair-node-gui-<version>-<commit_id>.jar
   checkpayment | paymentRequest                                                                         | returns true if the payment has been received, false otherwise
   close        | channelId                                                                              | close a channel
   close        | channelId, scriptPubKey                                                                | close a channel and send the funds to the given scriptPubKey
+  forceclose   | channelId                                                                              | force-close a channel by publishing the local commitment tx (careful: this is more expensive than a regular close and will incur a delay before funds are spendable)"
   help         |                                                                                        | display available methods
 
 ## Docker
diff --git a/eclair-core/src/main/scala/fr/acinq/eclair/api/Service.scala b/eclair-core/src/main/scala/fr/acinq/eclair/api/Service.scala
index 83d040837..d3151fa37 100644
--- a/eclair-core/src/main/scala/fr/acinq/eclair/api/Service.scala
+++ b/eclair-core/src/main/scala/fr/acinq/eclair/api/Service.scala
@@ -141,10 +141,14 @@ trait Service extends Logging {
                         case _ => reject(UnknownParamsRejection(req.id, s"[nodeId, fundingSatoshis], [nodeId, fundingSatoshis, pushMsat], [nodeId, fundingSatoshis, pushMsat, feerateSatPerByte] or [nodeId, fundingSatoshis, pushMsat, feerateSatPerByte, flag]"))
                       }
                       case "close"        => req.params match {
-                        case JString(identifier) :: Nil => completeRpc(req.id, sendToChannel(identifier, CMD_CLOSE(scriptPubKey = None)).mapTo[String])
-                        case JString(identifier) :: JString(scriptPubKey) :: Nil => completeRpc(req.id, sendToChannel(identifier, CMD_CLOSE(scriptPubKey = Some(scriptPubKey))).mapTo[String])
+                        case JString(identifier) :: Nil => completeRpcFuture(req.id, sendToChannel(identifier, CMD_CLOSE(scriptPubKey = None)).mapTo[String])
+                        case JString(identifier) :: JString(scriptPubKey) :: Nil => completeRpcFuture(req.id, sendToChannel(identifier, CMD_CLOSE(scriptPubKey = Some(scriptPubKey))).mapTo[String])
                         case _ => reject(UnknownParamsRejection(req.id, "[channelId] or [channelId, scriptPubKey]"))
                       }
+                      case "forceclose"   => req.params match {
+                        case JString(identifier) :: Nil => completeRpcFuture(req.id, sendToChannel(identifier, CMD_FORCECLOSE).mapTo[String])
+                        case _ => reject(UnknownParamsRejection(req.id, "[channelId]"))
+                      }
 
                       // local network methods
                       case "peers"        => completeRpcFuture(req.id, for {
@@ -273,6 +277,7 @@ trait Service extends Logging {
     "send (paymentRequest, amountMsat): send a payment to a lightning node using a BOLT11 payment request and a custom amount",
     "close (channelId): close a channel",
     "close (channelId, scriptPubKey): close a channel and send the funds to the given scriptPubKey",
+    "forceclose (channelId): force-close a channel by publishing the local commitment tx (careful: this is more expensive than a regular close and will incur a delay before funds are spendable)",
     "checkpayment (paymentHash): returns true if the payment has been received, false otherwise",
     "checkpayment (paymentRequest): returns true if the payment has been received, false otherwise",
     "getinfo: returns info about the blockchain and this node",
diff --git a/eclair-core/src/main/scala/fr/acinq/eclair/channel/Channel.scala b/eclair-core/src/main/scala/fr/acinq/eclair/channel/Channel.scala
index cc6413302..75cb08a35 100644
--- a/eclair-core/src/main/scala/fr/acinq/eclair/channel/Channel.scala
+++ b/eclair-core/src/main/scala/fr/acinq/eclair/channel/Channel.scala
@@ -174,6 +174,8 @@ class Channel(val nodeParams: NodeParams, wallet: EclairWallet, remoteNodeId: Pu
           blockchain ! WatchLost(self, data.commitments.commitInput.outPoint.txid, nodeParams.minDepthBlocks, BITCOIN_FUNDING_LOST)
           goto(OFFLINE) using data
       }
+
+    case Event(CMD_CLOSE(_), _) => goto(CLOSED) replying "ok"
   })
 
   when(WAIT_FOR_OPEN_CHANNEL)(handleExceptions {
@@ -220,7 +222,7 @@ class Channel(val nodeParams: NodeParams, wallet: EclairWallet, remoteNodeId: Pu
           goto(WAIT_FOR_FUNDING_CREATED) using DATA_WAIT_FOR_FUNDING_CREATED(open.temporaryChannelId, localParams, remoteParams, open.fundingSatoshis, open.pushMsat, open.feeratePerKw, open.firstPerCommitmentPoint, open.channelFlags, accept) sending accept
       }
 
-    case Event(CMD_CLOSE(_), _) => goto(CLOSED)
+    case Event(CMD_CLOSE(_), _) => goto(CLOSED) replying "ok"
 
     case Event(e: Error, d: DATA_WAIT_FOR_OPEN_CHANNEL) => handleRemoteError(e, d)
 
@@ -261,7 +263,7 @@ class Channel(val nodeParams: NodeParams, wallet: EclairWallet, remoteNodeId: Pu
 
     case Event(CMD_CLOSE(_), _) =>
       replyToUser(Right("closed"))
-      goto(CLOSED)
+      goto(CLOSED) replying "ok"
 
     case Event(e: Error, d: DATA_WAIT_FOR_ACCEPT_CHANNEL) =>
       replyToUser(Left(Right(e)))
@@ -300,7 +302,7 @@ class Channel(val nodeParams: NodeParams, wallet: EclairWallet, remoteNodeId: Pu
 
     case Event(CMD_CLOSE(_), _) =>
       replyToUser(Right("closed"))
-      goto(CLOSED)
+      goto(CLOSED) replying "ok"
 
     case Event(e: Error, d: DATA_WAIT_FOR_FUNDING_INTERNAL) =>
       replyToUser(Left(Right(e)))
@@ -352,7 +354,7 @@ class Channel(val nodeParams: NodeParams, wallet: EclairWallet, remoteNodeId: Pu
           goto(WAIT_FOR_FUNDING_CONFIRMED) using store(DATA_WAIT_FOR_FUNDING_CONFIRMED(commitments, None, Right(fundingSigned))) sending fundingSigned
       }
 
-    case Event(CMD_CLOSE(_), _) => goto(CLOSED)
+    case Event(CMD_CLOSE(_), _) => goto(CLOSED) replying "ok"
 
     case Event(e: Error, d: DATA_WAIT_FOR_FUNDING_CREATED) => handleRemoteError(e, d)
 
@@ -403,11 +405,11 @@ class Channel(val nodeParams: NodeParams, wallet: EclairWallet, remoteNodeId: Pu
           goto(WAIT_FOR_FUNDING_CONFIRMED) using nextState
       }
 
-    case Event(CMD_CLOSE(_), d: DATA_WAIT_FOR_FUNDING_SIGNED) =>
+    case Event(CMD_CLOSE(_) | CMD_FORCECLOSE, d: DATA_WAIT_FOR_FUNDING_SIGNED) =>
       // we rollback the funding tx, it will never be published
       wallet.rollback(d.fundingTx)
       replyToUser(Right("closed"))
-      goto(CLOSED)
+      goto(CLOSED) replying "ok"
 
     case Event(e: Error, d: DATA_WAIT_FOR_FUNDING_SIGNED) =>
       // we rollback the funding tx, it will never be published
@@ -456,8 +458,6 @@ class Channel(val nodeParams: NodeParams, wallet: EclairWallet, remoteNodeId: Pu
 
     case Event(WatchEventSpent(BITCOIN_FUNDING_SPENT, tx), d: DATA_WAIT_FOR_FUNDING_CONFIRMED) => handleInformationLeak(tx, d)
 
-    case Event(CMD_CLOSE(_), d: DATA_WAIT_FOR_FUNDING_CONFIRMED) => spendLocalCurrent(d)
-
     case Event(e: Error, d: DATA_WAIT_FOR_FUNDING_CONFIRMED) => handleRemoteError(e, d)
   })
 
@@ -480,8 +480,6 @@ class Channel(val nodeParams: NodeParams, wallet: EclairWallet, remoteNodeId: Pu
 
     case Event(WatchEventSpent(BITCOIN_FUNDING_SPENT, tx), d: DATA_WAIT_FOR_FUNDING_LOCKED) => handleInformationLeak(tx, d)
 
-    case Event(CMD_CLOSE(_), d: DATA_WAIT_FOR_FUNDING_LOCKED) => spendLocalCurrent(d)
-
     case Event(e: Error, d: DATA_WAIT_FOR_FUNDING_LOCKED) => handleRemoteError(e, d)
   })
 
@@ -1076,6 +1074,9 @@ class Channel(val nodeParams: NodeParams, wallet: EclairWallet, remoteNodeId: Pu
       if (d.mutualCloseProposed.map(_.txid).contains(tx.txid)) {
         // at any time they can publish a closing tx with any sig we sent them
         handleMutualClose(tx, Right(d))
+      } else if (d.mutualClosePublished.map(_.txid).contains(tx.txid)) {
+        // we have published a closing tx which isn't one that we proposed, and used it instead of our last commitment when an error happened
+        handleMutualClose(tx, Right(d))
       } else if (Some(tx.txid) == d.localCommitPublished.map(_.commitTx.txid)) {
         // this is because WatchSpent watches never expire and we are notified multiple times
         stay
@@ -1223,8 +1224,6 @@ class Channel(val nodeParams: NodeParams, wallet: EclairWallet, remoteNodeId: Pu
 
       goto(SYNCING) sending channelReestablish
 
-    case Event(c: CMD_CLOSE, d: HasCommitments) => handleLocalError(ForcedLocalCommit(d.channelId, "can't do a mutual close while disconnected"), d, Some(c)) replying "ok"
-
     case Event(c@CurrentBlockCount(count), d: HasCommitments) if d.commitments.hasTimedoutOutgoingHtlcs(count) =>
       // note: this can only happen if state is NORMAL or SHUTDOWN
       // -> in NEGOTIATING there are no more htlcs
@@ -1333,8 +1332,6 @@ class Channel(val nodeParams: NodeParams, wallet: EclairWallet, remoteNodeId: Pu
         goto(NEGOTIATING) using d.copy(closingTxProposed = closingTxProposed1) sending d.localShutdown
       }
 
-    case Event(c: CMD_CLOSE, d: HasCommitments) => handleLocalError(ForcedLocalCommit(d.channelId, "can't do a mutual close while syncing"), d, Some(c))
-
     case Event(c@CurrentBlockCount(count), d: HasCommitments) if d.commitments.hasTimedoutOutgoingHtlcs(count) => handleLocalError(HtlcTimedout(d.channelId), d, Some(c))
 
     case Event(WatchEventSpent(BITCOIN_FUNDING_SPENT, tx), d: DATA_NEGOTIATING) if d.closingTxProposed.flatten.map(_.unsignedTx.txid).contains(tx.txid) => handleMutualClose(tx, Left(d))
@@ -1366,8 +1363,6 @@ class Channel(val nodeParams: NodeParams, wallet: EclairWallet, remoteNodeId: Pu
 
   whenUnhandled {
 
-    case Event(c@INPUT_PUBLISH_LOCALCOMMIT, d: HasCommitments) => handleLocalError(ForcedLocalCommit(d.channelId, "manual unilateral close"), d, Some(c))
-
     case Event(INPUT_DISCONNECTED, _) => goto(OFFLINE)
 
     case Event(WatchEventLost(BITCOIN_FUNDING_LOST), _) => goto(ERR_FUNDING_LOST)
@@ -1393,6 +1388,14 @@ class Channel(val nodeParams: NodeParams, wallet: EclairWallet, remoteNodeId: Pu
         case _ => handleCommandError(AddHtlcFailed(d.channelId, c.paymentHash, error, origin(c), None), c) // we don't provide a channel_update: this will be a permanent channel failure
       }
 
+    case Event(c: CMD_CLOSE, d) => handleCommandError(CannotCloseInThisState(Helpers.getChannelId(d), stateName), c)
+
+    case Event(c@CMD_FORCECLOSE, d) =>
+      d match {
+        case data: HasCommitments => handleLocalError(ForcedLocalCommit(data.channelId, "forced local commit"), data, Some(c)) replying "ok"
+        case _ => handleCommandError(CannotCloseInThisState(Helpers.getChannelId(d), stateName), c)
+      }
+
     // we only care about this event in NORMAL and SHUTDOWN state, and we never unregister to the event stream
     case Event(CurrentBlockCount(_), _) => stay
 
@@ -1481,7 +1484,10 @@ class Channel(val nodeParams: NodeParams, wallet: EclairWallet, remoteNodeId: Pu
   }
 
   def handleLocalError(cause: Throwable, d: HasCommitments, msg: Option[Any]) = {
-    log.error(s"${cause.getMessage} while processing msg=${msg.getOrElse("n/a").getClass.getSimpleName} in state=$stateName")
+    cause match {
+      case _: ForcedLocalCommit => log.warning(s"force-closing channel at user request")
+      case _ => log.error(s"${cause.getMessage} while processing msg=${msg.getOrElse("n/a").getClass.getSimpleName} in state=$stateName")
+    }
     cause match {
       case _: ChannelException => ()
       case _ => log.error(cause, s"msg=${msg.getOrElse("n/a")} stateData=$stateData ")
@@ -1490,6 +1496,7 @@ class Channel(val nodeParams: NodeParams, wallet: EclairWallet, remoteNodeId: Pu
 
     d match {
       case negotiating@DATA_NEGOTIATING(_, _, _, _, Some(bestUnpublishedClosingTx)) =>
+        log.info(s"we have a valid closing tx, publishing it instead of our commitment: closingTxId=${bestUnpublishedClosingTx.txid}")
         // if we were in the process of closing and already received a closing sig from the counterparty, it's always better to use that
         handleMutualClose(bestUnpublishedClosingTx, Left(negotiating))
       case _ =>
diff --git a/eclair-core/src/main/scala/fr/acinq/eclair/channel/ChannelExceptions.scala b/eclair-core/src/main/scala/fr/acinq/eclair/channel/ChannelExceptions.scala
index d8125d591..7c0a1aaea 100644
--- a/eclair-core/src/main/scala/fr/acinq/eclair/channel/ChannelExceptions.scala
+++ b/eclair-core/src/main/scala/fr/acinq/eclair/channel/ChannelExceptions.scala
@@ -22,6 +22,7 @@ case class ChannelReserveTooHigh               (override val channelId: BinaryDa
 case class ChannelFundingError                 (override val channelId: BinaryData) extends ChannelException(channelId, "channel funding error")
 case class NoMoreHtlcsClosingInProgress        (override val channelId: BinaryData) extends ChannelException(channelId, "cannot send new htlcs, closing in progress")
 case class ClosingAlreadyInProgress            (override val channelId: BinaryData) extends ChannelException(channelId, "closing already in progress")
+case class CannotCloseInThisState              (override val channelId: BinaryData, state: State) extends ChannelException(channelId, s"cannot close in state=$state")
 case class CannotCloseWithUnsignedOutgoingHtlcs(override val channelId: BinaryData) extends ChannelException(channelId, "cannot close when there are unsigned outgoing htlcs")
 case class ChannelUnavailable                  (override val channelId: BinaryData) extends ChannelException(channelId, "channel is unavailable (offline or closing)")
 case class InvalidFinalScript                  (override val channelId: BinaryData) extends ChannelException(channelId, "invalid final script")
diff --git a/eclair-core/src/main/scala/fr/acinq/eclair/channel/ChannelTypes.scala b/eclair-core/src/main/scala/fr/acinq/eclair/channel/ChannelTypes.scala
index df3f659c4..6dba96393 100644
--- a/eclair-core/src/main/scala/fr/acinq/eclair/channel/ChannelTypes.scala
+++ b/eclair-core/src/main/scala/fr/acinq/eclair/channel/ChannelTypes.scala
@@ -33,7 +33,6 @@ case object WAIT_FOR_ACCEPT_CHANNEL extends State
 case object WAIT_FOR_FUNDING_INTERNAL extends State
 case object WAIT_FOR_FUNDING_CREATED extends State
 case object WAIT_FOR_FUNDING_SIGNED extends State
-case object WAIT_FOR_FUNDING_PUBLISHED extends State
 case object WAIT_FOR_FUNDING_CONFIRMED extends State
 case object WAIT_FOR_FUNDING_LOCKED extends State
 case object NORMAL extends State
@@ -63,7 +62,6 @@ case object ERR_INFORMATION_LEAK extends State
 case class INPUT_INIT_FUNDER(temporaryChannelId: BinaryData, fundingSatoshis: Long, pushMsat: Long, initialFeeratePerKw: Long, fundingTxFeeratePerKw: Long, localParams: LocalParams, remote: ActorRef, remoteInit: Init, channelFlags: Byte)
 case class INPUT_INIT_FUNDEE(temporaryChannelId: BinaryData, localParams: LocalParams, remote: ActorRef, remoteInit: Init)
 case object INPUT_CLOSE_COMPLETE_TIMEOUT // when requesting a mutual close, we wait for as much as this timeout, then unilateral close
-case object INPUT_PUBLISH_LOCALCOMMIT // used in tests
 case object INPUT_DISCONNECTED
 case class INPUT_RECONNECTED(remote: ActorRef)
 case class INPUT_RESTORED(data: HasCommitments)
@@ -97,11 +95,12 @@ final case class CMD_FULFILL_HTLC(id: Long, r: BinaryData, commit: Boolean = fal
 final case class CMD_FAIL_HTLC(id: Long, reason: Either[BinaryData, FailureMessage], commit: Boolean = false) extends Command
 final case class CMD_FAIL_MALFORMED_HTLC(id: Long, onionHash: BinaryData, failureCode: Int, commit: Boolean = false) extends Command
 final case class CMD_UPDATE_FEE(feeratePerKw: Long, commit: Boolean = false) extends Command
-case object CMD_SIGN extends Command
+final case object CMD_SIGN extends Command
 final case class CMD_CLOSE(scriptPubKey: Option[BinaryData]) extends Command
-case object CMD_GETSTATE extends Command
-case object CMD_GETSTATEDATA extends Command
-case object CMD_GETINFO extends Command
+final case object CMD_FORCECLOSE extends Command
+final case object CMD_GETSTATE extends Command
+final case object CMD_GETSTATEDATA extends Command
+final case object CMD_GETINFO extends Command
 final case class RES_GETINFO(nodeId: BinaryData, channelId: BinaryData, state: State, data: Data)
 
 /*
diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/b/WaitForFundingSignedStateSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/b/WaitForFundingSignedStateSpec.scala
index 8e9f8fed6..178308274 100644
--- a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/b/WaitForFundingSignedStateSpec.scala
+++ b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/b/WaitForFundingSignedStateSpec.scala
@@ -40,7 +40,7 @@ class WaitForFundingSignedStateSpec extends TestkitBaseClass with StateTestsHelp
     test((alice, alice2bob, bob2alice, alice2blockchain))
   }
 
-  test("recv FundingSigned with valid signature") { case (alice, alice2bob, bob2alice, alice2blockchain) =>
+  test("recv FundingSigned with valid signature") { case (alice, _, bob2alice, alice2blockchain) =>
     within(30 seconds) {
       bob2alice.expectMsgType[FundingSigned]
       bob2alice.forward(alice)
@@ -50,7 +50,7 @@ class WaitForFundingSignedStateSpec extends TestkitBaseClass with StateTestsHelp
     }
   }
 
-  test("recv FundingSigned with invalid signature") { case (alice, alice2bob, bob2alice, alice2blockchain) =>
+  test("recv FundingSigned with invalid signature") { case (alice, alice2bob, _, _) =>
     within(30 seconds) {
       // sending an invalid sig
       alice ! FundingSigned("00" * 32, BinaryData("00" * 64))
@@ -59,11 +59,18 @@ class WaitForFundingSignedStateSpec extends TestkitBaseClass with StateTestsHelp
     }
   }
 
-  test("recv CMD_CLOSE") { case (alice, alice2bob, bob2alice, _) =>
+  test("recv CMD_CLOSE") { case (alice, _, _, _) =>
     within(30 seconds) {
       alice ! CMD_CLOSE(None)
       awaitCond(alice.stateName == CLOSED)
     }
   }
 
+  test("recv CMD_FORCECLOSE") { case (alice, _, _, _) =>
+    within(30 seconds) {
+      alice ! CMD_FORCECLOSE
+      awaitCond(alice.stateName == CLOSED)
+    }
+  }
+
 }
diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/c/WaitForFundingConfirmedStateSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/c/WaitForFundingConfirmedStateSpec.scala
index ff40c2e18..2c132ff1e 100644
--- a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/c/WaitForFundingConfirmedStateSpec.scala
+++ b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/c/WaitForFundingConfirmedStateSpec.scala
@@ -1,5 +1,6 @@
 package fr.acinq.eclair.channel.states.c
 
+import akka.actor.Status.Failure
 import akka.testkit.{TestFSMRef, TestProbe}
 import fr.acinq.bitcoin.Transaction
 import fr.acinq.eclair.TestConstants.{Alice, Bob}
@@ -104,10 +105,18 @@ class WaitForFundingConfirmedStateSpec extends TestkitBaseClass with StateTestsH
     }
   }
 
-  test("recv CMD_CLOSE") { case (alice, _, _, _, alice2blockchain) =>
+  test("recv CMD_CLOSE") { case (alice, _, _, _, _) =>
+    within(30 seconds) {
+      val sender = TestProbe()
+      sender.send(alice, CMD_CLOSE(None))
+      sender.expectMsg(Failure(CannotCloseInThisState(channelId(alice), WAIT_FOR_FUNDING_CONFIRMED)))
+    }
+  }
+
+  test("recv CMD_FORCECLOSE") { case (alice, _, _, _, alice2blockchain) =>
     within(30 seconds) {
       val tx = alice.stateData.asInstanceOf[DATA_WAIT_FOR_FUNDING_CONFIRMED].commitments.localCommit.publishableTxs.commitTx.tx
-      alice ! CMD_CLOSE(None)
+      alice ! CMD_FORCECLOSE
       awaitCond(alice.stateName == CLOSING)
       alice2blockchain.expectMsg(PublishAsap(tx))
       alice2blockchain.expectMsgType[PublishAsap] // claim-main-delayed
diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/c/WaitForFundingLockedStateSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/c/WaitForFundingLockedStateSpec.scala
index c4b1a7e17..9edbe5894 100644
--- a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/c/WaitForFundingLockedStateSpec.scala
+++ b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/c/WaitForFundingLockedStateSpec.scala
@@ -1,5 +1,7 @@
 package fr.acinq.eclair.channel.states.c
 
+import akka.actor.Status
+import akka.actor.Status.Failure
 import akka.testkit.{TestFSMRef, TestProbe}
 import fr.acinq.bitcoin.Transaction
 import fr.acinq.eclair.TestConstants.{Alice, Bob}
@@ -94,10 +96,18 @@ class WaitForFundingLockedStateSpec extends TestkitBaseClass with StateTestsHelp
     }
   }
 
-  test("recv CMD_CLOSE") { case (alice, _, alice2bob, bob2alice, alice2blockchain, router) =>
+  test("recv CMD_CLOSE") { case (alice, _, _, _, _, _) =>
+    within(30 seconds) {
+      val sender = TestProbe()
+      sender.send(alice, CMD_CLOSE(None))
+      sender.expectMsg(Failure(CannotCloseInThisState(channelId(alice), WAIT_FOR_FUNDING_LOCKED)))
+    }
+  }
+
+  test("recv CMD_FORCECLOSE") { case (alice, _, _, _, alice2blockchain, _) =>
     within(30 seconds) {
       val tx = alice.stateData.asInstanceOf[DATA_WAIT_FOR_FUNDING_LOCKED].commitments.localCommit.publishableTxs.commitTx.tx
-      alice ! CMD_CLOSE(None)
+      alice ! CMD_FORCECLOSE
       awaitCond(alice.stateName == CLOSING)
       alice2blockchain.expectMsg(PublishAsap(tx))
       alice2blockchain.expectMsgType[PublishAsap]
diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/e/NormalStateSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/e/NormalStateSpec.scala
index e960ec655..4c0afd272 100644
--- a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/e/NormalStateSpec.scala
+++ b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/e/NormalStateSpec.scala
@@ -1863,11 +1863,9 @@ class NormalStateSpec extends TestkitBaseClass with StateTestsHelperMethods {
     within(30 seconds) {
       val initialState = alice.stateData.asInstanceOf[DATA_NORMAL]
       val sender = TestProbe()
-      sender.send(alice, WatchEventConfirmed(BITCOIN_FUNDING_DEEPLYBURIED, 42, 10))
-      assert(relayer.expectMsgType[LocalChannelUpdate].channelAnnouncement_opt === None)
+      sender.send(alice, WatchEventConfirmed(BITCOIN_FUNDING_DEEPLYBURIED, 400000, 42))
       val annSigsA = alice2bob.expectMsgType[AnnouncementSignatures]
-      sender.send(bob, WatchEventConfirmed(BITCOIN_FUNDING_DEEPLYBURIED, 42, 10))
-      assert(relayer.expectMsgType[LocalChannelUpdate].channelAnnouncement_opt === None)
+      sender.send(bob, WatchEventConfirmed(BITCOIN_FUNDING_DEEPLYBURIED, 400000, 42))
       val annSigsB = bob2alice.expectMsgType[AnnouncementSignatures]
       import initialState.commitments.localParams
       import initialState.commitments.remoteParams
diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/h/ClosingStateSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/h/ClosingStateSpec.scala
index ff4722d41..157934fd9 100644
--- a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/h/ClosingStateSpec.scala
+++ b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/h/ClosingStateSpec.scala
@@ -3,8 +3,9 @@ package fr.acinq.eclair.channel.states.h
 import akka.actor.Status.Failure
 import akka.testkit.{TestFSMRef, TestProbe}
 import fr.acinq.bitcoin.{OutPoint, ScriptFlags, Transaction, TxIn}
-import fr.acinq.eclair.TestkitBaseClass
+import fr.acinq.eclair.{Globals, TestkitBaseClass}
 import fr.acinq.eclair.blockchain._
+import fr.acinq.eclair.blockchain.fee.FeeratesPerKw
 import fr.acinq.eclair.channel.states.StateTestsHelperMethods
 import fr.acinq.eclair.channel.{Data, State, _}
 import fr.acinq.eclair.payment.{CommandBuffer, ForwardAdd, ForwardFulfill, Local}
@@ -101,7 +102,6 @@ class ClosingStateSpec extends TestkitBaseClass with StateTestsHelperMethods {
     }
   }
 
-
   test("recv CMD_FULFILL_HTLC (unexisting htlc)") { case (alice, bob, alice2bob, bob2alice, alice2blockchain, bob2blockchain, _, _) =>
     within(30 seconds) {
       mutualClose(alice, bob, alice2bob, bob2alice, alice2blockchain, bob2blockchain)
@@ -115,6 +115,36 @@ class ClosingStateSpec extends TestkitBaseClass with StateTestsHelperMethods {
     }
   }
 
+  test("recv BITCOIN_FUNDING_SPENT (mutual close before converging)") { case (alice, bob, alice2bob, bob2alice, alice2blockchain, bob2blockchain, _, _) =>
+    within(30 seconds) {
+      val sender = TestProbe()
+      // alice initiates a closing
+      sender.send(alice, CMD_CLOSE(None))
+      alice2bob.expectMsgType[Shutdown]
+      alice2bob.forward(bob)
+      bob2alice.expectMsgType[Shutdown]
+      bob2alice.forward(alice)
+      // agreeing on a closing fee
+      val aliceCloseFee = alice2bob.expectMsgType[ClosingSigned].feeSatoshis
+      Globals.feeratesPerKw.set(FeeratesPerKw.single(100))
+      alice2bob.forward(bob)
+      val bobCloseFee = bob2alice.expectMsgType[ClosingSigned].feeSatoshis
+      bob2alice.forward(alice)
+      // they don't converge yet, but alice has a publishable commit tx now
+      assert(aliceCloseFee != bobCloseFee)
+      val Some(mutualCloseTx) = alice.stateData.asInstanceOf[DATA_NEGOTIATING].bestUnpublishedClosingTx_opt
+      // let's make alice publish this closing tx
+      alice ! Error("00" * 32, "")
+      awaitCond(alice.stateName == CLOSING)
+      assert(mutualCloseTx === alice.stateData.asInstanceOf[DATA_CLOSING].mutualClosePublished.last)
+
+      // actual test starts here
+      alice ! WatchEventSpent(BITCOIN_FUNDING_SPENT, mutualCloseTx)
+      alice ! WatchEventConfirmed(BITCOIN_TX_CONFIRMED(mutualCloseTx), 0, 0)
+      awaitCond(alice.stateName == CLOSED)
+    }
+  }
+
   test("recv BITCOIN_TX_CONFIRMED (mutual close)") { case (alice, bob, alice2bob, bob2alice, alice2blockchain, bob2blockchain, _, _) =>
     within(30 seconds) {
       mutualClose(alice, bob, alice2bob, bob2alice, alice2blockchain, bob2blockchain)
diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/integration/IntegrationSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/integration/IntegrationSpec.scala
index 246baedd0..fbced1c65 100644
--- a/eclair-core/src/test/scala/fr/acinq/eclair/integration/IntegrationSpec.scala
+++ b/eclair-core/src/test/scala/fr/acinq/eclair/integration/IntegrationSpec.scala
@@ -404,7 +404,8 @@ class IntegrationSpec extends TestKit(ActorSystem("test")) with FunSuiteLike wit
       sender.expectMsgType[State] == OFFLINE
     }, max = 20 seconds, interval = 1 second)
     // we then have C unilateral close the channel (which will make F redeem the htlc onchain)
-    sender.send(nodes("C").register, Forward(htlc.channelId, INPUT_PUBLISH_LOCALCOMMIT))
+    sender.send(nodes("C").register, Forward(htlc.channelId, CMD_FORCECLOSE))
+    sender.expectMsg("ok")
     // we then wait for F to detect the unilateral close and go to CLOSING state
     awaitCond({
       sender.send(nodes("F1").register, Forward(htlc.channelId, CMD_GETSTATE))
@@ -473,7 +474,8 @@ class IntegrationSpec extends TestKit(ActorSystem("test")) with FunSuiteLike wit
       sender.expectMsgType[State] == OFFLINE
     }, max = 20 seconds, interval = 1 second)
     // then we have F unilateral close the channel
-    sender.send(nodes("F2").register, Forward(htlc.channelId, INPUT_PUBLISH_LOCALCOMMIT))
+    sender.send(nodes("F2").register, Forward(htlc.channelId, CMD_FORCECLOSE))
+    sender.expectMsg("ok")
     // we then fulfill the htlc (it won't be sent to C, and will be used to pull funds on-chain)
     sender.send(nodes("F2").register, Forward(htlc.channelId, CMD_FULFILL_HTLC(htlc.id, preimage)))
     // we then generate one block so that the htlc success tx gets written to the blockchain
@@ -579,7 +581,8 @@ class IntegrationSpec extends TestKit(ActorSystem("test")) with FunSuiteLike wit
     val res = sender.expectMsgType[JValue](10 seconds)
     val previouslyReceivedByC = res.filter(_ \ "address" == JString(finalAddressC)).flatMap(_ \ "txids" \\ classOf[JString])
     // then we ask F to unilaterally close the channel
-    sender.send(nodes("F4").register, Forward(htlc.channelId, INPUT_PUBLISH_LOCALCOMMIT))
+    sender.send(nodes("F4").register, Forward(htlc.channelId, CMD_FORCECLOSE))
+    sender.expectMsg("ok")
     // we then generate enough blocks to make the htlc timeout
     sender.send(bitcoincli, BitcoinReq("generate", 11))
     sender.expectMsgType[JValue](10 seconds)
diff --git a/eclair-node-gui/src/main/resources/gui/main/channelPane.fxml b/eclair-node-gui/src/main/resources/gui/main/channelPane.fxml
index 92dcc7c4d..809ca1f89 100644
--- a/eclair-node-gui/src/main/resources/gui/main/channelPane.fxml
+++ b/eclair-node-gui/src/main/resources/gui/main/channelPane.fxml
@@ -24,11 +24,14 @@
             <RowConstraints minHeight="10.0" vgrow="SOMETIMES"/>
             <RowConstraints minHeight="10.0" vgrow="SOMETIMES"/>
         </rowConstraints>
+
         <HBox GridPane.columnSpan="4" GridPane.columnIndex="0" alignment="CENTER" spacing="5.0">
             <TextField fx:id="channelId" text="N/A" editable="false" styleClass="noteditable, text-strong"
                        HBox.hgrow="ALWAYS" GridPane.valignment="BOTTOM" focusTraversable="false"/>
-            <Button fx:id="close" GridPane.columnIndex="4" GridPane.halignment="RIGHT" alignment="CENTER_RIGHT"
-                    HBox.hgrow="NEVER" mnemonicParsing="false" styleClass="close-channel" text="Close"/>
+            <HBox GridPane.columnIndex="4" GridPane.halignment="RIGHT" alignment="CENTER_RIGHT" HBox.hgrow="NEVER" spacing="5">
+                <Button fx:id="close" mnemonicParsing="false" styleClass="close-channel" text="Close" visible="false"/>
+                <Button fx:id="forceclose" mnemonicParsing="false" styleClass="forceclose-channel" text="Force close" visible="false"/>
+            </HBox>
         </HBox>
 
         <ProgressBar fx:id="balanceBar" minHeight="4.0" prefHeight="4.0" maxWidth="1.7976931348623157E308"
diff --git a/eclair-node-gui/src/main/resources/gui/main/main.css b/eclair-node-gui/src/main/resources/gui/main/main.css
index 6a40196fe..4850fd99f 100644
--- a/eclair-node-gui/src/main/resources/gui/main/main.css
+++ b/eclair-node-gui/src/main/resources/gui/main/main.css
@@ -78,6 +78,10 @@
 	-fx-faint-focus-color: transparent;
 }
 
+.button.forceclose-channel {
+    -fx-base: #f5dcd8;
+}
+
 /* ---------- Table ---------- */
 
 .table-view {
diff --git a/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/GUIUpdater.scala b/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/GUIUpdater.scala
index 66b195887..82fee8261 100644
--- a/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/GUIUpdater.scala
+++ b/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/GUIUpdater.scala
@@ -5,6 +5,8 @@ import java.util.function.Predicate
 import javafx.application.Platform
 import javafx.event.{ActionEvent, EventHandler}
 import javafx.fxml.FXMLLoader
+import javafx.scene.control.Alert.AlertType
+import javafx.scene.control.{Alert, ButtonType}
 import javafx.scene.layout.VBox
 
 import akka.actor.{Actor, ActorLogging, ActorRef, Terminated}
@@ -16,7 +18,7 @@ import fr.acinq.eclair.blockchain.electrum.ElectrumClient.{ElectrumConnected, El
 import fr.acinq.eclair.channel._
 import fr.acinq.eclair.gui.controllers._
 import fr.acinq.eclair.payment.{PaymentReceived, PaymentRelayed, PaymentSent}
-import fr.acinq.eclair.router._
+import fr.acinq.eclair.router.{NORMAL => _, _}
 import fr.acinq.eclair.wire.NodeAnnouncement
 
 import scala.collection.JavaConversions._
@@ -27,6 +29,9 @@ import scala.collection.JavaConversions._
   */
 class GUIUpdater(mainController: MainController) extends Actor with ActorLogging {
 
+  val STATE_MUTUAL_CLOSE = Set(WAIT_FOR_INIT_INTERNAL, WAIT_FOR_OPEN_CHANNEL, WAIT_FOR_ACCEPT_CHANNEL, WAIT_FOR_FUNDING_INTERNAL, WAIT_FOR_FUNDING_CREATED, WAIT_FOR_FUNDING_SIGNED, NORMAL)
+  val STATE_FORCE_CLOSE = Set(WAIT_FOR_FUNDING_CONFIRMED, WAIT_FOR_FUNDING_LOCKED, NORMAL, SHUTDOWN, NEGOTIATING, OFFLINE, SYNCING)
+
   /**
     * Needed to stop JavaFX complaining about updates from non GUI thread
     */
@@ -48,7 +53,16 @@ class GUIUpdater(mainController: MainController) extends Actor with ActorLogging
     channelPaneController.channelId.setText(temporaryChannelId.toString())
     channelPaneController.funder.setText(if (isFunder) "Yes" else "No")
     channelPaneController.close.setOnAction(new EventHandler[ActionEvent] {
-      override def handle(event: ActionEvent) = channel ! CMD_CLOSE(None)
+      override def handle(event: ActionEvent) = channel ! CMD_CLOSE(scriptPubKey = None)
+    })
+    channelPaneController.forceclose.setOnAction(new EventHandler[ActionEvent] {
+      override def handle(event: ActionEvent) = {
+        val alert = new Alert(AlertType.WARNING, "Careful: force-close is more expensive than a regular close and will incur a delay before funds are spendable.\n\nAre you sure you want to proceed?", ButtonType.YES, ButtonType.NO)
+        alert.showAndWait
+        if (alert.getResult eq ButtonType.YES) {
+          channel ! CMD_FORCECLOSE
+        }
+      }
     })
 
     // set the node alias if the node has already been announced
@@ -93,12 +107,8 @@ class GUIUpdater(mainController: MainController) extends Actor with ActorLogging
     case ChannelStateChanged(channel, _, _, _, currentState, _) if m.contains(channel) =>
       val channelPaneController = m(channel)
       runInGuiThread { () =>
-        if (currentState == CLOSING || currentState == CLOSED) {
-          channelPaneController.close.setVisible(false)
-        } else {
-          channelPaneController.close.setVisible(true)
-        }
-        channelPaneController.close.setText(if (OFFLINE == currentState) "Force close" else "Close")
+        channelPaneController.close.setVisible(STATE_MUTUAL_CLOSE.contains(currentState))
+        channelPaneController.forceclose.setVisible(STATE_FORCE_CLOSE.contains(currentState))
         channelPaneController.state.setText(currentState.toString)
       }
 
diff --git a/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/controllers/ChannelPaneController.scala b/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/controllers/ChannelPaneController.scala
index a07fdacac..436cb0def 100644
--- a/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/controllers/ChannelPaneController.scala
+++ b/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/controllers/ChannelPaneController.scala
@@ -25,6 +25,7 @@ class ChannelPaneController(val theirNodeIdValue: String) extends Logging {
   @FXML var funder: TextField = _
   @FXML var state: TextField = _
   @FXML var close: Button = _
+  @FXML var forceclose: Button = _
 
   var contextMenu: ContextMenu = _
 

From 3d48ec871eee4bb364fa289809c66582501feabb Mon Sep 17 00:00:00 2001
From: Dominique <dpad85@users.noreply.github.com>
Date: Thu, 15 Mar 2018 19:33:12 +0100
Subject: [PATCH 2/3] Improved handling of timeouts in API and GUI (#484)

Both the GUI and the API should handle AskTimeoutException failures as
specific cases: GUI should ignore them, API should print a pretty
response. Increased ask timeout to 60s.

Akka http server responses with the same format as other errors.
Fixes #414 where eclair-cli would fail to parse the server
timeout response.
---
 .../scala/fr/acinq/eclair/api/Service.scala   | 56 ++++++++++---------
 .../scala/fr/acinq/eclair/gui/FxApp.scala     |  3 +-
 .../fr/acinq/eclair/gui/GUIUpdater.scala      | 18 +++++-
 .../scala/fr/acinq/eclair/gui/Handlers.scala  | 35 ++++--------
 .../src/main/resources/application.conf       |  1 +
 .../src/main/resources/logback_colors.xml     |  2 +-
 6 files changed, 63 insertions(+), 52 deletions(-)

diff --git a/eclair-core/src/main/scala/fr/acinq/eclair/api/Service.scala b/eclair-core/src/main/scala/fr/acinq/eclair/api/Service.scala
index d3151fa37..5f6ab5129 100644
--- a/eclair-core/src/main/scala/fr/acinq/eclair/api/Service.scala
+++ b/eclair-core/src/main/scala/fr/acinq/eclair/api/Service.scala
@@ -1,7 +1,8 @@
 package fr.acinq.eclair.api
+
 import akka.actor.ActorRef
 import akka.http.scaladsl.model.HttpMethods._
-import akka.http.scaladsl.model.StatusCodes
+import akka.http.scaladsl.model._
 import akka.http.scaladsl.model.headers.CacheDirectives.{`max-age`, `no-store`, public}
 import akka.http.scaladsl.model.headers._
 import akka.http.scaladsl.server.Directives._
@@ -15,12 +16,12 @@ import de.heikoseeberger.akkahttpjson4s.Json4sSupport.ShouldWritePretty
 import fr.acinq.bitcoin.Crypto.PublicKey
 import fr.acinq.bitcoin.{BinaryData, MilliSatoshi, Satoshi}
 import fr.acinq.eclair.channel._
-import fr.acinq.eclair.{Kit, ShortChannelId, feerateByte2Kw}
 import fr.acinq.eclair.io.Peer.{GetPeerInfo, PeerInfo}
 import fr.acinq.eclair.io.{NodeURI, Peer}
 import fr.acinq.eclair.payment.{PaymentRequest, PaymentResult, ReceivePayment, SendPayment, _}
 import fr.acinq.eclair.router.ChannelDesc
 import fr.acinq.eclair.wire.{ChannelAnnouncement, ChannelUpdate, NodeAnnouncement}
+import fr.acinq.eclair.{Kit, ShortChannelId, feerateByte2Kw}
 import grizzled.slf4j.Logging
 import org.json4s.JsonAST.{JBool, JInt, JString}
 import org.json4s.{JValue, jackson}
@@ -51,7 +52,7 @@ trait Service extends Logging {
 
   implicit val serialization = jackson.Serialization
   implicit val formats = org.json4s.DefaultFormats + new BinaryDataSerializer + new StateSerializer + new ShaChainSerializer + new PublicKeySerializer + new PrivateKeySerializer + new ScalarSerializer + new PointSerializer + new TransactionSerializer + new TransactionWithInputInfoSerializer + new InetSocketAddressSerializer + new OutPointKeySerializer + new ColorSerializer + new ShortChannelIdSerializer
-  implicit val timeout = Timeout(30 seconds)
+  implicit val timeout = Timeout(60 seconds)
   implicit val shouldWritePretty: ShouldWritePretty = ShouldWritePretty.True
 
   import Json4sSupport.{marshaller, unmarshaller}
@@ -74,7 +75,7 @@ trait Service extends Logging {
   val myExceptionHandler = ExceptionHandler {
     case t: Throwable =>
       extractRequest { _ =>
-        logger.info(s"API call failed with cause=${t.getMessage}")
+        logger.error(s"API call failed with cause=${t.getMessage}")
         complete(StatusCodes.InternalServerError, JsonRPCRes(null, Some(Error(StatusCodes.InternalServerError.intValue, t.getMessage)), "-1"))
       }
   }
@@ -83,6 +84,7 @@ trait Service extends Logging {
     case Success(s) => completeRpc(requestId, s)
     case Failure(t) => reject(ExceptionRejection(requestId, t.getLocalizedMessage))
   }
+
   def completeRpc(requestId: String, result: AnyRef): Route = complete(JsonRPCRes(result, None, requestId))
 
   val myRejectionHandler: RejectionHandler = RejectionHandler.newBuilder()
@@ -106,6 +108,7 @@ trait Service extends Logging {
 
   val route: Route =
     respondWithDefaultHeaders(customHeaders) {
+      withRequestTimeoutResponse(r => HttpResponse(StatusCodes.RequestTimeout).withEntity(ContentTypes.`application/json`, """{ "result": null, "error": { "code": 408, "message": "request timed out"} } """)) {
       handleExceptions(myExceptionHandler) {
         handleRejections(myRejectionHandler) {
           authenticateBasic(realm = "Access restricted", userPassAuthenticator) { _ =>
@@ -118,18 +121,18 @@ trait Service extends Logging {
 
                     req.method match {
                       // utility methods
-                      case "getinfo"      => completeRpcFuture(req.id, getInfoResponse)
-                      case "help"         => completeRpc(req.id, help)
+                      case "getinfo" => completeRpcFuture(req.id, getInfoResponse)
+                      case "help" => completeRpc(req.id, help)
 
                       // channel lifecycle methods
-                      case "connect"      => req.params match {
+                      case "connect" => req.params match {
                         case JString(pubkey) :: JString(host) :: JInt(port) :: Nil =>
                           completeRpcFuture(req.id, (switchboard ? Peer.Connect(NodeURI.parse(s"$pubkey@$host:$port"))).mapTo[String])
                         case JString(uri) :: Nil =>
                           completeRpcFuture(req.id, (switchboard ? Peer.Connect(NodeURI.parse(uri))).mapTo[String])
                         case _ => reject(UnknownParamsRejection(req.id, "[nodeId@host:port] or [nodeId, host, port]"))
                       }
-                      case "open"         => req.params match {
+                      case "open" => req.params match {
                         case JString(nodeId) :: JInt(fundingSatoshis) :: Nil =>
                           completeRpcFuture(req.id, (switchboard ? Peer.OpenChannel(PublicKey(nodeId), Satoshi(fundingSatoshis.toLong), MilliSatoshi(0), fundingTxFeeratePerKw_opt = None, channelFlags = None)).mapTo[String])
                         case JString(nodeId) :: JInt(fundingSatoshis) :: JInt(pushMsat) :: Nil =>
@@ -140,7 +143,7 @@ trait Service extends Logging {
                           completeRpcFuture(req.id, (switchboard ? Peer.OpenChannel(PublicKey(nodeId), Satoshi(fundingSatoshis.toLong), MilliSatoshi(pushMsat.toLong), fundingTxFeeratePerKw_opt = Some(feerateByte2Kw(fundingFeerateSatPerByte.toLong)), channelFlags = Some(flags.toByte))).mapTo[String])
                         case _ => reject(UnknownParamsRejection(req.id, s"[nodeId, fundingSatoshis], [nodeId, fundingSatoshis, pushMsat], [nodeId, fundingSatoshis, pushMsat, feerateSatPerByte] or [nodeId, fundingSatoshis, pushMsat, feerateSatPerByte, flag]"))
                       }
-                      case "close"        => req.params match {
+                      case "close" => req.params match {
                         case JString(identifier) :: Nil => completeRpcFuture(req.id, sendToChannel(identifier, CMD_CLOSE(scriptPubKey = None)).mapTo[String])
                         case JString(identifier) :: JString(scriptPubKey) :: Nil => completeRpcFuture(req.id, sendToChannel(identifier, CMD_CLOSE(scriptPubKey = Some(scriptPubKey))).mapTo[String])
                         case _ => reject(UnknownParamsRejection(req.id, "[channelId] or [channelId, scriptPubKey]"))
@@ -151,11 +154,11 @@ trait Service extends Logging {
                       }
 
                       // local network methods
-                      case "peers"        => completeRpcFuture(req.id, for {
+                      case "peers" => completeRpcFuture(req.id, for {
                         peers <- (switchboard ? 'peers).mapTo[Map[PublicKey, ActorRef]]
                         peerinfos <- Future.sequence(peers.values.map(peer => (peer ? GetPeerInfo).mapTo[PeerInfo]))
                       } yield peerinfos)
-                      case "channels"     => req.params match {
+                      case "channels" => req.params match {
                         case Nil =>
                           val f = for {
                             channels_id <- (register ? 'channels).mapTo[Map[BinaryData, ActorRef]].map(_.keys)
@@ -164,26 +167,26 @@ trait Service extends Logging {
                           } yield channels
                           completeRpcFuture(req.id, f)
                         case JString(remoteNodeId) :: Nil => Try(PublicKey(remoteNodeId)) match {
-                            case Success(pk) =>
-                              val f = for {
-                                channels_id <- (register ? 'channelsTo).mapTo[Map[BinaryData, PublicKey]].map(_.filter(_._2 == pk).keys)
-                                channels <- Future.sequence(channels_id.map(channel_id => sendToChannel(channel_id.toString(), CMD_GETINFO).mapTo[RES_GETINFO]
-                                  .map(gi => LocalChannelInfo(gi.nodeId, gi.channelId, gi.state.toString))))
-                              } yield channels
-                              completeRpcFuture(req.id, f)
-                            case Failure(_) => reject(RpcValidationRejection(req.id, s"invalid remote node id '$remoteNodeId'"))
-                          }
+                          case Success(pk) =>
+                            val f = for {
+                              channels_id <- (register ? 'channelsTo).mapTo[Map[BinaryData, PublicKey]].map(_.filter(_._2 == pk).keys)
+                              channels <- Future.sequence(channels_id.map(channel_id => sendToChannel(channel_id.toString(), CMD_GETINFO).mapTo[RES_GETINFO]
+                                .map(gi => LocalChannelInfo(gi.nodeId, gi.channelId, gi.state.toString))))
+                            } yield channels
+                            completeRpcFuture(req.id, f)
+                          case Failure(_) => reject(RpcValidationRejection(req.id, s"invalid remote node id '$remoteNodeId'"))
+                        }
                         case _ => reject(UnknownParamsRejection(req.id, "no arguments or [remoteNodeId]"))
                       }
-                      case "channel"      => req.params match {
+                      case "channel" => req.params match {
                         case JString(identifier) :: Nil => completeRpcFuture(req.id, sendToChannel(identifier, CMD_GETINFO).mapTo[RES_GETINFO])
                         case _ => reject(UnknownParamsRejection(req.id, "[channelId]"))
                       }
 
                       // global network methods
-                      case "allnodes"     => completeRpcFuture(req.id, (router ? 'nodes).mapTo[Iterable[NodeAnnouncement]])
-                      case "allchannels"  => completeRpcFuture(req.id, (router ? 'channels).mapTo[Iterable[ChannelAnnouncement]].map(_.map(c => ChannelDesc(c.shortChannelId, c.nodeId1, c.nodeId2))))
-                      case "allupdates"   => req.params match {
+                      case "allnodes" => completeRpcFuture(req.id, (router ? 'nodes).mapTo[Iterable[NodeAnnouncement]])
+                      case "allchannels" => completeRpcFuture(req.id, (router ? 'channels).mapTo[Iterable[ChannelAnnouncement]].map(_.map(c => ChannelDesc(c.shortChannelId, c.nodeId1, c.nodeId2))))
+                      case "allupdates" => req.params match {
                         case JString(nodeId) :: Nil => Try(PublicKey(nodeId)) match {
                           case Success(pk) => completeRpcFuture(req.id, (router ? 'updatesMap).mapTo[Map[ChannelDesc, ChannelUpdate]].map(_.filter(e => e._1.a == pk || e._1.b == pk).values))
                           case Failure(_) => reject(RpcValidationRejection(req.id, s"invalid remote node id '$nodeId'"))
@@ -192,7 +195,7 @@ trait Service extends Logging {
                       }
 
                       // payment methods
-                      case "receive"      => req.params match {
+                      case "receive" => req.params match {
                         // only the payment description is given: user may want to generate a donation payment request
                         case JString(description) :: Nil =>
                           completeRpcFuture(req.id, (paymentHandler ? ReceivePayment(None, description)).mapTo[PaymentRequest].map(PaymentRequest.write))
@@ -201,7 +204,7 @@ trait Service extends Logging {
                           completeRpcFuture(req.id, (paymentHandler ? ReceivePayment(Some(MilliSatoshi(amountMsat.toLong)), description)).mapTo[PaymentRequest].map(PaymentRequest.write))
                         case _ => reject(UnknownParamsRejection(req.id, "[description] or [amount, description]"))
                       }
-                      case "send"         => req.params match {
+                      case "send" => req.params match {
                         // user manually sets the payment information
                         case JInt(amountMsat) :: JString(paymentHash) :: JString(nodeId) :: Nil =>
                           (Try(BinaryData(paymentHash)), Try(PublicKey(nodeId))) match {
@@ -254,6 +257,7 @@ trait Service extends Logging {
             }
           }
         }
+        }
       }
     }
 
diff --git a/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/FxApp.scala b/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/FxApp.scala
index c3be76515..92774fa09 100644
--- a/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/FxApp.scala
+++ b/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/FxApp.scala
@@ -15,7 +15,7 @@ import fr.acinq.eclair.blockchain.bitcoind.zmq.ZMQActor._
 import fr.acinq.eclair.blockchain.electrum.ElectrumClient.ElectrumEvent
 import fr.acinq.eclair.channel.ChannelEvent
 import fr.acinq.eclair.gui.controllers.{MainController, NotificationsController}
-import fr.acinq.eclair.payment.PaymentEvent
+import fr.acinq.eclair.payment.{PaymentEvent, PaymentResult}
 import fr.acinq.eclair.router.NetworkEvent
 import grizzled.slf4j.Logging
 
@@ -80,6 +80,7 @@ class FxApp extends Application with Logging {
           setup.system.eventStream.subscribe(guiUpdater, classOf[ChannelEvent])
           setup.system.eventStream.subscribe(guiUpdater, classOf[NetworkEvent])
           setup.system.eventStream.subscribe(guiUpdater, classOf[PaymentEvent])
+          setup.system.eventStream.subscribe(guiUpdater, classOf[PaymentResult])
           setup.system.eventStream.subscribe(guiUpdater, classOf[ZMQEvent])
           setup.system.eventStream.subscribe(guiUpdater, classOf[ElectrumEvent])
           pKit.completeWith(setup.bootstrap)
diff --git a/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/GUIUpdater.scala b/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/GUIUpdater.scala
index 82fee8261..0f32d2223 100644
--- a/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/GUIUpdater.scala
+++ b/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/GUIUpdater.scala
@@ -17,7 +17,7 @@ import fr.acinq.eclair.blockchain.bitcoind.zmq.ZMQActor.{ZMQConnected, ZMQDiscon
 import fr.acinq.eclair.blockchain.electrum.ElectrumClient.{ElectrumConnected, ElectrumDisconnected}
 import fr.acinq.eclair.channel._
 import fr.acinq.eclair.gui.controllers._
-import fr.acinq.eclair.payment.{PaymentReceived, PaymentRelayed, PaymentSent}
+import fr.acinq.eclair.payment._
 import fr.acinq.eclair.router.{NORMAL => _, _}
 import fr.acinq.eclair.wire.NodeAnnouncement
 
@@ -184,6 +184,22 @@ class GUIUpdater(mainController: MainController) extends Actor with ActorLogging
           mainController.networkChannelsList.update(idx, c)
         }
       }
+
+    case p: PaymentSucceeded =>
+      val message = CoinUtils.formatAmountInUnit(MilliSatoshi(p.amountMsat), FxApp.getUnit, withUnit = true)
+      mainController.handlers.notification("Payment Sent", message, NOTIFICATION_SUCCESS)
+
+    case p: PaymentFailed =>
+      val distilledFailures = PaymentLifecycle.transformForUser(p.failures)
+      val message = s"${distilledFailures.size} attempts:\n${
+        distilledFailures.map {
+          case LocalFailure(t) => s"- (local) ${t.getMessage}"
+          case RemoteFailure(_, e) => s"- (remote) ${e.failureMessage.message}"
+          case _ => "- Unknown error"
+        }.mkString("\n")
+      }"
+      mainController.handlers.notification("Payment Failed", message, NOTIFICATION_ERROR)
+
     case p: PaymentSent =>
       log.debug(s"payment sent with h=${p.paymentHash}, amount=${p.amount}, fees=${p.feesPaid}")
       runInGuiThread(() => mainController.paymentSentList.prepend(new PaymentSentRecord(p, LocalDateTime.now())))
diff --git a/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/Handlers.scala b/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/Handlers.scala
index a7d3ed391..ede967cd0 100644
--- a/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/Handlers.scala
+++ b/eclair-node-gui/src/main/scala/fr/acinq/eclair/gui/Handlers.scala
@@ -2,7 +2,7 @@ package fr.acinq.eclair.gui
 
 import java.io.{File, FileWriter}
 
-import akka.pattern.ask
+import akka.pattern.{AskTimeoutException, ask}
 import akka.util.Timeout
 import fr.acinq.bitcoin.MilliSatoshi
 import fr.acinq.eclair._
@@ -20,7 +20,7 @@ import scala.util.{Failure, Success}
   */
 class Handlers(fKit: Future[Kit])(implicit ec: ExecutionContext = ExecutionContext.Implicits.global) extends Logging {
 
-  implicit val timeout = Timeout(30 seconds)
+  implicit val timeout = Timeout(60 seconds)
 
   private var notifsController: Option[NotificationsController] = None
 
@@ -49,6 +49,8 @@ class Handlers(fKit: Future[Kit])(implicit ec: ExecutionContext = ExecutionConte
               case Success(s) =>
                 logger.info(s"successfully opened channel $s")
                 notification("Channel created", s.toString, NOTIFICATION_SUCCESS)
+              case Failure(_: AskTimeoutException) =>
+                logger.info("opening channel is taking a long time, notifications will not be shown")
               case Failure(t) =>
                 logger.info("could not open channel ", t)
                 notification("Channel creation failed", t.getMessage, NOTIFICATION_ERROR)
@@ -65,34 +67,22 @@ class Handlers(fKit: Future[Kit])(implicit ec: ExecutionContext = ExecutionConte
     val amountMsat = overrideAmountMsat_opt
       .orElse(req.amount.map(_.amount))
       .getOrElse(throw new RuntimeException("you need to manually specify an amount for this payment request"))
-
     logger.info(s"sending $amountMsat to ${req.paymentHash} @ ${req.nodeId}")
     val sendPayment = req.minFinalCltvExpiry match {
       case None => SendPayment(amountMsat, req.paymentHash, req.nodeId, req.routingInfo)
       case Some(minFinalCltvExpiry) => SendPayment(amountMsat, req.paymentHash, req.nodeId, req.routingInfo, finalCltvExpiry = minFinalCltvExpiry)
     }
+    // completed payment will be handled from GUIUpdater by listening to PaymentSucceeded/PaymentFailed events
     (for {
       kit <- fKit
       res <- (kit.paymentInitiator ? sendPayment).mapTo[PaymentResult]
-    } yield res)
-      .onComplete {
-        case Success(_: PaymentSucceeded) =>
-          val message = CoinUtils.formatAmountInUnit(MilliSatoshi(amountMsat), FxApp.getUnit, withUnit = true)
-          notification("Payment Sent", message, NOTIFICATION_SUCCESS)
-        case Success(PaymentFailed(_, failures)) =>
-          val distilledFailures = PaymentLifecycle.transformForUser(failures)
-          val message = s"${distilledFailures.size} attempts:\n${
-            distilledFailures.map {
-              case LocalFailure(t) => s"- (local) ${t.getMessage}"
-              case RemoteFailure(_, e) => s"- (remote) ${e.failureMessage.message}"
-              case _ => "- Unknown error"
-            }.mkString("\n")
-          }"
-          notification("Payment Failed", message, NOTIFICATION_ERROR)
-        case Failure(t) =>
-          val message = t.getMessage
-          notification("Payment Failed", message, NOTIFICATION_ERROR)
-      }
+    } yield res).recover {
+      case _: AskTimeoutException =>
+        logger.info("sending payment is taking a long time, notifications will not be shown")
+      case t =>
+        val message = t.getMessage
+        notification("Payment Failed", message, NOTIFICATION_ERROR)
+    }
   }
 
   def receive(amountMsat_opt: Option[MilliSatoshi], description: String): Future[String] = for {
@@ -100,7 +90,6 @@ class Handlers(fKit: Future[Kit])(implicit ec: ExecutionContext = ExecutionConte
     res <- (kit.paymentHandler ? ReceivePayment(amountMsat_opt, description)).mapTo[PaymentRequest].map(PaymentRequest.write)
   } yield res
 
-
   def exportToDot(file: File) = for {
     kit <- fKit
     dot <- (kit.router ? 'dot).mapTo[String]
diff --git a/eclair-node/src/main/resources/application.conf b/eclair-node/src/main/resources/application.conf
index 476eba17e..b1e3bdceb 100644
--- a/eclair-node/src/main/resources/application.conf
+++ b/eclair-node/src/main/resources/application.conf
@@ -1,4 +1,5 @@
 akka {
+
   loggers = ["akka.event.slf4j.Slf4jLogger"]
   loglevel = "INFO"
 
diff --git a/eclair-node/src/main/resources/logback_colors.xml b/eclair-node/src/main/resources/logback_colors.xml
index e71173dbe..dc3ada972 100644
--- a/eclair-node/src/main/resources/logback_colors.xml
+++ b/eclair-node/src/main/resources/logback_colors.xml
@@ -81,7 +81,7 @@
         <appender-ref ref="CYAN"/>
     </logger>
 
-    <logger name="fr.acinq.eclair.gui" level="WARN" additivity="false">
+    <logger name="fr.acinq.eclair.gui" level="INFO" additivity="false">
         <appender-ref ref="MAGENTA"/>
     </logger>
 

From dbb4f5b467ef6af3f1337a2ffee0a4d0a035ab38 Mon Sep 17 00:00:00 2001
From: pm47 <pm.padiou@gmail.com>
Date: Thu, 15 Mar 2018 19:41:53 +0100
Subject: [PATCH 3/3] set version to 0.2-alpha11

---
 eclair-core/pom.xml     | 2 +-
 eclair-node-gui/pom.xml | 2 +-
 eclair-node/pom.xml     | 2 +-
 pom.xml                 | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/eclair-core/pom.xml b/eclair-core/pom.xml
index 179158b5d..e176798c0 100644
--- a/eclair-core/pom.xml
+++ b/eclair-core/pom.xml
@@ -5,7 +5,7 @@
     <parent>
         <groupId>fr.acinq.eclair</groupId>
         <artifactId>eclair_2.11</artifactId>
-        <version>0.2-SNAPSHOT</version>
+        <version>0.2-alpha11</version>
     </parent>
 
     <artifactId>eclair-core_2.11</artifactId>
diff --git a/eclair-node-gui/pom.xml b/eclair-node-gui/pom.xml
index 5341e019c..12873daff 100644
--- a/eclair-node-gui/pom.xml
+++ b/eclair-node-gui/pom.xml
@@ -5,7 +5,7 @@
     <parent>
         <groupId>fr.acinq.eclair</groupId>
         <artifactId>eclair_2.11</artifactId>
-        <version>0.2-SNAPSHOT</version>
+        <version>0.2-alpha11</version>
     </parent>
 
     <artifactId>eclair-node-gui_2.11</artifactId>
diff --git a/eclair-node/pom.xml b/eclair-node/pom.xml
index 0f0a70721..211883f86 100644
--- a/eclair-node/pom.xml
+++ b/eclair-node/pom.xml
@@ -5,7 +5,7 @@
     <parent>
         <groupId>fr.acinq.eclair</groupId>
         <artifactId>eclair_2.11</artifactId>
-        <version>0.2-SNAPSHOT</version>
+        <version>0.2-alpha11</version>
     </parent>
 
     <artifactId>eclair-node_2.11</artifactId>
diff --git a/pom.xml b/pom.xml
index 86c44fd14..e5b93d61a 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
 
     <groupId>fr.acinq.eclair</groupId>
     <artifactId>eclair_2.11</artifactId>
-    <version>0.2-SNAPSHOT</version>
+    <version>0.2-alpha11</version>
     <packaging>pom</packaging>
 
     <modules>