block_header.hpp

Go to the documentation of this file.

#ifndef KAGOME_PRIMITIVES_BLOCK_HEADER_HPP
#define KAGOME_PRIMITIVES_BLOCK_HEADER_HPP

#include <type_traits>
#include <vector>

#include <scale/scale.hpp>

#include "common/blob.hpp"
#include "crypto/hasher.hpp"
#include "primitives/common.hpp"
#include "primitives/compact_integer.hpp"
#include "primitives/digest.hpp"
#include "storage/trie/types.hpp"

namespace kagome::primitives {
  struct BlockHeader {
    BlockHash parent_hash{};  
    BlockNumber number = 0u;  
    storage::trie::RootHash state_root{};  
    common::Hash256 extrinsics_root{};     
    Digest digest{};                       

    bool operator==(const BlockHeader &rhs) const {
      return std::tie(parent_hash, number, state_root, extrinsics_root, digest)
             == std::tie(rhs.parent_hash,
                         rhs.number,
                         rhs.state_root,
                         rhs.extrinsics_root,
                         rhs.digest);
    }

    bool operator!=(const BlockHeader &rhs) const {
      return !operator==(rhs);
    }
  };

  struct GenesisBlockHeader {
    const BlockHeader header;
    const BlockHash hash;
  };

  template <class Stream,
            typename = std::enable_if_t<Stream::is_encoder_stream>>
  Stream &operator<<(Stream &s, const BlockHeader &bh) {
    return s << bh.parent_hash << CompactInteger(bh.number) << bh.state_root
             << bh.extrinsics_root << bh.digest;
  }

  template <class Stream,
            typename = std::enable_if_t<Stream::is_decoder_stream>>
  Stream &operator>>(Stream &s, BlockHeader &bh) {
    CompactInteger number_compact;
    s >> bh.parent_hash >> number_compact >> bh.state_root >> bh.extrinsics_root
        >> bh.digest;
    bh.number = number_compact.convert_to<BlockNumber>();
    return s;
  }

  outcome::result<BlockHash> calculateBlockHash(
      BlockHeader const &header, crypto::Hasher const &hasher);

}  // namespace kagome::primitives

#endif  // KAGOME_PRIMITIVES_BLOCK_HEADER_HPP