#79 Change SMT bit ordering

Author: martti007

src/main/java/org/unicitylabs/sdk/api/InclusionCertificate.java

@@ -3,15 +3,11 @@
 import org.unicitylabs.sdk.crypto.hash.DataHash;
 import org.unicitylabs.sdk.crypto.hash.DataHasher;
 import org.unicitylabs.sdk.crypto.hash.HashAlgorithm;
-import org.unicitylabs.sdk.smt.radix.FinalizedBranch;
-import org.unicitylabs.sdk.smt.radix.FinalizedLeafBranch;
 import org.unicitylabs.sdk.smt.SparseMerkleTreePathUtils;
-import org.unicitylabs.sdk.smt.radix.FinalizedNodeBranch;
-import org.unicitylabs.sdk.util.BitString;
+import org.unicitylabs.sdk.smt.radix.SparseMerkleTreeRootNode;
 import org.unicitylabs.sdk.util.HexConverter;
 import org.unicitylabs.sdk.util.LongConverter;
 
-import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -30,35 +26,19 @@ private InclusionCertificate(byte[] bitmap, List<DataHash> siblings) {
     this.siblings = siblings;
   }
 
-  public static InclusionCertificate create(FinalizedNodeBranch root, byte[] key) {
-    FinalizedBranch node = root;
+  public static InclusionCertificate create(SparseMerkleTreeRootNode root, byte[] key) {
+    Objects.requireNonNull(root, "root cannot be null");
 
     ArrayList<DataHash> siblings = new ArrayList<>();
     byte[] bitmap = new byte[InclusionCertificate.BITMAP_SIZE];
-    BigInteger keyPath = BitString.fromBytesReversedLSB(key).toBigInteger();
 
-    while (node != null) {
-      if (node instanceof FinalizedLeafBranch) {
-        FinalizedLeafBranch leaf = (FinalizedLeafBranch) node;
-        if (!Arrays.equals(leaf.getKey(), key)) {
-          throw new RuntimeException(String.format("Leaf not found for key: %s", HexConverter.encode(key)));
-        }
-
-        return new InclusionCertificate(bitmap, siblings);
-      }
-
-      FinalizedNodeBranch nodeBranch = (FinalizedNodeBranch) node;
-      boolean isRight = keyPath.testBit(nodeBranch.getDepth());
-      FinalizedBranch sibling = isRight ? nodeBranch.getLeft() : nodeBranch.getRight();
-      if (sibling != null) {
-        bitmap[nodeBranch.getDepth() / 8] |= (byte) (1 << nodeBranch.getDepth() % 8);
-        siblings.add(sibling.getHash());
-      }
-
-      node = isRight ? nodeBranch.getRight() : nodeBranch.getLeft();
+    for (SparseMerkleTreeRootNode.Sibling sibling : root.getPath(key)) {
+      int depth = sibling.getDepth();
+      bitmap[depth >> 3] |= (byte) (0x80 >> (depth & 7));
+      siblings.add(sibling.getHash());
     }
 
-    throw new RuntimeException("Could not construct inclusion certificate: Invalid path");
+    return new InclusionCertificate(bitmap, siblings);
   }
 
   public static InclusionCertificate decode(byte[] bytes) {
@@ -114,20 +94,17 @@ public boolean verify(StateId leafKey, DataHash leafValue, DataHash expectedRoot
             .update(value)
             .digest();
 
-    BigInteger keyPath = BitString.fromBytesReversedLSB(key).toBigInteger();
-    BigInteger bitmapPath = BitString.fromBytesReversedLSB(this.bitmap).toBigInteger();
-
     int position = this.siblings.size();
     for (int depth = InclusionCertificate.MAX_DEPTH; depth >= 0; depth--) {
-      if (!bitmapPath.testBit(depth)) continue;
+      if (SparseMerkleTreePathUtils.getBitAtDepth(this.bitmap, depth) == 0) continue;
 
       position -= 1;
       if (position < 0) return false;
 
       DataHash sibling = this.siblings.get(position);
 
       byte[] left, right;
-      if (keyPath.testBit(depth)) {
+      if (SparseMerkleTreePathUtils.getBitAtDepth(key, depth) == 1) {
         left = sibling.getData();
         right = hash.getData();
       } else {
@@ -138,7 +115,7 @@ public boolean verify(StateId leafKey, DataHash leafValue, DataHash expectedRoot
       hash = new DataHasher(HashAlgorithm.SHA256)
               .update(new byte[]{0x01})
               .update(LongConverter.encode(depth))
-              .update(SparseMerkleTreePathUtils.pathToRegion(keyPath, depth))
+              .update(SparseMerkleTreePathUtils.regionFromKey(key, depth))
               .update(left)
               .update(right)
               .digest();

src/main/java/org/unicitylabs/sdk/payment/SplitAllocationProof.java

@@ -6,18 +6,12 @@
 import org.unicitylabs.sdk.serializer.cbor.CborDeserializer;
 import org.unicitylabs.sdk.serializer.cbor.CborSerializationException;
 import org.unicitylabs.sdk.serializer.cbor.CborSerializer;
-import org.unicitylabs.sdk.smt.radixsum.FinalizedBranch;
-import org.unicitylabs.sdk.smt.radixsum.FinalizedLeafBranch;
-import org.unicitylabs.sdk.smt.radixsum.FinalizedNodeBranch;
+import org.unicitylabs.sdk.smt.SparseMerkleTreePathUtils;
 import org.unicitylabs.sdk.smt.radixsum.SparseMerkleSumTreeRootNode;
 import org.unicitylabs.sdk.util.BigIntegerConverter;
-import org.unicitylabs.sdk.util.BitString;
-import org.unicitylabs.sdk.util.HexConverter;
 
 import java.math.BigInteger;
 import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
 
@@ -65,37 +59,11 @@ public static SplitAllocationProof create(SparseMerkleSumTreeRootNode root, byte
       throw new IllegalArgumentException("Key must be 32 bytes long.");
     }
 
-    BigInteger keyPath = BitString.fromBytesReversedLSB(key).toBigInteger();
     List<Sibling> siblings = new ArrayList<>();
-
-    boolean isRight = keyPath.testBit(0);
-    FinalizedBranch sibling = isRight ? root.getLeft() : root.getRight();
-    FinalizedBranch node = isRight ? root.getRight() : root.getLeft();
-    if (sibling != null) {
-      siblings.add(new Sibling(0, sibling.getHash(), sibling.getValue()));
+    for (SparseMerkleSumTreeRootNode.Sibling sibling : root.getPath(key)) {
+      siblings.add(new Sibling(sibling.getDepth(), sibling.getHash(), sibling.getValue()));
     }
 
-    while (node instanceof FinalizedNodeBranch) {
-      FinalizedNodeBranch branch = (FinalizedNodeBranch) node;
-      isRight = keyPath.testBit(branch.getDepth());
-      sibling = isRight ? branch.getLeft() : branch.getRight();
-      node = isRight ? branch.getRight() : branch.getLeft();
-      if (sibling != null) {
-        siblings.add(new Sibling(branch.getDepth(), sibling.getHash(), sibling.getValue()));
-      }
-    }
-
-    if (!(node instanceof FinalizedLeafBranch)) {
-      throw new IllegalArgumentException(
-              "Could not construct split allocation proof: invalid path.");
-    }
-
-    if (!Arrays.equals(((FinalizedLeafBranch) node).getKey(), key)) {
-      throw new IllegalArgumentException(
-              String.format("Leaf not found for key: %s", HexConverter.encode(key)));
-    }
-
-    Collections.reverse(siblings);
     return new SplitAllocationProof(siblings);
   }
 
@@ -170,8 +138,6 @@ public Root calculateRoot(byte[] key, byte[] data, BigInteger value) {
       throw new IllegalArgumentException("Data must be 32 bytes long.");
     }
 
-    BigInteger keyPath = BitString.fromBytesReversedLSB(key).toBigInteger();
-
     DataHash hash = new DataHasher(HashAlgorithm.SHA256)
             .update(new byte[]{0x10})
             .update(key)
@@ -186,7 +152,7 @@ public Root calculateRoot(byte[] key, byte[] data, BigInteger value) {
         throw new ArithmeticException("Reconstructed sum overflows 256 bits.");
       }
 
-      boolean isRight = keyPath.testBit(sibling.depth);
+      boolean isRight = SparseMerkleTreePathUtils.getBitAtDepth(key, sibling.depth) == 1;
       DataHash leftHash = isRight ? sibling.hash : hash;
       BigInteger leftValue = isRight ? sibling.sum : sum;
       DataHash rightHash = isRight ? hash : sibling.hash;

src/main/java/org/unicitylabs/sdk/payment/TokenSplit.java

@@ -9,8 +9,7 @@
 import org.unicitylabs.sdk.payment.asset.PaymentAssetCollection;
 import org.unicitylabs.sdk.predicate.EncodedPredicate;
 import org.unicitylabs.sdk.predicate.builtin.BurnPredicate;
-import org.unicitylabs.sdk.smt.BranchExistsException;
-import org.unicitylabs.sdk.smt.LeafOutOfBoundsException;
+import org.unicitylabs.sdk.smt.LeafExistsException;
 import org.unicitylabs.sdk.smt.radixsum.SparseMerkleSumTree;
 import org.unicitylabs.sdk.smt.radixsum.SparseMerkleSumTreeRootNode;
 import org.unicitylabs.sdk.transaction.StateMask;
@@ -43,14 +42,13 @@ private TokenSplit() {
    * @param paymentDataDeserializer decoder for the source token's payment data
    * @param requests per-output mint requests; each carries its own payment data
    * @return burn predicate, burn transaction and split tokens ready to mint
-   * @throws LeafOutOfBoundsException if a leaf path is invalid for merkle tree insertion
-   * @throws BranchExistsException if duplicate branches are inserted into a merkle tree
+   * @throws LeafExistsException if duplicate leaves are inserted into a merkle tree
    */
   public static SplitResult split(
           Token token,
           PaymentDataDeserializer paymentDataDeserializer,
           List<SplitTokenRequest> requests
-  ) throws LeafOutOfBoundsException, BranchExistsException {
+  ) throws LeafExistsException {
     return TokenSplit.split(token, paymentDataDeserializer, requests, StateMask.generate());
   }
 
@@ -64,15 +62,14 @@ public static SplitResult split(
    *     (re-buildable) split supply a deterministically derived mask so the identical burn
    *     transaction can be reconstructed after a failure
    * @return burn predicate, burn transaction and split tokens ready to mint
-   * @throws LeafOutOfBoundsException if a leaf path is invalid for merkle tree insertion
-   * @throws BranchExistsException if duplicate branches are inserted into a merkle tree
+   * @throws LeafExistsException if duplicate leaves are inserted into a merkle tree
    */
   public static SplitResult split(
           Token token,
           PaymentDataDeserializer paymentDataDeserializer,
           List<SplitTokenRequest> requests,
           StateMask burnStateMask
-  ) throws LeafOutOfBoundsException, BranchExistsException {
+  ) throws LeafExistsException {
     Objects.requireNonNull(token, "Token cannot be null");
     Objects.requireNonNull(paymentDataDeserializer, "Payment data deserializer cannot be null");
     Objects.requireNonNull(requests, "Requests cannot be null");

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

@@ -0,0 +1,15 @@
+package org.unicitylabs.sdk.smt;
+
+/**
+ * Exception thrown when a sparse Merkle tree insertion targets a key that is already present in the
+ * tree.
+ */
+public class LeafExistsException extends Exception {
+
+  /**
+   * Create exception indicating that a leaf already exists for the inserted key.
+   */
+  public LeafExistsException() {
+    super("Leaf already exists.");
+  }
+}