Merge branch 'develop' into etcm-301-fix-block-preparation

Author: Michał Mrożek

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

@@ -14,6 +14,7 @@ import io.iohk.ethereum.domain
 import io.iohk.ethereum.domain.BlockchainImpl.BestBlockLatestCheckpointNumbers
 import io.iohk.ethereum.ledger.{InMemoryWorldStateProxy, InMemoryWorldStateProxyStorage}
 import io.iohk.ethereum.mpt.{MerklePatriciaTrie, MptNode}
+import io.iohk.ethereum.utils.{ByteStringUtils, Logger}
 import io.iohk.ethereum.vm.{Storage, WorldStateProxy}
 import monix.reactive.Observable
 
@@ -215,7 +216,8 @@ class BlockchainImpl(
     protected val transactionMappingStorage: TransactionMappingStorage,
     protected val appStateStorage: AppStateStorage,
     protected val stateStorage: StateStorage
-) extends Blockchain {
+) extends Blockchain
+    with Logger {
 
   override def getStateStorage: StateStorage = stateStorage
 
@@ -237,11 +239,17 @@ class BlockchainImpl(
   override def getChainWeightByHash(blockhash: ByteString): Option[ChainWeight] = chainWeightStorage.get(blockhash)
 
   override def getBestBlockNumber(): BigInt = {
-    val bestBlockNum = appStateStorage.getBestBlockNumber()
-    if (bestKnownBlockAndLatestCheckpoint.get().bestBlockNumber > bestBlockNum)
-      bestKnownBlockAndLatestCheckpoint.get().bestBlockNumber
+    val bestSavedBlockNumber = appStateStorage.getBestBlockNumber()
+    val bestKnownBlockNumber = bestKnownBlockAndLatestCheckpoint.get().bestBlockNumber
+    log.debug(
+      "Current best saved block number {}. Current best known block number {}",
+      bestSavedBlockNumber,
+      bestKnownBlockNumber
+    )
+    if (bestKnownBlockNumber > bestSavedBlockNumber)
+      bestKnownBlockNumber
     else
-      bestBlockNum
+      bestSavedBlockNumber
   }
 
   override def getLatestCheckpointBlockNumber(): BigInt = {
@@ -254,8 +262,11 @@ class BlockchainImpl(
       latestCheckpointNumberInStorage
   }
 
-  override def getBestBlock(): Block =
-    getBlockByNumber(getBestBlockNumber()).get
+  override def getBestBlock(): Block = {
+    val bestBlockNumber = getBestBlockNumber()
+    log.debug("Trying to get best block with number {}", bestBlockNumber)
+    getBlockByNumber(bestBlockNumber).get
+  }
 
   override def getAccount(address: Address, blockNumber: BigInt): Option[Account] =
     getBlockHeaderByNumber(blockNumber).flatMap { bh =>
@@ -280,13 +291,23 @@ class BlockchainImpl(
   }
 
   private def persistBestBlocksData(): Unit = {
+    val currentBestBlockNumber = getBestBlockNumber()
+    val currentBestCheckpointNumber = getLatestCheckpointBlockNumber()
+    log.debug(
+      "Persisting block info data into database. Persisted block number is {}. " +
+        "Persisted checkpoint number is {}",
+      currentBestBlockNumber,
+      currentBestCheckpointNumber
+    )
+
     appStateStorage
-      .putBestBlockNumber(getBestBlockNumber())
-      .and(appStateStorage.putLatestCheckpointBlockNumber(getLatestCheckpointBlockNumber()))
+      .putBestBlockNumber(currentBestBlockNumber)
+      .and(appStateStorage.putLatestCheckpointBlockNumber(currentBestCheckpointNumber))
       .commit()
   }
 
   def save(block: Block, receipts: Seq[Receipt], weight: ChainWeight, saveAsBestBlock: Boolean): Unit = {
+    log.debug("Saving new block block {} to database", block.idTag)
     storeBlock(block)
       .and(storeReceipts(block.header.hash, receipts))
       .and(storeChainWeight(block.header.hash, weight))
@@ -297,8 +318,17 @@ class BlockchainImpl(
     stateStorage.onBlockSave(block.header.number, appStateStorage.getBestBlockNumber())(persistBestBlocksData)
 
     if (saveAsBestBlock && block.hasCheckpoint) {
+      log.debug(
+        "New best known block block number - {}, new best checkpoint number - {}",
+        block.header.number,
+        block.header.number
+      )
       saveBestKnownBlockAndLatestCheckpointNumber(block.header.number, block.header.number)
     } else if (saveAsBestBlock) {
+      log.debug(
+        "New best known block block number - {}",
+        block.header.number
+      )
       saveBestKnownBlock(block.header.number)
     }
   }
@@ -361,6 +391,13 @@ class BlockchainImpl(
 // scalastyle:off method.length
   override def removeBlock(blockHash: ByteString, withState: Boolean): Unit = {
     val maybeBlockHeader = getBlockHeaderByHash(blockHash)
+
+    log.debug(
+      "Trying to remove block with hash {} and number {}",
+      ByteStringUtils.hash2string(blockHash),
+      maybeBlockHeader.map(_.number)
+    )
+
     val maybeTxList = getBlockBodyByHash(blockHash).map(_.transactionList)
     val bestBlocks = bestKnownBlockAndLatestCheckpoint.get()
     // as we are decreasing block numbers in memory more often than in storage,
@@ -409,13 +446,27 @@ class BlockchainImpl(
 
     // not transactional part
     saveBestKnownBlocks(newBestBlockNumber, prevCheckpointNumber)
+    log.debug(
+      "Removed block with hash {}. New best block number - {}, new best checkpoint block number - {}",
+      ByteStringUtils.hash2string(blockHash),
+      newBestBlockNumber,
+      prevCheckpointNumber
+    )
 
     maybeBlockHeader.foreach { h =>
       if (withState) {
         val bestBlocksUpdates = appStateStorage
           .putBestBlockNumber(newBestBlockNumber)
           .and(checkpointUpdates)
-        stateStorage.onBlockRollback(h.number, bestBlockNumber)(() => bestBlocksUpdates.commit())
+        stateStorage.onBlockRollback(h.number, bestBlockNumber) { () =>
+          log.debug(
+            "Persisting block info data into database. Persisted block number is {}. " +
+              "Persisted checkpoint number is {}",
+            newBestBlockNumber,
+            prevCheckpointNumber
+          )
+          bestBlocksUpdates.commit()
+        }
       }
     }
   }

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

@@ -5,7 +5,7 @@ import io.iohk.ethereum.consensus.validators.BlockHeaderError.HeaderParentNotFou
 import io.iohk.ethereum.domain._
 import io.iohk.ethereum.ledger.BlockExecutionError.ValidationBeforeExecError
 import io.iohk.ethereum.ledger.BlockQueue.Leaf
-import io.iohk.ethereum.utils.{BlockchainConfig, Logger}
+import io.iohk.ethereum.utils.{BlockchainConfig, ByteStringUtils, Logger}
 import org.bouncycastle.util.encoders.Hex
 
 import scala.concurrent.{ExecutionContext, Future}
@@ -141,6 +141,7 @@ class BlockImport(
     *        (oldBranch, newBranch) as lists of blocks
     */
   private def reorganiseChainFromQueue(queuedLeaf: ByteString): BlockImportResult = {
+    log.debug("Reorganising chain from leaf {}", ByteStringUtils.hash2string(queuedLeaf))
     blockchain.persistCachedNodes()
     val newBranch = blockQueue.getBranch(queuedLeaf, dequeue = true)
     val bestNumber = blockchain.getBestBlockNumber()
@@ -150,6 +151,11 @@ class BlockImport(
       parentHash = parent.header.parentHash
       parentWeight <- blockchain.getChainWeightByHash(parentHash)
     } yield {
+      log.debug(
+        "Removing blocks starting from number {} and parent {}",
+        bestNumber,
+        ByteStringUtils.hash2string(parentHash)
+      )
       val oldBlocksData = removeBlocksUntil(parentHash, bestNumber).reverse
       oldBlocksData.foreach(block => blockQueue.enqueueBlock(block.block))
       handleBlockExecResult(newBranch, parentWeight, oldBlocksData)

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

@@ -20,17 +20,20 @@ class BlockValidation(consensus: Consensus, blockchain: Blockchain, blockQueue:
   }
 
   private def getNBlocksBackFromChainOrQueue(hash: ByteString, n: Int): List[Block] = {
-    val queuedBlocks = blockQueue.getBranch(hash, dequeue = false).take(n)
+    val queuedBlocks = blockQueue.getBranch(hash, dequeue = false).takeRight(n)
     if (queuedBlocks.length == n) {
       queuedBlocks
     } else {
       val chainedBlockHash = queuedBlocks.headOption.map(_.header.parentHash).getOrElse(hash)
       blockchain.getBlockByHash(chainedBlockHash) match {
         case None =>
+          // The in memory blocks aren't connected to the db ones, we don't have n blocks to return so we return none
           Nil
 
         case Some(block) =>
+          // We already have |block +: queuedBlocks|
           val remaining = n - queuedBlocks.length - 1
+
           val numbers = (block.header.number - remaining) until block.header.number
           val blocks = (numbers.toList.flatMap(blockchain.getBlockByNumber) :+ block) ::: queuedBlocks
           blocks