ETCM-697: Added separate transaction response class that includes signature fields required by retesteth

Author: Igor Grahovac

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

@@ -28,7 +28,7 @@ trait BaseBlockResponse {
   def gasLimit: BigInt
   def gasUsed: BigInt
   def timestamp: BigInt
-  def transactions: Either[Seq[ByteString], Seq[TransactionResponse]]
+  def transactions: Either[Seq[ByteString], Seq[BaseTransactionResponse]]
   def uncles: Seq[ByteString]
 }
 
@@ -51,7 +51,7 @@ case class EthBlockResponse(
     gasLimit: BigInt,
     gasUsed: BigInt,
     timestamp: BigInt,
-    transactions: Either[Seq[ByteString], Seq[TransactionResponse]],
+    transactions: Either[Seq[ByteString], Seq[BaseTransactionResponse]],
     uncles: Seq[ByteString]
 ) extends BaseBlockResponse
 

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

@@ -251,6 +251,8 @@ case class JsonRpcController(
       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/TestJsonMethodsImplicits.scala

@@ -11,6 +11,7 @@ import io.iohk.ethereum.blockchain.data.GenesisAccount
 
 import scala.util.Try
 import io.iohk.ethereum.domain.UInt256
+import org.json4s.Extraction
 
 object TestJsonMethodsImplicits extends JsonMethodsImplicits {
 
@@ -60,6 +61,8 @@ object TestJsonMethodsImplicits extends JsonMethodsImplicits {
         blockReward <- optionalQuantity(blockchainParamsJson \ "blockReward")
         byzantiumForkBlock <- extractQuantity(blockchainParamsJson \ "byzantiumForkBlock")
         homesteadForkBlock <- extractQuantity(blockchainParamsJson \ "homesteadForkBlock")
+        constantinopleForkBlock <- extractQuantity(blockchainParamsJson \ "constantinopleForkBlock")
+        istanbulForkBlock <- extractQuantity(blockchainParamsJson \ "istanbulForkBlock")
       } yield BlockchainParams(
         eIP150ForkBlock,
         eIP158ForkBlock,
@@ -68,7 +71,9 @@ object TestJsonMethodsImplicits extends JsonMethodsImplicits {
         blockReward.getOrElse(0),
         byzantiumForkBlock,
         homesteadForkBlock,
-        0
+        0,
+        constantinopleForkBlock,
+        istanbulForkBlock
       )
     }
 
@@ -187,4 +192,28 @@ object TestJsonMethodsImplicits extends JsonMethodsImplicits {
       "nextKey" -> encodeAsHex(t.nextKey)
     )
   }
+
+  implicit val debug_storageRangeAt = new JsonMethodDecoder[StorageRangeRequest]
+    with JsonEncoder[StorageRangeResponse] {
+    override def decodeJson(params: Option[JArray]): Either[JsonRpcError, StorageRangeRequest] =
+      params match {
+        case Some(JArray(blockHashOrNumber :: txIndex :: address :: begin :: maxResults :: Nil)) =>
+          for {
+            txIndex <- extractQuantity(txIndex)
+            maxResults <- extractQuantity(maxResults)
+            begin <- extractQuantity(begin)
+            addressHash <- extractBytes(address.extract[String])
+            blockHashOrNumberEither = extractBlockHashOrNumber(blockHashOrNumber.extract[String])
+          } yield StorageRangeRequest(
+            StorageRangeParams(blockHashOrNumberEither, txIndex, addressHash, begin, maxResults)
+          )
+        case _ => Left(InvalidParams())
+      }
+
+    private def extractBlockHashOrNumber(blockHash: String): Either[BigInt, ByteString] =
+      extractHash(blockHash)
+        .fold(_ => Left(BigInt(blockHash)), Right(_))
+
+    override def encodeJson(t: StorageRangeResponse): JValue = Extraction.decompose(t)
+  }
 }

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

@@ -40,7 +40,9 @@ object TestService {
       blockReward: BigInt,
       byzantiumForkBlock: BigInt,
       homesteadForkBlock: BigInt,
-      maximumExtraDataSize: BigInt
+      maximumExtraDataSize: BigInt,
+      constantinopleForkBlock: BigInt,
+      istanbulForkBlock: BigInt
   )
 
   case class ChainParams(
@@ -62,6 +64,16 @@ object TestService {
       nextKey: ByteString
   )
 
+  case class StorageRangeParams(
+      blockHashOrNumber: Either[BigInt, ByteString],
+      txIndex: BigInt,
+      address: ByteString,
+      begin: BigInt,
+      maxResults: BigInt
+  )
+
+  case class StorageEntry(key: ByteString, value: ByteString)
+
   case class SetChainParamsRequest(chainParams: ChainParams)
   case class SetChainParamsResponse()
 
@@ -82,6 +94,9 @@ object TestService {
 
   case class AccountsInRangeRequest(parameters: AccountsInRangeRequestParams)
   case class AccountsInRangeResponse(addressMap: Map[ByteString, ByteString], nextKey: ByteString)
+
+  case class StorageRangeRequest(parameters: StorageRangeParams)
+  case class StorageRangeResponse(complete: Boolean, storage: Map[ByteString, StorageEntry])
 }
 
 class TestService(
@@ -105,6 +120,9 @@ class TestService(
     val newBlockchainConfig = testLedgerWrapper.blockchainConfig.copy(
       homesteadBlockNumber = request.chainParams.blockchainParams.homesteadForkBlock,
       eip150BlockNumber = request.chainParams.blockchainParams.EIP150ForkBlock,
+      byzantiumBlockNumber = request.chainParams.blockchainParams.byzantiumForkBlock,
+      constantinopleBlockNumber = request.chainParams.blockchainParams.constantinopleForkBlock,
+      istanbulBlockNumber = request.chainParams.blockchainParams.istanbulForkBlock,
       accountStartNonce = UInt256(request.chainParams.blockchainParams.accountStartNonce),
       networkId = 1,
       bootstrapNodes = Set()
@@ -123,6 +141,9 @@ class TestService(
       }
     )
 
+    // set coinbase for blocks that will be tried to mine
+    etherbase = Address(genesisData.coinbase)
+
     // remove current genesis (Try because it may not exist)
     Try(blockchain.removeBlock(blockchain.genesisHeader.hash, withState = false))
 
@@ -251,4 +272,8 @@ class TestService(
       )
     )
   }
+
+  def storageRangeAt(request: StorageRangeRequest): ServiceResponse[StorageRangeResponse] = {
+    Task.now(Right(StorageRangeResponse(complete = true, storage = Map())))
+  }
 }

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

@@ -1,7 +1,21 @@
 package io.iohk.ethereum.jsonrpc
 
 import akka.util.ByteString
-import io.iohk.ethereum.domain.{BlockHeader, SignedTransaction}
+import io.iohk.ethereum.domain.{BlockHeader, SignedTransaction, UInt256}
+
+trait BaseTransactionResponse {
+  def hash: ByteString
+  def nonce: BigInt
+  def blockHash: Option[ByteString]
+  def blockNumber: Option[BigInt]
+  def transactionIndex: Option[BigInt]
+  def from: Option[ByteString]
+  def to: Option[ByteString]
+  def value: BigInt
+  def gasPrice: BigInt
+  def gas: BigInt
+  def input: ByteString
+}
 
 final case class TransactionResponse(
     hash: ByteString,
@@ -15,7 +29,24 @@ final case class TransactionResponse(
     gasPrice: BigInt,
     gas: BigInt,
     input: ByteString
-)
+) extends BaseTransactionResponse
+
+final case class EthTransactionResponse(
+    hash: ByteString,
+    nonce: BigInt,
+    blockHash: Option[ByteString],
+    blockNumber: Option[BigInt],
+    transactionIndex: Option[BigInt],
+    from: Option[ByteString],
+    to: Option[ByteString],
+    value: BigInt,
+    gasPrice: BigInt,
+    gas: BigInt,
+    input: ByteString,
+    r: ByteString,
+    s: ByteString,
+    v: ByteString
+) extends BaseTransactionResponse
 
 final case class TransactionData(
     stx: SignedTransaction,
@@ -48,3 +79,31 @@ object TransactionResponse {
     )
 
 }
+
+object EthTransactionResponse {
+
+  def apply(tx: TransactionData): EthTransactionResponse =
+    EthTransactionResponse(tx.stx, tx.blockHeader, tx.transactionIndex)
+
+  def apply(
+      stx: SignedTransaction,
+      blockHeader: Option[BlockHeader] = None,
+      transactionIndex: Option[Int] = None
+  ): EthTransactionResponse =
+    EthTransactionResponse(
+      hash = stx.hash,
+      nonce = stx.tx.nonce,
+      blockHash = blockHeader.map(_.hash),
+      blockNumber = blockHeader.map(_.number),
+      transactionIndex = transactionIndex.map(txIndex => BigInt(txIndex)),
+      from = SignedTransaction.getSender(stx).map(_.bytes),
+      to = stx.tx.receivingAddress.map(_.bytes),
+      value = stx.tx.value,
+      gasPrice = stx.tx.gasPrice,
+      gas = stx.tx.gasLimit,
+      input = stx.tx.payload,
+      r = UInt256(stx.signature.r).bytes,
+      s = UInt256(stx.signature.s).bytes,
+      v = ByteString(stx.signature.v)
+    )
+}

src/main/scala/io/iohk/ethereum/testmode/TestEthBlockServiceWrapper.scala

@@ -1,8 +1,16 @@
 package io.iohk.ethereum.testmode
 
-import io.iohk.ethereum.domain.Blockchain
+import io.iohk.ethereum.domain.{Block, Blockchain}
 import io.iohk.ethereum.jsonrpc.EthBlocksService.{BlockByBlockHashResponse, BlockByNumberResponse}
-import io.iohk.ethereum.jsonrpc.{BaseBlockResponse, EthBlockResponse, EthBlocksService, ServiceResponse}
+import io.iohk.ethereum.jsonrpc.{
+  BaseBlockResponse,
+  BaseTransactionResponse,
+  EthBlockResponse,
+  EthBlocksService,
+  EthTransactionResponse,
+  ServiceResponse,
+  TransactionData
+}
 import io.iohk.ethereum.ledger.Ledger
 import io.iohk.ethereum.utils.Logger
 import io.iohk.ethereum.consensus.Consensus
@@ -23,11 +31,12 @@ class TestEthBlockServiceWrapper(blockchain: Blockchain, ledger: Ledger, consens
   ): ServiceResponse[EthBlocksService.BlockByBlockHashResponse] = super
     .getByBlockHash(request)
     .map(
-      _.map(blockByBlockResponse =>
+      _.map(blockByBlockResponse => {
+        val fullBlock = blockchain.getBlockByNumber(blockByBlockResponse.blockResponse.get.number).get
         BlockByBlockHashResponse(
-          blockByBlockResponse.blockResponse.map(response => toEthResponse(response))
+          blockByBlockResponse.blockResponse.map(response => toEthResponse(fullBlock, response))
         )
-      )
+      })
     )
 
   /**
@@ -41,15 +50,16 @@ class TestEthBlockServiceWrapper(blockchain: Blockchain, ledger: Ledger, consens
   ): ServiceResponse[EthBlocksService.BlockByNumberResponse] = super
     .getBlockByNumber(request)
     .map(
-      _.map(blockByBlockResponse =>
+      _.map(blockByBlockResponse => {
+        val fullBlock = blockchain.getBlockByNumber(blockByBlockResponse.blockResponse.get.number).get
         BlockByNumberResponse(
           blockByBlockResponse.blockResponse
-            .map(response => toEthResponse(response))
+            .map(response => toEthResponse(fullBlock, response))
         )
-      )
+      })
     )
 
-  private def toEthResponse(response: BaseBlockResponse) = EthBlockResponse(
+  private def toEthResponse(block: Block, response: BaseBlockResponse) = EthBlockResponse(
     response.number,
     response.hash,
     response.mixHash,
@@ -68,7 +78,16 @@ class TestEthBlockServiceWrapper(blockchain: Blockchain, ledger: Ledger, consens
     response.gasLimit,
     response.gasUsed,
     response.timestamp,
-    response.transactions,
+    toEthTransaction(block, response.transactions),
     response.uncles
   )
+
+  private def toEthTransaction(
+      block: Block,
+      responseTransactions: Either[Seq[ByteString], Seq[BaseTransactionResponse]]
+  ): Either[Seq[ByteString], Seq[BaseTransactionResponse]] = responseTransactions.map(_ => {
+    block.body.transactionList.zipWithIndex.map { case (stx, transactionIndex) =>
+      EthTransactionResponse(tx = TransactionData(stx, Some(block.header), Some(transactionIndex)))
+    }
+  })
 }