block_header.cpp

Go to the documentation of this file.

#include <sysio/chain/block.hpp>
#include <sysio/chain/merkle.hpp>
#include <fc/io/raw.hpp>
#include <fc/bitutil.hpp>
#include <algorithm>
 
namespace sysio { namespace chain {
   digest_type block_header::digest()const
   {
      return digest_type::hash(*this);
   }
 
   uint32_t block_header::num_from_id(const block_id_type& id)
   {
      return fc::endian_reverse_u32(id._hash[0]);
   }
 
   block_id_type block_header::calculate_id()const
   {
      // Do not include signed_block_header attributes in id, specifically exclude producer_signature.
      block_id_type result = digest(); //fc::sha256::hash(*static_cast<const block_header*>(this));
      result._hash[0] &= 0xffffffff00000000;
      result._hash[0] += fc::endian_reverse_u32(block_num()); // store the block num in the ID, 160 bits is plenty for the hash
      return result;
   }
 
   flat_multimap<uint16_t, block_header_extension> block_header::validate_and_extract_header_extensions()const {
      using decompose_t = block_header_extension_types::decompose_t;
 
      flat_multimap<uint16_t, block_header_extension> results;
 
      uint16_t id_type_lower_bound = 0;
 
      for( size_t i = 0; i < header_extensions.size(); ++i ) {
         const auto& e = header_extensions[i];
         auto id = e.first;
 
         SYS_ASSERT( id >= id_type_lower_bound, invalid_block_header_extension,
                     "Block header 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_header_extension>( id, e.second, iter->second );
         SYS_ASSERT( match, invalid_block_header_extension,
                     "Block header extension with id type ${id} is not supported",
                     ("id", id)
         );
 
         if( match->enforce_unique ) {
            SYS_ASSERT( i == 0 || id > id_type_lower_bound, invalid_block_header_extension,
                        "Block header extension with id type ${id} is not allowed to repeat",
                        ("id", id)
            );
         }
 
 
         id_type_lower_bound = id;
      }
 
      return results;
   }
 
} }