parachains_inherent_data.hpp

Go to the documentation of this file.

#include <scale/bitvec.hpp>

#include "common/stub.hpp"
#include "common/tagged.hpp"
#include "common/unused.hpp"
#include "network/types/collator_messages.hpp"
#include "primitives/common.hpp"

namespace kagome::consensus::babe {
  using Signature = crypto::Ed25519Signature;  // FIXME check actual type
  using ParachainId = uint32_t;
  using CollatorPublicKey =
      crypto::Ed25519PublicKey;  // FIXME check actual type

  struct CandidateDescriptor {
    ParachainId parachain_id;

    primitives::BlockHash relay_chain_block_hash;

    CollatorPublicKey collator_public_key;

    common::Hash256 validation_data_hash;

    primitives::BlockHash pov_block_hash;

    common::Hash256 merkle;

    Signature collator_signature;

    common::Hash256 parachain_head_data_hash;

    common::Hash256 parachain_runtime_hash;
  };

  scale::ScaleEncoderStream &operator<<(scale::ScaleEncoderStream &s,
                                        const CandidateDescriptor &data) {
    // clang-format off
    return s << data.parachain_id
             << data.relay_chain_block_hash
             << data.collator_public_key
             << data.validation_data_hash
             << data.pov_block_hash
             << data.merkle
             << data.collator_signature
             << data.parachain_head_data_hash
             << data.parachain_runtime_hash;
    // clang-format on
  }

  scale::ScaleDecoderStream &operator>>(scale::ScaleDecoderStream &s,
                                        CandidateDescriptor &data) {
    // clang-format off
    return s >> data.parachain_id
             >> data.relay_chain_block_hash
             >> data.collator_public_key
             >> data.validation_data_hash
             >> data.pov_block_hash
             >> data.merkle
             >> data.collator_signature
             >> data.parachain_head_data_hash
             >> data.parachain_runtime_hash;
    // clang-format on
  }

  struct RecipientTag {};
  using Recipient = Stub<RecipientTag>;  // FIXME

  struct UpwardMessageTag {};
  using UpwardMessage = Stub<UpwardMessageTag>;  // FIXME

  struct OutboundHrmpMessage {
    Recipient recipient;

    UpwardMessage message;
  };

  scale::ScaleEncoderStream &operator<<(scale::ScaleEncoderStream &s,
                                        const OutboundHrmpMessage &data) {
    return s << data.recipient << data.message;
  }

  scale::ScaleDecoderStream &operator>>(scale::ScaleDecoderStream &s,
                                        OutboundHrmpMessage &data) {
    return s >> data.recipient >> data.message;
  }

  struct CandidateCommitments {
    std::vector<common::Buffer> upward_messages;

    std::vector<OutboundHrmpMessage> outbound_messages;

    std::optional<common::Buffer>
        new_parachain_runtime;  // FIXME check actual type

    common::Buffer parachain_head_data;

    uint32_t number_of_downward_messages;

    uint32_t watermark;
  };

  scale::ScaleEncoderStream &operator<<(scale::ScaleEncoderStream &s,
                                        const CandidateCommitments &data) {
    // clang-format off
    return s << data.upward_messages
             << data.outbound_messages
             << data.new_parachain_runtime
             << data.parachain_head_data
             << data.number_of_downward_messages
             << data.watermark;
    // clang-format on
  }

  scale::ScaleDecoderStream &operator>>(scale::ScaleDecoderStream &s,
                                        CandidateCommitments &data) {
    // clang-format off
    return s >> data.upward_messages
             >> data.outbound_messages
             >> data.new_parachain_runtime
             >> data.parachain_head_data
             >> data.number_of_downward_messages
             >> data.watermark;
    // clang-format on
  }

  struct CandidateReceipt {
    CandidateDescriptor descriptor;
    CandidateCommitments commitments;
  };

  scale::ScaleEncoderStream &operator<<(scale::ScaleEncoderStream &s,
                                        const CandidateReceipt &data) {
    return s << data.descriptor << data.commitments;
  }

  scale::ScaleDecoderStream &operator>>(scale::ScaleDecoderStream &s,
                                        CandidateReceipt &data) {
    return s >> data.descriptor >> data.commitments;
  }

  using Attestation = boost::variant<Unused<0>,                            // 0
                                     Tagged<Signature, struct Implicit>,   // 1
                                     Tagged<Signature, struct Explicit>>;  // 2

  struct CommittedCandidate {
    CandidateReceipt candidate;

    std::vector<Attestation> validity_votes;

    scale::BitVec indices;
  };

  scale::ScaleEncoderStream &operator<<(scale::ScaleEncoderStream &s,
                                        const CommittedCandidate &data) {
    // clang-format off
    return s << data.candidate
             << data.validity_votes
             << data.indices;
    // clang-format on
  }

  scale::ScaleDecoderStream &operator>>(scale::ScaleDecoderStream &s,
                                        CommittedCandidate &data) {
    // clang-format off
    return s >> data.candidate
             >> data.validity_votes
             >> data.indices;
    // clang-format on
  }

  using DisputeStatement =
      boost::variant<Tagged<Empty, struct ExplicitStatement>,
                     Tagged<common::Hash256, struct SecondedStatement>,
                     Tagged<common::Hash256, struct ValidStatement>,
                     Tagged<Empty, struct AprovalVote>>;

  struct Vote {
    uint32_t validator_index;

    Signature signature;

    DisputeStatement statement;
  };

  scale::ScaleEncoderStream &operator<<(scale::ScaleEncoderStream &s,
                                        const Vote &data) {
    // clang-format off
    return s << data.validator_index
             << data.signature
             << data.statement;
    // clang-format on
  }

  scale::ScaleDecoderStream &operator>>(scale::ScaleDecoderStream &s,
                                        Vote &data) {
    // clang-format off
    return s >> data.validator_index
             >> data.signature
             >> data.statement;
    // clang-format on
  }

  struct DisputeRequest {
    CandidateReceipt candidate;

    uint32_t session_index;

    Vote invalid_vote;

    Vote valid_vote;
  };

  scale::ScaleEncoderStream &operator<<(scale::ScaleEncoderStream &s,
                                        const DisputeRequest &data) {
    // clang-format off
    return s << data.candidate
             << data.session_index
             << data.invalid_vote
             << data.valid_vote;
    // clang-format on
  }

  scale::ScaleDecoderStream &operator>>(scale::ScaleDecoderStream &s,
                                        DisputeRequest &data) {
    // clang-format off
    return s >> data.candidate
             >> data.session_index
             >> data.invalid_vote
             >> data.valid_vote;
    // clang-format on
  }

  struct ParachainInherentData {
    std::vector<network::SignedBitfield> bitfields;

    std::vector<Empty> backed_candidates;

    std::vector<DisputeRequest> disputes;

    primitives::BlockHeader parent_header;
  };

  scale::ScaleEncoderStream &operator<<(scale::ScaleEncoderStream &s,
                                        const ParachainInherentData &data) {
    // clang-format off
    return s << data.bitfields
             << data.backed_candidates
             << data.disputes
             << data.parent_header;
    // clang-format on
  }

  scale::ScaleDecoderStream &operator>>(scale::ScaleDecoderStream &s,
                                        ParachainInherentData &data) {
    // clang-format off
    return s >> data.bitfields
             >> data.backed_candidates
             >> data.disputes
             >> data.parent_header;
    // clang-format on
  }

}  // namespace kagome::consensus::babe