status_update.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_STATUS_UPDATE_H_
#define OPENCBDC_TX_SRC_WATCHTOWER_STATUS_UPDATE_H_
 
#include "status_update_messages.hpp"
#include "uhs/transaction/transaction.hpp"
#include "util/common/hashmap.hpp"
 
#include <memory>
#include <optional>
#include <unordered_map>
#include <unordered_set>
 
namespace cbdc::watchtower {
    enum class search_status {
        no_history,
        unspent,
        spent,
        tx_rejected,
        invalid_input,
        internal_error
    };
 
    using tx_id_uhs_ids = std::unordered_map<hash_t,
                                             std::vector<hash_t>,
                                             hashing::const_sip_hash<hash_t>>;
 
    class status_update_request {
      public:
        friend auto
        cbdc::operator<<(cbdc::serializer& packet,
                         const cbdc::watchtower::status_update_request& su_req)
            -> cbdc::serializer&;
        friend auto cbdc::operator>>(cbdc::serializer& packet,
                                     status_update_request& su_req)
            -> cbdc::serializer&;
 
        auto operator==(const status_update_request& rhs) const -> bool;
 
        status_update_request() = delete;
 
        explicit status_update_request(tx_id_uhs_ids uhs_ids);
 
        explicit status_update_request(cbdc::serializer& pkt);
 
        [[nodiscard]] auto uhs_ids() const -> const tx_id_uhs_ids&;
 
      private:
        tx_id_uhs_ids m_uhs_ids;
    };
 
    class status_update_state {
      public:
        friend auto
        cbdc::operator<<(cbdc::serializer& packet,
                         const cbdc::watchtower::status_update_state& state)
            -> cbdc::serializer&;
        friend auto
        cbdc::operator>>(cbdc::serializer& packet,
                         cbdc::watchtower::status_update_state& state)
            -> cbdc::serializer&;
        friend class status_request_check_success;
 
        auto operator==(const status_update_state& rhs) const -> bool;
 
        status_update_state(search_status status,
                            uint64_t block_height,
                            hash_t uhs_id);
 
        explicit status_update_state(cbdc::serializer& pkt);
 
        [[nodiscard]] auto status() const -> search_status;
 
        [[nodiscard]] auto block_height() const -> uint64_t;
 
        [[nodiscard]] auto uhs_id() const -> hash_t;
 
      private:
        status_update_state() = default;
 
        search_status m_status{};
        uint64_t m_block_height{};
        hash_t m_uhs_id{};
    };
 
    using tx_id_states = std::unordered_map<hash_t,
                                            std::vector<status_update_state>,
                                            hashing::const_sip_hash<hash_t>>;
 
    class status_request_check_success {
      public:
        friend auto cbdc::operator<<(
            cbdc::serializer& packet,
            const cbdc::watchtower::status_request_check_success& chs)
            -> cbdc::serializer&;
        friend auto
        cbdc::operator>>(cbdc::serializer& packet,
                         cbdc::watchtower::status_request_check_success& chs)
            -> cbdc::serializer&;
 
        auto operator==(const status_request_check_success& rhs) const -> bool;
 
        status_request_check_success() = delete;
 
        explicit status_request_check_success(tx_id_states states);
 
        explicit status_request_check_success(cbdc::serializer& pkt);
 
        [[nodiscard]] auto states() const -> const tx_id_states&;
 
      private:
        tx_id_states m_states;
    };
}
 
#endif // OPENCBDC_TX_SRC_WATCHTOWER_STATUS_UPDATE_H_