wip proof

Author: abenso

app/src/metadata_proof.c

@@ -70,6 +70,29 @@ static uint8_t log2i(uint32_t input) {
     return log2;
 }
 
+/**
+ * @brief Calculate the largest power of two which is strictly less than the argument.
+ *
+ * @param n The input value.
+ * @return The largest power of two which is strictly less than the argument.
+ */
+static uint32_t next_smaller_po2(uint32_t n) {
+    if ((n & (n - 1)) == 0) {
+        return n >> 1;
+    }
+    // Find the next power of two greater than or equal to n
+    n |= n >> 1;
+    n |= n >> 2;
+    n |= n >> 4;
+    n |= n >> 8;
+    n |= n >> 16;
+    n += 1;
+    
+    // Return the next smaller power of two
+    return n >> 1;
+}
+
+
 /**
  * @brief Compute the number of left siblings needed for a given node index.
  *
@@ -82,14 +105,42 @@ static uint32_t compute_num_left_siblings(uint32_t node_idx) {
     uint32_t num_left_siblings = 0;
     uint32_t start_idx = node_idx;
     while (start_idx != 0) {
-        if (start_idx & 1 != 0) {
+        if ((start_idx & 1) != 0) {
             num_left_siblings += 1;
         }
         start_idx >>= 1;
     }
     return num_left_siblings;
 }
 
+/**
+ * @brief Compute the size of the tree needed to prove a given index.
+ *
+ * @param num_right_siblings The number of right siblings needed.
+ * @param index_of_last_included_leaf The index of the last included leaf.
+ * @param tree_size The output buffer for the computed tree size.
+ * @return parser_error_t Error code indicating the result of the operation.
+ */
+parser_error_t compute_tree_size(uint32_t num_right_siblings, uint32_t index_of_last_included_leaf, uint32_t* tree_size) {
+    uint32_t index_of_final_node = index_of_last_included_leaf;
+    uint32_t mask = 1;
+    uint32_t remaining_right_siblings = num_right_siblings;
+
+    while (remaining_right_siblings > 0) {
+        if ((index_of_final_node & mask) == 0) {
+            index_of_final_node |= mask;
+            remaining_right_siblings--;
+        }
+        mask <<= 1;
+        if (index_of_final_node == UINT32_MAX) {
+            return parser_value_out_of_range;
+        }
+    }
+
+    *tree_size = index_of_final_node + 1;
+    return parser_ok;
+}
+
 /**
  * @brief Check if a given index is a descendant of a leaf in a binary tree.
  *
@@ -141,6 +192,7 @@ static bool isLemma(uint32_t index, uint32_t leaf) {
  * @return parser_error_t Error code indicating the result of the operation.
  */
 static parser_error_t hash_leaf(proof_t *proof) {
+    CHECK_INPUT(proof);
     // const uint16_t initialOffset = proof->registry.registry.offset;
     // CHECK_ERROR(readType(&proof->registry.registry, &proof->lastEntry));
 
@@ -149,12 +201,7 @@ static parser_error_t hash_leaf(proof_t *proof) {
     crypto_sha256_init();
     crypto_sha256_update(&LEAF_PREFIX, 1);
     crypto_sha256_update(proof->registry.registry.buffer.ptr, proof->registry.registry.buffer.len);
-    crypto_sha256_final(proof->hash, CX_SHA256_SIZE);
-
-    bytes_t buffer = {0};
-    buffer.ptr = proof->hash;
-    buffer.len = CX_SHA256_SIZE;
-    print_buffer(&buffer, "hash leaf");
+    crypto_sha256_final(proof->hash_leaf, CX_SHA256_SIZE);
 
     return parser_ok;
 }
@@ -266,6 +313,80 @@ static parser_error_t get_hash(uint32_t index, proof_t *proof) {
     return freeStack();
 }
 
+static parser_error_t check_range_proof_inner(proof_t *proof, uint32_t start_index, uint32_t subtrie_size, uint32_t offset) {
+    CHECK_INPUT(proof);
+
+    uint32_t split_index = next_smaller_po2(subtrie_size);
+    print_u32("split_point:", split_index);
+
+    uint32_t leaves_end_idx = (proof->indices.entries + start_index) - 1;
+    print_u32("leaves_end_idx:", leaves_end_idx);
+
+    // Check right subtree
+    bytes_t right = {0};
+    if (leaves_end_idx >= (split_index + offset)) {
+        uint32_t right_subtrie_size = subtrie_size - split_index;
+        if (right_subtrie_size == 1) {
+            right.ptr = proof->hash_leaf;
+            right.len = CX_SHA256_SIZE;
+            print_buffer(&right, "right inside if true");
+        } else {
+            print_u32("right inside else:", right_subtrie_size);
+            CHECK_ERROR(check_range_proof_inner(
+                proof,
+                start_index,
+                right_subtrie_size,
+                offset + split_index
+            ));
+            right.ptr = proof->hash;
+            right.len = CX_SHA256_SIZE;
+        }
+    } else {
+        if (proof->lemmas.last_index == 0) {
+            return parser_value_out_of_range;
+        }
+        right.ptr = proof->lemmas.lemmas.buffer.ptr + CX_SHA256_SIZE * proof->lemmas.last_index;
+        right.len = CX_SHA256_SIZE;
+        proof->lemmas.last_index--;
+        print_buffer(&right, "proof right outside if else");
+    }
+
+    // Check left subtree
+    bytes_t left = {0};
+    if (start_index < (split_index + offset)) {
+        uint32_t left_subtrie_size = split_index;
+        if (left_subtrie_size == 1) {
+            left.ptr = proof->hash_leaf;
+            left.len = CX_SHA256_SIZE;
+            print_buffer(&left, "left inside if true");
+        } else {
+            print_u32("left inside else:", left_subtrie_size);
+            CHECK_ERROR(check_range_proof_inner(
+                proof,
+                start_index,
+                left_subtrie_size,
+                offset
+            ));
+            left.ptr = proof->hash;
+            left.len = CX_SHA256_SIZE;
+        }
+    } else {
+        left.ptr = proof->lemmas.lemmas.buffer.ptr + CX_SHA256_SIZE * proof->lemmas.last_index;
+        left.len = CX_SHA256_SIZE;
+        if (proof->lemmas.last_index > 0) {
+            proof->lemmas.last_index--;
+        }
+        print_buffer(&left, "proof left outside if else");
+    }
+
+    print_string("MERGING LEFT AND RIGHT");
+    print_buffer(&left, "left outside if else");
+    print_buffer(&right, "right outside if else");
+    merge_branches(left.ptr, right.ptr, proof->hash);
+
+    return parser_ok;
+}
+
 /**
  * @brief Compute the hash for a given index in the proof.
  *
@@ -274,42 +395,33 @@ static parser_error_t get_hash(uint32_t index, proof_t *proof) {
  * @return parser_error_t Error code indicating the result of the operation.
  */
 static parser_error_t get_hash_single_proof(uint32_t index, proof_t *proof) {
-    const uint16_t tmpOffset = proof->indices.indices.offset;
-    uint32_t nextIndex = 0;
-    CHECK_ERROR(get_next_index(&proof->indices.indices, &nextIndex));
+    CHECK_INPUT(proof);
 
-    // Check if this index is used
-    if (index == nextIndex) {
-        CHECK_ERROR(hash_leaf(proof));
-        return parser_ok;
-    }
+    // Compute hash of leaf data
+    CHECK_ERROR(hash_leaf(proof));
+    bytes_t buffer = {0};
+    buffer.ptr = proof->hash_leaf;
+    buffer.len = CX_SHA256_SIZE;
+    print_buffer(&buffer, "hash leaf");
 
-    // If nextIndex doesn't match the requested, restore the offset
-    proof->indices.indices.offset = tmpOffset;
+    // Get the number of left siblings needed
+    uint32_t num_left_siblings = compute_num_left_siblings(index);
 
-    // Check if this index is a lemma
-    if (isLemma(index, nextIndex)) {
-        CTX_CHECK(&proof->lemmas.lemmas, CX_SHA256_SIZE);
-        memcpy(proof->hash, proof->lemmas.lemmas.buffer.ptr + proof->lemmas.lemmas.offset, CX_SHA256_SIZE);
-        proof->lemmas.lemmas.offset += CX_SHA256_SIZE;
-        return parser_ok;
+    // Get the number of right siblings needed
+    if (num_left_siblings > proof->lemmas.entries) {
+        return parser_value_out_of_range;
     }
+    uint32_t num_right_siblings = proof->lemmas.entries - num_left_siblings;
+    print_u32("num_left_siblings:", num_left_siblings);
+    print_u32("num_right_siblings:", num_right_siblings);
 
-    CHECK_ERROR(checkStack());
+    uint32_t tree_size = 0;
+    CHECK_ERROR(compute_tree_size(num_right_siblings, index, &tree_size));
+    print_u32("tree_size:", tree_size);
 
-    // Go and find left and right children
-    uint8_t leftHash[CX_SHA256_SIZE] = {0};
-    uint8_t rightHash[CX_SHA256_SIZE] = {0};
-
-    CHECK_ERROR(get_hash(get_left_child(index), proof));
-    memcpy(leftHash, proof->hash, CX_SHA256_SIZE);
+    CHECK_ERROR(check_range_proof_inner(proof, index, tree_size, 0));
 
-    CHECK_ERROR(get_hash(get_right_child(index), proof));
-    memcpy(rightHash, proof->hash, CX_SHA256_SIZE);
-
-    merge_branches(leftHash, rightHash, proof->hash);
-
-    return freeStack();
+    return parser_ok;
 }
 
 /**
@@ -336,6 +448,9 @@ parser_error_t get_metadata_digest(metadata_t *metadata, uint8_t metadataDigest[
     CHECK_ERROR(read_u32(&proof.indices.indices, &leaves_start));
     print_u32("leaves_start:", leaves_start);
 
+    CHECK_ERROR(get_hash_single_proof(leaves_start, &proof));
+    memcpy(metadataDigest, proof.hash, CX_SHA256_SIZE);
+
     // // CHECK_ERROR(setInitialConditions(&proof));
     // const uint8_t MAX_ONE_BYTE_COMPACT = 0x3F;
 

app/src/metadata_proof.h

@@ -29,6 +29,7 @@ extern "C" {
 
 typedef struct {
     uint8_t hash[CX_SHA256_SIZE];
+    uint8_t hash_leaf[CX_SHA256_SIZE];
     short_registry_t registry;
     merkle_indices_t indices;
     merkle_lemmas_t lemmas;

app/src/metadata_reader.c

@@ -974,6 +974,7 @@ parser_error_t merkle_proofs_read(parser_context_t *ctx, parser_tx_t *txObj) {
 
     CHECK_ERROR(read_u32(ctx, &txObj->merkle_proofs.shortMetadata.lemmas.entries));
     print_u32("registry_qty:", txObj->merkle_proofs.shortMetadata.lemmas.entries);
+    txObj->merkle_proofs.shortMetadata.lemmas.last_index = txObj->merkle_proofs.shortMetadata.lemmas.entries - 1;
 
     // read short_registry
     txObj->merkle_proofs.shortMetadata.lemmas.lemmas.buffer.ptr = ctx->buffer.ptr + ctx->offset;

app/src/txdefs/merkle_txdef.h

@@ -34,6 +34,7 @@ typedef struct {
 
 typedef struct {
     uint32_t entries;
+    uint32_t last_index;
     parser_context_t lemmas;
 } merkle_lemmas_t;