protocol.h

Go to the documentation of this file.

// Copyright (c) 2020 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_AVALANCHE_PROTOCOL_H
#define BITCOIN_AVALANCHE_PROTOCOL_H
 
#include <avalanche/delegation.h>
#include <protocol.h> // for CInv
#include <serialize.h>
#include <uint256.h>
 
#include <cstdint>
#include <limits>
#include <vector>
 
namespace avalanche {
 
class Vote {
    uint32_t error{std::numeric_limits<uint32_t>::max()};
    uint256 hash;
 
public:
    Vote() = default;
    Vote(uint32_t errorIn, uint256 hashIn) : error(errorIn), hash(hashIn) {}
 
    const uint256 &GetHash() const { return hash; }
    uint32_t GetError() const { return error; }
 
    // serialization support
    SERIALIZE_METHODS(Vote, obj) { READWRITE(obj.error, obj.hash); }
};
 
class Response {
    uint64_t round{std::numeric_limits<uint64_t>::max()};
    uint32_t cooldown{std::numeric_limits<uint32_t>::max()};
    std::vector<Vote> votes;
 
public:
    Response() = default;
    Response(uint64_t roundIn, uint32_t cooldownIn, std::vector<Vote> votesIn)
        : round(roundIn), cooldown(cooldownIn), votes(votesIn) {}
 
    uint64_t getRound() const { return round; }
    uint32_t getCooldown() const { return cooldown; }
    const std::vector<Vote> &GetVotes() const { return votes; }
 
    // serialization support
    SERIALIZE_METHODS(Response, obj) {
        READWRITE(obj.round, obj.cooldown, obj.votes);
    }
};
 
class Poll {
    uint64_t round;
    std::vector<CInv> invs;
 
public:
    Poll(uint64_t roundIn, std::vector<CInv> invsIn)
        : round(roundIn), invs(std::move(invsIn)) {}
 
    uint64_t GetRound() { return round; }
    const std::vector<CInv> &GetInvs() const { return invs; }
 
    // serialization support
    SERIALIZE_METHODS(Poll, obj) { READWRITE(obj.round, obj.invs); }
};
 
class Hello {
    Delegation delegation;
    SchnorrSig sig;
    uint32_t max_elements;
 
public:
    Hello(Delegation delegationIn, SchnorrSig sigIn, uint32_t max_elements_in)
        : delegation(std::move(delegationIn)), sig(sigIn),
          max_elements(max_elements_in) {}
 
    SchnorrSig GetSig() { return sig; }
    uint32_t GetMaxElements() const { return max_elements; }
 
    // serialization support
    SERIALIZE_METHODS(Hello, obj) {
        READWRITE(obj.delegation, obj.sig, obj.max_elements);
    }
};
 
} // namespace avalanche
 
#endif // BITCOIN_AVALANCHE_PROTOCOL_H