[ETCM-910] ModExp gas cost change (#1013)

* [ETCM-910] ModExp gas cost change

* [ETCM-910] ModExp gas cost unit tests

* [ETCM-910] PR remarks applied

* [ETCM-910] Apply PR remarks

* [ETCM-910] Apply PR remarks

Author: dzajkowski

src/main/scala/io/iohk/ethereum/vm/BlockchainConfigForEvm.scala

@@ -56,12 +56,12 @@ object BlockchainConfigForEvm {
 
   object EtcForks extends Enumeration {
     type EtcFork = Value
-    val BeforeAtlantis, Atlantis, Agharta, Phoenix = Value
+    val BeforeAtlantis, Atlantis, Agharta, Phoenix, Magneto = Value
   }
 
   object EthForks extends Enumeration {
     type EthFork = Value
-    val BeforeByzantium, Byzantium, Constantinople, Petersburg, Istanbul = Value
+    val BeforeByzantium, Byzantium, Constantinople, Petersburg, Istanbul, Berlin = Value
   }
 
   def apply(blockchainConfig: BlockchainConfig): BlockchainConfigForEvm = {

src/main/scala/io/iohk/ethereum/vm/PrecompiledContracts.scala

@@ -165,14 +165,13 @@ object PrecompiledContracts {
 
     private val lengthBytes = 32
     private val totalLengthBytes = 3 * lengthBytes
-    private val GQUADDIVISOR = 20
 
     def exec(inputData: ByteString): Option[ByteString] = {
       val baseLength = getLength(inputData, 0)
       val expLength = getLength(inputData, 1)
       val modLength = getLength(inputData, 2)
 
-      val result =
+      val result = {
         if (baseLength == 0 && modLength == 0)
           BigInt(0)
         else {
@@ -187,6 +186,7 @@ object PrecompiledContracts {
             base.modPow(exp, mod)
           }
         }
+      }
       Some(ByteString(ByteUtils.bigIntegerToBytes(result.bigInteger, modLength)))
     }
 
@@ -201,58 +201,84 @@ object PrecompiledContracts {
           safeAdd(safeAdd(totalLengthBytes, baseLength), expLength)
         )
 
-      val multComplexity = getMultComplexity(math.max(baseLength, modLength))
+      if (ethFork >= EthForks.Berlin || etcFork >= EtcForks.Magneto)
+        PostEIP2565Cost.calculate(baseLength, modLength, expLength, expBytes)
+      else
+        PostEIP198Cost.calculate(baseLength, modLength, expLength, expBytes)
+    }
 
-      val adjExpLen = adjExpLength(expBytes, expLength)
+    //Spec: https://eips.ethereum.org/EIPS/eip-198
+    object PostEIP198Cost {
+      private val GQUADDIVISOR = 20
 
-      multComplexity * math.max(adjExpLen, 1) / GQUADDIVISOR
-    }
+      def calculate(baseLength: Int, modLength: Int, expLength: Int, expBytes: ByteString): BigInt = {
+        val multComplexity = getMultComplexity(math.max(baseLength, modLength))
+        val adjusted = adjustExpLength(expBytes, expLength)
+        multComplexity * math.max(adjusted, 1) / GQUADDIVISOR
+      }
 
-    private def adjExpLength(expBytes: ByteString, expLength: Int): Long = {
-      val expHead =
-        if (expLength <= lengthBytes)
-          expBytes.padToByteString(expLength, 0.toByte)
+      private def getMultComplexity(x: BigInt): BigInt = {
+        val x2 = x * x
+        if (x <= 64)
+          x2
+        else if (x <= 1024)
+          x2 / 4 + 96 * x - 3072
         else
-          expBytes.take(lengthBytes).padToByteString(lengthBytes, 0.toByte)
+          x2 / 16 + 480 * x - 199680
+      }
+    }
 
-      val highestBitIndex = math.max(ByteUtils.toBigInt(expHead).bitLength - 1, 0)
+    //Spec: https://eips.ethereum.org/EIPS/eip-2565
+    object PostEIP2565Cost {
+      private val GQUADDIVISOR = 3
 
-      if (expLength <= lengthBytes) {
-        highestBitIndex
-      } else {
-        8L * (expLength - lengthBytes) + highestBitIndex
+      def calculate(baseLength: Int, modLength: Int, expLength: Int, expBytes: ByteString): BigInt = {
+        val multComplexity = getMultComplexity(math.max(baseLength, modLength))
+        val adjusted = adjustExpLength(expBytes, expLength)
+        val r = multComplexity * math.max(adjusted, 1) / GQUADDIVISOR
+        if (r <= 200) 200
+        else r
       }
-    }
 
-    private def getLength(bytes: ByteString, position: Int): Int = {
-      val start = position * lengthBytes
-      safeInt(ByteUtils.toBigInt(bytes.slice(start, start + lengthBytes)))
+      // ceiling(x/8)^2
+      private def getMultComplexity(x: BigInt): BigInt =
+        ((x + 7) / 8).pow(2)
     }
 
     private def getNumber(bytes: ByteString, offset: Int, length: Int): BigInt = {
       val number = bytes.slice(offset, safeAdd(offset, length)).padToByteString(length, 0.toByte)
       ByteUtils.toBigInt(number)
     }
 
+    private def safeAdd(a: Int, b: Int): Int = {
+      safeInt(BigInt(a) + BigInt(b))
+    }
+
     private def safeInt(value: BigInt): Int =
       if (value.isValidInt)
         value.toInt
       else
         Integer.MAX_VALUE
 
-    private def safeAdd(a: Int, b: Int): Int = {
-      safeInt(BigInt(a) + BigInt(b))
+    private def getLength(bytes: ByteString, position: Int): Int = {
+      val start = position * lengthBytes
+      safeInt(ByteUtils.toBigInt(bytes.slice(start, start + lengthBytes)))
     }
 
-    private def getMultComplexity(x: BigInt): BigInt = {
-      val x2 = x * x
+    private def adjustExpLength(expBytes: ByteString, expLength: Int): Long = {
+      val expHead =
+        if (expLength <= lengthBytes)
+          expBytes.padToByteString(expLength, 0.toByte)
+        else
+          expBytes.take(lengthBytes).padToByteString(lengthBytes, 0.toByte)
 
-      if (x <= 64)
-        x2
-      else if (x <= 1024)
-        x2 / 4 + 96 * x - 3072
-      else
-        x2 / 16 + 480 * x - 199680
+      val highestBitIndex = math.max(ByteUtils.toBigInt(expHead).bitLength - 1, 0)
+
+      if (expLength <= lengthBytes) {
+        highestBitIndex
+      } else {
+        8L * (expLength - lengthBytes) + highestBitIndex
+      }
     }
   }