#75 Update smt region calculation

Author: martti007

src/main/java/org/unicitylabs/sdk/smt/SparseMerkleTreePathUtils.java

@@ -1,29 +1,46 @@
 package org.unicitylabs.sdk.smt;
 
 import java.math.BigInteger;
+import java.util.Objects;
 
 /**
  * Path utilities for the radix sparse Merkle trees.
  */
 public final class SparseMerkleTreePathUtils {
 
+  /**
+   * Region size in bytes: the SMT key length, since the region holds a full 256-bit key prefix. A
+   * fixed protocol constant that must match the JS SDK; it is not a tunable parameter.
+   */
+  private static final int REGION_LENGTH = 32;
+
   private SparseMerkleTreePathUtils() {
   }
 
   /**
-   * Region committed by an interior node: the node's {@code depth}-bit key prefix packed into 32
-   * bytes least-significant-byte-first. {@code path} is the absolute node/key path (leading
-   * sentinel bit at {@code depth}); its low {@code depth} bits are the prefix.
+   * Region committed by an interior node: the `depth`-bit common prefix of all leaves in the node's
+   * sub-tree. The `i`th lowest bit of path will be the `i mod 8`th lowest bit in the `i div 8`th
+   * byte of the returned 32-byte array (so the packing is little-endian); the remaining bits of the array
+   * are set to zero.
    *
    * @param path absolute node or key path
    * @param depth bifurcation depth of the node
    * @return 32-byte region
+   * @throws NullPointerException if {@code path} is {@code null}
    */
   public static byte[] pathToRegion(BigInteger path, int depth) {
-    BigInteger bits = path.and(BigInteger.ONE.shiftLeft(depth).subtract(BigInteger.ONE));
-    byte[] region = new byte[32];
-    for (int j = 0; j * 8 < depth; j++) {
-      region[j] = (byte) bits.shiftRight(8 * j).and(BigInteger.valueOf(0xff)).intValue();
+    Objects.requireNonNull(path, "path cannot be null");
+
+    byte[] region = new byte[REGION_LENGTH];
+    int fullBytes = depth / 8;
+    int remainderBits = depth % 8;
+
+    BigInteger bits = path;
+    for (int j = 0; j < fullBytes && j < REGION_LENGTH; j++, bits = bits.shiftRight(8)) {
+      region[j] = bits.byteValue();
+    }
+    if (remainderBits > 0 && fullBytes < REGION_LENGTH) {
+      region[fullBytes] = (byte) (bits.byteValue() & ((1 << remainderBits) - 1));
     }
     return region;
   }

src/test/java/org/unicitylabs/sdk/smt/radix/SparseMerkleTreeTest.java

@@ -44,4 +44,30 @@ void deepSplitAtDepth255VerifiesWithRegion() throws Exception {
       Assertions.assertTrue(certificate.verify(key, value, root.getHash()));
     }
   }
+
+  @Test
+  void everyLeafVerifiesThroughNonZeroRegions() throws Exception {
+    int[] firstBytes = {0b10010000, 0b00000000, 0b00010000, 0b10000000, 0b01100000, 0b00010100};
+    byte[][] keys = new byte[firstBytes.length][];
+    byte[][] values = new byte[firstBytes.length][];
+    SparseMerkleTree tree = new SparseMerkleTree(HashAlgorithm.SHA256);
+    for (int i = 0; i < firstBytes.length; i++) {
+      byte[] key = new byte[32];
+      key[0] = (byte) firstBytes[i];
+      byte[] value = new byte[32];
+      value[0] = (byte) (i + 1);
+      keys[i] = key;
+      values[i] = value;
+      tree.addLeaf(key, value);
+    }
+
+    FinalizedNodeBranch root = tree.calculateRoot();
+
+    for (int i = 0; i < keys.length; i++) {
+      InclusionCertificate certificate = InclusionCertificate.create(root, keys[i]);
+      StateId key = StateId.fromCbor(CborSerializer.encodeByteString(keys[i]));
+      DataHash value = new DataHash(HashAlgorithm.SHA256, values[i]);
+      Assertions.assertTrue(certificate.verify(key, value, root.getHash()));
+    }
+  }
 }