monero_utils.h

#ifndef monero_utils_h
#define monero_utils_h

#include "wallet/monero_wallet.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 std;
  using namespace cryptonote;

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

  shared_ptr<monero_tx_query> deserialize_tx_query(const string& txQueryStr);

  shared_ptr<monero_transfer_query> deserialize_transfer_query(const string& transfer_query_str);

  shared_ptr<monero_output_query> deserialize_output_query(const string& output_query_str);

  shared_ptr<monero_send_request> deserialize_send_request(const string& send_request_str);

  vector<shared_ptr<monero_key_image>> deserialize_key_images(const string& key_images_json);

  string serialize(const boost::property_tree::ptree& node);

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


  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();
  }

  // ----------------------------- PROPERTY TREE ------------------------------

  // 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> boost::property_tree::ptree to_property_tree(const vector<shared_ptr<T>>& types) {
    boost::property_tree::ptree typeNodes;
    for (const auto& type : types)  {
      typeNodes.push_back(std::make_pair("", type->to_property_tree()));
    }
    return typeNodes;
  }

  // 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> boost::property_tree::ptree to_property_tree(const vector<T>& types) {
    boost::property_tree::ptree typeNodes;
    for (const auto& type : types)  {
      typeNodes.push_back(std::make_pair("", type.to_property_tree()));
    }
    return typeNodes;
  }

  boost::property_tree::ptree to_property_tree(const vector<string>& strs);
  boost::property_tree::ptree to_property_tree(const vector<uint8_t>& nums);
  boost::property_tree::ptree to_property_tree(const vector<uint32_t>& nums);
  boost::property_tree::ptree to_property_tree(const vector<uint64_t>& nums);

  // ------------------------- VALUE RECONCILATION- ---------------------------

  // TODO: refactor common template code
  template <class T, typename std::enable_if<std::is_same<T, string>::value, T>::type* = nullptr>
  boost::optional<T> reconcile(const boost::optional<T>& val1, const boost::optional<T>& val2, boost::optional<bool> resolve_defined, boost::optional<bool> resolve_true, boost::optional<bool> resolve_max, const string& err_msg = "") {

    // check for equality
    if (val1 == val2) return val1;

    // resolve one value none
    if (val1 == boost::none || val2 == boost::none) {
      if (resolve_defined != boost::none && *resolve_defined == false) return boost::none;
      else return val1 == boost::none ? val2 : val1;
    }

    throw runtime_error(string("Cannot reconcile strings: ") + to_string(val1) + string(" vs ") + to_string(val2) + (!err_msg.empty() ? string(". ") + err_msg : string("")));
  }
  template <class T, typename std::enable_if<std::is_same<T, string>::value, T>::type* = nullptr>
  boost::optional<T> reconcile(const boost::optional<T>& val1, const boost::optional<T>& val2, const string& err_msg = "") {
    return reconcile(val1, val2, boost::none, boost::none, boost::none, err_msg);
  }

  template <class T, typename std::enable_if<std::is_integral<T>::value, T>::type* = nullptr>
  boost::optional<T> reconcile(const boost::optional<T>& val1, const boost::optional<T>& val2, boost::optional<bool> resolve_defined, boost::optional<bool> resolve_true, boost::optional<bool> resolve_max, const string& err_msg = "") {

    // check for equality
    if (val1 == val2) return val1;

    // resolve one value none
    if (val1 == boost::none || val2 == boost::none) {
      if (resolve_defined != boost::none && *resolve_defined == false) return boost::none;
      else return val1 == boost::none ? val2 : val1;
    }

    // resolve different numbers
    if (resolve_max != boost::none) {
      return *resolve_max ? max(*val1, *val2) : min(*val1, *val2);
    }

    // throw runtime_error("Cannot reconcile values " + val1 + " and " + val2 + " with config: [" + resolve_defined + ", " + resolve_true + ", " + resolve_max + "]", val1, val2);
    throw runtime_error(string("Cannot reconcile integrals: ") + to_string(val1) + string(" vs ") + to_string(val2) + (!err_msg.empty() ? string(". ") + err_msg : string("")));
  }
  template <class T, typename std::enable_if<std::is_integral<T>::value, T>::type* = nullptr>
  boost::optional<T> reconcile(const boost::optional<T>& val1, const boost::optional<T>& val2, const string& err_msg = "") {
    return reconcile(val1, val2, boost::none, boost::none, boost::none, err_msg);
  }

  template <class T, typename std::enable_if<std::is_same<T, bool>::value, T>::type>
  boost::optional<T> reconcile(const boost::optional<T>& val1, const boost::optional<T>& val2, boost::optional<bool> resolve_defined, boost::optional<bool> resolve_true, boost::optional<bool> resolve_max, const string& err_msg = "") {

    // check for equality
    if (val1 == val2) return val1;

    // resolve one value none
    if (val1 == boost::none || val2 == boost::none) {
      if (resolve_defined != boost::none && *resolve_defined == false) return boost::none;
      else return val1 == boost::none ? val2 : val1;
    }

    // resolve different booleans
    if (resolve_true != boost::none) {
      return val1 == resolve_true ? val1 : val2; // if resolve true, return true, else return false
    } else {
      throw runtime_error(string("Cannot reconcile booleans: ") + to_string(val1) + string(" vs ") + to_string(val2) + (!err_msg.empty() ? string(". ") + err_msg : string("")));
    }
  }
  template <class T, typename std::enable_if<std::is_same<T, bool>::value, T>::type>
  boost::optional<T> reconcile(const boost::optional<T>& val1, const boost::optional<T>& val2, const string& err_msg = "") {
    return reconcile(val1, val2, boost::none, boost::none, boost::none, err_msg);
  }

  template <class T>
  vector<T> reconcile(const vector<T>& v1, const vector<T>& v2, const string& err_msg = "") {

    // check for equality
    if (v1 == v2) return v1;

    // resolve one vector empty
    if (v1.empty()) return v2;
    if (v2.empty()) return v1;

    // otherwise cannot reconcile
    throw runtime_error("Cannot reconcile vectors" + (!err_msg.empty() ? string(". ") + err_msg : string("")));
  }

//    template <class T>
//    boost::optional<T> reconcile(const boost::optional<T>& val1, const boost::optional<T>& val2) {
//      return reconcile(val1, val2, boost::none, boost::none, boost::none);
//    }
}
#endif /* monero_utils_h */