jeffro comments

Author: j-berman

src/blockchain_db/blockchain_db.h

@@ -1807,7 +1807,7 @@ class BlockchainDB
    */
   virtual bool for_all_alt_blocks(std::function<bool(const crypto::hash &blkid, const alt_block_data_t &data, const cryptonote::blobdata_ref *blob)> f, bool include_blob = false) const = 0;
 
-  virtual void advance_tree_one_block(const uint64_t block_idx) = 0;
+  virtual void advance_tree(const uint64_t block_idx) = 0;
 
   // TODO: description and make private
   virtual void grow_tree(const uint64_t block_id, std::vector<fcmp_pp::curve_trees::OutputContext> &&new_outputs) = 0;

src/blockchain_db/lmdb/db_lmdb.cpp

@@ -1398,7 +1398,7 @@ void BlockchainLMDB::remove_spent_key(const crypto::key_image& k_image)
   }
 }
 
-void BlockchainLMDB::advance_tree_one_block(const uint64_t blk_idx)
+void BlockchainLMDB::advance_tree(const uint64_t blk_idx)
 {
   LOG_PRINT_L3("BlockchainLMDB::" << __func__);
   check_open();
@@ -1409,21 +1409,24 @@ void BlockchainLMDB::advance_tree_one_block(const uint64_t blk_idx)
   // If we're advancing the genesis block, make sure to initialize the tree
   if (blk_idx == 0)
   {
+    // TODO: include a pre-check that tree meta is empty
+
     // We grow the first blocks with empty outputs, since no outputs in this range should be spendable yet
     for (uint64_t new_blk_idx = blk_idx; new_blk_idx < earliest_last_locked_block; ++new_blk_idx)
     {
       this->grow_tree(new_blk_idx, {});
     }
   }
+  // TODO: include a pre-check that earliest_last_locked_block == last block idx + 1 in tree meta (when blk_idx != 0)
 
   // Now we can advance the tree 1 block
-  auto unlocked_outputs = this->get_outs_at_last_locked_block_id(earliest_last_locked_block);
+  auto unlocked_outputs = this->get_outs_at_last_locked_block_idx(earliest_last_locked_block);
 
   // Grow the tree with outputs that are spendable once the earliest_last_locked_block is in the chain
   this->grow_tree(earliest_last_locked_block, std::move(unlocked_outputs));
 
   // Now that we've used the unlocked leaves to grow the tree, we delete them from the locked outputs table
-  this->del_locked_outs_at_block_id(earliest_last_locked_block);
+  this->del_locked_outs_at_block_idx(earliest_last_locked_block);
 }
 
 void BlockchainLMDB::grow_tree(const uint64_t blk_idx, std::vector<fcmp_pp::curve_trees::OutputContext> &&new_outputs)
@@ -2391,16 +2394,16 @@ bool BlockchainLMDB::audit_layer(const std::unique_ptr<C_CHILD> &c_child,
   return audit_complete;
 }
 
-std::vector<fcmp_pp::curve_trees::OutputContext> BlockchainLMDB::get_outs_at_last_locked_block_id(
-  uint64_t block_id)
+std::vector<fcmp_pp::curve_trees::OutputContext> BlockchainLMDB::get_outs_at_last_locked_block_idx(
+  uint64_t block_idx)
 {
   LOG_PRINT_L3("BlockchainLMDB::" << __func__);
   check_open();
 
   TXN_PREFIX_RDONLY();
   RCURSOR(locked_outputs)
 
-  MDB_val_set(k_block_id, block_id);
+  MDB_val_set(k_block_idx, block_idx);
   MDB_val v_output;
 
   // Get all the locked outputs at the provided block id
@@ -2409,16 +2412,16 @@ std::vector<fcmp_pp::curve_trees::OutputContext> BlockchainLMDB::get_outs_at_las
   MDB_cursor_op op = MDB_SET;
   while (1)
   {
-    int result = mdb_cursor_get(m_cur_locked_outputs, &k_block_id, &v_output, op);
+    int result = mdb_cursor_get(m_cur_locked_outputs, &k_block_idx, &v_output, op);
     if (result == MDB_NOTFOUND)
       break;
     if (result != MDB_SUCCESS)
       throw0(DB_ERROR(lmdb_error("Failed to get next locked outputs: ", result).c_str()));
     op = MDB_NEXT_MULTIPLE;
 
-    const uint64_t blk_id = *(const uint64_t*)k_block_id.mv_data;
-    if (blk_id != block_id)
-      throw0(DB_ERROR(("Blk id " + std::to_string(blk_id) + " not the expected" + std::to_string(block_id)).c_str()));
+    const uint64_t blk_id = *(const uint64_t*)k_block_idx.mv_data;
+    if (blk_id != block_idx)
+      throw0(DB_ERROR(("Blk id " + std::to_string(blk_id) + " not the expected" + std::to_string(block_idx)).c_str()));
 
     const auto range_begin = ((const fcmp_pp::curve_trees::OutputContext*)v_output.mv_data);
     const auto range_end = range_begin + v_output.mv_size / sizeof(fcmp_pp::curve_trees::OutputContext);
@@ -2441,17 +2444,17 @@ std::vector<fcmp_pp::curve_trees::OutputContext> BlockchainLMDB::get_outs_at_las
   return outs;
 }
 
-void BlockchainLMDB::del_locked_outs_at_block_id(uint64_t block_id)
+void BlockchainLMDB::del_locked_outs_at_block_idx(uint64_t block_idx)
 {
   LOG_PRINT_L3("BlockchainLMDB::" << __func__);
   check_open();
   mdb_txn_cursors *m_cursors = &m_wcursors;
 
   CURSOR(locked_outputs)
 
-  MDB_val_set(k_block_id, block_id);
+  MDB_val_set(k_block_idx, block_idx);
 
-  int result = mdb_cursor_get(m_cur_locked_outputs, &k_block_id, NULL, MDB_SET);
+  int result = mdb_cursor_get(m_cur_locked_outputs, &k_block_idx, NULL, MDB_SET);
   if (result == MDB_NOTFOUND)
     return;
   if (result != MDB_SUCCESS)
@@ -7587,7 +7590,7 @@ void BlockchainLMDB::migrate_5_6()
           }
         }
 
-        this->advance_tree_one_block(i);
+        this->advance_tree(i);
 
         LOGIF(el::Level::Info)
         {

src/blockchain_db/lmdb/db_lmdb.h

@@ -342,7 +342,7 @@ class BlockchainLMDB : public BlockchainDB
                             , const std::vector<std::pair<transaction, blobdata>>& txs
                             );
 
-  virtual void advance_tree_one_block(const uint64_t blk_idx);
+  virtual void advance_tree(const uint64_t blk_idx);
 
   virtual void set_batch_transactions(bool batch_transactions);
   virtual bool batch_start(uint64_t batch_num_blocks=0, uint64_t batch_bytes=0);
@@ -457,6 +457,11 @@ class BlockchainLMDB : public BlockchainDB
 
   uint64_t get_block_n_leaf_tuples(uint64_t block_idx) const;
 
+  // Gets the tree root and n_tree_layers composed of all valid spendable outputs when blk_idx is the tip of the chain.
+  // If the chain tip is block index n, and `blk_idx == n`, then this will return the tree root and n layers for the
+  // tree composed of all valid spendable outputs in the chain at that time. Note that the tree stored in the database
+  // may not match up with the tree root returned here, since the tree stored in the database may have grown past the
+  // current tip, with outputs that will unlock in future blocks.
   virtual uint8_t get_tree_root_at_blk_idx(const uint64_t blk_idx, crypto::ec_point &tree_root_out) const;
 
   std::vector<crypto::ec_point> get_tree_edge(uint64_t block_id) const;
@@ -467,9 +472,9 @@ class BlockchainLMDB : public BlockchainDB
     const uint64_t child_layer_idx,
     const uint64_t chunk_width) const;
 
-  std::vector<fcmp_pp::curve_trees::OutputContext> get_outs_at_last_locked_block_id(uint64_t block_id);
+  std::vector<fcmp_pp::curve_trees::OutputContext> get_outs_at_last_locked_block_idx(uint64_t block_id);
 
-  void del_locked_outs_at_block_id(uint64_t block_id);
+  void del_locked_outs_at_block_idx(uint64_t block_idx);
 
   uint64_t get_tree_block_idx() const;
 

src/blockchain_db/testdb.h

@@ -117,7 +117,7 @@ class BaseTestDB: public cryptonote::BlockchainDB {
   virtual void add_tx_amount_output_indices(const uint64_t tx_index, const std::vector<uint64_t>& amount_output_indices) override {}
   virtual void add_spent_key(const crypto::key_image& k_image) override {}
   virtual void remove_spent_key(const crypto::key_image& k_image) override {}
-  virtual void advance_tree_one_block(const uint64_t block_idx) override {}
+  virtual void advance_tree(const uint64_t block_idx) override {}
   virtual void grow_tree(const uint64_t block_idx, std::vector<fcmp_pp::curve_trees::OutputContext> &&new_outputs) override {};
   virtual std::pair<uint64_t, fcmp_pp::curve_trees::PathBytes> get_last_path(const uint64_t block_idx) const override { return {0, fcmp_pp::curve_trees::PathBytes{}}; };
   virtual void trim_tree(const uint64_t new_n_leaf_tuples, const uint64_t trim_block_id) override {};

src/cryptonote_core/blockchain.cpp

@@ -4699,7 +4699,7 @@ bool Blockchain::handle_block_to_main_chain(const block& bl, const crypto::hash&
   TIME_MEASURE_START(advance_tree);
 
   static_assert(CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE > 0, "Expect a non-0 spendable age");
-  try { m_db->advance_tree_one_block(new_height-1); }
+  try { m_db->advance_tree(new_height-1); }
   catch (const std::exception& e)
   {
     LOG_ERROR("Failed to advance tree at block with hash: " << id << ", what = " << e.what());

src/fcmp_pp/tree_cache.h

@@ -226,6 +226,9 @@ class TreeCache final : public TreeSync<C1, C2>
 
     uint64_t get_output_count() const { return m_output_count; }
 
+    // Gets the tree root and n_tree_layers for the tree currently cached in the TreeCache. If the TreeCache's tip is
+    // block index n, then this will return the tree root and n_tree_layers for the tree composed of all valid spendable
+    // outputs in the chain when the chain tip is block index n.
     uint8_t get_tree_root(crypto::ec_point &tree_root_out) const;
 
     // Build the tree extension and all other types needed to grow the cache, returning the state change by ref