Merge branch 'fix/createSenderAcc' into phase/3/txExecution

Author: Nicolas Tallar

src/main/scala/io/iohk/ethereum/ledger/Ledger.scala

@@ -83,22 +83,22 @@ class LedgerImpl(vm: VM, blockchainConfig: BlockchainConfig) extends Ledger with
     *         if one of them failed
     */
   @tailrec
-  private def executeTransactions(signedTransactions: Seq[SignedTransaction], world: InMemoryWorldStateProxy,
+  private[ledger] final def executeTransactions(signedTransactions: Seq[SignedTransaction], world: InMemoryWorldStateProxy,
                                   blockHeader: BlockHeader, signedTransactionValidator: SignedTransactionValidator,
                                   acumGas: BigInt = 0, acumReceipts: Seq[Receipt] = Nil): Either[TxsExecutionError, BlockResult] =
     signedTransactions match {
       case Nil =>
         Right(BlockResult(worldState = world, gasUsed = acumGas, receipts = acumReceipts))
 
       case Seq(stx, otherStxs@_*) =>
-        val senderAccount = world.getAccount(stx.senderAddress)
+        val (senderAccount, worldForTx) = world.getAccount(stx.senderAddress).map(a => (a, world))
+          .getOrElse ((Account.Empty, world.saveAccount(stx.senderAddress, Account.Empty)))
         val upfrontCost = calculateUpfrontCost(stx.tx)
-        val validatedStx = senderAccount
-          .toRight(Left(TxsExecutionError(s"Account of tx sender ${stx.senderAddress.toString} not found")))
-          .flatMap(account => signedTransactionValidator.validate(stx, account, blockHeader, upfrontCost, acumGas))
+        val validatedStx = signedTransactionValidator.validate(stx, senderAccount, blockHeader, upfrontCost, acumGas)
+
         validatedStx match {
           case Right(_) =>
-            val TxResult(newWorld, gasUsed, logs) = executeTransaction(stx, blockHeader, world)
+            val TxResult(newWorld, gasUsed, logs) = executeTransaction(stx, blockHeader, worldForTx)
 
             val receipt = Receipt(
               postTransactionStateHash = newWorld.stateRootHash,
@@ -254,7 +254,7 @@ class LedgerImpl(vm: VM, blockchainConfig: BlockchainConfig) extends Ledger with
   private[ledger] def prepareProgramContext(stx: SignedTransaction, blockHeader: BlockHeader, worldStateProxy: InMemoryWorldStateProxy, config: EvmConfig): PC =
     stx.tx.receivingAddress match {
       case None =>
-        val address = worldStateProxy.createAddress(stx.senderAddress)
+        val address = worldStateProxy.createAddress(creatorAddr = stx.senderAddress)
         val world1 = worldStateProxy.transfer(stx.senderAddress, address, UInt256(stx.tx.value))
         ProgramContext(stx, address,  Program(stx.tx.payload), blockHeader, world1, config)
 

src/test/scala/io/iohk/ethereum/ledger/LedgerSpec.scala

@@ -663,10 +663,35 @@ class LedgerSpec extends FlatSpec with PropertyChecks with Matchers {
     }
   }
 
+  it should "create sender account if it does not exists" in new TestSetup {
+
+    val inputData = ByteString("the payload")
+
+    val newAccountKeyPair: AsymmetricCipherKeyPair = generateKeyPair()
+    val newAccountAddress = Address(kec256(newAccountKeyPair.getPublic.asInstanceOf[ECPublicKeyParameters].getQ.getEncoded(false).tail))
+
+    val mockVM = new MockVM((pc: Ledger.PC) => {
+      pc.env.inputData shouldEqual ByteString.empty
+      createResult(pc, defaultGasLimit, defaultGasLimit, 0, None, returnData = ByteString("contract code"))
+    })
+    val ledger = new LedgerImpl(mockVM, blockchainConfig)
+
+    val tx: Transaction = defaultTx.copy(gasPrice = 0, receivingAddress = None, payload = inputData)
+    val stx: SignedTransaction = SignedTransaction.sign(tx, newAccountKeyPair, blockchainConfig.chainId)
+
+    val result: Either[BlockExecutionError.TxsExecutionError, BlockResult] = ledger.executeTransactions(
+      Seq(stx),
+      initialWorld,
+      defaultBlockHeader,
+      (new Mocks.MockValidatorsAlwaysSucceed).signedTransactionValidator)
+
+    result shouldBe a[Right[_, BlockResult]]
+    result.map(br => br.worldState.getAccount(newAccountAddress)) shouldBe Right(Some(Account(nonce = 1)))
+  }
 
   trait TestSetup {
-    val originKeyPair = generateKeyPair()
-    val receiverKeyPair = generateKeyPair()
+    val originKeyPair: AsymmetricCipherKeyPair = generateKeyPair()
+    val receiverKeyPair: AsymmetricCipherKeyPair = generateKeyPair()
     //byte 0 of encoded ECC point indicates that it is uncompressed point, it is part of spongycastle encoding
     val originAddress = Address(kec256(originKeyPair.getPublic.asInstanceOf[ECPublicKeyParameters].getQ.getEncoded(false).tail))
     val receiverAddress = Address(kec256(receiverKeyPair.getPublic.asInstanceOf[ECPublicKeyParameters].getQ.getEncoded(false).tail))