Merge pull request #1699 from evoskuil/master

Update header.version processing, style, refactor.

Author: evoskuil

include/bitcoin/system/chain/context.hpp

@@ -31,7 +31,30 @@ class BC_API context final
 {
 public:
     /// Determine if the flag is active for this block.
-    bool is_enabled(chain::flags flag) const NOEXCEPT;
+    inline bool is_enabled(chain::flags flag) const NOEXCEPT
+    {
+        return to_bool(flag & flags);
+    }
+
+    // ************************************************************************
+    // CONSENSUS: Soft forks imposed minimum block versioning using a signed
+    // interpretation of header.version, which would otherwise be unsigned.
+    // ************************************************************************
+    inline bool is_insufficient_version(uint32_t version) const NOEXCEPT
+    {
+        return is_nonzero(minimum_block_version) &&
+            to_signed(version) < to_signed(minimum_block_version);
+    }
+
+    inline bool is_anachronistic_timestamp(uint32_t time_stamp) const NOEXCEPT
+    {
+        return time_stamp <= median_time_past;
+    }
+
+    inline bool is_invalid_work(uint32_t bits) const NOEXCEPT
+    {
+        return bits != work_required;
+    }
 
     /// Header context within chain.
     uint32_t flags;

include/bitcoin/system/chain/header.hpp

@@ -129,13 +129,13 @@ class BC_API header
 
     bool is_invalid_proof_of_work(uint32_t proof_of_work_limit,
         bool scrypt=false) const NOEXCEPT;
-    bool is_invalid_timestamp(uint32_t timestamp_limit_seconds) const NOEXCEPT;
+    bool is_futuristic_timestamp(uint32_t timestamp_limit_seconds) const NOEXCEPT;
 
     /// Accept (relative to chain_state).
     /// -----------------------------------------------------------------------
 
-    // error::invalid_block_version
-    // error::timestamp_too_early
+    // error::insufficient_block_version
+    // error::anachronistic_timestamp
     // error::incorrect_proof_of_work
 
 private:

include/bitcoin/system/error/block_error_t.hpp

@@ -39,8 +39,8 @@ enum block_error_t : uint8_t
 
     // accept header
     checkpoint_conflict,
-    invalid_block_version,
-    timestamp_too_early,
+    insufficient_block_version,
+    anachronistic_timestamp,
     incorrect_proof_of_work,
 
     // confirm header

src/chain/chain_state.cpp

@@ -106,8 +106,8 @@ inline uint32_t bits_high(const chain_state::data& values) NOEXCEPT
 chain_state::activations chain_state::activation(const data& values,
     const forks& forks, const system::settings& settings) NOEXCEPT
 {
-    // Initialize activation results with genesis values.
-    activations result{ flags::no_rules, settings.first_version };
+    // There are no constraints on block version before bip34.
+    activations result{ flags::no_rules, 0 };
 
     // regtest is only activated via configuration.
     if (forks.retarget)
@@ -231,10 +231,6 @@ chain_state::activations chain_state::activation(const data& values,
     {
         result.minimum_block_version = settings.bip34_version;
     }
-    else
-    {
-        result.minimum_block_version = settings.first_version;
-    }
 
     // TODO: bip9 historical activation.
 

src/chain/context.cpp

@@ -25,11 +25,6 @@ namespace libbitcoin {
 namespace system {
 namespace chain {
 
-bool context::is_enabled(chain::flags flag) const NOEXCEPT
-{
-    return to_bool(flag & flags);
-}
-
 bool operator==(const context& left, const context& right) NOEXCEPT
 {
     return left.flags == right.flags

src/chain/header.cpp

@@ -304,9 +304,9 @@ bool header::is_invalid_proof_of_work(uint32_t proof_of_work_limit,
 }
 
 // ****************************************************************************
-// CONSENSUS: bitcoin 32bit unix time: en.wikipedia.org/wiki/Year_2038_problem
+// CONSENSUS: 32 bit unsigned unix time overflows in 2106.
 // ****************************************************************************
-bool header::is_invalid_timestamp(
+bool header::is_futuristic_timestamp(
     uint32_t timestamp_limit_seconds) const NOEXCEPT
 {
     using namespace std::chrono;
@@ -324,7 +324,7 @@ code header::check(uint32_t timestamp_limit_seconds,
 {
     if (is_invalid_proof_of_work(proof_of_work_limit, scrypt))
         return error::invalid_proof_of_work;
-    if (is_invalid_timestamp(timestamp_limit_seconds))
+    if (is_futuristic_timestamp(timestamp_limit_seconds))
         return error::futuristic_timestamp;
 
     return error::block_success;
@@ -339,11 +339,11 @@ code header::check(uint32_t timestamp_limit_seconds,
 // All other work comparisons performed on expanded/normalized bits values.
 code header::accept(const context& ctx) const NOEXCEPT
 {
-    if (version_ < ctx.minimum_block_version)
-        return error::invalid_block_version;
-    if (timestamp_ <= ctx.median_time_past)
-        return error::timestamp_too_early;
-    if (bits_ != ctx.work_required)
+    if (ctx.is_insufficient_version(version_))
+        return error::insufficient_block_version;
+    if (ctx.is_anachronistic_timestamp(timestamp_))
+        return error::anachronistic_timestamp;
+    if (ctx.is_invalid_work(bits_))
         return error::incorrect_proof_of_work;
 
     return error::block_success;

src/error/block_error_t.cpp

@@ -35,8 +35,8 @@ DEFINE_ERROR_T_MESSAGE_MAP(block_error)
 
     // accept header
     { checkpoint_conflict, "block hash rejected by checkpoint" },
-    { invalid_block_version, "block version rejected at current height" },
-    { timestamp_too_early, "block timestamp is too early" },
+    { insufficient_block_version, "block version rejected at current height" },
+    { anachronistic_timestamp, "block timestamp is too early" },
     { incorrect_proof_of_work, "proof of work does not match bits field" },
 
     // confirm header

test/chain/header.cpp

@@ -50,9 +50,9 @@ class accessor
         return header::is_invalid_proof_of_work(proof_of_work_limit, scrypt);
     }
 
-    bool is_invalid_timestamp(uint32_t timestamp_limit_seconds) const
+    bool is_futuristic_timestamp(uint32_t timestamp_limit_seconds) const
     {
-        return header::is_invalid_timestamp(timestamp_limit_seconds);
+        return header::is_futuristic_timestamp(timestamp_limit_seconds);
     }
 };
 
@@ -328,21 +328,21 @@ BOOST_AUTO_TEST_CASE(header__is_invalid_proof_of_work__scrypt_hash_less_than_bit
     BOOST_REQUIRE(!instance.is_invalid_proof_of_work(settings.proof_of_work_limit, true));
 }
 
-BOOST_AUTO_TEST_CASE(header__is_invalid_timestamp__timestamp_less_than_2_hours_from_now__false)
+BOOST_AUTO_TEST_CASE(header__is_futuristic_timestamp__timestamp_less_than_2_hours_from_now__false)
 {
     const auto now = std::chrono::system_clock::now();
     const auto now_time = possible_narrow_and_sign_cast<uint32_t>(std::chrono::system_clock::to_time_t(now));
     const accessor instance{ {}, hash_digest{}, {}, now_time, {}, {} };
-    BOOST_REQUIRE(!instance.is_invalid_timestamp(settings().timestamp_limit_seconds));
+    BOOST_REQUIRE(!instance.is_futuristic_timestamp(settings().timestamp_limit_seconds));
 }
 
-BOOST_AUTO_TEST_CASE(header__is_invalid_timestamp__timestamp_greater_than_2_hours_from_now__true)
+BOOST_AUTO_TEST_CASE(header__is_futuristic_timestamp__timestamp_greater_than_2_hours_from_now__true)
 {
     const auto now = std::chrono::system_clock::now();
     const auto duration = std::chrono::hours(3);
     const auto future = possible_narrow_and_sign_cast<uint32_t>(std::chrono::system_clock::to_time_t(now + duration));
     const accessor instance{ {}, hash_digest{}, {}, future, {}, {} };
-    BOOST_REQUIRE(instance.is_invalid_timestamp(settings().timestamp_limit_seconds));
+    BOOST_REQUIRE(instance.is_futuristic_timestamp(settings().timestamp_limit_seconds));
 }
 
 // json

test/error/block_error_t.cpp

@@ -62,18 +62,18 @@ BOOST_AUTO_TEST_CASE(block_error_t__code__checkpoint_conflict__true_exected_mess
     BOOST_REQUIRE_EQUAL(ec.message(), "block hash rejected by checkpoint");
 }
 
-BOOST_AUTO_TEST_CASE(block_error_t__code__invalid_block_version__true_exected_message)
+BOOST_AUTO_TEST_CASE(block_error_t__code__insufficient_block_version__true_exected_message)
 {
-    constexpr auto value = error::invalid_block_version;
+    constexpr auto value = error::insufficient_block_version;
     const auto ec = code(value);
     BOOST_REQUIRE(ec);
     BOOST_REQUIRE(ec == value);
     BOOST_REQUIRE_EQUAL(ec.message(), "block version rejected at current height");
 }
 
-BOOST_AUTO_TEST_CASE(block_error_t__code__timestamp_too_early__true_exected_message)
+BOOST_AUTO_TEST_CASE(block_error_t__code__anachronistic_timestamp__true_exected_message)
 {
-    constexpr auto value = error::timestamp_too_early;
+    constexpr auto value = error::anachronistic_timestamp;
     const auto ec = code(value);
     BOOST_REQUIRE(ec);
     BOOST_REQUIRE(ec == value);