uhs/client/client.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_CLIENT_CLIENT_H_
#define OPENCBDC_TX_SRC_CLIENT_CLIENT_H_
 
#include "uhs/sentinel/client.hpp"
#include "uhs/transaction/validation.hpp"
#include "uhs/transaction/wallet.hpp"
 
namespace cbdc {
    namespace address {
        static constexpr auto bits_per_byte = 8;
        static constexpr auto bech32_bits_per_symbol = 5;
 
        auto decode(const std::string& addr_str)
            -> std::optional<cbdc::hash_t>;
    }
 
    class client {
      public:
        client(cbdc::config::options opts,
               std::shared_ptr<logging::log> logger,
               std::string wallet_file,
               std::string client_file);
 
        virtual ~client() = default;
 
        client(const client&) = delete;
        auto operator=(const client&) -> client& = delete;
 
        client(client&&) = delete;
        auto operator=(client&&) -> client& = delete;
 
        auto init() -> bool;
 
        static auto print_amount(uint64_t val) -> std::string;
 
        auto mint(size_t n_outputs, uint32_t output_val)
            -> transaction::full_tx;
 
        auto send(uint32_t value, const pubkey_t& payee)
            -> std::pair<std::optional<transaction::full_tx>,
                         std::optional<cbdc::sentinel::execute_response>>;
 
        auto fan(uint32_t count, uint32_t value, const pubkey_t& payee)
            -> std::pair<std::optional<transaction::full_tx>,
                         std::optional<cbdc::sentinel::execute_response>>;
 
        static auto export_send_inputs(const transaction::full_tx& send_tx,
                                       const pubkey_t& payee)
            -> std::vector<transaction::input>;
 
        void import_send_input(const transaction::input& in);
 
        virtual auto sync() -> bool = 0;
 
        auto new_address() -> pubkey_t;
 
        auto balance() -> uint64_t;
 
        auto utxo_count() -> size_t;
 
        auto pending_tx_count() -> size_t;
 
        auto pending_input_count() -> size_t;
 
        auto confirm_transaction(const hash_t& tx_id) -> bool;
 
        auto create_transaction(uint32_t value, const pubkey_t& payee)
            -> std::optional<transaction::full_tx>;
 
        auto send_transaction(const transaction::full_tx& tx)
            -> std::optional<cbdc::sentinel::execute_response>;
 
        auto abandon_transaction(const hash_t& tx_id) -> bool;
 
        auto check_pending(const transaction::input& inp) -> bool;
 
        void sign_transaction(transaction::full_tx& tx);
 
        enum class address_type : uint8_t {
            public_key = 0
        };
 
      protected:
        virtual auto init_derived() -> bool = 0;
 
        virtual auto send_mint_tx(const transaction::full_tx& mint_tx) -> bool
            = 0;
 
        [[nodiscard]] auto pending_txs() const
            -> std::unordered_map<hash_t, transaction::full_tx, hashing::null>;
 
        [[nodiscard]] auto pending_inputs() const
            -> std::unordered_map<hash_t, transaction::input, hashing::null>;
 
      private:
        cbdc::config::options m_opts;
        std::shared_ptr<logging::log> m_logger;
 
        cbdc::sentinel::rpc::client m_sentinel_client;
 
        std::unordered_map<hash_t, transaction::full_tx, hashing::null>
            m_pending_txs;
 
        std::unordered_map<hash_t, transaction::input, hashing::null>
            m_pending_spend;
 
        std::unordered_map<hash_t, transaction::input, hashing::null>
            m_pending_inputs;
 
        transaction::wallet m_wallet{};
 
        std::string m_client_file;
        std::string m_wallet_file;
 
        void import_transaction(const transaction::full_tx& tx);
 
        void load_client_state();
        void save_client_state();
 
        void save();
 
        void register_pending_tx(const transaction::full_tx& tx);
    };
}
 
#endif // OPENCBDC_TX_SRC_CLIENT_CLIENT_H_