wallet.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_TRANSACTION_WALLET_H_
#define OPENCBDC_TX_SRC_TRANSACTION_WALLET_H_
 
#include "uhs/transaction/transaction.hpp"
#include "util/common/config.hpp"
#include "util/common/hashmap.hpp"
#include "util/common/random_source.hpp"
 
#include <atomic>
#include <fstream>
#include <list>
#include <memory>
#include <mutex>
#include <optional>
#include <random>
#include <secp256k1.h>
#include <set>
#include <shared_mutex>
#include <unordered_map>
#include <unordered_set>
 
namespace cbdc::transaction {
    class wallet {
      public:
        wallet();
 
        auto mint_new_coins(size_t n_outputs, uint32_t output_val) -> full_tx;
 
        auto send_to(uint32_t amount, const pubkey_t& payee, bool sign_tx)
            -> std::optional<full_tx>;
 
        auto send_to(size_t input_count,
                     size_t output_count,
                     const pubkey_t& payee,
                     bool sign_tx) -> std::optional<full_tx>;
 
        auto fan(size_t output_count,
                 uint32_t value,
                 const pubkey_t& payee,
                 bool sign_tx) -> std::optional<transaction::full_tx>;
 
        static auto export_send_inputs(const full_tx& send_tx,
                                       const pubkey_t& payee)
            -> std::vector<input>;
 
        auto generate_key() -> pubkey_t;
 
        auto seed(const privkey_t& privkey,
                  uint32_t value,
                  size_t begin_seed,
                  size_t end_seed) -> bool;
 
        void seed_readonly(const hash_t& witness_commitment,
                           uint32_t value,
                           size_t begin_seed,
                           size_t end_seed);
 
        void confirm_transaction(const full_tx& tx);
 
        void sign(full_tx& tx) const;
 
        auto is_spendable(const input& in) const -> bool;
 
        auto balance() const -> uint64_t;
 
        auto count() const -> size_t;
 
        void save(const std::string& wallet_file) const;
 
        void load(const std::string& wallet_file);
 
        auto create_seeded_transaction(size_t seed_idx)
            -> std::optional<full_tx>;
 
        void confirm_inputs(const std::vector<input>& credits);
 
      private:
        struct cmp_input {
            auto operator()(const input& lhs, const input& rhs) const -> bool {
                // First sort by tx hash then output index
                return std::tie(lhs.m_prevout.m_tx_id, lhs.m_prevout.m_index)
                     < std::tie(rhs.m_prevout.m_tx_id, rhs.m_prevout.m_index);
            }
        };
 
        mutable std::shared_mutex m_utxos_mut;
        uint64_t m_balance{0};
        std::set<input, cmp_input> m_utxos_set;
        size_t m_seed_from{0};
        size_t m_seed_to{0};
        uint32_t m_seed_value{0};
        hash_t m_seed_witness_commitment{0};
        std::list<input> m_spend_queue;
 
        mutable std::shared_mutex m_keys_mut;
        std::unordered_map<pubkey_t,
                           privkey_t,
                           hashing::const_sip_hash<pubkey_t>>
            m_keys;
        std::vector<pubkey_t> m_pubkeys;
        std::default_random_engine m_shuffle;
 
        // TODO: currently this map grows unbounded, we need to garbage
        //       collect it
        std::unordered_map<hash_t, pubkey_t, hashing::const_sip_hash<hash_t>>
            m_witness_programs;
 
        auto create_seeded_input(size_t seed_idx) -> std::optional<input>;
 
        static const inline auto m_secp
            = std::unique_ptr<secp256k1_context,
                              decltype(&secp256k1_context_destroy)>(
                secp256k1_context_create(SECP256K1_CONTEXT_SIGN),
                &secp256k1_context_destroy);
 
        static const inline auto m_random_source
            = std::make_unique<random_source>(config::random_source);
 
        void update_balance(const std::vector<input>& credits,
                            const std::vector<input>& debits);
 
        auto accumulate_inputs(uint64_t amount)
            -> std::optional<std::pair<full_tx, uint64_t>>;
    };
    class wallet {…};
}
 
#endif // OPENCBDC_TX_SRC_TRANSACTION_WALLET_H_