wip

Author: Łukasz Gąsior

src/main/resources/application.conf

@@ -200,7 +200,8 @@ mantis {
         peer-manager-timeout = 5.seconds
       }
 
-      active-timeout = 5.seconds
+      // TODO: rename to miner-active-timeot
+      miner-active-timeout = 5.seconds
     }
   }
 

src/main/scala/io/iohk/ethereum/Mantis.scala

@@ -1,10 +1,14 @@
 package io.iohk.ethereum
 
-import io.iohk.ethereum.nodebuilder.StdNode
+import io.iohk.ethereum.nodebuilder.{StdNode, TestNode}
+import io.iohk.ethereum.utils.Config
 
 object Mantis {
   def main(args: Array[String]): Unit = {
-    val node = new StdNode
+    val node =
+      if (Config.testmode) new TestNode
+      else new StdNode
+
     node.start()
   }
 }

src/main/scala/io/iohk/ethereum/consensus/ConsensusBuilder.scala

@@ -5,6 +5,10 @@ import io.iohk.ethereum.consensus.ethash.EthashConsensus
 import io.iohk.ethereum.nodebuilder._
 import io.iohk.ethereum.utils.{Config, Logger}
 
+trait ConsensusBuilder {
+  def consensus: Consensus
+}
+
 /**
  * A consensus builder is responsible to instantiate the consensus protocol.
  * This is done dynamically when Mantis boots, based on its configuration.
@@ -13,7 +17,7 @@ import io.iohk.ethereum.utils.{Config, Logger}
  *      [[io.iohk.ethereum.consensus.ethash.EthashConsensus EthashConsensus]],
  *      [[io.iohk.ethereum.consensus.atomixraft.AtomixRaftConsensus AtomixRaftConsensus]]
  */
-trait ConsensusBuilder {
+trait StdConsensusBuilder extends ConsensusBuilder {
   self: VmBuilder with BlockchainBuilder with BlockchainConfigBuilder with ConsensusConfigBuilder with Logger ⇒
 
   private lazy val mantisConfig = Config.config
@@ -44,7 +48,8 @@ trait ConsensusBuilder {
         case Protocol.Ethash ⇒ buildEthashConsensus()
         case Protocol.AtomixRaft ⇒ buildAtomixRaftConsensus()
       }
-    log.info(s"Using '${protocol.name}' consensus [${consensus.getClass.getName}]")
+    // TODO: why the fuck does it fail with npe?
+//    log.info(s"Using '${protocol.name}' consensus [${consensus.getClass.getName}]")
 
     consensus
   }

src/main/scala/io/iohk/ethereum/consensus/TestConsensusBuilder.scala

@@ -7,13 +7,13 @@ import io.iohk.ethereum.utils.Logger
  * A [[io.iohk.ethereum.consensus.ConsensusBuilder ConsensusBuilder]] that builds a
  * [[io.iohk.ethereum.consensus.TestConsensus TestConsensus]]
  */
-trait TestConsensusBuilder { self: ConsensusBuilder ⇒
+trait TestConsensusBuilder { self: StdConsensusBuilder ⇒
   protected def buildTestConsensus(): TestConsensus =
     buildConsensus().asInstanceOf[TestConsensus] // we are in tests, so if we get an exception, so be it
 }
 
 /** A standard [[TestConsensusBuilder]] cake. */
-trait StdTestConsensusBuilder extends ConsensusBuilder
+trait StdTestConsensusBuilder extends StdConsensusBuilder
   with TestConsensusBuilder
   with VmBuilder
   with VmConfigBuilder

src/main/scala/io/iohk/ethereum/consensus/ethash/EthashConsensus.scala

@@ -9,13 +9,14 @@ import io.iohk.ethereum.consensus.blocks.TestBlockGenerator
 import io.iohk.ethereum.consensus.ethash.EthashMiner.MinerMsg
 import io.iohk.ethereum.consensus.ethash.blocks.{EthashBlockGenerator, EthashBlockGeneratorImpl}
 import io.iohk.ethereum.consensus.ethash.validators.{EthashValidators, StdEthashValidators}
-import io.iohk.ethereum.consensus.validators.Validators
+import io.iohk.ethereum.consensus.validators._
 import io.iohk.ethereum.domain.BlockchainImpl
 import io.iohk.ethereum.ledger.BlockPreparator
 import io.iohk.ethereum.ledger.Ledger.VMImpl
 import io.iohk.ethereum.nodebuilder.Node
 import io.iohk.ethereum.utils.{BlockchainConfig, Logger}
 
+
 /**
  * Implements standard Ethereum consensus (ethash PoW).
  */

src/main/scala/io/iohk/ethereum/jsonrpc/JsonRpcController.scala

@@ -27,7 +27,6 @@ object JsonRpcController {
     def encodeJson(t: T): JValue
   }
 
-
   trait JsonRpcConfig {
     def apis: Seq[String]
     def accountTransactionsMaxBlocks: Int
@@ -38,6 +37,7 @@ object JsonRpcController {
 
   object JsonRpcConfig {
     def apply(mantisConfig: TypesafeConfig): JsonRpcConfig = {
+      import scala.concurrent.duration._
       val rpcConfig = mantisConfig.getConfig("network.rpc")
 
       new JsonRpcConfig {
@@ -49,6 +49,7 @@ object JsonRpcController {
         }
 
         override def accountTransactionsMaxBlocks: Int = rpcConfig.getInt("account-transactions-max-blocks")
+        override def minerActiveTimeout: FiniteDuration = rpcConfig.getDuration("miner-active-timeout").toMillis.millis
 
         override val httpServerConfig: JsonRpcHttpServerConfig = JsonRpcHttpServerConfig(mantisConfig)
         override val ipcServerConfig: JsonRpcIpcServerConfig = JsonRpcIpcServerConfig(mantisConfig)
@@ -77,7 +78,7 @@ class JsonRpcController(
   netService: NetService,
   ethService: EthService,
   personalService: PersonalService,
-  testService: TestService,
+  testServiceOpt: Option[TestService],
   config: JsonRpcConfig) extends Logger {
 
   import JsonRpcController._
@@ -87,7 +88,7 @@ class JsonRpcController(
   import JsonMethodsImplicits._
   import JsonRpcErrors._
 
-  val apisHandleFns: Map[String, PartialFunction[JsonRpcRequest, Future[JsonRpcResponse]]] = Map(
+  lazy val apisHandleFns: Map[String, PartialFunction[JsonRpcRequest, Future[JsonRpcResponse]]] = Map(
     Apis.Eth -> handleEthRequest,
     Apis.Web3 -> handleWeb3Request,
     Apis.Net -> handleNetRequest,
@@ -208,6 +209,13 @@ class JsonRpcController(
   }
 
   private def handleTestRequest: PartialFunction[JsonRpcRequest, Future[JsonRpcResponse]] = {
+      testServiceOpt match {
+        case Some(testService) => handleTestRequest(testService)
+        case None => PartialFunction.empty
+      }
+  }
+
+  private def handleTestRequest(testService: TestService): PartialFunction[JsonRpcRequest, Future[JsonRpcResponse]] = {
     case req@JsonRpcRequest(_, "test_setChainParams", _, _) =>
       handle[SetChainParamsRequest, SetChainParamsResponse](testService.setChainParams, req)
     case req@JsonRpcRequest(_, "test_mineBlocks", _, _) =>

src/main/scala/io/iohk/ethereum/jsonrpc/TestService.scala

@@ -1,16 +1,12 @@
 package io.iohk.ethereum.jsonrpc
 
 import akka.actor.ActorRef
-import akka.agent.Agent
 import akka.util.{ByteString, Timeout}
 import io.iohk.ethereum.blockchain.data.{AllocAccount, GenesisData, GenesisDataLoader}
-import io.iohk.ethereum.consensus.{Consensus, ConsensusConfig, FullConsensusConfig, Protocol}
-import io.iohk.ethereum.consensus.blocks.{BlockGenerator, BlockTimestampProvider, PendingBlock}
-import io.iohk.ethereum.consensus.validators.Validators
+import io.iohk.ethereum.consensus.ConsensusConfig
+import io.iohk.ethereum.consensus.blocks._
 import io.iohk.ethereum.domain.{Address, Block, BlockchainImpl, UInt256}
-import io.iohk.ethereum.ledger.Ledger.VMImpl
-import io.iohk.ethereum.ledger._
-import io.iohk.ethereum.nodebuilder.Node
+import io.iohk.ethereum.testmode.TestLedgerWrapper
 import io.iohk.ethereum.transactions.PendingTransactionsManager
 import io.iohk.ethereum.transactions.PendingTransactionsManager.PendingTransactionsResponse
 import io.iohk.ethereum.utils.{BlockchainConfig, DaoForkConfig, MonetaryPolicyConfig}
@@ -53,40 +49,36 @@ object TestService {
 }
 
 class TestService(
-    vm: VMImpl,
     blockchain: BlockchainImpl,
     pendingTransactionsManager: ActorRef,
     consensusConfig: ConsensusConfig,
-    initialBlockchainConfig: BlockchainConfig,
-    validators: Validators,
-                 consensus: Consensus) {
+    testLedgerWrapper: TestLedgerWrapper) {
 
   import TestService._
   import akka.pattern.ask
 
-  private var blockchainConfig: BlockchainConfig = initialBlockchainConfig
   private var etherbase: Address = consensusConfig.coinbase
   private var testBlockTimestamp: Long = System.currentTimeMillis()
 
   def setChainParams(request: SetChainParamsRequest): ServiceResponse[SetChainParamsResponse] = {
     val newBlockchainConfig = new BlockchainConfig {
-      override val frontierBlockNumber: BigInt = initialBlockchainConfig.frontierBlockNumber
+      override val frontierBlockNumber: BigInt = testLedgerWrapper.blockchainConfig.frontierBlockNumber
       override val homesteadBlockNumber: BigInt = request.chainParams.blockchainParams.homesteadForkBlock
-      override val eip106BlockNumber: BigInt = initialBlockchainConfig.eip106BlockNumber
+      override val eip106BlockNumber: BigInt = testLedgerWrapper.blockchainConfig.eip106BlockNumber
       override val eip150BlockNumber: BigInt = request.chainParams.blockchainParams.EIP150ForkBlock
-      override val eip155BlockNumber: BigInt = initialBlockchainConfig.eip155BlockNumber
-      override val eip160BlockNumber: BigInt = initialBlockchainConfig.eip160BlockNumber
-      override val eip161BlockNumber: BigInt = initialBlockchainConfig.eip161BlockNumber
-      override val maxCodeSize: Option[BigInt] = initialBlockchainConfig.maxCodeSize
-      override val difficultyBombPauseBlockNumber: BigInt = initialBlockchainConfig.difficultyBombPauseBlockNumber
-      override val difficultyBombContinueBlockNumber: BigInt = initialBlockchainConfig.difficultyBombContinueBlockNumber
-      override val customGenesisFileOpt: Option[String] = initialBlockchainConfig.customGenesisFileOpt
-      override val daoForkConfig: Option[DaoForkConfig] = initialBlockchainConfig.daoForkConfig
+      override val eip155BlockNumber: BigInt = testLedgerWrapper.blockchainConfig.eip155BlockNumber
+      override val eip160BlockNumber: BigInt = testLedgerWrapper.blockchainConfig.eip160BlockNumber
+      override val eip161BlockNumber: BigInt = testLedgerWrapper.blockchainConfig.eip161BlockNumber
+      override val maxCodeSize: Option[BigInt] = testLedgerWrapper.blockchainConfig.maxCodeSize
+      override val difficultyBombPauseBlockNumber: BigInt = testLedgerWrapper.blockchainConfig.difficultyBombPauseBlockNumber
+      override val difficultyBombContinueBlockNumber: BigInt = testLedgerWrapper.blockchainConfig.difficultyBombContinueBlockNumber
+      override val customGenesisFileOpt: Option[String] = testLedgerWrapper.blockchainConfig.customGenesisFileOpt
+      override val daoForkConfig: Option[DaoForkConfig] = testLedgerWrapper.blockchainConfig.daoForkConfig
       override val accountStartNonce: UInt256 = UInt256(request.chainParams.blockchainParams.accountStartNonce)
-      override val chainId: Byte = initialBlockchainConfig.chainId
-      override val monetaryPolicyConfig: MonetaryPolicyConfig = initialBlockchainConfig.monetaryPolicyConfig
-      override val gasTieBreaker: Boolean = initialBlockchainConfig.gasTieBreaker
-      override val ethCompatibleStorage: Boolean = initialBlockchainConfig.ethCompatibleStorage
+      override val chainId: Byte = testLedgerWrapper.blockchainConfig.chainId
+      override val monetaryPolicyConfig: MonetaryPolicyConfig = testLedgerWrapper.blockchainConfig.monetaryPolicyConfig
+      override val gasTieBreaker: Boolean = testLedgerWrapper.blockchainConfig.gasTieBreaker
+      override val ethCompatibleStorage: Boolean = testLedgerWrapper.blockchainConfig.ethCompatibleStorage
     }
 
     val genesisData = GenesisData(
@@ -106,16 +98,16 @@ class TestService(
     val genesisDataLoader = new GenesisDataLoader(blockchain, newBlockchainConfig)
     genesisDataLoader.loadGenesisData(genesisData)
 
-    // update ledger with new config
-    setupLedger(newBlockchainConfig)
+    // update test ledger with new config
+    testLedgerWrapper.blockchainConfig = newBlockchainConfig
 
     Future.successful(Right(SetChainParamsResponse()))
   }
 
   def mineBlocks(request: MineBlocksRequest): ServiceResponse[MineBlocksResponse] = {
     def mineBlock(): Future[Unit] = {
       getBlockForMining(blockchain.getBestBlock()).map { blockForMining =>
-        ledgerHolder().importBlock(blockForMining.block) // TODO: check result?
+        testLedgerWrapper.ledger.importBlock(blockForMining.block) // TODO: check result?
         pendingTransactionsManager ! PendingTransactionsManager.ClearPendingTransactions
         testBlockTimestamp += 1
       }
@@ -149,53 +141,29 @@ class TestService(
   }
 
   private def getBlockForMining(parentBlock: Block): Future[PendingBlock] = {
-    val blockGenerator = new BlockGenerator(
-      blockchain, blockchainConfig, consensusConfig.headerExtraData, 5, ledgerHolder, validators, new BlockTimestampProvider {
+    val blockGenerator = new NoOmmersBlockGenerator(
+      blockchain,
+      testLedgerWrapper.blockchainConfig,
+      consensusConfig,
+      testLedgerWrapper.ledger.consensus.blockPreparator,
+      new BlockTimestampProvider {
         override def getEpochSecond: Long = testBlockTimestamp
-      }
-    )
+      }) {
+      override def withBlockTimestampProvider(blockTimestampProvider: BlockTimestampProvider): TestBlockGenerator = this
+    }
 
-    implicit val timeout = Timeout(5.seconds)
-    (pendingTransactionsManager ? PendingTransactionsManager.GetPendingTransactions)
-      .mapTo[PendingTransactionsResponse]
-      .flatMap { pendingTxs =>
-        blockGenerator.generateBlockForMining(parentBlock, pendingTxs.pendingTransactions.map(_.stx), Nil, etherbase) match {
-          case Right(pb) => Future.successful(pb)
-          case Left(err) => Future.failed(new RuntimeException(s"Error while generating block for mining: $err"))
-        }
+    getTransactionsFromPool.flatMap { pendingTxs =>
+      blockGenerator.generateBlock(parentBlock, pendingTxs.pendingTransactions.map(_.stx), etherbase, Nil) match {
+        case Right(pb) => Future.successful(pb)
+        case Left(err) => Future.failed(new RuntimeException(s"Error while generating block for mining: $err"))
       }
+    }
   }
 
-  private def setupLedger(newBlockchainConfig: BlockchainConfig): Unit = {
-    blockchainConfig = newBlockchainConfig
-    ledgerHolder.send(new LedgerImpl(blockchain, new BlockQueue(blockchain, 5, 5), blockchainConfig, prepareConsensus()))
-  }
+  private def getTransactionsFromPool: Future[PendingTransactionsResponse] = {
+    implicit val timeout = Timeout(5.seconds)
 
-  private def testCnsensus(): Consensus = {
-    new Consensus {
-      /**
-        * The type of configuration [[io.iohk.ethereum.consensus.FullConsensusConfig#specific specific]]
-        * to this consensus protocol implementation.
-        */
-      override type Config = this.type
-
-      override def protocol: Protocol = ???
-
-      override def config: FullConsensusConfig[this.type] = ???
-
-      /**
-        * This is the VM used while preparing and generating blocks.
-        */
-      override def vm: VMImpl = ???
-
-      /**
-        * Provides the set of validators specific to this consensus protocol.
-        */
-      override def validators: Validators = ???
-      override def blockPreparator: BlockPreparator = consensus.blockPreparator
-      override def blockGenerator: BlockGenerator = consensus.blockGenerator
-      override def startProtocol(node: Node): Unit = consensus.startProtocol(node)
-      override def stopProtocol(): Unit = consensus.stopProtocol()
-    }
+    (pendingTransactionsManager ? PendingTransactionsManager.GetPendingTransactions).mapTo[PendingTransactionsResponse]
+      .recover { case _ => PendingTransactionsResponse(Nil) }
   }
 }