text: // Copyright (c) 2009-2010 Satoshi Nakamoto
  // Copyright (c) 2017-2019 The DragonBallChain Developers
  // Distributed under the MIT/X11 software license, see the accompanying
  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  
  #ifndef __cplusplus
  # error This header can only be compiled as C++.
  #endif
  
  #ifndef __INCLUDED_PROTOCOL_H__
  #define __INCLUDED_PROTOCOL_H__
  
  #include "config/chainparams.h"
  #include "netbase.h"
  #include "commons/serialize.h"
  #include "commons/uint256.h"
  
  #include <stdint.h>
  #include <string>
  
  /** Message header.
   * (4) message start.
   * (12) command.
   * (4) size.
   * (4) checksum.
   */
  class CMessageHeader
  {
      public:
          CMessageHeader();
          CMessageHeader(const char* pszCommand, uint32_t nMessageSizeIn);
  
          std::string GetCommand() const;
          bool IsValid() const;
  
          IMPLEMENT_SERIALIZE
              (
               READWRITE(FLATDATA(pchMessageStart));
               READWRITE(FLATDATA(pchCommand));
               READWRITE(nMessageSize);
               READWRITE(nChecksum);
              )
  
      // TODO: make private (improves encapsulation)
      public:
          enum {
              COMMAND_SIZE=12,
              MESSAGE_SIZE_SIZE=sizeof(int32_t),
              CHECKSUM_SIZE=sizeof(int32_t),
  
              MESSAGE_SIZE_OFFSET=MESSAGE_START_SIZE+COMMAND_SIZE,
              CHECKSUM_OFFSET=MESSAGE_SIZE_OFFSET+MESSAGE_SIZE_SIZE,
              HEADER_SIZE=MESSAGE_START_SIZE+COMMAND_SIZE+MESSAGE_SIZE_SIZE+CHECKSUM_SIZE
          };
          char pchMessageStart[MESSAGE_START_SIZE];
          char pchCommand[COMMAND_SIZE];
          uint32_t nMessageSize;
          uint32_t nChecksum;
  };
  
  /** nServices flags */
  enum
  {
      NODE_NETWORK = (1 << 0),
  };
  
  
  /**
   * Bitcoin protocol message types. When adding new message types, don't forget
   * to update allNetMessageTypes in protocol.cpp.
   */
  namespace NetMsgType {
  
  /**
   * The version message provides information about the transmitting node to the
   * receiving node at the beginning of a connection.
   * @see https://bitcoin.org/en/developer-reference#version
   */
  extern const char *VERSION;
  /**
   * The verack message acknowledges a previously-received version message,
   * informing the connecting node that it can begin to send other messages.
   * @see https://bitcoin.org/en/developer-reference#verack
   */
  extern const char *VERACK;
  /**
   * The addr (IP address) message relays connection information for peers on the
   * network.
   * @see https://bitcoin.org/en/developer-reference#addr
   */
  extern const char *ADDR;
  /**
   * The inv message (inventory message) transmits one or more inventories of
   * objects known to the transmitting peer.
   * @see https://bitcoin.org/en/developer-reference#inv
   */
  extern const char *INV;
  /**
   * The getdata message requests one or more data objects from another node.
   * @see https://bitcoin.org/en/developer-reference#getdata
   */
  extern const char *GETDATA;
  /**
   * The merkleblock message is a reply to a getdata message which requested a
   * block using the inventory type MSG_MERKLEBLOCK.
   * @since protocol version 70001 as described by BIP37.
   * @see https://bitcoin.org/en/developer-reference#merkleblock
   */
  // extern const char *MERKLEBLOCK;
  /**
   * The getblocks message requests an inv message that provides block header
   * hashes starting from a particular point in the block chain.
   * @see https://bitcoin.org/en/developer-reference#getblocks
   */
  extern const char *GETBLOCKS;
  /**
   * The getheaders message requests a headers message that provides block
   * headers starting from a particular point in the block chain.
   * @since protocol version 31800.
   * @see https://bitcoin.org/en/developer-reference#getheaders
   */
  extern const char *GETHEADERS;
  /**
   * The tx message transmits a single transaction.
   * @see https://bitcoin.org/en/developer-reference#tx
   */
  extern const char *TX;
  /**
   * The headers message sends one or more block headers to a node which
   * previously requested certain headers with a getheaders message.
   * @since protocol version 31800.
   * @see https://bitcoin.org/en/developer-reference#headers
   */
  // extern const char *HEADERS;
  /**
   * The block message transmits a single serialized block.
   * @see https://bitcoin.org/en/developer-reference#block
   */
  extern const char *BLOCK;
  /**
   * The getaddr message requests an addr message from the receiving node,
   * preferably one with lots of IP addresses of other receiving nodes.
   * @see https://bitcoin.org/en/developer-reference#getaddr
   */
  extern const char *GETADDR;
  /**
   * The mempool message requests the TXIDs of transactions that the receiving
   * node has verified as valid but which have not yet appeared in a block.
   * @since protocol version 60002.
   * @see https://bitcoin.org/en/developer-reference#mempool
   */
  extern const char *MEMPOOL;
  /**
   * The ping message is sent periodically to help confirm that the receiving
   * peer is still connected.
   * @see https://bitcoin.org/en/developer-reference#ping
   */
  extern const char *PING;
  /**
   * The pong message replies to a ping message, proving to the pinging node that
   * the ponging node is still alive.
   * @since protocol version 60001 as described by BIP31.
   * @see https://bitcoin.org/en/developer-reference#pong
   */
  extern const char *PONG;
  /**
   * The notfound message is a reply to a getdata message which requested an
   * object the receiving node does not have available for relay.
   * @since protocol version 70001.
   * @see https://bitcoin.org/en/developer-reference#notfound
   */
  // extern const char *NOTFOUND;
  extern const char *ALERT;
  /**
   * The filterload message tells the receiving peer to filter all relayed
   * transactions and requested merkle blocks through the provided filter.
   * @since protocol version 70001 as described by BIP37.
   *   Only available with service bit NODE_BLOOM since protocol version
   *   70011 as described by BIP111.
   * @see https://bitcoin.org/en/developer-reference#filterload
   */
  extern const char *FILTERLOAD;
  /**
   * The filteradd message tells the receiving peer to add a single element to a
   * previously-set bloom filter, such as a new public key.
   * @since protocol version 70001 as described by BIP37.
   *   Only available with service bit NODE_BLOOM since protocol version
   *   70011 as described by BIP111.
   * @see https://bitcoin.org/en/developer-reference#filteradd
   */
  extern const char *FILTERADD;
  /**
   * The filterclear message tells the receiving peer to remove a previously-set
   * bloom filter.
   * @since protocol version 70001 as described by BIP37.
   *   Only available with service bit NODE_BLOOM since protocol version
   *   70011 as described by BIP111.
   * @see https://bitcoin.org/en/developer-reference#filterclear
   */
  extern const char *FILTERCLEAR;
  /**
   * The reject message informs the receiving node that one of its previous
   * messages has been rejected.
   * @since protocol version 70002 as described by BIP61.
   * @see https://bitcoin.org/en/developer-reference#reject
   */
  extern const char *REJECT;
  /**
   * Indicates that a node prefers to receive new block announcements via a
   * "headers" message rather than an "inv".
   * @since protocol version 70012 as described by BIP130.
   * @see https://bitcoin.org/en/developer-reference#sendheaders
   */
  extern const char *SENDHEADERS;
  /**
   * The feefilter message tells the receiving peer not to inv us any txs
   * which do not meet the specified min fee rate.
   * @since protocol version 70013 as described by BIP133
   */
  extern const char *FEEFILTER;
  /**
   * Contains a 1-byte bool and 8-byte LE version number.
   * Indicates that a node is willing to provide blocks via "cmpctblock" messages.
   * May indicate that a node prefers to receive new block announcements via a
   * "cmpctblock" message rather than an "inv", depending on message contents.
   * @since protocol version 70014 as described by BIP 152
   */
  extern const char *SENDCMPCT;
  /**
   * Contains a CBlockHeaderAndShortTxIDs object - providing a header and
   * list of "short txids".
   * @since protocol version 70014 as described by BIP 152
   */
  extern const char *CMPCTBLOCK;
  /**
   * Contains a BlockTransactionsRequest
   * Peer should respond with "blocktxn" message.
   * @since protocol version 70014 as described by BIP 152
   */
  extern const char *GETBLOCKTXN;
  /**
   * Contains a BlockTransactions.
   * Sent in response to a "getblocktxn" message.
   * @since protocol version 70014 as described by BIP 152
   */
  extern const char *BLOCKTXN;
  
  /**
   * the message must be send by miner,means the the
   * miner had checked the block  and it's valid;
   * @since protocol version 70014 as described by BIP 152
   */
  extern const char *CONFIRMBLOCK;
  
  extern const char *FINALITYBLOCK;
  };
  
  enum PBFTMsgType {
  
      CONFIRM_BLOCK =1 ,
      FINALITY_BLOCK =2 ,
  
  };
  
  /** A CService with information about it as peer */
  class CAddress : public CService
  {
      public:
          CAddress();
          explicit CAddress(CService ipIn, uint64_t nServicesIn=NODE_NETWORK);
  
          void Init();
  
          IMPLEMENT_SERIALIZE
              (
               CAddress* pthis = const_cast<CAddress*>(this);
               CService* pip = (CService*)pthis;
               if (fRead)
                   pthis->Init();
               if (nType & SER_DISK)
                   READWRITE(nVersion);
               if ((nType & SER_DISK) /*|| (nVersion >= CADDR_TIME_VERSION && !(nType & SER_GETHASH))*/)
                   READWRITE(nTime);
               READWRITE(nServices);
               READWRITE(*pip);
              )
  
          void Print() const;
  
      // TODO: make private (improves encapsulation)
      public:
          uint64_t nServices;
  
          // disk and network only
          uint32_t nTime;
  
          // memory only
          int64_t nLastTry;
  };
  
  /** inv message data */
  class CInv
  {
      public:
          CInv();
          CInv(int32_t typeIn, const uint256& hashIn);
          CInv(const std::string& strType, const uint256& hashIn);
  
          IMPLEMENT_SERIALIZE
          (
              READWRITE(type);
              READWRITE(hash);
          )
  
          friend bool operator<(const CInv& a, const CInv& b);
  
          bool IsKnownType() const;
          const char* GetCommand() const;
          std::string ToString() const;
          void Print() const;
  
      // TODO: make private (improves encapsulation)
      public:
          int32_t type;
          uint256 hash;
  };
  
  class CPBFTMessage{
  public:
      vector<unsigned char > vSignature;
      CRegID miner;
      uint32_t height;
      uint256 blockHash;
      uint256 preBlockHash;
      int32_t msgType;
  
  
  
      bool SetSignature(const vector<unsigned char> signature) { vSignature = signature;  return true;};
  
      IMPLEMENT_SERIALIZE
      (
              READWRITE(msgType);
              READWRITE(vSignature);
              READWRITE(miner);
              READWRITE(height);
              READWRITE(blockHash);
              READWRITE(preBlockHash);
      )
  
      friend bool operator<(const CPBFTMessage& a , const CPBFTMessage& b);
  
      uint256 GetHash() const;
  
      string GetBlockId() const {
          return strprintf("[%u]%s", height, blockHash.ToString());
      }
  
  };
  
  class CBlockConfirmMessage: public CPBFTMessage{
  public:
      CBlockConfirmMessage() = default;
      CBlockConfirmMessage(const uint32_t heightIn,
                   const uint256 blockHashIn, const uint256 preBlockHashIn){
          msgType = PBFTMsgType::CONFIRM_BLOCK;
          height = heightIn;
          blockHash = blockHashIn;
          preBlockHash = preBlockHashIn;
      }
  };
  class CBlockFinalityMessage: public CPBFTMessage{
  public:
      CBlockFinalityMessage() = default;
      CBlockFinalityMessage(const uint32_t heightIn,
                           const uint256 blockHashIn, const uint256 preBlockHashIn){
          msgType = PBFTMsgType::FINALITY_BLOCK;
          height = heightIn;
          blockHash = blockHashIn;
          preBlockHash = preBlockHashIn;
      }
  };
  
  enum
  {
      MSG_TX = 1,
      MSG_BLOCK,
      // Nodes may always request a MSG_FILTERED_BLOCK in a getdata, however,
      // MSG_FILTERED_BLOCK should not appear in any invs except as a part of getdata.
      MSG_FILTERED_BLOCK,
  };
  
  #endif // __INCLUDED_PROTOCOL_H__
  