Merge pull request #1731 from evoskuil/master

Add mutable chain_state field and const get/set for header/block.

Author: evoskuil

include/bitcoin/system/chain/block.hpp

@@ -20,6 +20,7 @@
 #define LIBBITCOIN_SYSTEM_CHAIN_BLOCK_HPP
 
 #include <memory>
+#include <bitcoin/system/chain/chain_state.hpp>
 #include <bitcoin/system/chain/context.hpp>
 #include <bitcoin/system/chain/header.hpp>
 #include <bitcoin/system/chain/input.hpp>
@@ -105,15 +106,20 @@ class BC_API block
     bool is_malleable64() const NOEXCEPT;
     bool is_malleated64() const NOEXCEPT;
 
-    /// Cache setters/getters, not thread safe.
+    /// Cache and metadata.
     /// -----------------------------------------------------------------------
+    /// getters/setters, const/mutable, not thread safe.
 
     /// Cache (overrides hash() computation).
     void set_hashes(const data_chunk& data) NOEXCEPT;
 
     /// Reference used to avoid copy, sets cache if not set.
     const hash_digest& get_hash() const NOEXCEPT;
 
+    /// Set/get chain_state associated with the block.header, may be nullptr.
+    void set_state(const chain_state::cptr& state) const NOEXCEPT;
+    const chain_state::cptr& get_state() const NOEXCEPT;
+
     /// Set/get memory allocation.
     void set_allocation(size_t allocation) const NOEXCEPT;
     size_t get_allocation() const NOEXCEPT;

include/bitcoin/system/chain/header.hpp

@@ -96,18 +96,23 @@ class BC_API header
     uint32_t nonce() const NOEXCEPT;
 
     /// Computed properties.
-    hash_digest hash() const NOEXCEPT;
     uint256_t proof() const NOEXCEPT;
+    hash_digest hash() const NOEXCEPT;
 
-    /// Cache setters/getters, not thread safe.
+    /// Cache and metadata.
     /// -----------------------------------------------------------------------
+    /// getters/setters, const/mutable, not thread safe.
 
-    /// Cache (overrides hash() computation).
+    /// Set to avoid hash() re-computation.
     void set_hash(const hash_digest& hash) const NOEXCEPT;
 
     /// Reference used to avoid copy, sets cache if not set.
     const hash_digest& get_hash() const NOEXCEPT;
 
+    /// Set/get chain_state associated with the header, may be nullptr.
+    void set_state(const chain_state::cptr& state) const NOEXCEPT;
+    const chain_state::cptr& get_state() const NOEXCEPT;
+
     /// Validation.
     /// -----------------------------------------------------------------------
     /// Checkpoints and previous_block_hash are chain validation (not here).
@@ -153,6 +158,9 @@ class BC_API header
 
     // Identity hash caching.
     mutable std::optional<hash_digest> hash_{};
+
+    // Chain state caching.
+    mutable chain_state::cptr state_{};
 };
 
 typedef std_vector<header> headers;

src/chain/block.cpp

@@ -326,6 +326,16 @@ void block::set_hashes(const data_chunk& data) NOEXCEPT
     }
 }
 
+const chain_state::cptr& block::get_state() const NOEXCEPT
+{
+    return header_->get_state();
+}
+
+void block::set_state(const chain_state::cptr& state) const NOEXCEPT
+{
+    header_->set_state(state);
+}
+
 // static/private
 block::sizes block::serialized_size(const transaction_cptrs& txs) NOEXCEPT
 {

src/chain/header.cpp

@@ -218,9 +218,35 @@ uint32_t header::nonce() const NOEXCEPT
     return nonce_;
 }
 
-void header::set_hash(const hash_digest& hash) const NOEXCEPT
+// static/computed
+uint256_t header::proof(uint32_t bits) NOEXCEPT
 {
-    hash_ = hash;
+    auto target = compact::expand(bits);
+
+    //*************************************************************************
+    // CONSENSUS: bits may be overflowed, which is guarded here.
+    // A target of zero is disallowed so is useful as a sentinel value.
+    //*************************************************************************
+    if (is_zero(target))
+        return target;
+
+    //*************************************************************************
+    // CONSENSUS: If target is (2^256)-1, division would fail, however compact
+    // compression is lossy, and therefore unable to produce negative one.
+    //*************************************************************************
+
+    // We need to compute 2**256 / (target + 1), but we can't represent 2**256
+    // as it's too large for uint256. However as 2**256 is at least as large as
+    // target + 1, it is equal to ((2**256 - target - 1) / (target + 1)) + 1, or
+    // (~target / (target + 1)) + 1.
+    return ++(~target / (target + one));
+}
+
+// computed
+uint256_t header::proof() const NOEXCEPT
+{
+    // Returns zero if bits_ mantissa is less than one or bits_ is overflowed.
+    return proof(bits_);
 }
 
 // computed
@@ -240,6 +266,14 @@ hash_digest header::hash() const NOEXCEPT
     return digest;
 }
 
+// Cache and metadata.
+// ----------------------------------------------------------------------------
+
+void header::set_hash(const hash_digest& hash) const NOEXCEPT
+{
+    hash_ = hash;
+}
+
 const hash_digest& header::get_hash() const NOEXCEPT
 {
     if (!hash_)
@@ -248,35 +282,14 @@ const hash_digest& header::get_hash() const NOEXCEPT
     return *hash_;
 }
 
-// static
-uint256_t header::proof(uint32_t bits) NOEXCEPT
+const chain_state::cptr& header::get_state() const NOEXCEPT
 {
-    auto target = compact::expand(bits);
-
-    //*************************************************************************
-    // CONSENSUS: bits may be overflowed, which is guarded here.
-    // A target of zero is disallowed so is useful as a sentinel value.
-    //*************************************************************************
-    if (is_zero(target))
-        return target;
-
-    //*************************************************************************
-    // CONSENSUS: If target is (2^256)-1, division would fail, however compact
-    // compression is lossy, and therefore unable to produce negative one.
-    //*************************************************************************
-
-    // We need to compute 2**256 / (target + 1), but we can't represent 2**256
-    // as it's too large for uint256. However as 2**256 is at least as large as
-    // target + 1, it is equal to ((2**256 - target - 1) / (target + 1)) + 1, or
-    // (~target / (target + 1)) + 1.
-    return ++(~target / (target + one));
+    return state_;
 }
 
-// computed
-uint256_t header::proof() const NOEXCEPT
+void header::set_state(const chain_state::cptr& state) const NOEXCEPT
 {
-    // Returns zero if bits_ mantissa is less than one or bits_ is overflowed.
-    return proof(bits_);
+    state_ = state;
 }
 
 // Check.