Merge pull request #1081 from exonum/ECR-3413

Add proofs of absence for ListProof [ECR-3413]

Author: Ilya Bogdanov

exonum-java-binding/CHANGELOG.md

@@ -26,6 +26,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
   `CheckedProof#getIndexHash`, `ProofListIndexProxy#getIndexHash` and
   `ProofMapIndexProxy#getIndexHash` accordingly.
 
+### Added
+- Proofs of absence of an element with the specified index for `ProofListIndexProxy`. (#1081)
+
 ## [0.7.0] - 2019-07-17
 
 ### Overview

exonum-java-binding/common/src/main/java/com/exonum/binding/common/proofs/list/CheckedListProof.java

@@ -36,7 +36,9 @@
  */
 public interface CheckedListProof<E> extends CheckedProof {
   /**
-   * Get all list elements. There might be several consecutive ranges.
+   * Get all list proof elements. There might be several consecutive ranges.
+   *
+   * @return list proof elements. Empty if the proof is a proof of absence
    * @throws IllegalStateException if the proof is not valid
    */
   NavigableMap<Long, E> getElements();

exonum-java-binding/common/src/main/java/com/exonum/binding/common/proofs/list/CheckedListProofImpl.java

@@ -30,7 +30,10 @@
  *   <li>a calculated index hash of corresponding collection
  *   <li>proof elements
  * </ul>
- * If the proof is not valid, you may get the verification status using
+ *
+ * <p>If the proof is the proof of absence, then empty collection of elements is returned.
+ *
+ * <p>If the proof is not valid, you may get the verification status using
  * {@link #getProofStatus()} with description of why the proof is not
  * valid.
  */
@@ -45,7 +48,7 @@ public class CheckedListProofImpl<E> implements CheckedListProof {
   /**
    * Creates checked list proof.
    * @param calculatedIndexHash calculated index hash of the proof
-   * @param elements proof elements collection
+   * @param elements proof elements collection (empty in case of a proof of absence)
    * @param proofStatus a status of proof verification
    */
   public CheckedListProofImpl(HashCode calculatedIndexHash,

exonum-java-binding/common/src/main/java/com/exonum/binding/common/proofs/list/ListProofHashCalculator.java

@@ -115,6 +115,11 @@ public void visit(ListProofElement value) {
         .hash();
   }
 
+  @Override
+  public void visit(ListProofOfAbsence listProofOfAbsence) {
+    hash = listProofOfAbsence.getMerkleRoot();
+  }
+
   private HashCode visitLeft(ListProofBranch branch, long parentIndex) {
     index = 2 * parentIndex;
     branch.getLeft().accept(this);

exonum-java-binding/common/src/main/java/com/exonum/binding/common/proofs/list/ListProofOfAbsence.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2019 The Exonum Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.exonum.binding.common.proofs.list;
+
+import com.exonum.binding.common.hash.HashCode;
+
+/**
+ * Represents the proof of absence of a requested element or a range of elements
+ * by providing Merkle root hash of a corresponding proof list.
+ */
+public final class ListProofOfAbsence implements ListProofNode {
+
+  private final HashCode merkleRoot;
+
+  @SuppressWarnings("unused")  // Native API
+  ListProofOfAbsence(byte[] merkleRoot) {
+    this(HashCode.fromBytes(merkleRoot));
+  }
+
+  /**
+   * Creates ListProof absence node with given Merkle root.
+   */
+  public ListProofOfAbsence(HashCode merkleRoot) {
+    this.merkleRoot = merkleRoot;
+  }
+
+  @Override
+  public void accept(ListProofVisitor visitor) {
+    visitor.visit(this);
+  }
+
+  /**
+   * Returns the Merkle root of a corresponding proof list.
+   */
+  public HashCode getMerkleRoot() {
+    return merkleRoot;
+  }
+}

exonum-java-binding/common/src/main/java/com/exonum/binding/common/proofs/list/ListProofStatus.java

@@ -27,7 +27,8 @@ public enum ListProofStatus implements ProofStatus {
   INVALID_HASH_NODE_DEPTH("Hash node appears below the maximum allowed depth"),
   INVALID_TREE_NO_ELEMENTS("Tree does not contain any element nodes"),
   INVALID_NODE_DEPTH("Value node appears at the wrong level"),
-  INVALID_HASH_NODES_COUNT("A branch node in a proof tree has only hash nodes as children");
+  INVALID_HASH_NODES_COUNT("A branch node in a proof tree has only hash nodes as children"),
+  INVALID_PROOF_OF_ABSENCE("Proof of absence is not a root node of a proof tree");
 
   private final String description;
 

exonum-java-binding/common/src/main/java/com/exonum/binding/common/proofs/list/ListProofStructureValidator.java

@@ -16,9 +16,13 @@
 
 package com.exonum.binding.common.proofs.list;
 
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Multimaps;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
+import java.util.EnumMap;
 import java.util.List;
 
 /**
@@ -29,11 +33,7 @@ final class ListProofStructureValidator implements ListProofVisitor {
   static final int MAX_NODE_DEPTH = 63;
 
   // TODO: optimize data storage and algorithms of validity checks, https://jira.bf.local/browse/ECR-2443
-  private final List<NodeInfo> listProofBranchesInfo;
-
-  private final List<NodeInfo> listProofElementsInfo;
-
-  private final List<NodeInfo> listProofHashNodesInfo;
+  private final Multimap<NodeType, NodeInfo> listProofInfo;
 
   private int depth;
 
@@ -45,9 +45,7 @@ final class ListProofStructureValidator implements ListProofVisitor {
   ListProofStructureValidator(ListProofNode listProof) {
     depth = 0;
     proofStatus = ListProofStatus.VALID;
-    listProofBranchesInfo = new ArrayList<>();
-    listProofElementsInfo = new ArrayList<>();
-    listProofHashNodesInfo = new ArrayList<>();
+    listProofInfo = Multimaps.newListMultimap(new EnumMap<>(NodeType.class), ArrayList::new);
 
     listProof.accept(this);
     this.check();
@@ -59,7 +57,7 @@ public void visit(ListProofBranch branch) {
 
     NodeType leftElementType = getNodeType(branch.getLeft());
     NodeType rightElementType = branch.getRight().map(this::getNodeType).orElse(NodeType.NONE);
-    listProofBranchesInfo.add(
+    listProofInfo.get(NodeType.BRANCH).add(
         new NodeInfo(branch, depth, Arrays.asList(leftElementType, rightElementType))
     );
 
@@ -69,12 +67,17 @@ public void visit(ListProofBranch branch) {
 
   @Override
   public void visit(ListProofHashNode hashNode) {
-    listProofHashNodesInfo.add(new NodeInfo(hashNode, depth));
+    listProofInfo.get(NodeType.HASHNODE).add(new NodeInfo(hashNode, depth));
   }
 
   @Override
   public void visit(ListProofElement element) {
-    listProofElementsInfo.add(new NodeInfo(element, depth));
+    listProofInfo.get(NodeType.ELEMENT).add(new NodeInfo(element, depth));
+  }
+
+  @Override
+  public void visit(ListProofOfAbsence listProofOfAbsence) {
+    listProofInfo.get(NodeType.ABSENCE).add(new NodeInfo(listProofOfAbsence, depth));
   }
 
   private void visitLeft(ListProofBranch branch, int branchDepth) {
@@ -95,16 +98,19 @@ private int getChildDepth(int branchDepth) {
    * Performs list proof structure checks and assigns proofStatus based on results of these checks.
    */
   private void check() {
-    if (exceedsMaxDepth(listProofElementsInfo)) {
+    if (exceedsMaxDepth(listProofInfo.get(NodeType.ELEMENT))) {
       proofStatus = ListProofStatus.INVALID_ELEMENT_NODE_DEPTH;
-    } else if (exceedsMaxDepth(listProofHashNodesInfo)) {
+    } else if (exceedsMaxDepth(listProofInfo.get(NodeType.HASHNODE))) {
       proofStatus = ListProofStatus.INVALID_HASH_NODE_DEPTH;
-    } else if (hasInvalidNodesDepth(listProofElementsInfo)) {
+    } else if (hasInvalidNodesDepth(listProofInfo.get(NodeType.ELEMENT))) {
       proofStatus = ListProofStatus.INVALID_NODE_DEPTH;
-    } else if (hasNoElementNodes(listProofBranchesInfo, listProofElementsInfo)) {
+    } else if (hasNoElementNodes(listProofInfo.get(NodeType.BRANCH),
+        listProofInfo.get(NodeType.ELEMENT))) {
       proofStatus = ListProofStatus.INVALID_TREE_NO_ELEMENTS;
-    } else if (hashNodesLimitExceeded(listProofBranchesInfo)) {
+    } else if (hashNodesLimitExceeded(listProofInfo.get(NodeType.BRANCH))) {
       proofStatus = ListProofStatus.INVALID_HASH_NODES_COUNT;
+    } else if (hasInvalidAbsentNodes()) {
+      proofStatus = ListProofStatus.INVALID_PROOF_OF_ABSENCE;
     }
   }
 
@@ -120,6 +126,8 @@ private NodeType getNodeType(ListProofNode node) {
       return NodeType.ELEMENT;
     } else if (node instanceof ListProofHashNode) {
       return NodeType.HASHNODE;
+    } else if (node instanceof ListProofOfAbsence) {
+      return NodeType.ABSENCE;
     } else {
       throw new RuntimeException("Unknown tree node type: " + node);
     }
@@ -131,7 +139,7 @@ private NodeType getNodeType(ListProofNode node) {
    * @param nodes collection of node info
    * @return true if node depth is invalid
    */
-  private boolean exceedsMaxDepth(List<NodeInfo> nodes) {
+  private boolean exceedsMaxDepth(Collection<NodeInfo> nodes) {
     return nodes.stream()
         .anyMatch(nodeInfo -> nodeInfo.getDepth() > MAX_NODE_DEPTH);
   }
@@ -142,7 +150,7 @@ private boolean exceedsMaxDepth(List<NodeInfo> nodes) {
    * @param nodes collection of node info
    * @return true if node depths vary
    */
-  private boolean hasInvalidNodesDepth(List<NodeInfo> nodes) {
+  private boolean hasInvalidNodesDepth(Collection<NodeInfo> nodes) {
     long depthsCount = nodes.stream()
         .map(NodeInfo::getDepth)
         .distinct()
@@ -157,7 +165,7 @@ private boolean hasInvalidNodesDepth(List<NodeInfo> nodes) {
    * @param nodes collection of node info
    * @return true if node depths vary
    */
-  private boolean hasNoElementNodes(List<NodeInfo> branches, List<NodeInfo> nodes) {
+  private boolean hasNoElementNodes(Collection<NodeInfo> branches, Collection<NodeInfo> nodes) {
     return branches.size() > 0 && nodes.size() == 0;
   }
 
@@ -167,7 +175,7 @@ private boolean hasNoElementNodes(List<NodeInfo> branches, List<NodeInfo> nodes)
    * @param branches collection of branches info
    * @return true if branch contains only hash nodes.
    */
-  private boolean hashNodesLimitExceeded(List<NodeInfo> branches) {
+  private boolean hashNodesLimitExceeded(Collection<NodeInfo> branches) {
     return branches.stream()
         .anyMatch(this::invalidBranch);
   }
@@ -181,6 +189,26 @@ private boolean invalidBranch(NodeInfo branch) {
         .allMatch(nodeType -> (nodeType == NodeType.HASHNODE) || (nodeType == NodeType.NONE));
   }
 
+  /**
+   * Returns true if this proof is a proof of absence and doesn't have a valid structure:
+   * contains more than one node of absence, or contains any nodes other than a node of absence,
+   * or the node of absence has non-zero depth.
+   */
+  private boolean hasInvalidAbsentNodes() {
+    Collection<NodeInfo> absentNodes = listProofInfo.get(NodeType.ABSENCE);
+    int absentNodesSize = absentNodes.size();
+    if (absentNodesSize > 1) {
+      return true;
+    } else if (absentNodesSize == 1) {
+      boolean singleNodeTree = listProofInfo.get(NodeType.BRANCH).isEmpty()
+          && listProofInfo.get(NodeType.HASHNODE).isEmpty()
+          && listProofInfo.get(NodeType.ELEMENT).isEmpty();
+      return !singleNodeTree || absentNodes.stream().allMatch(node -> node.getDepth() != 0);
+    } else {
+      return false;
+    }
+  }
+
   /**
    * Returns proof status.
    */
@@ -238,6 +266,6 @@ List<NodeType> getChildElementsTypes() {
    * Enum used to identify tree node type.
    */
   private enum NodeType {
-    BRANCH, ELEMENT, HASHNODE, NONE
+    BRANCH, ELEMENT, HASHNODE, ABSENCE, NONE
   }
 }

exonum-java-binding/common/src/main/java/com/exonum/binding/common/proofs/list/ListProofVisitor.java

@@ -23,4 +23,6 @@ public interface ListProofVisitor {
   void visit(ListProofHashNode listProofHashNode);
 
   void visit(ListProofElement value);
+
+  void visit(ListProofOfAbsence listProofOfAbsence);
 }

exonum-java-binding/common/src/test/java/com/exonum/binding/common/proofs/list/ListProofStructureValidatorTest.java

@@ -100,6 +100,15 @@ void visit_ProofRightValue() {
     assertTrue(validator.isValid());
   }
 
+  @Test
+  void visit_ProofOfAbsence() {
+    ListProofNode root = new ListProofOfAbsence(H1);
+
+    validator = createListProofStructureValidator(root);
+
+    assertTrue(validator.isValid());
+  }
+
   @Test
   void visit_InvalidTreeHasNoElements() {
     ListProofNode left = new ListProofHashNode(H1);
@@ -218,6 +227,22 @@ void visit_InvalidBranchHasMissingRightElement() {
     assertFalse(validator.isValid());
   }
 
+  @Test
+  void visit_InvalidProofOfAbsence() {
+    ListProofBranch root = new ListProofBranch(
+        new ListProofBranch(
+            leafOf(V1),
+            // Having proof of absence not as a proof tree root is not allowed
+            new ListProofOfAbsence(H1)
+        ),
+        new ListProofHashNode(H2)
+    );
+
+    validator = createListProofStructureValidator(root);
+
+    assertThat(validator.getProofStatus(), is(ListProofStatus.INVALID_PROOF_OF_ABSENCE));
+  }
+
   private ListProofStructureValidator createListProofStructureValidator(ListProofNode listProof) {
     return new ListProofStructureValidator(listProof);
   }

exonum-java-binding/core/rust/src/storage/proof_list_index.rs

@@ -14,7 +14,7 @@
 
 use exonum::crypto::Hash;
 use exonum_merkledb::{
-    proof_list_index::{ListProof, ProofListIndexIter},
+    proof_list_index::{ListProof, ProofListIndexIter, ProofOfAbsence},
     Fork, ObjectHash, ProofListIndex, Snapshot,
 };
 use jni::{
@@ -402,8 +402,8 @@ fn make_java_proof<'a>(env: &JNIEnv<'a>, proof: &ListProof<Value>) -> Result<JOb
             make_java_proof_branch(env, left, right)
         }
         ListProof::Leaf(ref value) => make_java_proof_element(env, value),
-        ListProof::Absent(_) => {
-            unimplemented!("The ProofOfAbsence structure is not public for the moment")
+        ListProof::Absent(ref proof_of_absence) => {
+            make_java_proof_of_absence(env, proof_of_absence)
         }
     }
 }
@@ -442,3 +442,15 @@ fn make_java_hash_node<'a>(env: &JNIEnv<'a>, hash: &Hash) -> Result<JObject<'a>>
         &[hash.as_obj().into()],
     )
 }
+
+fn make_java_proof_of_absence<'a>(
+    env: &JNIEnv<'a>,
+    proof_of_absence: &ProofOfAbsence,
+) -> Result<JObject<'a>> {
+    let hash = env.auto_local(utils::convert_hash(env, &proof_of_absence.merkle_root())?.into());
+    env.new_object(
+        "com/exonum/binding/common/proofs/list/ListProofOfAbsence",
+        "([B)V",
+        &[hash.as_obj().into()],
+    )
+}