block_state.cpp

Go to the documentation of this file.

#include <sysio/chain/block_state.hpp>
#include <sysio/chain/exceptions.hpp>
 
namespace sysio { namespace chain {
 
   namespace {
      constexpr auto additional_sigs_eid = additional_block_signatures_extension::extension_id();
 
      vector<signature_type> extract_additional_signatures( const signed_block_ptr& b,
                                                            const protocol_feature_set& pfs,
                                                            const protocol_feature_activation_set_ptr& pfa )
      {
         auto exts = b->validate_and_extract_extensions();
 
         if ( exts.count(additional_sigs_eid) > 0 ) {
            auto& additional_sigs = std::get<additional_block_signatures_extension>(exts.lower_bound(additional_sigs_eid)->second);
 
            return std::move(additional_sigs.signatures);
         }
 
         return {};
      }
 
      template<typename ...Extras>
      block_header_state inject_additional_signatures( pending_block_header_state&& cur,
                                                       signed_block& b,
                                                       const protocol_feature_set& pfs,
                                                       Extras&& ... extras )
      {
         auto pfa = cur.prev_activated_protocol_features;
         block_header_state result = std::move(cur).finish_next(b, pfs, std::forward<Extras>(extras)...);
 
         if (!result.additional_signatures.empty()) {
            bool wtmsig_enabled = detail::is_builtin_activated(pfa, pfs, builtin_protocol_feature_t::wtmsig_block_signatures);
 
            SYS_ASSERT(wtmsig_enabled, block_validate_exception,
                       "Block has multiple signatures before activation of WTMsig Block Signatures");
 
            // as an optimization we don't copy this out into the legitimate extension structure as it serializes
            // the same way as the vector of signatures
            static_assert(fc::reflector<additional_block_signatures_extension>::total_member_count == 1);
            static_assert(std::is_same_v<decltype(additional_block_signatures_extension::signatures), std::vector<signature_type>>);
 
            emplace_extension(b.block_extensions, additional_sigs_eid, fc::raw::pack( result.additional_signatures ));
         }
 
         return result;
      }
 
   }
 
   block_state::block_state( const block_header_state& prev,
                             signed_block_ptr b,
                             const protocol_feature_set& pfs,
                             const std::function<void( block_timestamp_type,
                                                       const flat_set<digest_type>&,
                                                       const vector<digest_type>& )>& validator,
                             bool skip_validate_signee
                           )
   :block_header_state( prev.next( *b, extract_additional_signatures(b, pfs, prev.activated_protocol_features), pfs, validator, skip_validate_signee ) )
   ,block( std::move(b) )
   {}
 
   block_state::block_state( pending_block_header_state&& cur,
                             signed_block_ptr&& b,
                             vector<transaction_metadata_ptr>&& trx_metas,
                             const protocol_feature_set& pfs,
                             const std::function<void( block_timestamp_type,
                                                       const flat_set<digest_type>&,
                                                       const vector<digest_type>& )>& validator,
                             const signer_callback_type& signer
                           )
   :block_header_state( inject_additional_signatures( std::move(cur), *b, pfs, validator, signer ) )
   ,block( std::move(b) )
   ,_pub_keys_recovered( true ) // called by produce_block so signature recovery of trxs must have been done
   ,_cached_trxs( std::move(trx_metas) )
   {}
 
} }