monero_wallet.h

#pragma once

#include "monero_wallet_model.h"
#include "wallet/wallet2.h"

#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/condition_variable.hpp>

using namespace std;
using namespace crypto;
using namespace monero;

namespace monero {

  // --------------------------------- LISTENERS ------------------------------

  class monero_sync_listener {
  public:

    virtual void on_sync_progress(uint64_t height, uint64_t start_height, uint64_t end_height, double percent_done, const string& message) {}
  };

  class monero_wallet_listener : public monero_sync_listener {
  public:

    virtual void on_new_block(uint64_t height) {};

    virtual void on_output_received(const monero_output_wallet& output) {};

    virtual void on_output_spent(const monero_output_wallet& output) {};
  };

  // forward declaration of internal wallet2 listener
  struct wallet2_listener;

  // ---------------------------- WALLET INTERFACE ----------------------------

  class monero_wallet {

  public:

    static bool wallet_exists(const string& path);

    static monero_wallet* open_wallet(const string& path, const string& password, const monero_network_type network_type);

    static monero_wallet* create_wallet_random(const string& path, const string& password);
    static monero_wallet* create_wallet_random(const string& path, const string& password, const monero_network_type network_type, const monero_rpc_connection& daemon_connection, const string& language);

    static monero_wallet* create_wallet_from_mnemonic(const string& path, const string& password, const monero_network_type network_type, const string& mnemonic);
    static monero_wallet* create_wallet_from_mnemonic(const string& path, const string& password, const monero_network_type network_type, const string& mnemonic, const monero_rpc_connection& daemon_connection, uint64_t restore_height);

    static monero_wallet* create_wallet_from_keys(const string& path, const string& password, const monero_network_type network_type, const string& address, const string& view_key, const string& spend_key);
    static monero_wallet* create_wallet_from_keys(const string& path, const string& password, const monero_network_type network_type, const string& address, const string& view_key, const string& spend_key, const monero_rpc_connection& daemon_connection, uint64_t restore_height);
    static monero_wallet* create_wallet_from_keys(const string& path, const string& password, const monero_network_type network_type, const string& address, const string& view_key, const string& spend_key, const monero_rpc_connection& daemon_connection, uint64_t restore_height, const string& language);

    ~monero_wallet();

    uint64_t get_height() const;

    uint64_t get_restore_height() const;

    void set_restore_height(uint64_t restore_height);

    uint64_t get_daemon_height() const;

    uint64_t get_daemon_max_peer_height() const;

    void set_daemon_connection(const string& uri, const string& username = "", const string& password = "");

    void set_daemon_connection(const monero_rpc_connection& connection);

    shared_ptr<monero_rpc_connection> get_daemon_connection() const;

    bool is_connected() const;

    bool is_daemon_synced() const;

    bool is_synced() const;

    string get_path() const;

    monero_network_type get_network_type() const;

    string get_seed() const;

    string get_mnemonic() const;

    string get_language() const;

    vector<string> get_languages() const;

    string get_public_view_key() const;

    string get_private_view_key() const;

    string get_public_spend_key() const;

    string get_private_spend_key() const;

    string get_primary_address() const;

    string get_address(const uint32_t account_idx, const uint32_t subaddress_idx) const;

    monero_subaddress get_address_index(const string& address) const;

    monero_integrated_address get_integrated_address(const string& standard_address = "", const string& payment_id = "") const;

    monero_integrated_address decode_integrated_address(const string& integrated_address) const;

    void add_listener(monero_wallet_listener& listener);

    void remove_listener(monero_wallet_listener& listener);

    set<monero_wallet_listener*> get_listeners();

    monero_sync_result sync();

    monero_sync_result sync(monero_sync_listener& listener);

    monero_sync_result sync(uint64_t start_height);

    monero_sync_result sync(uint64_t start_height, monero_sync_listener& listener);

    void start_syncing();

    void stop_syncing();

    void rescan_blockchain();

//    /**
//     * Indicates if importing multisig data is needed for returning a correct balance.
//     *
//     * @return true if importing multisig data is needed for returning a correct balance, false otherwise
//     */
//    public boolean isMultisigImportNeeded();

    uint64_t get_balance() const;

    uint64_t get_balance(uint32_t account_idx) const;

    uint64_t get_balance(uint32_t account_idx, uint32_t subaddress_idx) const;

    uint64_t get_unlocked_balance() const;

    uint64_t get_unlocked_balance(uint32_t account_idx) const;

    uint64_t get_unlocked_balance(uint32_t account_idx, uint32_t subaddress_idx) const;

    vector<monero_account> get_accounts() const;

    vector<monero_account> get_accounts(bool include_subaddresses) const;

    vector<monero_account> get_accounts(const string& tag) const;

    vector<monero_account> get_accounts(bool include_subaddresses, const string& tag) const;

    monero_account get_account(uint32_t account_idx) const;

    monero_account get_account(const uint32_t account_idx, bool include_subaddresses) const;

    monero_account create_account(const string& label = "");

    vector<monero_subaddress> get_subaddresses(const uint32_t account_idx) const;

    vector<monero_subaddress> get_subaddresses(const uint32_t account_idx, const vector<uint32_t>& subaddress_indices) const;

    monero_subaddress getSubaddress(const uint32_t account_idx, const uint32_t subaddress_idx) const;

    monero_subaddress create_subaddress(uint32_t account_idx, const string& label = "");

//    /**
//     * Get a wallet transaction by id.
//     *
//     * @param tx_id is an id of a transaction to get
//     * @return monero_tx_wallet is the identified transactions
//     */
//    public monero_tx_wallet getTx(string tx_id);

    vector<shared_ptr<monero_tx_wallet>> get_txs() const;

//    /**
//     * Get wallet transactions by id.
//     *
//     * @param tx_ids are ids of transactions to get
//     * @return the identified transactions
//     */
//    public List<monero_tx_wallet> get_txs(Collection<string> tx_ids);

    vector<shared_ptr<monero_tx_wallet>> get_txs(const monero_tx_query& request) const;

//    /**
//     * Get all incoming and outgoing transfers to and from this wallet.  An
//     * outgoing transfer represents a total amount sent from one or more
//     * subaddresses within an account to individual destination addresses, each
//     * with their own amount.  An incoming transfer represents a total amount
//     * received into a subaddress within an account.  Transfers belong to
//     * transactions which are stored on the blockchain.
//     *
//     * @return all wallet transfers
//     */
//    public List<monero_transfer> get_transfers();
//
//    /**
//     * Get incoming and outgoing transfers to and from an account.  An outgoing
//     * transfer represents a total amount sent from one or more subaddresses
//     * within an account to individual destination addresses, each with their
//     * own amount.  An incoming transfer represents a total amount received into
//     * a subaddress within an account.  Transfers belong to transactions which
//     * are stored on the blockchain.
//     *
//     * @param account_idx is the index of the account to get transfers from
//     * @return transfers to/from the account
//     */
//    public List<monero_transfer> get_transfers(int account_idx);
//
//    /**
//     * Get incoming and outgoing transfers to and from a subaddress.  An outgoing
//     * transfer represents a total amount sent from one or more subaddresses
//     * within an account to individual destination addresses, each with their
//     * own amount.  An incoming transfer represents a total amount received into
//     * a subaddress within an account.  Transfers belong to transactions which
//     * are stored on the blockchain.
//     *
//     * @param account_idx is the index of the account to get transfers from
//     * @param subaddress_idx is the index of the subaddress to get transfers from
//     * @return transfers to/from the subaddress
//     */
//    public List<monero_transfer> get_transfers(int account_idx, int subaddress_idx);

    vector<shared_ptr<monero_transfer>> get_transfers(const monero_transfer_query& request) const;

//    /**
//     * Get outputs created from previous transactions that belong to the wallet
//     * (i.e. that the wallet can spend one time).  Outputs are part of
//     * transactions which are stored in blocks on the blockchain.
//     *
//     * @return List<monero_output_wallet> are all wallet outputs
//     */
//    public List<monero_output_wallet> get_outputs();

    vector<shared_ptr<monero_output_wallet>> get_outputs(const monero_output_query& request) const;

    string get_outputs_hex() const;

    int import_outputs_hex(const string& outputs_hex);

    vector<shared_ptr<monero_key_image>> get_key_images() const;

    shared_ptr<monero_key_image_import_result> import_key_images(const vector<shared_ptr<monero_key_image>>& key_images);

//    /**
//     * Get new key images from the last imported outputs.
//     *
//     * @return the key images from the last imported outputs
//     */
//    public List<monero_key_image> getNewKeyImagesFromLastImport();

    shared_ptr<monero_tx_wallet> create_tx(monero_send_request& request);

    shared_ptr<monero_tx_wallet> create_tx(uint32_t account_index, string address, uint64_t amount);

    shared_ptr<monero_tx_wallet> create_tx(int account_index, string address, uint64_t amount, monero_send_priority priority);

    vector<shared_ptr<monero_tx_wallet>> create_txs(monero_send_request& request);

    string relay_tx(const string& tx_metadata);

    string relay_tx(const monero_tx_wallet& tx);

    vector<string> relay_txs(const vector<string>& tx_metadatas);

    vector<string> relay_txs(const vector<shared_ptr<monero_tx_wallet>>& txs);

    shared_ptr<monero_tx_wallet> send(monero_send_request& request);

    shared_ptr<monero_tx_wallet> send(uint32_t account_index, string address, uint64_t amount);

    shared_ptr<monero_tx_wallet> send(uint32_t account_index, string address, uint64_t amount, monero_send_priority priority);

    vector<shared_ptr<monero_tx_wallet>> send_split(const monero_send_request& request);

//
//    /**
//     * Create and relay a transaction which transfers funds from this wallet to
//     * a destination address.
//     *
//     * @param account_index is the index of the account to draw funds from
//     * @param address is the destination address to send funds to
//     * @param sendAmount is the amount being sent
//     * @return the resulting transaction
//     */
//    public monero_tx_wallet send(int account_index, string address, BigInteger sendAmount);
//
//    /**
//     * Create and relay a transaction which transfers funds from this wallet to
//     * a destination address.
//     *
//     * @param account_index is the index of the account to draw funds from
//     * @param address is the destination address to send funds to
//     * @param sendAmount is the amount being sent
//     * @param priority is the send priority (default normal)
//     * @return the resulting transaction
//     */
//    public monero_tx_wallet send(int account_index, string address, BigInteger sendAmount, monero_send_priority priority);
//
//    /**
//     * Create and relay (depending on configuration) one or more transactions
//     * which transfer funds from this wallet to one or more destination.
//     *
//     * @param request configures the transactions
//     * @return the resulting transactions
//     */
//    public List<monero_tx_wallet> send_split(monero_send_request request);
//
//    /**
//     * Create and relay one or more transactions which transfer funds from this
//     * wallet to one or more destination.
//     *
//     * @param account_index is the index of the account to draw funds from
//     * @param address is the destination address to send funds to
//     * @param sendAmount is the amount being sent
//     * @return the resulting transactions
//     */
//    public List<monero_tx_wallet> send_split(int account_index, string address, BigInteger sendAmount);
//
//    /**
//     * Create and relay one or more transactions which transfer funds from this
//     * wallet to one or more destination.
//     *
//     * @param account_index is the index of the account to draw funds from
//     * @param address is the destination address to send funds to
//     * @param sendAmount is the amount being sent
//     * @param priority is the send priority (default normal)
//     * @return the resulting transactions
//     */
//    public List<monero_tx_wallet> send_split(int account_index, string address, BigInteger sendAmount, monero_send_priority priority);

    shared_ptr<monero_tx_wallet> sweep_output(const monero_send_request& request) const;

//    /**
//     * Sweep an output with a given key image.
//     *
//     * @param address is the destination address to send to
//     * @param key_image is the key image hex of the output to sweep
//     * @return the resulting transaction from sweeping an output
//     */
//    public monero_tx_wallet sweep_output(string address, string key_image);
//
//    /**
//     * Sweep an output with a given key image.
//     *
//     * @param address is the destination address to send to
//     * @param key_image is the key image hex of the output to sweep
//     * @param priority is the transaction priority (optional)
//     * @return the resulting transaction from sweeping an output
//     */
//    public monero_tx_wallet sweep_output(string address, string key_image, monero_send_priority priority);
//
//    /**
//     * Sweep a subaddress's unlocked funds to an address.
//     *
//     * @param account_idx is the index of the account
//     * @param subaddress_idx is the index of the subaddress
//     * @param address is the address to sweep the subaddress's funds to
//     * @return the resulting transactions
//     */
//    public List<monero_tx_wallet> sweepSubaddress(int account_idx, int subaddress_idx, string address);
//
//    /**
//     * Sweep an acount's unlocked funds to an address.
//     *
//     * @param account_idx is the index of the account
//     * @param address is the address to sweep the account's funds to
//     * @return the resulting transactions
//     */
//    public List<monero_tx_wallet> sweepAccount(int account_idx, string address);
//
//    /**
//     * Sweep the wallet's unlocked funds to an address.
//     *
//     * @param address is the address to sweep the wallet's funds to
//     * @return the resulting transactions
//     */
//    public List<monero_tx_wallet> sweepWallet(string address);
//
//    /**
//     * Sweep all unlocked funds according to the given request.
//     *
//     * @param request is the sweep configuration
//     * @return the resulting transactions
//     */
//    public List<monero_tx_wallet> sweepAllUnlocked(monero_send_request request);
//
//    /**
//     * Sweep all unmixable dust outputs back to the wallet to make them easier to spend and mix.
//     *
//     * NOTE: Dust only exists pre RCT, so this method will return "no dust to sweep" on new wallets.
//     *
//     * @return the resulting transactions from sweeping dust
//     */
//    public List<monero_tx_wallet> sweep_dust();

    vector<shared_ptr<monero_tx_wallet>> sweep_dust(bool do_not_relay = false);

    string get_tx_note(const string& tx_id) const;

    vector<string> get_tx_notes(const vector<string>& tx_ids) const;

    void set_tx_note(const string& tx_id, const string& note);

    void set_tx_notes(const vector<string>& tx_ids, const vector<string>& notes);

    string sign(const string& msg) const;

    bool verify(const string& msg, const string& address, const string& signature) const;

    string get_tx_key(const string& tx_id) const;

    shared_ptr<monero_check_tx> check_tx_key(const string& tx_id, const string& txKey, const string& address) const;

//    /**
//     * Get a transaction signature to prove it.
//     *
//     * @param tx_id specifies the transaction to prove
//     * @param address is the destination public address of the transaction
//     * @return the transaction signature
//     */
//    string get_tx_proof(const string& tx_id, const string& address) const;

    string get_tx_proof(const string& tx_id, const string& address, const string& message) const;

    shared_ptr<monero_check_tx> check_tx_proof(const string& tx_id, const string& address, const string& message, const string& signature) const;

//    /**
//     * Generate a signature to prove a spend. Unlike proving a transaction, it does not require the destination public address.
//     *
//     * @param tx_id specifies the transaction to prove
//     * @return the transaction signature
//     */
//    string get_spend_proof(const string& tx_id) const;

    string get_spend_proof(const string& tx_id, const string& message) const;

    bool check_spend_proof(const string& tx_id, const string& message, const string& signature) const;

    string get_reserve_proof_wallet(const string& message) const;

    string get_reserve_proof_account(uint32_t account_idx, uint64_t amount, const string& message) const;

    shared_ptr<monero_check_reserve> check_reserve_proof(const string& address, const string& message, const string& signature) const;

//    /**
//     * Get all address book entries.
//     *
//     * @return the address book entries
//     */
//    public List<MoneroAddressBookEntry> getAddressBookEntries();
//
//    /**
//     * Get address book entries.
//     *
//     * @param entryIndices are indices of the entries to get
//     * @return the address book entries
//     */
//    public List<MoneroAddressBookEntry> getAddressBookEntries(Collection<Integer> entryIndices);
//
//    /**
//     * Add an address book entry.
//     *
//     * @param address is the entry address
//     * @param description is the entry description (optional)
//     * @return the index of the added entry
//     */
//    public int addAddressBookEntry(string address, string description);
//
//    /**
//     * Add an address book entry.
//     *
//     * @param address is the entry address
//     * @param description is the entry description (optional)
//     * @param payment_id is the entry paymet id (optional)
//     * @return the index of the added entry
//     */
//    public int addAddressBookEntry(string address, string description, string payment_id);
//
//    /**
//     * Delete an address book entry.
//     *
//     * @param entryIdx is the index of the entry to delete
//     */
//    public void deleteAddressBookEntry(int entryIdx);
//
//    /**
//     * Tag accounts.
//     *
//     * @param tag is the tag to apply to the specified accounts
//     * @param accountIndices are the indices of the accounts to tag
//     */
//    public void tagAccounts(string tag, Collection<Integer> accountIndices);
//
//    /**
//     * Untag acconts.
//     *
//     * @param accountIndices are the indices of the accounts to untag
//     */
//    public void untagAccounts(Collection<Integer> accountIndices);
//
//    /**
//     * Return all account tags.
//     *
//     * @return the wallet's account tags
//     */
//    public List<MoneroAccountTag> getAccountTags();
//
//    /**
//     * Sets a human-readable description for a tag.
//     *
//     * @param tag is the tag to set a description for
//     * @param label is the label to set for the tag
//     */
//    public void setAccountTagLabel(string tag, string label);

    string create_payment_uri(const monero_send_request& request) const;

    shared_ptr<monero_send_request> parse_payment_uri(const string& uri) const;

    void set_attribute(const string& key, const string& val);

    string get_attribute(const string& key) const;

    void start_mining(boost::optional<uint64_t> num_threads, boost::optional<bool> background_mining, boost::optional<bool> ignore_battery);

    void stop_mining();

    uint64_t wait_for_next_block();

    void save();

    void move_to(string path, string password);

    void close();

    // --------------------------------- PRIVATE --------------------------------

  private:
    friend struct wallet2_listener;
    unique_ptr<tools::wallet2> m_w2;              // internal wallet implementation
    unique_ptr<wallet2_listener> m_w2_listener;   // internal wallet implementation listener
    set<monero_wallet_listener*> m_listeners;  // external wallet listeners

    void init_common();
    vector<monero_subaddress> get_subaddresses_aux(uint32_t account_idx, const vector<uint32_t>& subaddress_indices, const vector<tools::wallet2::transfer_details>& transfers) const;

    // blockchain sync management
    mutable std::atomic<bool> m_is_synced;       // whether or not wallet is synced
    mutable std::atomic<bool> m_is_connected;    // cache connection status to avoid unecessary RPC calls
    boost::condition_variable m_sync_cv;         // to make sync threads woke
    boost::mutex m_sync_mutex;                   // synchronize sync() and syncAsync() requests
    std::atomic<bool> m_rescan_on_sync;          // whether or not to rescan on sync
    std::atomic<bool> m_syncing_enabled;         // whether or not auto sync is enabled
    std::atomic<int> m_syncing_interval;         // auto sync loop interval in milliseconds
    boost::thread m_syncing_thread;              // thread for auto sync loop
    boost::mutex m_syncing_mutex;                // synchronize auto sync loop
    std::atomic<bool> m_syncing_thread_done;     // whether or not the syncing thread is shut down
    void sync_thread_func();                     // function to run thread with syncing loop
    monero_sync_result lock_and_sync(boost::optional<uint64_t> start_height = boost::none);  // internal function to synchronize request to sync and rescan
    monero_sync_result sync_aux(boost::optional<uint64_t> start_height = boost::none);       // internal function to immediately block, sync, and report progress
  };
}