From fdc3bf6f387cf24273947dc514111fb4826f433a Mon Sep 17 00:00:00 2001 From: greg7mdp Date: Fri, 21 Apr 2023 15:57:00 -0400 Subject: [PATCH 1/3] Changes for building with c++20. With these changes, plus the ones in the PRs opened in the following submodules: - bn256 - eos-vm - CLI11 - abieos Leap builds with clang-16 in c++20 mode. --- libraries/chain/include/eosio/chain/types.hpp | 8 ++ .../chain/unapplied_transaction_queue.hpp | 5 +- .../eosio/chain/wasm_eosio_injection.hpp | 120 ++++++++-------- libraries/chain/webassembly/crypto.cpp | 8 +- plugins/chain_plugin/account_query_db.cpp | 3 +- .../test_trx_finality_status_processing.cpp | 128 +++++++++--------- plugins/chain_plugin/trx_retry_db.cpp | 5 +- .../file_space_handler.hpp | 2 +- 8 files changed, 149 insertions(+), 130 deletions(-) diff --git a/libraries/chain/include/eosio/chain/types.hpp b/libraries/chain/include/eosio/chain/types.hpp index b0089f3a15..0a71ea9fdf 100644 --- a/libraries/chain/include/eosio/chain/types.hpp +++ b/libraries/chain/include/eosio/chain/types.hpp @@ -87,6 +87,14 @@ namespace eosio::chain { #endif struct void_t{}; + struct noncopyable { + noncopyable() = default; + noncopyable(noncopyable&&) = default; + noncopyable& operator=(noncopyable&&) = default; + noncopyable(const noncopyable&) = delete; + noncopyable& operator=(const noncopyable&) = delete; + }; + using chainbase::allocator; using shared_string = chainbase::shared_string; template diff --git a/libraries/chain/include/eosio/chain/unapplied_transaction_queue.hpp b/libraries/chain/include/eosio/chain/unapplied_transaction_queue.hpp index 7677caa5b5..65775e6a7a 100644 --- a/libraries/chain/include/eosio/chain/unapplied_transaction_queue.hpp +++ b/libraries/chain/include/eosio/chain/unapplied_transaction_queue.hpp @@ -37,11 +37,14 @@ struct unapplied_transaction { const transaction_id_type& id()const { return trx_meta->id(); } fc::time_point_sec expiration()const { return trx_meta->packed_trx()->expiration(); } - +#if __cplusplus >= 202002L + [[no_unique_address]] noncopyable _; +#else unapplied_transaction(const unapplied_transaction&) = delete; unapplied_transaction() = delete; unapplied_transaction& operator=(const unapplied_transaction&) = delete; unapplied_transaction(unapplied_transaction&&) = default; +#endif }; /** diff --git a/libraries/chain/include/eosio/chain/wasm_eosio_injection.hpp b/libraries/chain/include/eosio/chain/wasm_eosio_injection.hpp index 48ee05c2a3..020a4ad202 100644 --- a/libraries/chain/include/eosio/chain/wasm_eosio_injection.hpp +++ b/libraries/chain/include/eosio/chain/wasm_eosio_injection.hpp @@ -168,121 +168,121 @@ namespace eosio { namespace chain { namespace wasm_injections { constexpr const char* inject_which_op( uint16_t opcode ) { switch ( opcode ) { case wasm_ops::f32_add_code: - return u8"_eosio_f32_add"; + return "_eosio_f32_add"; case wasm_ops::f32_sub_code: - return u8"_eosio_f32_sub"; + return "_eosio_f32_sub"; case wasm_ops::f32_mul_code: - return u8"_eosio_f32_mul"; + return "_eosio_f32_mul"; case wasm_ops::f32_div_code: - return u8"_eosio_f32_div"; + return "_eosio_f32_div"; case wasm_ops::f32_min_code: - return u8"_eosio_f32_min"; + return "_eosio_f32_min"; case wasm_ops::f32_max_code: - return u8"_eosio_f32_max"; + return "_eosio_f32_max"; case wasm_ops::f32_copysign_code: - return u8"_eosio_f32_copysign"; + return "_eosio_f32_copysign"; case wasm_ops::f32_abs_code: - return u8"_eosio_f32_abs"; + return "_eosio_f32_abs"; case wasm_ops::f32_neg_code: - return u8"_eosio_f32_neg"; + return "_eosio_f32_neg"; case wasm_ops::f32_sqrt_code: - return u8"_eosio_f32_sqrt"; + return "_eosio_f32_sqrt"; case wasm_ops::f32_ceil_code: - return u8"_eosio_f32_ceil"; + return "_eosio_f32_ceil"; case wasm_ops::f32_floor_code: - return u8"_eosio_f32_floor"; + return "_eosio_f32_floor"; case wasm_ops::f32_trunc_code: - return u8"_eosio_f32_trunc"; + return "_eosio_f32_trunc"; case wasm_ops::f32_nearest_code: - return u8"_eosio_f32_nearest"; + return "_eosio_f32_nearest"; case wasm_ops::f32_eq_code: - return u8"_eosio_f32_eq"; + return "_eosio_f32_eq"; case wasm_ops::f32_ne_code: - return u8"_eosio_f32_ne"; + return "_eosio_f32_ne"; case wasm_ops::f32_lt_code: - return u8"_eosio_f32_lt"; + return "_eosio_f32_lt"; case wasm_ops::f32_le_code: - return u8"_eosio_f32_le"; + return "_eosio_f32_le"; case wasm_ops::f32_gt_code: - return u8"_eosio_f32_gt"; + return "_eosio_f32_gt"; case wasm_ops::f32_ge_code: - return u8"_eosio_f32_ge"; + return "_eosio_f32_ge"; case wasm_ops::f64_add_code: - return u8"_eosio_f64_add"; + return "_eosio_f64_add"; case wasm_ops::f64_sub_code: - return u8"_eosio_f64_sub"; + return "_eosio_f64_sub"; case wasm_ops::f64_mul_code: - return u8"_eosio_f64_mul"; + return "_eosio_f64_mul"; case wasm_ops::f64_div_code: - return u8"_eosio_f64_div"; + return "_eosio_f64_div"; case wasm_ops::f64_min_code: - return u8"_eosio_f64_min"; + return "_eosio_f64_min"; case wasm_ops::f64_max_code: - return u8"_eosio_f64_max"; + return "_eosio_f64_max"; case wasm_ops::f64_copysign_code: - return u8"_eosio_f64_copysign"; + return "_eosio_f64_copysign"; case wasm_ops::f64_abs_code: - return u8"_eosio_f64_abs"; + return "_eosio_f64_abs"; case wasm_ops::f64_neg_code: - return u8"_eosio_f64_neg"; + return "_eosio_f64_neg"; case wasm_ops::f64_sqrt_code: - return u8"_eosio_f64_sqrt"; + return "_eosio_f64_sqrt"; case wasm_ops::f64_ceil_code: - return u8"_eosio_f64_ceil"; + return "_eosio_f64_ceil"; case wasm_ops::f64_floor_code: - return u8"_eosio_f64_floor"; + return "_eosio_f64_floor"; case wasm_ops::f64_trunc_code: - return u8"_eosio_f64_trunc"; + return "_eosio_f64_trunc"; case wasm_ops::f64_nearest_code: - return u8"_eosio_f64_nearest"; + return "_eosio_f64_nearest"; case wasm_ops::f64_eq_code: - return u8"_eosio_f64_eq"; + return "_eosio_f64_eq"; case wasm_ops::f64_ne_code: - return u8"_eosio_f64_ne"; + return "_eosio_f64_ne"; case wasm_ops::f64_lt_code: - return u8"_eosio_f64_lt"; + return "_eosio_f64_lt"; case wasm_ops::f64_le_code: - return u8"_eosio_f64_le"; + return "_eosio_f64_le"; case wasm_ops::f64_gt_code: - return u8"_eosio_f64_gt"; + return "_eosio_f64_gt"; case wasm_ops::f64_ge_code: - return u8"_eosio_f64_ge"; + return "_eosio_f64_ge"; case wasm_ops::f64_promote_f32_code: - return u8"_eosio_f32_promote"; + return "_eosio_f32_promote"; case wasm_ops::f32_demote_f64_code: - return u8"_eosio_f64_demote"; + return "_eosio_f64_demote"; case wasm_ops::i32_trunc_u_f32_code: - return u8"_eosio_f32_trunc_i32u"; + return "_eosio_f32_trunc_i32u"; case wasm_ops::i32_trunc_s_f32_code: - return u8"_eosio_f32_trunc_i32s"; + return "_eosio_f32_trunc_i32s"; case wasm_ops::i32_trunc_u_f64_code: - return u8"_eosio_f64_trunc_i32u"; + return "_eosio_f64_trunc_i32u"; case wasm_ops::i32_trunc_s_f64_code: - return u8"_eosio_f64_trunc_i32s"; + return "_eosio_f64_trunc_i32s"; case wasm_ops::i64_trunc_u_f32_code: - return u8"_eosio_f32_trunc_i64u"; + return "_eosio_f32_trunc_i64u"; case wasm_ops::i64_trunc_s_f32_code: - return u8"_eosio_f32_trunc_i64s"; + return "_eosio_f32_trunc_i64s"; case wasm_ops::i64_trunc_u_f64_code: - return u8"_eosio_f64_trunc_i64u"; + return "_eosio_f64_trunc_i64u"; case wasm_ops::i64_trunc_s_f64_code: - return u8"_eosio_f64_trunc_i64s"; + return "_eosio_f64_trunc_i64s"; case wasm_ops::f32_convert_s_i32_code: - return u8"_eosio_i32_to_f32"; + return "_eosio_i32_to_f32"; case wasm_ops::f32_convert_u_i32_code: - return u8"_eosio_ui32_to_f32"; + return "_eosio_ui32_to_f32"; case wasm_ops::f32_convert_s_i64_code: - return u8"_eosio_i64_f32"; + return "_eosio_i64_f32"; case wasm_ops::f32_convert_u_i64_code: - return u8"_eosio_ui64_to_f32"; + return "_eosio_ui64_to_f32"; case wasm_ops::f64_convert_s_i32_code: - return u8"_eosio_i32_to_f64"; + return "_eosio_i32_to_f64"; case wasm_ops::f64_convert_u_i32_code: - return u8"_eosio_ui32_to_f64"; + return "_eosio_ui32_to_f64"; case wasm_ops::f64_convert_s_i64_code: - return u8"_eosio_i64_to_f64"; + return "_eosio_i64_to_f64"; case wasm_ops::f64_convert_u_i64_code: - return u8"_eosio_ui64_to_f64"; + return "_eosio_ui64_to_f64"; default: FC_THROW_EXCEPTION( eosio::chain::wasm_execution_error, "Error, unknown opcode in injection ${op}", ("op", opcode)); @@ -483,7 +483,7 @@ namespace eosio { namespace chain { namespace wasm_injections { static void init() {} static void accept( wasm_ops::instr* inst, wasm_ops::visitor_arg& arg ) { int32_t idx; - injector_utils::add_import( *(arg.module), u8"_eosio_f32_promote", idx ); + injector_utils::add_import( *(arg.module), "_eosio_f32_promote", idx ); wasm_ops::op_types<>::call_t f32promote; f32promote.field = idx; f32promote.pack(arg.new_code); @@ -496,7 +496,7 @@ namespace eosio { namespace chain { namespace wasm_injections { static void init() {} static void accept( wasm_ops::instr* inst, wasm_ops::visitor_arg& arg ) { int32_t idx; - injector_utils::add_import( *(arg.module), u8"_eosio_f64_demote", idx ); + injector_utils::add_import( *(arg.module), "_eosio_f64_demote", idx ); wasm_ops::op_types<>::call_t f32promote; f32promote.field = idx; f32promote.pack(arg.new_code); diff --git a/libraries/chain/webassembly/crypto.cpp b/libraries/chain/webassembly/crypto.cpp index 43991610f9..095ee4c1d9 100644 --- a/libraries/chain/webassembly/crypto.cpp +++ b/libraries/chain/webassembly/crypto.cpp @@ -118,14 +118,18 @@ namespace eosio { namespace chain { namespace webassembly { int32_t interface::alt_bn128_add(span op1, span op2, span result ) const { if (op1.size() != 64 || op2.size() != 64 || result.size() < 64 || - bn256::g1_add({(const uint8_t*)op1.data(), 64}, {(const uint8_t*)op2.data(), 64}, { (uint8_t*)result.data(), 64}) == -1) + bn256::g1_add(std::span{(const uint8_t*)op1.data(), 64}, + std::span{(const uint8_t*)op2.data(), 64}, + std::span{ (uint8_t*)result.data(), 64}) == -1) return return_code::failure; return return_code::success; } int32_t interface::alt_bn128_mul(span g1_point, span scalar, span result) const { if (g1_point.size() != 64 || scalar.size() != 32 || result.size() < 64 || - bn256::g1_scalar_mul({(const uint8_t*)g1_point.data(), 64}, {(const uint8_t*)scalar.data(), 32}, { (uint8_t*)result.data(), 64}) == -1) + bn256::g1_scalar_mul(std::span{(const uint8_t*)g1_point.data(), 64}, + std::span{(const uint8_t*)scalar.data(), 32}, + std::span{ (uint8_t*)result.data(), 64}) == -1) return return_code::failure; return return_code::success; } diff --git a/plugins/chain_plugin/account_query_db.cpp b/plugins/chain_plugin/account_query_db.cpp index f0206eabcb..0c2442f6da 100644 --- a/plugins/chain_plugin/account_query_db.cpp +++ b/plugins/chain_plugin/account_query_db.cpp @@ -266,7 +266,8 @@ namespace eosio::chain_apis { } else { const auto& po = *itr; - uint32_t last_updated_height = po.last_updated == bsp->header.timestamp ? bsp->block_num : last_updated_time_to_height(po.last_updated); + uint32_t last_updated_height = chain::block_timestamp_type(po.last_updated) == bsp->header.timestamp ? + bsp->block_num : last_updated_time_to_height(po.last_updated); index.modify(index.iterator_to(pi), [&po, last_updated_height](auto& mutable_pi) { mutable_pi.last_updated_height = last_updated_height; diff --git a/plugins/chain_plugin/test/test_trx_finality_status_processing.cpp b/plugins/chain_plugin/test/test_trx_finality_status_processing.cpp index 938c07d304..4dd9a1748a 100644 --- a/plugins/chain_plugin/test/test_trx_finality_status_processing.cpp +++ b/plugins/chain_plugin/test/test_trx_finality_status_processing.cpp @@ -203,28 +203,28 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { op_ts ts = status.get_trx_state(std::get<1>(trx_pairs_20[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == eosio::chain::block_id_type{}); - BOOST_CHECK(ts->block_timestamp == eosio::chain::block_timestamp_type{}); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == eosio::chain::block_timestamp_type{}); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "LOCALLY_APPLIED"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[1])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == eosio::chain::block_id_type{}); - BOOST_CHECK(ts->block_timestamp == eosio::chain::block_timestamp_type{}); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == eosio::chain::block_timestamp_type{}); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "LOCALLY_APPLIED"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[2])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == eosio::chain::block_id_type{}); - BOOST_CHECK(ts->block_timestamp == eosio::chain::block_timestamp_type{}); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == eosio::chain::block_timestamp_type{}); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "LOCALLY_APPLIED"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[3])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == eosio::chain::block_id_type{}); - BOOST_CHECK(ts->block_timestamp == eosio::chain::block_timestamp_type{}); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == eosio::chain::block_timestamp_type{}); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "LOCALLY_APPLIED"); @@ -271,14 +271,14 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { ts = status.get_trx_state(std::get<1>(trx_pairs_20[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[1])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK(fc::time_point_sec(ts->expiration) == (std::get<1>(trx_pairs_20[1])->expiration())); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); @@ -286,28 +286,28 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { ts = status.get_trx_state(std::get<1>(trx_pairs_20[2])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[3])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(hold_pairs[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == eosio::chain::block_id_type{}); - BOOST_CHECK(ts->block_timestamp == eosio::chain::block_timestamp_type{}); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == eosio::chain::block_timestamp_type{}); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "LOCALLY_APPLIED"); ts = status.get_trx_state(std::get<1>(hold_pairs[1])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == eosio::chain::block_id_type{}); - BOOST_CHECK(ts->block_timestamp == eosio::chain::block_timestamp_type{}); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == eosio::chain::block_timestamp_type{}); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "LOCALLY_APPLIED"); @@ -334,49 +334,49 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { ts = status.get_trx_state(std::get<1>(trx_pairs_20[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[1])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[2])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[3])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(hold_pairs[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == eosio::chain::block_id_type{}); - BOOST_CHECK(ts->block_timestamp == eosio::chain::block_timestamp_type{}); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == eosio::chain::block_timestamp_type{}); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "LOCALLY_APPLIED"); ts = status.get_trx_state(std::get<1>(hold_pairs[1])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == eosio::chain::block_id_type{}); - BOOST_CHECK(ts->block_timestamp == eosio::chain::block_timestamp_type{}); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == eosio::chain::block_timestamp_type{}); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "LOCALLY_APPLIED"); ts = status.get_trx_state(std::get<1>(trx_pairs_21[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_21->id); - BOOST_CHECK(ts->block_timestamp == bs_21->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_21->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_21_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); @@ -404,56 +404,56 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { ts = status.get_trx_state(std::get<1>(trx_pairs_20[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[1])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[2])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[3])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(hold_pairs[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == eosio::chain::block_id_type{}); - BOOST_CHECK(ts->block_timestamp == eosio::chain::block_timestamp_type{}); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == eosio::chain::block_timestamp_type{}); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "LOCALLY_APPLIED"); ts = status.get_trx_state(std::get<1>(hold_pairs[1])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == eosio::chain::block_id_type{}); - BOOST_CHECK(ts->block_timestamp == eosio::chain::block_timestamp_type{}); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == eosio::chain::block_timestamp_type{}); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "LOCALLY_APPLIED"); ts = status.get_trx_state(std::get<1>(trx_pairs_21[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_21->id); - BOOST_CHECK(ts->block_timestamp == bs_21->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_21->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_21_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(trx_pairs_22[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_22->id); - BOOST_CHECK(ts->block_timestamp == bs_22->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_22->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_22_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); @@ -482,63 +482,63 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { ts = status.get_trx_state(std::get<1>(trx_pairs_20[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[1])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[2])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[3])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(hold_pairs[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == eosio::chain::block_id_type{}); - BOOST_CHECK(ts->block_timestamp == eosio::chain::block_timestamp_type{}); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == eosio::chain::block_timestamp_type{}); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "FAILED"); ts = status.get_trx_state(std::get<1>(hold_pairs[1])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == eosio::chain::block_id_type{}); - BOOST_CHECK(ts->block_timestamp == eosio::chain::block_timestamp_type{}); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == eosio::chain::block_timestamp_type{}); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "FAILED"); ts = status.get_trx_state(std::get<1>(trx_pairs_21[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_21->id); - BOOST_CHECK(ts->block_timestamp == bs_21->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_21->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_21_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(trx_pairs_22[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_22->id); - BOOST_CHECK(ts->block_timestamp == bs_22->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_22->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_22_time); BOOST_CHECK_EQUAL(ts->status, "FORKED_OUT"); ts = status.get_trx_state(std::get<1>(trx_pairs_22_alt[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_22_alt->id); - BOOST_CHECK(ts->block_timestamp == bs_22_alt->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_22_alt->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_22_alt_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); @@ -567,49 +567,49 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { ts = status.get_trx_state(std::get<1>(trx_pairs_20[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "FAILED"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[1])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "FAILED"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[2])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_20_time); BOOST_CHECK_EQUAL(ts->status, "FAILED"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[3])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_20->id); - BOOST_CHECK(ts->block_timestamp == bs_20->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_20->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_20_time); BOOST_CHECK_EQUAL(ts->status, "FAILED"); ts = status.get_trx_state(std::get<1>(hold_pairs[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == eosio::chain::block_id_type{}); - BOOST_CHECK(ts->block_timestamp == eosio::chain::block_timestamp_type{}); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == eosio::chain::block_timestamp_type{}); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "FAILED"); ts = status.get_trx_state(std::get<1>(hold_pairs[1])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == eosio::chain::block_id_type{}); - BOOST_CHECK(ts->block_timestamp == eosio::chain::block_timestamp_type{}); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == eosio::chain::block_timestamp_type{}); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "FAILED"); ts = status.get_trx_state(std::get<1>(trx_pairs_21[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_21->id); - BOOST_CHECK(ts->block_timestamp == bs_21->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_21->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_21_time); BOOST_CHECK_EQUAL(ts->status, "FAILED"); @@ -617,21 +617,21 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { ts = status.get_trx_state(std::get<1>(trx_pairs_22[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_22->id); - BOOST_CHECK(ts->block_timestamp == bs_22->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_22->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_22_time); BOOST_CHECK_EQUAL(ts->status, "FAILED"); ts = status.get_trx_state(std::get<1>(trx_pairs_22_alt[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_22_alt->id); - BOOST_CHECK(ts->block_timestamp == bs_22_alt->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_22_alt->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_22_alt_time); BOOST_CHECK_EQUAL(ts->status, "FORKED_OUT"); ts = status.get_trx_state(std::get<1>(trx_pairs_19[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_19->id); - BOOST_CHECK(ts->block_timestamp == bs_19->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_19->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_19_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); @@ -675,49 +675,49 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { ts = status.get_trx_state(std::get<1>(trx_pairs_20[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_19_alt->id); - BOOST_CHECK(ts->block_timestamp == bs_19_alt->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_19_alt->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[1])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_19_alt->id); - BOOST_CHECK(ts->block_timestamp == bs_19_alt->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_19_alt->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[2])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_19_alt->id); - BOOST_CHECK(ts->block_timestamp == bs_19_alt->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_19_alt->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[3])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_19_alt->id); - BOOST_CHECK(ts->block_timestamp == bs_19_alt->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_19_alt->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(hold_pairs[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_19_alt->id); - BOOST_CHECK(ts->block_timestamp == bs_19_alt->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_19_alt->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); ts = status.get_trx_state(std::get<1>(hold_pairs[1])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == eosio::chain::block_id_type{}); - BOOST_CHECK(ts->block_timestamp == eosio::chain::block_timestamp_type{}); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == eosio::chain::block_timestamp_type{}); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "LOCALLY_APPLIED"); ts = status.get_trx_state(std::get<1>(trx_pairs_21[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_21->id); - BOOST_CHECK(ts->block_timestamp == bs_21->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_21->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_21_time); BOOST_CHECK_EQUAL(ts->status, "FORKED_OUT"); @@ -725,21 +725,21 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { ts = status.get_trx_state(std::get<1>(trx_pairs_22[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_22->id); - BOOST_CHECK(ts->block_timestamp == bs_22->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_22->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_22_time); BOOST_CHECK_EQUAL(ts->status, "FORKED_OUT"); ts = status.get_trx_state(std::get<1>(trx_pairs_22_alt[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_22_alt->id); - BOOST_CHECK(ts->block_timestamp == bs_22_alt->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_22_alt->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_22_alt_time); BOOST_CHECK_EQUAL(ts->status, "FORKED_OUT"); ts = status.get_trx_state(std::get<1>(trx_pairs_19[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_19_alt->id); - BOOST_CHECK(ts->block_timestamp == bs_19_alt->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_19_alt->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_19_time); BOOST_CHECK_EQUAL(ts->status, "IN_BLOCK"); @@ -763,49 +763,49 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { ts = status.get_trx_state(std::get<1>(trx_pairs_20[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_19_alt->id); - BOOST_CHECK(ts->block_timestamp == bs_19_alt->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_19_alt->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "IRREVERSIBLE"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[1])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_19_alt->id); - BOOST_CHECK(ts->block_timestamp == bs_19_alt->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_19_alt->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "IRREVERSIBLE"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[2])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_19_alt->id); - BOOST_CHECK(ts->block_timestamp == bs_19_alt->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_19_alt->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_20_time); BOOST_CHECK_EQUAL(ts->status, "IRREVERSIBLE"); ts = status.get_trx_state(std::get<1>(trx_pairs_20[3])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_19_alt->id); - BOOST_CHECK(ts->block_timestamp == bs_19_alt->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_19_alt->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_20_time); BOOST_CHECK_EQUAL(ts->status, "IRREVERSIBLE"); ts = status.get_trx_state(std::get<1>(hold_pairs[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_19_alt->id); - BOOST_CHECK(ts->block_timestamp == bs_19_alt->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_19_alt->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "IRREVERSIBLE"); ts = status.get_trx_state(std::get<1>(hold_pairs[1])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == eosio::chain::block_id_type{}); - BOOST_CHECK(ts->block_timestamp == eosio::chain::block_timestamp_type{}); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == eosio::chain::block_timestamp_type{}); BOOST_CHECK_EQUAL(std::string(ts->received), pre_block_20_time); BOOST_CHECK_EQUAL(ts->status, "LOCALLY_APPLIED"); ts = status.get_trx_state(std::get<1>(trx_pairs_21[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_21->id); - BOOST_CHECK(ts->block_timestamp == bs_21->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_21->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_21_time); BOOST_CHECK_EQUAL(ts->status, "FORKED_OUT"); @@ -813,21 +813,21 @@ BOOST_AUTO_TEST_CASE(trx_finality_status_logic) { try { ts = status.get_trx_state(std::get<1>(trx_pairs_22[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_22->id); - BOOST_CHECK(ts->block_timestamp == bs_22->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_22->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_22_time); BOOST_CHECK_EQUAL(ts->status, "FORKED_OUT"); ts = status.get_trx_state(std::get<1>(trx_pairs_22_alt[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_22_alt->id); - BOOST_CHECK(ts->block_timestamp == bs_22_alt->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_22_alt->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_22_alt_time); BOOST_CHECK_EQUAL(ts->status, "FORKED_OUT"); ts = status.get_trx_state(std::get<1>(trx_pairs_19[0])->id()); BOOST_REQUIRE(ts); BOOST_CHECK(ts->block_id == bs_19_alt->id); - BOOST_CHECK(ts->block_timestamp == bs_19_alt->block->timestamp); + BOOST_CHECK(block_timestamp_type(ts->block_timestamp) == bs_19_alt->block->timestamp); BOOST_CHECK_EQUAL(std::string(ts->received), block_19_time); BOOST_CHECK_EQUAL(ts->status, "IRREVERSIBLE"); diff --git a/plugins/chain_plugin/trx_retry_db.cpp b/plugins/chain_plugin/trx_retry_db.cpp index dd617279f0..a9863ce233 100644 --- a/plugins/chain_plugin/trx_retry_db.cpp +++ b/plugins/chain_plugin/trx_retry_db.cpp @@ -52,11 +52,14 @@ struct tracked_transaction { } size_t memory_size()const { return ptrx->get_estimated_size() + trx_trace_v.estimated_size() + sizeof(*this); } - +#if __cplusplus >= 202002L + [[no_unique_address]] noncopyable _; +#else tracked_transaction(const tracked_transaction&) = delete; tracked_transaction() = delete; tracked_transaction& operator=(const tracked_transaction&) = delete; tracked_transaction(tracked_transaction&&) = default; +#endif }; struct by_trx_id; diff --git a/plugins/resource_monitor_plugin/include/eosio/resource_monitor_plugin/file_space_handler.hpp b/plugins/resource_monitor_plugin/include/eosio/resource_monitor_plugin/file_space_handler.hpp index 6a5828c7fe..230edf62fb 100644 --- a/plugins/resource_monitor_plugin/include/eosio/resource_monitor_plugin/file_space_handler.hpp +++ b/plugins/resource_monitor_plugin/include/eosio/resource_monitor_plugin/file_space_handler.hpp @@ -138,7 +138,7 @@ namespace eosio::resource_monitor { timer.expires_from_now( boost::posix_time::seconds( sleep_time_in_secs )); - timer.async_wait([this](auto& ec) { + timer.async_wait([this](const auto& ec) { if ( ec ) { wlog("Exit due to error: ${ec}, message: ${message}", ("ec", ec.value()) From b40f23f64f84e46639f3dd8ea17b4e7c30a19dbd Mon Sep 17 00:00:00 2001 From: greg7mdp Date: Mon, 24 Apr 2023 10:00:19 -0400 Subject: [PATCH 2/3] Remove `#ifdef` preserving the `nocopy` constraint as per PR comment --- .../include/eosio/chain/unapplied_transaction_queue.hpp | 8 -------- plugins/chain_plugin/trx_retry_db.cpp | 8 -------- 2 files changed, 16 deletions(-) diff --git a/libraries/chain/include/eosio/chain/unapplied_transaction_queue.hpp b/libraries/chain/include/eosio/chain/unapplied_transaction_queue.hpp index 65775e6a7a..51f07e3cc7 100644 --- a/libraries/chain/include/eosio/chain/unapplied_transaction_queue.hpp +++ b/libraries/chain/include/eosio/chain/unapplied_transaction_queue.hpp @@ -37,14 +37,6 @@ struct unapplied_transaction { const transaction_id_type& id()const { return trx_meta->id(); } fc::time_point_sec expiration()const { return trx_meta->packed_trx()->expiration(); } -#if __cplusplus >= 202002L - [[no_unique_address]] noncopyable _; -#else - unapplied_transaction(const unapplied_transaction&) = delete; - unapplied_transaction() = delete; - unapplied_transaction& operator=(const unapplied_transaction&) = delete; - unapplied_transaction(unapplied_transaction&&) = default; -#endif }; /** diff --git a/plugins/chain_plugin/trx_retry_db.cpp b/plugins/chain_plugin/trx_retry_db.cpp index a9863ce233..5b93cb1943 100644 --- a/plugins/chain_plugin/trx_retry_db.cpp +++ b/plugins/chain_plugin/trx_retry_db.cpp @@ -52,14 +52,6 @@ struct tracked_transaction { } size_t memory_size()const { return ptrx->get_estimated_size() + trx_trace_v.estimated_size() + sizeof(*this); } -#if __cplusplus >= 202002L - [[no_unique_address]] noncopyable _; -#else - tracked_transaction(const tracked_transaction&) = delete; - tracked_transaction() = delete; - tracked_transaction& operator=(const tracked_transaction&) = delete; - tracked_transaction(tracked_transaction&&) = default; -#endif }; struct by_trx_id; From 6bf4c8881f1ed197f6cd53af09e611066e3b5e49 Mon Sep 17 00:00:00 2001 From: greg7mdp Date: Tue, 25 Apr 2023 13:06:43 -0400 Subject: [PATCH 3/3] remove no longer used `noncopyable` struct --- libraries/chain/include/eosio/chain/types.hpp | 8 -------- 1 file changed, 8 deletions(-) diff --git a/libraries/chain/include/eosio/chain/types.hpp b/libraries/chain/include/eosio/chain/types.hpp index 0a71ea9fdf..b0089f3a15 100644 --- a/libraries/chain/include/eosio/chain/types.hpp +++ b/libraries/chain/include/eosio/chain/types.hpp @@ -87,14 +87,6 @@ namespace eosio::chain { #endif struct void_t{}; - struct noncopyable { - noncopyable() = default; - noncopyable(noncopyable&&) = default; - noncopyable& operator=(noncopyable&&) = default; - noncopyable(const noncopyable&) = delete; - noncopyable& operator=(const noncopyable&) = delete; - }; - using chainbase::allocator; using shared_string = chainbase::shared_string; template