[ETCM-1095] Unify TransactionGen/ReceiptGen with other generators style

Author: strauss-m

src/test/scala/io/iohk/ethereum/ObjectGenerators.scala

@@ -69,10 +69,10 @@ trait ObjectGenerators {
       arrayList <- Gen.nonEmptyListOf(byteArrayOfNItemsGen(size))
     } yield byteStringList.zip(arrayList)
 
-  def receiptGen(): Gen[Receipt] =
-    Gen.oneOf(legacyReceiptGen(), type01ReceiptGen())
+  def receiptGen: Gen[Receipt] =
+    Gen.oneOf(legacyReceiptGen, type01ReceiptGen)
 
-  def legacyReceiptGen(): Gen[LegacyReceipt] = for {
+  def legacyReceiptGen: Gen[LegacyReceipt] = for {
     postTransactionStateHash <- byteArrayOfNItemsGen(32)
     cumulativeGasUsed <- bigIntGen
     logsBloomFilter <- byteArrayOfNItemsGen(256)
@@ -83,19 +83,19 @@ trait ObjectGenerators {
     logs = Seq()
   )
 
-  def type01ReceiptGen(): Gen[Type01Receipt] = legacyReceiptGen().map(Type01Receipt(_))
+  def type01ReceiptGen: Gen[Type01Receipt] = legacyReceiptGen.map(Type01Receipt(_))
 
   def addressGen: Gen[Address] = byteArrayOfNItemsGen(20).map(Address(_))
 
-  def accessListItemGen(): Gen[AccessListItem] = for {
+  def accessListItemGen: Gen[AccessListItem] = for {
     address <- addressGen
     storageKeys <- Gen.listOf(bigIntGen)
   } yield AccessListItem(address, storageKeys)
 
-  def transactionGen(): Gen[Transaction] =
-    Gen.oneOf(legacyTransactionGen(), typedTransactionGen())
+  def transactionGen: Gen[Transaction] =
+    Gen.oneOf(legacyTransactionGen, typedTransactionGen)
 
-  def legacyTransactionGen(): Gen[LegacyTransaction] = for {
+  def legacyTransactionGen: Gen[LegacyTransaction] = for {
     nonce <- bigIntGen
     gasPrice <- bigIntGen
     gasLimit <- bigIntGen
@@ -111,15 +111,15 @@ trait ObjectGenerators {
     payload
   )
 
-  def typedTransactionGen(): Gen[TransactionWithAccessList] = for {
+  def typedTransactionGen: Gen[TransactionWithAccessList] = for {
     chainId <- bigIntGen
     nonce <- bigIntGen
     gasPrice <- bigIntGen
     gasLimit <- bigIntGen
     receivingAddress <- addressGen
     value <- bigIntGen
     payload <- byteStringOfLengthNGen(256)
-    accessList <- Gen.listOf(accessListItemGen())
+    accessList <- Gen.listOf(accessListItemGen)
   } yield TransactionWithAccessList(
     chainId,
     nonce,
@@ -131,7 +131,7 @@ trait ObjectGenerators {
     accessList
   )
 
-  def receiptsGen(n: Int): Gen[Seq[Seq[Receipt]]] = Gen.listOfN(n, Gen.listOf(receiptGen()))
+  def receiptsGen(n: Int): Gen[Seq[Seq[Receipt]]] = Gen.listOfN(n, Gen.listOf(receiptGen))
 
   def branchNodeGen: Gen[BranchNode] = for {
     children <- Gen
@@ -172,7 +172,7 @@ trait ObjectGenerators {
 
   def signedTxSeqGen(length: Int, secureRandom: SecureRandom, chainId: Option[Byte]): Gen[Seq[SignedTransaction]] = {
     val senderKeys = crypto.generateKeyPair(secureRandom)
-    val txsSeqGen = Gen.listOfN(length, transactionGen())
+    val txsSeqGen = Gen.listOfN(length, transactionGen)
     txsSeqGen.map { txs =>
       txs.map { tx =>
         SignedTransaction.sign(tx, senderKeys, chainId)
@@ -183,7 +183,7 @@ trait ObjectGenerators {
   def signedTxGen(secureRandom: SecureRandom, chainId: Option[Byte]): Gen[SignedTransaction] = {
     val senderKeys = crypto.generateKeyPair(secureRandom)
     for {
-      tx <- transactionGen()
+      tx <- transactionGen
     } yield SignedTransaction.sign(tx, senderKeys, chainId)
   }
 

src/test/scala/io/iohk/ethereum/domain/SignedLegacyTransactionSpec.scala

@@ -18,21 +18,20 @@ class SignedLegacyTransactionSpec
     with ScalaCheckPropertyChecks
     with SecureRandomBuilder {
   "SignedTransaction" should "correctly set pointSign for chainId with chain specific signing schema" in {
-    forAll(Generators.transactionGen(), Arbitrary.arbitrary[Unit].map(_ => generateKeyPair(secureRandom))) {
-      (tx, key) =>
-        val chainId: Byte = 0x3d
-        val allowedPointSigns = Set((chainId * 2 + 35).toByte, (chainId * 2 + 36).toByte)
-        //byte 0 of encoded ECC point indicates that it is uncompressed point, it is part of bouncycastle encoding
-        val address = Address(
-          crypto
-            .kec256(key.getPublic.asInstanceOf[ECPublicKeyParameters].getQ.getEncoded(false).tail)
-            .drop(FirstByteOfAddress)
-        )
-        val signedTransaction = SignedTransaction.sign(tx, key, Some(chainId))
-        val result = SignedTransactionWithSender(signedTransaction, Address(key))
+    forAll(Generators.transactionGen, Arbitrary.arbitrary[Unit].map(_ => generateKeyPair(secureRandom))) { (tx, key) =>
+      val chainId: Byte = 0x3d
+      val allowedPointSigns = Set((chainId * 2 + 35).toByte, (chainId * 2 + 36).toByte)
+      //byte 0 of encoded ECC point indicates that it is uncompressed point, it is part of bouncycastle encoding
+      val address = Address(
+        crypto
+          .kec256(key.getPublic.asInstanceOf[ECPublicKeyParameters].getQ.getEncoded(false).tail)
+          .drop(FirstByteOfAddress)
+      )
+      val signedTransaction = SignedTransaction.sign(tx, key, Some(chainId))
+      val result = SignedTransactionWithSender(signedTransaction, Address(key))
 
-        allowedPointSigns should contain(result.tx.signature.v)
-        address shouldEqual result.senderAddress
+      allowedPointSigns should contain(result.tx.signature.v)
+      address shouldEqual result.senderAddress
     }
   }
 }