monero_wallet.h

#pragma once

#include "monero_wallet_model.h"

using namespace std;
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 METHODS -----------------------------

  class monero_wallet {

  public:

    virtual ~monero_wallet() {}

    virtual void set_daemon_connection(const string& uri, const string& username = "", const string& password = "") {
      throw runtime_error("set_daemon_connection() not supported");
    }

    virtual void set_daemon_connection(const monero_rpc_connection& connection) {
      throw runtime_error("set_daemon_connection() not supported");
    }

    virtual shared_ptr<monero_rpc_connection> get_daemon_connection() const {
      throw runtime_error("get_daemon_connection() not supported");
    }

    virtual bool is_connected() const {
      throw runtime_error("is_connected() not supported");
    }

    virtual bool is_daemon_synced() const {
      throw runtime_error("is_daemon_synced() not supported");
    }

    virtual bool is_daemon_trusted() const {
      throw runtime_error("is_daemon_trusted() not supported");
    }

    virtual bool is_synced() const {
      throw runtime_error("is_synced() not supported");
    }

    virtual monero_version get_version() const {
      throw runtime_error("get_version() not supported");
    }

    virtual string get_path() const {
      throw runtime_error("get_path() not supported");
    }

    virtual monero_network_type get_network_type() const {
      throw runtime_error("get_network_type() not supported");
    }

    virtual string get_mnemonic() const {
      throw runtime_error("get_mnemonic() not supported");
    }

    virtual string get_mnemonic_language() const {
      throw runtime_error("get_mnemonic_language() not supported");
    }

    virtual string get_public_view_key() const {
      throw runtime_error("get_public_view_key() not supported");
    }

    virtual string get_private_view_key() const {
      throw runtime_error("get_private_view_key() not supported");
    }

    virtual string get_public_spend_key() const {
      throw runtime_error("get_public_spend_key() not supported");
    }

    virtual string get_private_spend_key() const {
      throw runtime_error("get_private_spend_key() not supported");
    }

    virtual string get_primary_address() const {
      return get_address(0, 0);
    }

    virtual string get_address(const uint32_t account_idx, const uint32_t subaddress_idx) const {
      throw runtime_error("get_address() not supported");
    }

    virtual monero_subaddress get_address_index(const string& address) const {
      throw runtime_error("get_address_index() not supported");
    }

    virtual monero_integrated_address get_integrated_address(const string& standard_address = "", const string& payment_id = "") const {
      throw runtime_error("get_integrated_address() not supported");
    }

    virtual monero_integrated_address decode_integrated_address(const string& integrated_address) const {
      throw runtime_error("decode_integrated_address() not supported");
    }

    virtual uint64_t get_height() const {
      throw runtime_error("get_height() not supported");
    }

    virtual uint64_t get_restore_height() const {
      throw runtime_error("get_restore_height() not supported");
    }

    virtual void set_restore_height(uint64_t restore_height) {
      throw runtime_error("set_restore_height() not supported");
    }

    virtual uint64_t get_daemon_height() const {
      throw runtime_error("get_daemon_height() not supported");
    }

    virtual uint64_t get_daemon_max_peer_height() const {
      throw runtime_error("get_daemon_max_peer_height() not supported");
    }

    virtual void add_listener(monero_wallet_listener& listener) {
      throw runtime_error("add_listener() not supported");
    }

    virtual void remove_listener(monero_wallet_listener& listener) {
      throw runtime_error("remove_listener() not supported");
    }

    virtual set<monero_wallet_listener*> get_listeners() {
      throw runtime_error("get_listeners() not supported");
    }

    virtual monero_sync_result sync() {
      throw runtime_error("sync() not supported");
    }

    virtual monero_sync_result sync(monero_sync_listener& listener) {
      throw runtime_error("sync() not supported");
    }

    virtual monero_sync_result sync(uint64_t start_height) {
      throw runtime_error("sync() not supported");
    }

    virtual monero_sync_result sync(uint64_t start_height, monero_sync_listener& listener) {
      throw runtime_error("sync() not supported");
    }

    virtual void start_syncing() {
      throw runtime_error("start_syncing() not supported");
    }

    virtual void stop_syncing() {
      throw runtime_error("stop_syncing() not supported");
    }

    virtual void rescan_spent() {
      throw runtime_error("rescan_spent() not supported");
    }

    virtual void rescan_blockchain() {
      throw runtime_error("rescan_blockchain() not supported");
    }

//    /**
//     * 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();

    virtual uint64_t get_balance() const {
      throw runtime_error("get_balance() not supported");
    }

    virtual uint64_t get_balance(uint32_t account_idx) const {
      throw runtime_error("get_balance() not supported");
    }

    virtual uint64_t get_balance(uint32_t account_idx, uint32_t subaddress_idx) const {
      throw runtime_error("get_balance() not supported");
    }

    virtual uint64_t get_unlocked_balance() const {
      throw runtime_error("get_unlocked_balance() not supported");
    }

    virtual uint64_t get_unlocked_balance(uint32_t account_idx) const {
      throw runtime_error("get_unlocked_balance() not supported");
    }

    virtual uint64_t get_unlocked_balance(uint32_t account_idx, uint32_t subaddress_idx) const {
      throw runtime_error("get_unlocked_balance() not supported");
    }

    virtual vector<monero_account> get_accounts() const {
      return get_accounts(false, string(""));
    }

    virtual vector<monero_account> get_accounts(bool include_subaddresses) const {
      return get_accounts(include_subaddresses, "");
    }

    virtual vector<monero_account> get_accounts(const string& tag) const {
      return get_accounts(false, tag);
    }

    virtual vector<monero_account> get_accounts(bool include_subaddresses, const string& tag) const {
      throw runtime_error("get_accounts() not supported");
    }

    virtual monero_account get_account(uint32_t account_idx) const {
      return get_account(account_idx, false);
    }

    virtual monero_account get_account(const uint32_t account_idx, bool include_subaddresses) const {
      throw runtime_error("get_account() not supported");
    }

    virtual monero_account create_account(const string& label = "") {
      throw runtime_error("create_account() not supported");
    }

    virtual vector<monero_subaddress> get_subaddresses(const uint32_t account_idx) const {
      return get_subaddresses(account_idx, vector<uint32_t>());
    }

    virtual vector<monero_subaddress> get_subaddresses(const uint32_t account_idx, const vector<uint32_t>& subaddress_indices) const {
      throw runtime_error("get_subaddresses() not supported");
    }

    virtual monero_subaddress get_subaddress(const uint32_t account_idx, const uint32_t subaddress_idx) const {
      throw runtime_error("get_subaddress() not supported");
    }

    virtual monero_subaddress create_subaddress(uint32_t account_idx, const string& label = "") {
      throw runtime_error("create_subaddress() not supported");
    }

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

    virtual vector<shared_ptr<monero_tx_wallet>> get_txs() const {
      throw runtime_error("get_txs() not supported");
    }

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

    virtual vector<shared_ptr<monero_tx_wallet>> get_txs(const monero_tx_query& query) const {
      throw runtime_error("get_txs(query) not supported");
    }

    virtual vector<shared_ptr<monero_tx_wallet>> get_txs(const monero_tx_query& query, vector<string>& missing_tx_hashes) const {
      throw runtime_error("get_txs(query, missing_tx_hashes) not supported");
    }

//    /**
//     * 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);

    virtual vector<shared_ptr<monero_transfer>> get_transfers(const monero_transfer_query& query) const {
      throw runtime_error("get_transfers() not supported");
    }

//    /**
//     * 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();

    virtual vector<shared_ptr<monero_output_wallet>> get_outputs(const monero_output_query& query) const {
      throw runtime_error("get_outputs() not supported");
    }

    virtual string get_outputs_hex() const {
      throw runtime_error("get_outputs_hex() not supported");
    }

    virtual int import_outputs_hex(const string& outputs_hex) {
      throw runtime_error("import_outputs_hex() not supported");
    }

    virtual vector<shared_ptr<monero_key_image>> get_key_images() const {
      throw runtime_error("get_key_images() not supported");
    }

    virtual shared_ptr<monero_key_image_import_result> import_key_images(const vector<shared_ptr<monero_key_image>>& key_images) {
      throw runtime_error("import_key_images() not supported");
    }

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

    virtual monero_tx_set create_tx(monero_send_request& request) {
      throw runtime_error("create_tx() not supported");
    }

    virtual monero_tx_set create_tx(uint32_t account_index, string address, uint64_t amount) {
      throw runtime_error("create_tx() not supported");
    }

    virtual monero_tx_set create_tx(int account_index, string address, uint64_t amount, monero_send_priority priority) {
      throw runtime_error("create_tx() not supported");
    }

    virtual monero_tx_set create_txs(monero_send_request& request) {
      throw runtime_error("create_txs() not supported");
    }

    virtual string relay_tx(const string& tx_metadata) {
      throw runtime_error("relay_tx() not supported");
    }

    virtual string relay_tx(const monero_tx_wallet& tx) {
      throw runtime_error("relay_tx() not supported");
    }

    virtual vector<string> relay_txs(const vector<string>& tx_metadatas) {
      throw runtime_error("relay_txs() not supported");
    }

    virtual vector<string> relay_txs(const vector<shared_ptr<monero_tx_wallet>>& txs) {
      throw runtime_error("relay_txs() not supported");
    }

    virtual monero_tx_set send(const monero_send_request& request) {
      throw runtime_error("send() not supported");
    }

    virtual monero_tx_set send(uint32_t account_index, string address, uint64_t amount) {
      throw runtime_error("send() not supported");
    }

    virtual monero_tx_set send(uint32_t account_index, string address, uint64_t amount, monero_send_priority priority) {
      throw runtime_error("send() not supported");
    }

    virtual monero_tx_set send_split(const monero_send_request& request) {
      throw runtime_error("send_split() not supported");
    }

    //    /**
    //     * 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);

    virtual vector<monero_tx_set> sweep_unlocked(const monero_send_request& request) {
      throw runtime_error("sweep_unlocked() not supported");
    }

    virtual monero_tx_set sweep_output(const monero_send_request& request) {
      throw runtime_error("sweep_output() not supported");
    }

//    /**
//     * 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();

    virtual monero_tx_set sweep_dust(bool do_not_relay = false) {
      throw runtime_error("sweep_dust() not supported");
    }

    virtual monero_tx_set parse_tx_set(const monero_tx_set& tx_set) {
      throw runtime_error("parse_tx_set() not supported");
    }

    virtual string sign(const string& msg) const {
      throw runtime_error("sign() not supported");
    }

    virtual bool verify(const string& msg, const string& address, const string& signature) const {
      throw runtime_error("verify() not supported");
    }

    virtual string get_tx_key(const string& tx_hash) const {
      throw runtime_error("get_tx_key() not supported");
    }

    virtual shared_ptr<monero_check_tx> check_tx_key(const string& tx_hash, const string& txKey, const string& address) const {
      throw runtime_error("check_tx_key() not supported");
    }

//    /**
//     * Get a transaction signature to prove it.
//     *
//     * @param tx_hash 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_hash, const string& address) const;

    virtual string get_tx_proof(const string& tx_hash, const string& address, const string& message) const {
      throw runtime_error("get_tx_proof() not supported");
    }

    virtual shared_ptr<monero_check_tx> check_tx_proof(const string& tx_hash, const string& address, const string& message, const string& signature) const {
      throw runtime_error("check_tx_proof() not supported");
    }

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

    virtual string get_spend_proof(const string& tx_hash, const string& message) const {
      throw runtime_error("get_spend_proof() not supported");
    }

    virtual bool check_spend_proof(const string& tx_hash, const string& message, const string& signature) const {
      throw runtime_error("check_spend_proof() not supported");
    }

    virtual string get_reserve_proof_wallet(const string& message) const {
      throw runtime_error("get_reserve_proof_wallet() not supported");
    }

    virtual string get_reserve_proof_account(uint32_t account_idx, uint64_t amount, const string& message) const {
      throw runtime_error("get_reserve_proof_account() not supported");
    }

    virtual shared_ptr<monero_check_reserve> check_reserve_proof(const string& address, const string& message, const string& signature) const {
      throw runtime_error("check_reserve_proof() not supported");
    }

    virtual string get_tx_note(const string& tx_hash) const {
      throw runtime_error("get_tx_note() not supported");
    }

    virtual vector<string> get_tx_notes(const vector<string>& tx_hashes) const {
      throw runtime_error("get_tx_notes() not supported");
    }

    virtual void set_tx_note(const string& tx_hash, const string& note) {
      throw runtime_error("set_tx_note() not supported");
    }

    virtual void set_tx_notes(const vector<string>& tx_hashes, const vector<string>& notes) {
      throw runtime_error("set_tx_notes() not supported");
    }

    virtual vector<monero_address_book_entry> get_address_book_entries(const vector<uint64_t>& indices) const {
      throw runtime_error("get_address_book_entries() not supported");
    }

    virtual uint64_t add_address_book_entry(const string& address, const string& description, const string& payment_id = "") {
      throw runtime_error("add_address_book_entry() not supported");
    }

    virtual void edit_address_book_entry(uint64_t index, bool set_address, const string& address, bool set_description, const string& description, bool set_payment_id = false, const string& payment_id = "") {
      throw runtime_error("edit_address_book_entry() not supported");
    }

    virtual void delete_address_book_entry(uint64_t index) {
      throw runtime_error("delete_address_book_entry() not supported");
    }

//    /**
//     * 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);

    virtual string create_payment_uri(const monero_send_request& request) const {
      throw runtime_error("create_payment_uri() not supported");
    }

    virtual shared_ptr<monero_send_request> parse_payment_uri(const string& uri) const {
      throw runtime_error("parse_payment_uri() not supported");
    }

    virtual bool get_attribute(const string& key, string& value) const {
      throw runtime_error("get_attribute() not supported");
    }

    virtual void set_attribute(const string& key, const string& val) {
      throw runtime_error("set_attribute() not supported");
    }

    virtual void start_mining(boost::optional<uint64_t> num_threads, boost::optional<bool> background_mining, boost::optional<bool> ignore_battery) {
      throw runtime_error("start_mining() not supported");
    }

    virtual void stop_mining() {
      throw runtime_error("stop_mining() not supported");
    }

    virtual uint64_t wait_for_next_block() {
      throw runtime_error("wait_for_next_block() not supported");
    }

    virtual bool is_multisig_import_needed() const {
      throw runtime_error("is_multisig_import_needed() not supported");
    }

    // bool is_multisig()

    virtual monero_multisig_info get_multisig_info() {
      throw runtime_error("get_multisig_info() not supported");
    }

    virtual string prepare_multisig() {
      throw runtime_error("prepare_multisig() not supported");
    }

    virtual monero_multisig_init_result make_multisig(const vector<string>& multisig_hexes, int threshold, const string& password) {
      throw runtime_error("make_multisig() not supported");
    }

    virtual  monero_multisig_init_result exchange_multisig_keys(const vector<string>& mutisig_hexes, const string& password) {
      throw runtime_error("exchange_multisig_keys() not supported");
    }

    virtual string get_multisig_hex() {
      throw runtime_error("get_multisig_hex() not supported");
    }

    virtual int import_multisig_hex(const vector<string>& multisig_hexes) {
      throw runtime_error("import_multisig_hex() not supported");
    }

    virtual monero_multisig_sign_result sign_multisig_tx_hex(const string& multisig_tx_hex) {
      throw runtime_error("monero_multisig_sign_result() not supported");
    }

    virtual vector<string> submit_multisig_tx_hex(const string& signed_multisig_tx_hex) {
      throw runtime_error("submit_multisig_tx_hex() not supported");
    }

    virtual void save() {
      throw runtime_error("save() not supported");
    }

    virtual void move_to(string path, string password) {
      throw runtime_error("move_to() not supported");
    }

    virtual void close(bool save = false) {
      throw runtime_error("close() not supported");
    }
  };
}