[ETCM-893] Add support for chains with ids bigger than 127 (#1006)

[ETCM-893] Add support for networks with a chainid bigger than 127

Author: Leonor Boga

crypto/src/main/scala/io/iohk/ethereum/crypto/ECDSASignature.scala

@@ -31,7 +31,7 @@ object ECDSASignature {
 
   val allowedPointSigns = Set(negativePointSign, positivePointSign)
 
-  def apply(r: ByteString, s: ByteString, v: Byte): ECDSASignature = {
+  def apply(r: ByteString, s: ByteString, v: BigInt): ECDSASignature = {
     ECDSASignature(BigInt(1, r.toArray), BigInt(1, s.toArray), v)
   }
 
@@ -46,7 +46,11 @@ object ECDSASignature {
     sign(messageHash.toArray, keyPairFromPrvKey(prvKey.toArray), None)
 
   /** Sign a messageHash, expected to be a Keccak256 hash of the original data. */
-  def sign(messageHash: Array[Byte], keyPair: AsymmetricCipherKeyPair, chainId: Option[Byte] = None): ECDSASignature = {
+  def sign(
+      messageHash: Array[Byte],
+      keyPair: AsymmetricCipherKeyPair,
+      chainId: Option[BigInt] = None
+  ): ECDSASignature = {
     require(
       messageHash.size == 32,
       s"The message should be a hash, expected to be 32 bytes; got ${messageHash.size} bytes."
@@ -61,10 +65,10 @@ object ECDSASignature {
       .getOrElse(throw new RuntimeException("Failed to calculate signature rec id"))
 
     val pointSign = chainId match {
-      case Some(id) if v == negativePointSign => (id * 2 + newNegativePointSign).toByte
-      case Some(id) if v == positivePointSign => (id * 2 + newPositivePointSign).toByte
-      case None => v
-      case _ => throw new IllegalStateException(s"Unexpected pointSign. ChainId: ${chainId}, v: ${v}")
+      case Some(id) if v == negativePointSign => id * 2 + newNegativePointSign
+      case Some(id) if v == positivePointSign => id * 2 + newPositivePointSign
+      case None => BigInt(v)
+      case _ => throw new IllegalStateException(s"Unexpected pointSign. ChainId: $chainId, v: $v")
     }
 
     ECDSASignature(r, s, pointSign)
@@ -74,17 +78,18 @@ object ECDSASignature {
     * new formula for calculating point sign post EIP 155 adoption
     * v = CHAIN_ID * 2 + 35 or v = CHAIN_ID * 2 + 36
     */
-  private def getRecoveredPointSign(pointSign: Byte, chainId: Option[Byte]): Option[Byte] = {
+  private def getRecoveredPointSign(pointSign: BigInt, chainId: Option[BigInt]): Option[Byte] = {
+    val signByte = pointSign.toByte
     (chainId match {
       case Some(id) =>
-        if (pointSign == negativePointSign || pointSign == (id * 2 + newNegativePointSign).toByte) {
+        if (signByte == negativePointSign || signByte == (id * 2 + newNegativePointSign).toByte) {
           Some(negativePointSign)
-        } else if (pointSign == positivePointSign || pointSign == (id * 2 + newPositivePointSign).toByte) {
+        } else if (signByte == positivePointSign || signByte == (id * 2 + newPositivePointSign).toByte) {
           Some(positivePointSign)
         } else {
           None
         }
-      case None => Some(pointSign)
+      case None => Some(signByte)
     }).filter(pointSign => allowedPointSigns.contains(pointSign))
   }
 
@@ -106,8 +111,8 @@ object ECDSASignature {
   private def recoverPubBytes(
       r: BigInt,
       s: BigInt,
-      recId: Byte,
-      chainId: Option[Byte],
+      recId: BigInt,
+      chainId: Option[BigInt],
       messageHash: Array[Byte]
   ): Option[Array[Byte]] = {
     Try {
@@ -152,15 +157,15 @@ object ECDSASignature {
   * @param s - part of the signature calculated with signer private key
   * @param v - public key recovery id
   */
-case class ECDSASignature(r: BigInt, s: BigInt, v: Byte) {
+case class ECDSASignature(r: BigInt, s: BigInt, v: BigInt) {
 
   /**
     * returns ECC point encoded with on compression and without leading byte indicating compression
     * @param messageHash message to be signed; should be a hash of the actual data.
     * @param chainId optional value if you want new signing schema with recovery id calculated with chain id
     * @return
     */
-  def publicKey(messageHash: Array[Byte], chainId: Option[Byte] = None): Option[Array[Byte]] =
+  def publicKey(messageHash: Array[Byte], chainId: Option[BigInt] = None): Option[Array[Byte]] =
     ECDSASignature.recoverPubBytes(r, s, v, chainId, messageHash)
 
   /**

crypto/src/test/scala/io/iohk/ethereum/crypto/ECDSASignatureSpec.scala

@@ -18,7 +18,7 @@ class ECDSASignatureSpec extends AnyFlatSpec with Matchers with ScalaCheckProper
     val pointSign = 28
 
     val sig =
-      ECDSASignature(BigInt(1, signatureRandom.toArray[Byte]), BigInt(1, signature.toArray[Byte]), pointSign.toByte)
+      ECDSASignature(BigInt(1, signatureRandom.toArray[Byte]), BigInt(1, signature.toArray[Byte]), pointSign)
 
     sig.publicKey(bytesToSign).isEmpty shouldBe false
   }
@@ -30,7 +30,7 @@ class ECDSASignatureSpec extends AnyFlatSpec with Matchers with ScalaCheckProper
     val pointSign = 0x1f
 
     val sig =
-      ECDSASignature(BigInt(1, signatureRandom.toArray[Byte]), BigInt(1, signature.toArray[Byte]), pointSign.toByte)
+      ECDSASignature(BigInt(1, signatureRandom.toArray[Byte]), BigInt(1, signature.toArray[Byte]), pointSign)
 
     sig.publicKey(bytesToSign).isEmpty shouldBe true
   }
@@ -39,7 +39,7 @@ class ECDSASignatureSpec extends AnyFlatSpec with Matchers with ScalaCheckProper
     val sig = ECDSASignature(
       ByteStringUtils.string2hash("149a2046f51f5d043633664d76eef4f99cdba8e53851dcda57224dfe8770f98a"),
       ByteStringUtils.string2hash("a8898478e9aae9fadb71c7ab5451d47d2efa4199fc26ecc1da62ce8fb77e06f1"),
-      28.toByte
+      28
     )
     val messageHash = ByteStringUtils.string2hash("a1ede9cdf0b6fe37a384b265dce6b74a7464f11799dcee022f628450a19cf4eb")
 

src/benchmark/scala/io/iohk/ethereum/rlp/RLPSpeedSuite.scala

@@ -88,7 +88,7 @@ class RLPSpeedSuite
     pointSign = 28,
     signatureRandom = ByteString(Hex.decode("cfe3ad31d6612f8d787c45f115cc5b43fb22bcc210b62ae71dc7cbf0a6bea8df")),
     signature = ByteString(Hex.decode("57db8998114fae3c337e99dbd8573d4085691880f4576c6c1f6c5bbfe67d6cf0")),
-    chainId = 0x3d.toByte
+    chainId = 0x3d
   )
 
   lazy val blockGen: Gen[Block] = for {

src/it/scala/io/iohk/ethereum/txExecTest/ECIP1017Test.scala

@@ -19,7 +19,7 @@ class ECIP1017Test extends AnyFlatSpec with Matchers {
       monetaryPolicyConfig = MonetaryPolicyConfig(EraDuration, 0.2, 5000000000000000000L, 3000000000000000000L),
       // unused
       maxCodeSize = None,
-      chainId = 0x3d.toByte,
+      chainId = 0x3d,
       networkId = 1,
       forkBlockNumbers = ForkBlockNumbers(
         frontierBlockNumber = 0,

src/it/scala/io/iohk/ethereum/txExecTest/ForksTest.scala

@@ -35,7 +35,7 @@ class ForksTest extends AnyFlatSpec with Matchers {
         ecip1099BlockNumber = Long.MaxValue,
         ecip1049BlockNumber = None
       ),
-      chainId = 0x3d.toByte,
+      chainId = 0x3d,
       monetaryPolicyConfig = MonetaryPolicyConfig(5000000, 0.2, 5000000000000000000L, 3000000000000000000L),
       // unused
       bootstrapNodes = Set(),

src/main/resources/conf/testmode.conf

@@ -54,3 +54,5 @@ mantis {
   }
 
 }
+
+akka.http.server.request-timeout = 30.seconds

src/main/scala/io/iohk/ethereum/domain/SignedTransaction.scala

@@ -45,10 +45,10 @@ object SignedTransaction {
 
   def apply(
       tx: Transaction,
-      pointSign: Byte,
+      pointSign: BigInt,
       signatureRandom: ByteString,
       signature: ByteString,
-      chainId: Byte
+      chainId: BigInt
   ): SignedTransaction = {
     val txSignature = ECDSASignature(
       r = new BigInteger(1, signatureRandom.toArray),
@@ -58,7 +58,12 @@ object SignedTransaction {
     SignedTransaction(tx, txSignature)
   }
 
-  def apply(tx: Transaction, pointSign: Byte, signatureRandom: ByteString, signature: ByteString): SignedTransaction = {
+  def apply(
+      tx: Transaction,
+      pointSign: BigInt,
+      signatureRandom: ByteString,
+      signature: ByteString
+  ): SignedTransaction = {
     val txSignature = ECDSASignature(
       r = new BigInteger(1, signatureRandom.toArray),
       s = new BigInteger(1, signature.toArray),
@@ -67,14 +72,14 @@ object SignedTransaction {
     SignedTransaction(tx, txSignature)
   }
 
-  def sign(tx: Transaction, keyPair: AsymmetricCipherKeyPair, chainId: Option[Byte]): SignedTransactionWithSender = {
+  def sign(tx: Transaction, keyPair: AsymmetricCipherKeyPair, chainId: Option[BigInt]): SignedTransactionWithSender = {
     val bytes = bytesToSign(tx, chainId)
     val sig = ECDSASignature.sign(bytes, keyPair, chainId)
     val address = Address(keyPair)
     SignedTransactionWithSender(tx, sig, address)
   }
 
-  private def bytesToSign(tx: Transaction, chainId: Option[Byte]): Array[Byte] = {
+  private def bytesToSign(tx: Transaction, chainId: Option[BigInt]): Array[Byte] = {
     chainId match {
       case Some(id) =>
         chainSpecificTransactionBytes(tx, id)
@@ -128,7 +133,7 @@ object SignedTransaction {
     crypto.kec256(rlpEncode(RLPList(tx.nonce, tx.gasPrice, tx.gasLimit, receivingAddressAsArray, tx.value, tx.payload)))
   }
 
-  private def chainSpecificTransactionBytes(tx: Transaction, chainId: Byte): Array[Byte] = {
+  private def chainSpecificTransactionBytes(tx: Transaction, chainId: BigInt): Array[Byte] = {
     val receivingAddressAsArray: Array[Byte] = tx.receivingAddress.map(_.toArray).getOrElse(Array.emptyByteArray)
     crypto.kec256(
       rlpEncode(

src/main/scala/io/iohk/ethereum/extvm/VMServer.scala

@@ -192,7 +192,7 @@ class VMServer(messageHandler: MessageHandler) extends Logger {
       aghartaBlockNumber = BigInt(9573000), //TODO include agharta block number in protobuf
       petersburgBlockNumber = BigInt(10000000), //TODO include petersburg block number in protobuf
       phoenixBlockNumber = BigInt(10500839), //TODO include phoenix block number in protobuf
-      chainId = 0x3d.toByte //TODO include chainId in protobuf
+      chainId = 0x3d //TODO include chainId in protobuf
     )
   }
 }

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

@@ -26,7 +26,7 @@ import io.iohk.ethereum.utils.BlockchainConfig
 
 object EthInfoService {
   case class ChainIdRequest()
-  case class ChainIdResponse(value: Byte)
+  case class ChainIdResponse(value: BigInt)
 
   case class ProtocolVersionRequest()
   case class ProtocolVersionResponse(value: String)
@@ -174,7 +174,7 @@ class EthInfoService(
       val toAddress = req.tx.to.map(Address.apply)
 
       val tx = Transaction(0, req.tx.gasPrice, gasLimit, toAddress, req.tx.value, req.tx.data)
-      val fakeSignature = ECDSASignature(0, 0, 0.toByte)
+      val fakeSignature = ECDSASignature(0, 0, 0)
       SignedTransactionWithSender(tx, fakeSignature, fromAddress)
     }
   }

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

@@ -220,7 +220,7 @@ object JsonMethodsImplicits extends JsonMethodsImplicits {
   implicit val personal_sign = new JsonMethodCodec[SignRequest, SignResponse] {
     override def encodeJson(t: SignResponse): JValue = {
       import t.signature._
-      encodeAsHex(ByteString(r.toUnsignedByteArray ++ s.toUnsignedByteArray :+ v))
+      encodeAsHex(ByteString(r.toUnsignedByteArray ++ s.toUnsignedByteArray ++ v.toUnsignedByteArray))
     }
 
     override def decodeJson(params: Option[JArray]): Either[JsonRpcError, SignRequest] =