collator_messages.hpp

Go to the documentation of this file.

#ifndef KAGOME_COLLATOR_DECLARE_HPP
#define KAGOME_COLLATOR_DECLARE_HPP

#include <boost/variant.hpp>
#include <scale/bitvec.hpp>
#include <tuple>
#include <type_traits>
#include <vector>

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

namespace kagome::network {
  using Signature = crypto::Sr25519Signature;
  using ParachainId = uint32_t;
  using CollatorPublicKey = crypto::Sr25519PublicKey;
  using ValidatorIndex = uint32_t;
  using UpwardMessage = common::Buffer;
  using ParachainRuntime = common::Buffer;
  using HeadData = common::Buffer;
  using CandidateHash = primitives::BlockHash;
  using ChunkProof = std::vector<common::Buffer>;

  template <typename Payload>
  struct Signed {
    SCALE_TIE(3);

    static_assert(std::is_same_v<std::decay_t<Payload>, Payload>);

    Payload payload;
    ValidatorIndex validator_index;
    Signature signature;
  };

  using Dummy = std::tuple<>;

  using ViewUpdate = Dummy;

  struct CollatorAdvertisement {
    SCALE_TIE(1);

    primitives::BlockHash relay_parent;  
  };

  struct CollatorDeclaration {
    SCALE_TIE(3);

    CollatorPublicKey collator_id;  
    ParachainId para_id;            
    Signature signature;  
  };

  struct ErasureChunk {
    SCALE_TIE(3);

    common::Buffer chunk;
    ValidatorIndex index;
    ChunkProof proof;
  };

  struct ParachainBlock {
    SCALE_TIE(1);

    common::Buffer payload;  
  };

  struct CandidateDescriptor {
    SCALE_TIE(9);

    ParachainId para_id;  
    primitives::BlockHash
        relay_parent;  
    CollatorPublicKey collator_id;  
    primitives::BlockHash
        persisted_data_hash;         
    primitives::BlockHash pov_hash;  
    storage::trie::RootHash
        erasure_encoding_root;  
    Signature signature;  
    primitives::BlockHash
        para_head_hash;  
    primitives::BlockHash para_runtime_hash;  
  };

  struct CandidateReceipt {
    SCALE_TIE(2);

    CandidateDescriptor descriptor;          
    primitives::BlockHash commitments_hash;  
  };

  struct CollationResponse {
    SCALE_TIE(2);

    CandidateReceipt receipt;  
    ParachainBlock pov;        
  };

  using ReqCollationResponseData = boost::variant<CollationResponse>;

  struct CollationFetchingRequest {
    SCALE_TIE(2);

    primitives::BlockHash relay_parent;  
    ParachainId para_id;                 
  };

  struct CollationFetchingResponse {
    SCALE_TIE(1);

    ReqCollationResponseData response_data;  
  };

  struct OutboundHorizontal {
    SCALE_TIE(2);

    ParachainId para_id;       
    UpwardMessage upward_msg;  
  };

  struct CandidateCommitments {
    SCALE_TIE(6);

    std::vector<UpwardMessage> upward_msgs;  
    std::vector<OutboundHorizontal>
        outbound_hor_msgs;  
    std::optional<ParachainRuntime>
        opt_para_runtime;          
    HeadData para_head;            
    uint32_t downward_msgs_count;  
    uint32_t watermark;  
  };

  struct CommittedCandidateReceipt {
    SCALE_TIE(2);

    CandidateDescriptor descriptor;    
    CandidateCommitments commitments;  
  };

  using CandidateState = boost::variant<
      Dummy,                      
      CommittedCandidateReceipt,  
      primitives::BlockHash  
      >;

  struct Statement {
    SCALE_TIE(3);

    CandidateState candidate_state;
    ValidatorIndex validator_ix;
    Signature signature;
  };

  struct Seconded {
    SCALE_TIE(2);

    primitives::BlockHash relay_parent;  
    Statement statement;                 
  };

  using SignedBitfield = Signed<scale::BitVec>;

  using CollationMessage = boost::variant<
      CollatorDeclaration,    
      CollatorAdvertisement,  
      Dummy,    
      Dummy,    
      Seconded  
      >;

  using ProtocolMessage =
      boost::variant<CollationMessage  
                     >;

  using WireMessage = boost::variant<Dummy,            
                                     ProtocolMessage,  
                                     ViewUpdate        
                                     >;

  inline CandidateHash candidateHash(const crypto::Hasher &hasher,
                                     const CandidateReceipt &receipt) {
    return hasher.blake2b_256(scale::encode(receipt).value());
  }

  inline CandidateHash candidateHash(const crypto::Hasher &hasher,
                                     const CommittedCandidateReceipt &receipt) {
    return candidateHash(
        hasher,
        CandidateReceipt{
            receipt.descriptor,
            hasher.blake2b_256(scale::encode(receipt.commitments).value()),
        });
  }

  inline CandidateHash candidateHash(const crypto::Hasher &hasher,
                                     const CandidateState &statement) {
    if (auto receipt = boost::get<CommittedCandidateReceipt>(&statement)) {
      return candidateHash(hasher, *receipt);
    }
    return boost::get<CandidateHash>(statement);
  }
}  // namespace kagome::network

#endif  // KAGOME_COLLATOR_DECLARE_HPP