nerodev
/
onion-wownero-explorer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix merging problems

Browse Source
master
moneroexamples 8 years ago
parent b540bf5f72
commit c3c25fcb03
3 changed files with 5070 additions and 5086 deletions
Show Stats Download Patch File Download Diff File

7635
src/page.h
View File

File diff suppressed because it is too large Load Diff

2069
src/tools.cpp
View File

File diff suppressed because it is too large Load Diff

446
src/tools.h
Unescape Escape View File

@ -19,7 +19,6 @@
#include "../ext/fmt/ostream.h" #include "../ext/fmt/ostream.h"
#include "../ext/fmt/format.h" #include "../ext/fmt/format.h"
#include "../ext/json.hpp" #include "../ext/json.hpp"
#include "../ext/member_checker.h"
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
#include <boost/filesystem.hpp> #include <boost/filesystem.hpp>
@ -41,318 +40,317 @@
namespace xmreg namespace xmreg
{ {
using namespace cryptonote; using namespace cryptonote;
using namespace crypto; using namespace crypto;
using namespace std; using namespace std;
namespace bf = boost::filesystem; namespace bf = boost::filesystem;
namespace pt = boost::posix_time; namespace pt = boost::posix_time;
namespace gt = boost::gregorian; namespace gt = boost::gregorian;
namespace lt = boost::local_time; namespace lt = boost::local_time;
using json = nlohmann::json; using json = nlohmann::json;
struct outputs_visitor struct outputs_visitor
{ {
std::vector<crypto::public_key >& m_output_keys; std::vector<crypto::public_key >& m_output_keys;
const Blockchain& m_bch; const Blockchain& m_bch;
outputs_visitor(std::vector<crypto::public_key>& output_keys, const Blockchain& bch) : outputs_visitor(std::vector<crypto::public_key>& output_keys, const Blockchain& bch) :
m_output_keys(output_keys), m_bch(bch) m_output_keys(output_keys), m_bch(bch)
{ {
} }
bool handle_output(uint64_t unlock_time, const crypto::public_key &pubkey)
{
m_output_keys.push_back(pubkey);
return true;
}
};
bool handle_output(uint64_t unlock_time, const crypto::public_key &pubkey)
{
m_output_keys.push_back(pubkey);
return true;
}
};
template <typename T>
bool
parse_str_secret_key(const string& key_str, T& secret_key);
template <typename T>
bool
parse_str_secret_key(const string& key_str, T& secret_key);
bool
get_tx_pub_key_from_str_hash(Blockchain& core_storage,
const string& hash_str,
transaction& tx);
bool bool
get_tx_pub_key_from_str_hash(Blockchain& core_storage, parse_str_address(const string& address_str,
const string& hash_str, account_public_address& address,
transaction& tx); bool testnet = false);
bool inline bool
parse_str_address(const string& address_str, is_separator(char c);
account_public_address& address,
string
print_address(const account_public_address& address,
bool testnet = false); bool testnet = false);
inline bool string
is_separator(char c); print_sig (const signature& sig);
string string
print_address(const account_public_address& address, remove_trailing_path_separator(const string& in_path);
bool testnet = false);
string bf::path
print_sig (const signature& sig); remove_trailing_path_separator(const bf::path& in_path);
string string
remove_trailing_path_separator(const string& in_path); timestamp_to_str_gm(time_t timestamp, const char* format = "%F %T");
bf::path ostream&
remove_trailing_path_separator(const bf::path& in_path); operator<< (ostream& os, const account_public_address& addr);
string
timestamp_to_str_gm(time_t timestamp, const char* format = "%F %T");
ostream& string
operator<< (ostream& os, const account_public_address& addr); get_default_lmdb_folder(bool testnet = false);
bool
generate_key_image(const crypto::key_derivation& derivation,
const std::size_t output_index,
const crypto::secret_key& sec_key,
const crypto::public_key& pub_key,
crypto::key_image& key_img);
string bool
get_default_lmdb_folder(bool testnet = false); get_blockchain_path(const boost::optional<string>& bc_path,
bf::path& blockchain_path,
bool testnet = false);
bool uint64_t
generate_key_image(const crypto::key_derivation& derivation, sum_money_in_outputs(const transaction& tx);
const std::size_t output_index,
const crypto::secret_key& sec_key,
const crypto::public_key& pub_key,
crypto::key_image& key_img);
bool pair<uint64_t, uint64_t>
get_blockchain_path(const boost::optional<string>& bc_path, sum_money_in_outputs(const string& json_str);
bf::path& blockchain_path,
bool testnet = false);
uint64_t pair<uint64_t, uint64_t>
sum_money_in_outputs(const transaction& tx); sum_money_in_outputs(const json& _json);
pair<uint64_t, uint64_t>
sum_money_in_outputs(const string& json_str);
pair<uint64_t, uint64_t> array<uint64_t, 4>
sum_money_in_outputs(const json& _json); summary_of_in_out_rct(
array<uint64_t, 4> const transaction& tx,
summary_of_in_out_rct( vector<pair<txout_to_key, uint64_t>>& output_pub_keys,
const transaction& tx, vector<txin_to_key>& input_key_imgs);
vector<pair<txout_to_key, uint64_t>>& output_pub_keys,
vector<txin_to_key>& input_key_imgs);
// this version for mempool txs from json // this version for mempool txs from json
array<uint64_t, 6> array<uint64_t, 6>
summary_of_in_out_rct(const json& _json); summary_of_in_out_rct(const json& _json);
uint64_t uint64_t
sum_money_in_inputs(const transaction& tx); sum_money_in_inputs(const transaction& tx);
pair<uint64_t, uint64_t> pair<uint64_t, uint64_t>
sum_money_in_inputs(const string& json_str); sum_money_in_inputs(const string& json_str);
pair<uint64_t, uint64_t> pair<uint64_t, uint64_t>
sum_money_in_inputs(const json& _json); sum_money_in_inputs(const json& _json);
uint64_t uint64_t
count_nonrct_inputs(const transaction& tx); count_nonrct_inputs(const transaction& tx);
uint64_t uint64_t
count_nonrct_inputs(const string& json_str); count_nonrct_inputs(const string& json_str);
uint64_t uint64_t
count_nonrct_inputs(const json& _json); count_nonrct_inputs(const json& _json);
array<uint64_t, 2> array<uint64_t, 2>
sum_money_in_tx(const transaction& tx); sum_money_in_tx(const transaction& tx);
array<uint64_t, 2> array<uint64_t, 2>
sum_money_in_txs(const vector<transaction>& txs); sum_money_in_txs(const vector<transaction>& txs);
uint64_t uint64_t
sum_fees_in_txs(const vector<transaction>& txs); sum_fees_in_txs(const vector<transaction>& txs);
uint64_t uint64_t
get_mixin_no(const transaction& tx); get_mixin_no(const transaction& tx);
vector<uint64_t> vector<uint64_t>
get_mixin_no(const string& json_str); get_mixin_no(const string& json_str);
vector<uint64_t> vector<uint64_t>
get_mixin_no(const json& _json); get_mixin_no(const json& _json);
vector<uint64_t> vector<uint64_t>
get_mixin_no_in_txs(const vector<transaction>& txs); get_mixin_no_in_txs(const vector<transaction>& txs);
vector<pair<txout_to_key, uint64_t>> vector<pair<txout_to_key, uint64_t>>
get_ouputs(const transaction& tx); get_ouputs(const transaction& tx);
vector<tuple<txout_to_key, uint64_t, uint64_t>> vector<tuple<txout_to_key, uint64_t, uint64_t>>
get_ouputs_tuple(const transaction& tx); get_ouputs_tuple(const transaction& tx);
vector<txin_to_key> vector<txin_to_key>
get_key_images(const transaction& tx); get_key_images(const transaction& tx);
bool bool
get_payment_id(const vector<uint8_t>& extra, get_payment_id(const vector<uint8_t>& extra,
crypto::hash& payment_id, crypto::hash& payment_id,
crypto::hash8& payment_id8); crypto::hash8& payment_id8);
bool bool
get_payment_id(const transaction& tx, get_payment_id(const transaction& tx,
crypto::hash& payment_id, crypto::hash& payment_id,
crypto::hash8& payment_id8); crypto::hash8& payment_id8);
inline double inline double
get_xmr(uint64_t core_amount) get_xmr(uint64_t core_amount)
{ {
return static_cast<double>(core_amount) / 1e12; return static_cast<double>(core_amount) / 1e12;
} }
array<size_t, 5> array<size_t, 5>
timestamp_difference(uint64_t t1, uint64_t t2); timestamp_difference(uint64_t t1, uint64_t t2);
string string
read(string filename); read(string filename);
/** /**
* prints an iterable such as vector * prints an iterable such as vector
*/ */
template<typename T> template<typename T>
void print_iterable(const T & elems) { void print_iterable(const T & elems) {
infix_ostream_iterator<typename T::value_type> infix_ostream_iterator<typename T::value_type>
oiter(std::cout, ","); oiter(std::cout, ",");
std::cout << "["; std::cout << "[";
std::copy(elems.begin(), elems.end(),oiter); std::copy(elems.begin(), elems.end(),oiter);
std::cout << "]" << std::endl; std::cout << "]" << std::endl;
} }
pair<string, double> pair<string, double>
timestamps_time_scale(const vector<uint64_t>& timestamps, timestamps_time_scale(const vector<uint64_t>& timestamps,
uint64_t timeN, uint64_t resolution = 80, uint64_t timeN, uint64_t resolution = 80,
uint64_t time0 = 1397818193 /* timestamp of the second block */); uint64_t time0 = 1397818193 /* timestamp of the second block */);
time_t time_t
ptime_to_time_t(const pt::ptime& in_ptime); ptime_to_time_t(const pt::ptime& in_ptime);
bool bool
decode_ringct(const rct::rctSig & rv, decode_ringct(const rct::rctSig & rv,
const crypto::public_key pub, const crypto::public_key pub,
const crypto::secret_key &sec, const crypto::secret_key &sec,
unsigned int i, unsigned int i,
rct::key & mask, rct::key & mask,
uint64_t & amount); uint64_t & amount);
bool bool
url_decode(const std::string& in, std::string& out); url_decode(const std::string& in, std::string& out);
map<std::string, std::string> map<std::string, std::string>
parse_crow_post_data(const string& req_body); parse_crow_post_data(const string& req_body);
// from wallet2::decrypt // from wallet2::decrypt
string string
decrypt(const std::string &ciphertext, decrypt(const std::string &ciphertext,
const crypto::secret_key &skey, const crypto::secret_key &skey,
bool authenticated = true); bool authenticated = true);
// based on // based on
// crypto::public_key wallet2::get_tx_pub_key_from_received_outs(const tools::wallet2::transfer_details &td) const // crypto::public_key wallet2::get_tx_pub_key_from_received_outs(const tools::wallet2::transfer_details &td) const
public_key public_key
get_tx_pub_key_from_received_outs(const transaction &tx); get_tx_pub_key_from_received_outs(const transaction &tx);
date::sys_seconds static
parse(const std::string& str, string format="%Y-%m-%d %H:%M:%S"); string
xmr_amount_to_str(const uint64_t& xmr_amount,
static string _format="{:0.12f}",
string bool zero_to_question_mark=true)
xmr_amount_to_str(const uint64_t& xmr_amount,
string _format="{:0.12f}",
bool zero_to_question_mark=true)
{
string amount_str = "?";
if (!zero_to_question_mark)
{
amount_str = fmt::format(_format, XMR_AMOUNT(xmr_amount));
}
else
{ {
if (xmr_amount > 0 && zero_to_question_mark == true) string amount_str = "?";
if (!zero_to_question_mark)
{ {
amount_str = fmt::format(_format, XMR_AMOUNT(xmr_amount)); amount_str = fmt::format(_format, XMR_AMOUNT(xmr_amount));
} }
} else
{
if (xmr_amount > 0 && zero_to_question_mark == true)
{
amount_str = fmt::format(_format, XMR_AMOUNT(xmr_amount));
}
}
return amount_str; return amount_str;
} }
bool bool
is_output_ours(const size_t& output_index, is_output_ours(const size_t& output_index,
const transaction& tx, const transaction& tx,
const public_key& pub_tx_key, const public_key& pub_tx_key,
const secret_key& private_view_key, const secret_key& private_view_key,
const public_key& public_spend_key); const public_key& public_spend_key);
bool bool
get_real_output_for_key_image(const key_image& ki, get_real_output_for_key_image(const key_image& ki,
const transaction& tx, const transaction& tx,
const secret_key& private_view_key, const secret_key& private_view_key,
const public_key& public_spend_key, const public_key& public_spend_key,
uint64_t output_idx, uint64_t output_idx,
public_key output_pub_key); public_key output_pub_key);
// based on http://stackoverflow.com/a/9943098/248823 // based on http://stackoverflow.com/a/9943098/248823
template<typename Iterator, typename Func> template<typename Iterator, typename Func>
void chunks(Iterator begin, void chunks(Iterator begin,
Iterator end, Iterator end,
iterator_traits<string::iterator>::difference_type k, iterator_traits<string::iterator>::difference_type k,
Func f) Func f)
{
Iterator chunk_begin;
Iterator chunk_end;
chunk_end = chunk_begin = begin;
do
{ {
if(std::distance(chunk_end, end) < k) Iterator chunk_begin;
chunk_end = end; Iterator chunk_end;
else chunk_end = chunk_begin = begin;
std::advance(chunk_end, k);
f(chunk_begin,chunk_end); do
chunk_begin = chunk_end; {
if(std::distance(chunk_end, end) < k)
chunk_end = end;
else
std::advance(chunk_end, k);
f(chunk_begin,chunk_end);
chunk_begin = chunk_end;
}
while(std::distance(chunk_begin,end) > 0);
} }
while(std::distance(chunk_begin,end) > 0);
}
bool bool
make_tx_from_json(const string& json_str, transaction& tx); make_tx_from_json(const string& json_str, transaction& tx);
string string
make_printable(const string& in_s); make_printable(const string& in_s);
string string
get_human_readable_timestamp(uint64_t ts); get_human_readable_timestamp(uint64_t ts);
// Get the median of an unordered set of numbers of arbitrary // Get the median of an unordered set of numbers of arbitrary
// type without modifying the underlying dataset. // type without modifying the underlying dataset.
// taken from http://stackoverflow.com/a/19695285 // taken from http://stackoverflow.com/a/19695285
template <typename It> template <typename It>
typename std::iterator_traits<It>::value_type typename std::iterator_traits<It>::value_type
calc_median(It it_begin, It it_end) calc_median(It it_begin, It it_end)
{ {
using T = typename std::iterator_traits<It>::value_type; using T = typename std::iterator_traits<It>::value_type;
std::vector<T> data(it_begin, it_end); std::vector<T> data(it_begin, it_end);
std::nth_element(data.begin(), data.begin() + data.size() / 2, data.end()); std::nth_element(data.begin(), data.begin() + data.size() / 2, data.end());
return data[data.size() / 2]; return data[data.size() / 2];
} }
void void
pause_execution(uint64_t no_seconds, const string& text = "now"); pause_execution(uint64_t no_seconds, const string& text = "now");
} }

Write Preview
Loading…
Cancel
Save