Rename 'unlock block' to 'last locked block'

Author: j-berman

src/blockchain_db/blockchain_db.cpp

@@ -232,11 +232,11 @@ void BlockchainDB::add_transaction(const crypto::hash& blk_hash, const std::pair
   {
     // miner v2 txes have their coinbase output in one single out to save space,
     // and we store them as rct outputs with an identity mask
-    // note: get_outs_by_unlock_block mirrors this logic
+    // note: get_outs_by_last_locked_block mirrors this logic
     if (miner_tx && tx.version == 2)
     {
       cryptonote::tx_out vout = tx.vout[i];
-      // TODO: avoid duplicate zeroCommitVartime call in get_outs_by_unlock_block
+      // TODO: avoid duplicate zeroCommitVartime call in get_outs_by_last_locked_block
       rct::key commitment = rct::zeroCommitVartime(vout.amount);
       vout.amount = 0;
       amount_output_indices[i] = add_output(tx_hash, vout, i, tx.unlock_time,
@@ -304,13 +304,13 @@ uint64_t BlockchainDB::add_block( const std::pair<block, blobdata>& blck
 
   // When adding a block, we also need to keep track of when outputs unlock, so
   // we can use them to grow the merkle tree used in fcmp's at that point.
-  const auto outs_by_unlock_block_meta = cryptonote::get_outs_by_unlock_block(blk.miner_tx, _txs, total_n_outputs, prev_height);
-  const auto &outs_by_unlock_block = outs_by_unlock_block_meta.outs_by_unlock_block;
-  const auto &timelocked_outputs = outs_by_unlock_block_meta.timelocked_outputs;
+  const auto outs_by_last_locked_block_meta = cryptonote::get_outs_by_last_locked_block(blk.miner_tx, _txs, total_n_outputs, prev_height);
+  const auto &outs_by_last_locked_block = outs_by_last_locked_block_meta.outs_by_last_locked_block;
+  const auto &timelocked_outputs = outs_by_last_locked_block_meta.timelocked_outputs;
 
   // call out to subclass implementation to add the block & metadata
   time1 = epee::misc_utils::get_tick_count();
-  add_block(blk, block_weight, long_term_block_weight, cumulative_difficulty, coins_generated, num_rct_outs, blk_hash, outs_by_unlock_block, timelocked_outputs);
+  add_block(blk, block_weight, long_term_block_weight, cumulative_difficulty, coins_generated, num_rct_outs, blk_hash, outs_by_last_locked_block, timelocked_outputs);
   TIME_MEASURE_FINISH(time1);
   time_add_block1 += time1;
 

src/blockchain_db/blockchain_db.h

@@ -422,7 +422,7 @@ class BlockchainDB
    * @param cumulative_difficulty the accumulated difficulty after this block
    * @param coins_generated the number of coins generated total after this block
    * @param blk_hash the hash of the block
-   * @param outs_by_unlock_block the outputs from this block to add to the merkle tree
+   * @param outs_by_last_locked_block the outputs from this block to add to the merkle tree
    * @param timelocked_outputs the outputs from this block that are custom timelocked
    */
   virtual void add_block( const block& blk
@@ -432,8 +432,8 @@ class BlockchainDB
                 , const uint64_t& coins_generated
                 , uint64_t num_rct_outs
                 , const crypto::hash& blk_hash
-                , const fcmp_pp::curve_trees::OutputsByUnlockBlock& outs_by_unlock_block
-                , const std::unordered_map<uint64_t/*output_id*/, uint64_t/*unlock block_id*/>& timelocked_outputs
+                , const fcmp_pp::curve_trees::OutputsByLastLockedBlock& outs_by_last_locked_block
+                , const std::unordered_map<uint64_t/*output_id*/, uint64_t/*last locked block_id*/>& timelocked_outputs
                 ) = 0;
 
   /**
@@ -1823,18 +1823,21 @@ class BlockchainDB
    *
    * @param start_block_idx
    *
-   * @return custom timelocked outputs grouped by unlock block
+   * @return custom timelocked outputs grouped by last locked block
    */
-  virtual fcmp_pp::curve_trees::OutputsByUnlockBlock get_custom_timelocked_outputs(uint64_t start_block_idx) const = 0;
+  virtual fcmp_pp::curve_trees::OutputsByLastLockedBlock get_custom_timelocked_outputs(uint64_t start_block_idx) const = 0;
 
   /**
    * @brief return recent timelocked outputs after the provided end_block_idx
    *
    * @param end_block_idx
    *
-   * @return the recent locked outputs grouped by unlock block, that unlock
+   * @return
+   *  - coinbase outputs created between [end_block_idx - CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW]
+   *  - normal outputs created between [end_block_idx - CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE]
+   *  - the outputs are grouped by last locked block idx
    */
-  virtual fcmp_pp::curve_trees::OutputsByUnlockBlock get_recent_locked_outputs(uint64_t end_block_idx) const = 0;
+  virtual fcmp_pp::curve_trees::OutputsByLastLockedBlock get_recent_locked_outputs(uint64_t end_block_idx) const = 0;
 
   //
   // Hard fork related storage

src/blockchain_db/blockchain_db_utils.cpp

@@ -35,16 +35,16 @@
 #include "profile_tools.h"
 
 //----------------------------------------------------------------------------------------------------------------------
-// Helper function to group outputs by unlock block
-static uint64_t set_tx_outs_by_unlock_block(const cryptonote::transaction &tx,
+// Helper function to group outputs by last locked block idx
+static uint64_t set_tx_outs_by_last_locked_block(const cryptonote::transaction &tx,
     const uint64_t &first_output_id,
     const uint64_t block_idx,
     const bool miner_tx,
-    fcmp_pp::curve_trees::OutputsByUnlockBlock &outs_by_unlock_block_inout,
-    std::unordered_map<uint64_t/*output_id*/, uint64_t/*unlock block_id*/> &timelocked_outputs_inout)
+    fcmp_pp::curve_trees::OutputsByLastLockedBlock &outs_by_last_locked_block_inout,
+    std::unordered_map<uint64_t/*output_id*/, uint64_t/*last locked block_id*/> &timelocked_outputs_inout)
 {
-    const uint64_t unlock_block = cryptonote::get_unlock_block_index(tx.unlock_time, block_idx);
-    const bool has_custom_timelock = cryptonote::is_custom_timelocked(miner_tx, unlock_block, block_idx);
+    const uint64_t last_locked_block = cryptonote::get_last_locked_block_index(tx.unlock_time, block_idx);
+    const bool has_custom_timelock = cryptonote::is_custom_timelocked(miner_tx, last_locked_block, block_idx);
 
     uint64_t getting_commitment_ns = 0;
 
@@ -84,17 +84,17 @@ static uint64_t set_tx_outs_by_unlock_block(const cryptonote::transaction &tx,
 
         if (has_custom_timelock)
         {
-            timelocked_outputs_inout[output_id] = unlock_block;
+            timelocked_outputs_inout[output_id] = last_locked_block;
         }
 
-        if (outs_by_unlock_block_inout.find(unlock_block) == outs_by_unlock_block_inout.end())
+        if (outs_by_last_locked_block_inout.find(last_locked_block) == outs_by_last_locked_block_inout.end())
         {
             auto new_vec = std::vector<fcmp_pp::curve_trees::OutputContext>{std::move(output_context)};
-            outs_by_unlock_block_inout[unlock_block] = std::move(new_vec);
+            outs_by_last_locked_block_inout[last_locked_block] = std::move(new_vec);
         }
         else
         {
-            outs_by_unlock_block_inout[unlock_block].emplace_back(std::move(output_context));
+            outs_by_last_locked_block_inout[last_locked_block].emplace_back(std::move(output_context));
         }
 
         getting_commitment_ns += getting_commitment;
@@ -108,37 +108,37 @@ static uint64_t set_tx_outs_by_unlock_block(const cryptonote::transaction &tx,
 //----------------------------------------------------------------------------------------------------------------------
 namespace cryptonote
 {
-OutsByUnlockBlockMeta get_outs_by_unlock_block(
+OutsByLastLockedBlockMeta get_outs_by_last_locked_block(
     const cryptonote::transaction &miner_tx,
     const std::vector<std::reference_wrapper<const cryptonote::transaction>> &txs,
     const uint64_t first_output_id,
     const uint64_t block_idx)
 {
-    OutsByUnlockBlockMeta outs_by_unlock_meta_out;
-    outs_by_unlock_meta_out.next_output_id = first_output_id;
+    OutsByLastLockedBlockMeta outs_by_last_locked_block_meta_out;
+    outs_by_last_locked_block_meta_out.next_output_id = first_output_id;
 
     // Get miner tx's leaf tuples
-    outs_by_unlock_meta_out.next_output_id += set_tx_outs_by_unlock_block(
+    outs_by_last_locked_block_meta_out.next_output_id += set_tx_outs_by_last_locked_block(
         miner_tx,
-        outs_by_unlock_meta_out.next_output_id,
+        outs_by_last_locked_block_meta_out.next_output_id,
         block_idx,
         true/*miner_tx*/,
-        outs_by_unlock_meta_out.outs_by_unlock_block,
-        outs_by_unlock_meta_out.timelocked_outputs);
+        outs_by_last_locked_block_meta_out.outs_by_last_locked_block,
+        outs_by_last_locked_block_meta_out.timelocked_outputs);
 
     // Get all other txs' leaf tuples
     for (const auto &tx : txs)
     {
-        outs_by_unlock_meta_out.next_output_id += set_tx_outs_by_unlock_block(
+        outs_by_last_locked_block_meta_out.next_output_id += set_tx_outs_by_last_locked_block(
             tx.get(),
-            outs_by_unlock_meta_out.next_output_id,
+            outs_by_last_locked_block_meta_out.next_output_id,
             block_idx,
             false/*miner_tx*/,
-            outs_by_unlock_meta_out.outs_by_unlock_block,
-            outs_by_unlock_meta_out.timelocked_outputs);
+            outs_by_last_locked_block_meta_out.outs_by_last_locked_block,
+            outs_by_last_locked_block_meta_out.timelocked_outputs);
     }
 
-    return outs_by_unlock_meta_out;
+    return outs_by_last_locked_block_meta_out;
 }
 //----------------------------------------------------------------------------------------------------------------------
 }//namespace cryptonote

src/blockchain_db/blockchain_db_utils.h

@@ -38,18 +38,18 @@
 namespace cryptonote
 {
 
-struct OutsByUnlockBlockMeta
+struct OutsByLastLockedBlockMeta
 {
-    fcmp_pp::curve_trees::OutputsByUnlockBlock outs_by_unlock_block;
-    std::unordered_map<uint64_t/*output_id*/, uint64_t/*unlock block_id*/> timelocked_outputs;
+    fcmp_pp::curve_trees::OutputsByLastLockedBlock outs_by_last_locked_block;
+    std::unordered_map<uint64_t/*output_id*/, uint64_t/*last locked block_id*/> timelocked_outputs;
     uint64_t next_output_id;
 };
 
 // These functions internally rely on ringct for zeroCommitVartime. I implemented in this blockchain_db_utils file
 // instead of cryptonote_basic (where it would seem the better place to put it) to avoid a circular dependency between
 // ringct <> cryptonote_basic.
 // Note that zeroCommitVartime is expensive.
-OutsByUnlockBlockMeta get_outs_by_unlock_block(
+OutsByLastLockedBlockMeta get_outs_by_last_locked_block(
     const cryptonote::transaction &miner_tx,
     const std::vector<std::reference_wrapper<const cryptonote::transaction>> &txs,
     const uint64_t first_output_id,