ETS integration RPC endpoints

src/main/resources/conf/base.conf

@@ -332,7 +332,7 @@ mantis {
     testnet-internal-nomad {include required("chains/testnet-internal-nomad-chain.conf")}
 
     testnet-internal-gac {include required("chains/testnet-internal-gac-chain.conf")}
-	
+
     pottery	{include required("chains/pottery-chain.conf")}
   }
 

src/main/resources/conf/testmode.conf

@@ -14,10 +14,41 @@ mantis {
 
   blockchains {
     network = "test"
+
+    test {
+        chain-id = 1
+
+        frontier-block-number = 0
+
+        homestead-block-number = 0
+
+        eip106-block-number = 0
+
+        eip150-block-number = 0
+
+        eip155-block-number = 0
+
+        eip160-block-number = 0
+
+        eip161-block-number = 0
+
+        byzantium-block-number = 0
+
+        constantinople-block-number = 0
+
+        istanbul-block-number = 0
+
+        atlantis-block-number = 0
+
+        agharta-block-number = 0
+
+        phoenix-block-number = 0
+
+        petersburg-block-number = 0
+    }
   }
 
   network.rpc {
     apis = "eth,web3,net,personal,mantis,test,iele,debug,qa,checkpointing"
   }
-
 }

src/main/scala/io/iohk/ethereum/blockchain/data/GenesisDataLoader.scala

@@ -1,15 +1,19 @@
 package io.iohk.ethereum.blockchain.data
 
 import java.io.FileNotFoundException
-
 import akka.util.ByteString
-import io.iohk.ethereum.blockchain.data.GenesisDataLoader.JsonSerializers.ByteStringJsonSerializer
+import io.iohk.ethereum.blockchain.data.GenesisDataLoader.JsonSerializers.{
+  ByteStringJsonSerializer,
+  UInt256JsonSerializer
+}
+import io.iohk.ethereum.db.storage.MptStorage
 import io.iohk.ethereum.db.storage.StateStorage.GenesisDataLoad
 import io.iohk.ethereum.rlp.RLPList
 import io.iohk.ethereum.utils.BlockchainConfig
 import io.iohk.ethereum.utils.Logger
 import io.iohk.ethereum.{crypto, rlp}
 import io.iohk.ethereum.domain._
+import io.iohk.ethereum.jsonrpc.JsonMethodsImplicits
 import io.iohk.ethereum.mpt.MerklePatriciaTrie
 import io.iohk.ethereum.rlp.RLPImplicits._
 import org.json4s.{CustomSerializer, DefaultFormats, Formats, JString, JValue}
@@ -75,7 +79,7 @@ class GenesisDataLoader(blockchain: Blockchain, blockchainConfig: BlockchainConf
 
   private def loadGenesisData(genesisJson: String): Try[Unit] = {
     import org.json4s.native.JsonMethods.parse
-    implicit val formats: Formats = DefaultFormats + ByteStringJsonSerializer
+    implicit val formats: Formats = DefaultFormats + ByteStringJsonSerializer + UInt256JsonSerializer
     for {
       genesisData <- Try(parse(genesisJson).extract[GenesisData])
       _ <- loadGenesisData(genesisData)
@@ -89,19 +93,7 @@ class GenesisDataLoader(blockchain: Blockchain, blockchainConfig: BlockchainConf
     val storage = stateStorage.getReadOnlyStorage
     val initalRootHash = MerklePatriciaTrie.EmptyRootHash
 
-    val stateMptRootHash = genesisData.alloc.zipWithIndex.foldLeft(initalRootHash) {
-      case (rootHash, (((address, AllocAccount(balance)), idx))) =>
-        val mpt = MerklePatriciaTrie[Array[Byte], Account](rootHash, storage)
-        val paddedAddress = address.reverse.padTo(addressLength, "0").reverse.mkString
-        val stateRoot = mpt
-          .put(
-            crypto.kec256(Hex.decode(paddedAddress)),
-            Account(blockchainConfig.accountStartNonce, UInt256(BigInt(balance)), emptyTrieRootHash, emptyEvmHash)
-          )
-          .getRootHash
-        stateRoot
-    }
-
+    val stateMptRootHash = getGenesisStateRoot(genesisData, initalRootHash, storage)
     val header: BlockHeader = prepareHeader(genesisData, stateMptRootHash)
 
     log.debug(s"Prepared genesis header: $header")
@@ -130,6 +122,27 @@ class GenesisDataLoader(blockchain: Blockchain, blockchainConfig: BlockchainConf
     }
   }
 
+  private def getGenesisStateRoot(genesisData: GenesisData, initalRootHash: Array[Byte], storage: MptStorage) = {
+    import MerklePatriciaTrie.defaultByteArraySerializable
+
+    genesisData.alloc.zipWithIndex.foldLeft(initalRootHash) { case (rootHash, ((address, genesisAccount), _)) =>
+      val mpt = MerklePatriciaTrie[Array[Byte], Account](rootHash, storage)
+      val paddedAddress = address.reverse.padTo(addressLength, "0").reverse.mkString
+      val stateRoot = mpt
+        .put(
+          crypto.kec256(Hex.decode(paddedAddress)),
+          Account(
+            nonce = genesisAccount.nonce
+              .getOrElse(blockchainConfig.accountStartNonce),
+            balance = genesisAccount.balance,
+            codeHash = genesisAccount.code.map(codeValue => crypto.kec256(codeValue)).getOrElse(Account.EmptyCodeHash)
+          )
+        )
+        .getRootHash
+      stateRoot
+    }
+  }
+
   private def prepareHeader(genesisData: GenesisData, stateMptRootHash: Array[Byte]) =
     BlockHeader(
       parentHash = zeros(hashLength),
@@ -178,5 +191,23 @@ object GenesisDataLoader {
           )
         )
 
+    def deserializeUint256String(jv: JValue): UInt256 = jv match {
+      case JString(s) =>
+        Try(UInt256(BigInt(s))) match {
+          case Failure(_) => throw new RuntimeException("Cannot parse hex string: " + s)
+          case Success(value) => value
+        }
+      case other => throw new RuntimeException("Expected hex string, but got: " + other)
+    }
+
+    object UInt256JsonSerializer
+        extends CustomSerializer[UInt256](formats =>
+          (
+            { case jv => deserializeUint256String(jv) },
+            PartialFunction.empty
+          )
+        )
   }
 }
+
+object Implicits extends JsonMethodsImplicits

src/main/scala/io/iohk/ethereum/blockchain/data/genesis.scala

@@ -1,8 +1,17 @@
 package io.iohk.ethereum.blockchain.data
 
 import akka.util.ByteString
+import io.iohk.ethereum.domain.UInt256
 
-case class AllocAccount(balance: String)
+case class PrecompiledAccountConfig(name: String)
+
+case class GenesisAccount(
+    precompiled: Option[PrecompiledAccountConfig],
+    balance: UInt256,
+    code: Option[ByteString],
+    nonce: Option[UInt256],
+    storage: Option[Map[UInt256, UInt256]]
+)
 
 case class GenesisData(
     nonce: ByteString,
@@ -12,5 +21,5 @@ case class GenesisData(
     gasLimit: String,
     coinbase: ByteString,
     timestamp: String,
-    alloc: Map[String, AllocAccount]
+    alloc: Map[String, GenesisAccount]
 )

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

@@ -9,6 +9,51 @@ import io.iohk.ethereum.utils.ByteStringUtils
 
 case class CheckpointResponse(signatures: Seq[ECDSASignature], signers: Seq[ByteString])
 
+trait BaseBlockResponse {
+  def number: BigInt
+  def hash: Option[ByteString]
+  def parentHash: ByteString
+  def nonce: Option[ByteString]
+  def sha3Uncles: ByteString
+  def logsBloom: ByteString
+  def transactionsRoot: ByteString
+  def stateRoot: ByteString
+  def receiptsRoot: ByteString
+  def miner: Option[ByteString]
+  def difficulty: BigInt
+  def totalDifficulty: Option[BigInt]
+  def extraData: ByteString
+  def size: BigInt
+  def gasLimit: BigInt
+  def gasUsed: BigInt
+  def timestamp: BigInt
+  def transactions: Either[Seq[ByteString], Seq[BaseTransactionResponse]]
+  def uncles: Seq[ByteString]
+}
+
+case class EthBlockResponse(
+    number: BigInt,
+    hash: Option[ByteString],
+    mixHash: Option[ByteString],
+    parentHash: ByteString,
+    nonce: Option[ByteString],
+    sha3Uncles: ByteString,
+    logsBloom: ByteString,
+    transactionsRoot: ByteString,
+    stateRoot: ByteString,
+    receiptsRoot: ByteString,
+    miner: Option[ByteString],
+    difficulty: BigInt,
+    totalDifficulty: Option[BigInt],
+    extraData: ByteString,
+    size: BigInt,
+    gasLimit: BigInt,
+    gasUsed: BigInt,
+    timestamp: BigInt,
+    transactions: Either[Seq[ByteString], Seq[BaseTransactionResponse]],
+    uncles: Seq[ByteString]
+) extends BaseBlockResponse
+
 //scalastyle:off method.length
 case class BlockResponse(
     number: BigInt,
@@ -35,7 +80,7 @@ case class BlockResponse(
     uncles: Seq[ByteString],
     signature: String,
     signer: String
-) {
+) extends BaseBlockResponse {
   val chainWeight: Option[ChainWeight] = for {
     lcn <- lastCheckpointNumber
     td <- totalDifficulty
@@ -50,7 +95,8 @@ object BlockResponse {
       block: Block,
       weight: Option[ChainWeight] = None,
       fullTxs: Boolean = false,
-      pendingBlock: Boolean = false
+      pendingBlock: Boolean = false,
+      coinbase: Option[ByteString] = None
   ): BlockResponse = {
     val transactions =
       if (fullTxs)

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

@@ -15,19 +15,19 @@ object EthBlocksService {
   case class TxCountByBlockHashResponse(txsQuantity: Option[Int])
 
   case class BlockByBlockHashRequest(blockHash: ByteString, fullTxs: Boolean)
-  case class BlockByBlockHashResponse(blockResponse: Option[BlockResponse])
+  case class BlockByBlockHashResponse(blockResponse: Option[BaseBlockResponse])
 
   case class BlockByNumberRequest(block: BlockParam, fullTxs: Boolean)
-  case class BlockByNumberResponse(blockResponse: Option[BlockResponse])
+  case class BlockByNumberResponse(blockResponse: Option[BaseBlockResponse])
 
   case class GetBlockTransactionCountByNumberRequest(block: BlockParam)
   case class GetBlockTransactionCountByNumberResponse(result: BigInt)
 
   case class UncleByBlockHashAndIndexRequest(blockHash: ByteString, uncleIndex: BigInt)
-  case class UncleByBlockHashAndIndexResponse(uncleBlockResponse: Option[BlockResponse])
+  case class UncleByBlockHashAndIndexResponse(uncleBlockResponse: Option[BaseBlockResponse])
 
   case class UncleByBlockNumberAndIndexRequest(block: BlockParam, uncleIndex: BigInt)
-  case class UncleByBlockNumberAndIndexResponse(uncleBlockResponse: Option[BlockResponse])
+  case class UncleByBlockNumberAndIndexResponse(uncleBlockResponse: Option[BaseBlockResponse])
 
   case class GetUncleCountByBlockNumberRequest(block: BlockParam)
   case class GetUncleCountByBlockNumberResponse(result: BigInt)

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

@@ -1,7 +1,6 @@
 package io.iohk.ethereum.jsonrpc
 
 import java.time.Duration
-
 import akka.util.ByteString
 import io.iohk.ethereum.crypto.ECDSASignature
 import io.iohk.ethereum.domain.Address
@@ -13,13 +12,14 @@ import io.iohk.ethereum.jsonrpc.serialization.JsonMethodDecoder.NoParamsMethodDe
 import io.iohk.ethereum.jsonrpc.serialization.{JsonEncoder, JsonMethodCodec, JsonMethodDecoder, JsonSerializers}
 import io.iohk.ethereum.utils.BigIntExtensionMethods.BigIntAsUnsigned
 import org.bouncycastle.util.encoders.Hex
+import org.json4s.Formats
 import org.json4s.JsonAST._
 import org.json4s.JsonDSL._
 
 import scala.util.Try
 
 trait JsonMethodsImplicits {
-  implicit val formats = JsonSerializers.formats
+  implicit val formats: Formats = JsonSerializers.formats
 
   def encodeAsHex(input: ByteString): JString =
     JString(s"0x${Hex.toHexString(input.toArray[Byte])}")
@@ -30,7 +30,7 @@ trait JsonMethodsImplicits {
   def encodeAsHex(input: BigInt): JString =
     JString(s"0x${input.toString(16)}")
 
-  protected def decode(s: String): Array[Byte] = {
+  def decode(s: String): Array[Byte] = {
     val stripped = s.replaceFirst("^0x", "")
     val normalized = if (stripped.length % 2 == 1) "0" + stripped else stripped
     Hex.decode(normalized)

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

@@ -245,8 +245,16 @@ case class JsonRpcController(
       handle[ModifyTimestampRequest, ModifyTimestampResponse](testService.modifyTimestamp, req)
     case req @ JsonRpcRequest(_, "test_rewindToBlock", _, _) =>
       handle[RewindToBlockRequest, RewindToBlockResponse](testService.rewindToBlock, req)
+    case req @ JsonRpcRequest(_, "test_importRawBlock", _, _) =>
+      handle[ImportRawBlockRequest, ImportRawBlockResponse](testService.importRawBlock, req)
+    case req @ JsonRpcRequest(_, "test_getLogHash", _, _) =>
+      handle[GetLogHashRequest, GetLogHashResponse](testService.getLogHash, req)
     case req @ JsonRpcRequest(_, "miner_setEtherbase", _, _) =>
       handle[SetEtherbaseRequest, SetEtherbaseResponse](testService.setEtherbase, req)
+    case req @ JsonRpcRequest(_, "debug_accountRange", _, _) =>
+      handle[AccountsInRangeRequest, AccountsInRangeResponse](testService.getAccountsInRange, req)
+    case req @ JsonRpcRequest(_, "debug_storageRangeAt", _, _) =>
+      handle[StorageRangeRequest, StorageRangeResponse](testService.storageRangeAt, req)
   }
 
   private def handleIeleRequest: PartialFunction[JsonRpcRequest, Task[JsonRpcResponse]] = {

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

@@ -1,6 +1,9 @@
 package io.iohk.ethereum.jsonrpc
 
 import org.json4s.JsonAST.{JArray, JValue}
+import org.json4s.native.Serialization.write
+import org.json4s.DefaultFormats
+import org.json4s.Formats
 
 //TODO: work on a more elegant solution
 trait SensitiveInformationToString {
@@ -14,4 +17,10 @@ trait SensitiveInformationToString {
 }
 
 case class JsonRpcRequest(jsonrpc: String, method: String, params: Option[JArray], id: Option[JValue])
-    extends SensitiveInformationToString
+    extends SensitiveInformationToString {
+
+  def inspect: String = {
+    implicit val formats: Formats = DefaultFormats
+    "JsonRpcRequest" + (jsonrpc, method, params.map(write(_)), id.map(write(_))).toString
+  }
+}

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

@@ -1,5 +1,13 @@
 package io.iohk.ethereum.jsonrpc
 
+import org.json4s.native.Serialization.write
 import org.json4s.JsonAST.JValue
+import org.json4s.DefaultFormats
+import org.json4s.Formats
 
-case class JsonRpcResponse(jsonrpc: String, result: Option[JValue], error: Option[JsonRpcError], id: JValue)
+case class JsonRpcResponse(jsonrpc: String, result: Option[JValue], error: Option[JsonRpcError], id: JValue) {
+  def inspect: String = {
+    implicit val formats: Formats = DefaultFormats
+    "JsonRpcResponse" + (jsonrpc, result.map(write(_)), error.map(write(_))).toString
+  }
+}