deletion is working and tested

Author: Davidson-Souza

src/forest_test.c

@@ -16,6 +16,15 @@ typedef struct {
   size_t preimage_count;
 } add_test_data;
 
+typedef struct {
+  uint8_t expected_roots[10][32];
+  size_t expected_roots_len;
+  uint64_t *leaf_preimages;
+  size_t preimage_count;
+  uint64_t *target_values;
+  size_t n_target_values;
+} deletion_test_data;
+
 #define True 1
 #define False 0
 
@@ -137,6 +146,7 @@ void test_add_single() {
   ASSERT_ARRAY_EQ(root->hash.hash, leaf.hash, 32);
   TEST_END;
 }
+
 void test_add_two() {
   TEST_BEGIN("add_two");
   utreexo_node_hash leaf = {.hash = {0}};
@@ -230,6 +240,7 @@ void test_from_test_cases(void) {
 }
 
 void test_grab_node() {
+  TEST_BEGIN("grab node");
   struct utreexo_forest_file *file = NULL;
   utreexo_forest_file_init(&file, "test_grab_node.bin");
   const unsigned char *expected = (unsigned char[]){
@@ -251,6 +262,170 @@ void test_grab_node() {
   utreexo_forest_node *node = NULL, *sibling = NULL, *parent = NULL;
   grab_node(&p, &node, &sibling, &parent, 5);
   ASSERT_ARRAY_EQ(node->hash.hash, expected, 32);
+  TEST_END;
+}
+
+void test_delete_some() {
+  TEST_BEGIN("delete single");
+  struct utreexo_forest_file *file = NULL;
+  utreexo_forest_file_init(&file, "test_delete_some.bin");
+  const uint8_t expected_root[32] = {
+      0x55, 0xe9, 0x91, 0x3e, 0xda, 0xc7, 0x5c, 0xbf, 0x92, 0x30, 0x1c,
+      0xe5, 0xf9, 0x95, 0xdf, 0x40, 0xd1, 0xe9, 0x3c, 0x0d, 0xde, 0x87,
+      0x91, 0xbd, 0x75, 0x7a, 0x0f, 0x28, 0xbc, 0x02, 0xf4, 0xa5};
+  struct utreexo_forest p = {
+      .data = file,
+      .roots = {0},
+      .nLeaf = 0,
+  };
+
+  for (size_t i = 0; i < 8; ++i) {
+    utreexo_node_hash leaf = {.hash = {0}};
+    hash_from_u8(leaf.hash, i);
+    utreexo_forest_add(&p, leaf);
+  }
+
+  delete_single(&p, 0);
+  delete_single(&p, 2);
+  delete_single(&p, 9);
+  ASSERT_ARRAY_EQ(p.roots[3]->hash.hash, expected_root, 32);
+  TEST_END;
+}
+
+static deletion_test_data test_cases[] =
+    {{
+         .expected_roots = {{0x33, 0x2c, 0x30, 0x61, 0x88, 0xd3, 0x5e, 0xb2,
+                             0x2e, 0xcb, 0x05, 0xd8, 0xc0, 0x04, 0x46, 0xcd,
+                             0x6a, 0x7a, 0x47, 0x5f, 0x66, 0x15, 0xf4, 0x62,
+                             0x07, 0xcf, 0xaa, 0x71, 0x3b, 0xb3, 0xe6, 0x2c}},
+         .expected_roots_len = 1,
+         .leaf_preimages = (uint64_t[]){0, 1, 2, 3, 4, 5, 6, 7},
+         .preimage_count = 8,
+         .target_values = (uint64_t[]){1, 7},
+         .n_target_values = 2,
+     },
+     {
+         .expected_roots = {{0x3b, 0x8b, 0x6e, 0xb2, 0x31, 0x43, 0x70, 0x92,
+                             0xf6, 0xd9, 0xfb, 0xf8, 0xa0, 0x69, 0x6b, 0x7c,
+                             0xb4, 0x46, 0xe4, 0x0f, 0x1b, 0xf8, 0x1d, 0xdb,
+                             0x23, 0xd3, 0xea, 0xbb, 0x30, 0x80, 0xb0, 0xdd}},
+         .expected_roots_len = 1,
+         .leaf_preimages = (uint64_t[]){0, 1, 2, 3, 4, 5, 6, 7},
+         .preimage_count = 8,
+         .target_values = (uint64_t[]){1, 5, 7},
+         .n_target_values = 3,
+     },
+     {
+         .expected_roots = {{0x37, 0x96, 0x8e, 0xf7, 0x3d, 0x30, 0xdd, 0xa3,
+                             0x8e, 0xde, 0x83, 0x57, 0xd6, 0x65, 0x93, 0xc7,
+                             0x2a, 0xcd, 0x4f, 0x0e, 0xb9, 0xf7, 0xa1, 0xa9,
+                             0xac, 0xfe, 0xb7, 0xde, 0x85, 0x0c, 0x05, 0xb4},
+                            {0x3c, 0xb9, 0x20, 0xc1, 0x13, 0xe8, 0xce, 0x3a,
+                             0xce, 0x35, 0xfc, 0x83, 0x5e, 0x6f, 0xf8, 0x3a,
+                             0x65, 0x66, 0xc4, 0xc1, 0x27, 0xea, 0x67, 0xee,
+                             0xbc, 0x0f, 0x5d, 0x25, 0xd2, 0x29, 0x5e, 0xa2}},
+         .expected_roots_len = 2,
+         .leaf_preimages = (uint64_t[]){0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                                        10, 11, 12, 13, 14, 15, 16, 17, 18, 19},
+         .preimage_count = 20,
+         .target_values = (uint64_t[]){1, 10},
+         .n_target_values = 2,
+     },
+     {
+         .expected_roots = {{0x37, 0x96, 0x8e, 0xf7, 0x3d, 0x30, 0xdd, 0xa3,
+                             0x8e, 0xde, 0x83, 0x57, 0xd6, 0x65, 0x93, 0xc7,
+                             0x2a, 0xcd, 0x4f, 0x0e, 0xb9, 0xf7, 0xa1, 0xa9,
+                             0xac, 0xfe, 0xb7, 0xde, 0x85, 0x0c, 0x05, 0xb4},
+                            {0x21, 0x32, 0x6d, 0x8a, 0xeb, 0xeb, 0x6e, 0xf7,
+                             0xbc, 0x02, 0xf4, 0x0b, 0xdf, 0x77, 0x8a, 0x02,
+                             0xba, 0x1c, 0x83, 0x6b, 0x25, 0x7f, 0x94, 0x6a,
+                             0xe2, 0x1c, 0xab, 0x2a, 0x6f, 0x95, 0xfa, 0x18}},
+         .expected_roots_len = 2,
+         .leaf_preimages = (uint64_t[]){0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+                                        10, 11, 12, 13, 14, 15, 16, 17, 18, 19},
+         .preimage_count = 20,
+         .target_values = (uint64_t[]){1, 10, 16},
+         .n_target_values = 3,
+     },
+     {
+         .expected_roots =
+             {{0xe4, 0x67, 0x6b, 0xa6, 0x3c, 0x94, 0x58, 0x8b, 0xcb, 0x40, 0x83,
+               0xe5, 0x47, 0x40, 0x63, 0xb6, 0x33, 0xaa, 0x63, 0x18, 0x97, 0xdd,
+               0xaa, 0xbd, 0xe7, 0xa4, 0xda, 0x45, 0x93, 0x68, 0x90, 0xcb},
+              {0xca, 0xe9, 0x21, 0xbb, 0xf6, 0x49, 0xd4, 0xdd, 0x84, 0xc2, 0x52,
+               0xc5, 0x5c, 0x54, 0x0e, 0x2e, 0x30, 0xc6, 0xc0, 0x0c, 0xb0, 0x89,
+               0xd9, 0x70, 0x4b, 0xd6, 0x13, 0xec, 0xea, 0x30, 0x86, 0x43},
+              {0x55, 0xd0, 0xa0, 0xef, 0x8f, 0x5c, 0x25, 0xa9, 0xda, 0x26, 0x6b,
+               0x36, 0xc0, 0xc5, 0xf4, 0xb3, 0x10, 0x08, 0xec, 0xe8, 0x2d, 0xf2,
+               0x51, 0x2c, 0x89, 0x66, 0xbd, 0xdc, 0xc2, 0x7a, 0x66, 0xa0},
+              {0x4d, 0x7b, 0x3e, 0xf7, 0x30, 0x0a, 0xcf, 0x70, 0xc8, 0x92, 0xd8,
+               0x32, 0x7d, 0xb8, 0x27, 0x2f, 0x54, 0x43, 0x4a, 0xdb, 0xc6, 0x1a,
+               0x4e, 0x13, 0x0a, 0x56, 0x3c, 0xb5, 0x9a, 0x0d, 0x0f, 0x47}},
+         .expected_roots_len = 4,
+         .leaf_preimages =
+             (uint64_t[]){0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
+         .preimage_count = 15,
+         .target_values = (uint64_t[]){1, 10, 5},
+         .n_target_values = 3,
+     },
+     {
+         .expected_roots =
+             {{0x35, 0x2d, 0x0d, 0x5e, 0x17, 0x23, 0x16, 0xe7, 0x3b, 0x6d, 0x0d,
+               0x40, 0x60, 0x5a, 0xd4, 0x11, 0xc7, 0x9b, 0x7e, 0x7c, 0x1e, 0xd0,
+               0xb4, 0x52, 0x9c, 0x56, 0x5f, 0x08, 0x05, 0x7b, 0xc4, 0xa8},
+              {0xca, 0xe9, 0x21, 0xbb, 0xf6, 0x49, 0xd4, 0xdd, 0x84, 0xc2, 0x52,
+               0xc5, 0x5c, 0x54, 0x0e, 0x2e, 0x30, 0xc6, 0xc0, 0x0c, 0xb0, 0x89,
+               0xd9, 0x70, 0x4b, 0xd6, 0x13, 0xec, 0xea, 0x30, 0x86, 0x43},
+              {0x55, 0xd0, 0xa0, 0xef, 0x8f, 0x5c, 0x25, 0xa9, 0xda, 0x26, 0x6b,
+               0x36, 0xc0, 0xc5, 0xf4, 0xb3, 0x10, 0x08, 0xec, 0xe8, 0x2d, 0xf2,
+               0x51, 0x2c, 0x89, 0x66, 0xbd, 0xdc, 0xc2, 0x7a, 0x66, 0xa0},
+              {0x4d, 0x7b, 0x3e, 0xf7, 0x30, 0x0a, 0xcf, 0x70, 0xc8, 0x92, 0xd8,
+               0x32, 0x7d, 0xb8, 0x27, 0x2f, 0x54, 0x43, 0x4a, 0xdb, 0xc6, 0x1a,
+               0x4e, 0x13, 0x0a, 0x56, 0x3c, 0xb5, 0x9a, 0x0d, 0x0f, 0x47}},
+         .expected_roots_len = 4,
+         .leaf_preimages =
+             (uint64_t[]){0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
+         .preimage_count = 15,
+         .target_values = (uint64_t[]){10, 5, 16},
+         .n_target_values = 3,
+     }};
+
+void test_deletion_cases() {
+  deletion_test_data *test_case;
+  size_t n_tests = sizeof(test_cases) / sizeof(deletion_test_data);
+  for (test_case = &test_cases[0]; test_case != (test_cases + n_tests);
+       ++test_case) {
+    struct utreexo_forest_file *file = NULL;
+    utreexo_forest_file_init(&file, "test_deletion_cases.bin");
+    struct utreexo_forest p = {
+        .data = file,
+        .roots = {0},
+        .nLeaf = 0,
+    };
+    for (size_t i = 0; i < test_case->preimage_count; ++i) {
+      utreexo_node_hash leaf = {.hash = {0}};
+      hash_from_u8(leaf.hash, test_case->leaf_preimages[i]);
+      utreexo_forest_add(&p, leaf);
+    }
+    for (size_t i = 0; i < test_case->n_target_values; ++i) {
+      delete_single(&p, test_case->target_values[i]);
+    }
+    size_t n_mached = 0;
+    size_t expected_root_ctr = 0;
+    for (int root = 63; root >= 0; --root) {
+      if (expected_root_ctr > test_case->expected_roots_len)
+        break;
+      if (p.roots[root] == NULL)
+        continue;
+      if (memcmp(test_case->expected_roots[expected_root_ctr],
+                 p.roots[root]->hash.hash, 32) == 0) {
+        ++n_mached;
+        ++expected_root_ctr;
+      }
+    }
+
+    assert(test_case->expected_roots_len == n_mached);
+  }
 }
 
 int main() {
@@ -260,5 +435,7 @@ int main() {
   test_add_many();
   test_from_test_cases();
   test_grab_node();
+  test_delete_some();
+  test_deletion_cases();
   return 0;
 }

src/map_forest_impl.h

@@ -77,9 +77,10 @@ static inline void grab_node(struct utreexo_forest *f,
 
     pparent = pnode;
 
-    if (pnode->right_child == NULL)
+    if (pnode->right_child == NULL) {
+      pnode = NULL;
       break;
-
+    }
     if (mask & pos) {
       pnode = pparent->right_child;
       psibling = pparent->left_child;
@@ -108,23 +109,30 @@ static inline void recompute_parent_hash(utreexo_forest_node *origin) {
   }
 }
 
-static inline void delete_single(struct utreexo_forest *f, uint64_t pos) {
+static inline int delete_single(struct utreexo_forest *f, uint64_t pos) {
   utreexo_forest_node *pnode, *psibling, *pparent;
 
   node_offset offset = detect_offset(pos, f->nLeaf);
   grab_node(f, &pnode, &psibling, &pparent, pos);
 
-  if (pparent == NULL)
+  if (!pnode)
+    return -1;
+
+  if (pparent == NULL) {
     f->roots[offset.tree] = NULL;
+    return 0;
+  }
 
   if (pparent->parent != NULL) {
     if (pparent->parent->right_child == pparent)
       pparent->parent->right_child = psibling;
     else
       pparent->parent->left_child = psibling;
-    return;
+  } else {
+    f->roots[offset.tree] = psibling;
   }
-  f->roots[offset.tree] = psibling;
+  recompute_parent_hash(psibling);
+  return 0;
 }
 
 #endif

src/mmap_forest.h

@@ -28,4 +28,19 @@ static inline void utreexo_forest_add(struct utreexo_forest *p,
 /* Frees a forest. */
 static inline void utreexo_forest_free(struct utreexo_forest *p);
 
+/* Deletes a single node from a forest.
+ *
+ * This function returns an integer representing whether the operations was
+ * successful. 0 means success, -1 means this node doesn't exist in the current
+ * forest
+ */
+static inline int delete_single(struct utreexo_forest *f, uint64_t pos);
+
+/* Walks up the tree and recompute the node hashes */
+static inline void recompute_parent_hash(utreexo_forest_node *origin);
+
+static inline void grab_node(struct utreexo_forest *f,
+                             utreexo_forest_node **node,
+                             utreexo_forest_node **sibling,
+                             utreexo_forest_node **parent, uint64_t pos);
 #endif // MMAP_FOREST_H