digest.hpp

Go to the documentation of this file.

#ifndef KAGOME_CORE_PRIMITIVES_DIGEST
#define KAGOME_CORE_PRIMITIVES_DIGEST

#include <boost/variant.hpp>

#include "common/buffer.hpp"
#include "common/tagged.hpp"
#include "common/unused.hpp"
#include "consensus/babe/types/babe_block_header.hpp"
#include "consensus/constants.hpp"
#include "primitives/babe_configuration.hpp"
#include "primitives/scheduled_change.hpp"
#include "scale/scale.hpp"
#include "scale/tie.hpp"

namespace kagome::primitives {
  using ConsensusEngineId = common::Blob<4>;

  inline const auto kBabeEngineId =
      ConsensusEngineId::fromString("BABE").value();

  inline const auto kGrandpaEngineId =
      ConsensusEngineId::fromString("FRNK").value();

  inline const auto kUnsupportedEngineId_POL1 =
      ConsensusEngineId::fromString("POL1").value();

  inline const auto kUnsupportedEngineId_BEEF =
      ConsensusEngineId::fromString("BEEF").value();

  struct Other : public common::Buffer {};

  namespace detail {
    struct DigestItemCommon {
      SCALE_TIE(2);

      ConsensusEngineId consensus_engine_id;

      common::SLBuffer<consensus::kMaxValidatorsNumber * 1024> data;
    };
  }  // namespace detail

  struct PreRuntime : public detail::DigestItemCommon {};

  using BabeDigest =
      boost::variant<Unused<0>,
                     NextEpochData,    // 1: (Auth C; R)
                     OnDisabled,       // 2: Auth ID
                     NextConfigData>;  // 3: c, S2nd

  using GrandpaDigest =
      boost::variant<Unused<0>,
                     ScheduledChange,  // 1: (Auth C; N delay)
                     ForcedChange,     // 2: (Auth C; N delay)
                     OnDisabled,       // 3: Auth ID
                     Pause,            // 4: N delay
                     Resume>;          // 5: N delay

  using UnsupportedDigest_POL1 = Tagged<Empty, struct POL1>;
  using UnsupportedDigest_BEEF = Tagged<Empty, struct BEEF>;

  struct DecodedConsensusMessage {
    static outcome::result<DecodedConsensusMessage> create(
        ConsensusEngineId engine_id, const common::Buffer &data) {
      if (engine_id == primitives::kBabeEngineId) {
        OUTCOME_TRY(payload, scale::decode<BabeDigest>(data));
        return DecodedConsensusMessage{engine_id, std::move(payload)};
      } else if (engine_id == primitives::kGrandpaEngineId) {
        OUTCOME_TRY(payload, scale::decode<GrandpaDigest>(data));
        return DecodedConsensusMessage{engine_id, std::move(payload)};
      } else if (engine_id == primitives::kUnsupportedEngineId_POL1) {
        OUTCOME_TRY(payload, scale::decode<UnsupportedDigest_POL1>(data));
        return DecodedConsensusMessage{engine_id, std::move(payload)};
      } else if (engine_id == primitives::kUnsupportedEngineId_BEEF) {
        OUTCOME_TRY(payload, scale::decode<UnsupportedDigest_BEEF>(data));
        return DecodedConsensusMessage{engine_id, std::move(payload)};
      }
      BOOST_ASSERT_MSG(false, "Invalid consensus engine id");
      BOOST_UNREACHABLE_RETURN({})
    }

    const BabeDigest &asBabeDigest() const {
      BOOST_ASSERT(consensus_engine_id == primitives::kBabeEngineId);
      return boost::relaxed_get<BabeDigest>(digest);
    }

    template <typename T>
    bool isBabeDigestOf() const {
      return consensus_engine_id == primitives::kBabeEngineId
             && boost::get<T>(&asBabeDigest()) != nullptr;
    }

    const GrandpaDigest &asGrandpaDigest() const {
      BOOST_ASSERT(consensus_engine_id == primitives::kGrandpaEngineId);
      return boost::relaxed_get<GrandpaDigest>(digest);
    }

    template <typename T>
    bool isGrandpaDigestOf() const {
      return consensus_engine_id == primitives::kGrandpaEngineId
             && boost::get<T>(&asGrandpaDigest()) != nullptr;
    }

    ConsensusEngineId consensus_engine_id;
    boost::variant<BabeDigest,
                   GrandpaDigest,
                   UnsupportedDigest_POL1,
                   UnsupportedDigest_BEEF>
        digest{};

   private:
    DecodedConsensusMessage() = default;
  };

  struct Consensus : public detail::DigestItemCommon {
    Consensus() = default;

    // Note: this ctor is needed only for tests
    template <class A>
    Consensus(const A &a) {
      // clang-format off
      if constexpr (std::is_same_v<A, NextEpochData>
                 or std::is_same_v<A, NextConfigData>) {
        consensus_engine_id = primitives::kBabeEngineId;
        data = common::Buffer(scale::encode(BabeDigest(a)).value());
      } else if constexpr (std::is_same_v<A, ScheduledChange>
                        or std::is_same_v<A, ForcedChange>
                        or std::is_same_v<A, OnDisabled>
                        or std::is_same_v<A, Pause>
                        or std::is_same_v<A, Resume>) {
        consensus_engine_id = primitives::kGrandpaEngineId;
        data = common::Buffer(scale::encode(GrandpaDigest(a)).value());
      } else {
        BOOST_UNREACHABLE_RETURN();
      }
      // clang-format on
    }

    outcome::result<DecodedConsensusMessage> decode() const {
      return DecodedConsensusMessage::create(consensus_engine_id, data);
    }
  };

  struct Seal : public detail::DigestItemCommon {};

  struct RuntimeEnvironmentUpdated : public Empty {};

  using DigestItem = boost::variant<Other,                       // 0
                                    Unused<1>,                   // 1
                                    Unused<2>,                   // 2
                                    Unused<3>,                   // 3
                                    Consensus,                   // 4
                                    Seal,                        // 5
                                    PreRuntime,                  // 6
                                    Unused<7>,                   // 7
                                    RuntimeEnvironmentUpdated>;  // 8

  namespace {
    // This value is enough to disable each of validators in each of two
    // consensus engines
    constexpr auto kMaxItemsInDigest = consensus::kMaxValidatorsNumber * 4;
  }  // namespace

  using Digest = common::SLVector<DigestItem, kMaxItemsInDigest>;

}  // namespace kagome::primitives

#endif  // KAGOME_CORE_PRIMITIVES_DIGEST