monero_utils.h

 
#pragma once
 
#ifndef monero_utils_h
#define monero_utils_h
 
#include "wallet/monero_wallet_model.h"
#include "cryptonote_basic/cryptonote_basic.h"
#include "serialization/keyvalue_serialization.h" // TODO: consolidate with other binary deps?
#include "storages/portable_storage.h"

namespace monero_utils
{
  using namespace cryptonote;
 
  // ------------------------------ CONSTANTS ---------------------------------
 
  static const int RING_SIZE = 16;  // network-enforced ring size
  static const uint64_t XMR_AU_MULTIPLIER = 1000000000000ULL;
 
  // -------------------------------- UTILS -----------------------------------
 
  void set_log_level(int level);
  void set_log_categories(const std::string& categories);
  void configure_logging(const std::string& path, bool console);
  monero_integrated_address get_integrated_address(monero_network_type network_type, const std::string& standard_address, const std::string& payment_id);
  std::string get_payment_uri(const monero_tx_config& config, monero_network_type network_type);
  std::shared_ptr<monero_tx_config> parse_payment_uri(const std::string& uri, monero_network_type network_type);
  bool is_valid_address(const std::string& address, monero_network_type network_type);
  bool is_valid_private_view_key(const std::string& private_view_key);
  bool is_valid_private_spend_key(const std::string& private_spend_key);
  bool is_valid_public_view_key(const std::string& public_view_key);
  bool is_valid_public_spend_key(const std::string& public_spend_key);
  bool is_valid_payment_id(const std::string& payment_id);
  bool is_valid_mnemonic(const std::string& mnemonic, const std::string& language = "");
  void validate_address(const std::string& address, monero_network_type network_type);
  void validate_private_view_key(const std::string& private_view_key);
  void validate_private_spend_key(const std::string& private_spend_key);
  void validate_public_view_key(const std::string& public_view_key);
  void validate_public_spend_key(const std::string& public_spend_key);
  void validate_payment_id(const std::string& payment_id);
  void validate_mnemonic(const std::string& mnemonic, const std::string& language = "");
  void json_to_binary(const std::string &json, std::string &bin);
  void binary_to_json(const std::string &bin, std::string &json);
  void binary_blocks_to_json(const std::string &bin, std::string &json);
  void binary_blocks_fast_to_json(const std::string &bin, std::string &json);
  uint64_t xmr_to_atomic_units(double amount_xmr);
  double atomic_units_to_xmr(uint64_t amount_atomic_units);
 
  // ------------------------------ RAPIDJSON ---------------------------------

  template <class T>
  void add_json_member(std::string key, T val, rapidjson::Document::AllocatorType& allocator, rapidjson::Value& root, rapidjson::Value& field) {
    rapidjson::Value field_key(key.c_str(), key.size(), allocator);
    if (std::is_signed<T>::value) field.SetInt64((int64_t) val);
    else field.SetUint64((uint64_t) val);
    root.AddMember(field_key, field, allocator);
  }
  void add_json_member(std::string key, std::string val, rapidjson::Document::AllocatorType& allocator, rapidjson::Value& root, rapidjson::Value& field);
  void add_json_member(std::string key, bool val, rapidjson::Document::AllocatorType& allocator, rapidjson::Value& root);
 
  // TODO: template implementation here, could move to monero_utils.hpp per https://stackoverflow.com/questions/3040480/c-template-function-compiles-in-header-but-not-implementation
  template <class T> rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator, const std::vector<std::shared_ptr<T>>& vals) {
    rapidjson::Value value_arr(rapidjson::kArrayType);
    for (const auto& val : vals) {
      value_arr.PushBack(val->to_rapidjson_val(allocator), allocator);
    }
    return value_arr;
  }
 
  // TODO: template implementation here, could move to monero_utils.hpp per https://stackoverflow.com/questions/3040480/c-template-function-compiles-in-header-but-not-implementation
  template <class T> rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator, const std::vector<T>& vals) {
    rapidjson::Value value_arr(rapidjson::kArrayType);
    for (const auto& val : vals) {
      value_arr.PushBack(val.to_rapidjson_val(allocator), allocator);
    }
    return value_arr;
  }
 
  rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator, const std::vector<std::string>& strs);
  rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator, const std::vector<int>& nums);
  rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator, const std::vector<uint8_t>& nums);
  rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator, const std::vector<uint32_t>& nums);
  rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator, const std::vector<uint64_t>& nums);
 
  // --------------------------------------------------------------------------

  bool is_valid_language(const std::string& language);

  bool parse_payment_id_long(const std::string& payment_id_str, crypto::hash& payment_id);

  bool parse_payment_id_short(const std::string& payment_id_str, crypto::hash8& payment_id);

  std::shared_ptr<monero_block> cn_block_to_block(const cryptonote::block& cn_block);

  std::shared_ptr<monero_tx> cn_tx_to_tx(const cryptonote::transaction& cn_tx, bool init_as_tx_wallet = false);

  static std::string get_pruned_tx_json(cryptonote::transaction &tx)
  {
    std::stringstream ss;
    json_archive<true> ar(ss);
    bool r = tx.serialize_base(ar);
    CHECK_AND_ASSERT_MES(r, std::string(), "Failed to serialize rct signatures base");
    return ss.str();
  }
 
  void binary_blocks_to_property_tree(const std::string &bin, boost::property_tree::ptree &node);
  void binary_blocks_fast_to_property_tree(const std::string &bin, boost::property_tree::ptree &node);

  void merge_tx(const std::shared_ptr<monero_tx_wallet>& tx, std::map<std::string, std::shared_ptr<monero_tx_wallet>>& tx_map, std::map<uint64_t, std::shared_ptr<monero_block>>& block_map);

  bool tx_height_less_than(const std::shared_ptr<monero_tx>& tx1, const std::shared_ptr<monero_tx>& tx2);

  bool incoming_transfer_before(const std::shared_ptr<monero_incoming_transfer>& transfer1, const std::shared_ptr<monero_incoming_transfer>& transfer2);

  bool vout_before(const std::shared_ptr<monero_output>& o1, const std::shared_ptr<monero_output>& o2);
 
  // ----------------------------- GATHER BLOCKS ------------------------------
 
  static std::vector<std::shared_ptr<monero_block>> get_blocks_from_txs(std::vector<std::shared_ptr<monero_tx_wallet>> txs) {
    std::shared_ptr<monero_block> unconfirmed_block = nullptr; // placeholder for unconfirmed txs
    std::vector<std::shared_ptr<monero_block>> blocks;
    std::unordered_set<std::shared_ptr<monero_block>> seen_block_ptrs;
    for (const std::shared_ptr<monero_tx_wallet>& tx : txs) {
      if (tx->m_block == nullptr) {
        if (unconfirmed_block == nullptr) unconfirmed_block = std::make_shared<monero_block>();
        tx->m_block = unconfirmed_block;
        unconfirmed_block->m_txs.push_back(tx);
      }
      std::unordered_set<std::shared_ptr<monero_block>>::const_iterator got = seen_block_ptrs.find(tx->m_block);
      if (got == seen_block_ptrs.end()) {
        seen_block_ptrs.insert(tx->m_block);
        blocks.push_back(tx->m_block);
      }
    }
    return blocks;
  }
 
  static std::vector<std::shared_ptr<monero_block>> get_blocks_from_transfers(std::vector<std::shared_ptr<monero_transfer>> transfers) {
    std::shared_ptr<monero_block> unconfirmed_block = nullptr; // placeholder for unconfirmed txs in return json
    std::vector<std::shared_ptr<monero_block>> blocks;
    std::unordered_set<std::shared_ptr<monero_block>> seen_block_ptrs;
    for (auto const& transfer : transfers) {
      if (transfer->m_tx == nullptr) throw std::runtime_error("Transfer has no tx");
      std::shared_ptr<monero_tx_wallet> tx = transfer->m_tx;
      if (tx->m_block == nullptr) {
        if (unconfirmed_block == nullptr) unconfirmed_block = std::make_shared<monero_block>();
        tx->m_block = unconfirmed_block;
        unconfirmed_block->m_txs.push_back(tx);
      }
      std::unordered_set<std::shared_ptr<monero_block>>::const_iterator got = seen_block_ptrs.find(tx->m_block);
      if (got == seen_block_ptrs.end()) {
        seen_block_ptrs.insert(tx->m_block);
        blocks.push_back(tx->m_block);
      }
    }
    return blocks;
  }
 
  static std::vector<std::shared_ptr<monero_block>> get_blocks_from_outputs(std::vector<std::shared_ptr<monero_output_wallet>> outputs) {
    std::vector<std::shared_ptr<monero_block>> blocks;
    std::unordered_set<std::shared_ptr<monero_block>> seen_block_ptrs;
    for (auto const& output : outputs) {
      if (output->m_tx == nullptr) throw std::runtime_error("Output has no tx");
      std::shared_ptr<monero_tx_wallet> tx = std::static_pointer_cast<monero_tx_wallet>(output->m_tx);
      if (tx->m_block == nullptr) throw std::runtime_error("Need to handle unconfirmed output");
      std::unordered_set<std::shared_ptr<monero_block>>::const_iterator got = seen_block_ptrs.find(tx->m_block);
      if (got == seen_block_ptrs.end()) {
        seen_block_ptrs.insert(tx->m_block);
        blocks.push_back(tx->m_block);
      }
    }
    return blocks;
  }
 
  // ------------------------------ FREE MEMORY -------------------------------
 
  static void free(std::shared_ptr<monero_block> block) {
    if (block == nullptr) return;
    for (std::shared_ptr<monero_tx>& tx : block->m_txs) {
      tx->m_block.reset();
      monero_tx_wallet* tx_wallet = dynamic_cast<monero_tx_wallet*>(tx.get());
      if (tx_wallet != nullptr) {
        if (tx_wallet->m_tx_set != nullptr) tx_wallet->m_tx_set.reset();
        if (tx_wallet->m_outgoing_transfer != nullptr) tx_wallet->m_outgoing_transfer->m_tx.reset();
        for (std::shared_ptr<monero_transfer> transfer : tx_wallet->m_incoming_transfers) transfer->m_tx.reset();
        for (std::shared_ptr<monero_output> output : tx_wallet->m_outputs) output->m_tx.reset();
        for (std::shared_ptr<monero_output> input : tx_wallet->m_inputs) {
          input->m_key_image.reset();
          input->m_tx.reset();
        }
      }
      monero_tx_query* tx_query = dynamic_cast<monero_tx_query*>(tx.get());
      if (tx_query != nullptr) {
        if (tx_query->m_transfer_query != nullptr) {
          tx_query->m_transfer_query->m_tx_query.reset();
          tx_query->m_transfer_query.reset();
        }
        if (tx_query->m_output_query != nullptr) {
          tx_query->m_output_query->m_tx_query.reset();
          tx_query->m_output_query.reset();
        }
      }
    }
    block.reset();
  }
 
  static void free(std::vector<std::shared_ptr<monero_block>> blocks) {
    for (std::shared_ptr<monero_block>& block : blocks) monero_utils::free(block);
  }
 
  static void free(std::shared_ptr<monero_tx> tx) {
    if (tx == nullptr) return;
    if (tx->m_block == nullptr) {
      std::shared_ptr<monero_block> block = std::make_shared<monero_block>();
      tx->m_block = block;
      block->m_txs.push_back(tx);
    }
    monero_utils::free(tx->m_block);
  }
 
  static void free(std::vector<std::shared_ptr<monero_tx_wallet>> txs) {
    return monero_utils::free(monero_utils::get_blocks_from_txs(txs));
  }
 
  static void free(std::vector<std::shared_ptr<monero_transfer>> transfers) {
    return monero_utils::free(monero_utils::get_blocks_from_transfers(transfers));
  }
 
  static void free(std::vector<std::shared_ptr<monero_output_wallet>> outputs) {
    return monero_utils::free(monero_utils::get_blocks_from_outputs(outputs));
  }
}
#endif /* monero_utils_h */