[ETCM-17] Implement blake2b compress precompiled contract

Author: KonradStaniec

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

@@ -44,7 +44,6 @@ object Blake2bCompression {
 
   def parseNumberOfRounds(input: Array[Byte]): Long =
     Integer.toUnsignedLong(bytesToInt(copyOfRange(input, 0, 4)))
-  
   /**
     * Parses input according to the rules defined in: https://eips.ethereum.org/EIPS/eip-152
     * The encoded inputs are corresponding to the ones specified in the BLAKE2 RFC Section 3.2:
@@ -58,8 +57,8 @@ object Blake2bCompression {
     * @param input [4 bytes for rounds][64 bytes for h][128 bytes for m][8 bytes for t_0][8 bytes for t_1][1 byte for f]
     * @return all parsed inputs from input array: (rounds, h, m, t, f)
     */
-  def parseInput(input: Array[Byte]): (Long, Array[Long], Array[Long], Array[Long], Boolean) = {
-    val rounds =parseNumberOfRounds(input)
+  private def parseInput(input: Array[Byte]): (Long, Array[Long], Array[Long], Array[Long], Boolean) = {
+    val rounds = parseNumberOfRounds(input)
     val h = new Array[Long](8)
     val m = new Array[Long](16)
     val t = new Array[Long](2)
@@ -88,13 +87,13 @@ object Blake2bCompression {
     if (isValidInput(input)) {
       val (rounds, h, m, t, f) = parseInput(input)
       compress(rounds, h, m, t, f)
-      Some(compute(h))
+      Some(convertToBytes(h))
     } else {
       None
     }
   }
 
-  private def compute(h: Array[Long]): Array[Byte] = {
+  private def convertToBytes(h: Array[Long]): Array[Byte] = {
     var i = 0
     val out = new Array[Byte](h.length * 8)
     while (i < h.length) {

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

@@ -10,6 +10,7 @@ import io.iohk.ethereum.utils.ByteUtils
 import io.iohk.ethereum.vm.BlockchainConfigForEvm.EtcForks.EtcFork
 import io.iohk.ethereum.vm.BlockchainConfigForEvm.EthForks.EthFork
 import io.iohk.ethereum.vm.BlockchainConfigForEvm.{EtcForks, EthForks}
+
 import scala.util.Try
 
 // scalastyle:off magic.number
@@ -23,6 +24,7 @@ object PrecompiledContracts {
   val Bn128AddAddr = Address(6)
   val Bn128MulAddr = Address(7)
   val Bn128PairingAddr = Address(8)
+  val Blake2bCompressionAddr = Address(9)
 
   val contracts = Map(
     EcDsaRecAddr -> EllipticCurveRecovery,
@@ -37,6 +39,10 @@ object PrecompiledContracts {
     Bn128MulAddr -> Bn128Mul,
     Bn128PairingAddr -> Bn128Pairing
   )
+
+  val istanbulPhoenisContracts = byzantiumAtlantisContracts ++ Map(
+    Blake2bCompressionAddr -> Blake2bCompress
+  )
   /**
     * Checks whether `ProgramContext#recipientAddr` points to a precompiled contract
     */
@@ -53,8 +59,12 @@ object PrecompiledContracts {
 
   private def getContract(context: ProgramContext[_, _]): Option[PrecompiledContract] = {
     context.recipientAddr.flatMap{ addr =>
-      if (context.evmConfig.blockchainConfig.ethForkForBlockNumber(context.blockHeader.number) >= EthForks.Byzantium ||
-        context.evmConfig.blockchainConfig.etcForkForBlockNumber(context.blockHeader.number) >= EtcForks.Atlantis) {
+      val ethFork = context.evmConfig.blockchainConfig.ethForkForBlockNumber(context.blockHeader.number)
+      val etcFork = context.evmConfig.blockchainConfig.etcForkForBlockNumber(context.blockHeader.number)
+
+      if (ethFork >= EthForks.Istanbul || etcFork >= EtcForks.Phoenix) {
+        istanbulPhoenisContracts.get(addr)
+      } else if (ethFork >= EthForks.Byzantium || etcFork >= EtcForks.Atlantis) {
         // byzantium and atlantis hard fork introduce the same set of precompiled contracts
         byzantiumAtlantisContracts.get(addr)
       } else
@@ -375,4 +385,23 @@ object PrecompiledContracts {
       input.slice(from, from + wordLength)
     }
   }
+
+  //Spec: https://eips.ethereum.org/EIPS/eip-152
+  // scalastyle: off
+  object Blake2bCompress extends PrecompiledContract {
+    def exec(inputData: ByteString): Option[ByteString] = {
+      Blake2bCompression.blake2bCompress(inputData.toArray).map(ByteString.fromArrayUnsafe)
+    }
+
+    def gas(inputData: ByteString, etcFork: EtcFork, ethFork: EthFork): BigInt = {
+      val inputArray = inputData.toArray
+      if (Blake2bCompression.isValidInput(inputArray)) {
+        // Each round costs 1gas
+        Blake2bCompression.parseNumberOfRounds(inputArray)
+      } else {
+        // bad input to contract, contract will not execute, set price to zero
+        0
+      }
+    }
+  }
 }

src/test/scala/io/iohk/ethereum/vm/PrecompiledContractsSpec.scala

@@ -248,4 +248,21 @@ class PrecompiledContractsSpec extends FunSuite with Matchers with PropertyCheck
       result.returnData shouldEqual ByteString(Hex.decode(expectedResult))
     }
   }
+
+  test("BLAKE2bCompress") {
+    val testData = Table(("input", "Expected"),
+      ("0000000148c9bdf267e6096a3ba7ca8485ae67bb2bf894fe72f36e3cf1361d5f3af54fa5d182e6ad7f520e511f6c3e2b8c68059b6bbd41fbabd9831f79217e1319cde05b61626300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000001", "b63a380cb2897d521994a85234ee2c181b5f844d2c624c002677e9703449d2fba551b3a8333bcdf5f2f7e08993d53923de3d64fcc68c034e717b9293fed7a421")
+    )
+
+    forAll(testData) { (input, expectedResult) =>
+      val inputArray = Hex.decode(input)
+      val expectedNumOfRounds = BigInt(1, inputArray.take(4))
+      val context = buildContext(PrecompiledContracts.Blake2bCompressionAddr, ByteString(inputArray))
+      val result = vm.run(context)
+      val gasUsed =  context.startGas - result.gasRemaining
+      gasUsed shouldEqual expectedNumOfRounds
+      result.returnData shouldEqual ByteString(Hex.decode(expectedResult))
+    }
+  }
+
 }