tx_error_messages.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_TX_ERROR_MESSAGES_H_
#define OPENCBDC_TX_SRC_WATCHTOWER_TX_ERROR_MESSAGES_H_
 
#include "uhs/transaction/transaction.hpp"
#include "util/common/hashmap.hpp"
#include "util/common/variant_overloaded.hpp"
#include "util/serialization/serializer.hpp"
 
#include <memory>
#include <string>
#include <unordered_set>
#include <variant>
#include <vector>
 
namespace cbdc::watchtower {
    struct tx_error_sync;
    class tx_error_inputs_dne;
    struct tx_error_stxo_range;
    struct tx_error_incomplete;
    class tx_error_inputs_spent;
 
    using tx_error_info = std::variant<tx_error_sync,
                                       tx_error_inputs_dne,
                                       tx_error_stxo_range,
                                       tx_error_incomplete,
                                       tx_error_inputs_spent>;
 
    class tx_error;
}
 
namespace cbdc {
    auto operator<<(cbdc::serializer& packet,
                    const cbdc::watchtower::tx_error_inputs_dne& err)
        -> cbdc::serializer&;
    auto operator>>(cbdc::serializer& packet,
                    cbdc::watchtower::tx_error_inputs_dne& err)
        -> cbdc::serializer&;
    auto operator<<(cbdc::serializer& packet,
                    const cbdc::watchtower::tx_error_inputs_spent& err)
        -> cbdc::serializer&;
    auto operator>>(cbdc::serializer& packet,
                    cbdc::watchtower::tx_error_inputs_spent& err)
        -> cbdc::serializer&;
    auto operator<<(cbdc::serializer& packet,
                    const cbdc::watchtower::tx_error& err)
        -> cbdc::serializer&;
    auto operator>>(cbdc::serializer& packet, cbdc::watchtower::tx_error& err)
        -> cbdc::serializer&;
}
 
namespace cbdc::watchtower {
    struct tx_error_sync {
        tx_error_sync() = default;
 
        explicit tx_error_sync(cbdc::serializer& pkt);
 
        auto operator==(const tx_error_sync& rhs) const -> bool;
    };
 
    class tx_error_inputs_dne {
      public:
        friend auto
        cbdc::operator<<(cbdc::serializer& packet,
                         const cbdc::watchtower::tx_error_inputs_dne& err)
            -> cbdc::serializer&;
        friend auto
        cbdc::operator>>(cbdc::serializer& packet,
                         cbdc::watchtower::tx_error_inputs_dne& err)
            -> cbdc::serializer&;
 
        auto operator==(const tx_error_inputs_dne& rhs) const -> bool;
 
        tx_error_inputs_dne() = delete;
 
        explicit tx_error_inputs_dne(std::vector<hash_t> input_uhs_ids);
 
        explicit tx_error_inputs_dne(cbdc::serializer& pkt);
 
        [[nodiscard]] auto input_uhs_ids() const -> std::vector<hash_t>;
 
      private:
        std::vector<hash_t> m_input_uhs_ids;
    };
 
    struct tx_error_stxo_range {
        tx_error_stxo_range() = default;
 
        explicit tx_error_stxo_range(cbdc::serializer& pkt);
 
        auto operator==(const tx_error_stxo_range& rhs) const -> bool;
    };
 
    struct tx_error_incomplete {
        tx_error_incomplete() = default;
 
        explicit tx_error_incomplete(cbdc::serializer& pkt);
 
        auto operator==(const tx_error_incomplete& rhs) const -> bool;
    };
 
    class tx_error_inputs_spent {
      public:
        friend auto
        cbdc::operator<<(cbdc::serializer& packet,
                         const cbdc::watchtower::tx_error_inputs_spent& err)
            -> cbdc::serializer&;
        friend auto
        cbdc::operator>>(cbdc::serializer& packet,
                         cbdc::watchtower::tx_error_inputs_spent& err)
            -> cbdc::serializer&;
 
        auto operator==(const tx_error_inputs_spent& rhs) const -> bool;
 
        tx_error_inputs_spent() = delete;
 
        explicit tx_error_inputs_spent(
            std::unordered_set<hash_t, hashing::null> input_uhs_ids);
 
        explicit tx_error_inputs_spent(cbdc::serializer& pkt);
 
        [[nodiscard]] auto input_uhs_ids() const
            -> std::unordered_set<hash_t, hashing::null>;
 
      private:
        std::unordered_set<hash_t, hashing::null> m_input_uhs_ids;
    };
 
    class tx_error {
      public:
        friend auto cbdc::operator<<(cbdc::serializer& packet,
                                     const cbdc::watchtower::tx_error& err)
            -> cbdc::serializer&;
        friend auto cbdc::operator>>(cbdc::serializer& packet,
                                     cbdc::watchtower::tx_error& err)
            -> cbdc::serializer&;
 
        auto operator==(const tx_error& rhs) const -> bool;
 
        tx_error() = delete;
 
        tx_error(const hash_t& tx_id, const tx_error_sync& err);
 
        tx_error(const hash_t& tx_id, const tx_error_inputs_dne& err);
 
        tx_error(const hash_t& tx_id, const tx_error_stxo_range& err);
 
        tx_error(const hash_t& tx_id, const tx_error_incomplete& err);
 
        tx_error(const hash_t& tx_id, const tx_error_inputs_spent& err);
 
        explicit tx_error(cbdc::serializer& pkt);
 
        [[nodiscard]] auto tx_id() const -> hash_t;
 
        [[nodiscard]] auto info() const -> tx_error_info;
 
        [[nodiscard]] auto to_string() const -> std::string;
 
      private:
        hash_t m_tx_id{};
        std::shared_ptr<tx_error_info> m_info;
    };
}
 
#endif // OPENCBDC_TX_SRC_WATCHTOWER_TX_ERROR_MESSAGES_H_