/* * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define GET_REQUIRED_FEES_MAX_RECURSION 4 typedef std::map, std::vector> market_queue_type; template class fc::api; namespace graphene { namespace app { class database_api_impl : public std::enable_shared_from_this { public: database_api_impl(graphene::chain::database &db); ~database_api_impl(); // Objects fc::variants get_objects(const vector &ids) const; // Subscriptions void set_subscribe_callback(std::function cb, bool notify_remove_create); void set_pending_transaction_callback(std::function cb); void set_block_applied_callback(std::function cb); void cancel_all_subscriptions(); // Blocks and transactions optional get_block_header(uint32_t block_num) const; map> get_block_header_batch(const vector block_nums) const; optional get_block(uint32_t block_num) const; vector> get_blocks(uint32_t block_num_from, uint32_t block_num_to) const; processed_transaction get_transaction(uint32_t block_num, uint32_t trx_in_block) const; // Globals chain_property_object get_chain_properties() const; global_property_object get_global_properties() const; fc::variant_object get_config() const; chain_id_type get_chain_id() const; dynamic_global_property_object get_dynamic_global_properties() const; global_betting_statistics_object get_global_betting_statistics() const; // Keys vector> get_key_references(vector key) const; bool is_public_key_registered(string public_key) const; // Accounts account_id_type get_account_id_from_string(const std::string &name_or_id) const; vector> get_accounts(const vector &account_names_or_ids) const; std::map get_full_accounts(const vector &names_or_ids, bool subscribe); optional get_account_by_name(string name) const; vector get_account_references(const std::string account_id_or_name) const; vector> lookup_account_names(const vector &account_names) const; map lookup_accounts(const string &lower_bound_name, uint32_t limit) const; uint64_t get_account_count() const; // Balances vector get_account_balances(const std::string &account_name_or_id, const flat_set &assets) const; vector get_balance_objects(const vector

&addrs) const; vector get_vested_balances(const vector &objs) const; vector get_vesting_balances(const std::string account_id_or_name) const; // Assets asset_id_type get_asset_id_from_string(const std::string &symbol_or_id) const; vector> get_assets(const vector &asset_symbols_or_ids) const; // helper function vector> get_assets(const vector &asset_ids) const; vector list_assets(const string &lower_bound_symbol, uint32_t limit) const; vector> lookup_asset_symbols(const vector &symbols_or_ids) const; uint64_t get_asset_count() const; // Peerplays vector list_sports() const; vector list_event_groups(sport_id_type sport_id) const; vector list_events_in_group(event_group_id_type event_group_id) const; vector list_betting_market_groups(event_id_type) const; vector list_betting_markets(betting_market_group_id_type) const; vector get_unmatched_bets_for_bettor(betting_market_id_type, account_id_type) const; vector get_all_unmatched_bets_for_bettor(account_id_type) const; // Lottery Assets vector get_lotteries(asset_id_type stop = asset_id_type(), unsigned limit = 100, asset_id_type start = asset_id_type()) const; vector get_account_lotteries(account_id_type issuer, asset_id_type stop, unsigned limit, asset_id_type start) const; asset get_lottery_balance(asset_id_type lottery_id) const; sweeps_vesting_balance_object get_sweeps_vesting_balance_object(account_id_type account) const; asset get_sweeps_vesting_balance_available_for_claim(account_id_type account) const; // Markets / feeds vector get_limit_orders(const asset_id_type a, const asset_id_type b, const uint32_t limit) const; vector get_limit_orders(const std::string &a, const std::string &b, const uint32_t limit) const; vector get_call_orders(const std::string &a, uint32_t limit) const; vector get_settle_orders(const std::string &a, uint32_t limit) const; vector get_margin_positions(const std::string account_id_or_name) const; void subscribe_to_market(std::function callback, const std::string &a, const std::string &b); void unsubscribe_from_market(const std::string &a, const std::string &b); market_ticker get_ticker(const string &base, const string "e) const; market_volume get_24_volume(const string &base, const string "e) const; order_book get_order_book(const string &base, const string "e, unsigned limit = 50) const; vector get_trade_history(const string &base, const string "e, fc::time_point_sec start, fc::time_point_sec stop, unsigned limit = 100) const; // Witnesses vector> get_witnesses(const vector &witness_ids) const; fc::optional get_witness_by_account(const std::string account_id_or_name) const; map lookup_witness_accounts(const string &lower_bound_name, uint32_t limit) const; uint64_t get_witness_count() const; // Committee members vector> get_committee_members(const vector &committee_member_ids) const; fc::optional get_committee_member_by_account(const std::string account_id_or_name) const; map lookup_committee_member_accounts(const string &lower_bound_name, uint32_t limit) const; // SON members vector> get_sons(const vector &son_ids) const; fc::optional get_son_by_account(account_id_type account) const; map lookup_son_accounts(const string &lower_bound_name, uint32_t limit) const; uint64_t get_son_count() const; // SON wallets optional get_active_son_wallet(); optional get_son_wallet_by_time_point(time_point_sec time_point); vector> get_son_wallets(uint32_t limit); // Sidechain addresses vector> get_sidechain_addresses(const vector &sidechain_address_ids) const; vector> get_sidechain_addresses_by_account(account_id_type account) const; vector> get_sidechain_addresses_by_sidechain(sidechain_type sidechain) const; fc::optional get_sidechain_address_by_account_and_sidechain(account_id_type account, sidechain_type sidechain) const; uint64_t get_sidechain_addresses_count() const; // Votes vector lookup_vote_ids(const vector &votes) const; // Authority / validation std::string get_transaction_hex(const signed_transaction &trx) const; set get_required_signatures(const signed_transaction &trx, const flat_set &available_keys) const; set get_potential_signatures(const signed_transaction &trx) const; set

get_potential_address_signatures(const signed_transaction &trx) const; bool verify_authority(const signed_transaction &trx) const; bool verify_account_authority(const string &name_or_id, const flat_set &signers) const; processed_transaction validate_transaction(const signed_transaction &trx) const; vector get_required_fees(const vector &ops, const std::string &asset_id_or_symbol) const; // Proposed transactions vector get_proposed_transactions(const std::string account_id_or_name) const; // Blinded balances vector get_blinded_balances(const flat_set &commitments) const; // Tournaments vector get_tournaments_in_state(tournament_state state, uint32_t limit) const; vector get_tournaments(tournament_id_type stop, unsigned limit, tournament_id_type start); vector get_tournaments_by_state(tournament_id_type stop, unsigned limit, tournament_id_type start, tournament_state state); vector get_registered_tournaments(account_id_type account_filter, uint32_t limit) const; // gpos gpos_info get_gpos_info(const account_id_type account) const; // rbac vector get_custom_permissions(const account_id_type account) const; fc::optional get_custom_permission_by_name(const account_id_type account, const string &permission_name) const; vector get_custom_account_authorities(const account_id_type account) const; vector get_custom_account_authorities_by_permission_id(const custom_permission_id_type permission_id) const; vector get_custom_account_authorities_by_permission_name(const account_id_type account, const string &permission_name) const; vector get_active_custom_account_authorities_by_operation(const account_id_type account, int operation_type) const; // NFT uint64_t nft_get_balance(const account_id_type owner) const; optional nft_owner_of(const nft_id_type token_id) const; optional nft_get_approved(const nft_id_type token_id) const; bool nft_is_approved_for_all(const account_id_type owner, const account_id_type operator_) const; string nft_get_name(const nft_metadata_id_type nft_metadata_id) const; string nft_get_symbol(const nft_metadata_id_type nft_metadata_id) const; string nft_get_token_uri(const nft_id_type token_id) const; uint64_t nft_get_total_supply(const nft_metadata_id_type nft_metadata_id) const; nft_object nft_token_by_index(const nft_metadata_id_type nft_metadata_id, const uint64_t token_idx) const; nft_object nft_token_of_owner_by_index(const nft_metadata_id_type nft_metadata_id, const account_id_type owner, const uint64_t token_idx) const; vector nft_get_all_tokens() const; vector nft_get_tokens_by_owner(const account_id_type owner) const; // Marketplace vector list_offers(const offer_id_type lower_id, uint32_t limit) const; vector list_sell_offers(const offer_id_type lower_id, uint32_t limit) const; vector list_buy_offers(const offer_id_type lower_id, uint32_t limit) const; vector list_offer_history(const offer_history_id_type lower_id, uint32_t limit) const; vector get_offers_by_issuer(const offer_id_type lower_id, const account_id_type issuer_account_id, uint32_t limit) const; vector get_offers_by_item(const offer_id_type lower_id, const nft_id_type item, uint32_t limit) const; vector get_offer_history_by_issuer(const offer_history_id_type lower_id, const account_id_type issuer_account_id, uint32_t limit) const; vector get_offer_history_by_item(const offer_history_id_type lower_id, const nft_id_type item, uint32_t limit) const; vector get_offer_history_by_bidder(const offer_history_id_type lower_id, const account_id_type bidder_account_id, uint32_t limit) const; uint32_t api_limit_get_lower_bound_symbol = 100; uint32_t api_limit_get_limit_orders = 300; uint32_t api_limit_get_limit_orders_by_account = 101; uint32_t api_limit_get_order_book = 50; uint32_t api_limit_all_offers_count = 100; uint32_t api_limit_lookup_accounts = 1000; uint32_t api_limit_lookup_witness_accounts = 1000; uint32_t api_limit_lookup_committee_member_accounts = 1000; uint32_t api_limit_get_trade_history = 100; uint32_t api_limit_get_trade_history_by_sequence = 100; // Account Role vector get_account_roles_by_owner(account_id_type owner) const; //private: const account_object *get_account_from_string(const std::string &name_or_id, bool throw_if_not_found = true) const; const asset_object *get_asset_from_string(const std::string &symbol_or_id, bool throw_if_not_found = true) const; template void subscribe_to_item(const T &i) const { auto vec = fc::raw::pack(i); if (!_subscribe_callback) return; if (!is_subscribed_to_item(i)) { _subscribe_filter.insert(vec.data(), vec.size()); //(vecconst char*)&i, sizeof(i) ); } } template bool is_subscribed_to_item(const T &i) const { if (!_subscribe_callback) return false; return _subscribe_filter.contains(i); } bool is_impacted_account(const flat_set &accounts) { if (!_subscribed_accounts.size() || !accounts.size()) return false; return std::any_of(accounts.begin(), accounts.end(), [this](const account_id_type &account) { return _subscribed_accounts.find(account) != _subscribed_accounts.end(); }); } template void enqueue_if_subscribed_to_market(const object *obj, market_queue_type &queue, bool full_object = true) { const T *order = dynamic_cast(obj); FC_ASSERT(order != nullptr); auto market = order->get_market(); auto sub = _market_subscriptions.find(market); if (sub != _market_subscriptions.end()) { queue[market].emplace_back(full_object ? obj->to_variant() : fc::variant(obj->id, 1)); } } void broadcast_updates(const vector &updates); void broadcast_market_updates(const market_queue_type &queue); void handle_object_changed(bool force_notify, bool full_object, const vector &ids, const flat_set &impacted_accounts, std::function find_object); /** called every time a block is applied to report the objects that were changed */ void on_objects_new(const vector &ids, const flat_set &impacted_accounts); void on_objects_changed(const vector &ids, const flat_set &impacted_accounts); void on_objects_removed(const vector &ids, const vector &objs, const flat_set &impacted_accounts); void on_applied_block(); bool _notify_remove_create = false; mutable fc::bloom_filter _subscribe_filter; std::set _subscribed_accounts; std::function _subscribe_callback; std::function _pending_trx_callback; std::function _block_applied_callback; boost::signals2::scoped_connection _new_connection; boost::signals2::scoped_connection _change_connection; boost::signals2::scoped_connection _removed_connection; boost::signals2::scoped_connection _applied_block_connection; boost::signals2::scoped_connection _pending_trx_connection; map, std::function> _market_subscriptions; graphene::chain::database &_db; }; ////////////////////////////////////////////////////////////////////// // // // Constructors // // // ////////////////////////////////////////////////////////////////////// database_api::database_api(graphene::chain::database &db) : my(new database_api_impl(db)) { } database_api::~database_api() { } database_api_impl::database_api_impl(graphene::chain::database &db) : _db(db) { wlog("creating database api ${x}", ("x", int64_t(this))); _new_connection = _db.new_objects.connect([this](const vector &ids, const flat_set &impacted_accounts) { on_objects_new(ids, impacted_accounts); }); _change_connection = _db.changed_objects.connect([this](const vector &ids, const flat_set &impacted_accounts) { on_objects_changed(ids, impacted_accounts); }); _removed_connection = _db.removed_objects.connect([this](const vector &ids, const vector &objs, const flat_set &impacted_accounts) { on_objects_removed(ids, objs, impacted_accounts); }); _applied_block_connection = _db.applied_block.connect([this](const signed_block &) { on_applied_block(); }); _pending_trx_connection = _db.on_pending_transaction.connect([this](const signed_transaction &trx) { if (_pending_trx_callback) _pending_trx_callback(fc::variant(trx, GRAPHENE_MAX_NESTED_OBJECTS)); }); } database_api_impl::~database_api_impl() { elog("freeing database api ${x}", ("x", int64_t(this))); } ////////////////////////////////////////////////////////////////////// // // // Objects // // // ////////////////////////////////////////////////////////////////////// fc::variants database_api::get_objects(const vector &ids) const { return my->get_objects(ids); } fc::variants database_api_impl::get_objects(const vector &ids) const { if (_subscribe_callback) { for (auto id : ids) { if (id.type() == operation_history_object_type && id.space() == protocol_ids) continue; if (id.type() == impl_account_transaction_history_object_type && id.space() == implementation_ids) continue; this->subscribe_to_item(id); } } fc::variants result; result.reserve(ids.size()); std::transform(ids.begin(), ids.end(), std::back_inserter(result), [this](object_id_type id) -> fc::variant { if (auto obj = _db.find_object(id)) return obj->to_variant(); return {}; }); return result; } ////////////////////////////////////////////////////////////////////// // // // Subscriptions // // // ////////////////////////////////////////////////////////////////////// void database_api::set_subscribe_callback(std::function cb, bool notify_remove_create) { my->set_subscribe_callback(cb, notify_remove_create); } void database_api_impl::set_subscribe_callback(std::function cb, bool notify_remove_create) { //edump((clear_filter)); _subscribe_callback = cb; _notify_remove_create = notify_remove_create; _subscribed_accounts.clear(); static fc::bloom_parameters param; param.projected_element_count = 10000; param.false_positive_probability = 1.0 / 100; param.maximum_size = 1024 * 8 * 8 * 2; param.compute_optimal_parameters(); _subscribe_filter = fc::bloom_filter(param); } void database_api::set_pending_transaction_callback(std::function cb) { my->set_pending_transaction_callback(cb); } void database_api_impl::set_pending_transaction_callback(std::function cb) { _pending_trx_callback = cb; } void database_api::set_block_applied_callback(std::function cb) { my->set_block_applied_callback(cb); } void database_api_impl::set_block_applied_callback(std::function cb) { _block_applied_callback = cb; } void database_api::cancel_all_subscriptions() { my->cancel_all_subscriptions(); } void database_api_impl::cancel_all_subscriptions() { set_subscribe_callback(std::function(), true); _market_subscriptions.clear(); } ////////////////////////////////////////////////////////////////////// // // // Blocks and transactions // // // ////////////////////////////////////////////////////////////////////// optional database_api::get_block_header(uint32_t block_num) const { return my->get_block_header(block_num); } optional database_api_impl::get_block_header(uint32_t block_num) const { auto result = _db.fetch_block_by_number(block_num); if (result) return *result; return {}; } map> database_api::get_block_header_batch(const vector block_nums) const { return my->get_block_header_batch(block_nums); } map> database_api_impl::get_block_header_batch(const vector block_nums) const { map> results; for (const uint32_t block_num : block_nums) { results[block_num] = get_block_header(block_num); } return results; } optional database_api::get_block(uint32_t block_num) const { return my->get_block(block_num); } optional database_api_impl::get_block(uint32_t block_num) const { return _db.fetch_block_by_number(block_num); } vector> database_api::get_blocks(uint32_t block_num_from, uint32_t block_num_to) const { return my->get_blocks(block_num_from, block_num_to); } vector> database_api_impl::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> 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; } processed_transaction database_api::get_transaction(uint32_t block_num, uint32_t trx_in_block) const { return my->get_transaction(block_num, trx_in_block); } optional database_api::get_recent_transaction_by_id(const transaction_id_type &id) const { try { return my->_db.get_recent_transaction(id); } catch (...) { return optional(); } } processed_transaction database_api_impl::get_transaction(uint32_t block_num, uint32_t trx_num) const { auto opt_block = _db.fetch_block_by_number(block_num); FC_ASSERT(opt_block); FC_ASSERT(opt_block->transactions.size() > trx_num); return opt_block->transactions[trx_num]; } ////////////////////////////////////////////////////////////////////// // // // Globals // // // ////////////////////////////////////////////////////////////////////// chain_property_object database_api::get_chain_properties() const { return my->get_chain_properties(); } chain_property_object database_api_impl::get_chain_properties() const { return _db.get(chain_property_id_type()); } global_property_object database_api::get_global_properties() const { return my->get_global_properties(); } global_property_object database_api_impl::get_global_properties() const { return _db.get(global_property_id_type()); } fc::variant_object database_api::get_config() const { return my->get_config(); } fc::variant_object database_api_impl::get_config() const { return graphene::chain::get_config(); } chain_id_type database_api::get_chain_id() const { return my->get_chain_id(); } chain_id_type database_api_impl::get_chain_id() const { return _db.get_chain_id(); } dynamic_global_property_object database_api::get_dynamic_global_properties() const { return my->get_dynamic_global_properties(); } dynamic_global_property_object database_api_impl::get_dynamic_global_properties() const { return _db.get(dynamic_global_property_id_type()); } global_betting_statistics_object database_api::get_global_betting_statistics() const { return my->get_global_betting_statistics(); } global_betting_statistics_object database_api_impl::get_global_betting_statistics() const { return _db.get(global_betting_statistics_id_type()); } ////////////////////////////////////////////////////////////////////// // // // Keys // // // ////////////////////////////////////////////////////////////////////// vector> database_api::get_key_references(vector key) const { return my->get_key_references(key); } /** * @return all accounts that referr to the key or account id in their owner or active authorities. */ vector> database_api_impl::get_key_references(vector keys) const { wdump((keys)); const auto &idx = _db.get_index_type(); const auto &aidx = dynamic_cast(idx); const auto &refs = aidx.get_secondary_index(); vector> final_result; final_result.reserve(keys.size()); for (auto &key : keys) { address a1(pts_address(key, false, 56)); address a2(pts_address(key, true, 56)); address a3(pts_address(key, false, 0)); address a4(pts_address(key, true, 0)); address a5(key); subscribe_to_item(key); subscribe_to_item(a1); subscribe_to_item(a2); subscribe_to_item(a3); subscribe_to_item(a4); subscribe_to_item(a5); vector result; for (auto &a : {a1, a2, a3, a4, a5}) { auto itr = refs.account_to_address_memberships.find(a); if (itr != refs.account_to_address_memberships.end()) { result.reserve(result.size() + itr->second.size()); for (auto item : itr->second) { wdump((a)(item)(item(_db).name)); result.push_back(item); } } } auto itr = refs.account_to_key_memberships.find(key); if (itr != refs.account_to_key_memberships.end()) { result.reserve(result.size() + itr->second.size()); for (auto item : itr->second) result.push_back(item); } final_result.emplace_back(std::move(result)); } for (auto i : final_result) subscribe_to_item(i); return final_result; } bool database_api::is_public_key_registered(string public_key) const { return my->is_public_key_registered(public_key); } bool database_api_impl::is_public_key_registered(string public_key) const { // Short-circuit if (public_key.empty()) { return false; } // Search among all keys using an existing map of *current* account keys public_key_type key; try { key = public_key_type(public_key); } catch (...) { // An invalid public key was detected return false; } const auto &idx = _db.get_index_type(); const auto &aidx = dynamic_cast(idx); const auto &refs = aidx.get_secondary_index(); auto itr = refs.account_to_key_memberships.find(key); bool is_known = itr != refs.account_to_key_memberships.end(); return is_known; } ////////////////////////////////////////////////////////////////////// // // // Accounts // // // ////////////////////////////////////////////////////////////////////// account_id_type database_api::get_account_id_from_string(const std::string &name_or_id) const { return my->get_account_from_string(name_or_id)->id; } vector> database_api::get_accounts(const vector &account_names_or_ids) const { return my->get_accounts(account_names_or_ids); } vector> database_api_impl::get_accounts(const vector &account_names_or_ids) const { vector> result; result.reserve(account_names_or_ids.size()); std::transform(account_names_or_ids.begin(), account_names_or_ids.end(), std::back_inserter(result), [this](std::string id_or_name) -> optional { const account_object *account = get_account_from_string(id_or_name, false); if (account == nullptr) return {}; subscribe_to_item(account->id); return *account; }); return result; } std::map database_api::get_full_accounts(const vector &names_or_ids, bool subscribe) { return my->get_full_accounts(names_or_ids, subscribe); } std::map database_api_impl::get_full_accounts(const vector &names_or_ids, bool subscribe) { const auto &proposal_idx = _db.get_index_type(); const auto &pidx = dynamic_cast(proposal_idx); const auto &proposals_by_account = pidx.get_secondary_index(); std::map results; for (const std::string &account_name_or_id : names_or_ids) { const account_object *account = nullptr; if (std::isdigit(account_name_or_id[0])) account = _db.find(fc::variant(account_name_or_id, 1).as(1)); else { const auto &idx = _db.get_index_type().indices().get(); auto itr = idx.find(account_name_or_id); if (itr != idx.end()) account = &*itr; } if (account == nullptr) continue; if (subscribe) { FC_ASSERT(std::distance(_subscribed_accounts.begin(), _subscribed_accounts.end()) <= 100); _subscribed_accounts.insert(account->get_id()); subscribe_to_item(account->id); } full_account acnt; acnt.account = *account; acnt.statistics = account->statistics(_db); acnt.registrar_name = account->registrar(_db).name; acnt.referrer_name = account->referrer(_db).name; acnt.lifetime_referrer_name = account->lifetime_referrer(_db).name; acnt.votes = lookup_vote_ids(vector(account->options.votes.begin(), account->options.votes.end())); if (account->cashback_vb) { acnt.cashback_balance = account->cashback_balance(_db); } // Add the account's proposals auto required_approvals_itr = proposals_by_account._account_to_proposals.find(account->id); if (required_approvals_itr != proposals_by_account._account_to_proposals.end()) { acnt.proposals.reserve(required_approvals_itr->second.size()); for (auto proposal_id : required_approvals_itr->second) acnt.proposals.push_back(proposal_id(_db)); } // Add the account's balances const auto &balances = _db.get_index_type>().get_secondary_index().get_account_balances(account->id); for (const auto balance : balances) acnt.balances.emplace_back(*balance.second); // Add the account's vesting balances auto vesting_range = _db.get_index_type().indices().get().equal_range(account->id); std::for_each(vesting_range.first, vesting_range.second, [&acnt](const vesting_balance_object &balance) { acnt.vesting_balances.emplace_back(balance); }); // Add the account's orders auto order_range = _db.get_index_type().indices().get().equal_range(account->id); std::for_each(order_range.first, order_range.second, [&acnt](const limit_order_object &order) { acnt.limit_orders.emplace_back(order); }); auto call_range = _db.get_index_type().indices().get().equal_range(account->id); std::for_each(call_range.first, call_range.second, [&acnt](const call_order_object &call) { acnt.call_orders.emplace_back(call); }); auto settle_range = _db.get_index_type().indices().get().equal_range(account->id); std::for_each(settle_range.first, settle_range.second, [&acnt](const force_settlement_object &settle) { acnt.settle_orders.emplace_back(settle); }); // get assets issued by user auto asset_range = _db.get_index_type().indices().get().equal_range(account->id); std::for_each(asset_range.first, asset_range.second, [&acnt](const asset_object &asset) { acnt.assets.emplace_back(asset.id); }); // get withdraws permissions auto withdraw_range = _db.get_index_type().indices().get().equal_range(account->id); std::for_each(withdraw_range.first, withdraw_range.second, [&acnt](const withdraw_permission_object &withdraw) { acnt.withdraws.emplace_back(withdraw); }); auto pending_payouts_range = _db.get_index_type().indices().get().equal_range(boost::make_tuple(account->id)); std::copy(pending_payouts_range.first, pending_payouts_range.second, std::back_inserter(acnt.pending_dividend_payments)); results[account_name_or_id] = acnt; } return results; } optional database_api::get_account_by_name(string name) const { return my->get_account_by_name(name); } optional database_api_impl::get_account_by_name(string name) const { const auto &idx = _db.get_index_type().indices().get(); auto itr = idx.find(name); if (itr != idx.end()) return *itr; return optional(); } vector database_api::get_account_references(const std::string account_id_or_name) const { return my->get_account_references(account_id_or_name); } vector database_api_impl::get_account_references(const std::string account_id_or_name) const { const auto &idx = _db.get_index_type(); const auto &aidx = dynamic_cast(idx); const auto &refs = aidx.get_secondary_index(); const account_id_type account_id = get_account_from_string(account_id_or_name)->id; auto itr = refs.account_to_account_memberships.find(account_id); vector result; if (itr != refs.account_to_account_memberships.end()) { result.reserve(itr->second.size()); for (auto item : itr->second) result.push_back(item); } return result; } vector> database_api::lookup_account_names(const vector &account_names) const { return my->lookup_account_names(account_names); } vector> database_api_impl::lookup_account_names(const vector &account_names) const { const auto &accounts_by_name = _db.get_index_type().indices().get(); vector> result; result.reserve(account_names.size()); std::transform(account_names.begin(), account_names.end(), std::back_inserter(result), [&accounts_by_name](const string &name) -> optional { auto itr = accounts_by_name.find(name); return itr == accounts_by_name.end() ? optional() : *itr; }); return result; } map database_api::lookup_accounts(const string &lower_bound_name, uint32_t limit) const { return my->lookup_accounts(lower_bound_name, limit); } map database_api_impl::lookup_accounts(const string &lower_bound_name, uint32_t limit) const { FC_ASSERT(limit <= api_limit_lookup_accounts, "Number of querying accounts can not be greater than ${configured_limit}", ("configured_limit", api_limit_lookup_accounts)); const auto &accounts_by_name = _db.get_index_type().indices().get(); map result; for (auto itr = accounts_by_name.lower_bound(lower_bound_name); limit-- && itr != accounts_by_name.end(); ++itr) { result.insert(make_pair(itr->name, itr->get_id())); if (limit == 1) subscribe_to_item(itr->get_id()); } return result; } uint64_t database_api::get_account_count() const { return my->get_account_count(); } uint64_t database_api_impl::get_account_count() const { return _db.get_index_type().indices().size(); } ////////////////////////////////////////////////////////////////////// // // // Balances // // // ////////////////////////////////////////////////////////////////////// vector database_api::get_account_balances(const std::string &account_name_or_id, const flat_set &assets) const { return my->get_account_balances(account_name_or_id, assets); } vector database_api_impl::get_account_balances(const std::string &account_name_or_id, const flat_set &assets) const { const account_object *account = get_account_from_string(account_name_or_id); account_id_type acnt = account->id; vector result; if (assets.empty()) { // if the caller passes in an empty list of assets, return balances for all assets the account owns const auto &balance_index = _db.get_index_type>(); const auto &balances = balance_index.get_secondary_index().get_account_balances(acnt); for (const auto balance : balances) result.push_back(balance.second->get_balance()); } else { result.reserve(assets.size()); std::transform(assets.begin(), assets.end(), std::back_inserter(result), [this, acnt](asset_id_type id) { return _db.get_balance(acnt, id); }); } return result; } vector database_api::get_named_account_balances(const std::string &name, const flat_set &assets) const { return my->get_account_balances(name, assets); } vector database_api::get_balance_objects(const vector

&addrs) const { return my->get_balance_objects(addrs); } vector database_api_impl::get_balance_objects(const vector

&addrs) const { try { const auto &bal_idx = _db.get_index_type(); const auto &by_owner_idx = bal_idx.indices().get(); vector result; for (const auto &owner : addrs) { subscribe_to_item(owner); auto itr = by_owner_idx.lower_bound(boost::make_tuple(owner, asset_id_type(0))); while (itr != by_owner_idx.end() && itr->owner == owner) { result.push_back(*itr); ++itr; } } return result; } FC_CAPTURE_AND_RETHROW((addrs)) } vector database_api::get_vested_balances(const vector &objs) const { return my->get_vested_balances(objs); } vector database_api_impl::get_vested_balances(const vector &objs) const { try { vector result; result.reserve(objs.size()); auto now = _db.head_block_time(); for (auto obj : objs) result.push_back(obj(_db).available(now)); return result; } FC_CAPTURE_AND_RETHROW((objs)) } vector database_api::get_vesting_balances(const std::string account_id_or_name) const { return my->get_vesting_balances(account_id_or_name); } vector database_api_impl::get_vesting_balances(const std::string account_id_or_name) const { try { const account_id_type account_id = get_account_from_string(account_id_or_name)->id; vector result; auto vesting_range = _db.get_index_type().indices().get().equal_range(account_id); std::for_each(vesting_range.first, vesting_range.second, [&result](const vesting_balance_object &balance) { if (balance.balance.amount > 0) result.emplace_back(balance); }); return result; } FC_CAPTURE_AND_RETHROW((account_id_or_name)); } ////////////////////////////////////////////////////////////////////// // // // Assets // // // ////////////////////////////////////////////////////////////////////// asset_id_type database_api::get_asset_id_from_string(const std::string &symbol_or_id) const { return my->get_asset_from_string(symbol_or_id)->id; } const asset_object *database_api_impl::get_asset_from_string(const std::string &symbol_or_id, bool throw_if_not_found) const { // TODO cache the result to avoid repeatly fetching from db FC_ASSERT(symbol_or_id.size() > 0); const asset_object *asset = nullptr; if (std::isdigit(symbol_or_id[0])) asset = _db.find(fc::variant(symbol_or_id, 1).as(1)); else { const auto &idx = _db.get_index_type().indices().get(); auto itr = idx.find(symbol_or_id); if (itr != idx.end()) asset = &*itr; } if (throw_if_not_found) FC_ASSERT(asset, "no such asset"); return asset; } vector> database_api::get_assets(const vector &asset_symbols_or_ids) const { return my->get_assets(asset_symbols_or_ids); } vector> database_api_impl::get_assets(const vector &asset_symbols_or_ids) const { vector> result; result.reserve(asset_symbols_or_ids.size()); std::transform(asset_symbols_or_ids.begin(), asset_symbols_or_ids.end(), std::back_inserter(result), [this](std::string id_or_name) -> optional { const asset_object *asset_obj = get_asset_from_string(id_or_name, false); if (asset_obj == nullptr) return {}; subscribe_to_item(asset_obj->id); return asset_object(*asset_obj); }); return result; } vector> database_api_impl::get_assets(const vector &asset_ids) const { vector> result; result.reserve(asset_ids.size()); std::transform(asset_ids.begin(), asset_ids.end(), std::back_inserter(result), [this](asset_id_type id) -> optional { if (auto o = _db.find(id)) { subscribe_to_item(id); return *o; } return {}; }); return result; } vector database_api::list_assets(const string &lower_bound_symbol, uint32_t limit) const { return my->list_assets(lower_bound_symbol, limit); } vector database_api_impl::list_assets(const string &lower_bound_symbol, uint32_t limit) const { FC_ASSERT(limit <= api_limit_get_lower_bound_symbol, "Number of querying accounts can not be greater than ${configured_limit}", ("configured_limit", api_limit_get_lower_bound_symbol)); const auto &assets_by_symbol = _db.get_index_type().indices().get(); vector result; result.reserve(limit); auto itr = assets_by_symbol.lower_bound(lower_bound_symbol); if (lower_bound_symbol == "") itr = assets_by_symbol.begin(); while (limit-- && itr != assets_by_symbol.end()) result.emplace_back(*itr++); return result; } vector> database_api::lookup_asset_symbols(const vector &symbols_or_ids) const { return my->lookup_asset_symbols(symbols_or_ids); } vector> database_api_impl::lookup_asset_symbols(const vector &symbols_or_ids) const { const auto &assets_by_symbol = _db.get_index_type().indices().get(); vector> result; result.reserve(symbols_or_ids.size()); std::transform(symbols_or_ids.begin(), symbols_or_ids.end(), std::back_inserter(result), [this, &assets_by_symbol](const string &symbol_or_id) -> optional { if (!symbol_or_id.empty() && std::isdigit(symbol_or_id[0])) { auto ptr = _db.find(variant(symbol_or_id, 1).as(1)); return ptr == nullptr ? optional() : *ptr; } auto itr = assets_by_symbol.find(symbol_or_id); return itr == assets_by_symbol.end() ? optional() : *itr; }); return result; } uint64_t database_api::get_asset_count() const { return my->get_asset_count(); } uint64_t database_api_impl::get_asset_count() const { return _db.get_index_type().indices().size(); } //////////////////// // Lottery Assets // //////////////////// vector database_api::get_lotteries(asset_id_type stop, unsigned limit, asset_id_type start) const { return my->get_lotteries(stop, limit, start); } vector database_api_impl::get_lotteries(asset_id_type stop, unsigned limit, asset_id_type start) const { vector result; if (limit > 100) limit = 100; const auto &assets = _db.get_index_type().indices().get(); const auto range = assets.equal_range(boost::make_tuple(true)); for (const auto &a : boost::make_iterator_range(range.first, range.second)) { if (start == asset_id_type() || (a.get_id().instance.value <= start.instance.value)) result.push_back(a); if (a.get_id().instance.value < stop.instance.value || result.size() >= limit) break; } return result; } vector database_api::get_account_lotteries(account_id_type issuer, asset_id_type stop, unsigned limit, asset_id_type start) const { return my->get_account_lotteries(issuer, stop, limit, start); } vector database_api_impl::get_account_lotteries(account_id_type issuer, asset_id_type stop, unsigned limit, asset_id_type start) const { vector result; if (limit > 100) limit = 100; const auto &assets = _db.get_index_type().indices().get(); const auto range = assets.equal_range(boost::make_tuple(true, issuer.instance.value)); for (const auto &a : boost::make_iterator_range(range.first, range.second)) { if (start == asset_id_type() || (a.get_id().instance.value <= start.instance.value)) result.push_back(a); if (a.get_id().instance.value < stop.instance.value || result.size() >= limit) break; } return result; } asset database_api::get_lottery_balance(asset_id_type lottery_id) const { return my->get_lottery_balance(lottery_id); } asset database_api_impl::get_lottery_balance(asset_id_type lottery_id) const { auto lottery_asset = lottery_id(_db); FC_ASSERT(lottery_asset.is_lottery()); return _db.get_balance(lottery_id); } sweeps_vesting_balance_object database_api::get_sweeps_vesting_balance_object(account_id_type account) const { return my->get_sweeps_vesting_balance_object(account); } sweeps_vesting_balance_object database_api_impl::get_sweeps_vesting_balance_object(account_id_type account) const { const auto &vesting_idx = _db.get_index_type().indices().get(); auto account_balance = vesting_idx.find(account); FC_ASSERT(account_balance != vesting_idx.end(), "NO SWEEPS VESTING BALANCE"); return *account_balance; } asset database_api::get_sweeps_vesting_balance_available_for_claim(account_id_type account) const { return my->get_sweeps_vesting_balance_available_for_claim(account); } asset database_api_impl::get_sweeps_vesting_balance_available_for_claim(account_id_type account) const { const auto &vesting_idx = _db.get_index_type().indices().get(); auto account_balance = vesting_idx.find(account); FC_ASSERT(account_balance != vesting_idx.end(), "NO SWEEPS VESTING BALANCE"); return account_balance->available_for_claim(); } ////////////////////////////////////////////////////////////////////// // Peerplays // ////////////////////////////////////////////////////////////////////// vector database_api::list_sports() const { return my->list_sports(); } vector database_api_impl::list_sports() const { const auto &sport_object_idx = _db.get_index_type().indices().get(); return boost::copy_range>(sport_object_idx); } vector database_api::list_event_groups(sport_id_type sport_id) const { return my->list_event_groups(sport_id); } vector database_api_impl::list_event_groups(sport_id_type sport_id) const { const auto &event_group_idx = _db.get_index_type().indices().get(); return boost::copy_range>(event_group_idx.equal_range(sport_id)); } vector database_api::list_events_in_group(event_group_id_type event_group_id) const { return my->list_events_in_group(event_group_id); } vector database_api_impl::list_events_in_group(event_group_id_type event_group_id) const { const auto &event_idx = _db.get_index_type().indices().get(); return boost::copy_range>(event_idx.equal_range(event_group_id)); } vector database_api::list_betting_market_groups(event_id_type event_id) const { return my->list_betting_market_groups(event_id); } vector database_api_impl::list_betting_market_groups(event_id_type event_id) const { const auto &betting_market_group_idx = _db.get_index_type().indices().get(); return boost::copy_range>(betting_market_group_idx.equal_range(event_id)); } vector database_api::list_betting_markets(betting_market_group_id_type betting_market_group_id) const { return my->list_betting_markets(betting_market_group_id); } vector database_api_impl::list_betting_markets(betting_market_group_id_type betting_market_group_id) const { const auto &betting_market_idx = _db.get_index_type().indices().get(); return boost::copy_range>(betting_market_idx.equal_range(betting_market_group_id)); } vector database_api::get_unmatched_bets_for_bettor(betting_market_id_type betting_market_id, account_id_type bettor_id) const { return my->get_unmatched_bets_for_bettor(betting_market_id, bettor_id); } vector database_api_impl::get_unmatched_bets_for_bettor(betting_market_id_type betting_market_id, account_id_type bettor_id) const { const auto &bet_idx = _db.get_index_type().indices().get(); return boost::copy_range>(bet_idx.equal_range(std::make_tuple(bettor_id, betting_market_id))); } vector database_api::get_all_unmatched_bets_for_bettor(account_id_type bettor_id) const { return my->get_all_unmatched_bets_for_bettor(bettor_id); } vector database_api_impl::get_all_unmatched_bets_for_bettor(account_id_type bettor_id) const { const auto &bet_idx = _db.get_index_type().indices().get(); return boost::copy_range>(bet_idx.equal_range(std::make_tuple(bettor_id))); } ////////////////////////////////////////////////////////////////////// // // // Markets / feeds // // // ////////////////////////////////////////////////////////////////////// vector database_api::get_limit_orders(const std::string &a, const std::string &b, const uint32_t limit) const { return my->get_limit_orders(a, b, limit); } /** * @return the limit orders for both sides of the book for the two assets specified up to limit number on each side. */ vector database_api_impl::get_limit_orders(const std::string &a, const std::string &b, const uint32_t limit) const { const asset_id_type asset_a_id = get_asset_from_string(a)->id; const asset_id_type asset_b_id = get_asset_from_string(b)->id; return get_limit_orders(asset_a_id, asset_b_id, limit); } vector database_api_impl::get_limit_orders(const asset_id_type a, const asset_id_type b, const uint32_t limit) const { const auto &limit_order_idx = _db.get_index_type(); const auto &limit_price_idx = limit_order_idx.indices().get(); vector result; result.reserve(limit * 2); uint32_t count = 0; auto limit_itr = limit_price_idx.lower_bound(price::max(a, b)); auto limit_end = limit_price_idx.upper_bound(price::min(a, b)); while (limit_itr != limit_end && count < limit) { result.push_back(*limit_itr); ++limit_itr; ++count; } count = 0; limit_itr = limit_price_idx.lower_bound(price::max(b, a)); limit_end = limit_price_idx.upper_bound(price::min(b, a)); while (limit_itr != limit_end && count < limit) { result.push_back(*limit_itr); ++limit_itr; ++count; } return result; } vector database_api::get_call_orders(const std::string &a, uint32_t limit) const { return my->get_call_orders(a, limit); } vector database_api_impl::get_call_orders(const std::string &a, uint32_t limit) const { const auto &call_index = _db.get_index_type().indices().get(); const asset_object *mia = get_asset_from_string(a); price index_price = price::min(mia->bitasset_data(_db).options.short_backing_asset, mia->get_id()); return vector(call_index.lower_bound(index_price.min()), call_index.lower_bound(index_price.max())); } vector database_api::get_settle_orders(const std::string &a, uint32_t limit) const { return my->get_settle_orders(a, limit); } vector database_api_impl::get_settle_orders(const std::string &a, uint32_t limit) const { const auto &settle_index = _db.get_index_type().indices().get(); const asset_object *mia = get_asset_from_string(a); return vector(settle_index.lower_bound(mia->get_id()), settle_index.upper_bound(mia->get_id())); } vector database_api::get_margin_positions(const std::string account_id_or_name) const { return my->get_margin_positions(account_id_or_name); } vector database_api_impl::get_margin_positions(const std::string account_id_or_name) const { try { const auto &idx = _db.get_index_type(); const auto &aidx = idx.indices().get(); const account_id_type id = get_account_from_string(account_id_or_name)->id; auto start = aidx.lower_bound(boost::make_tuple(id, asset_id_type(0))); auto end = aidx.lower_bound(boost::make_tuple(id + 1, asset_id_type(0))); vector result; while (start != end) { result.push_back(*start); ++start; } return result; } FC_CAPTURE_AND_RETHROW((account_id_or_name)) } void database_api::subscribe_to_market(std::function callback, const std::string &a, const std::string &b) { my->subscribe_to_market(callback, a, b); } void database_api_impl::subscribe_to_market(std::function callback, const std::string &a, const std::string &b) { auto asset_a_id = get_asset_from_string(a)->id; auto asset_b_id = get_asset_from_string(b)->id; if (asset_a_id > asset_b_id) std::swap(asset_a_id, asset_b_id); FC_ASSERT(asset_a_id != asset_b_id); _market_subscriptions[std::make_pair(asset_a_id, asset_b_id)] = callback; } void database_api::unsubscribe_from_market(const std::string &a, const std::string &b) { my->unsubscribe_from_market(a, b); } void database_api_impl::unsubscribe_from_market(const std::string &a, const std::string &b) { auto asset_a_id = get_asset_from_string(a)->id; auto asset_b_id = get_asset_from_string(b)->id; if (asset_a_id > asset_b_id) std::swap(asset_a_id, asset_b_id); FC_ASSERT(asset_a_id != asset_b_id); _market_subscriptions.erase(std::make_pair(asset_a_id, asset_b_id)); } market_ticker database_api::get_ticker(const string &base, const string "e) const { return my->get_ticker(base, quote); } market_ticker database_api_impl::get_ticker(const string &base, const string "e) const { const auto assets = lookup_asset_symbols({base, quote}); FC_ASSERT(assets[0], "Invalid base asset symbol: ${s}", ("s", base)); FC_ASSERT(assets[1], "Invalid quote asset symbol: ${s}", ("s", quote)); market_ticker result; result.base = base; result.quote = quote; result.latest = 0; result.lowest_ask = 0; result.highest_bid = 0; result.percent_change = 0; result.base_volume = 0; result.quote_volume = 0; try { const fc::time_point_sec now = fc::time_point::now(); const fc::time_point_sec yesterday = fc::time_point_sec(now.sec_since_epoch() - 86400); const auto batch_size = 100; vector trades = get_trade_history(base, quote, now, yesterday, batch_size); if (!trades.empty()) { result.latest = trades[0].price; while (!trades.empty()) { for (const market_trade &t : trades) { result.base_volume += t.value; result.quote_volume += t.amount; } trades = get_trade_history(base, quote, trades.back().date, yesterday, batch_size); } const auto last_trade_yesterday = get_trade_history(base, quote, yesterday, fc::time_point_sec(), 1); if (!last_trade_yesterday.empty()) { const auto price_yesterday = last_trade_yesterday[0].price; result.percent_change = ((result.latest / price_yesterday) - 1) * 100; } } else { const auto last_trade = get_trade_history(base, quote, now, fc::time_point_sec(), 1); if (!last_trade.empty()) result.latest = last_trade[0].price; } const auto orders = get_order_book(base, quote, 1); if (!orders.asks.empty()) result.lowest_ask = orders.asks[0].price; if (!orders.bids.empty()) result.highest_bid = orders.bids[0].price; } FC_CAPTURE_AND_RETHROW((base)(quote)) return result; } market_volume database_api::get_24_volume(const string &base, const string "e) const { return my->get_24_volume(base, quote); } market_volume database_api_impl::get_24_volume(const string &base, const string "e) const { const auto ticker = get_ticker(base, quote); market_volume result; result.base = ticker.base; result.quote = ticker.quote; result.base_volume = ticker.base_volume; result.quote_volume = ticker.quote_volume; return result; } order_book database_api::get_order_book(const string &base, const string "e, unsigned limit) const { return my->get_order_book(base, quote, limit); } order_book database_api_impl::get_order_book(const string &base, const string "e, unsigned limit) const { using boost::multiprecision::uint128_t; FC_ASSERT(limit <= api_limit_get_order_book, "Number of querying accounts can not be greater than ${configured_limit}", ("configured_limit", api_limit_get_order_book)); order_book result; result.base = base; result.quote = quote; auto assets = lookup_asset_symbols({base, quote}); FC_ASSERT(assets[0], "Invalid base asset symbol: ${s}", ("s", base)); FC_ASSERT(assets[1], "Invalid quote asset symbol: ${s}", ("s", quote)); auto base_id = assets[0]->id; auto quote_id = assets[1]->id; auto orders = get_limit_orders(base_id, quote_id, limit); auto asset_to_real = [&](const asset &a, int p) { return double(a.amount.value) / pow(10, p); }; auto price_to_real = [&](const price &p) { if (p.base.asset_id == base_id) return asset_to_real(p.base, assets[0]->precision) / asset_to_real(p.quote, assets[1]->precision); else return asset_to_real(p.quote, assets[0]->precision) / asset_to_real(p.base, assets[1]->precision); }; for (const auto &o : orders) { if (o.sell_price.base.asset_id == base_id) { order ord; ord.price = price_to_real(o.sell_price); ord.quote = asset_to_real(share_type((uint128_t(o.for_sale.value) * o.sell_price.quote.amount.value) / o.sell_price.base.amount.value), assets[1]->precision); ord.base = asset_to_real(o.for_sale, assets[0]->precision); result.bids.push_back(ord); } else { order ord; ord.price = price_to_real(o.sell_price); ord.quote = asset_to_real(o.for_sale, assets[1]->precision); ord.base = asset_to_real(share_type((uint128_t(o.for_sale.value) * o.sell_price.quote.amount.value) / o.sell_price.base.amount.value), assets[0]->precision); result.asks.push_back(ord); } } return result; } vector database_api::get_trade_history(const string &base, const string "e, fc::time_point_sec start, fc::time_point_sec stop, unsigned limit) const { return my->get_trade_history(base, quote, start, stop, limit); } vector database_api_impl::get_trade_history(const string &base, const string "e, fc::time_point_sec start, fc::time_point_sec stop, unsigned limit) const { FC_ASSERT(limit <= api_limit_get_trade_history, "Number of querying accounts can not be greater than ${configured_limit}", ("configured_limit", api_limit_get_trade_history)); auto assets = lookup_asset_symbols({base, quote}); FC_ASSERT(assets[0], "Invalid base asset symbol: ${s}", ("s", base)); FC_ASSERT(assets[1], "Invalid quote asset symbol: ${s}", ("s", quote)); auto base_id = assets[0]->id; auto quote_id = assets[1]->id; if (base_id > quote_id) std::swap(base_id, quote_id); const auto &history_idx = _db.get_index_type().indices().get(); history_key hkey; hkey.base = base_id; hkey.quote = quote_id; hkey.sequence = std::numeric_limits::min(); auto price_to_real = [&](const share_type a, int p) { return double(a.value) / pow(10, p); }; if (start.sec_since_epoch() == 0) start = fc::time_point_sec(fc::time_point::now()); uint32_t count = 0; auto itr = history_idx.lower_bound(hkey); vector result; while (itr != history_idx.end() && count < limit && !(itr->key.base != base_id || itr->key.quote != quote_id || itr->time < stop)) { if (itr->time < start) { market_trade trade; if (assets[0]->id == itr->op.receives.asset_id) { trade.amount = price_to_real(itr->op.pays.amount, assets[1]->precision); trade.value = price_to_real(itr->op.receives.amount, assets[0]->precision); } else { trade.amount = price_to_real(itr->op.receives.amount, assets[1]->precision); trade.value = price_to_real(itr->op.pays.amount, assets[0]->precision); } trade.date = itr->time; trade.price = trade.value / trade.amount; result.push_back(trade); ++count; } // Trades are tracked in each direction. ++itr; ++itr; } return result; } ////////////////////////////////////////////////////////////////////// // // // Witnesses // // // ////////////////////////////////////////////////////////////////////// vector> database_api::get_witnesses(const vector &witness_ids) const { return my->get_witnesses(witness_ids); } vector database_api::get_workers_by_account(const std::string account_id_or_name) const { const auto &idx = my->_db.get_index_type().indices().get(); const account_id_type account = my->get_account_from_string(account_id_or_name)->id; auto itr = idx.find(account); vector result; if (itr != idx.end() && itr->worker_account == account) { result.emplace_back(*itr); ++itr; } return result; } vector> database_api_impl::get_witnesses(const vector &witness_ids) const { vector> result; result.reserve(witness_ids.size()); std::transform(witness_ids.begin(), witness_ids.end(), std::back_inserter(result), [this](witness_id_type id) -> optional { if (auto o = _db.find(id)) return *o; return {}; }); return result; } fc::optional database_api::get_witness_by_account(const std::string account_id_or_name) const { return my->get_witness_by_account(account_id_or_name); } fc::optional database_api_impl::get_witness_by_account(const std::string account_id_or_name) const { const auto &idx = _db.get_index_type().indices().get(); const account_id_type account = get_account_from_string(account_id_or_name)->id; auto itr = idx.find(account); if (itr != idx.end()) return *itr; return {}; } map database_api::lookup_witness_accounts(const string &lower_bound_name, uint32_t limit) const { return my->lookup_witness_accounts(lower_bound_name, limit); } map