Peerplays_Blockchain/peerplays_migrated
1
0
Fork 0
Code Issues 35 Pull requests 4 Projects Releases 20 Packages Wiki Activity Actions
peerplays_migrated/libraries/app/api.cpp
serkixenos c888274846 Merge beatrice to master 2021-12
2021-12-15 16:36:40 +00:00

646 lines
25 KiB
C++
Raw Blame History

/*
* Copyright (c) 2015 Cryptonomex, Inc., and contributors.
*
* The MIT License
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <cctype>
#include <graphene/app/api.hpp>
#include <graphene/app/api_access.hpp>
#include <graphene/app/application.hpp>
#include <graphene/chain/confidential_object.hpp>
#include <graphene/chain/database.hpp>
#include <graphene/chain/get_config.hpp>
#include <graphene/chain/market_object.hpp>
#include <graphene/chain/protocol/fee_schedule.hpp>
#include <graphene/chain/tournament_object.hpp>
#include <graphene/chain/transaction_object.hpp>
#include <graphene/chain/withdraw_permission_object.hpp>
#include <graphene/chain/worker_object.hpp>
#include <graphene/utilities/key_conversion.hpp>
#include <fc/crypto/hex.hpp>
#include <fc/rpc/api_connection.hpp>
#include <fc/thread/future.hpp>
template class fc::api<graphene::app::block_api>;
template class fc::api<graphene::app::network_broadcast_api>;
template class fc::api<graphene::app::network_node_api>;
template class fc::api<graphene::app::history_api>;
template class fc::api<graphene::app::crypto_api>;
template class fc::api<graphene::app::asset_api>;
template class fc::api<graphene::debug_witness::debug_api>;
template class fc::api<graphene::app::login_api>;
namespace graphene { namespace app {
login_api::login_api(application &a) :
_app(a) {
}
login_api::~login_api() {
}
bool login_api::login(const string &user, const string &password) {
optional<api_access_info> acc = _app.get_api_access_info(user);
if (!acc.valid())
return false;
if (acc->password_hash_b64 != "*") {
std::string password_salt = fc::base64_decode(acc->password_salt_b64);
std::string acc_password_hash = fc::base64_decode(acc->password_hash_b64);
fc::sha256 hash_obj = fc::sha256::hash(password + password_salt);
if (hash_obj.data_size() != acc_password_hash.length())
return false;
if (memcmp(hash_obj.data(), acc_password_hash.c_str(), hash_obj.data_size()) != 0)
return false;
}
for (const std::string &api_name : acc->allowed_apis)
enable_api(api_name);
return true;
}
void login_api::enable_api(const std::string &api_name) {
if (api_name == "database_api") {
_database_api = std::make_shared<database_api>(std::ref(*_app.chain_database()));
} else if (api_name == "block_api") {
_block_api = std::make_shared<block_api>(std::ref(*_app.chain_database()));
} else if (api_name == "network_broadcast_api") {
_network_broadcast_api = std::make_shared<network_broadcast_api>(std::ref(_app));
} else if (api_name == "history_api") {
_history_api = std::make_shared<history_api>(_app);
} else if (api_name == "network_node_api") {
_network_node_api = std::make_shared<network_node_api>(std::ref(_app));
} else if (api_name == "crypto_api") {
_crypto_api = std::make_shared<crypto_api>();
} else if (api_name == "asset_api") {
_asset_api = std::make_shared<asset_api>(_app);
} else if (api_name == "debug_api") {
// can only enable this API if the plugin was loaded
if (_app.get_plugin("debug_witness"))
_debug_api = std::make_shared<graphene::debug_witness::debug_api>(std::ref(_app));
} else if (api_name == "bookie_api") {
// can only enable this API if the plugin was loaded
if (_app.get_plugin("bookie"))
_bookie_api = std::make_shared<graphene::bookie::bookie_api>(std::ref(_app));
} else if (api_name == "affiliate_stats_api") {
// can only enable this API if the plugin was loaded
if (_app.get_plugin("affiliate_stats"))
_affiliate_stats_api = std::make_shared<graphene::affiliate_stats::affiliate_stats_api>(std::ref(_app));
}
return;
}
// block_api
block_api::block_api(graphene::chain::database &db) :
_db(db) {
}
block_api::~block_api() {
}
vector<optional<signed_block>> block_api::get_blocks(uint32_t block_num_from, uint32_t block_num_to) const {
FC_ASSERT(block_num_to >= block_num_from && block_num_to - block_num_from <= 100, "Total blocks to be returned should be less than 100");
vector<optional<signed_block>> res;
for (uint32_t block_num = block_num_from; block_num <= block_num_to; block_num++) {
res.push_back(_db.fetch_block_by_number(block_num));
}
return res;
}
network_broadcast_api::network_broadcast_api(application &a) :
_app(a) {
_applied_block_connection = _app.chain_database()->applied_block.connect([this](const signed_block &b) {
on_applied_block(b);
});
}
void network_broadcast_api::on_applied_block(const signed_block &b) {
if (_callbacks.size()) {
/// we need to ensure the database_api is not deleted for the life of the async operation
auto capture_this = shared_from_this();
for (uint32_t trx_num = 0; trx_num < b.transactions.size(); ++trx_num) {
const auto &trx = b.transactions[trx_num];
auto id = trx.id();
auto itr = _callbacks.find(id);
if (itr != _callbacks.end()) {
auto block_num = b.block_num();
auto &callback = _callbacks.find(id)->second;
fc::async([capture_this, this, id, block_num, trx_num, trx, callback]() {
callback(fc::variant(transaction_confirmation{id, block_num, trx_num, trx},
GRAPHENE_MAX_NESTED_OBJECTS));
});
}
}
}
}
void network_broadcast_api::broadcast_transaction(const signed_transaction &trx) {
trx.validate();
_app.chain_database()->check_transaction_for_duplicated_operations(trx);
_app.chain_database()->push_transaction(trx);
if (_app.p2p_node() != nullptr)
_app.p2p_node()->broadcast_transaction(trx);
}
fc::variant network_broadcast_api::broadcast_transaction_synchronous(const signed_transaction &trx) {
_app.chain_database()->check_transaction_for_duplicated_operations(trx);
fc::promise<fc::variant>::ptr prom(new fc::promise<fc::variant>());
broadcast_transaction_with_callback([=](const fc::variant &v) {
prom->set_value(v);
},
trx);
return fc::future<fc::variant>(prom).wait();
}
void network_broadcast_api::broadcast_block(const signed_block &b) {
_app.chain_database()->push_block(b);
if (_app.p2p_node() != nullptr)
_app.p2p_node()->broadcast(net::block_message(b));
}
void network_broadcast_api::broadcast_transaction_with_callback(confirmation_callback cb, const signed_transaction &trx) {
trx.validate();
_callbacks[trx.id()] = cb;
_app.chain_database()->push_transaction(trx);
if (_app.p2p_node() != nullptr)
_app.p2p_node()->broadcast_transaction(trx);
}
network_node_api::network_node_api(application &a) :
_app(a) {
_pending_trx_connection = _app.chain_database()->on_pending_transaction.connect([this](const signed_transaction &transaction) {
auto transaction_it = _pending_transactions.find(transaction.id());
if (_pending_transactions.end() == transaction_it) {
_pending_transactions[transaction.id()] = transaction;
}
if (_on_pending_transaction) {
_on_pending_transaction(fc::variant(transaction, GRAPHENE_MAX_NESTED_OBJECTS));
}
});
_applied_block_connection = _app.chain_database()->applied_block.connect([this](const signed_block &block) {
for (const auto &transaction : block.transactions) {
auto transaction_it = _pending_transactions.find(transaction.id());
if (_pending_transactions.end() != transaction_it) {
_pending_transactions.erase(transaction_it);
}
}
/*
* Remove expired transactions from pending_transactions
*/
for (const auto &transaction : _pending_transactions) {
if (transaction.second.expiration < block.timestamp) {
auto transaction_it = _pending_transactions.find(transaction.second.id());
if (_pending_transactions.end() != transaction_it) {
_pending_transactions.erase(transaction_it);
}
}
}
});
}
fc::variant_object network_node_api::get_info() const {
fc::mutable_variant_object result = _app.p2p_node()->network_get_info();
result["connection_count"] = _app.p2p_node()->get_connection_count();
return result;
}
void network_node_api::add_node(const fc::ip::endpoint &ep) {
_app.p2p_node()->add_node(ep);
}
std::vector<net::peer_status> network_node_api::get_connected_peers() const {
return _app.p2p_node()->get_connected_peers();
}
std::vector<net::potential_peer_record> network_node_api::get_potential_peers() const {
return _app.p2p_node()->get_potential_peers();
}
fc::variant_object network_node_api::get_advanced_node_parameters() const {
return _app.p2p_node()->get_advanced_node_parameters();
}
void network_node_api::set_advanced_node_parameters(const fc::variant_object &params) {
return _app.p2p_node()->set_advanced_node_parameters(params);
}
map<transaction_id_type, signed_transaction> network_node_api::list_pending_transactions() const {
return _pending_transactions;
}
void network_node_api::subscribe_to_pending_transactions(std::function<void(const variant &)> callback) {
_on_pending_transaction = callback;
}
void network_node_api::unsubscribe_from_pending_transactions() {
_on_pending_transaction = std::function<void(const variant &)>();
}
fc::api<network_broadcast_api> login_api::network_broadcast() const {
FC_ASSERT(_network_broadcast_api);
return *_network_broadcast_api;
}
fc::api<block_api> login_api::block() const {
FC_ASSERT(_block_api);
return *_block_api;
}
fc::api<network_node_api> login_api::network_node() const {
FC_ASSERT(_network_node_api);
return *_network_node_api;
}
fc::api<database_api> login_api::database() const {
FC_ASSERT(_database_api);
return *_database_api;
}
fc::api<history_api> login_api::history() const {
FC_ASSERT(_history_api);
return *_history_api;
}
fc::api<crypto_api> login_api::crypto() const {
FC_ASSERT(_crypto_api);
return *_crypto_api;
}
fc::api<asset_api> login_api::asset() const {
FC_ASSERT(_asset_api);
return *_asset_api;
}
fc::api<graphene::debug_witness::debug_api> login_api::debug() const {
FC_ASSERT(_debug_api);
return *_debug_api;
}
fc::api<graphene::bookie::bookie_api> login_api::bookie() const {
FC_ASSERT(_bookie_api);
return *_bookie_api;
}
fc::api<graphene::affiliate_stats::affiliate_stats_api> login_api::affiliate_stats() const {
FC_ASSERT(_affiliate_stats_api);
return *_affiliate_stats_api;
}
vector<order_history_object> history_api::get_fill_order_history(std::string asset_a, std::string asset_b, uint32_t limit) const {
FC_ASSERT(_app.chain_database());
const auto &db = *_app.chain_database();
asset_id_type a = database_api.get_asset_id_from_string(asset_a);
asset_id_type b = database_api.get_asset_id_from_string(asset_b);
if (a > b)
std::swap(a, b);
const auto &history_idx = db.get_index_type<graphene::market_history::history_index>().indices().get<by_key>();
history_key hkey;
hkey.base = a;
hkey.quote = b;
hkey.sequence = std::numeric_limits<int64_t>::min();
uint32_t count = 0;
auto itr = history_idx.lower_bound(hkey);
vector<order_history_object> result;
while (itr != history_idx.end() && count < limit) {
if (itr->key.base != a || itr->key.quote != b)
break;
result.push_back(*itr);
++itr;
++count;
}
return result;
}
vector<operation_history_object> history_api::get_account_history(const std::string account_id_or_name,
operation_history_id_type stop,
unsigned limit,
operation_history_id_type start) const {
FC_ASSERT(_app.chain_database());
const auto &db = *_app.chain_database();
FC_ASSERT(limit <= api_limit_get_account_history,
"Number of querying accounts can not be greater than ${configured_limit}",
("configured_limit", api_limit_get_account_history));
vector<operation_history_object> result;
account_id_type account;
try {
account = database_api.get_account_id_from_string(account_id_or_name);
const account_transaction_history_object &node = account(db).statistics(db).most_recent_op(db);
if (start == operation_history_id_type() || start.instance.value > node.operation_id.instance.value)
start = node.operation_id;
} catch (...) {
return result;
}
if (_app.is_plugin_enabled("elasticsearch")) {
auto es = _app.get_plugin<elasticsearch::elasticsearch_plugin>("elasticsearch");
if (es.get()->get_running_mode() != elasticsearch::mode::only_save) {
if (!_app.elasticsearch_thread)
_app.elasticsearch_thread = std::make_shared<fc::thread>("elasticsearch");
return _app.elasticsearch_thread->async([&es, &account, &stop, &limit, &start]() {
return es->get_account_history(account, stop, limit, start);
},
"thread invoke for method " BOOST_PP_STRINGIZE(method_name))
.wait();
}
}
const auto &hist_idx = db.get_index_type<account_transaction_history_index>();
const auto &by_op_idx = hist_idx.indices().get<by_op>();
auto index_start = by_op_idx.begin();
auto itr = by_op_idx.lower_bound(boost::make_tuple(account, start));
while (itr != index_start && itr->account == account && itr->operation_id.instance.value > stop.instance.value && result.size() < limit) {
if (itr->operation_id.instance.value <= start.instance.value)
result.push_back(itr->operation_id(db));
--itr;
}
if (stop.instance.value == 0 && result.size() < limit && itr->account == account) {
result.push_back(itr->operation_id(db));
}
return result;
}
vector<operation_history_object> history_api::get_account_history_operations(const std::string account_id_or_name,
int operation_id,
operation_history_id_type start,
operation_history_id_type stop,
unsigned limit) const {
FC_ASSERT(_app.chain_database());
const auto &db = *_app.chain_database();
FC_ASSERT(limit <= api_limit_get_account_history_operations,
"Number of querying history accounts can not be greater than ${configured_limit}",
("configured_limit", api_limit_get_account_history_operations));
vector<operation_history_object> result;
account_id_type account;
try {
account = database_api.get_account_id_from_string(account_id_or_name);
} catch (...) {
return result;
}
const auto &stats = account(db).statistics(db);
if (stats.most_recent_op == account_transaction_history_id_type())
return result;
const account_transaction_history_object *node = &stats.most_recent_op(db);
if (start == operation_history_id_type())
start = node->operation_id;
while (node && node->operation_id.instance.value > stop.instance.value && result.size() < limit) {
if (node->operation_id.instance.value <= start.instance.value) {
if (node->operation_id(db).op.which() == operation_id)
result.push_back(node->operation_id(db));
}
if (node->next == account_transaction_history_id_type())
node = nullptr;
else
node = &node->next(db);
}
if (stop.instance.value == 0 && result.size() < limit) {
auto head = db.find(account_transaction_history_id_type());
if (head != nullptr && head->account == account && head->operation_id(db).op.which() == operation_id)
result.push_back(head->operation_id(db));
}
return result;
}
vector<operation_history_object> history_api::get_relative_account_history(const std::string account_id_or_name,
uint32_t stop,
unsigned limit,
uint32_t start) const {
FC_ASSERT(_app.chain_database());
const auto &db = *_app.chain_database();
FC_ASSERT(limit <= api_limit_get_relative_account_history,
"Number of querying accounts can not be greater than ${configured_limit}",
("configured_limit", api_limit_get_relative_account_history));
vector<operation_history_object> result;
account_id_type account;
try {
account = database_api.get_account_id_from_string(account_id_or_name);
} catch (...) {
return result;
}
const auto &stats = account(db).statistics(db);
if (start == 0)
start = stats.total_ops;
else
start = min(stats.total_ops, start);
if (start >= stop && start > stats.removed_ops && limit > 0) {
const auto &hist_idx = db.get_index_type<account_transaction_history_index>();
const auto &by_seq_idx = hist_idx.indices().get<by_seq>();
auto itr = by_seq_idx.upper_bound(boost::make_tuple(account, start));
auto itr_stop = by_seq_idx.lower_bound(boost::make_tuple(account, stop));
do {
--itr;
result.push_back(itr->operation_id(db));
} while (itr != itr_stop && result.size() < limit);
}
return result;
}
vector<account_balance_object> history_api::list_core_accounts() const {
auto list = _app.get_plugin<accounts_list_plugin>("accounts_list");
FC_ASSERT(list);
return list->list_accounts();
}
flat_set<uint32_t> history_api::get_market_history_buckets() const {
auto hist = _app.get_plugin<market_history_plugin>("market_history");
FC_ASSERT(hist);
return hist->tracked_buckets();
}
vector<bucket_object> history_api::get_market_history(std::string asset_a, std::string asset_b,
uint32_t bucket_seconds, fc::time_point_sec start, fc::time_point_sec end) const {
try {
FC_ASSERT(_app.chain_database());
const auto &db = *_app.chain_database();
asset_id_type a = database_api.get_asset_id_from_string(asset_a);
asset_id_type b = database_api.get_asset_id_from_string(asset_b);
vector<bucket_object> result;
result.reserve(200);
if (a > b)
std::swap(a, b);
const auto &bidx = db.get_index_type<bucket_index>();
const auto &by_key_idx = bidx.indices().get<by_key>();
auto itr = by_key_idx.lower_bound(bucket_key(a, b, bucket_seconds, start));
while (itr != by_key_idx.end() && itr->key.open <= end && result.size() < 200) {
if (!(itr->key.base == a && itr->key.quote == b && itr->key.seconds == bucket_seconds)) {
return result;
}
result.push_back(*itr);
++itr;
}
return result;
}
FC_CAPTURE_AND_RETHROW((asset_a)(asset_b)(bucket_seconds)(start)(end))
}
crypto_api::crypto_api(){};
commitment_type crypto_api::blind(const blind_factor_type &blind, uint64_t value) {
return fc::ecc::blind(blind, value);
}
blind_factor_type crypto_api::blind_sum(const std::vector<blind_factor_type> &blinds_in, uint32_t non_neg) {
return fc::ecc::blind_sum(blinds_in, non_neg);
}
bool crypto_api::verify_sum(const std::vector<commitment_type> &commits_in, const std::vector<commitment_type> &neg_commits_in, int64_t excess) {
return fc::ecc::verify_sum(commits_in, neg_commits_in, excess);
}
verify_range_result crypto_api::verify_range(const commitment_type &commit, const std::vector<char> &proof) {
verify_range_result result;
result.success = fc::ecc::verify_range(result.min_val, result.max_val, commit, proof);
return result;
}
std::vector<char> crypto_api::range_proof_sign(uint64_t min_value,
const commitment_type &commit,
const blind_factor_type &commit_blind,
const blind_factor_type &nonce,
int8_t base10_exp,
uint8_t min_bits,
uint64_t actual_value) {
return fc::ecc::range_proof_sign(min_value, commit, commit_blind, nonce, base10_exp, min_bits, actual_value);
}
verify_range_proof_rewind_result crypto_api::verify_range_proof_rewind(const blind_factor_type &nonce,
const commitment_type &commit,
const std::vector<char> &proof) {
verify_range_proof_rewind_result result;
result.success = fc::ecc::verify_range_proof_rewind(result.blind_out,
result.value_out,
result.message_out,
nonce,
result.min_val,
result.max_val,
const_cast<commitment_type &>(commit),
proof);
return result;
}
range_proof_info crypto_api::range_get_info(const std::vector<char> &proof) {
return fc::ecc::range_get_info(proof);
}
// asset_api
asset_api::asset_api(graphene::app::application &app) :
_app(app),
_db(*app.chain_database()),
database_api(std::ref(*app.chain_database())) {
}
asset_api::~asset_api() {
}
vector<account_asset_balance> asset_api::get_asset_holders(std::string asset, uint32_t start, uint32_t limit) const {
FC_ASSERT(limit <= api_limit_get_asset_holders,
"Number of querying asset holder accounts can not be greater than ${configured_limit}",
("configured_limit", api_limit_get_asset_holders));
asset_id_type asset_id = database_api.get_asset_id_from_string(asset);
const auto &bal_idx = _db.get_index_type<account_balance_index>().indices().get<by_asset_balance>();
auto range = bal_idx.equal_range(boost::make_tuple(asset_id));
vector<account_asset_balance> result;
uint32_t index = 0;
for (const account_balance_object &bal : boost::make_iterator_range(range.first, range.second)) {
if (result.size() >= limit)
break;
if (bal.balance.value == 0)
continue;
if (index++ < start)
continue;
const auto account = _db.find(bal.owner);
account_asset_balance aab;
aab.name = account->name;
aab.account_id = account->id;
aab.amount = bal.balance.value;
result.push_back(aab);
}
return result;
}
// get number of asset holders.
int asset_api::get_asset_holders_count(std::string asset) const {
const auto &bal_idx = _db.get_index_type<account_balance_index>().indices().get<by_asset_balance>();
asset_id_type asset_id = database_api.get_asset_id_from_string(asset);
auto range = bal_idx.equal_range(boost::make_tuple(asset_id));
int count = boost::distance(range) - 1;
return count;
}
// function to get vector of system assets with holders count.
vector<asset_holders> asset_api::get_all_asset_holders() const {
vector<asset_holders> result;
vector<asset_id_type> total_assets;
for (const asset_object &asset_obj : _db.get_index_type<asset_index>().indices()) {
const auto &dasset_obj = asset_obj.dynamic_asset_data_id(_db);
asset_id_type asset_id;
asset_id = dasset_obj.id;
const auto &bal_idx = _db.get_index_type<account_balance_index>().indices().get<by_asset_balance>();
auto range = bal_idx.equal_range(boost::make_tuple(asset_id));
int count = boost::distance(range) - 1;
asset_holders ah;
ah.asset_id = asset_id;
ah.count = count;
result.push_back(ah);
}
return result;
}
}} // namespace graphene::app
Reference in a new issue View git blame Copy permalink