[ETCM-533] Proof of non-existence

Author: AnastasiiaL

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

@@ -103,7 +103,7 @@ 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]] = {
-    pathTraverse[Vector[MptNode]](Vector.empty, mkKeyNibbles(key)) { case (acc, node) =>
+    pathTraverseWithProof[Vector[MptNode]](Vector.empty, mkKeyNibbles(key)) { case (acc, node) =>
       node match {
         case nextNodeOnExt @ (_: BranchNode | _: ExtensionNode | _: LeafNode) => acc :+ nextNodeOnExt
         case _ => acc
@@ -161,6 +161,46 @@ 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/domain/BlockchainSpec.scala

@@ -152,7 +152,10 @@ class BlockchainSpec extends AnyFlatSpec with Matchers with ScalaCheckPropertyCh
     //unhappy path
     val wrongAddress = Address(666)
     val retrievedAccountProofWrong = blockchain.getAccountProof(wrongAddress, headerWithAcc.number)
-    retrievedAccountProofWrong.isDefined shouldBe false
+    //the account doesn't exist, so we can't retrieve it, but we do receive a proof of non-existence with a full path of nodes that we iterated
+    retrievedAccountProofWrong.isDefined shouldBe true
+    retrievedAccountProofWrong.size shouldBe 1
+    mptWithAcc.get(wrongAddress) shouldBe None
 
     //happy path
     val retrievedAccountProof = blockchain.getAccountProof(address, headerWithAcc.number)

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

@@ -554,22 +554,26 @@ class MerklePatriciaTrieSuite extends AnyFunSuite with ScalaCheckPropertyChecks
     assert(proof.isEmpty)
   }
 
-  test("getProof returns empty result for non-existing key") {
-    forAll(keyValueListGen()) { keyValueList: Seq[(Int, Int)] =>
-      val input: Seq[(Array[Byte], Array[Byte])] = keyValueList
-        .map { case (k, v) => k.toString.getBytes() -> v.toString.getBytes() }
-
-      val trie = input
-        .foldLeft(emptyMpt) { case (recTrie, (key, value)) =>
-          recTrie.put(key, value)
-        }
-
-      input.toList.foreach(x => {
-        val keyToFind = x._1 ++ Array(Byte.MaxValue)
-        val proof = trie.getProof(keyToFind)
-        assert(proof.isEmpty)
-      })
-    }
+  test("getProof returns proof result for non-existing address") {
+      // given
+      val EmptyTrie = MerklePatriciaTrie[Array[Byte], Array[Byte]](emptyEphemNodeStorage)
+      val key1: Array[Byte] = Hex.decode("10000001")
+      val key2: Array[Byte] = Hex.decode("10000002")
+      val key3: Array[Byte] = Hex.decode("30000003")
+      val key4: Array[Byte] = Hex.decode("10000004") //a key that doesn't have a corresponding value in the trie
+
+      val val1: Array[Byte] = Hex.decode("0101")
+      val val2: Array[Byte] = Hex.decode("0102")
+      val val3: Array[Byte] = Hex.decode("0103")
+      val trie = EmptyTrie
+        .put(key1, val1)
+        .put(key2, val2)
+        .put(key3, val3)
+      // when
+      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") {
@@ -620,3 +624,43 @@ 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, "  "))
+  }
+}