Include n tree layers in PoW block hash as well

Author: j-berman

src/blockchain_db/blockchain_db.h

@@ -1820,7 +1820,7 @@ class BlockchainDB
   virtual bool audit_tree(const uint64_t expected_n_leaf_tuples) const = 0;
   virtual uint64_t get_n_leaf_tuples() const = 0;
   virtual uint64_t get_block_n_leaf_tuples(const uint64_t block_idx) const = 0;
-  virtual std::size_t get_tree_root_at_blk_idx(const uint64_t blk_idx, crypto::ec_point &tree_root_out) const = 0;
+  virtual uint8_t get_tree_root_at_blk_idx(const uint64_t blk_idx, crypto::ec_point &tree_root_out) const = 0;
 
   /**
    * @brief return custom timelocked outputs after the provided block idx

src/blockchain_db/lmdb/db_lmdb.cpp

@@ -2116,7 +2116,7 @@ uint64_t BlockchainLMDB::get_block_n_leaf_tuples(const uint64_t block_idx) const
   return n_leaf_tuples;
 }
 
-std::size_t BlockchainLMDB::get_tree_root_at_blk_idx(const uint64_t blk_idx, crypto::ec_point &tree_root_out) const
+uint8_t BlockchainLMDB::get_tree_root_at_blk_idx(const uint64_t blk_idx, crypto::ec_point &tree_root_out) const
 {
   const std::vector<crypto::ec_point> tree_edge = this->get_tree_edge(blk_idx);
   if (tree_edge.empty())
@@ -2125,7 +2125,8 @@ std::size_t BlockchainLMDB::get_tree_root_at_blk_idx(const uint64_t blk_idx, cry
     return 0;
   }
   tree_root_out = tree_edge.back();
-  return tree_edge.size();
+  static_assert(sizeof(std::size_t) >= sizeof(uint8_t), "unexpected size of size_t");
+  return (uint8_t) tree_edge.size();
 }
 
 bool BlockchainLMDB::audit_tree(const uint64_t expected_n_leaf_tuples) const

src/blockchain_db/lmdb/db_lmdb.h

@@ -457,7 +457,7 @@ class BlockchainLMDB : public BlockchainDB
 
   uint64_t get_block_n_leaf_tuples(uint64_t block_idx) const;
 
-  virtual std::size_t get_tree_root_at_blk_idx(const uint64_t blk_idx, crypto::ec_point &tree_root_out) const;
+  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;
 

src/blockchain_db/testdb.h

@@ -122,7 +122,7 @@ class BaseTestDB: public cryptonote::BlockchainDB {
   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 {};
   virtual bool audit_tree(const uint64_t expected_n_leaf_tuples) const override { return false; };
-  virtual std::size_t get_tree_root_at_blk_idx(const uint64_t blk_idx, crypto::ec_point &tree_root_out) const override { return {}; };
+  virtual uint8_t get_tree_root_at_blk_idx(const uint64_t blk_idx, crypto::ec_point &tree_root_out) const override { return {}; };
   virtual uint64_t get_n_leaf_tuples() const override { return 0; };
   virtual uint64_t get_block_n_leaf_tuples(const uint64_t block_idx) const override { return 0; };
   virtual fcmp_pp::curve_trees::OutsByLastLockedBlock get_custom_timelocked_outputs(uint64_t start_block_idx) const override { return {{}}; };

src/cryptonote_basic/cryptonote_basic.h

@@ -478,8 +478,8 @@ namespace cryptonote
 
   public:
     block(): block_header(), hash_valid(false) {}
-    block(const block &b): block_header(b), hash_valid(false), miner_tx(b.miner_tx), tx_hashes(b.tx_hashes), fcmp_pp_tree_root(b.fcmp_pp_tree_root) { if (b.is_hash_valid()) { hash = b.hash; set_hash_valid(true); } }
-    block &operator=(const block &b) { block_header::operator=(b); hash_valid = false; miner_tx = b.miner_tx; tx_hashes = b.tx_hashes; fcmp_pp_tree_root = b.fcmp_pp_tree_root; if (b.is_hash_valid()) { hash = b.hash; set_hash_valid(true); } return *this; }
+    block(const block &b): block_header(b), hash_valid(false), miner_tx(b.miner_tx), tx_hashes(b.tx_hashes), fcmp_pp_n_tree_layers(b.fcmp_pp_n_tree_layers), fcmp_pp_tree_root(b.fcmp_pp_tree_root) { if (b.is_hash_valid()) { hash = b.hash; set_hash_valid(true); } }
+    block &operator=(const block &b) { block_header::operator=(b); hash_valid = false; miner_tx = b.miner_tx; tx_hashes = b.tx_hashes; fcmp_pp_n_tree_layers = b.fcmp_pp_n_tree_layers; fcmp_pp_tree_root = b.fcmp_pp_tree_root; if (b.is_hash_valid()) { hash = b.hash; set_hash_valid(true); } return *this; }
     void invalidate_hashes() { set_hash_valid(false); }
     bool is_hash_valid() const { return hash_valid.load(std::memory_order_acquire); }
     void set_hash_valid(bool v) const { hash_valid.store(v,std::memory_order_release); }
@@ -488,6 +488,8 @@ namespace cryptonote
     transaction miner_tx;
     std::vector<crypto::hash> tx_hashes;
 
+    // We include both n tree layers and the root so SPV nodes can verify FCMP++ proofs
+    uint8_t fcmp_pp_n_tree_layers;
     crypto::ec_point fcmp_pp_tree_root;
 
     // hash cash
@@ -503,7 +505,12 @@ namespace cryptonote
       if (tx_hashes.size() > CRYPTONOTE_MAX_TX_PER_BLOCK)
         return false;
       if (major_version >= HF_VERSION_FCMP_PLUS_PLUS)
+      {
+        FIELD(fcmp_pp_n_tree_layers)
+        if (fcmp_pp_n_tree_layers > FCMP_PLUS_PLUS_MAX_LAYERS)
+          return false;
         FIELD(fcmp_pp_tree_root)
+      }
     END_SERIALIZE()
   };
 

src/cryptonote_basic/cryptonote_boost_serialization.h

@@ -203,7 +203,10 @@ namespace boost
     a & b.miner_tx;
     a & b.tx_hashes;
     if (b.major_version >= HF_VERSION_FCMP_PLUS_PLUS)
+    {
+      a & b.fcmp_pp_n_tree_layers;
       a & b.fcmp_pp_tree_root;
+    }
   }
 
   template <class Archive>

src/cryptonote_basic/cryptonote_format_utils.cpp

@@ -1476,8 +1476,8 @@ namespace cryptonote
   blobdata get_block_hashing_blob(const block& b)
   {
     blobdata blob = t_serializable_object_to_blob(static_cast<block_header>(b));
-    crypto::hash tree_root_hash = get_tree_hash(b);
-    blob.append(reinterpret_cast<const char*>(&tree_root_hash), sizeof(tree_root_hash));
+    crypto::hash block_content_hash = get_block_content_hash(b);
+    blob.append(reinterpret_cast<const char*>(&block_content_hash), sizeof(block_content_hash));
     blob.append(tools::get_varint_data(b.tx_hashes.size()+1));
     return blob;
   }
@@ -1619,20 +1619,24 @@ namespace cryptonote
     return t_serializable_object_to_blob(tx, b_blob);
   }
   //---------------------------------------------------------------
-  crypto::hash get_tree_hash(const block& b)
+  crypto::hash get_block_content_hash(const block& b)
   {
     std::vector<crypto::hash> hashes;
-    hashes.reserve(1 + 1 + b.tx_hashes.size());
-    // 1. FCMP++ root
+    hashes.reserve(1 + 1 + 1 + b.tx_hashes.size());
+    // 1. n tree layers in FCMP++ tree
+    static_assert(sizeof(crypto::hash) >= sizeof(uint8_t), "crypto::hash is too small");
+    if (b.major_version >= HF_VERSION_FCMP_PLUS_PLUS)
+      hashes.push_back(crypto::hash{static_cast<char>(b.fcmp_pp_n_tree_layers)});
+    // 2. FCMP++ tree root
     static_assert(sizeof(crypto::hash) == sizeof(crypto::ec_point), "expected sizeof hash == sizeof ec_point");
     if (b.major_version >= HF_VERSION_FCMP_PLUS_PLUS)
       hashes.push_back((crypto::hash&)b.fcmp_pp_tree_root);
-    // 2. Miner tx
+    // 3. Miner tx
     crypto::hash h = null_hash;
     size_t bl_sz = 0;
     CHECK_AND_ASSERT_THROW_MES(get_transaction_hash(b.miner_tx, h, bl_sz), "Failed to calculate transaction hash");
     hashes.push_back(h);
-    // 3. All other txs
+    // 4. All other txs
     for(auto& th: b.tx_hashes)
       hashes.push_back(th);
     return get_tree_hash(hashes);

src/cryptonote_basic/cryptonote_format_utils.h

@@ -260,7 +260,7 @@ namespace cryptonote
   bool block_to_blob(const block& b, blobdata& b_blob);
   blobdata tx_to_blob(const transaction& b);
   bool tx_to_blob(const transaction& b, blobdata& b_blob);
-  crypto::hash get_tree_hash(const block& b);
+  crypto::hash get_block_content_hash(const block& b);
   bool is_valid_decomposed_amount(uint64_t amount);
   void get_hash_stats(uint64_t &tx_hashes_calculated, uint64_t &tx_hashes_cached, uint64_t &block_hashes_calculated, uint64_t & block_hashes_cached);
 

src/cryptonote_core/blockchain.cpp

@@ -1664,7 +1664,7 @@ bool Blockchain::create_block_template(block& b, const crypto::hash *from_block,
 
   if (b.major_version >= HF_VERSION_FCMP_PLUS_PLUS)
   {
-    m_db->get_tree_root_at_blk_idx(height, b.fcmp_pp_tree_root);
+    b.fcmp_pp_n_tree_layers = m_db->get_tree_root_at_blk_idx(height, b.fcmp_pp_tree_root);
   }
 
   size_t txs_weight;
@@ -1800,21 +1800,20 @@ bool Blockchain::create_block_template(block& b, const account_public_address& m
   return create_block_template(b, NULL, miner_address, diffic, height, expected_reward, cumulative_weight, ex_nonce, seed_height, seed_hash);
 }
 //------------------------------------------------------------------
-bool Blockchain::get_miner_data(uint8_t& major_version, uint64_t& height, crypto::hash& prev_id, crypto::ec_point& fcmp_pp_tree_root, crypto::hash& seed_hash, difficulty_type& difficulty, uint64_t& median_weight, uint64_t& already_generated_coins, std::vector<tx_block_template_backlog_entry>& tx_backlog)
+bool Blockchain::get_miner_data(uint8_t& major_version, uint64_t& height, crypto::hash& prev_id, uint8_t& fcmp_pp_n_tree_layers, crypto::ec_point& fcmp_pp_tree_root, crypto::hash& seed_hash, difficulty_type& difficulty, uint64_t& median_weight, uint64_t& already_generated_coins, std::vector<tx_block_template_backlog_entry>& tx_backlog)
 {
   prev_id = m_db->top_block_hash(&height);
   ++height;
 
   major_version = m_hardfork->get_ideal_version(height);
 
-  const uint8_t cur_version = m_hardfork->get_current_version();
-
+  fcmp_pp_n_tree_layers = 0;
   fcmp_pp_tree_root = crypto::ec_point{};
-  if (cur_version >= HF_VERSION_FCMP_PLUS_PLUS)
-    m_db->get_tree_root_at_blk_idx(height, fcmp_pp_tree_root);
+  if (major_version >= HF_VERSION_FCMP_PLUS_PLUS)
+    fcmp_pp_n_tree_layers = m_db->get_tree_root_at_blk_idx(height, fcmp_pp_tree_root);
 
   seed_hash = crypto::null_hash;
-  if (cur_version >= RX_BLOCK_VERSION)
+  if (major_version >= RX_BLOCK_VERSION)
   {
     uint64_t seed_height, next_height;
     crypto::rx_seedheights(height, &seed_height, &next_height);
@@ -2605,12 +2604,11 @@ static bool get_fcmp_tx_tree_root(const BlockchainDB *db, const cryptonote::tran
       "tx included reference block that was too high");
 
   // Get the tree root and n tree layers at provided block
-  const std::size_t n_tree_layers = db->get_tree_root_at_blk_idx(tx.rct_signatures.p.reference_block, tree_root_out);
+  const uint8_t n_tree_layers = db->get_tree_root_at_blk_idx(tx.rct_signatures.p.reference_block, tree_root_out);
 
   // Make sure the provided n tree layers matches expected
   // IMPORTANT!
-  static_assert(sizeof(std::size_t) >= sizeof(uint8_t), "unexpected size of size_t");
-  CHECK_AND_ASSERT_MES((std::size_t)tx.rct_signatures.p.n_tree_layers == n_tree_layers, false,
+  CHECK_AND_ASSERT_MES(tx.rct_signatures.p.n_tree_layers == n_tree_layers, false,
       "tx included incorrect number of tree layers");
 
   return true;
@@ -4354,14 +4352,14 @@ bool Blockchain::handle_block_to_main_chain(const block& bl, const crypto::hash&
 
   TIME_MEASURE_START(t3);
 
-  // Make sure the block uses the correct FCMP++ tree root
+  // Make sure the block uses the correct FCMP++ tree root and n tree layers
   if (hf_version >= HF_VERSION_FCMP_PLUS_PLUS)
   {
     crypto::ec_point fcmp_pp_tree_root;
-    m_db->get_tree_root_at_blk_idx(blockchain_height, fcmp_pp_tree_root);
-    if (bl.fcmp_pp_tree_root != fcmp_pp_tree_root)
+    const uint8_t n_tree_layers = m_db->get_tree_root_at_blk_idx(blockchain_height, fcmp_pp_tree_root);
+    if (bl.fcmp_pp_n_tree_layers != n_tree_layers || bl.fcmp_pp_tree_root != fcmp_pp_tree_root)
     {
-      MERROR_VER("Block with id: " << id << " used incorrect FCMP++ tree root");
+      MERROR_VER("Block with id: " << id << " used incorrect FCMP++ n tree layers or tree root");
       bvc.m_verifivation_failed = true;
       goto leave;
     }
@@ -5982,13 +5980,14 @@ void Blockchain::send_miner_notifications(uint64_t height, const crypto::hash &s
   std::vector<tx_block_template_backlog_entry> tx_backlog;
   m_tx_pool.get_block_template_backlog(tx_backlog);
 
+  uint8_t fcmp_pp_n_tree_layers = 0;
   crypto::ec_point fcmp_pp_tree_root{};
-  if (m_hardfork->get_current_version() >= HF_VERSION_FCMP_PLUS_PLUS)
-    m_db->get_tree_root_at_blk_idx(height, fcmp_pp_tree_root);
+  if (major_version >= HF_VERSION_FCMP_PLUS_PLUS)
+    fcmp_pp_n_tree_layers = m_db->get_tree_root_at_blk_idx(height, fcmp_pp_tree_root);
 
   for (const auto& notifier : m_miner_notifiers)
   {
-    notifier(major_version, height, prev_id, fcmp_pp_tree_root, seed_hash, diff, median_weight, already_generated_coins, tx_backlog);
+    notifier(major_version, height, prev_id, fcmp_pp_n_tree_layers, fcmp_pp_tree_root, seed_hash, diff, median_weight, already_generated_coins, tx_backlog);
   }
 }
 

src/cryptonote_core/blockchain.h

@@ -94,7 +94,7 @@ namespace cryptonote
 
   typedef boost::function<void(std::vector<txpool_event>)> TxpoolNotifyCallback;
   typedef boost::function<void(uint64_t /* height */, epee::span<const block> /* blocks */)> BlockNotifyCallback;
-  typedef boost::function<void(uint8_t /* major_version */, uint64_t /* height */, const crypto::hash& /* prev_id */, const crypto::ec_point& /* fcmp_pp_tree_root */, const crypto::hash& /* seed_hash */, difficulty_type /* diff */, uint64_t /* median_weight */, uint64_t /* already_generated_coins */, const std::vector<tx_block_template_backlog_entry>& /* tx_backlog */)> MinerNotifyCallback;
+  typedef boost::function<void(uint8_t /* major_version */, uint64_t /* height */, const crypto::hash& /* prev_id */, const uint8_t& /*fcmp_pp_n_tree_layers*/, const crypto::ec_point& /* fcmp_pp_tree_root */, const crypto::hash& /* seed_hash */, difficulty_type /* diff */, uint64_t /* median_weight */, uint64_t /* already_generated_coins */, const std::vector<tx_block_template_backlog_entry>& /* tx_backlog */)> MinerNotifyCallback;
 
   /************************************************************************/
   /*                                                                      */
@@ -396,6 +396,7 @@ namespace cryptonote
      * @param major_version current hardfork version
      * @param height current blockchain height
      * @param prev_id hash of the top block
+     * @param fcmp_pp_n_tree_layers number of layers in the FCMP++ curve tree
      * @param fcmp_pp_tree_root FCMP++ root as of when this next block enters the chain
      * @param seed_hash seed hash used for RandomX initialization
      * @param difficulty current mining difficulty
@@ -405,7 +406,7 @@ namespace cryptonote
      *
      * @return true if block template filled in successfully, else false
      */
-    bool get_miner_data(uint8_t& major_version, uint64_t& height, crypto::hash& prev_id, crypto::ec_point& fcmp_pp_tree_root, crypto::hash& seed_hash, difficulty_type& difficulty, uint64_t& median_weight, uint64_t& already_generated_coins, std::vector<tx_block_template_backlog_entry>& tx_backlog);
+    bool get_miner_data(uint8_t& major_version, uint64_t& height, crypto::hash& prev_id, uint8_t& fcmp_pp_n_tree_layers, crypto::ec_point& fcmp_pp_tree_root, crypto::hash& seed_hash, difficulty_type& difficulty, uint64_t& median_weight, uint64_t& already_generated_coins, std::vector<tx_block_template_backlog_entry>& tx_backlog);
 
     /**
      * @brief checks if a block is known about with a given hash