Merge pull request #439 from input-output-hk/feature/faucet

Łukasz Gąsior · web-flow · commit f3c7f087d78c · 2018-05-11T14:38:23.000+02:00
Add faucet
diff --git a/build.sbt b/build.sbt
@@ -46,6 +46,7 @@ val dep = {
     "commons-io" % "commons-io" % "2.5",
     "com.typesafe.akka" %% "akka-stream" % akkaVersion,
     "org.scala-sbt.ipcsocket" % "ipcsocket" % "1.0.0",
+    "com.twitter" %% "util-collection" % "18.4.0",
 
     // Pluggable Consensus: AtomixRaft
     "io.atomix" % "atomix" % "2.1.0-beta1",
diff --git a/src/main/resources/application.conf b/src/main/resources/application.conf
@@ -547,7 +547,6 @@ mantis {
       port = 8888
     }
   }
-
 }
 
 akka {
diff --git a/src/main/scala/io/iohk/ethereum/App.scala b/src/main/scala/io/iohk/ethereum/App.scala
@@ -1,6 +1,7 @@
 package io.iohk.ethereum
 
 import io.iohk.ethereum.extvm.VmServerApp
+import io.iohk.ethereum.faucet.Faucet
 import io.iohk.ethereum.mallet.main.Mallet
 import io.iohk.ethereum.utils.{Config, Logger}
 
@@ -14,6 +15,7 @@ object App extends Logger {
     val downloadBootstrap = "bootstrap"
     val vmServer = "vm-server"
     val mallet = "mallet"
+    val faucet = "faucet"
 
       args.headOption match {
         case None => Mantis.main(args)
@@ -22,9 +24,10 @@ object App extends Logger {
         case Some(`downloadBootstrap`) => BootstrapDownload.main(args.tail :+ Config.Db.LevelDb.path)
         case Some(`vmServer`) => VmServerApp.main(args.tail)
         case Some(`mallet`) => Mallet.main(args.tail)
+        case Some(`faucet`) => Faucet.main(args.tail)
         case Some(unknown) =>
           log.error(s"Unrecognised launcher option, " +
-            s"first parameter must be $launchKeytool, $downloadBootstrap, $launchMantis or $vmServer")
+            s"first parameter must be $launchKeytool, $downloadBootstrap, $launchMantis, $mallet, $faucet or $vmServer")
       }
 
 
diff --git a/src/main/scala/io/iohk/ethereum/faucet/Faucet.scala b/src/main/scala/io/iohk/ethereum/faucet/Faucet.scala
@@ -0,0 +1,36 @@
+package io.iohk.ethereum.faucet
+
+import java.security.SecureRandom
+
+import akka.actor.ActorSystem
+import akka.http.scaladsl.Http
+import akka.stream.ActorMaterializer
+import com.typesafe.config.ConfigFactory
+import io.iohk.ethereum.keystore.KeyStoreImpl
+import io.iohk.ethereum.mallet.service.RpcClient
+import io.iohk.ethereum.utils.Logger
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.util.{Failure, Success}
+
+object Faucet extends Logger {
+
+  def main(args: Array[String]): Unit = {
+    val config = FaucetConfig(ConfigFactory.load())
+
+    implicit val system = ActorSystem("Faucet-system")
+    implicit val materializer = ActorMaterializer()
+
+    val keyStore = new KeyStoreImpl(config.keyStoreDir, new SecureRandom())
+    val rpcClient = new RpcClient(config.rpcAddress)
+    val api = new FaucetApi(rpcClient, keyStore, config)
+
+    val bindingResultF = Http().bindAndHandle(api.route, config.listenInterface, config.listenPort)
+
+    bindingResultF onComplete {
+      case Success(serverBinding) => log.info(s"Faucet HTTP server listening on ${serverBinding.localAddress}")
+      case Failure(ex) => log.error("Cannot start faucet HTTP server", ex)
+    }
+  }
+
+}
diff --git a/src/main/scala/io/iohk/ethereum/faucet/FaucetApi.scala b/src/main/scala/io/iohk/ethereum/faucet/FaucetApi.scala
@@ -0,0 +1,82 @@
+package io.iohk.ethereum.faucet
+
+import java.time.Clock
+
+import akka.http.scaladsl.model.{RemoteAddress, StatusCodes}
+import akka.http.scaladsl.server.Route
+import akka.http.scaladsl.server.Directives._
+import akka.util.ByteString
+import ch.megard.akka.http.cors.scaladsl.CorsDirectives.cors
+import ch.megard.akka.http.cors.scaladsl.settings.CorsSettings
+import com.twitter.util.LruMap
+import io.iohk.ethereum.domain.{Address, Transaction}
+import io.iohk.ethereum.keystore.KeyStore
+import io.iohk.ethereum.mallet.service.RpcClient
+import io.iohk.ethereum.utils.Logger
+import io.iohk.ethereum.rlp
+import io.iohk.ethereum.network.p2p.messages.CommonMessages.SignedTransactions.SignedTransactionEnc
+import org.spongycastle.util.encoders.Hex
+
+class FaucetApi(
+    rpcClient: RpcClient,
+    keyStore: KeyStore,
+    config: FaucetConfig,
+    clock: Clock = Clock.systemUTC())
+  extends Logger {
+
+  private val latestRequestTimestamps = new LruMap[RemoteAddress, Long](config.latestTimestampCacheSize)
+
+  private val wallet = keyStore.unlockAccount(config.walletAddress, config.walletPassword) match {
+    case Right(w) => w
+    case Left(err) => throw new RuntimeException(s"Cannot unlock wallet for use in faucet (${config.walletAddress}), because of $err")
+  }
+
+  private val corsSettings = CorsSettings.defaultSettings.copy(
+    allowGenericHttpRequests = true,
+    allowedOrigins = config.corsAllowedOrigins)
+
+  val route: Route = cors(corsSettings) {
+    (path("faucet") & pathEndOrSingleSlash & post & parameter('address)) { targetAddress =>
+      extractClientIP { clientAddr =>
+        handleRequest(clientAddr, targetAddress)
+      }
+    }
+  }
+
+  private def handleRequest(clientAddr: RemoteAddress, targetAddress: String) = {
+    val timeMillis = clock.instant().toEpochMilli
+    val latestRequestTimestamp = latestRequestTimestamps.getOrElse(clientAddr, 0L)
+    if (latestRequestTimestamp + config.minRequestInterval.toMillis < timeMillis) {
+      latestRequestTimestamps.put(clientAddr, timeMillis)
+
+      val res = for {
+        nonce <- rpcClient.getNonce(wallet.address)
+        txId <- rpcClient.sendTransaction(prepareTx(Address(targetAddress), nonce))
+      } yield txId
+
+      res match {
+        case Right(txId) =>
+          log.info(s"Sending ${config.txValue} ETH to $targetAddress in tx: $txId. Requested by $clientAddr")
+          complete(StatusCodes.OK, s"0x${Hex.toHexString(txId.toArray[Byte])}")
+
+        case Left(err) =>
+          log.error(s"An error occurred while using faucet: $err")
+          complete(StatusCodes.InternalServerError)
+      }
+    } else complete(StatusCodes.TooManyRequests)
+  }
+
+  private def prepareTx(targetAddress: Address, nonce: BigInt): ByteString = {
+    val transaction = Transaction(
+      nonce,
+      config.txGasPrice,
+      config.txGasLimit,
+      Some(targetAddress),
+      config.txValue,
+      ByteString())
+
+    val stx = wallet.signTx(transaction, None)
+    ByteString(rlp.encode(stx.toRLPEncodable))
+  }
+
+}
diff --git a/src/main/scala/io/iohk/ethereum/faucet/FaucetConfig.scala b/src/main/scala/io/iohk/ethereum/faucet/FaucetConfig.scala
@@ -0,0 +1,44 @@
+package io.iohk.ethereum.faucet
+
+import akka.http.scaladsl.model.headers.HttpOriginRange
+import com.typesafe.config.{Config => TypesafeConfig}
+import io.iohk.ethereum.domain.Address
+import io.iohk.ethereum.utils.ConfigUtils
+
+import scala.concurrent.duration.{FiniteDuration, _}
+
+case class FaucetConfig(
+    walletAddress: Address,
+    walletPassword: String,
+    txGasPrice: BigInt,
+    txGasLimit: BigInt,
+    txValue: BigInt,
+    corsAllowedOrigins: HttpOriginRange,
+    rpcAddress: String,
+    keyStoreDir: String,
+    listenInterface: String,
+    listenPort: Int,
+    minRequestInterval: FiniteDuration,
+    latestTimestampCacheSize: Int)
+
+object FaucetConfig {
+  def apply(typesafeConfig: TypesafeConfig): FaucetConfig = {
+    val faucetConfig = typesafeConfig.getConfig("faucet")
+
+    val corsAllowedOrigins = ConfigUtils.parseCorsAllowedOrigins(faucetConfig, "cors-allowed-origins")
+
+    FaucetConfig(
+      walletAddress = Address(faucetConfig.getString("wallet-address")),
+      walletPassword = faucetConfig.getString("wallet-password"),
+      txGasPrice = faucetConfig.getLong("tx-gas-price"),
+      txGasLimit = faucetConfig.getLong("tx-gas-limit"),
+      txValue = faucetConfig.getLong("tx-value"),
+      corsAllowedOrigins = corsAllowedOrigins,
+      rpcAddress = faucetConfig.getString("rpc-address"),
+      keyStoreDir = faucetConfig.getString("keystore-dir"),
+      listenInterface = faucetConfig.getString("listen-interface"),
+      listenPort = faucetConfig.getInt("listen-port"),
+      minRequestInterval = faucetConfig.getDuration("min-request-interval").toMillis.millis,
+      latestTimestampCacheSize = faucetConfig.getInt("latest-timestamp-cache-size"))
+  }
+}
diff --git a/src/main/scala/io/iohk/ethereum/jsonrpc/server/http/JsonRpcHttpServer.scala b/src/main/scala/io/iohk/ethereum/jsonrpc/server/http/JsonRpcHttpServer.scala
@@ -4,15 +4,15 @@ import java.security.SecureRandom
 
 import akka.actor.ActorSystem
 import akka.http.scaladsl.model.StatusCodes
-import akka.http.scaladsl.model.headers.{HttpOrigin, HttpOriginRange}
+import akka.http.scaladsl.model.headers.HttpOriginRange
 import akka.http.scaladsl.server.Directives._
 import akka.http.scaladsl.server.{MalformedRequestContentRejection, RejectionHandler, Route}
 import ch.megard.akka.http.cors.javadsl.CorsRejection
 import ch.megard.akka.http.cors.scaladsl.CorsDirectives._
 import ch.megard.akka.http.cors.scaladsl.settings.CorsSettings
 import de.heikoseeberger.akkahttpjson4s.Json4sSupport
 import io.iohk.ethereum.jsonrpc.{JsonRpcController, JsonRpcErrors, JsonRpcRequest, JsonRpcResponse}
-import io.iohk.ethereum.utils.Logger
+import io.iohk.ethereum.utils.{ConfigUtils, Logger}
 import org.json4s.JsonAST.JInt
 import org.json4s.{DefaultFormats, native}
 
@@ -89,29 +89,18 @@ object JsonRpcHttpServer extends Logger {
   }
 
   object JsonRpcHttpServerConfig {
-    import scala.collection.JavaConverters._
     import com.typesafe.config.{Config => TypesafeConfig}
 
     def apply(mantisConfig: TypesafeConfig): JsonRpcHttpServerConfig = {
       val rpcHttpConfig = mantisConfig.getConfig("network.rpc.http")
 
-      def parseMultipleOrigins(origins: Seq[String]): HttpOriginRange = HttpOriginRange(origins.map(HttpOrigin(_)): _*)
-
-      def parseSingleOrigin(origin: String): HttpOriginRange = origin match {
-        case "*" => HttpOriginRange.*
-        case s => HttpOriginRange.Default(HttpOrigin(s) :: Nil)
-      }
-
       new JsonRpcHttpServerConfig {
         override val mode: String = rpcHttpConfig.getString("mode")
         override val enabled: Boolean = rpcHttpConfig.getBoolean("enabled")
         override val interface: String = rpcHttpConfig.getString("interface")
         override val port: Int = rpcHttpConfig.getInt("port")
 
-        override val corsAllowedOrigins: HttpOriginRange =
-          (Try(parseMultipleOrigins(rpcHttpConfig.getStringList("cors-allowed-origins").asScala)) recoverWith {
-            case _ => Try(parseSingleOrigin(rpcHttpConfig.getString("cors-allowed-origins")))
-          }).get
+        override val corsAllowedOrigins = ConfigUtils.parseCorsAllowedOrigins(rpcHttpConfig, "cors-allowed-origins")
 
         override val certificateKeyStorePath: Option[String] = Try(rpcHttpConfig.getString("certificate-keystore-path")).toOption
         override val certificateKeyStoreType: Option[String] = Try(rpcHttpConfig.getString("certificate-keystore-type")).toOption
diff --git a/src/main/scala/io/iohk/ethereum/utils/ConfigUtils.scala b/src/main/scala/io/iohk/ethereum/utils/ConfigUtils.scala
@@ -0,0 +1,24 @@
+package io.iohk.ethereum.utils
+
+import akka.http.scaladsl.model.headers.{HttpOrigin, HttpOriginRange}
+import com.typesafe.config.{Config => TypesafeConfig}
+
+import scala.collection.JavaConverters._
+import scala.util.Try
+
+object ConfigUtils {
+
+  def parseCorsAllowedOrigins(config: TypesafeConfig, key: String): HttpOriginRange = {
+    (Try(parseMultipleOrigins(config.getStringList(key).asScala)) recoverWith {
+      case _ => Try(parseSingleOrigin(config.getString(key)))
+    }).get
+  }
+
+  def parseMultipleOrigins(origins: Seq[String]): HttpOriginRange = HttpOriginRange(origins.map(HttpOrigin(_)): _*)
+
+  def parseSingleOrigin(origin: String): HttpOriginRange = origin match {
+    case "*" => HttpOriginRange.*
+    case s => HttpOriginRange.Default(HttpOrigin(s) :: Nil)
+  }
+
+}
diff --git a/src/test/scala/io/iohk/ethereum/faucet/FaucetApiSpec.scala b/src/test/scala/io/iohk/ethereum/faucet/FaucetApiSpec.scala
diff --git a/src/universal/bin/faucet-server b/src/universal/bin/faucet-server
diff --git a/src/universal/conf/faucet.conf b/src/universal/conf/faucet.conf
diff --git a/verify.sbt b/verify.sbt

Original file line number	Diff line number	Diff line change
`@@ -547,7 +547,6 @@ mantis {`
`547`	`547`	`port = 8888`
`548`	`548`	`}`
`549`	`549`	`}`
`550`		`-`
`551`	`550`	`}`
`552`	`551`
`553`	`552`	`akka {`