watchtower.hpp

Go to the documentation of this file.

// Copyright (c) 2021 MIT Digital Currency Initiative,
//                    Federal Reserve Bank of Boston
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef OPENCBDC_TX_SRC_WATCHTOWER_WATCHTOWER_H_
#define OPENCBDC_TX_SRC_WATCHTOWER_WATCHTOWER_H_
 
#include "block_cache.hpp"
#include "error_cache.hpp"
#include "messages.hpp"
#include "status_update.hpp"
 
namespace cbdc::watchtower {
    struct best_block_height_request {
        auto operator==(const best_block_height_request& /* unused */) const
            -> bool;
 
        best_block_height_request() = default;
 
        explicit best_block_height_request(cbdc::serializer& pkt);
    };
 
    class best_block_height_response {
      public:
        friend auto cbdc::operator<<(
            cbdc::serializer& packet,
            const cbdc::watchtower::best_block_height_response& bbh_res)
            -> cbdc::serializer&;
        friend auto
        cbdc::operator>>(cbdc::serializer& packet,
                         cbdc::watchtower::best_block_height_response& bbh_res)
            -> cbdc::serializer&;
 
        auto operator==(const best_block_height_response& rhs) const -> bool;
 
        best_block_height_response() = delete;
 
        explicit best_block_height_response(uint64_t height);
 
        explicit best_block_height_response(cbdc::serializer& pkt);
 
        [[nodiscard]] auto height() const -> uint64_t;
 
      private:
        uint64_t m_height{};
    };
 
    class request {
      public:
        friend auto cbdc::operator<<(cbdc::serializer& packet,
                                     const cbdc::watchtower::request& req)
            -> cbdc::serializer&;
 
        auto operator==(const request& rhs) const -> bool;
 
        request() = delete;
 
        using request_t
            = std::variant<status_update_request, best_block_height_request>;
 
        explicit request(request_t req);
 
        explicit request(cbdc::serializer& pkt);
 
        [[nodiscard]] auto payload() const -> const request_t&;
 
      private:
        request_t m_req;
    };
 
    class response {
      public:
        friend auto cbdc::operator<<(cbdc::serializer& packet,
                                     const cbdc::watchtower::response& res)
            -> cbdc::serializer&;
 
        auto operator==(const response& rhs) const -> bool;
 
        response() = delete;
 
        using response_t = std::variant<status_request_check_success,
                                        best_block_height_response>;
 
        explicit response(response_t resp);
 
        explicit response(cbdc::serializer& pkt);
 
        [[nodiscard]] auto payload() const -> const response_t&;
 
      private:
        response_t m_resp;
    };
 
    class watchtower {
      public:
        watchtower() = delete;
 
        watchtower(size_t block_cache_size, size_t error_cache_size);
 
        void add_block(cbdc::atomizer::block&& blk);
 
        void add_errors(std::vector<tx_error>&& errs);
 
        auto handle_status_update_request(const status_update_request& req)
            -> std::unique_ptr<response>;
 
        auto
        handle_best_block_height_request(const best_block_height_request& req)
            -> std::unique_ptr<response>;
 
      private:
        block_cache m_bc;
        std::shared_mutex m_bc_mut;
        error_cache m_ec;
        std::shared_mutex m_ec_mut;
 
        auto check_uhs_id_statuses(const std::vector<hash_t>& uhs_ids,
                                   const hash_t& tx_id,
                                   bool internal_err,
                                   bool tx_err,
                                   uint64_t best_height)
            -> std::vector<status_update_state>;
    };
}
 
#endif // OPENCBDC_TX_SRC_WATCHTOWER_WATCHTOWER_H_