protocol.hpp

Go to the documentation of this file.

#pragma once
#include <sysio/chain/block.hpp>
#include <sysio/chain/types.hpp>
#include <chrono>
 
namespace sysio {
   using namespace chain;
   using namespace fc;
 
   static_assert(sizeof(std::chrono::system_clock::duration::rep) >= 8, "system_clock is expected to be at least 64 bits");
   typedef std::chrono::system_clock::duration::rep tstamp;
 
   struct chain_size_message {
      uint32_t                   last_irreversible_block_num = 0;
      block_id_type              last_irreversible_block_id;
      uint32_t                   head_num = 0;
      block_id_type              head_id;
   };
 
   // Longest domain name is 253 characters according to wikipedia.
   // Addresses include ":port" where max port is 65535, which adds 6 chars.
   // We also add our own extentions of "[:trx|:blk] - xxxxxxx", which adds 14 chars, total= 273.
   // Allow for future extentions as well, hence 384.
   constexpr size_t max_p2p_address_length = 253 + 6;
   constexpr size_t max_handshake_str_length = 384;
 
   struct handshake_message {
      uint16_t                   network_version = 0; 
      chain_id_type              chain_id; 
      fc::sha256                 node_id; 
      chain::public_key_type     key; 
      int64_t                    time{0}; 
      fc::sha256                 token; 
      chain::signature_type      sig; 
      string                     p2p_address;
      uint32_t                   last_irreversible_block_num = 0;
      block_id_type              last_irreversible_block_id;
      uint32_t                   head_num = 0;
      block_id_type              head_id;
      string                     os;
      string                     agent;
      int16_t                    generation = 0;
   };
 
 
  enum go_away_reason {
    no_reason, 
    self, 
    duplicate, 
    wrong_chain, 
    wrong_version, 
    forked, 
    unlinkable, 
    bad_transaction, 
    validation, 
    benign_other, 
    fatal_other, 
    authentication 
  };
 
  constexpr auto reason_str( go_away_reason rsn ) {
    switch (rsn ) {
    case no_reason : return "no reason";
    case self : return "self connect";
    case duplicate : return "duplicate";
    case wrong_chain : return "wrong chain";
    case wrong_version : return "wrong version";
    case forked : return "chain is forked";
    case unlinkable : return "unlinkable block received";
    case bad_transaction : return "bad transaction";
    case validation : return "invalid block";
    case authentication : return "authentication failure";
    case fatal_other : return "some other failure";
    case benign_other : return "some other non-fatal condition, possibly unknown block";
    default : return "some crazy reason";
    }
  }
 
  struct go_away_message {
    go_away_message(go_away_reason r = no_reason) : reason(r), node_id() {}
    go_away_reason reason{no_reason};
    fc::sha256 node_id; 
  };
 
  struct time_message {
            tstamp  org{0};       
            tstamp  rec{0};       
            tstamp  xmt{0};       
    mutable tstamp  dst{0};       
  };
 
  enum id_list_modes {
    none,
    catch_up,
    last_irr_catch_up,
    normal
  };
 
  constexpr auto modes_str( id_list_modes m ) {
    switch( m ) {
    case none : return "none";
    case catch_up : return "catch up";
    case last_irr_catch_up : return "last irreversible";
    case normal : return "normal";
    default: return "undefined mode";
    }
  }
 
  template<typename T>
  struct select_ids {
    select_ids() : mode(none),pending(0),ids() {}
    id_list_modes  mode{none};
    uint32_t       pending{0};
    vector<T>      ids;
    bool           empty () const { return (mode == none || ids.empty()); }
  };
 
  using ordered_txn_ids = select_ids<transaction_id_type>;
  using ordered_blk_ids = select_ids<block_id_type>;
 
  struct notice_message {
    notice_message() : known_trx(), known_blocks() {}
    ordered_txn_ids known_trx;
    ordered_blk_ids known_blocks;
  };
 
  struct request_message {
    request_message() : req_trx(), req_blocks() {}
    ordered_txn_ids req_trx;
    ordered_blk_ids req_blocks;
  };
 
   struct sync_request_message {
      uint32_t start_block{0};
      uint32_t end_block{0};
   };
 
   using net_message = std::variant<handshake_message,
                                    chain_size_message,
                                    go_away_message,
                                    time_message,
                                    notice_message,
                                    request_message,
                                    sync_request_message,
                                    signed_block,         // which = 7
                                    packed_transaction>;  // which = 8
 
} // namespace sysio
 
FC_REFLECT( sysio::select_ids<fc::sha256>, (mode)(pending)(ids) )
FC_REFLECT( sysio::chain_size_message,
            (last_irreversible_block_num)(last_irreversible_block_id)
            (head_num)(head_id))
FC_REFLECT( sysio::handshake_message,
            (network_version)(chain_id)(node_id)(key)
            (time)(token)(sig)(p2p_address)
            (last_irreversible_block_num)(last_irreversible_block_id)
            (head_num)(head_id)
            (os)(agent)(generation) )
FC_REFLECT( sysio::go_away_message, (reason)(node_id) )
FC_REFLECT( sysio::time_message, (org)(rec)(xmt)(dst) )
FC_REFLECT( sysio::notice_message, (known_trx)(known_blocks) )
FC_REFLECT( sysio::request_message, (req_trx)(req_blocks) )
FC_REFLECT( sysio::sync_request_message, (start_block)(end_block) )