[ETCM-533] refactor pathTraverse in order to get the proof and value in both cases(existing/non existing key)

Author: bsuieric

src/it/scala/io/iohk/ethereum/txExecTest/util/DumpChainApp.scala

@@ -150,7 +150,7 @@ class BlockchainMock(genesisHash: ByteString) extends Blockchain {
       rootHash: NodeHash,
       position: BigInt,
       ethCompatibleStorage: Boolean
-  ): (BigInt, Seq[MptNode]) = (1, Seq.empty)
+  ): (BigInt, Seq[MptNode]) = (BigInt(0), Seq.empty)
 
   override protected def getHashByBlockNumber(number: BigInt): Option[ByteString] = Some(genesisHash)
 

src/main/scala/io/iohk/ethereum/mpt/MerklePatriciaTrie.scala

@@ -84,10 +84,10 @@ class MerklePatriciaTrie[K, V] private (private[mpt] val rootNode: Option[MptNod
   def get(key: K): Option[V] = {
     pathTraverse[Option[V]](None, mkKeyNibbles(key)) { case (_, node) =>
       node match {
-        case LeafNode(_, value, _, _, _) =>
+        case Some(LeafNode(_, value, _, _, _)) =>
           Some(vSerializer.fromBytes(value.toArray[Byte]))
 
-        case BranchNode(_, terminator, _, _, _) =>
+        case Some(BranchNode(_, terminator, _, _, _)) =>
           terminator.map(term => vSerializer.fromBytes(term.toArray[Byte]))
 
         case _ => None
@@ -103,9 +103,9 @@ class MerklePatriciaTrie[K, V] private (private[mpt] val rootNode: Option[MptNod
     * @throws io.iohk.ethereum.mpt.MerklePatriciaTrie.MPTException if there is any inconsistency in how the trie is build.
     */
   def getProof(key: K): Option[Vector[MptNode]] = {
-    pathTraverseWithProof[Vector[MptNode]](Vector.empty, mkKeyNibbles(key)) { case (acc, node) =>
+    pathTraverse[Vector[MptNode]](Vector.empty, mkKeyNibbles(key)) { case (acc, node) =>
       node match {
-        case nextNodeOnExt @ (_: BranchNode | _: ExtensionNode | _: LeafNode) => acc :+ nextNodeOnExt
+        case Some(nextNodeOnExt @ (_: BranchNode | _: ExtensionNode | _: LeafNode)) => acc :+ nextNodeOnExt
         case _ => acc
       }
     }
@@ -121,25 +121,25 @@ class MerklePatriciaTrie[K, V] private (private[mpt] val rootNode: Option[MptNod
     * @tparam T accumulator type
     * @return accumulated data or None if key doesn't exist
     */
-  private def pathTraverse[T](acc: T, searchKey: Array[Byte])(op: (T, MptNode) => T): Option[T] = {
+  private def pathTraverse[T](acc: T, searchKey: Array[Byte])(op: (T, Option[MptNode]) => T): Option[T] = {
 
     @tailrec
-    def pathTraverse(acc: T, node: MptNode, searchKey: Array[Byte], op: (T, MptNode) => T): Option[T] = {
+    def pathTraverse(acc: T, node: MptNode, searchKey: Array[Byte], op: (T, Option[MptNode]) => T): Option[T] = {
       node match {
         case LeafNode(key, _, _, _, _) =>
-          if (key.toArray[Byte] sameElements searchKey) Some(op(acc, node)) else None
+          if (key.toArray[Byte] sameElements searchKey) Some(op(acc, Some(node))) else Some(op(acc, None))
 
         case extNode @ ExtensionNode(sharedKey, _, _, _, _) =>
           val (commonKey, remainingKey) = searchKey.splitAt(sharedKey.length)
           if (searchKey.length >= sharedKey.length && (sharedKey.toArray[Byte] sameElements commonKey)) {
-            pathTraverse(op(acc, node), extNode.next, remainingKey, op)
-          } else None
+            pathTraverse(op(acc, Some(node)), extNode.next, remainingKey, op)
+          } else Some(op(acc, None))
 
         case branch: BranchNode =>
-          if (searchKey.isEmpty) Some(op(acc, node))
+          if (searchKey.isEmpty) Some(op(acc, Some(node)))
           else
             pathTraverse(
-              op(acc, node),
+              op(acc, Some(node)),
               branch.children(searchKey(0)),
               searchKey.slice(1, searchKey.length),
               op
@@ -149,7 +149,7 @@ class MerklePatriciaTrie[K, V] private (private[mpt] val rootNode: Option[MptNod
           pathTraverse(acc, getFromHash(bytes, nodeStorage), searchKey, op)
 
         case NullNode =>
-          None
+          Some(op(acc, None))
       }
     }
 
@@ -161,46 +161,6 @@ class MerklePatriciaTrie[K, V] private (private[mpt] val rootNode: Option[MptNod
     }
   }
 
-  private def pathTraverseWithProof[T](acc: T, searchKey: Array[Byte])(op: (T, MptNode) => T): Option[T] = {
-
-    @tailrec
-    def pathTraverseWithProof(acc: T, node: MptNode, searchKey: Array[Byte], op: (T, MptNode) => T): Option[T] = {
-      node match {
-        case LeafNode(key, _, _, _, _) =>
-          if (key.toArray[Byte] sameElements searchKey) Some(op(acc, node)) else Some(acc)
-
-        case extNode @ ExtensionNode(sharedKey, _, _, _, _) =>
-          val (commonKey, remainingKey) = searchKey.splitAt(sharedKey.length)
-          if (searchKey.length >= sharedKey.length && (sharedKey.toArray[Byte] sameElements commonKey)) {
-            pathTraverseWithProof(op(acc, node), extNode.next, remainingKey, op)
-          } else Some(acc)
-
-        case branch: BranchNode =>
-          if (searchKey.isEmpty) Some(op(acc, node))
-          else
-            pathTraverseWithProof(
-              op(acc, node),
-              branch.children(searchKey(0)),
-              searchKey.slice(1, searchKey.length),
-              op
-            )
-
-        case HashNode(bytes) =>
-          pathTraverseWithProof(acc, getFromHash(bytes, nodeStorage), searchKey, op)
-
-        case NullNode =>
-          Some(acc)
-      }
-    }
-
-    rootNode match {
-      case Some(root) =>
-        pathTraverseWithProof(acc, root, searchKey, op)
-      case None =>
-        None
-    }
-  }
-
   private def getFromHash(nodeId: Array[Byte], source: MptStorage): MptNode = {
     val nodeEncoded = source.get(nodeId).encode
     MptTraversals

src/test/scala/io/iohk/ethereum/mpt/MerklePatriciaTrieSuite.scala

@@ -573,7 +573,6 @@ class MerklePatriciaTrieSuite extends AnyFunSuite with ScalaCheckPropertyChecks
       val proof: Option[Vector[MptNode]] = trie.getProof(key4)
       // then
       assert(proof.isDefined)
-      proof.foreach(_.foreach(MptUtils.showMptNode(_, true, " ")))
   }
 
   test("getProof returns valid proof for existing key") {
@@ -624,43 +623,3 @@ class MerklePatriciaTrieSuite extends AnyFunSuite with ScalaCheckPropertyChecks
       assert(obtained.isEmpty)
     }
 }
-
-object MptUtils {
-  import io.iohk.ethereum.mpt._
-  import org.bouncycastle.util.encoders.Hex
-  def show(val1: Array[Byte]): String =
-    Hex.encode(val1).map(_.toChar).mkString
-  def showKV(key1: Array[Byte], trie: MerklePatriciaTrie[Array[Byte], Array[Byte]]): String =
-    show(key1) + " -> " + trie.get(key1).map(show)
-  def showMptNode(n: MptNode, showNull: Boolean = false, indent: String): Unit = {
-    n match {
-      case LeafNode(key, value, cachedHash, cachedRlpEncoded, parsedRlp) =>
-        if (showNull) println("\n")
-        println(s"$indent LeafNode(${show(key.toArray)} -> ${show(value.toArray)})")
-      case ExtensionNode(sharedKey, next, cachedHash, cachedRlpEncoded, parsedRlp) =>
-        if (showNull) println("\n")
-        println(s"$indent ExtensionNode(sharedKey = ${show(sharedKey.toArray)}")
-        println(s"$indent next = ")
-        showMptNode(next, false, indent + " ")
-        println(s"$indent )")
-      case BranchNode(children, terminator, cachedHash, cachedRlpEncoded, parsedRlp) =>
-        if (showNull) println("\n")
-        println(
-          s"$indent BranchNode(children = ${children.filterNot(n => n.isInstanceOf[NullNode.type]).size}, terminator = ${terminator
-            .map(e => show(e.toArray))}"
-        )
-        println(s"$indent children: ")
-        children.map(showMptNode(_, false, indent + " "))
-        println(s"$indent )")
-      case NullNode =>
-        if (showNull) println(s"$indent NullNode")
-      case other =>
-        if (showNull) println("\n")
-        println(s"$indent $other")
-    }
-  }
-  def showMptTrie[K, V](mpt: MerklePatriciaTrie[K, V]): Unit = {
-    println(s"MPT ROOT HASH ${mpt.getRootHash} rootNode: ")
-    mpt.rootNode.map(n => showMptNode(n, false, "  "))
-  }
-}