moved akka conf to eclair-node application.conf

use a local queue for outgoing rpc requests. this should be a better solution than
inceasing the number of concurrent requests.
see https://doc.akka.io/docs/akka-http/current/scala/http/client-side/host-level.html#using-the-host-level-api-with-a-queue
for more information.

.travis.yml

@@ -1,5 +1,5 @@
 sudo: required
-dist: precise
+dist: trusty
 language: scala
 scala:
  - 2.11.11

README.md

@@ -118,8 +118,8 @@ java -Declair.datadir=/tmp/node1 -jar eclair-node-gui-<version>-<commit_id>.jar
  method       |  params                                       | description
  -------------|-----------------------------------------------|-----------------------------------------------------------
   getinfo     |                                               | return basic node information (id, chain hash, current block height) 
-  connect     | host, port, nodeId                            | connect to another lightning node through a secure connection
-  open        | host, port, nodeId, fundingSatoshis, pushMsat | opens a channel with another lightning node
+  connect     | nodeId, host, port                            | connect to another lightning node through a secure connection
+  open        | nodeId, host, port, fundingSatoshis, pushMsat | opens a channel with another lightning node
   peers       |                                               | list existing local peers
   channels    |                                               | list existing local channels
   channel     | channelId                                     | retrieve detailed information about a given channel

eclair-core/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>fr.acinq.eclair</groupId>
         <artifactId>eclair_2.11</artifactId>
-        <version>0.2-android-alpha8</version>
+        <version>0.2-SNAPSHOT</version>
     </parent>
 
     <artifactId>eclair-core_2.11</artifactId>
@@ -83,9 +83,9 @@
         <profile>
             <id>Mac</id>
             <activation>
-              <os>
-                <family>mac</family>
-              </os>
+                <os>
+                    <family>mac</family>
+                </os>
             </activation>
             <properties>
                 <bitcoind.url>https://bitcoin.org/bin/bitcoin-core-0.14.0/bitcoin-0.14.0-osx64.tar.gz
@@ -121,11 +121,10 @@
             <artifactId>akka-slf4j_${scala.version.short}</artifactId>
             <version>${akka.version}</version>
         </dependency>
-        <!-- HTTP -->
         <dependency>
-            <groupId>com.ning</groupId>
-            <artifactId>async-http-client</artifactId>
-            <version>1.9.40</version>
+            <groupId>com.typesafe.akka</groupId>
+            <artifactId>akka-http-core_${scala.version.short}</artifactId>
+            <version>10.0.7</version>
         </dependency>
         <!-- JSON -->
         <dependency>
@@ -133,6 +132,11 @@
             <artifactId>json4s-jackson_${scala.version.short}</artifactId>
             <version>3.5.2</version>
         </dependency>
+        <dependency>
+            <groupId>de.heikoseeberger</groupId>
+            <artifactId>akka-http-json4s_${scala.version.short}</artifactId>
+            <version>1.16.1</version>
+        </dependency>
         <!-- BITCOIN -->
         <dependency>
             <groupId>fr.acinq</groupId>
@@ -176,12 +180,12 @@
         <dependency>
             <groupId>org.jgrapht</groupId>
             <artifactId>jgrapht-core</artifactId>
-            <version>0.9.0</version>
+            <version>1.0.1</version>
         </dependency>
         <dependency>
             <groupId>org.jgrapht</groupId>
             <artifactId>jgrapht-ext</artifactId>
-            <version>0.9.0</version>
+            <version>1.0.1</version>
             <exclusions>
                 <exclusion>
                     <groupId>org.tinyjee.jgraphx</groupId>

eclair-core/src/main/resources/electrum/servers_regtest.json

@@ -1,4 +1,10 @@
 {
-        "127.0.0.1": {"t":"51001", "s":"51002"},
-        "10.0.2.2": {"t":"51001", "s":"51002"}
+  "127.0.0.1": {
+    "t": "51001",
+    "s": "51002"
+  },
+  "10.0.2.2": {
+    "t": "51001",
+    "s": "51002"
+  }
 }

eclair-core/src/main/resources/electrum/servers_testnet.json

@@ -1,5 +1,14 @@
 {
-        "testnetnode.arihanc.com": {"t":"51001", "s":"51002"},
-        "testnet.hsmiths.com": {"t":"53011", "s":"53012"},
-        "electrum.akinbo.org": {"t":"51001", "s":"51002"}
+  "testnetnode.arihanc.com": {
+    "t": "51001",
+    "s": "51002"
+  },
+  "testnet.hsmiths.com": {
+    "t": "53011",
+    "s": "53012"
+  },
+  "electrum.akinbo.org": {
+    "t": "51001",
+    "s": "51002"
+  }
 }

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

@@ -13,7 +13,7 @@ eclair {
     port = 8080
   }
 
-  watcher-type = "electrum" // other *experimental* values include "bitcoinj" or "electrum"
+  watcher-type = "bitcoind" // other *experimental* values include "bitcoinj" or "electrum"
 
   bitcoind {
     host = "localhost"
@@ -47,7 +47,7 @@ eclair {
   node-color = "49daaa"
   global-features = ""
   local-features = "08" // initial_routing_sync
-  channel-flags = 0 // do not announce channels
+  channel-flags = 1 // announce channels
   dust-limit-satoshis = 542
   default-feerate-per-kb = 20000  // default bitcoin core value
 
@@ -81,21 +81,4 @@ eclair {
   auto-reconnect = true
 
   payment-handler = "local"
-}
-akka {
-  loggers = ["akka.event.slf4j.Slf4jLogger"]
-  loglevel = "DEBUG"
-
-  actor {
-    debug {
-      # enable DEBUG logging of all LoggingFSMs for events, transitions and timers
-      fsm = on
-    }
-  }
-
-  http {
-    host-connection-pool {
-      max-open-requests = 64
-    }
-  }
 }

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

@@ -8,8 +8,11 @@ import akka.event.{DiagnosticLoggingAdapter, LoggingAdapter}
   * See https://groups.google.com/forum/#!topic/akka-user/0CxR8CImr4Q
   */
 trait FSMDiagnosticActorLogging[S, D] extends FSM[S, D] {
+
   import akka.event.Logging._
+
   val diagLog: DiagnosticLoggingAdapter = akka.event.Logging(this)
+
   def mdc(currentMessage: Any): MDC = emptyMDC
 
   override def log: LoggingAdapter = diagLog

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

@@ -2,7 +2,6 @@ package fr.acinq.eclair
 
 
 import java.util.BitSet
-import java.util.function.IntPredicate
 
 import fr.acinq.bitcoin.BinaryData
 
@@ -20,14 +19,14 @@ object Features {
     * @param features feature bits
     * @return true if an initial dump of the routing table is requested
     */
-  def initialRoutingSync(features: BitSet) : Boolean = features.get(INITIAL_ROUTING_SYNC_BIT_OPTIONAL)
+  def initialRoutingSync(features: BitSet): Boolean = features.get(INITIAL_ROUTING_SYNC_BIT_OPTIONAL)
 
   /**
     *
     * @param features feature bits
     * @return true if an initial dump of the routing table is requested
     */
-  def initialRoutingSync(features: BinaryData) : Boolean = initialRoutingSync(BitSet.valueOf(features.reverse.toArray))
+  def initialRoutingSync(features: BinaryData): Boolean = initialRoutingSync(BitSet.valueOf(features.reverse.toArray))
 
   /**
     * Check that the features that we understand are correctly specified, and that there are no mandatory features that
@@ -35,7 +34,7 @@ object Features {
     */
   def areSupported(bitset: BitSet): Boolean = {
     // for now there is no mandatory feature bit, so we don't support features with any even bit set
-    for(i <- 0 until bitset.length() by 2) {
+    for (i <- 0 until bitset.length() by 2) {
       if (bitset.get(i)) return false
     }
     return true

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

@@ -1,37 +0,0 @@
-package fr.acinq.eclair
-
-import com.ning.http.client.{AsyncCompletionHandler, AsyncHttpClient, AsyncHttpClientConfig, Response}
-import grizzled.slf4j.Logging
-import org.json4s.DefaultFormats
-import org.json4s.JsonAST.{JNothing, JValue}
-import org.json4s.jackson.JsonMethods.parse
-
-import scala.concurrent.{ExecutionContext, Future, Promise}
-import scala.util.{Failure, Success, Try}
-
-object HttpHelper extends Logging {
-
-  val client = new AsyncHttpClient(new AsyncHttpClientConfig.Builder().setAcceptAnyCertificate(true).build())
-
-  implicit val formats = DefaultFormats
-
-  def get(url: String)(implicit ec: ExecutionContext): Future[JValue] = {
-    val promise = Promise[JValue]
-    client
-      .prepareGet(url)
-      .execute(new AsyncCompletionHandler[Unit] {
-        override def onCompleted(response: Response): Unit = {
-          Try(parse(response.getResponseBody)) match {
-            case Success(json) => promise.success(json)
-            case Failure(t) => promise.success(JNothing)
-          }
-        }
-      })
-    val f = promise.future
-    f onFailure {
-      case t: Throwable => logger.error(s"GET $url failed: ", t)
-    }
-    f
-  }
-
-}

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

@@ -2,10 +2,10 @@ package fr.acinq.eclair
 
 import java.io.File
 import java.net.InetSocketAddress
+import java.nio.file.Files
 import java.sql.DriverManager
 import java.util.concurrent.TimeUnit
 
-import com.google.common.io.Files
 import com.typesafe.config.{Config, ConfigFactory}
 import fr.acinq.bitcoin.Crypto.PrivateKey
 import fr.acinq.bitcoin.DeterministicWallet.ExtendedPrivateKey
@@ -57,8 +57,11 @@ case class NodeParams(extendedPrivateKey: ExtendedPrivateKey,
 object NodeParams {
 
   sealed trait WatcherType
+
   object BITCOIND extends WatcherType
+
   object BITCOINJ extends WatcherType
+
   object ELECTRUM extends WatcherType
 
   /**
@@ -80,10 +83,10 @@ object NodeParams {
 
     val seedPath = new File(datadir, "seed.dat")
     val seed: BinaryData = seedPath.exists() match {
-      case true => Files.toByteArray(seedPath)
+      case true => Files.readAllBytes(seedPath.toPath)
       case false =>
         val seed = randomKey.toBin
-        Files.write(seed, seedPath)
+        Files.write(seedPath.toPath, seed)
         seed
     }
     val master = DeterministicWallet.generate(seed)
@@ -135,15 +138,15 @@ object NodeParams {
       peersDb = peersDb,
       networkDb = networkDb,
       preimagesDb = preimagesDb,
-      routerBroadcastInterval = FiniteDuration(config.getDuration("router-broadcast-interval", TimeUnit.SECONDS), TimeUnit.SECONDS),
-      routerValidateInterval = FiniteDuration(config.getDuration("router-validate-interval", TimeUnit.SECONDS), TimeUnit.SECONDS),
-      pingInterval = FiniteDuration(config.getDuration("ping-interval", TimeUnit.SECONDS), TimeUnit.SECONDS),
+      routerBroadcastInterval = FiniteDuration(config.getDuration("router-broadcast-interval").getSeconds, TimeUnit.SECONDS),
+      routerValidateInterval = FiniteDuration(config.getDuration("router-validate-interval").getSeconds, TimeUnit.SECONDS),
+      pingInterval = FiniteDuration(config.getDuration("ping-interval").getSeconds, TimeUnit.SECONDS),
       maxFeerateMismatch = config.getDouble("max-feerate-mismatch"),
       updateFeeMinDiffRatio = config.getDouble("update-fee_min-diff-ratio"),
       autoReconnect = config.getBoolean("auto-reconnect"),
       chainHash = chainHash,
       channelFlags = config.getInt("channel-flags").toByte,
-      channelExcludeDuration = FiniteDuration(config.getDuration("channel-exclude-duration", TimeUnit.SECONDS), TimeUnit.SECONDS),
+      channelExcludeDuration = FiniteDuration(config.getDuration("channel-exclude-duration").getSeconds, TimeUnit.SECONDS),
       watcherType = watcherType)
   }
 }

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

@@ -4,29 +4,35 @@ import java.io.File
 import java.net.InetSocketAddress
 
 import akka.actor.{ActorRef, ActorSystem, Props, SupervisorStrategy}
+import akka.http.scaladsl.Http
+import akka.pattern.after
+import akka.stream.{ActorMaterializer, BindFailedException}
 import akka.util.Timeout
 import com.typesafe.config.{Config, ConfigFactory}
-import fr.acinq.bitcoin.Block
-import fr.acinq.eclair.NodeParams.{BITCOINJ, ELECTRUM}
+import fr.acinq.bitcoin.{BinaryData, Block}
+import fr.acinq.eclair.NodeParams.{BITCOIND, BITCOINJ, ELECTRUM}
+import fr.acinq.eclair.api.{GetInfoResponse, Service}
+import fr.acinq.eclair.blockchain.bitcoind.rpc.{BitcoinJsonRPCClient, ExtendedBitcoinClient}
+import fr.acinq.eclair.blockchain.bitcoind.zmq.ZMQActor
+import fr.acinq.eclair.blockchain.bitcoind.{BitcoinCoreWallet, ZmqWatcher}
 import fr.acinq.eclair.blockchain.bitcoinj.{BitcoinjKit, BitcoinjWallet, BitcoinjWatcher}
 import fr.acinq.eclair.blockchain.electrum.{ElectrumClient, ElectrumEclairWallet, ElectrumWallet, ElectrumWatcher}
 import fr.acinq.eclair.blockchain.fee.{ConstantFeeProvider, _}
 import fr.acinq.eclair.blockchain.{EclairWallet, _}
 import fr.acinq.eclair.channel.Register
-import fr.acinq.eclair.io.Switchboard
+import fr.acinq.eclair.io.{Server, Switchboard}
 import fr.acinq.eclair.payment._
 import fr.acinq.eclair.router._
 import grizzled.slf4j.Logging
 
 import scala.collection.JavaConversions._
 import scala.concurrent.duration._
-import scala.concurrent.{Await, ExecutionContext, Future}
-
+import scala.concurrent.{Await, ExecutionContext, Future, Promise}
 
 /**
   * Created by PM on 25/01/2016.
   */
-class Setup(datadir: File, wallet_opt: Option[EclairWallet] = None, overrideDefaults: Config = ConfigFactory.empty(), actorSystem: ActorSystem = ActorSystem()) extends Logging {
+class Setup(datadir: File, overrideDefaults: Config = ConfigFactory.empty(), actorSystem: ActorSystem = ActorSystem()) extends Logging {
 
   logger.info(s"hello!")
   logger.info(s"version=${getClass.getPackage.getImplementationVersion} commit=${getClass.getPackage.getSpecificationVersion}")
@@ -35,37 +41,65 @@ class Setup(datadir: File, wallet_opt: Option[EclairWallet] = None, overrideDefa
   val nodeParams = NodeParams.makeNodeParams(datadir, config)
   val chain = config.getString("chain")
 
+  // early checks
+  DBCompatChecker.checkDBCompatibility(nodeParams)
+  PortChecker.checkAvailable(config.getString("server.binding-ip"), config.getInt("server.port"))
+
   logger.info(s"nodeid=${nodeParams.privateKey.publicKey.toBin} alias=${nodeParams.alias}")
   logger.info(s"using chain=$chain chainHash=${nodeParams.chainHash}")
 
+  logger.info(s"initializing secure random generator")
+  // this will force the secure random instance to initialize itself right now, making sure it doesn't hang later (see comment in package.scala)
+  secureRandom.nextInt()
+
   implicit val system = actorSystem
+  implicit val materializer = ActorMaterializer()
   implicit val timeout = Timeout(30 seconds)
   implicit val formats = org.json4s.DefaultFormats
   implicit val ec = ExecutionContext.Implicits.global
 
-  def bootstrap: Future[Kit] = Future {
+  val bitcoin = nodeParams.watcherType match {
+    case BITCOIND =>
+      val bitcoinClient = new ExtendedBitcoinClient(new BitcoinJsonRPCClient(
+        user = config.getString("bitcoind.rpcuser"),
+        password = config.getString("bitcoind.rpcpassword"),
+        host = config.getString("bitcoind.host"),
+        port = config.getInt("bitcoind.rpcport")))
+      val future = for {
+        json <- bitcoinClient.rpcClient.invoke("getblockchaininfo").recover { case _ => throw BitcoinRPCConnectionException }
+        progress = (json \ "verificationprogress").extract[Double]
+        chainHash <- bitcoinClient.rpcClient.invoke("getblockhash", 0).map(_.extract[String]).map(BinaryData(_)).map(x => BinaryData(x.reverse))
+        bitcoinVersion <- bitcoinClient.rpcClient.invoke("getnetworkinfo").map(json => (json \ "version")).map(_.extract[String])
+      } yield (progress, chainHash, bitcoinVersion)
+      // blocking sanity checks
+      val (progress, chainHash, bitcoinVersion) = Await.result(future, 10 seconds)
+      assert(chainHash == nodeParams.chainHash, s"chainHash mismatch (conf=${nodeParams.chainHash} != bitcoind=$chainHash)")
+      assert(progress > 0.99, "bitcoind should be synchronized")
+      // TODO: add a check on bitcoin version?
+      Bitcoind(bitcoinClient)
+    case BITCOINJ =>
+      logger.warn("EXPERIMENTAL BITCOINJ MODE ENABLED!!!")
+      val staticPeers = config.getConfigList("bitcoinj.static-peers").map(c => new InetSocketAddress(c.getString("host"), c.getInt("port"))).toList
+      logger.info(s"using staticPeers=$staticPeers")
+      val bitcoinjKit = new BitcoinjKit(chain, datadir, staticPeers)
+      bitcoinjKit.startAsync()
+      Await.ready(bitcoinjKit.initialized, 10 seconds)
+      Bitcoinj(bitcoinjKit)
+    case ELECTRUM =>
+      logger.warn("EXPERIMENTAL ELECTRUM MODE ENABLED!!!")
+      val addressesFile = chain match {
+        case "test" => "/electrum/servers_testnet.json"
+        case "regtest" => "/electrum/servers_regtest.json"
+      }
+      val stream = classOf[Setup].getResourceAsStream(addressesFile)
+      val addresses = ElectrumClient.readServerAddresses(stream)
+      val electrumClient = system.actorOf(SimpleSupervisor.props(Props(new ElectrumClient(addresses)), "electrum-client", SupervisorStrategy.Resume))
+      Electrum(electrumClient)
+  }
 
-    val bitcoin = nodeParams.watcherType match {
-      case BITCOINJ =>
-        logger.warn("EXPERIMENTAL BITCOINJ MODE ENABLED!!!")
-        val staticPeers = config.getConfigList("bitcoinj.static-peers").map(c => new InetSocketAddress(c.getString("host"), c.getInt("port"))).toList
-        logger.info(s"using staticPeers=$staticPeers")
-        val bitcoinjKit = new BitcoinjKit(chain, datadir, staticPeers)
-        bitcoinjKit.startAsync()
-        Await.ready(bitcoinjKit.initialized, 10 seconds)
-        Bitcoinj(bitcoinjKit)
-      case ELECTRUM =>
-        logger.warn("EXPERIMENTAL ELECTRUM MODE ENABLED!!!")
-        val addressesFile = chain match {
-          case "test" => "/electrum/servers_testnet.json"
-          case "regtest" => "/electrum/servers_regtest.json"
-        }
-        val stream = classOf[Setup].getResourceAsStream(addressesFile)
-        val addresses = ElectrumClient.readServerAddresses(stream)
-        val electrumClient =  system.actorOf(SimpleSupervisor.props(Props(new ElectrumClient(addresses)), "electrum-client", SupervisorStrategy.Resume))
-        Electrum(electrumClient)
-      case _ => ???
-    }
+  def bootstrap: Future[Kit] = {
+    val zmqConnected = Promise[Boolean]()
+    val tcpBound = Promise[Unit]()
 
     val defaultFeerates = FeeratesPerByte(block_1 = config.getLong("default-feerates.delay-blocks.1"), blocks_2 = config.getLong("default-feerates.delay-blocks.2"), blocks_6 = config.getLong("default-feerates.delay-blocks.6"), blocks_12 = config.getLong("default-feerates.delay-blocks.12"), blocks_36 = config.getLong("default-feerates.delay-blocks.36"), blocks_72 = config.getLong("default-feerates.delay-blocks.72"))
     Globals.feeratesPerByte.set(defaultFeerates)
@@ -73,6 +107,7 @@ class Setup(datadir: File, wallet_opt: Option[EclairWallet] = None, overrideDefa
     logger.info(s"initial feeratesPerByte=${Globals.feeratesPerByte.get()}")
     val feeProvider = (chain, bitcoin) match {
       case ("regtest", _) => new ConstantFeeProvider(defaultFeerates)
+      case (_, Bitcoind(client)) => new FallbackFeeProvider(new EarnDotComFeeProvider() :: new BitcoinCoreFeeProvider(client.rpcClient, defaultFeerates) :: new ConstantFeeProvider(defaultFeerates) :: Nil) // order matters!
       case _ => new FallbackFeeProvider(new EarnDotComFeeProvider() :: new ConstantFeeProvider(defaultFeerates) :: Nil) // order matters!
     }
     system.scheduler.schedule(0 seconds, 10 minutes)(feeProvider.getFeerates.map {
@@ -84,23 +119,25 @@ class Setup(datadir: File, wallet_opt: Option[EclairWallet] = None, overrideDefa
     })
 
     val watcher = bitcoin match {
+      case Bitcoind(bitcoinClient) =>
+        system.actorOf(SimpleSupervisor.props(Props(new ZMQActor(config.getString("bitcoind.zmq"), Some(zmqConnected))), "zmq", SupervisorStrategy.Restart))
+        system.actorOf(SimpleSupervisor.props(ZmqWatcher.props(bitcoinClient), "watcher", SupervisorStrategy.Resume))
       case Bitcoinj(bitcoinj) =>
+        zmqConnected.success(true)
         system.actorOf(SimpleSupervisor.props(BitcoinjWatcher.props(bitcoinj), "watcher", SupervisorStrategy.Resume))
       case Electrum(electrumClient) =>
+        zmqConnected.success(true)
         system.actorOf(SimpleSupervisor.props(Props(new ElectrumWatcher(electrumClient)), "watcher", SupervisorStrategy.Resume))
-      case _ => ???
     }
 
     val wallet = bitcoin match {
-      case _ if wallet_opt.isDefined => wallet_opt.get
+      case Bitcoind(bitcoinClient) => new BitcoinCoreWallet(bitcoinClient.rpcClient, watcher)
       case Bitcoinj(bitcoinj) => new BitcoinjWallet(bitcoinj.initialized.map(_ => bitcoinj.wallet()))
       case Electrum(electrumClient) =>
         val electrumSeedPath = new File(datadir, "electrum_seed.dat")
         val electrumWallet = system.actorOf(ElectrumWallet.props(electrumSeedPath, electrumClient, ElectrumWallet.WalletParameters(Block.RegtestGenesisBlock.hash, allowSpendUnconfirmed = true)), "electrum-wallet")
         new ElectrumEclairWallet(electrumWallet)
-      case _ => ???
     }
-
     wallet.getFinalAddress.map {
       case address => logger.info(s"initial wallet address=$address")
     }
@@ -114,6 +151,7 @@ class Setup(datadir: File, wallet_opt: Option[EclairWallet] = None, overrideDefa
     val router = system.actorOf(SimpleSupervisor.props(Router.props(nodeParams, watcher), "router", SupervisorStrategy.Resume))
     val switchboard = system.actorOf(SimpleSupervisor.props(Switchboard.props(nodeParams, watcher, router, relayer, wallet), "switchboard", SupervisorStrategy.Resume))
     val paymentInitiator = system.actorOf(SimpleSupervisor.props(PaymentInitiator.props(nodeParams.privateKey.publicKey, router, register), "payment-initiator", SupervisorStrategy.Restart))
+    val server = system.actorOf(SimpleSupervisor.props(Server.props(nodeParams, switchboard, new InetSocketAddress(config.getString("server.binding-ip"), config.getInt("server.port")), Some(tcpBound)), "server", SupervisorStrategy.Restart))
 
     val kit = Kit(
       nodeParams = nodeParams,
@@ -125,16 +163,40 @@ class Setup(datadir: File, wallet_opt: Option[EclairWallet] = None, overrideDefa
       router = router,
       switchboard = switchboard,
       paymentInitiator = paymentInitiator,
+      server = server,
       wallet = wallet)
 
-    kit
+    val api = new Service {
+
+      override def getInfoResponse: Future[GetInfoResponse] = Future.successful(GetInfoResponse(nodeId = nodeParams.privateKey.publicKey, alias = nodeParams.alias, port = config.getInt("server.port"), chainHash = nodeParams.chainHash, blockHeight = Globals.blockCount.intValue()))
+
+      override def appKit = kit
+    }
+    val httpBound = Http().bindAndHandle(api.route, config.getString("api.binding-ip"), config.getInt("api.port")).recover {
+      case _: BindFailedException => throw TCPBindException(config.getInt("api.port"))
+    }
+
+    val zmqTimeout = after(5 seconds, using = system.scheduler)(Future.failed(BitcoinZMQConnectionTimeoutException))
+    val tcpTimeout = after(5 seconds, using = system.scheduler)(Future.failed(TCPBindException(config.getInt("server.port"))))
+    val httpTimeout = after(5 seconds, using = system.scheduler)(Future.failed(TCPBindException(config.getInt("api.port"))))
+
+    for {
+      _ <- Future.firstCompletedOf(zmqConnected.future :: zmqTimeout :: Nil)
+      _ <- Future.firstCompletedOf(tcpBound.future :: tcpTimeout :: Nil)
+      _ <- Future.firstCompletedOf(httpBound :: httpTimeout :: Nil)
+    } yield kit
+
   }
 
 }
 
+
+// @formatter:off
 sealed trait Bitcoin
+case class Bitcoind(extendedBitcoinClient: ExtendedBitcoinClient) extends Bitcoin
 case class Bitcoinj(bitcoinjKit: BitcoinjKit) extends Bitcoin
 case class Electrum(electrumClient: ActorRef) extends Bitcoin
+// @formatter:on
 
 case class Kit(nodeParams: NodeParams,
                system: ActorSystem,
@@ -145,6 +207,9 @@ case class Kit(nodeParams: NodeParams,
                router: ActorRef,
                switchboard: ActorRef,
                paymentInitiator: ActorRef,
+               server: ActorRef,
                wallet: EclairWallet)
 
+case object BitcoinZMQConnectionTimeoutException extends RuntimeException("could not connect to bitcoind using zeromq")
 
+case object BitcoinRPCConnectionException extends RuntimeException("could not connect to bitcoind using json-rpc")

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

@@ -31,4 +31,5 @@ object UInt64 {
 
     implicit def longToUint64(l: Long) = UInt64(l)
   }
+
 }

eclair-core/src/main/scala/fr/acinq/eclair/api/JsonSerializers.scala

@@ -0,0 +1,76 @@
+package fr.acinq.eclair.api
+
+import fr.acinq.bitcoin.Crypto.{Point, PrivateKey, PublicKey, Scalar}
+import fr.acinq.bitcoin.{BinaryData, Transaction}
+import fr.acinq.eclair.channel.State
+import fr.acinq.eclair.crypto.ShaChain
+import fr.acinq.eclair.transactions.Transactions.TransactionWithInputInfo
+import org.json4s.CustomSerializer
+import org.json4s.JsonAST.{JNull, JString}
+
+/**
+  * Created by PM on 28/01/2016.
+  */
+class BinaryDataSerializer extends CustomSerializer[BinaryData](format => ( {
+  case JString(hex) if (false) => // NOT IMPLEMENTED
+    ???
+}, {
+  case x: BinaryData => JString(x.toString())
+}
+))
+
+class StateSerializer extends CustomSerializer[State](format => ( {
+  case JString(x) if (false) => // NOT IMPLEMENTED
+    ???
+}, {
+  case x: State => JString(x.toString())
+}
+))
+
+class ShaChainSerializer extends CustomSerializer[ShaChain](format => ( {
+  case JString(x) if (false) => // NOT IMPLEMENTED
+    ???
+}, {
+  case x: ShaChain => JNull
+}
+))
+
+class PublicKeySerializer extends CustomSerializer[PublicKey](format => ( {
+  case JString(x) if (false) => // NOT IMPLEMENTED
+    ???
+}, {
+  case x: PublicKey => JString(x.toString())
+}
+))
+
+class PrivateKeySerializer extends CustomSerializer[PrivateKey](format => ( {
+  case JString(x) if (false) => // NOT IMPLEMENTED
+    ???
+}, {
+  case x: PrivateKey => JString("XXX")
+}
+))
+
+class PointSerializer extends CustomSerializer[Point](format => ( {
+  case JString(x) if (false) => // NOT IMPLEMENTED
+    ???
+}, {
+  case x: Point => JString(x.toString())
+}
+))
+
+class ScalarSerializer extends CustomSerializer[Scalar](format => ( {
+  case JString(x) if (false) => // NOT IMPLEMENTED
+    ???
+}, {
+  case x: Scalar => JString("XXX")
+}
+))
+
+class TransactionWithInputInfoSerializer extends CustomSerializer[TransactionWithInputInfo](format => ( {
+  case JString(x) if (false) => // NOT IMPLEMENTED
+    ???
+}, {
+  case x: TransactionWithInputInfo => JString(Transaction.write(x.tx).toString())
+}
+))

eclair-core/src/main/scala/fr/acinq/eclair/api/Service.scala

@@ -0,0 +1,148 @@
+package fr.acinq.eclair.api
+
+import java.net.InetSocketAddress
+
+import akka.actor.ActorRef
+import akka.http.scaladsl.model.HttpMethods._
+import akka.http.scaladsl.model.StatusCodes
+import akka.http.scaladsl.model.headers.CacheDirectives.{`max-age`, `no-store`, public}
+import akka.http.scaladsl.model.headers.HttpOriginRange.*
+import akka.http.scaladsl.model.headers._
+import akka.http.scaladsl.server.Directives._
+import akka.pattern.ask
+import akka.util.Timeout
+import de.heikoseeberger.akkahttpjson4s.Json4sSupport
+import de.heikoseeberger.akkahttpjson4s.Json4sSupport.ShouldWritePretty
+import fr.acinq.bitcoin.Crypto.PublicKey
+import fr.acinq.bitcoin.{BinaryData, MilliSatoshi, Satoshi}
+import fr.acinq.eclair.Kit
+import fr.acinq.eclair.channel._
+import fr.acinq.eclair.io.Switchboard.{NewChannel, NewConnection}
+import fr.acinq.eclair.payment.{PaymentRequest, PaymentResult, ReceivePayment, SendPayment}
+import fr.acinq.eclair.wire.{ChannelAnnouncement, NodeAnnouncement}
+import grizzled.slf4j.Logging
+import org.json4s.JsonAST.{JInt, JString}
+import org.json4s.{JValue, jackson}
+
+import scala.concurrent.duration._
+import scala.concurrent.{ExecutionContext, Future}
+import scala.util.{Failure, Success}
+
+/**
+  * Created by PM on 25/01/2016.
+  */
+
+// @formatter:off
+case class JsonRPCBody(jsonrpc: String = "1.0", id: String = "scala-client", method: String, params: Seq[JValue])
+case class Error(code: Int, message: String)
+case class JsonRPCRes(result: AnyRef, error: Option[Error], id: String)
+case class Status(node_id: String)
+case class GetInfoResponse(nodeId: PublicKey, alias: String, port: Int, chainHash: BinaryData, blockHeight: Int)
+case class ChannelInfo(shortChannelId: String, nodeId1: PublicKey , nodeId2: PublicKey)
+// @formatter:on
+
+trait Service extends Logging {
+
+  implicit def ec: ExecutionContext = ExecutionContext.Implicits.global
+
+  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 TransactionWithInputInfoSerializer
+  implicit val timeout = Timeout(30 seconds)
+  implicit val shouldWritePretty: ShouldWritePretty = ShouldWritePretty.True
+
+  import Json4sSupport.{marshaller, unmarshaller}
+
+  def appKit: Kit
+
+  def getInfoResponse: Future[GetInfoResponse]
+
+  val customHeaders = `Access-Control-Allow-Origin`(*) ::
+    `Access-Control-Allow-Headers`("Content-Type, Authorization") ::
+    `Access-Control-Allow-Methods`(PUT, GET, POST, DELETE, OPTIONS) ::
+    `Cache-Control`(public, `no-store`, `max-age`(0)) ::
+    `Access-Control-Allow-Headers`("x-requested-with") :: Nil
+
+  def getChannel(channelId: String): Future[ActorRef] =
+    for {
+      channels <- (appKit.register ? 'channels).mapTo[Map[BinaryData, ActorRef]]
+    } yield channels.get(BinaryData(channelId)).getOrElse(throw new RuntimeException("unknown channel"))
+
+  val route =
+    respondWithDefaultHeaders(customHeaders) {
+      pathSingleSlash {
+        post {
+          entity(as[JsonRPCBody]) {
+            req =>
+              val kit = appKit
+              import kit._
+              val f_res: Future[AnyRef] = req match {
+                case JsonRPCBody(_, _, "getinfo", _) => getInfoResponse
+                case JsonRPCBody(_, _, "connect", JString(nodeId) :: JString(host) :: JInt(port) :: Nil) =>
+                  (switchboard ? NewConnection(PublicKey(nodeId), new InetSocketAddress(host, port.toInt), None)).mapTo[String]
+                case JsonRPCBody(_, _, "open", JString(nodeId) :: JString(host) :: JInt(port) :: JInt(fundingSatoshi) :: JInt(pushMsat) :: options) =>
+                  val channelFlags = options match {
+                    case JInt(value) :: Nil => Some(value.toByte)
+                    case _ => None // TODO: too lax?
+                  }
+                  (switchboard ? NewConnection(PublicKey(nodeId), new InetSocketAddress(host, port.toInt), Some(NewChannel(Satoshi(fundingSatoshi.toLong), MilliSatoshi(pushMsat.toLong), channelFlags)))).mapTo[String]
+                case JsonRPCBody(_, _, "peers", _) =>
+                  (switchboard ? 'peers).mapTo[Map[PublicKey, ActorRef]].map(_.map(_._1.toBin))
+                case JsonRPCBody(_, _, "channels", _) =>
+                  (register ? 'channels).mapTo[Map[Long, ActorRef]].map(_.keys)
+                case JsonRPCBody(_, _, "channel", JString(channelId) :: Nil) =>
+                  getChannel(channelId).flatMap(_ ? CMD_GETINFO).mapTo[RES_GETINFO]
+                case JsonRPCBody(_, _, "allnodes", _) =>
+                  (router ? 'nodes).mapTo[Iterable[NodeAnnouncement]].map(_.map(_.nodeId))
+                case JsonRPCBody(_, _, "allchannels", _) =>
+                  (router ? 'channels).mapTo[Iterable[ChannelAnnouncement]].map(_.map(c => ChannelInfo(c.shortChannelId.toHexString, c.nodeId1, c.nodeId2)))
+                case JsonRPCBody(_, _, "receive", JInt(amountMsat) :: JString(description) :: Nil) =>
+                  (paymentHandler ? ReceivePayment(MilliSatoshi(amountMsat.toLong), description)).mapTo[PaymentRequest].map(PaymentRequest.write)
+                case JsonRPCBody(_, _, "send", JInt(amountMsat) :: JString(paymentHash) :: JString(nodeId) :: Nil) =>
+                  (paymentInitiator ? SendPayment(amountMsat.toLong, paymentHash, PublicKey(nodeId))).mapTo[PaymentResult]
+                case JsonRPCBody(_, _, "send", JString(paymentRequest) :: rest) =>
+                  for {
+                    req <- Future(PaymentRequest.read(paymentRequest))
+                    amount = (req.amount, rest) match {
+                      case (Some(_), JInt(amt) :: Nil) => amt.toLong // overriding payment request amount with the one provided
+                      case (Some(amt), _) => amt.amount
+                      case (None, JInt(amt) :: Nil) => amt.toLong // amount wasn't specified in request, using custom one
+                      case (None, _) => throw new RuntimeException("you need to manually specify an amount for this payment request")
+                    }
+                    sendPayment = req.minFinalCltvExpiry match {
+                      case None => SendPayment(amount, req.paymentHash, req.nodeId)
+                      case Some(value) => SendPayment(amount, req.paymentHash, req.nodeId, value)
+                    }
+                    res <- (paymentInitiator ? sendPayment).mapTo[PaymentResult]
+                  } yield res
+                case JsonRPCBody(_, _, "close", JString(channelId) :: JString(scriptPubKey) :: Nil) =>
+                  getChannel(channelId).flatMap(_ ? CMD_CLOSE(scriptPubKey = Some(scriptPubKey))).mapTo[String]
+                case JsonRPCBody(_, _, "close", JString(channelId) :: Nil) =>
+                  getChannel(channelId).flatMap(_ ? CMD_CLOSE(scriptPubKey = None)).mapTo[String]
+                case JsonRPCBody(_, _, "help", _) =>
+                  Future.successful(List(
+                    "connect (nodeId, host, port): connect to another lightning node through a secure connection",
+                    "open (nodeId, host, port, fundingSatoshi, pushMsat, channelFlags = 0x01): open a channel with another lightning node",
+                    "peers: list existing local peers",
+                    "channels: list existing local channels",
+                    "channel (channelId): retrieve detailed information about a given channel",
+                    "allnodes: list all known nodes",
+                    "allchannels: list all known channels",
+                    "receive (amountMsat, description): generate a payment request for a given amount",
+                    "send (amountMsat, paymentHash, nodeId): send a payment to a lightning node",
+                    "send (paymentRequest): send a payment to a lightning node using a BOLT11 payment request",
+                    "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",
+                    "help: display this message"))
+                case _ => Future.failed(new RuntimeException("method not found"))
+              }
+
+              onComplete(f_res) {
+                case Success(res) => complete(JsonRPCRes(res, None, req.id))
+                case Failure(t) => complete(StatusCodes.InternalServerError, JsonRPCRes(null, Some(Error(-1, t.getMessage)), req.id))
+              }
+          }
+        }
+      }
+    }
+}

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

@@ -30,6 +30,7 @@ trait EclairWallet {
 
   /**
     * Cancels this transaction: this probably translates to "release locks on utxos".
+    *
     * @param tx
     * @return
     */

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

@@ -15,7 +15,7 @@ import scala.concurrent.{ExecutionContext, Future, Promise}
 
 /**
   * Due to bitcoin-core wallet not fully supporting segwit txes yet, our current scheme is:
-  *   utxos <- parent-tx <- funding-tx
+  * utxos <- parent-tx <- funding-tx
   *
   * With:
   *   - utxos may be non-segwit
@@ -200,6 +200,7 @@ class BitcoinCoreWallet(rpcClient: BitcoinJsonRPCClient, watcher: ActorRef)(impl
   /**
     * We currently only put a lock on the parent tx inputs, and we publish the parent tx immediately so there is nothing
     * to do here.
+    *
     * @param tx
     * @return
     */

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

@@ -3,13 +3,20 @@ package fr.acinq.eclair.blockchain.bitcoind.rpc
 import java.io.IOException
 
 import akka.actor.ActorSystem
-import com.ning.http.client._
-import org.json4s.{DefaultFormats, DefaultReaders}
-import org.json4s.JsonAST.{JInt, JNull, JString, JValue}
-import org.json4s.jackson.JsonMethods.parse
-import org.json4s.jackson.Serialization._
+import akka.http.scaladsl.Http
+import akka.http.scaladsl.marshalling.Marshal
+import akka.http.scaladsl.model._
+import akka.http.scaladsl.model.headers.{Authorization, BasicHttpCredentials}
+import akka.http.scaladsl.unmarshalling.Unmarshal
+import akka.stream.{ActorMaterializer, OverflowStrategy, QueueOfferResult}
+import akka.stream.scaladsl.{Keep, Sink, Source}
+import de.heikoseeberger.akkahttpjson4s.Json4sSupport._
+import org.json4s.JsonAST.JValue
+import org.json4s.{DefaultFormats, jackson}
 
 import scala.concurrent.{ExecutionContext, Future, Promise}
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.util.{Failure, Success}
 
 // @formatter:off
 case class JsonRPCRequest(jsonrpc: String = "1.0", id: String = "scala-client", method: String, params: Seq[Any])
@@ -18,50 +25,57 @@ case class JsonRPCResponse(result: JValue, error: Option[Error], id: String)
 case class JsonRPCError(error: Error) extends IOException(s"${error.message} (code: ${error.code})")
 // @formatter:on
 
-class BitcoinJsonRPCClient(config: AsyncHttpClientConfig, host: String, port: Int, ssl: Boolean)(implicit system: ActorSystem) {
-
-    def this(user: String, password: String, host: String = "127.0.0.1", port: Int = 8332, ssl: Boolean = false)(implicit system: ActorSystem) = this(
-      new AsyncHttpClientConfig.Builder()
-        .setRealm(new Realm.RealmBuilder().setPrincipal(user).setPassword(password).setUsePreemptiveAuth(true).setScheme(Realm.AuthScheme.BASIC).build)
-        .build,
-      host,
-      port,
-      ssl
-    )
-
-  val client: AsyncHttpClient = new AsyncHttpClient(config)
+class BitcoinJsonRPCClient(user: String, password: String, host: String = "127.0.0.1", port: Int = 8332, ssl: Boolean = false)(implicit system: ActorSystem) {
 
+  val scheme = if (ssl) "https" else "http"
+  val uri = Uri(s"$scheme://$host:$port")
+  implicit val serialization = jackson.Serialization
   implicit val formats = DefaultFormats
 
-  def invoke(method: String, params: Any*)(implicit ec: ExecutionContext): Future[JValue] = {
-    val promise = Promise[JValue]()
-    client
-      .preparePost((if (ssl) "https" else "http") + s"://$host:$port/")
-      .addHeader("Content-Type", "application/json")
-      .setBody(write(JsonRPCRequest(method = method, params = params)))
-      .execute(new AsyncCompletionHandler[Unit] {
-        override def onCompleted(response: Response): Unit =
-          try {
-            val jvalue = parse(response.getResponseBody)
-            val jerror = jvalue \ "error"
-            val result = jvalue \ "result"
-            if (jerror != JNull) {
-              for {
-                JInt(code) <- jerror \ "code"
-                JString(message) <- jerror \ "message"
-              } yield promise.failure(new JsonRPCError(Error(code.toInt, message)))
-            } else {
-              promise.success(result)
-            }
-          } catch {
-            case t: Throwable => promise.failure(t)
-          }
+  implicit val materializer = ActorMaterializer()
+  val httpClientFlow = Http().cachedHostConnectionPool[Promise[HttpResponse]](host, port)
 
-        override def onThrowable(t: Throwable): Unit = promise.failure(t)
-      })
-    promise.future
+  val queueSize = 512
+  val queue = Source.queue[(HttpRequest, Promise[HttpResponse])](queueSize, OverflowStrategy.dropNew)
+      .via(httpClientFlow)
+      .toMat(Sink.foreach({
+        case ((Success(resp), p)) => p.success(resp)
+        case ((Failure(e), p))    => p.failure(e)
+      }))(Keep.left)
+      .run()
+
+  def queueRequest(request: HttpRequest): Future[HttpResponse] = {
+    val responsePromise = Promise[HttpResponse]()
+    queue.offer(request -> responsePromise).flatMap {
+      case QueueOfferResult.Enqueued    => responsePromise.future
+      case QueueOfferResult.Dropped     => Future.failed(new RuntimeException("Queue overflowed. Try again later."))
+      case QueueOfferResult.Failure(ex) => Future.failed(ex)
+      case QueueOfferResult.QueueClosed => Future.failed(new RuntimeException("Queue was closed (pool shut down) while running the request. Try again later."))
+    }
   }
 
-  def invoke(request: Seq[(String, Seq[Any])])(implicit ec: ExecutionContext): Future[Seq[JValue]] = ???
+  def invoke(method: String, params: Any*)(implicit ec: ExecutionContext): Future[JValue] =
+    for {
+      entity <- Marshal(JsonRPCRequest(method = method, params = params)).to[RequestEntity]
+      httpRes <- queueRequest(HttpRequest(uri = "/", method = HttpMethods.POST).addHeader(Authorization(BasicHttpCredentials(user, password))).withEntity(entity))
+      jsonRpcRes <- Unmarshal(httpRes).to[JsonRPCResponse].map {
+        case JsonRPCResponse(_, Some(error), _) => throw JsonRPCError(error)
+        case o => o
+      } recover {
+        case t: Throwable if httpRes.status == StatusCodes.Unauthorized => throw new RuntimeException("bitcoind replied with 401/Unauthorized (bad user/password?)", t)
+      }
+    } yield jsonRpcRes.result
+
+  def invoke(request: Seq[(String, Seq[Any])])(implicit ec: ExecutionContext): Future[Seq[JValue]] =
+    for {
+      entity <- Marshal(request.map(r => JsonRPCRequest(method = r._1, params = r._2))).to[RequestEntity]
+      httpRes <- queueRequest(HttpRequest(uri = "/", method = HttpMethods.POST).addHeader(Authorization(BasicHttpCredentials(user, password))).withEntity(entity))
+      jsonRpcRes <- Unmarshal(httpRes).to[Seq[JsonRPCResponse]].map {
+        //case JsonRPCResponse(_, Some(error), _) => throw JsonRPCError(error)
+        case o => o
+      } recover {
+        case t: Throwable if httpRes.status == StatusCodes.Unauthorized => throw new RuntimeException("bitcoind replied with 401/Unauthorized (bad user/password?)", t)
+      }
+    } yield jsonRpcRes.map(_.result)
 
 }

eclair-core/src/main/scala/fr/acinq/eclair/blockchain/bitcoinj/BitcoinjKit.scala

@@ -7,11 +7,11 @@ import akka.actor.ActorSystem
 import com.google.common.util.concurrent.{FutureCallback, Futures}
 import fr.acinq.bitcoin.Transaction
 import fr.acinq.eclair.Globals
-import fr.acinq.eclair.blockchain.bitcoinj.BitcoinjKit._
 import fr.acinq.eclair.blockchain.CurrentBlockCount
+import fr.acinq.eclair.blockchain.bitcoinj.BitcoinjKit._
 import grizzled.slf4j.Logging
 import org.bitcoinj.core.TransactionConfidence.ConfidenceType
-import org.bitcoinj.core.listeners.{NewBestBlockListener, PeerConnectedEventListener, TransactionConfidenceEventListener, _}
+import org.bitcoinj.core.listeners._
 import org.bitcoinj.core.{Block, Context, FilteredBlock, NetworkParameters, Peer, PeerAddress, StoredBlock, VersionMessage, Transaction => BitcoinjTransaction}
 import org.bitcoinj.kits.WalletAppKit
 import org.bitcoinj.params.{RegTestParams, TestNet3Params}
@@ -22,7 +22,6 @@ import scala.collection.JavaConversions._
 import scala.concurrent.Promise
 import scala.util.Try
 
-
 /**
   * Created by PM on 09/07/2017.
   */
@@ -42,8 +41,8 @@ class BitcoinjKit(chain: String, datadir: File, staticPeers: List[InetSocketAddr
   val atCurrentHeight = atCurrentHeightPromise.future
 
   // tells us when we are at current block height
-//  private val syncedPromise = Promise[Boolean]()
-//  val synced = syncedPromise.future
+  //  private val syncedPromise = Promise[Boolean]()
+  //  val synced = syncedPromise.future
 
   private def updateBlockCount(blockCount: Int) = {
     // when synchronizing we don't want to advertise previous blocks
@@ -62,13 +61,13 @@ class BitcoinjKit(chain: String, datadir: File, staticPeers: List[InetSocketAddr
     peerGroup().setMinRequiredProtocolVersion(70015) // bitcoin core 0.13
     wallet().watchMode = true
 
-//    setDownloadListener(new DownloadProgressTracker {
-//      override def doneDownload(): Unit = {
-//        super.doneDownload()
-//        // may be called multiple times
-//        syncedPromise.trySuccess(true)
-//      }
-//    })
+    //    setDownloadListener(new DownloadProgressTracker {
+    //      override def doneDownload(): Unit = {
+    //        super.doneDownload()
+    //        // may be called multiple times
+    //        syncedPromise.trySuccess(true)
+    //      }
+    //    })
 
     // we set the blockcount to the previous stored block height
     updateBlockCount(chain().getBestChainHeight)

eclair-core/src/main/scala/fr/acinq/eclair/blockchain/bitcoinj/BitcoinjKit2.scala

@@ -1,39 +0,0 @@
-package fr.acinq.eclair.blockchain.bitcoinj
-
-import java.io.File
-
-import fr.acinq.eclair.blockchain.bitcoinj.BitcoinjKit._
-import grizzled.slf4j.Logging
-import org.bitcoinj.core.listeners.PeerConnectedEventListener
-import org.bitcoinj.core.{Peer, VersionMessage}
-import org.bitcoinj.kits.WalletAppKit
-
-import scala.concurrent.Promise
-
-/**
-  * Created by PM on 09/07/2017.
-  */
-class BitcoinjKit2(chain: String, datadir: File) extends WalletAppKit(chain2Params(chain), datadir, "bitcoinj-wallet", true) with Logging {
-
-  // so that we know when the peerGroup/chain/wallet are accessible
-  private val initializedPromise = Promise[Boolean]()
-  val initialized = initializedPromise.future
-
-  override def onSetupCompleted(): Unit = {
-
-    peerGroup().setMinRequiredProtocolVersion(70015) // bitcoin core 0.13
-
-    peerGroup().addConnectedEventListener(new PeerConnectedEventListener {
-      override def onPeerConnected(peer: Peer, peerCount: Int): Unit = {
-        if ((peer.getPeerVersionMessage.localServices & VersionMessage.NODE_WITNESS) == 0) {
-          peer.close()
-        }
-      }
-    })
-
-    initializedPromise.success(true)
-  }
-
-}
-
-

eclair-core/src/main/scala/fr/acinq/eclair/blockchain/bitcoinj/BitcoinjWatcher.scala

@@ -7,16 +7,15 @@ import fr.acinq.bitcoin.Crypto.PublicKey
 import fr.acinq.bitcoin.Script.{pay2wsh, write}
 import fr.acinq.bitcoin.{BinaryData, Satoshi, Transaction, TxIn, TxOut}
 import fr.acinq.eclair.blockchain._
-import fr.acinq.eclair.{Globals, fromShortId}
 import fr.acinq.eclair.channel.BITCOIN_PARENT_TX_CONFIRMED
 import fr.acinq.eclair.transactions.Scripts
+import fr.acinq.eclair.{Globals, fromShortId}
 import org.bitcoinj.core.{Context, Transaction => BitcoinjTransaction}
 import org.bitcoinj.kits.WalletAppKit
 import org.bitcoinj.script.Script
 
 import scala.collection.SortedMap
 import scala.concurrent.ExecutionContext
-import scala.concurrent.duration._
 import scala.util.{Failure, Success, Try}
 
 final case class NewConfidenceLevel(tx: Transaction, blockHeight: Int, confirmations: Int) extends BlockchainEvent
@@ -130,6 +129,7 @@ class BitcoinjWatcher(val kit: WalletAppKit)(implicit ec: ExecutionContext = Exe
 
   /**
     * Bitcoinj needs hints to be able to detect transactions
+    *
     * @param pubkeyScript
     * @return
     */
@@ -189,4 +189,5 @@ class Broadcaster(kit: WalletAppKit) extends Actor with ActorLogging {
     }, context.dispatcher)
   }
 
+
 }

eclair-core/src/main/scala/fr/acinq/eclair/blockchain/electrum/ElectrumEclairWallet.scala

@@ -10,7 +10,7 @@ import grizzled.slf4j.Logging
 
 import scala.concurrent.{ExecutionContext, Future}
 
-class ElectrumEclairWallet(val wallet: ActorRef)(implicit system: ActorSystem, ec: ExecutionContext, timeout: akka.util.Timeout)  extends EclairWallet with Logging {
+class ElectrumEclairWallet(val wallet: ActorRef)(implicit system: ActorSystem, ec: ExecutionContext, timeout: akka.util.Timeout) extends EclairWallet with Logging {
 
   override def getBalance = (wallet ? GetBalance).mapTo[GetBalanceResponse].map(balance => balance.confirmed + balance.unconfirmed)
 
@@ -45,7 +45,7 @@ class ElectrumEclairWallet(val wallet: ActorRef)(implicit system: ActorSystem, e
       case CancelTransactionResponse(_) => false
     }
 
-  def sendPayment(amount: Satoshi, address: String, feeRatePerKw: Long) : Future[String] = {
+  def sendPayment(amount: Satoshi, address: String, feeRatePerKw: Long): Future[String] = {
     val publicKeyScript = Base58Check.decode(address) match {
       case (Base58.Prefix.PubkeyAddressTestnet, pubKeyHash) => Script.pay2pkh(pubKeyHash)
       case (Base58.Prefix.ScriptAddressTestnet, scriptHash) => OP_HASH160 :: OP_PUSHDATA(scriptHash) :: OP_EQUAL :: Nil

eclair-core/src/main/scala/fr/acinq/eclair/blockchain/electrum/ElectrumWallet.scala

@@ -126,19 +126,11 @@ class ElectrumWallet(mnemonics: Seq[String], client: ActorRef, params: ElectrumW
         status = data.status + (scriptHash -> status),
         pendingHistoryRequests = data.pendingHistoryRequests + scriptHash)
 
-      manualTransition(data1)
       goto(stateName) using data1 // goto instead of stay because we want to fire transitions
 
-    case Event(ElectrumClient.GetScriptHashHistoryResponse(scriptHash, items), data) =>
-      log.debug(s"scriptHash=$scriptHash has history=$items")
-      val shadow_items = data.history.get(scriptHash) match {
-        case Some(existing_items) => existing_items.filterNot(item => items.exists(_.tx_hash == item.tx_hash))
-        case None => Nil
-      }
-      shadow_items.foreach(item => log.warning(s"keeping shadow item for txid=${item.tx_hash}"))
-      val items0 = items ++ shadow_items
-
-      val (heights1, pendingTransactionRequests1) = items0.foldLeft((data.heights, data.pendingTransactionRequests)) {
+    case Event(ElectrumClient.GetScriptHashHistoryResponse(scriptHash, history), data) =>
+      log.debug(s"scriptHash=$scriptHash has history=$history")
+      val (heights1, pendingTransactionRequests1) = history.foldLeft((data.heights, data.pendingTransactionRequests)) {
         case ((heights, hashes), item) if !data.transactions.contains(item.tx_hash) && !data.pendingTransactionRequests.contains(item.tx_hash) =>
           // we retrieve the tx if we don't have it and haven't yet requested it
           client ! GetTransaction(item.tx_hash)
@@ -165,8 +157,7 @@ class ElectrumWallet(mnemonics: Seq[String], client: ActorRef, params: ElectrumW
             // no reorg, nothing to do
           }
       }
-      val data1 = data.copy(heights = heights1, history = data.history + (scriptHash -> items0), pendingHistoryRequests = data.pendingHistoryRequests - scriptHash, pendingTransactionRequests = pendingTransactionRequests1)
-      manualTransition(data1)
+      val data1 = data.copy(heights = heights1, history = data.history + (scriptHash -> history), pendingHistoryRequests = data.pendingHistoryRequests - scriptHash, pendingTransactionRequests = pendingTransactionRequests1)
       goto(stateName) using data1 // goto instead of stay because we want to fire transitions
 
     case Event(GetTransactionResponse(tx), data) =>
@@ -178,7 +169,6 @@ class ElectrumWallet(mnemonics: Seq[String], client: ActorRef, params: ElectrumW
           // when we have successfully processed a new tx, we retry all pending txes to see if they can be added now
           data.pendingTransactions.foreach(self ! GetTransactionResponse(_))
           val data1 = data.copy(transactions = data.transactions + (tx.txid -> tx), pendingTransactionRequests = data.pendingTransactionRequests - tx.txid, pendingTransactions = Nil)
-          manualTransition(data1)
           goto(stateName) using data1 // goto instead of stay because we want to fire transitions
         case None =>
           // missing parents
@@ -202,7 +192,6 @@ class ElectrumWallet(mnemonics: Seq[String], client: ActorRef, params: ElectrumW
       val (received, sent, Some(fee)) = data.computeTransactionDelta(tx).get
       // we notify here because the tx won't be downloaded again (it has been added to the state at commit)
       context.system.eventStream.publish(TransactionReceived(tx, data1.computeTransactionDepth(tx.txid), received, sent, Some(fee)))
-      manualTransition(data1)
       goto(stateName) using data1 replying CommitTransactionResponse(tx) // goto instead of stay because we want to fire transitions
 
     case Event(CancelTransaction(tx), data) =>
@@ -233,16 +222,12 @@ class ElectrumWallet(mnemonics: Seq[String], client: ActorRef, params: ElectrumW
     case Event(ElectrumClient.BroadcastTransaction(tx), _) => stay replying ElectrumClient.BroadcastTransactionResponse(tx, Some(Error(-1, "wallet is not connected")))
   }
 
-  /**
-    * Bug in akka 2.3 onTransition won't fire on same-state transitions
-    */
-  def manualTransition(nextStateData: Data) = {
-    if (nextStateData.isReady(params.swipeRange)) {
+  onTransition {
+    case _ -> _ if nextStateData.isReady(params.swipeRange) =>
       val ready = nextStateData.readyMessage
       log.info(s"wallet is ready with $ready")
       context.system.eventStream.publish(ready)
       context.system.eventStream.publish(NewWalletReceiveAddress(nextStateData.currentReceiveAddress))
-    }
   }
 
   initialize()
@@ -357,6 +342,7 @@ object ElectrumWallet {
 
   /**
     * use BIP49 (and not BIP44) since we use p2sh-of-p2wpkh
+    *
     * @param master master key
     * @return the BIP49 account key for this master key: m/49'/1'/0'/0
     */
@@ -364,6 +350,7 @@ object ElectrumWallet {
 
   /**
     * use BIP49 (and not BIP44) since we use p2sh-of-p2wpkh
+    *
     * @param master master key
     * @return the BIP49 change key for this master key: m/49'/1'/0'/1
     */
@@ -423,9 +410,6 @@ object ElectrumWallet {
     * @param heights      transactions heights
     * @param history      script hash -> history
     * @param locks        transactions which lock some of our utxos.
-    * @param pendingHistoryRequests       requests pending a response from the electrum server
-    * @param pendingTransactionRequests   requests pending a response from the electrum server
-    * @param pendingTransactions          transactions received but not yet connected to their parents
     */
   case class Data(tip: ElectrumClient.Header,
                   accountKeys: Vector[ExtendedPrivateKey],
@@ -448,7 +432,7 @@ object ElectrumWallet {
 
     lazy val publicScriptMap = (accountKeys ++ changeKeys).map(key => Script.write(computePublicKeyScript(key.publicKey)) -> key).toMap
 
-    lazy val utxos: Seq[Utxo] = history.keys.toSeq.map(scriptHash => getUtxos(scriptHash)).flatten
+    lazy val utxos = history.keys.toSeq.map(scriptHash => getUtxos(scriptHash)).flatten
 
     /**
       * The wallet is ready if all current keys have an empty status, and we don't have

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

@@ -1,4 +1,5 @@
 package fr.acinq.eclair.blockchain.fee
+
 import scala.concurrent.Future
 
 /**

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

@@ -1,8 +1,13 @@
 package fr.acinq.eclair.blockchain.fee
 
 import akka.actor.ActorSystem
-import fr.acinq.eclair.HttpHelper.get
+import akka.http.scaladsl.Http
+import akka.http.scaladsl.model._
+import akka.http.scaladsl.unmarshalling.Unmarshal
+import akka.stream.ActorMaterializer
+import de.heikoseeberger.akkahttpjson4s.Json4sSupport._
 import org.json4s.JsonAST.{JArray, JInt, JValue}
+import org.json4s.{DefaultFormats, jackson}
 
 import scala.concurrent.{ExecutionContext, Future}
 
@@ -13,9 +18,15 @@ class EarnDotComFeeProvider(implicit system: ActorSystem, ec: ExecutionContext)
 
   import EarnDotComFeeProvider._
 
+  implicit val materializer = ActorMaterializer()
+  val httpClient = Http(system)
+  implicit val serialization = jackson.Serialization
+  implicit val formats = DefaultFormats
+
   override def getFeerates: Future[FeeratesPerByte] =
     for {
-      json <- get("https://bitcoinfees.earn.com/api/v1/fees/list")
+      httpRes <- httpClient.singleRequest(HttpRequest(uri = Uri("https://bitcoinfees.earn.com/api/v1/fees/list"), method = HttpMethods.GET))
+      json <- Unmarshal(httpRes).to[JValue]
       feeRanges = parseFeeRanges(json)
     } yield extractFeerates(feeRanges)
 }

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

@@ -28,6 +28,7 @@ object FeeratesPerKw {
 
   /**
     * Used in tests
+    *
     * @param feeratePerKw
     * @return
     */

eclair-core/src/main/scala/fr/acinq/eclair/channel/Channel.scala

@@ -7,7 +7,6 @@ import fr.acinq.bitcoin.Crypto.{PublicKey, ripemd160, sha256}
 import fr.acinq.bitcoin._
 import fr.acinq.eclair.NodeParams.BITCOINJ
 import fr.acinq.eclair._
-import fr.acinq.eclair.blockchain.WatchConfirmed.extractPublicKeyScript
 import fr.acinq.eclair.blockchain._
 import fr.acinq.eclair.channel.Helpers.{Closing, Funding}
 import fr.acinq.eclair.crypto.{Generators, ShaChain, Sphinx}

eclair-core/src/main/scala/fr/acinq/eclair/channel/ChannelExceptions.scala

@@ -7,10 +7,8 @@ import fr.acinq.eclair.UInt64
   * Created by PM on 11/04/2017.
   */
 
-class ChannelException(channelId: BinaryData, message: String) extends RuntimeException(message) {
-  def getChannelId = channelId
-}
-
+class ChannelException(channelId: BinaryData, message: String) extends RuntimeException(message)
+// @formatter:off
 case class DebugTriggeredException             (channelId: BinaryData) extends ChannelException(channelId, "debug-mode triggered failure")
 case class ChannelReserveTooHigh               (channelId: BinaryData, channelReserveSatoshis: Long, reserveToFundingRatio: Double, maxReserveToFundingRatio: Double) extends ChannelException(channelId, s"channelReserveSatoshis too high: reserve=$channelReserveSatoshis fundingRatio=$reserveToFundingRatio maxFundingRatio=$maxReserveToFundingRatio")
 case class ClosingInProgress                   (channelId: BinaryData) extends ChannelException(channelId, "cannot send new htlcs, closing in progress")
@@ -41,4 +39,5 @@ case class UnexpectedRevocation                (channelId: BinaryData) extends C
 case class InvalidRevocation                   (channelId: BinaryData) extends ChannelException(channelId, "invalid revocation")
 case class CommitmentSyncError                 (channelId: BinaryData) extends ChannelException(channelId, "commitment sync error")
 case class RevocationSyncError                 (channelId: BinaryData) extends ChannelException(channelId, "revocation sync error")
-case class InvalidFailureCode                  (channelId: BinaryData) extends ChannelException(channelId, "UpdateFailMalformedHtlc message doesn't have BADONION bit set")
+case class InvalidFailureCode                  (channelId: BinaryData) extends ChannelException(channelId, "UpdateFailMalformedHtlc message doesn't have BADONION bit set")
+// @formatter:on

eclair-core/src/main/scala/fr/acinq/eclair/channel/Commitments.scala

@@ -1,7 +1,7 @@
 package fr.acinq.eclair.channel
 
 import fr.acinq.bitcoin.Crypto.{Point, PrivateKey, sha256}
-import fr.acinq.bitcoin.{BinaryData, Crypto, Satoshi, Script, Transaction}
+import fr.acinq.bitcoin.{BinaryData, Crypto, Satoshi, Transaction}
 import fr.acinq.eclair.crypto.{Generators, ShaChain, Sphinx}
 import fr.acinq.eclair.payment.Origin
 import fr.acinq.eclair.transactions.Transactions._

eclair-core/src/main/scala/fr/acinq/eclair/channel/Forwarder.scala

@@ -2,7 +2,7 @@ package fr.acinq.eclair.channel
 
 import akka.actor.{Actor, ActorLogging, ActorRef}
 import fr.acinq.eclair.NodeParams
-import fr.acinq.eclair.wire.{Error, LightningMessage}
+import fr.acinq.eclair.wire.LightningMessage
 
 /**
   * Created by fabrice on 27/02/17.

eclair-core/src/main/scala/fr/acinq/eclair/channel/Helpers.scala

@@ -490,6 +490,7 @@ object Helpers {
       * A local commit is considered done when:
       * - all commitment tx outputs that we can spend have been spent and confirmed (even if the spending tx was not ours)
       * - all 3rd stage txes (txes spending htlc txes) have been confirmed
+      *
       * @param localCommitPublished
       * @return
       */
@@ -509,6 +510,7 @@ object Helpers {
     /**
       * A remote commit is considered done when all commitment tx outputs that we can spend have been spent and confirmed
       * (even if the spending tx was not ours).
+      *
       * @param remoteCommitPublished
       * @return
       */
@@ -524,6 +526,7 @@ object Helpers {
     /**
       * A remote commit is considered done when all commitment tx outputs that we can spend have been spent and confirmed
       * (even if the spending tx was not ours).
+      *
       * @param revokedCommitPublished
       * @return
       */

eclair-core/src/main/scala/fr/acinq/eclair/channel/Register.scala

@@ -57,6 +57,7 @@ class Register extends Actor with ActorLogging {
 }
 
 object Register {
+
   // @formatter:off
   case class Forward[T](channelId: BinaryData, message: T)
   case class ForwardShortId[T](shortChannelId: Long, message: T)

eclair-core/src/main/scala/fr/acinq/eclair/crypto/BitStream.scala

@@ -1,15 +1,15 @@
 package fr.acinq.eclair.crypto
 
-import fr.acinq.bitcoin.BinaryData
 import org.spongycastle.util.encoders.Hex
 
 import scala.annotation.tailrec
 
 /**
   * Bit stream that can be written to and read at both ends (i.e. you can read from the end or the beginning of the stream)
-  * @param bytes bits packed as bytes, the last byte is padded with 0s
+  *
+  * @param bytes    bits packed as bytes, the last byte is padded with 0s
   * @param offstart offset at which the first bit is in the first byte
-  * @param offend offset at which the last bit is in the last byte
+  * @param offend   offset at which the last bit is in the last byte
   */
 case class BitStream(bytes: Vector[Byte], offstart: Int, offend: Int) {
 
@@ -20,6 +20,7 @@ case class BitStream(bytes: Vector[Byte], offstart: Int, offend: Int) {
   def bitCount = 8 * bytes.length - offstart - offend
 
   def isEmpty = bitCount == 0
+
   /**
     * append a byte to a bitstream
     *
@@ -97,16 +98,17 @@ case class BitStream(bytes: Vector[Byte], offstart: Int, offend: Int) {
       BitStream(bytes.dropRight(2) :+ a1.toByte, offstart, offend) -> byte.toByte
   }
 
-  def popBytes(n: Int) : (BitStream, Seq[Byte]) = {
+  def popBytes(n: Int): (BitStream, Seq[Byte]) = {
     @tailrec
-    def loop(stream: BitStream, acc: Seq[Byte]) : (BitStream, Seq[Byte]) =
+    def loop(stream: BitStream, acc: Seq[Byte]): (BitStream, Seq[Byte]) =
       if (acc.length == n) (stream, acc) else {
-      val (stream1, value) = stream.popByte
-      loop(stream1, acc :+ value)
-    }
+        val (stream1, value) = stream.popByte
+        loop(stream1, acc :+ value)
+      }
 
     loop(this, Nil)
   }
+
   /**
     * read the first bit from a bitstream
     *
@@ -117,7 +119,7 @@ case class BitStream(bytes: Vector[Byte], offstart: Int, offend: Int) {
     case _ => BitStream(bytes, offstart + 1, offend) -> firstBit
   }
 
-  def readBits(count: Int) : (BitStream, Seq[Bit]) = {
+  def readBits(count: Int): (BitStream, Seq[Bit]) = {
     @tailrec
     def loop(stream: BitStream, acc: Seq[Bit]): (BitStream, Seq[Bit]) = if (acc.length == count) (stream, acc) else {
       val (stream1, bit) = stream.readBit
@@ -126,14 +128,15 @@ case class BitStream(bytes: Vector[Byte], offstart: Int, offend: Int) {
 
     loop(this, Nil)
   }
+
   /**
     * read the first byte from a bitstream
     *
     * @return
     */
   def readByte: (BitStream, Byte) = {
-      val byte = ((bytes(0) << offstart) | (bytes(1) >>> (7 - offstart))) & 0xff
-      BitStream(bytes.tail, offstart, offend) -> byte.toByte
+    val byte = ((bytes(0) << offstart) | (bytes(1) >>> (7 - offstart))) & 0xff
+    BitStream(bytes.tail, offstart, offend) -> byte.toByte
   }
 
   def isSet(pos: Int): Boolean = {

eclair-core/src/main/scala/fr/acinq/eclair/crypto/Noise.scala

@@ -3,8 +3,8 @@ package fr.acinq.eclair.crypto
 import java.math.BigInteger
 import java.nio.ByteOrder
 
-import fr.acinq.eclair.randomBytes
 import fr.acinq.bitcoin.{BinaryData, Crypto, Protocol}
+import fr.acinq.eclair.randomBytes
 import grizzled.slf4j.Logging
 import org.spongycastle.crypto.digests.SHA256Digest
 import org.spongycastle.crypto.macs.HMac

eclair-core/src/main/scala/fr/acinq/eclair/crypto/ShaChain.scala

@@ -97,7 +97,7 @@ object ShaChain {
   }
 
 
-  val shaChainCodec: Codec[ShaChain] =  {
+  val shaChainCodec: Codec[ShaChain] = {
     import scodec.Codec
     import scodec.bits.BitVector
     import scodec.codecs._
@@ -106,7 +106,7 @@ object ShaChain {
     val entryCodec = vectorOfN(uint16, bool) ~ LightningMessageCodecs.varsizebinarydata
 
     // codec for a Map[Vector[Boolean], BinaryData]: write all k ->v pairs using the codec defined above
-    val mapCodec: Codec[Map[Vector[Boolean], BinaryData]] = Codec[Map[Vector[Boolean], BinaryData]] (
+    val mapCodec: Codec[Map[Vector[Boolean], BinaryData]] = Codec[Map[Vector[Boolean], BinaryData]](
       (m: Map[Vector[Boolean], BinaryData]) => vectorOfN(uint16, entryCodec).encode(m.toVector),
       (b: BitVector) => vectorOfN(uint16, entryCodec).decode(b).map(_.map(_.toMap))
     )

eclair-core/src/main/scala/fr/acinq/eclair/crypto/Sphinx.scala

@@ -5,7 +5,7 @@ import java.nio.ByteOrder
 
 import fr.acinq.bitcoin.Crypto.{PrivateKey, PublicKey}
 import fr.acinq.bitcoin.{BinaryData, Crypto, Protocol}
-import fr.acinq.eclair.wire.{ChannelUpdate, FailureMessage, FailureMessageCodecs, LightningMessageCodecs}
+import fr.acinq.eclair.wire.{FailureMessage, FailureMessageCodecs}
 import grizzled.slf4j.Logging
 import org.spongycastle.crypto.digests.SHA256Digest
 import org.spongycastle.crypto.macs.HMac
@@ -32,7 +32,7 @@ object Sphinx extends Logging {
 
   // onion packet length
   val PacketLength = 1 + 33 + MacLength + MaxHops * (PayloadLength + MacLength)
-  
+
   // last packet (all zeroes except for the version byte)
   val LAST_PACKET = Packet(Version, zeroes(33), zeroes(MacLength), zeroes(MaxHops * (PayloadLength + MacLength)))
 

eclair-core/src/main/scala/fr/acinq/eclair/crypto/TransportHandler.scala

@@ -35,6 +35,7 @@ class TransportHandler[T: ClassTag](keyPair: KeyPair, rs: Option[BinaryData], co
   connection ! akka.io.Tcp.Register(self)
 
   val out = context.actorOf(Props(new WriteAckSender(connection)))
+
   def buf(message: BinaryData): ByteString = ByteString.fromArray(message)
 
   // it means we initiate the dialog

eclair-core/src/main/scala/fr/acinq/eclair/db/NetworkDb.scala

@@ -17,6 +17,7 @@ trait NetworkDb {
 
   /**
     * This method removes 1 channel announcement and 2 channel updates (at both ends of the same channel)
+    *
     * @param shortChannelId
     * @return
     */

eclair-core/src/main/scala/fr/acinq/eclair/db/PreimagesDb.scala

@@ -1,7 +1,6 @@
 package fr.acinq.eclair.db
 
 import fr.acinq.bitcoin.BinaryData
-import fr.acinq.eclair.channel.HasCommitments
 
 /**
   * This database stores the preimages that we have received from downstream

eclair-core/src/main/scala/fr/acinq/eclair/db/sqlite/SqliteNetworkDb.scala

@@ -1,14 +1,12 @@
 package fr.acinq.eclair.db.sqlite
 
-import java.sql.{Connection, ResultSet}
+import java.sql.Connection
 
 import fr.acinq.bitcoin.Crypto
 import fr.acinq.eclair.db.NetworkDb
 import fr.acinq.eclair.router.Announcements
 import fr.acinq.eclair.wire.LightningMessageCodecs.{channelAnnouncementCodec, channelUpdateCodec, nodeAnnouncementCodec}
 import fr.acinq.eclair.wire.{ChannelAnnouncement, ChannelUpdate, NodeAnnouncement}
-import scodec.Codec
-import scodec.bits.BitVector
 
 class SqliteNetworkDb(sqlite: Connection) extends NetworkDb {
 

eclair-core/src/main/scala/fr/acinq/eclair/io/Peer.scala

@@ -55,7 +55,6 @@ class Peer(nodeParams: NodeParams, remoteNodeId: PublicKey, address_opt: Option[
     channel ! INPUT_RESTORED(state)
     HotChannel(FinalChannelId(state.channelId), channel)
   }, attempts = 0))
-  setTimer(RECONNECT_TIMER, Reconnect, 1 second, repeat = false)
 
   when(DISCONNECTED) {
     case Event(c: NewChannel, d@DisconnectedData(offlineChannels, _)) =>

eclair-core/src/main/scala/fr/acinq/eclair/io/Server.scala

@@ -2,7 +2,7 @@ package fr.acinq.eclair.io
 
 import java.net.InetSocketAddress
 
-import akka.actor.{Actor, ActorLogging, ActorRef, OneForOneStrategy, Props, Status, SupervisorStrategy, Terminated}
+import akka.actor.{Actor, ActorLogging, ActorRef, OneForOneStrategy, Props, SupervisorStrategy}
 import akka.io.Tcp.SO.KeepAlive
 import akka.io.{IO, Tcp}
 import fr.acinq.eclair.NodeParams

eclair-core/src/main/scala/fr/acinq/eclair/payment/LocalPaymentHandler.scala

@@ -2,9 +2,9 @@ package fr.acinq.eclair.payment
 
 import akka.actor.{Actor, ActorLogging, Props, Status}
 import fr.acinq.bitcoin.{BinaryData, Crypto, MilliSatoshi}
-import fr.acinq.eclair.{Globals, NodeParams, randomBytes}
-import fr.acinq.eclair.channel.{CMD_FAIL_HTLC, CMD_FULFILL_HTLC, ExpiryTooSmall}
+import fr.acinq.eclair.channel.{CMD_FAIL_HTLC, CMD_FULFILL_HTLC}
 import fr.acinq.eclair.wire._
+import fr.acinq.eclair.{NodeParams, randomBytes}
 
 import scala.util.{Failure, Success, Try}
 
@@ -32,25 +32,25 @@ class LocalPaymentHandler(nodeParams: NodeParams) extends Actor with ActorLoggin
       }
 
     case htlc: UpdateAddHtlc =>
-     if (h2r.contains(htlc.paymentHash)) {
+      if (h2r.contains(htlc.paymentHash)) {
         val r = h2r(htlc.paymentHash)._1
         val pr = h2r(htlc.paymentHash)._2
         // The htlc amount must be equal or greater than the requested amount. A slight overpaying is permitted, however
         // it must not be greater than two times the requested amount.
         // see https://github.com/lightningnetwork/lightning-rfc/blob/master/04-onion-routing.md#failure-messages
-       pr.amount match {
-         case Some(amount) if MilliSatoshi(htlc.amountMsat) < amount => sender ! CMD_FAIL_HTLC(htlc.id, Right(IncorrectPaymentAmount), commit = true)
-         case Some(amount) if MilliSatoshi(htlc.amountMsat) > amount * 2 => sender ! CMD_FAIL_HTLC(htlc.id, Right(IncorrectPaymentAmount), commit = true)
-         case _ =>
-           log.info(s"received payment for paymentHash=${htlc.paymentHash} amountMsat=${htlc.amountMsat}")
-           // amount is correct or was not specified in the payment request
-           sender ! CMD_FULFILL_HTLC(htlc.id, r, commit = true)
-           context.system.eventStream.publish(PaymentReceived(MilliSatoshi(htlc.amountMsat), htlc.paymentHash))
-           context.become(run(h2r - htlc.paymentHash))
-       }
-     } else {
+        pr.amount match {
+          case Some(amount) if MilliSatoshi(htlc.amountMsat) < amount => sender ! CMD_FAIL_HTLC(htlc.id, Right(IncorrectPaymentAmount), commit = true)
+          case Some(amount) if MilliSatoshi(htlc.amountMsat) > amount * 2 => sender ! CMD_FAIL_HTLC(htlc.id, Right(IncorrectPaymentAmount), commit = true)
+          case _ =>
+            log.info(s"received payment for paymentHash=${htlc.paymentHash} amountMsat=${htlc.amountMsat}")
+            // amount is correct or was not specified in the payment request
+            sender ! CMD_FULFILL_HTLC(htlc.id, r, commit = true)
+            context.system.eventStream.publish(PaymentReceived(MilliSatoshi(htlc.amountMsat), htlc.paymentHash))
+            context.become(run(h2r - htlc.paymentHash))
+        }
+      } else {
         sender ! CMD_FAIL_HTLC(htlc.id, Right(UnknownPaymentHash), commit = true)
-     }
+      }
   }
 }
 

eclair-core/src/main/scala/fr/acinq/eclair/payment/PaymentHop.scala

@@ -18,7 +18,7 @@ object PaymentHop {
   /**
     *
     * @param reversePath sequence of Hops from recipient to a start of assisted path
-    * @param msat an amount to send to a payment recipient
+    * @param msat        an amount to send to a payment recipient
     * @return a sequence of extra hops with a pre-calculated fee for a given msat amount
     */
   def buildExtra(reversePath: Seq[Hop], msat: Long): Seq[ExtraHop] = (List.empty[ExtraHop] /: reversePath) {
@@ -29,13 +29,18 @@ object PaymentHop {
 
 trait PaymentHop {
   def nextFee(msat: Long): Long
+
   def shortChannelId: Long
+
   def cltvExpiryDelta: Int
+
   def nodeId: PublicKey
 }
 
 case class Hop(nodeId: PublicKey, nextNodeId: PublicKey, lastUpdate: ChannelUpdate) extends PaymentHop {
   def nextFee(msat: Long): Long = PaymentHop.nodeFee(lastUpdate.feeBaseMsat, lastUpdate.feeProportionalMillionths, msat)
+
   def cltvExpiryDelta: Int = lastUpdate.cltvExpiryDelta
+
   def shortChannelId: Long = lastUpdate.shortChannelId
 }

eclair-core/src/main/scala/fr/acinq/eclair/payment/PaymentInitiator.scala

@@ -1,7 +1,6 @@
 package fr.acinq.eclair.payment
 
 import akka.actor.{Actor, ActorLogging, ActorRef, Props}
-import fr.acinq.bitcoin.BinaryData
 import fr.acinq.bitcoin.Crypto.PublicKey
 
 /**

eclair-core/src/main/scala/fr/acinq/eclair/payment/PaymentRequest.scala

@@ -263,13 +263,13 @@ object PaymentRequest {
   case class ExpiryTag(seconds: Long) extends Tag {
     override def toInt5s = {
       val ints = writeUnsignedLong(seconds)
-      Bech32.map('x') +: (writeSize(ints.size) ++ ints)    }
+      Bech32.map('x') +: (writeSize(ints.size) ++ ints)
+    }
   }
 
   /**
     * Min final CLTV expiry
     *
-    *
     * @param blocks min final cltv expiry, in blocks
     */
   case class MinFinalCltvExpiryTag(blocks: Long) extends Tag {
@@ -418,8 +418,9 @@ object PaymentRequest {
 
   /**
     * prepend an unsigned long value to a sequence of Int5s
+    *
     * @param value input value
-    * @param acc sequence of Int5 values
+    * @param acc   sequence of Int5 values
     * @return an update sequence of Int5s
     */
   @tailrec
@@ -432,10 +433,11 @@ object PaymentRequest {
   /**
     * convert a tag data size to a sequence of Int5s. It * must * fit on a sequence
     * of 2 Int5 values
+    *
     * @param size data size
     * @return size as a sequence of exactly 2 Int5 values
     */
-  def writeSize(size: Long) : Seq[Int5] = {
+  def writeSize(size: Long): Seq[Int5] = {
     val output = writeUnsignedLong(size)
     // make sure that size is encoded on 2 int5 values
     output.length match {
@@ -448,8 +450,9 @@ object PaymentRequest {
 
   /**
     * reads an unsigned long value from a sequence of Int5s
+    *
     * @param length length of the sequence
-    * @param ints sequence of Int5s
+    * @param ints   sequence of Int5s
     * @return an unsigned long value
     */
   def readUnsignedLong(length: Int, ints: Seq[Int5]): Long = ints.take(length).foldLeft(0L) { case (acc, i) => acc * 32 + i }

eclair-core/src/main/scala/fr/acinq/eclair/router/Announcements.scala

@@ -79,6 +79,7 @@ object Announcements {
     * The creating node MUST set node-id-1 and node-id-2 to the public keys of the
     * two nodes who are operating the channel, such that node-id-1 is the numerically-lesser
     * of the two DER encoded keys sorted in ascending numerical order,
+    *
     * @return true if localNodeId is node1
     */
   def isNode1(localNodeId: BinaryData, remoteNodeId: BinaryData) = LexicographicalOrdering.isLessThan(localNodeId, remoteNodeId)
@@ -87,6 +88,7 @@ object Announcements {
     * BOLT 7:
     * The creating node [...] MUST set the direction bit of flags to 0 if
     * the creating node is node-id-1 in that message, otherwise 1.
+    *
     * @return true if the node who sent these flags is node1
     */
   def isNode1(flags: BinaryData) = !BitVector(flags.data).reverse.get(0)
@@ -94,6 +96,7 @@ object Announcements {
   /**
     * A node MAY create and send a channel_update with the disable bit set to
     * signal the temporary unavailability of a channel
+    *
     * @return
     */
   def isEnabled(flags: BinaryData) = !BitVector(flags.data).reverse.get(1)

eclair-core/src/main/scala/fr/acinq/eclair/router/Router.scala

@@ -11,19 +11,18 @@ import fr.acinq.eclair._
 import fr.acinq.eclair.blockchain._
 import fr.acinq.eclair.channel._
 import fr.acinq.eclair.io.Peer
+import fr.acinq.eclair.payment.Hop
 import fr.acinq.eclair.transactions.Scripts
 import fr.acinq.eclair.wire._
-import org.jgrapht.alg.DijkstraShortestPath
-import org.jgrapht.graph.{DefaultDirectedGraph, DefaultEdge}
-import fr.acinq.eclair.payment.Hop
+import org.jgrapht.alg.shortestpath.DijkstraShortestPath
 import org.jgrapht.ext._
 import org.jgrapht.graph.{DefaultDirectedGraph, DefaultEdge, SimpleGraph}
 
 import scala.collection.JavaConversions._
 import scala.compat.Platform
+import scala.concurrent.duration._
 import scala.concurrent.{ExecutionContext, Future}
 import scala.util.{Random, Success, Try}
-import scala.concurrent.duration._
 
 // @formatter:off
 
@@ -73,17 +72,20 @@ class Router(nodeParams: NodeParams, watcher: ActorRef) extends FSM[State, Data]
 
   val db = nodeParams.networkDb
 
-  {
-    log.info(s"loading network announcements from db...")
-    val initChannels = db.listChannels().map(c => (c.shortChannelId -> c)).toMap
-    val initNodes = (db.listNodes() match {
-      case Nil => Nil
-      case l => l :+ Announcements.makeNodeAnnouncement(nodeParams.privateKey, nodeParams.alias, nodeParams.color, nodeParams.publicAddresses, Platform.currentTime / 1000)
-    }).map(n => (n.nodeId -> n)).toMap
-    val initChannelUpdates = db.listChannelUpdates().map(u => (getDesc(u, initChannels(u.shortChannelId)) -> u)).toMap
-    log.info(s"starting state machine")
-    startWith(NORMAL, Data(initNodes, initChannels, initChannelUpdates, Nil, Nil, Nil, Map.empty, Map.empty, Set.empty))
+  // Note: We go through the whole validation process instead of directly loading into memory, because the channels
+  // could have been closed while we were shutdown, and if someone connects to us right after startup we don't want to
+  // advertise invalid channels. We could optimize this (at least not fetch txes from the blockchain, and not check sigs)
+  log.info(s"loading network announcements from db...")
+  db.listChannels().map(self ! _)
+  db.listNodes().map(self ! _)
+  db.listChannelUpdates().map(self ! _)
+  if (db.listChannels().size > 0) {
+    val nodeAnn = Announcements.makeNodeAnnouncement(nodeParams.privateKey, nodeParams.alias, nodeParams.color, nodeParams.publicAddresses, Platform.currentTime / 1000)
+    self ! nodeAnn
   }
+  log.info(s"starting state machine")
+
+  startWith(NORMAL, Data(Map.empty, Map.empty, Map.empty, Nil, Nil, Nil, Map.empty, Map.empty, Set.empty))
 
   when(NORMAL) {
     case Event(TickValidate, d) =>
@@ -118,9 +120,7 @@ class Router(nodeParams: NodeParams, watcher: ActorRef) extends FSM[State, Data]
             log.error(s"invalid script for shortChannelId=${c.shortChannelId} txid=${tx.txid} ann=$c")
             None
           } else {
-            // On Android we disable the ability to detect when external channels die. If we try to use them during a
-            // payment, we simply will get an error from the node that is just before the missing channel.
-            //watcher ! WatchSpentBasic(self, tx, outputIndex, BITCOIN_FUNDING_EXTERNAL_CHANNEL_SPENT(c.shortChannelId))
+            watcher ! WatchSpentBasic(self, tx, outputIndex, BITCOIN_FUNDING_EXTERNAL_CHANNEL_SPENT(c.shortChannelId))
             // TODO: check feature bit set
             log.debug(s"added channel channelId=${c.shortChannelId}")
             context.system.eventStream.publish(ChannelDiscovered(c, tx.txOut(outputIndex).amount))
@@ -158,10 +158,9 @@ class Router(nodeParams: NodeParams, watcher: ActorRef) extends FSM[State, Data]
     case Event(_: ChannelStateChanged, _) => stay
 
     case Event(SendRoutingState(remote), Data(nodes, channels, updates, _, _, _, _, _, _)) =>
-      // disabled on Android for performance reasons
-      //log.debug(s"info sending all announcements to $remote: channels=${channels.size} nodes=${nodes.size} updates=${updates.size}")
+      log.debug(s"info sending all announcements to $remote: channels=${channels.size} nodes=${nodes.size} updates=${updates.size}")
       // we group and add delays to leave room for channel messages
-      //context.actorOf(ThrottleForwarder.props(remote, channels.values ++ nodes.values ++ updates.values, 100, 100 millis))
+      context.actorOf(ThrottleForwarder.props(remote, channels.values ++ nodes.values ++ updates.values, 100, 100 millis))
       stay
 
     case Event(c: ChannelAnnouncement, d) =>
@@ -262,8 +261,8 @@ class Router(nodeParams: NodeParams, watcher: ActorRef) extends FSM[State, Data]
       d.rebroadcast match {
         case Nil => stay using d.copy(origins = Map.empty)
         case _ =>
-          //log.info(s"broadcasting ${d.rebroadcast.size} routing messages")
-          //context.actorSelection(context.system / "*" / "switchboard") ! Rebroadcast(d.rebroadcast, d.origins)
+          log.info(s"broadcasting ${d.rebroadcast.size} routing messages")
+          context.actorSelection(context.system / "*" / "switchboard") ! Rebroadcast(d.rebroadcast, d.origins)
           stay using d.copy(rebroadcast = Nil, origins = Map.empty)
       }
 
@@ -348,7 +347,7 @@ class Router(nodeParams: NodeParams, watcher: ActorRef) extends FSM[State, Data]
 
 object Router {
 
-  val MAX_PARALLEL_JSONRPC_REQUESTS = 1000
+  val MAX_PARALLEL_JSONRPC_REQUESTS = 50
 
   def props(nodeParams: NodeParams, watcher: ActorRef) = Props(new Router(nodeParams, watcher))
 
@@ -396,7 +395,7 @@ object Router {
       g.addEdge(d.a, d.b, new DescEdge(d))
     })
     Try(Option(DijkstraShortestPath.findPathBetween(g, localNodeId, targetNodeId))) match {
-      case Success(Some(path)) => path.map(_.desc)
+      case Success(Some(path)) => path.getEdgeList.map(_.desc)
       case _ => throw RouteNotFound
     }
   }
@@ -406,7 +405,39 @@ object Router {
       .map(desc => Hop(desc.a, desc.b, updates(desc)))
   }
 
-  def graph2dot(nodes: Map[PublicKey, NodeAnnouncement], channels: Map[Long, ChannelAnnouncement])(implicit ec: ExecutionContext): Future[String] = ???
+  def graph2dot(nodes: Map[PublicKey, NodeAnnouncement], channels: Map[Long, ChannelAnnouncement])(implicit ec: ExecutionContext): Future[String] = Future {
+    case class DescEdge(channelId: Long) extends DefaultEdge
+    val g = new SimpleGraph[PublicKey, DescEdge](classOf[DescEdge])
+    channels.foreach(d => {
+      g.addVertex(d._2.nodeId1)
+      g.addVertex(d._2.nodeId2)
+      g.addEdge(d._2.nodeId1, d._2.nodeId2, new DescEdge(d._1))
+    })
+    val vertexIDProvider = new ComponentNameProvider[PublicKey]() {
+      override def getName(nodeId: PublicKey): String = "\"" + nodeId.toString() + "\""
+    }
+    val edgeLabelProvider = new ComponentNameProvider[DescEdge]() {
+      override def getName(e: DescEdge): String = e.channelId.toString
+    }
+    val vertexAttributeProvider = new ComponentAttributeProvider[PublicKey]() {
+
+      override def getComponentAttributes(nodeId: PublicKey): java.util.Map[String, String] =
+
+        nodes.get(nodeId) match {
+          case Some(ann) => Map("label" -> ann.alias, "color" -> f"#${ann.rgbColor._1}%02x${ann.rgbColor._2}%02x${ann.rgbColor._3}%02x")
+          case None => Map.empty[String, String]
+        }
+    }
+    val exporter = new DOTExporter[PublicKey, DescEdge](vertexIDProvider, null, edgeLabelProvider, vertexAttributeProvider, null)
+    val writer = new StringWriter()
+    try {
+      exporter.exportGraph(g, writer)
+      writer.toString
+    } finally {
+      writer.close()
+    }
+
+  }
 
 
 }

eclair-core/src/main/scala/fr/acinq/eclair/router/RouterExceptions.scala

@@ -7,4 +7,5 @@ package fr.acinq.eclair.router
 class RouterException(message: String) extends RuntimeException(message)
 
 object RouteNotFound extends RouterException("Route not found")
+
 object CannotRouteToSelf extends RouterException("Cannot route to self")

eclair-core/src/main/scala/fr/acinq/eclair/router/ThrottleForwarder.scala

@@ -13,8 +13,10 @@ import scala.concurrent.duration.{FiniteDuration, _}
   */
 class ThrottleForwarder(target: ActorRef, messages: Iterable[Any], chunkSize: Int, delay: FiniteDuration) extends Actor with ActorLogging {
 
-  import scala.concurrent.ExecutionContext.Implicits.global
   import ThrottleForwarder.Tick
+
+  import scala.concurrent.ExecutionContext.Implicits.global
+
   val clock = context.system.scheduler.schedule(0 second, delay, self, Tick)
 
   log.debug(s"sending messages=${messages.size} with chunkSize=$chunkSize and delay=$delay")

eclair-core/src/main/scala/fr/acinq/eclair/transactions/CommitmentSpec.scala

@@ -1,6 +1,5 @@
 package fr.acinq.eclair.transactions
 
-import fr.acinq.bitcoin.BinaryData
 import fr.acinq.eclair.wire._
 
 /**

eclair-core/src/main/scala/fr/acinq/eclair/transactions/Scripts.scala

@@ -1,8 +1,8 @@
 package fr.acinq.eclair.transactions
 
-import fr.acinq.bitcoin.Crypto.{PrivateKey, PublicKey, ripemd160}
+import fr.acinq.bitcoin.Crypto.{PublicKey, ripemd160}
 import fr.acinq.bitcoin.Script._
-import fr.acinq.bitcoin.{BinaryData, Crypto, LexicographicalOrdering, LockTimeThreshold, OP_0, OP_1, OP_1NEGATE, OP_2, OP_2DROP, OP_ADD, OP_CHECKLOCKTIMEVERIFY, OP_CHECKMULTISIG, OP_CHECKSEQUENCEVERIFY, OP_CHECKSIG, OP_DROP, OP_DUP, OP_ELSE, OP_ENDIF, OP_EQUAL, OP_EQUALVERIFY, OP_HASH160, OP_IF, OP_NOTIF, OP_PUSHDATA, OP_SIZE, OP_SWAP, OutPoint, SIGHASH_ALL, Satoshi, Script, ScriptElt, ScriptWitness, Transaction, TxIn, TxOut}
+import fr.acinq.bitcoin.{BinaryData, LexicographicalOrdering, LockTimeThreshold, OP_0, OP_1, OP_1NEGATE, OP_2, OP_2DROP, OP_ADD, OP_CHECKLOCKTIMEVERIFY, OP_CHECKMULTISIG, OP_CHECKSEQUENCEVERIFY, OP_CHECKSIG, OP_DROP, OP_DUP, OP_ELSE, OP_ENDIF, OP_EQUAL, OP_EQUALVERIFY, OP_HASH160, OP_IF, OP_NOTIF, OP_PUSHDATA, OP_SIZE, OP_SWAP, Satoshi, Script, ScriptElt, ScriptWitness, Transaction, TxIn}
 
 /**
   * Created by PM on 02/12/2016.

eclair-core/src/main/scala/fr/acinq/eclair/wire/FailureMessage.scala

@@ -1,7 +1,7 @@
 package fr.acinq.eclair.wire
 
 import fr.acinq.bitcoin.BinaryData
-import fr.acinq.eclair.wire.LightningMessageCodecs.{binarydata, uint64, channelUpdateCodec}
+import fr.acinq.eclair.wire.LightningMessageCodecs.{binarydata, channelUpdateCodec, uint64}
 import scodec.Codec
 import scodec.codecs._
 

eclair-core/src/main/scala/fr/acinq/eclair/wire/FixedSizeStrictCodec.scala

@@ -47,9 +47,13 @@ object FixedSizeStrictCodec {
     */
   def bytesStrict(size: Int): Codec[ByteVector] = new Codec[ByteVector] {
     private val codec = new FixedSizeStrictCodec(size * 8L, codecs.bits).xmap[ByteVector](_.toByteVector, _.toBitVector)
+
     def sizeBound = codec.sizeBound
+
     def encode(b: ByteVector) = codec.encode(b)
+
     def decode(b: BitVector) = codec.decode(b)
+
     override def toString = s"bytesStrict($size)"
   }
 }

eclair-core/src/main/scala/fr/acinq/eclair/wire/LightningMessageCodecs.scala

@@ -6,8 +6,8 @@ import java.net.{Inet4Address, Inet6Address, InetAddress, InetSocketAddress}
 import fr.acinq.bitcoin.Crypto.{Point, PrivateKey, PublicKey, Scalar}
 import fr.acinq.bitcoin.{BinaryData, Crypto}
 import fr.acinq.eclair.crypto.{Generators, Sphinx}
-import fr.acinq.eclair.{UInt64, wire}
 import fr.acinq.eclair.wire.FixedSizeStrictCodec.bytesStrict
+import fr.acinq.eclair.{UInt64, wire}
 import scodec.bits.{BitVector, ByteVector}
 import scodec.codecs._
 import scodec.{Attempt, Codec, Err}

eclair-core/src/main/scala/fr/acinq/eclair/wire/LightningMessageTypes.scala

@@ -32,9 +32,9 @@ case class Ping(pongLength: Int, data: BinaryData) extends SetupMessage
 case class Pong(data: BinaryData) extends SetupMessage
 
 case class ChannelReestablish(
-                             channelId: BinaryData,
-                             nextLocalCommitmentNumber: Long,
-                             nextRemoteRevocationNumber: Long) extends ChannelMessage with HasChannelId
+                               channelId: BinaryData,
+                               nextLocalCommitmentNumber: Long,
+                               nextRemoteRevocationNumber: Long) extends ChannelMessage with HasChannelId
 
 case class OpenChannel(chainHash: BinaryData,
                        temporaryChannelId: BinaryData,

eclair-core/src/test/java/fr/acinq/eclair/crypto/Curve25519.java

@@ -27,13 +27,13 @@ import java.util.Arrays;
 
 /**
  * Implementation of the Curve25519 elliptic curve algorithm.
- *
+ * <p>
  * This implementation is based on that from arduinolibs:
  * https://github.com/rweather/arduinolibs
- *
+ * <p>
  * Differences in this version are due to using 26-bit limbs for the
  * representation instead of the 8/16/32-bit limbs in the original.
- *
+ * <p>
  * References: http://cr.yp.to/ecdh.html, RFC 7748
  */
 public final class Curve25519 {
@@ -61,25 +61,24 @@ public final class Curve25519 {
     /**
      * Constructs the temporary state holder for Curve25519 evaluation.
      */
-    private Curve25519()
-    {
+    private Curve25519() {
         // Allocate memory for all of the temporary variables we will need.
-        x_1 = new int [NUM_LIMBS_255BIT];
-        x_2 = new int [NUM_LIMBS_255BIT];
-        x_3 = new int [NUM_LIMBS_255BIT];
-        z_2 = new int [NUM_LIMBS_255BIT];
-        z_3 = new int [NUM_LIMBS_255BIT];
-        A = new int [NUM_LIMBS_255BIT];
-        B = new int [NUM_LIMBS_255BIT];
-        C = new int [NUM_LIMBS_255BIT];
-        D = new int [NUM_LIMBS_255BIT];
-        E = new int [NUM_LIMBS_255BIT];
-        AA = new int [NUM_LIMBS_255BIT];
-        BB = new int [NUM_LIMBS_255BIT];
-        DA = new int [NUM_LIMBS_255BIT];
-        CB = new int [NUM_LIMBS_255BIT];
-        t1 = new long [NUM_LIMBS_510BIT];
-        t2 = new int [NUM_LIMBS_510BIT];
+        x_1 = new int[NUM_LIMBS_255BIT];
+        x_2 = new int[NUM_LIMBS_255BIT];
+        x_3 = new int[NUM_LIMBS_255BIT];
+        z_2 = new int[NUM_LIMBS_255BIT];
+        z_3 = new int[NUM_LIMBS_255BIT];
+        A = new int[NUM_LIMBS_255BIT];
+        B = new int[NUM_LIMBS_255BIT];
+        C = new int[NUM_LIMBS_255BIT];
+        D = new int[NUM_LIMBS_255BIT];
+        E = new int[NUM_LIMBS_255BIT];
+        AA = new int[NUM_LIMBS_255BIT];
+        BB = new int[NUM_LIMBS_255BIT];
+        DA = new int[NUM_LIMBS_255BIT];
+        CB = new int[NUM_LIMBS_255BIT];
+        t1 = new long[NUM_LIMBS_510BIT];
+        t2 = new int[NUM_LIMBS_510BIT];
     }
 
 
@@ -102,8 +101,8 @@ public final class Curve25519 {
         Arrays.fill(BB, 0);
         Arrays.fill(DA, 0);
         Arrays.fill(CB, 0);
-        Arrays.fill(t1,  0L);
-        Arrays.fill(t2,  0);
+        Arrays.fill(t1, 0L);
+        Arrays.fill(t2, 0);
     }
 
     /**
@@ -112,8 +111,7 @@ public final class Curve25519 {
      *
      * @param x The number to reduce, and the result.
      */
-    private void reduceQuick(int[] x)
-    {
+    private void reduceQuick(int[] x) {
         int index, carry;
 
         // Perform a trial subtraction of (2^255 - 19) from "x" which is
@@ -142,12 +140,11 @@ public final class Curve25519 {
      * Reduce a number modulo 2^255 - 19.
      *
      * @param result The result.
-     * @param x The value to be reduced.  This array will be
-     * modified during the reduction.
-     * @param size The number of limbs in the high order half of x.
+     * @param x      The value to be reduced.  This array will be
+     *               modified during the reduction.
+     * @param size   The number of limbs in the high order half of x.
      */
-    private void reduce(int[] result, int[] x, int size)
-    {
+    private void reduce(int[] result, int[] x, int size) {
         int index, limb, carry;
 
         // Calculate (x mod 2^255) + ((x / 2^255) * 19) which will
@@ -198,11 +195,10 @@ public final class Curve25519 {
      * Multiplies two numbers modulo 2^255 - 19.
      *
      * @param result The result.
-     * @param x The first number to multiply.
-     * @param y The second number to multiply.
+     * @param x      The first number to multiply.
+     * @param y      The second number to multiply.
      */
-    private void mul(int[] result, int[] x, int[] y)
-    {
+    private void mul(int[] result, int[] x, int[] y) {
         int i, j;
 
         // Multiply the two numbers to create the intermediate result.
@@ -220,10 +216,10 @@ public final class Curve25519 {
 
         // Propagate carries and convert back into 26-bit words.
         v = t1[0];
-        t2[0] = ((int)v) & 0x03FFFFFF;
+        t2[0] = ((int) v) & 0x03FFFFFF;
         for (i = 1; i < NUM_LIMBS_510BIT; ++i) {
             v = (v >> 26) + t1[i];
-            t2[i] = ((int)v) & 0x03FFFFFF;
+            t2[i] = ((int) v) & 0x03FFFFFF;
         }
 
         // Reduce the result modulo 2^255 - 19.
@@ -234,10 +230,9 @@ public final class Curve25519 {
      * Squares a number modulo 2^255 - 19.
      *
      * @param result The result.
-     * @param x The number to square.
+     * @param x      The number to square.
      */
-    private void square(int[] result, int[] x)
-    {
+    private void square(int[] result, int[] x) {
         mul(result, x, x);
     }
 
@@ -245,19 +240,18 @@ public final class Curve25519 {
      * Multiplies a number by the a24 constant, modulo 2^255 - 19.
      *
      * @param result The result.
-     * @param x The number to multiply by a24.
+     * @param x      The number to multiply by a24.
      */
-    private void mulA24(int[] result, int[] x)
-    {
+    private void mulA24(int[] result, int[] x) {
         long a24 = 121665;
         long carry = 0;
         int index;
         for (index = 0; index < NUM_LIMBS_255BIT; ++index) {
             carry += a24 * x[index];
-            t2[index] = ((int)carry) & 0x03FFFFFF;
+            t2[index] = ((int) carry) & 0x03FFFFFF;
             carry >>= 26;
         }
-        t2[NUM_LIMBS_255BIT] = ((int)carry) & 0x03FFFFFF;
+        t2[NUM_LIMBS_255BIT] = ((int) carry) & 0x03FFFFFF;
         reduce(result, t2, 1);
     }
 
@@ -265,11 +259,10 @@ public final class Curve25519 {
      * Adds two numbers modulo 2^255 - 19.
      *
      * @param result The result.
-     * @param x The first number to add.
-     * @param y The second number to add.
+     * @param x      The first number to add.
+     * @param y      The second number to add.
      */
-    private void add(int[] result, int[] x, int[] y)
-    {
+    private void add(int[] result, int[] x, int[] y) {
         int index, carry;
         carry = x[0] + y[0];
         result[0] = carry & 0x03FFFFFF;
@@ -284,11 +277,10 @@ public final class Curve25519 {
      * Subtracts two numbers modulo 2^255 - 19.
      *
      * @param result The result.
-     * @param x The first number to subtract.
-     * @param y The second number to subtract.
+     * @param x      The first number to subtract.
+     * @param y      The second number to subtract.
      */
-    private void sub(int[] result, int[] x, int[] y)
-    {
+    private void sub(int[] result, int[] x, int[] y) {
         int index, borrow;
 
         // Subtract y from x to generate the intermediate result.
@@ -316,11 +308,10 @@ public final class Curve25519 {
      * Conditional swap of two values.
      *
      * @param select Set to 1 to swap, 0 to leave as-is.
-     * @param x The first value.
-     * @param y The second value.
+     * @param x      The first value.
+     * @param y      The second value.
      */
-    private static void cswap(int select, int[] x, int[] y)
-    {
+    private static void cswap(int select, int[] x, int[] y) {
         int dummy;
         select = -select;
         for (int index = 0; index < NUM_LIMBS_255BIT; ++index) {
@@ -334,10 +325,9 @@ public final class Curve25519 {
      * Raise x to the power of (2^250 - 1).
      *
      * @param result The result.  Must not overlap with x.
-     * @param x The argument.
+     * @param x      The argument.
      */
-    private void pow250(int[] result, int[] x)
-    {
+    private void pow250(int[] result, int[] x) {
         int i, j;
 
         // The big-endian hexadecimal expansion of (2^250 - 1) is:
@@ -375,10 +365,9 @@ public final class Curve25519 {
      * Computes the reciprocal of a number modulo 2^255 - 19.
      *
      * @param result The result.  Must not overlap with x.
-     * @param x The argument.
+     * @param x      The argument.
      */
-    private void recip(int[] result, int[] x)
-    {
+    private void recip(int[] result, int[] x) {
         // The reciprocal is the same as x ^ (p - 2) where p = 2^255 - 19.
         // The big-endian hexadecimal expansion of (p - 2) is:
         // 7FFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFEB
@@ -401,8 +390,7 @@ public final class Curve25519 {
      *
      * @param s The 32-byte secret key.
      */
-    private void evalCurve(byte[] s)
-    {
+    private void evalCurve(byte[] s) {
         int sposn = 31;
         int sbit = 6;
         int svalue = s[sposn] | 0x40;
@@ -411,7 +399,7 @@ public final class Curve25519 {
 
         // Iterate over all 255 bits of "s" from the highest to the lowest.
         // We ignore the high bit of the 256-bit representation of "s".
-        for (;;) {
+        for (; ; ) {
             // Conditional swaps on entry to this bit but only if we
             // didn't swap on the previous bit.
             select = (svalue >> sbit) & 0x01;
@@ -464,14 +452,13 @@ public final class Curve25519 {
     /**
      * Evaluates the Curve25519 curve.
      *
-     * @param result Buffer to place the result of the evaluation into.
-     * @param offset Offset into the result buffer.
+     * @param result     Buffer to place the result of the evaluation into.
+     * @param offset     Offset into the result buffer.
      * @param privateKey The private key to use in the evaluation.
-     * @param publicKey The public key to use in the evaluation, or null
-     * if the base point of the curve should be used.
+     * @param publicKey  The public key to use in the evaluation, or null
+     *                   if the base point of the curve should be used.
      */
-    public static void eval(byte[] result, int offset, byte[] privateKey, byte[] publicKey)
-    {
+    public static void eval(byte[] result, int offset, byte[] privateKey, byte[] publicKey) {
         Curve25519 state = new Curve25519();
         try {
             // Unpack the public key value.  If null, use 9 as the base point.
@@ -501,11 +488,11 @@ public final class Curve25519 {
             }
 
             // Initialize the other temporary variables.
-            Arrays.fill(state.x_2, 0);			// x_2 = 1
+            Arrays.fill(state.x_2, 0);            // x_2 = 1
             state.x_2[0] = 1;
-            Arrays.fill(state.z_2, 0);			// z_2 = 0
+            Arrays.fill(state.z_2, 0);            // z_2 = 0
             System.arraycopy(state.x_1, 0, state.x_3, 0, state.x_1.length);  // x_3 = x_1
-            Arrays.fill(state.z_3, 0);			// z_3 = 1
+            Arrays.fill(state.z_3, 0);            // z_3 = 1
             state.z_3[0] = 1;
 
             // Evaluate the curve for every bit of the private key.
@@ -520,9 +507,9 @@ public final class Curve25519 {
                 int bit = (index * 8) % 26;
                 int word = (index * 8) / 26;
                 if (bit <= (26 - 8))
-                    result[offset + index] = (byte)(state.x_2[word] >> bit);
+                    result[offset + index] = (byte) (state.x_2[word] >> bit);
                 else
-                    result[offset + index] = (byte)((state.x_2[word] >> bit) | (state.x_2[word + 1] << (26 - bit)));
+                    result[offset + index] = (byte) ((state.x_2[word] >> bit) | (state.x_2[word + 1] << (26 - bit)));
             }
         } finally {
             // Clean up all temporary state before we exit.

eclair-core/src/test/scala/fr/acinq/eclair/FeaturesSpec.scala

@@ -2,7 +2,7 @@ package fr.acinq.eclair
 
 import java.nio.ByteOrder
 
-import fr.acinq.bitcoin.{BinaryData, Protocol}
+import fr.acinq.bitcoin.Protocol
 import fr.acinq.eclair.Features._
 import org.junit.runner.RunWith
 import org.scalatest.FunSuite

eclair-core/src/test/scala/fr/acinq/eclair/Pipe.scala

@@ -2,7 +2,6 @@ package fr.acinq.eclair
 
 import akka.actor.{Actor, ActorLogging, ActorRef, Stash}
 import fr.acinq.eclair.channel.Commitments.msg2String
-import fr.acinq.eclair.channel.{INPUT_DISCONNECTED, INPUT_RECONNECTED}
 import fr.acinq.eclair.wire.LightningMessage
 
 /**

eclair-core/src/test/scala/fr/acinq/eclair/TestConstants.scala

@@ -23,7 +23,9 @@ object TestConstants {
     val seed = BinaryData("01" * 32)
     val master = DeterministicWallet.generate(seed)
     val extendedPrivateKey = DeterministicWallet.derivePrivateKey(master, DeterministicWallet.hardened(46) :: DeterministicWallet.hardened(0) :: Nil)
+
     def sqlite = DriverManager.getConnection("jdbc:sqlite::memory:")
+
     def nodeParams = NodeParams(
       extendedPrivateKey = extendedPrivateKey,
       privateKey = extendedPrivateKey.privateKey,
@@ -58,7 +60,9 @@ object TestConstants {
       channelFlags = 1,
       channelExcludeDuration = 5 seconds,
       watcherType = BITCOIND)
+
     def id = nodeParams.privateKey.publicKey
+
     def channelParams = Peer.makeChannelParams(
       nodeParams = nodeParams,
       defaultFinalScriptPubKey = Script.write(Script.pay2wpkh(PrivateKey(Array.fill[Byte](32)(4), compressed = true).publicKey)),
@@ -72,7 +76,9 @@ object TestConstants {
     val seed = BinaryData("02" * 32)
     val master = DeterministicWallet.generate(seed)
     val extendedPrivateKey = DeterministicWallet.derivePrivateKey(master, DeterministicWallet.hardened(46) :: DeterministicWallet.hardened(0) :: Nil)
+
     def sqlite = DriverManager.getConnection("jdbc:sqlite::memory:")
+
     def nodeParams = NodeParams(
       extendedPrivateKey = extendedPrivateKey,
       privateKey = extendedPrivateKey.privateKey,
@@ -107,7 +113,9 @@ object TestConstants {
       channelFlags = 1,
       channelExcludeDuration = 5 seconds,
       watcherType = BITCOIND)
+
     def id = nodeParams.privateKey.publicKey
+
     def channelParams = Peer.makeChannelParams(
       nodeParams = nodeParams,
       defaultFinalScriptPubKey = Script.write(Script.pay2wpkh(PrivateKey(Array.fill[Byte](32)(5), compressed = true).publicKey)),

eclair-core/src/test/scala/fr/acinq/eclair/blockchain/electrum/ElectrumClientSpec.scala

@@ -5,8 +5,8 @@ import akka.testkit.{TestKit, TestProbe}
 import fr.acinq.bitcoin.{BinaryData, Crypto, Transaction}
 import grizzled.slf4j.Logging
 import org.junit.runner.RunWith
-import org.scalatest.{BeforeAndAfterAll, FunSuiteLike}
 import org.scalatest.junit.JUnitRunner
+import org.scalatest.{BeforeAndAfterAll, FunSuiteLike}
 
 import scala.concurrent.duration._
 
@@ -14,6 +14,7 @@ import scala.concurrent.duration._
 class ElectrumClientSpec extends TestKit(ActorSystem("test")) with FunSuiteLike with Logging with BeforeAndAfterAll {
 
   import ElectrumClient._
+
   var client: ActorRef = _
   val probe = TestProbe()
   val referenceTx = Transaction.read("0200000003947e307df3ab452d23f02b5a65f4ada1804ee733e168e6197b0bd6cc79932b6c010000006a473044022069346ec6526454a481690a3664609f9e8032c34553015cfa2e9b25ebb420a33002206998f21a2aa771ad92a0c1083f4181a3acdb0d42ca51d01be1309da2ffb9cecf012102b4568cc6ee751f6d39f4a908b1fcffdb878f5f784a26a48c0acb0acff9d88e3bfeffffff966d9d969cd5f95bfd53003a35fcc1a50f4fb51f211596e6472583fdc5d38470000000006b4830450221009c9757515009c5709b5b678d678185202b817ef9a69ffb954144615ab11762210220732216384da4bf79340e9c46d0effba6ba92982cca998adfc3f354cec7715f800121035f7c3e077108035026f4ebd5d6ca696ef088d4f34d45d94eab4c41202ec74f9bfefffffff8d5062f5b04455c6cfa7e3f250e5a4fb44308ba2b86baf77f9ad0d782f57071010000006a47304402207f9f7dd91fe537a26d5554105977e3949a5c8c4ef53a6a3bff6da2d36eff928f02202b9427bef487a1825fd0c3c6851d17d5f19e6d73dfee22bf06db591929a2044d012102b4568cc6ee751f6d39f4a908b1fcffdb878f5f784a26a48c0acb0acff9d88e3bfeffffff02809698000000000017a914c82753548fdf4be1c3c7b14872c90b5198e67eaa876e642500000000001976a914e2365ec29471b3e271388b22eadf0e7f54d307a788ac6f771200")
@@ -73,6 +74,6 @@ class ElectrumClientSpec extends TestKit(ActorSystem("test")) with FunSuiteLike
   test("list script unspents") {
     probe.send(client, ScriptHashListUnspent(scriptHash))
     val ScriptHashListUnspentResponse(scriptHash1, unspents) = probe.expectMsgType[ScriptHashListUnspentResponse]
-    assert(unspents.contains(UnspentItem("3903726806aa044fe59f40e42eed71bded068b43aaa9e2d716e38b7825412de0", 0, 10000000L,1210224L)))
+    assert(unspents.contains(UnspentItem("3903726806aa044fe59f40e42eed71bded068b43aaa9e2d716e38b7825412de0", 0, 10000000L, 1210224L)))
   }
 }

eclair-core/src/test/scala/fr/acinq/eclair/blockchain/electrum/ElectrumWalletBasicSpec.scala

@@ -1,14 +1,12 @@
 package fr.acinq.eclair.blockchain.electrum
 
-import fr.acinq.bitcoin._
-import fr.acinq.bitcoin.Crypto.{PrivateKey, PublicKey}
+import fr.acinq.bitcoin.Crypto.PrivateKey
 import fr.acinq.bitcoin.DeterministicWallet.derivePrivateKey
+import fr.acinq.bitcoin._
 import org.junit.runner.RunWith
 import org.scalatest.FunSuite
 import org.scalatest.junit.JUnitRunner
 
-import scala.util.Try
-
 @RunWith(classOf[JUnitRunner])
 class ElectrumWalletBasicSpec extends FunSuite {
 

eclair-core/src/test/scala/fr/acinq/eclair/blockchain/electrum/ElectrumWalletSpec.scala

@@ -9,7 +9,8 @@ import org.json4s.JsonAST._
 import scala.concurrent.duration._
 import scala.sys.process._
 
-class ElectrumWalletSpec extends IntegrationSpec{
+class ElectrumWalletSpec extends IntegrationSpec {
+
   import ElectrumWallet._
 
   val entropy = BinaryData("01" * 32)
@@ -107,7 +108,7 @@ class ElectrumWalletSpec extends IntegrationSpec{
 
     awaitCond({
       val msg = listener.receiveOne(5 seconds)
-      msg == TransactionConfidenceChanged(BinaryData(txid),1)
+      msg == TransactionConfidenceChanged(BinaryData(txid), 1)
     }, max = 30 seconds, interval = 1 second)
   }
 

eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/EarnDotComFeeProviderSpec.scala

@@ -16,8 +16,8 @@ import scala.concurrent.Await
 class EarnDotComFeeProviderSpec extends FunSuite {
 
   import EarnDotComFeeProvider._
-
   import org.json4s.jackson.JsonMethods.parse
+
   implicit val formats = DefaultFormats
 
   val sample_response =
@@ -53,8 +53,8 @@ class EarnDotComFeeProviderSpec extends FunSuite {
   }
 
   test("make sure API hasn't changed") {
-    import scala.concurrent.duration._
     import scala.concurrent.ExecutionContext.Implicits.global
+    import scala.concurrent.duration._
     implicit val system = ActorSystem()
     implicit val timeout = Timeout(30 seconds)
     val provider = new EarnDotComFeeProvider()

eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/FallbackFeeProviderSpec.scala

@@ -4,8 +4,8 @@ import org.junit.runner.RunWith
 import org.scalatest.FunSuite
 import org.scalatest.junit.JUnitRunner
 
-import scala.concurrent.{Await, Future}
 import scala.concurrent.duration._
+import scala.concurrent.{Await, Future}
 import scala.util.Random
 
 @RunWith(classOf[JUnitRunner])
@@ -15,6 +15,7 @@ class FallbackFeeProviderSpec extends FunSuite {
 
   /**
     * This provider returns a constant value, but fails after ttl tries
+    *
     * @param ttl
     * @param feeratesPerByte
     */
@@ -25,7 +26,7 @@ class FallbackFeeProviderSpec extends FunSuite {
       if (i < ttl) {
         i = i + 1
         Future.successful(feeratesPerByte)
-      }  else Future.failed(new RuntimeException())
+      } else Future.failed(new RuntimeException())
   }
 
   def dummyFeerates = FeeratesPerByte(Random.nextInt(10000), Random.nextInt(10000), Random.nextInt(10000), Random.nextInt(10000), Random.nextInt(10000), Random.nextInt(10000))
@@ -39,7 +40,7 @@ class FallbackFeeProviderSpec extends FunSuite {
     val provider5 = new FailingFeeProvider(5, dummyFeerates) // fails after 5 tries
     val provider7 = new FailingFeeProvider(Int.MaxValue, dummyFeerates) // "never" fails
 
-   val fallbackFeeProvider = new FallbackFeeProvider(provider0 :: provider1 :: provider3 :: provider5 :: provider7 :: Nil)
+    val fallbackFeeProvider = new FallbackFeeProvider(provider0 :: provider1 :: provider3 :: provider5 :: provider7 :: Nil)
 
     assert(await(fallbackFeeProvider.getFeerates) === provider1.feeratesPerByte)
 
@@ -58,5 +59,4 @@ class FallbackFeeProviderSpec extends FunSuite {
   }
 
 
-
 }

eclair-core/src/test/scala/fr/acinq/eclair/channel/states/StateTestsHelperMethods.scala

@@ -7,8 +7,7 @@ import fr.acinq.eclair.blockchain._
 import fr.acinq.eclair.blockchain.fee.FeeratesPerKw
 import fr.acinq.eclair.channel._
 import fr.acinq.eclair.crypto.Sphinx
-import fr.acinq.eclair.payment.PaymentLifecycle
-import fr.acinq.eclair.payment.Hop
+import fr.acinq.eclair.payment.{Hop, PaymentLifecycle}
 import fr.acinq.eclair.wire._
 import fr.acinq.eclair.{Globals, TestConstants}
 

eclair-core/src/test/scala/fr/acinq/eclair/channel/states/a/WaitForAcceptChannelStateSpec.scala

@@ -1,6 +1,5 @@
 package fr.acinq.eclair.channel.states.a
 
-import akka.actor.ActorRef
 import akka.testkit.{TestFSMRef, TestProbe}
 import fr.acinq.eclair.TestConstants.{Alice, Bob}
 import fr.acinq.eclair.channel.states.StateTestsHelperMethods

eclair-core/src/test/scala/fr/acinq/eclair/channel/states/e/NormalStateSpec.scala

@@ -210,7 +210,7 @@ class NormalStateSpec extends TestkitBaseClass with StateTestsHelperMethods {
   test("recv CMD_ADD_HTLC (while waiting for a revocation)") { case (alice, _, alice2bob, _, _, _, relayer) =>
     within(30 seconds) {
       val sender = TestProbe()
-      val add1 = CMD_ADD_HTLC(TestConstants.fundingSatoshis * 2/3 * 1000, "11" * 32, 400144)
+      val add1 = CMD_ADD_HTLC(TestConstants.fundingSatoshis * 2 / 3 * 1000, "11" * 32, 400144)
       sender.send(alice, add1)
       sender.expectMsg("ok")
       alice2bob.expectMsgType[UpdateAddHtlc]
@@ -218,7 +218,7 @@ class NormalStateSpec extends TestkitBaseClass with StateTestsHelperMethods {
       sender.expectMsg("ok")
       alice2bob.expectMsgType[CommitSig]
       // this is over channel-capacity
-      val add2 = CMD_ADD_HTLC(TestConstants.fundingSatoshis * 2/3 * 1000, "22" * 32, 400144)
+      val add2 = CMD_ADD_HTLC(TestConstants.fundingSatoshis * 2 / 3 * 1000, "22" * 32, 400144)
       sender.send(alice, add2)
       //sender.expectMsgType[Failure]
       relayer.expectMsgType[ForwardLocalFail]

eclair-core/src/test/scala/fr/acinq/eclair/channel/states/f/ShutdownStateSpec.scala

@@ -8,8 +8,7 @@ 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._
-import fr.acinq.eclair.payment.{ForwardAdd, ForwardLocalFail, Local, PaymentLifecycle}
+import fr.acinq.eclair.payment.{ForwardAdd, ForwardLocalFail, Local, PaymentLifecycle, _}
 import fr.acinq.eclair.wire.{CommitSig, Error, FailureMessageCodecs, PermanentChannelFailure, RevokeAndAck, Shutdown, UpdateAddHtlc, UpdateFailHtlc, UpdateFailMalformedHtlc, UpdateFee, UpdateFulfillHtlc}
 import fr.acinq.eclair.{Globals, TestConstants, TestkitBaseClass}
 import org.junit.runner.RunWith

eclair-core/src/test/scala/fr/acinq/eclair/channel/states/g/NegotiatingStateSpec.scala

@@ -2,12 +2,12 @@ package fr.acinq.eclair.channel.states.g
 
 import akka.actor.Status.Failure
 import akka.testkit.{TestFSMRef, TestProbe}
-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.wire.{ClosingSigned, Error, Shutdown}
+import fr.acinq.eclair.{Globals, TestkitBaseClass}
 import org.junit.runner.RunWith
 import org.scalatest.Tag
 import org.scalatest.junit.JUnitRunner

eclair-core/src/test/scala/fr/acinq/eclair/channel/states/h/ClosingStateSpec.scala

@@ -7,7 +7,6 @@ import fr.acinq.eclair.TestkitBaseClass
 import fr.acinq.eclair.blockchain._
 import fr.acinq.eclair.channel.states.StateTestsHelperMethods
 import fr.acinq.eclair.channel.{Data, State, _}
-import fr.acinq.eclair.payment.HtlcGenerationSpec.paymentPreimage
 import fr.acinq.eclair.payment.{AckFulfillCmd, ForwardAdd, ForwardFulfill}
 import fr.acinq.eclair.transactions.Scripts
 import fr.acinq.eclair.wire._

eclair-core/src/test/scala/fr/acinq/eclair/crypto/BitStreamSpec.scala

@@ -10,6 +10,7 @@ import org.spongycastle.util.encoders.Hex
   */
 @RunWith(classOf[JUnitRunner])
 class BitStreamSpec extends FunSuite {
+
   import BitStream._
 
   test("add bits") {

eclair-core/src/test/scala/fr/acinq/eclair/crypto/NoiseSpec.scala

@@ -2,10 +2,10 @@ package fr.acinq.eclair.crypto
 
 import fr.acinq.bitcoin.BinaryData
 import fr.acinq.eclair.crypto.Noise._
-import org.spongycastle.crypto.ec.CustomNamedCurves
 import org.junit.runner.RunWith
 import org.scalatest.FunSuite
 import org.scalatest.junit.JUnitRunner
+import org.spongycastle.crypto.ec.CustomNamedCurves
 
 @RunWith(classOf[JUnitRunner])
 class NoiseSpec extends FunSuite {

eclair-core/src/test/scala/fr/acinq/eclair/crypto/SphinxSpec.scala

@@ -1,7 +1,7 @@
 package fr.acinq.eclair.crypto
 
+import fr.acinq.bitcoin.BinaryData
 import fr.acinq.bitcoin.Crypto.{PrivateKey, PublicKey}
-import fr.acinq.bitcoin.{BinaryData, Crypto}
 import fr.acinq.eclair.wire._
 import org.junit.runner.RunWith
 import org.scalatest.FunSuite
@@ -102,23 +102,23 @@ class SphinxSpec extends FunSuite {
     // node #4 want to reply with an error message
     val error = createErrorPacket(sharedSecret4, TemporaryNodeFailure)
     assert(error == BinaryData("a5e6bd0c74cb347f10cce367f949098f2457d14c046fd8a22cb96efb30b0fdcda8cb9168b50f2fd45edd73c1b0c8b33002df376801ff58aaa94000bf8a86f92620f343baef38a580102395ae3abf9128d1047a0736ff9b83d456740ebbb4aeb3aa9737f18fb4afb4aa074fb26c4d702f42968888550a3bded8c05247e045b866baef0499f079fdaeef6538f31d44deafffdfd3afa2fb4ca9082b8f1c465371a9894dd8c243fb4847e004f5256b3e90e2edde4c9fb3082ddfe4d1e734cacd96ef0706bf63c9984e22dc98851bcccd1c3494351feb458c9c6af41c0044bea3c47552b1d992ae542b17a2d0bba1a096c78d169034ecb55b6e3a7263c26017f033031228833c1daefc0dedb8cf7c3e37c9c37ebfe42f3225c326e8bcfd338804c145b16e34e4"))
-//    assert(error == BinaryData("69b1e5a3e05a7b5478e6529cd1749fdd8c66da6f6db42078ff8497ac4e117e91a8cb9168b58f2fd45edd73c1b0c8b33002df376801ff58aaa94000bf8a86f92620f343baef38a580102395ae3abf9128d1047a0736ff9b83d456740ebbb4aeb3aa9737f18fb4afb4aa074fb26c4d702f42968888550a3bded8c05247e045b866baef0499f079fdaeef6538f31d44deafffdfd3afa2fb4ca9082b8f1c465371a9894dd8c2"))
+    //    assert(error == BinaryData("69b1e5a3e05a7b5478e6529cd1749fdd8c66da6f6db42078ff8497ac4e117e91a8cb9168b58f2fd45edd73c1b0c8b33002df376801ff58aaa94000bf8a86f92620f343baef38a580102395ae3abf9128d1047a0736ff9b83d456740ebbb4aeb3aa9737f18fb4afb4aa074fb26c4d702f42968888550a3bded8c05247e045b866baef0499f079fdaeef6538f31d44deafffdfd3afa2fb4ca9082b8f1c465371a9894dd8c2"))
     // error sent back to 3, 2, 1 and 0
     val error1 = forwardErrorPacket(error, sharedSecret3)
     assert(error1 == BinaryData("c49a1ce81680f78f5f2000cda36268de34a3f0a0662f55b4e837c83a8773c22aa081bab1616a0011585323930fa5b9fae0c85770a2279ff59ec427ad1bbff9001c0cd1497004bd2a0f68b50704cf6d6a4bf3c8b6a0833399a24b3456961ba00736785112594f65b6b2d44d9f5ea4e49b5e1ec2af978cbe31c67114440ac51a62081df0ed46d4a3df295da0b0fe25c0115019f03f15ec86fabb4c852f83449e812f141a9395b3f70b766ebbd4ec2fae2b6955bd8f32684c15abfe8fd3a6261e52650e8807a92158d9f1463261a925e4bfba44bd20b166d532f0017185c3a6ac7957adefe45559e3072c8dc35abeba835a8cb01a71a15c736911126f27d46a36168ca5ef7dccd4e2886212602b181463e0dd30185c96348f9743a02aca8ec27c0b90dca270"))
-//    assert(error1 == BinaryData("08cd44478211b8a4370ab1368b5ffe8c9c92fb830ff4ad6e3b0a316df9d24176a081bab161ea0011585323930fa5b9fae0c85770a2279ff59ec427ad1bbff9001c0cd1497004bd2a0f68b50704cf6d6a4bf3c8b6a0833399a24b3456961ba00736785112594f65b6b2d44d9f5ea4e49b5e1ec2af978cbe31c67114440ac51a62081df0ed46d4a3df295da0b0fe25c0115019f03f15ec86fabb4c852f83449e812f141a93"))
+    //    assert(error1 == BinaryData("08cd44478211b8a4370ab1368b5ffe8c9c92fb830ff4ad6e3b0a316df9d24176a081bab161ea0011585323930fa5b9fae0c85770a2279ff59ec427ad1bbff9001c0cd1497004bd2a0f68b50704cf6d6a4bf3c8b6a0833399a24b3456961ba00736785112594f65b6b2d44d9f5ea4e49b5e1ec2af978cbe31c67114440ac51a62081df0ed46d4a3df295da0b0fe25c0115019f03f15ec86fabb4c852f83449e812f141a93"))
 
     val error2 = forwardErrorPacket(error1, sharedSecret2)
     assert(error2 == BinaryData("a5d3e8634cfe78b2307d87c6d90be6fe7855b4f2cc9b1dfb19e92e4b79103f61ff9ac25f412ddfb7466e74f81b3e545563cdd8f5524dae873de61d7bdfccd496af2584930d2b566b4f8d3881f8c043df92224f38cf094cfc09d92655989531524593ec6d6caec1863bdfaa79229b5020acc034cd6deeea1021c50586947b9b8e6faa83b81fbfa6133c0af5d6b07c017f7158fa94f0d206baf12dda6b68f785b773b360fd0497e16cc402d779c8d48d0fa6315536ef0660f3f4e1865f5b38ea49c7da4fd959de4e83ff3ab686f059a45c65ba2af4a6a79166aa0f496bf04d06987b6d2ea205bdb0d347718b9aeff5b61dfff344993a275b79717cd815b6ad4c0beb568c4ac9c36ff1c315ec1119a1993c4b61e6eaa0375e0aaf738ac691abd3263bf937e3"))
-//    assert(error2 == BinaryData("6984b0ccd86f37995857363df13670acd064bfd1a540e521cad4d71c07b1bc3dff9ac25f41addfb7466e74f81b3e545563cdd8f5524dae873de61d7bdfccd496af2584930d2b566b4f8d3881f8c043df92224f38cf094cfc09d92655989531524593ec6d6caec1863bdfaa79229b5020acc034cd6deeea1021c50586947b9b8e6faa83b81fbfa6133c0af5d6b07c017f7158fa94f0d206baf12dda6b68f785b773b360fd"))
+    //    assert(error2 == BinaryData("6984b0ccd86f37995857363df13670acd064bfd1a540e521cad4d71c07b1bc3dff9ac25f41addfb7466e74f81b3e545563cdd8f5524dae873de61d7bdfccd496af2584930d2b566b4f8d3881f8c043df92224f38cf094cfc09d92655989531524593ec6d6caec1863bdfaa79229b5020acc034cd6deeea1021c50586947b9b8e6faa83b81fbfa6133c0af5d6b07c017f7158fa94f0d206baf12dda6b68f785b773b360fd"))
 
     val error3 = forwardErrorPacket(error2, sharedSecret1)
     assert(error3 == BinaryData("aac3200c4968f56b21f53e5e374e3a2383ad2b1b6501bbcc45abc31e59b26881b7dfadbb56ec8dae8857add94e6702fb4c3a4de22e2e669e1ed926b04447fc73034bb730f4932acd62727b75348a648a1128744657ca6a4e713b9b646c3ca66cac02cdab44dd3439890ef3aaf61708714f7375349b8da541b2548d452d84de7084bb95b3ac2345201d624d31f4d52078aa0fa05a88b4e20202bd2b86ac5b52919ea305a8949de95e935eed0319cf3cf19ebea61d76ba92532497fcdc9411d06bcd4275094d0a4a3c5d3a945e43305a5a9256e333e1f64dbca5fcd4e03a39b9012d197506e06f29339dfee3331995b21615337ae060233d39befea925cc262873e0530408e6990f1cbd233a150ef7b004ff6166c70c68d9f8c853c1abca640b8660db2921"))
-//    assert(error3 == BinaryData("669478a3ddf9ba4049df8fa51f73ac712b9c20380cda431696963a492713ebddb7dfadbb566c8dae8857add94e6702fb4c3a4de22e2e669e1ed926b04447fc73034bb730f4932acd62727b75348a648a1128744657ca6a4e713b9b646c3ca66cac02cdab44dd3439890ef3aaf61708714f7375349b8da541b2548d452d84de7084bb95b3ac2345201d624d31f4d52078aa0fa05a88b4e20202bd2b86ac5b52919ea305a8"))
+    //    assert(error3 == BinaryData("669478a3ddf9ba4049df8fa51f73ac712b9c20380cda431696963a492713ebddb7dfadbb566c8dae8857add94e6702fb4c3a4de22e2e669e1ed926b04447fc73034bb730f4932acd62727b75348a648a1128744657ca6a4e713b9b646c3ca66cac02cdab44dd3439890ef3aaf61708714f7375349b8da541b2548d452d84de7084bb95b3ac2345201d624d31f4d52078aa0fa05a88b4e20202bd2b86ac5b52919ea305a8"))
 
     val error4 = forwardErrorPacket(error3, sharedSecret0)
     assert(error4 == BinaryData("9c5add3963fc7f6ed7f148623c84134b5647e1306419dbe2174e523fa9e2fbed3a06a19f899145610741c83ad40b7712aefaddec8c6baf7325d92ea4ca4d1df8bce517f7e54554608bf2bd8071a4f52a7a2f7ffbb1413edad81eeea5785aa9d990f2865dc23b4bc3c301a94eec4eabebca66be5cf638f693ec256aec514620cc28ee4a94bd9565bc4d4962b9d3641d4278fb319ed2b84de5b665f307a2db0f7fbb757366067d88c50f7e829138fde4f78d39b5b5802f1b92a8a820865af5cc79f9f30bc3f461c66af95d13e5e1f0381c184572a91dee1c849048a647a1158cf884064deddbf1b0b88dfe2f791428d0ba0f6fb2f04e14081f69165ae66d9297c118f0907705c9c4954a199bae0bb96fad763d690e7daa6cfda59ba7f2c8d11448b604d12d"))
-//    assert(error4 == BinaryData("500d8596f76d3045bfdbf99914b98519fe76ea130dc22338c473ab68d74378b13a06a19f891145610741c83ad40b7712aefaddec8c6baf7325d92ea4ca4d1df8bce517f7e54554608bf2bd8071a4f52a7a2f7ffbb1413edad81eeea5785aa9d990f2865dc23b4bc3c301a94eec4eabebca66be5cf638f693ec256aec514620cc28ee4a94bd9565bc4d4962b9d3641d4278fb319ed2b84de5b665f307a2db0f7fbb757366"))
+    //    assert(error4 == BinaryData("500d8596f76d3045bfdbf99914b98519fe76ea130dc22338c473ab68d74378b13a06a19f891145610741c83ad40b7712aefaddec8c6baf7325d92ea4ca4d1df8bce517f7e54554608bf2bd8071a4f52a7a2f7ffbb1413edad81eeea5785aa9d990f2865dc23b4bc3c301a94eec4eabebca66be5cf638f693ec256aec514620cc28ee4a94bd9565bc4d4962b9d3641d4278fb319ed2b84de5b665f307a2db0f7fbb757366"))
 
 
     // origin parses error packet and can see that it comes from node #4

eclair-core/src/test/scala/fr/acinq/eclair/crypto/TransportHandlerSpec.scala

@@ -123,18 +123,17 @@ class TransportHandlerSpec extends TestKit(ActorSystem("test")) with FunSuiteLik
     probe1.expectTerminated(pipe)
   }
 
-//  NOTE: disabled because TestFSMRef interface changed between akka versions
-//  test("failed handshake") {
-//    val pipe = system.actorOf(Props[MyPipe])
-//    val probe1 = TestProbe()
-//    val supervisor = TestActorRef(Props(new MySupervisor()))
-//    val initiator = TestFSMRef(new TransportHandler(Initiator.s, Some(Initiator.s.pub), pipe, LightningMessageCodecs.varsizebinarydata), supervisor, "ini")
-//    val responder = TestFSMRef(new TransportHandler(Responder.s, None, pipe, LightningMessageCodecs.varsizebinarydata), supervisor, "res")
-//    probe1.watch(responder)
-//    pipe ! (initiator, responder)
-//
-//    probe1.expectTerminated(responder, 3 seconds)
-//  }
+  test("failed handshake") {
+    val pipe = system.actorOf(Props[MyPipe])
+    val probe1 = TestProbe()
+    val supervisor = TestActorRef(Props(new MySupervisor()))
+    val initiator = TestFSMRef(new TransportHandler(Initiator.s, Some(Initiator.s.pub), pipe, LightningMessageCodecs.varsizebinarydata), supervisor, "ini")
+    val responder = TestFSMRef(new TransportHandler(Responder.s, None, pipe, LightningMessageCodecs.varsizebinarydata), supervisor, "res")
+    probe1.watch(responder)
+    pipe ! (initiator, responder)
+
+    probe1.expectTerminated(responder, 3 seconds)
+  }
 
   test("key rotation") {
 

eclair-core/src/test/scala/fr/acinq/eclair/db/ChannelStateSpec.scala

@@ -6,10 +6,10 @@ import fr.acinq.eclair.channel.Helpers.Funding
 import fr.acinq.eclair.channel._
 import fr.acinq.eclair.crypto.{ShaChain, Sphinx}
 import fr.acinq.eclair.payment.{Local, Relayed}
-import fr.acinq.eclair.{UInt64, randomKey}
 import fr.acinq.eclair.transactions.Transactions.CommitTx
 import fr.acinq.eclair.transactions._
-import fr.acinq.eclair.wire.{ChannelCodecs, CommitSig, UpdateAddHtlc}
+import fr.acinq.eclair.wire.{ChannelCodecs, UpdateAddHtlc}
+import fr.acinq.eclair.{UInt64, randomKey}
 import org.junit.runner.RunWith
 import org.scalatest.FunSuite
 import org.scalatest.junit.JUnitRunner

eclair-core/src/test/scala/fr/acinq/eclair/db/SqliteNetworkDbSpec.scala

@@ -7,7 +7,6 @@ import fr.acinq.bitcoin.{Block, Crypto}
 import fr.acinq.eclair.db.sqlite.SqliteNetworkDb
 import fr.acinq.eclair.randomKey
 import fr.acinq.eclair.router.Announcements
-import fr.acinq.eclair.wire.LightningMessageCodecs.channelAnnouncementCodec
 import org.junit.runner.RunWith
 import org.scalatest.FunSuite
 import org.scalatest.junit.JUnitRunner

eclair-core/src/test/scala/fr/acinq/eclair/integration/BasicBitcoinjIntegrationSpec.scala

@@ -87,7 +87,7 @@ class BasicIntegrationSpvSpec extends TestKit(ActorSystem("test")) with FunSuite
     nodes.foreach {
       case (name, setup) =>
         logger.info(s"stopping node $name")
-        setup.system.shutdown()
+        setup.system.terminate()
     }
     //    logger.warn(s"starting bitcoin-qt")
     //    val PATH_BITCOINQT = new File(System.getProperty("buildDirectory"), "bitcoin-0.14.0/bin/bitcoin-qt").toPath
@@ -115,7 +115,7 @@ class BasicIntegrationSpvSpec extends TestKit(ActorSystem("test")) with FunSuite
     }
     val setup = new Setup(datadir, actorSystem = ActorSystem(s"system-$name"))
     val kit = Await.result(setup.bootstrap, 10 seconds)
-    //TODO setup.bitcoin.asInstanceOf[Bitcoinj].bitcoinjKit.awaitRunning()
+    setup.bitcoin.asInstanceOf[Bitcoinj].bitcoinjKit.awaitRunning()
     nodes = nodes + (name -> kit)
   }
 

eclair-core/src/test/scala/fr/acinq/eclair/integration/IntegrationSpec.scala

@@ -26,7 +26,7 @@ import org.json4s.JsonAST.JValue
 import org.json4s.{DefaultFormats, JString}
 import org.junit.runner.RunWith
 import org.scalatest.junit.JUnitRunner
-import org.scalatest.{BeforeAndAfterAll, FunSuiteLike, Ignore}
+import org.scalatest.{BeforeAndAfterAll, FunSuiteLike}
 
 import scala.concurrent.Await
 import scala.concurrent.ExecutionContext.Implicits.global
@@ -37,7 +37,6 @@ import scala.sys.process._
   * Created by PM on 15/03/2017.
   */
 @RunWith(classOf[JUnitRunner])
-@Ignore
 class IntegrationSpec extends TestKit(ActorSystem("test")) with FunSuiteLike with BeforeAndAfterAll with Logging {
 
   val INTEGRATION_TMP_DIR = s"${System.getProperty("buildDirectory")}/integration-${UUID.randomUUID().toString}"
@@ -79,7 +78,7 @@ class IntegrationSpec extends TestKit(ActorSystem("test")) with FunSuiteLike wit
     nodes.foreach {
       case (name, setup) =>
         logger.info(s"stopping node $name")
-        setup.system.shutdown()
+        setup.system.terminate()
     }
     //    logger.warn(s"starting bitcoin-qt")
     //    val PATH_BITCOINQT = new File(System.getProperty("buildDirectory"), "bitcoin-0.14.0/bin/bitcoin-qt").toPath
@@ -365,6 +364,7 @@ class IntegrationSpec extends TestKit(ActorSystem("test")) with FunSuiteLike wit
 
   /**
     * We currently use p2pkh script Helpers.getFinalScriptPubKey
+    *
     * @param scriptPubKey
     * @return
     */

eclair-core/src/test/scala/fr/acinq/eclair/interop/rustytests/SynchronizationPipe.scala

@@ -1,11 +1,10 @@
 package fr.acinq.eclair.interop.rustytests
 
 import java.io.{BufferedWriter, File, FileWriter}
-import java.util.UUID
 import java.util.concurrent.CountDownLatch
 
 import akka.actor.{Actor, ActorLogging, ActorRef, Stash}
-import fr.acinq.bitcoin.{BinaryData, Crypto}
+import fr.acinq.bitcoin.BinaryData
 import fr.acinq.eclair.channel._
 import fr.acinq.eclair.transactions.{IN, OUT}
 

eclair-core/src/test/scala/fr/acinq/eclair/payment/HtlcGenerationSpec.scala

@@ -3,9 +3,9 @@ package fr.acinq.eclair.payment
 import fr.acinq.bitcoin.{BinaryData, Block, Crypto}
 import fr.acinq.eclair.crypto.Sphinx
 import fr.acinq.eclair.crypto.Sphinx.{PacketAndSecrets, ParsedPacket}
+import fr.acinq.eclair.payment.PaymentHop.nodeFee
 import fr.acinq.eclair.payment.PaymentLifecycle._
 import fr.acinq.eclair.randomKey
-import fr.acinq.eclair.payment.PaymentHop.nodeFee
 import fr.acinq.eclair.wire.{ChannelUpdate, LightningMessageCodecs, PerHopPayload}
 import org.junit.runner.RunWith
 import org.scalatest.FunSuite

eclair-core/src/test/scala/fr/acinq/eclair/payment/PaymentLifecycleSpec.scala

@@ -1,7 +1,6 @@
 package fr.acinq.eclair.payment
 
 import akka.actor.FSM.{CurrentState, SubscribeTransitionCallBack, Transition}
-import akka.actor.Status.Failure
 import akka.testkit.{TestFSMRef, TestProbe}
 import fr.acinq.bitcoin.MilliSatoshi
 import fr.acinq.eclair.Globals
@@ -12,7 +11,6 @@ import fr.acinq.eclair.router._
 import fr.acinq.eclair.wire._
 import org.junit.runner.RunWith
 import org.scalatest.junit.JUnitRunner
-import org.scalatest.matchers.FailureMessage
 
 /**
   * Created by PM on 29/08/2016.

eclair-core/src/test/scala/fr/acinq/eclair/router/AnnouncementsSpec.scala

@@ -1,7 +1,7 @@
 package fr.acinq.eclair.router
 
-import fr.acinq.bitcoin.{BinaryData, Block}
 import fr.acinq.bitcoin.Crypto.{PrivateKey, PublicKey}
+import fr.acinq.bitcoin.{BinaryData, Block}
 import fr.acinq.eclair.TestConstants.Alice
 import fr.acinq.eclair._
 import fr.acinq.eclair.router.Announcements._

eclair-core/src/test/scala/fr/acinq/eclair/router/BaseRouterSpec.scala

@@ -92,15 +92,15 @@ abstract class BaseRouterSpec extends TestkitBaseClass {
       // and answers with valid scripts
       watcher.send(router, ParallelGetResponse(
         IndividualResult(chan_ab, Some(Transaction(version = 0, txIn = Nil, txOut = TxOut(Satoshi(1000000), write(pay2wsh(Scripts.multiSig2of2(funding_a, funding_b)))) :: Nil, lockTime = 0)), true) ::
-        IndividualResult(chan_bc, Some(Transaction(version = 0, txIn = Nil, txOut = TxOut(Satoshi(1000000), write(pay2wsh(Scripts.multiSig2of2(funding_b, funding_c)))) :: Nil, lockTime = 0)), true) ::
-        IndividualResult(chan_cd, Some(Transaction(version = 0, txIn = Nil, txOut = TxOut(Satoshi(1000000), write(pay2wsh(Scripts.multiSig2of2(funding_c, funding_d)))) :: Nil, lockTime = 0)), true) ::
-        IndividualResult(chan_ef, Some(Transaction(version = 0, txIn = Nil, txOut = TxOut(Satoshi(1000000), write(pay2wsh(Scripts.multiSig2of2(funding_e, funding_f)))) :: Nil, lockTime = 0)), true) :: Nil
+          IndividualResult(chan_bc, Some(Transaction(version = 0, txIn = Nil, txOut = TxOut(Satoshi(1000000), write(pay2wsh(Scripts.multiSig2of2(funding_b, funding_c)))) :: Nil, lockTime = 0)), true) ::
+          IndividualResult(chan_cd, Some(Transaction(version = 0, txIn = Nil, txOut = TxOut(Satoshi(1000000), write(pay2wsh(Scripts.multiSig2of2(funding_c, funding_d)))) :: Nil, lockTime = 0)), true) ::
+          IndividualResult(chan_ef, Some(Transaction(version = 0, txIn = Nil, txOut = TxOut(Satoshi(1000000), write(pay2wsh(Scripts.multiSig2of2(funding_e, funding_f)))) :: Nil, lockTime = 0)), true) :: Nil
       ))
       // watcher receives watch-spent request
-      //watcher.expectMsgType[WatchSpentBasic]
-      //watcher.expectMsgType[WatchSpentBasic]
-      //watcher.expectMsgType[WatchSpentBasic]
-      //watcher.expectMsgType[WatchSpentBasic]
+      watcher.expectMsgType[WatchSpentBasic]
+      watcher.expectMsgType[WatchSpentBasic]
+      watcher.expectMsgType[WatchSpentBasic]
+      watcher.expectMsgType[WatchSpentBasic]
       // then nodes
       router ! ann_a
       router ! ann_b

eclair-core/src/test/scala/fr/acinq/eclair/router/RouteCalculationSpec.scala

@@ -3,9 +3,9 @@ package fr.acinq.eclair.router
 import fr.acinq.bitcoin.Crypto.{PrivateKey, PublicKey}
 import fr.acinq.bitcoin.{BinaryData, Block, Crypto, MilliSatoshi}
 import fr.acinq.eclair.payment.PaymentRequest.ExtraHop
-import fr.acinq.eclair.{Globals, randomKey, toShortId}
-import fr.acinq.eclair.wire.{ChannelAnnouncement, ChannelUpdate, PerHopPayload}
 import fr.acinq.eclair.payment._
+import fr.acinq.eclair.wire.{ChannelAnnouncement, ChannelUpdate, PerHopPayload}
+import fr.acinq.eclair.{Globals, randomKey, toShortId}
 import org.junit.runner.RunWith
 import org.scalatest.FunSuite
 import org.scalatest.junit.JUnitRunner
@@ -49,7 +49,7 @@ class RouteCalculationSpec extends FunSuite {
       ChannelDesc(5L, d, e)
     )
 
-    val routes = for(i <- 0 until 10) yield Router.findRouteDijkstra(a, e, channels)
+    val routes = for (i <- 0 until 10) yield Router.findRouteDijkstra(a, e, channels)
     assert(routes.exists(_ != routes.head))
 
   }
@@ -201,7 +201,7 @@ class RouteCalculationSpec extends FunSuite {
     val extraRoute = PaymentHop.buildExtra(reverseRoute, amount.amount)
 
     assert(extraRoute === List(ExtraHop(PublicKey("02f0b230e53723ccc331db140edc518be1ee5ab29a508104a4be2f5be922c928e8"), 24412456671576064L, 547005, 144),
-      ExtraHop(PublicKey("032b4af42b5e8089a7a06005ead9ac4667527390ee39c998b7b0307f0d81d7f4ac") ,23366821113626624L, 547000, 144)))
+      ExtraHop(PublicKey("032b4af42b5e8089a7a06005ead9ac4667527390ee39c998b7b0307f0d81d7f4ac"), 23366821113626624L, 547000, 144)))
 
     // Sender side
 
@@ -223,11 +223,16 @@ class RouteCalculationSpec extends FunSuite {
   test("stale channels pruning") {
     // set current block height
     Globals.blockCount.set(500000)
+
     // we only care about timestamps
     def channelAnnouncement(shortChannelId: Long) = ChannelAnnouncement("", "", "", "", "", "", shortChannelId, randomKey.publicKey, randomKey.publicKey, randomKey.publicKey, randomKey.publicKey)
+
     def channelUpdate(shortChannelId: Long, timestamp: Long) = ChannelUpdate("", "", shortChannelId, timestamp, "", 0, 0, 0, 0)
+
     def desc(shortChannelId: Long) = ChannelDesc(shortChannelId, randomKey.publicKey, randomKey.publicKey)
+
     def daysAgoInBlocks(daysAgo: Int): Int = Globals.blockCount.get().toInt - 144 * daysAgo
+
     def daysAgoInSeconds(daysAgo: Int): Long = Platform.currentTime / 1000 - daysAgo * 24 * 3600
 
     // a is an old channel with an old channel update => PRUNED

eclair-core/src/test/scala/fr/acinq/eclair/router/RouterSpec.scala

@@ -13,7 +13,6 @@ import fr.acinq.eclair.{randomKey, toShortId}
 import org.junit.runner.RunWith
 import org.scalatest.junit.JUnitRunner
 
-import scala.concurrent.Future
 import scala.concurrent.duration._
 
 /**
@@ -50,7 +49,7 @@ class RouterSpec extends BaseRouterSpec {
         IndividualResult(chan_ax, None, false) ::
         IndividualResult(chan_ay, Some(Transaction(version = 0, txIn = Nil, txOut = TxOut(Satoshi(1000000), write(pay2wsh(Scripts.multiSig2of2(funding_a, randomKey.publicKey)))) :: Nil, lockTime = 0)), true) ::
         IndividualResult(chan_az, Some(Transaction(version = 0, txIn = Nil, txOut = TxOut(Satoshi(1000000), write(pay2wsh(Scripts.multiSig2of2(funding_a, priv_funding_z.publicKey)))) :: Nil, lockTime = 0)), false) :: Nil))
-    //watcher.expectMsgType[WatchSpentBasic]
+    watcher.expectMsgType[WatchSpentBasic]
     watcher.expectNoMsg(1 second)
 
     eventListener.expectMsg(ChannelDiscovered(chan_ac, Satoshi(1000000)))
@@ -163,7 +162,7 @@ class RouterSpec extends BaseRouterSpec {
     sender.expectMsgType[RouteResponse]
   }
 
-  ignore("export graph in dot format") { case (router, _) =>
+  test("export graph in dot format") { case (router, _) =>
     val sender = TestProbe()
     sender.send(router, 'dot)
     val dot = sender.expectMsgType[String]
@@ -181,7 +180,9 @@ class RouterSpec extends BaseRouterSpec {
     val sender = TestProbe()
     val receiver = TestProbe()
     sender.send(router, SendRoutingState(receiver.ref))
-    receiver.expectNoMsg(1 second)
+    for (_ <- 0 until 4) receiver.expectMsgType[ChannelAnnouncement]
+    for (_ <- 0 until 6) receiver.expectMsgType[NodeAnnouncement]
+    for (_ <- 0 until 8) receiver.expectMsgType[ChannelUpdate]
   }
 
 }

eclair-core/src/test/scala/fr/acinq/eclair/transactions/TestVectorsSpec.scala

@@ -1,14 +1,12 @@
 package fr.acinq.eclair.transactions
 
-import fr.acinq.bitcoin._
 import fr.acinq.bitcoin.Crypto.{Point, PrivateKey, PublicKey, Scalar}
+import fr.acinq.bitcoin._
 import fr.acinq.eclair.channel.Helpers.Funding
 import fr.acinq.eclair.crypto.Generators
 import fr.acinq.eclair.transactions.Transactions.{HtlcSuccessTx, HtlcTimeoutTx, TransactionWithInputInfo}
 import fr.acinq.eclair.wire.UpdateAddHtlc
-import org.junit.runner.RunWith
 import org.scalatest.FunSuite
-import org.scalatest.junit.JUnitRunner
 
 import scala.io.Source
 

eclair-core/src/test/scala/fr/acinq/eclair/wire/LightningMessageCodecsSpec.scala

@@ -5,8 +5,8 @@ import java.net.{InetAddress, InetSocketAddress}
 import fr.acinq.bitcoin.Crypto.{PrivateKey, Scalar}
 import fr.acinq.bitcoin.{BinaryData, Block, Crypto}
 import fr.acinq.eclair.crypto.Sphinx
+import fr.acinq.eclair.wire.LightningMessageCodecs._
 import fr.acinq.eclair.{UInt64, randomBytes, randomKey}
-import fr.acinq.eclair.wire.LightningMessageCodecs.{lightningMessageCodec, rgb, socketaddress, uint64ex, zeropaddedstring}
 import org.junit.runner.RunWith
 import org.scalatest.FunSuite
 import org.scalatest.junit.JUnitRunner

eclair-node-gui/pom.xml

@@ -0,0 +1,121 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>fr.acinq.eclair</groupId>
+        <artifactId>eclair_2.11</artifactId>
+        <version>0.2-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>eclair-node-gui_2.11</artifactId>
+    <packaging>jar</packaging>
+
+    <name>eclair-node-gui</name>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>pl.project13.maven</groupId>
+                <artifactId>git-commit-id-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>revision</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <configuration>
+                    <archive>
+                        <manifest>
+                            <addClasspath>true</addClasspath>
+                            <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
+                        </manifest>
+                        <manifestEntries>
+                            <!-- we hide the git commit in the Specification-Version standard field-->
+                            <Specification-Version>${git.commit.id}</Specification-Version>
+                            <Url>${project.parent.url}</Url>
+                        </manifestEntries>
+                    </archive>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>com.github.chrisdchristo</groupId>
+                <artifactId>capsule-maven-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>build</goal>
+                        </goals>
+                        <configuration>
+                            <appClass>fr.acinq.eclair.JavafxBoot</appClass>
+                            <type>fat</type>
+                            <fileName>${project.name}-${project.version}</fileName>
+                            <fileDesc>-${git.commit.id.abbrev}</fileDesc>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+    <profiles>
+        <profile>
+            <id>installer</id>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>com.zenjava</groupId>
+                        <artifactId>javafx-maven-plugin</artifactId>
+                        <version>8.8.3</version>
+                        <executions>
+                            <execution>
+                                <!-- required before build-native -->
+                                <id>create-jfxjar</id>
+                                <phase>package</phase>
+                                <goals>
+                                    <goal>build-jar</goal>
+                                </goals>
+                            </execution>
+                            <execution>
+                                <phase>package</phase>
+                                <goals>
+                                    <goal>build-native</goal>
+                                </goals>
+                            </execution>
+                        </executions>
+                        <configuration>
+                            <vendor>ACINQ</vendor>
+                            <needShortcut>true</needShortcut>
+                            <appName>Eclair</appName>
+                            <nativeReleaseVersion>${project.version}</nativeReleaseVersion>
+                            <skipNativeVersionNumberSanitizing>true</skipNativeVersionNumberSanitizing>
+                            <nativeOutputDir>${project.build.directory}/jfx/installer</nativeOutputDir>
+                            <mainClass>fr.acinq.eclair.JavafxBoot</mainClass>
+                            <verbose>false</verbose>
+                            <bundler>EXE</bundler>
+                            <updateExistingJar>true</updateExistingJar>
+                        </configuration>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+    </profiles>
+
+    <dependencies>
+        <dependency>
+            <groupId>fr.acinq.eclair</groupId>
+            <artifactId>eclair-node_${scala.version.short}</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.zxing</groupId>
+            <artifactId>core</artifactId>
+            <version>3.3.0</version>
+        </dependency>
+    </dependencies>
+</project>

eclair-node-gui/src/main/resources/gui/commons/globals.css

@@ -0,0 +1,132 @@
+/* ---------- Root ---------- */
+
+.root {
+    -fx-font-size: 14px;
+    -fx-text-fill: rgb(80, 82, 84);
+}
+
+/* ---------- Text Utilities (color, weight) ---------- */
+
+.text-mono {
+    -fx-font-family: monospace;
+}
+
+.text-strong {
+	-fx-font-weight: bold;
+}
+
+.text-sm {
+    -fx-font-size: 12px;
+}
+
+.text-error {
+	-fx-text-fill: rgb(216,31,74);
+	-fx-font-size: 11px;
+}
+
+.text-error.text-error-downward {
+	-fx-translate-y: 24px;
+}
+
+.text-error.text-error-upward {
+	-fx-translate-y: -24px;
+}
+
+.label-description {
+    -fx-text-fill: rgb(146,149,151);
+    -fx-font-size: 11px;
+}
+
+.link {
+    -fx-text-fill: rgb(25,157,221);
+    -fx-fill: rgb(25,157,221);
+    -fx-underline: true;
+    -fx-cursor: hand;
+}
+.link:hover {
+    -fx-text-fill: rgb(93,199,254);
+    -fx-fill: rgb(93,199,254);
+}
+
+.text-muted,
+.label.text-muted {
+	-fx-text-fill: rgb(146,149,151);
+}
+
+.align-right {
+    /* useful for table columns */
+    -fx-alignment: CENTER_RIGHT;
+}
+
+/* ---------- Context Menu ---------- */
+
+.context-menu {
+    -fx-padding: 4px;
+    -fx-font-weight: normal;
+    -fx-font-size: 12px;
+}
+.context-menu .menu-item:focused {
+   -fx-background-color: rgb(63,179,234);
+}
+.context-menu .menu-item:focused .label {
+   -fx-text-fill: white;
+}
+.context-menu .separator {
+    -fx-padding: 2px 0;
+}
+
+.menu-bar .context-menu {
+    /* font size in menu context popup is standard */
+    -fx-font-size: 14px;
+}
+
+/* ---------- Grid Structure ---------- */
+
+.grid {
+	-fx-vgap: 1em;
+	-fx-hgap: 1em;
+	-fx-padding: 1em;
+}
+
+/* ------------- Not Editable TextFields ------------- */
+/* Java FX text can only be selected if in a TextField or TextArea */
+/* Make it look like a standard label with the editable = false prop and a special styling */
+.text-area.noteditable,
+.text-field.noteditable,
+.text-field.noteditable:hover,
+.text-field.noteditable:focused,
+.noteditable {
+    -fx-background-color: transparent;
+    -fx-border-width: 0;
+    -fx-border-color: transparent;
+    -fx-padding: 0;
+}
+.text-area.noteditable .scroll-pane {
+    -fx-background-color: transparent;
+}
+.text-area.noteditable .scroll-pane .viewport{
+    -fx-background-color: transparent;
+}
+.text-area.noteditable .scroll-pane .content{
+    -fx-background-color: transparent;
+    -fx-padding: 0;
+}
+
+/* ---------- Progress Bar ---------- */
+
+.bar {
+	-fx-background-color: rgb(63,179,234);
+	-fx-background-insets: 0;
+	-fx-background-radius: 0;
+}
+
+.track {
+	-fx-background-color: rgb(206,230,255);
+	-fx-background-insets: 0;
+	-fx-background-radius: 0;
+}
+
+/* ---------- Forms ----------- */
+.options-separator {
+    -fx-translate-y: -7px;
+}