monero_wallet.h

 
#pragma once
 
#include "monero_wallet_model.h"
#include <vector>
#include <set>
 
using namespace monero;
 
namespace monero {
 
  // --------------------------------- LISTENERS ------------------------------
 
  class monero_wallet_listener {
  public:
 
    virtual void on_sync_progress(uint64_t height, uint64_t start_height, uint64_t end_height, double percent_done, const std::string& message) {}
 
    virtual void on_new_block(uint64_t height) {};
 
    virtual void on_balances_changed(uint64_t new_balance, uint64_t new_unlocked_balance) {};
 
    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 bool is_view_only() const {
      throw std::runtime_error("is_view_only() not supported");
    }
 
    virtual void set_daemon_connection(const std::string& uri, const std::string& username = "", const std::string& password = "") {
      throw std::runtime_error("set_daemon_connection() not supported");
    }
 
    virtual void set_daemon_connection(const boost::optional<monero_rpc_connection>& connection) {
      throw std::runtime_error("set_daemon_connection() not supported");
    }
 
    virtual void set_daemon_proxy(const std::string& uri = "") {
      throw std::runtime_error("set_daemon_proxy() not supported");
    }
 
    virtual boost::optional<monero_rpc_connection> get_daemon_connection() const {
      throw std::runtime_error("get_daemon_connection() not supported");
    }
 
    virtual bool is_connected_to_daemon() const {
      throw std::runtime_error("is_connected_to_daemon() not supported");
    }
 
    virtual bool is_daemon_synced() const {
      throw std::runtime_error("is_daemon_synced() not supported");
    }
 
    virtual bool is_daemon_trusted() const {
      throw std::runtime_error("is_daemon_trusted() not supported");
    }
 
    virtual bool is_synced() const {
      throw std::runtime_error("is_synced() not supported");
    }
 
    virtual monero_version get_version() const {
      throw std::runtime_error("get_version() not supported");
    }
 
    virtual std::string get_path() const {
      throw std::runtime_error("get_path() not supported");
    }
 
    virtual monero_network_type get_network_type() const {
      throw std::runtime_error("get_network_type() not supported");
    }
 
    virtual std::string get_seed() const {
      throw std::runtime_error("get_seed() not supported");
    }
 
    virtual std::string get_seed_language() const {
      throw std::runtime_error("get_seed_language() not supported");
    }
 
    virtual std::string get_public_view_key() const {
      throw std::runtime_error("get_public_view_key() not supported");
    }
 
    virtual std::string get_private_view_key() const {
      throw std::runtime_error("get_private_view_key() not supported");
    }
 
    virtual std::string get_public_spend_key() const {
      throw std::runtime_error("get_public_spend_key() not supported");
    }
 
    virtual std::string get_private_spend_key() const {
      throw std::runtime_error("get_private_spend_key() not supported");
    }
 
    virtual std::string get_primary_address() const {
      return get_address(0, 0);
    }
 
    virtual std::string get_address(const uint32_t account_idx, const uint32_t subaddress_idx) const {
      throw std::runtime_error("get_address() not supported");
    }
 
    virtual monero_subaddress get_address_index(const std::string& address) const {
      throw std::runtime_error("get_address_index() not supported");
    }
 
    virtual monero_integrated_address get_integrated_address(const std::string& standard_address = "", const std::string& payment_id = "") const {
      throw std::runtime_error("get_integrated_address() not supported");
    }
 
    virtual monero_integrated_address decode_integrated_address(const std::string& integrated_address) const {
      throw std::runtime_error("decode_integrated_address() not supported");
    }
 
    virtual uint64_t get_height() const {
      throw std::runtime_error("get_height() not supported");
    }
 
    virtual uint64_t get_restore_height() const {
      throw std::runtime_error("get_restore_height() not supported");
    }
 
    virtual void set_restore_height(uint64_t restore_height) {
      throw std::runtime_error("set_restore_height() not supported");
    }
 
    virtual uint64_t get_daemon_height() const {
      throw std::runtime_error("get_daemon_height() not supported");
    }
 
    virtual uint64_t get_daemon_max_peer_height() const {
      throw std::runtime_error("get_daemon_max_peer_height() not supported");
    }
    
    virtual uint64_t get_height_by_date(uint16_t year, uint8_t month, uint8_t day) const {
      throw std::runtime_error("get_height_by_date(year, month, day) not supported");
    }
 
    virtual void add_listener(monero_wallet_listener& listener) {
      throw std::runtime_error("add_listener() not supported");
    }
 
    virtual void remove_listener(monero_wallet_listener& listener) {
      throw std::runtime_error("remove_listener() not supported");
    }
 
    virtual std::set<monero_wallet_listener*> get_listeners() {
      throw std::runtime_error("get_listeners() not supported");
    }
 
    virtual monero_sync_result sync() {
      throw std::runtime_error("sync() not supported");
    }
 
    virtual monero_sync_result sync(monero_wallet_listener& listener) {
      throw std::runtime_error("sync() not supported");
    }
 
    virtual monero_sync_result sync(uint64_t start_height) {
      throw std::runtime_error("sync() not supported");
    }
 
    virtual monero_sync_result sync(uint64_t start_height, monero_wallet_listener& listener) {
      throw std::runtime_error("sync() not supported");
    }
 
    virtual void start_syncing(uint64_t sync_period_in_ms = 10000) {
      throw std::runtime_error("start_syncing() not supported");
    }
 
    virtual void stop_syncing() {
      throw std::runtime_error("stop_syncing() not supported");
    }
 
    virtual void scan_txs(const std::vector<std::string>& tx_hashes) {
      throw std::runtime_error("scan_txs() not supported");
    }
 
    virtual void rescan_spent() {
      throw std::runtime_error("rescan_spent() not supported");
    }
 
    virtual void rescan_blockchain() {
      throw std::runtime_error("rescan_blockchain() not supported");
    }
 
    virtual uint64_t get_balance() const {
      throw std::runtime_error("get_balance() not supported");
    }
 
    virtual uint64_t get_balance(uint32_t account_idx) const {
      throw std::runtime_error("get_balance() not supported");
    }
 
    virtual uint64_t get_balance(uint32_t account_idx, uint32_t subaddress_idx) const {
      throw std::runtime_error("get_balance() not supported");
    }
 
    virtual uint64_t get_unlocked_balance() const {
      throw std::runtime_error("get_unlocked_balance() not supported");
    }
 
    virtual uint64_t get_unlocked_balance(uint32_t account_idx) const {
      throw std::runtime_error("get_unlocked_balance() not supported");
    }
 
    virtual uint64_t get_unlocked_balance(uint32_t account_idx, uint32_t subaddress_idx) const {
      throw std::runtime_error("get_unlocked_balance() not supported");
    }
 
    virtual std::vector<monero_account> get_accounts() const {
      return get_accounts(false, std::string(""));
    }
 
    virtual std::vector<monero_account> get_accounts(bool include_subaddresses) const {
      return get_accounts(include_subaddresses, "");
    }
 
    virtual std::vector<monero_account> get_accounts(const std::string& tag) const {
      return get_accounts(false, tag);
    }
 
    virtual std::vector<monero_account> get_accounts(bool include_subaddresses, const std::string& tag) const {
      throw std::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 std::runtime_error("get_account() not supported");
    }
 
    virtual monero_account create_account(const std::string& label = "") {
      throw std::runtime_error("create_account() not supported");
    }
 
    virtual std::vector<monero_subaddress> get_subaddresses(const uint32_t account_idx) const {
      return get_subaddresses(account_idx, std::vector<uint32_t>());
    }
 
    virtual std::vector<monero_subaddress> get_subaddresses(const uint32_t account_idx, const std::vector<uint32_t>& subaddress_indices) const {
      throw std::runtime_error("get_subaddresses() not supported");
    }
 
    virtual monero_subaddress get_subaddress(const uint32_t account_idx, const uint32_t subaddress_idx) const {
      throw std::runtime_error("get_subaddress() not supported");
    }
 
    virtual monero_subaddress create_subaddress(uint32_t account_idx, const std::string& label = "") {
      throw std::runtime_error("create_subaddress() not supported");
    }
 
    virtual void set_subaddress_label(uint32_t account_idx, uint32_t subaddress_idx, const std::string& label = "") {
      throw std::runtime_error("set_subaddress_label() not supported");
    }
 
    virtual std::vector<std::shared_ptr<monero_tx_wallet>> get_txs() const {
      throw std::runtime_error("get_txs() not supported");
    }
 
    virtual std::vector<std::shared_ptr<monero_tx_wallet>> get_txs(const monero_tx_query& query) const {
      throw std::runtime_error("get_txs(query) not supported");
    }
 
    virtual std::vector<std::shared_ptr<monero_transfer>> get_transfers(const monero_transfer_query& query) const {
      throw std::runtime_error("get_transfers() not supported");
    }
 
    virtual std::vector<std::shared_ptr<monero_output_wallet>> get_outputs(const monero_output_query& query) const {
      throw std::runtime_error("get_outputs() not supported");
    }
 
    virtual std::string export_outputs(bool all = false) const {
      throw std::runtime_error("export_outputs() not supported");
    }
 
    virtual int import_outputs(const std::string& outputs_hex) {
      throw std::runtime_error("import_outputs() not supported");
    }
 
    virtual std::vector<std::shared_ptr<monero_key_image>> export_key_images(bool all = false) const {
      throw std::runtime_error("export_key_images() not supported");
    }
 
    virtual std::shared_ptr<monero_key_image_import_result> import_key_images(const std::vector<std::shared_ptr<monero_key_image>>& key_images) {
      throw std::runtime_error("import_key_images() not supported");
    }
 
    virtual void freeze_output(const std::string& key_image) {
      throw std::runtime_error("freeze_output() not supported");
    }
 
    virtual void thaw_output(const std::string& key_image) {
      throw std::runtime_error("thaw_output() not supported");
    }
 
    virtual bool is_output_frozen(const std::string& key_image) {
      throw std::runtime_error("is_output_frozen() not supported");
    }
 
    virtual std::shared_ptr<monero_tx_wallet> create_tx(const monero_tx_config& config) {
      if (config.m_can_split != boost::none && config.m_can_split.get()) throw std::runtime_error("Cannot split transactions with create_tx(); use create_txs() instead");
      monero_tx_config config_copy = monero_tx_config(config);
      config_copy.m_can_split = false;
      return create_txs(config_copy)[0];
    }
 
    virtual std::vector<std::shared_ptr<monero_tx_wallet>> create_txs(const monero_tx_config& config) {
      throw std::runtime_error("create_txs() not supported");
    }
 
    virtual std::vector<std::shared_ptr<monero_tx_wallet>> sweep_unlocked(const monero_tx_config& config) {
      throw std::runtime_error("sweep_unlocked() not supported");
    }
 
    virtual std::shared_ptr<monero_tx_wallet> sweep_output(const monero_tx_config& config) {
      throw std::runtime_error("sweep_output() not supported");
    }
 
    virtual std::vector<std::shared_ptr<monero_tx_wallet>> sweep_dust(bool relay = false) {
      throw std::runtime_error("sweep_dust() not supported");
    }
 
    virtual std::string relay_tx(const std::string& tx_metadata) {
      std::vector<std::string> tx_metadatas;
      tx_metadatas.push_back(tx_metadata);
      return relay_txs(tx_metadatas)[0];
    }
 
    virtual std::string relay_tx(const monero_tx_wallet& tx) {
      return relay_tx(tx.m_metadata.get());
    }
 
    virtual std::vector<std::string> relay_txs(const std::vector<std::shared_ptr<monero_tx_wallet>>& txs) {
      std::vector<std::string> tx_hexes;
      for (const std::shared_ptr<monero_tx_wallet>& tx : txs) tx_hexes.push_back(tx->m_metadata.get());
      return relay_txs(tx_hexes);
    }
 
    virtual std::vector<std::string> relay_txs(const std::vector<std::string>& tx_metadatas) {
      throw std::runtime_error("relay_txs() not supported");
    }
 
    virtual monero_tx_set describe_tx_set(const monero_tx_set& tx_set) {
      throw std::runtime_error("describe_tx_set() not supported");
    }
 
    virtual monero_tx_set sign_txs(const std::string& unsigned_tx_hex) {
      throw std::runtime_error("sign_txs() not supported");
    }
 
    virtual std::vector<std::string> submit_txs(const std::string& signed_tx_hex) {
      throw std::runtime_error("submit_txs() not supported");
    }
 
    virtual std::string sign_message(const std::string& msg, monero_message_signature_type signature_type, uint32_t account_idx = 0, uint32_t subaddress_idx = 0) const {
      throw std::runtime_error("sign_message() not supported");
    }
 
    virtual monero_message_signature_result verify_message(const std::string& msg, const std::string& address, const std::string& signature) const {
      throw std::runtime_error("verify_message() not supported");
    }
 
    virtual std::string get_tx_key(const std::string& tx_hash) const {
      throw std::runtime_error("get_tx_key() not supported");
    }
 
    virtual std::shared_ptr<monero_check_tx> check_tx_key(const std::string& tx_hash, const std::string& tx_key, const std::string& address) const {
      throw std::runtime_error("check_tx_key() not supported");
    }
 
    virtual std::string get_tx_proof(const std::string& tx_hash, const std::string& address, const std::string& message) const {
      throw std::runtime_error("get_tx_proof() not supported");
    }
 
    virtual std::shared_ptr<monero_check_tx> check_tx_proof(const std::string& tx_hash, const std::string& address, const std::string& message, const std::string& signature) const {
      throw std::runtime_error("check_tx_proof() not supported");
    }
 
    virtual std::string get_spend_proof(const std::string& tx_hash, const std::string& message) const {
      throw std::runtime_error("get_spend_proof() not supported");
    }
 
    virtual bool check_spend_proof(const std::string& tx_hash, const std::string& message, const std::string& signature) const {
      throw std::runtime_error("check_spend_proof() not supported");
    }
 
    virtual std::string get_reserve_proof_wallet(const std::string& message) const {
      throw std::runtime_error("get_reserve_proof_wallet() not supported");
    }
 
    virtual std::string get_reserve_proof_account(uint32_t account_idx, uint64_t amount, const std::string& message) const {
      throw std::runtime_error("get_reserve_proof_account() not supported");
    }
 
    virtual std::shared_ptr<monero_check_reserve> check_reserve_proof(const std::string& address, const std::string& message, const std::string& signature) const {
      throw std::runtime_error("check_reserve_proof() not supported");
    }
 
    virtual std::string get_tx_note(const std::string& tx_hash) const {
      throw std::runtime_error("get_tx_note() not supported");
    }
 
    virtual std::vector<std::string> get_tx_notes(const std::vector<std::string>& tx_hashes) const {
      throw std::runtime_error("get_tx_notes() not supported");
    }
 
    virtual void set_tx_note(const std::string& tx_hash, const std::string& note) {
      throw std::runtime_error("set_tx_note() not supported");
    }
 
    virtual void set_tx_notes(const std::vector<std::string>& tx_hashes, const std::vector<std::string>& notes) {
      throw std::runtime_error("set_tx_notes() not supported");
    }
 
    virtual std::vector<monero_address_book_entry> get_address_book_entries(const std::vector<uint64_t>& indices) const {
      throw std::runtime_error("get_address_book_entries() not supported");
    }
 
    virtual uint64_t add_address_book_entry(const std::string& address, const std::string& description) {
      throw std::runtime_error("add_address_book_entry() not supported");
    }
 
    virtual void edit_address_book_entry(uint64_t index, bool set_address, const std::string& address, bool set_description, const std::string& description) {
      throw std::runtime_error("edit_address_book_entry() not supported");
    }
 
    virtual void delete_address_book_entry(uint64_t index) {
      throw std::runtime_error("delete_address_book_entry() not supported");
    }
 
    virtual std::string get_payment_uri(const monero_tx_config& config) const {
      throw std::runtime_error("get_payment_uri() not supported");
    }
 
    virtual std::shared_ptr<monero_tx_config> parse_payment_uri(const std::string& uri) const {
      throw std::runtime_error("parse_payment_uri() not supported");
    }
 
    virtual bool get_attribute(const std::string& key, std::string& value) const {
      throw std::runtime_error("get_attribute() not supported");
    }
 
    virtual void set_attribute(const std::string& key, const std::string& val) {
      throw std::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 std::runtime_error("start_mining() not supported");
    }
 
    virtual void stop_mining() {
      throw std::runtime_error("stop_mining() not supported");
    }
 
    virtual uint64_t wait_for_next_block() {
      throw std::runtime_error("wait_for_next_block() not supported");
    }
 
    virtual bool is_multisig_import_needed() const {
      throw std::runtime_error("is_multisig_import_needed() not supported");
    }
 
    virtual bool is_multisig() const {
      return get_multisig_info().m_is_multisig;
    }
 
    virtual monero_multisig_info get_multisig_info() const {
      throw std::runtime_error("get_multisig_info() not supported");
    }
 
    virtual std::string prepare_multisig() {
      throw std::runtime_error("prepare_multisig() not supported");
    }
 
    virtual std::string make_multisig(const std::vector<std::string>& multisig_hexes, int threshold, const std::string& password) {
      throw std::runtime_error("make_multisig() not supported");
    }
 
    virtual monero_multisig_init_result exchange_multisig_keys(const std::vector<std::string>& mutisig_hexes, const std::string& password) {
      throw std::runtime_error("exchange_multisig_keys() not supported");
    }
 
    virtual std::string export_multisig_hex() {
      throw std::runtime_error("export_multisig_hex() not supported");
    }
 
    virtual int import_multisig_hex(const std::vector<std::string>& multisig_hexes) {
      throw std::runtime_error("import_multisig_hex() not supported");
    }
 
    virtual monero_multisig_sign_result sign_multisig_tx_hex(const std::string& multisig_tx_hex) {
      throw std::runtime_error("monero_multisig_sign_result() not supported");
    }
 
    virtual std::vector<std::string> submit_multisig_tx_hex(const std::string& signed_multisig_tx_hex) {
      throw std::runtime_error("submit_multisig_tx_hex() not supported");
    }
 
    virtual void change_password(const std::string& old_password, const std::string& new_password) {
      throw std::runtime_error("change_password() not supported");
    }
 
    virtual void move_to(const std::string& path, const std::string& password) {
      throw std::runtime_error("move_to() not supported");
    }
 
    virtual void save() {
      throw std::runtime_error("save() not supported");
    }
 
    virtual void close(bool save = false) {
      throw std::runtime_error("close() not supported");
    }
  };
}