wtmsig block production

libraries/chain/CMakeLists.txt

@@ -21,6 +21,7 @@ add_library( eosio_chain
              merkle.cpp
              name.cpp
              transaction.cpp
+             block.cpp
              block_header.cpp
              block_header_state.cpp
              block_state.cpp
@@ -60,6 +61,7 @@ add_library( eosio_chain
              protocol_state_object.cpp
              protocol_feature_activation.cpp
              protocol_feature_manager.cpp
+             producer_schedule.cpp
              genesis_intrinsics.cpp
              whitelisted_intrinsics.cpp
              thread_utils.cpp

libraries/chain/apply_context.cpp

@@ -372,8 +372,8 @@ void apply_context::schedule_deferred_transaction( const uint128_t& sender_id, a
                      ("expected", trx_context.id)("actual", context.sender_trx_id)
          );
       } else {
-         FC_ASSERT( trx.transaction_extensions.size() == 0, "invariant failure" );
-         trx.transaction_extensions.emplace_back(
+         emplace_extension(
+            trx.transaction_extensions,
             deferred_transaction_generation_context::extension_id(),
             fc::raw::pack( deferred_transaction_generation_context( trx_context.id, sender_id, receiver ) )
          );

libraries/chain/block.cpp

@@ -0,0 +1,68 @@
+/**
+ *  @file
+ *  @copyright defined in eos/LICENSE
+ */
+#include <eosio/chain/block.hpp>
+
+namespace eosio { namespace chain {
+   void additional_block_signatures_extension::reflector_init() {
+      static_assert( fc::raw::has_feature_reflector_init_on_unpacked_reflected_types,
+                     "additional_block_signatures_extension expects FC to support reflector_init" );
+
+      EOS_ASSERT( signatures.size() > 0, ill_formed_additional_block_signatures_extension,
+                  "Additional block signatures extension must contain at least one signature",
+      );
+
+      set<signature_type> unique_sigs;
+
+      for( const auto& s : signatures ) {
+         auto res = unique_sigs.insert( s );
+         EOS_ASSERT( res.second, ill_formed_additional_block_signatures_extension,
+                     "Signature ${s} was repeated in the additional block signatures extension",
+                     ("s", s)
+         );
+      }
+   }
+
+   flat_multimap<uint16_t, block_extension> signed_block::validate_and_extract_extensions()const {
+      using decompose_t = block_extension_types::decompose_t;
+
+      flat_multimap<uint16_t, block_extension> results;
+
+      uint16_t id_type_lower_bound = 0;
+
+      for( size_t i = 0; i < block_extensions.size(); ++i ) {
+         const auto& e = block_extensions[i];
+         auto id = e.first;
+
+         EOS_ASSERT( id >= id_type_lower_bound, invalid_block_extension,
+                     "Block extensions are not in the correct order (ascending id types required)"
+         );
+
+         auto iter = results.emplace(std::piecewise_construct,
+            std::forward_as_tuple(id),
+            std::forward_as_tuple()
+         );
+
+         auto match = decompose_t::extract<block_extension>( id, e.second, iter->second );
+         EOS_ASSERT( match, invalid_block_extension,
+                     "Block extension with id type ${id} is not supported",
+                     ("id", id)
+         );
+
+         if( match->enforce_unique ) {
+            EOS_ASSERT( i == 0 || id > id_type_lower_bound, invalid_block_header_extension,
+                        "Block extension with id type ${id} is not allowed to repeat",
+                        ("id", id)
+            );
+         }
+
+
+         id_type_lower_bound = id;
+      }
+
+      return results;
+
+   }
+
+} } /// namespace eosio::chain

libraries/chain/block_header.cpp

@@ -28,14 +28,14 @@ namespace eosio { namespace chain {
       return result;
    }
 
-   vector<block_header_extensions> block_header::validate_and_extract_header_extensions()const {
+   flat_multimap<uint16_t, block_header_extensions> block_header::validate_and_extract_header_extensions()const {
       using block_header_extensions_t = block_header_extension_types::block_header_extensions_t;
       using decompose_t = block_header_extension_types::decompose_t;
 
       static_assert( std::is_same<block_header_extensions_t, block_header_extensions>::value,
                      "block_header_extensions is not setup as expected" );
 
-      vector<block_header_extensions_t> results;
+      flat_multimap<uint16_t, block_header_extensions> results;
 
       uint16_t id_type_lower_bound = 0;
 
@@ -47,9 +47,12 @@ namespace eosio { namespace chain {
                      "Block header extensions are not in the correct order (ascending id types required)"
          );
 
-         results.emplace_back();
+         auto iter = results.emplace(std::piecewise_construct,
+            std::forward_as_tuple(id),
+            std::forward_as_tuple()
+         );
 
-         auto match = decompose_t::extract<block_header_extensions_t>( id, e.second, results.back() );
+         auto match = decompose_t::extract<block_header_extensions_t>( id, e.second, iter->second );
          EOS_ASSERT( match, invalid_block_header_extension,
                      "Block header extension with id type ${id} is not supported",
                      ("id", id)
@@ -62,6 +65,7 @@ namespace eosio { namespace chain {
             );
          }
 
+
          id_type_lower_bound = id;
       }