database_api.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2017 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.
 */
#pragma once
 
#include <graphene/app/api_objects.hpp>
 
#include <graphene/protocol/types.hpp>
 
#include <graphene/chain/database.hpp>
 
#include <graphene/chain/balance_object.hpp>
#include <graphene/chain/chain_property_object.hpp>
#include <graphene/chain/committee_member_object.hpp>
#include <graphene/chain/confidential_object.hpp>
#include <graphene/chain/credit_offer_object.hpp>
#include <graphene/chain/operation_history_object.hpp>
#include <graphene/chain/samet_fund_object.hpp>
#include <graphene/chain/ticket_object.hpp>
#include <graphene/chain/worker_object.hpp>
#include <graphene/chain/witness_object.hpp>
 
#include <fc/api.hpp>
#include <fc/variant_object.hpp>
 
#include <boost/container/flat_set.hpp>
 
#include <functional>
#include <map>
#include <memory>
#include <vector>
 
namespace graphene { namespace app {
 
using namespace graphene::chain;
using namespace graphene::market_history;
using std::string;
using std::vector;
using std::map;
 
class database_api_impl;
 
class database_api
{
   public:
      database_api(graphene::chain::database& db, const application_options* app_options = nullptr );
      ~database_api();
 
      // Objects //
 
      fc::variants get_objects( const vector<object_id_type>& ids,
                                optional<bool> subscribe = optional<bool>() )const;
 
      // Subscriptions //
 
      void set_subscribe_callback( std::function<void(const variant&)> cb, bool notify_remove_create );
      void set_auto_subscription( bool enable );
      void set_pending_transaction_callback( std::function<void(const variant& signed_transaction_object)> cb );
      void set_block_applied_callback( std::function<void(const variant& block_id)> cb );
      void cancel_all_subscriptions();
 
      // Blocks and transactions //
 
      optional<maybe_signed_block_header> get_block_header(
            uint32_t block_num,
            const optional<bool>& with_witness_signature = optional<bool>() )const;
 
      map<uint32_t, optional<maybe_signed_block_header>> get_block_header_batch(
            const vector<uint32_t>& block_nums,
            const optional<bool>& with_witness_signatures = optional<bool>() )const;
 
      optional<signed_block> get_block(uint32_t block_num)const;
 
      processed_transaction get_transaction( uint32_t block_num, uint32_t trx_in_block )const;
 
      optional<signed_transaction> get_recent_transaction_by_id( const transaction_id_type& txid )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;
 
      object_id_type get_next_object_id( uint8_t space_id, uint8_t type_id, bool with_pending_transactions )const;
 
      // Keys //
 
      vector<flat_set<account_id_type>> get_key_references( vector<public_key_type> keys )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<optional<account_object>> get_accounts( const vector<std::string>& account_names_or_ids,
                                                     optional<bool> subscribe = optional<bool>() )const;
 
      map<string, full_account, std::less<>> get_full_accounts(
            const vector<string>& names_or_ids,
            const optional<bool>& subscribe = optional<bool>() )const;
 
      vector<account_statistics_object> get_top_voters(uint32_t limit)const;
 
      optional<account_object> get_account_by_name( string name )const;
 
      vector<account_id_type> get_account_references( const std::string account_name_or_id )const;
 
      vector<optional<account_object>> lookup_account_names(const vector<string>& account_names)const;
 
      map<string, account_id_type, std::less<>> lookup_accounts( const string& lower_bound_name,
                                                   uint32_t limit,
                                                   const optional<bool>& subscribe = optional<bool>() )const;
 
      // Balances //
 
      vector<asset> get_account_balances( const std::string& account_name_or_id,
                                          const flat_set<asset_id_type>& assets )const;
 
      vector<asset> get_named_account_balances(const std::string& name, const flat_set<asset_id_type>& assets)const;
 
      vector<balance_object> get_balance_objects( const vector<address>& addrs )const;
 
      vector<asset> get_vested_balances( const vector<balance_id_type>& objs )const;
 
      vector<vesting_balance_object> get_vesting_balances( const std::string account_name_or_id )const;
 
      uint64_t get_account_count()const;
 
      // Assets //
 
      asset_id_type get_asset_id_from_string(const std::string& symbol_or_id) const;
 
      vector<optional<extended_asset_object>> get_assets( const vector<std::string>& asset_symbols_or_ids,
                                                          optional<bool> subscribe = optional<bool>() )const;
 
      vector<extended_asset_object> list_assets(const string& lower_bound_symbol, uint32_t limit)const;
 
      vector<optional<extended_asset_object>> lookup_asset_symbols(const vector<string>& symbols_or_ids)const;
 
      uint64_t get_asset_count()const;
 
      vector<extended_asset_object> get_assets_by_issuer(const std::string& issuer_name_or_id,
                                                         asset_id_type start, uint32_t limit)const;
 
      // Markets / feeds //
 
      vector<limit_order_object> get_limit_orders(std::string a, std::string b, uint32_t limit)const;
 
      vector<limit_order_object> get_limit_orders_by_account(
            const string& account_name_or_id,
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<limit_order_id_type>& start_id = optional<limit_order_id_type>() );
 
      vector<limit_order_object> get_account_limit_orders( const string& account_name_or_id,
            const string &base,
            const string &quote,
            uint32_t limit = application_options::get_default().api_limit_get_account_limit_orders,
            optional<limit_order_id_type> ostart_id = optional<limit_order_id_type>(),
            optional<price> ostart_price = optional<price>());
 
      vector<call_order_object> get_call_orders(const std::string& a, uint32_t limit)const;
 
      vector<call_order_object> get_call_orders_by_account(const std::string& account_name_or_id,
                                                           asset_id_type start, uint32_t limit)const;
 
      vector<force_settlement_object> get_settle_orders(const std::string& a, uint32_t limit)const;
 
      vector<force_settlement_object> get_settle_orders_by_account( const std::string& account_name_or_id,
                                                                    force_settlement_id_type start,
                                                                    uint32_t limit )const;
 
      vector<collateral_bid_object> get_collateral_bids(const std::string& a, uint32_t limit, uint32_t start)const;
 
      vector<call_order_object> get_margin_positions( const std::string& account_name_or_id )const;
 
      void subscribe_to_market(std::function<void(const variant&)> 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& quote )const;
 
      market_volume get_24_volume( const string& base, const string& quote )const;
 
      order_book get_order_book( const string& base, const string& quote,
            uint32_t limit = application_options::get_default().api_limit_get_order_book )const;
 
      vector<market_ticker> get_top_markets(uint32_t limit)const;
 
      vector<market_trade> get_trade_history( const string& base, const string& quote,
            fc::time_point_sec start, fc::time_point_sec stop,
            uint32_t limit = application_options::get_default().api_limit_get_trade_history )const;
 
      vector<market_trade> get_trade_history_by_sequence( const string& base, const string& quote,
            int64_t start, fc::time_point_sec stop,
            uint32_t limit = application_options::get_default().api_limit_get_trade_history_by_sequence )const;
 
 
      // Liquidity pools //
 
      vector<extended_liquidity_pool_object> list_liquidity_pools(
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<liquidity_pool_id_type>& start_id = optional<liquidity_pool_id_type>(),
            const optional<bool>& with_statistics = false )const;
 
      vector<extended_liquidity_pool_object> get_liquidity_pools_by_asset_a(
            const std::string& asset_symbol_or_id,
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<liquidity_pool_id_type>& start_id = optional<liquidity_pool_id_type>(),
            const optional<bool>& with_statistics = false )const;
 
      vector<extended_liquidity_pool_object> get_liquidity_pools_by_asset_b(
            const std::string& asset_symbol_or_id,
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<liquidity_pool_id_type>& start_id = optional<liquidity_pool_id_type>(),
            const optional<bool>& with_statistics = false )const;
 
      vector<extended_liquidity_pool_object> get_liquidity_pools_by_one_asset(
            const std::string& asset_symbol_or_id,
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<liquidity_pool_id_type>& start_id = optional<liquidity_pool_id_type>(),
            const optional<bool>& with_statistics = false )const;
 
      vector<extended_liquidity_pool_object> get_liquidity_pools_by_both_assets(
            const std::string& asset_symbol_or_id_a,
            const std::string& asset_symbol_or_id_b,
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<liquidity_pool_id_type>& start_id = optional<liquidity_pool_id_type>(),
            const optional<bool>& with_statistics = false )const;
 
      vector<optional<extended_liquidity_pool_object>> get_liquidity_pools(
            const vector<liquidity_pool_id_type>& ids,
            const optional<bool>& subscribe = optional<bool>(),
            const optional<bool>& with_statistics = false )const;
 
      vector<optional<extended_liquidity_pool_object>> get_liquidity_pools_by_share_asset(
            const vector<std::string>& asset_symbols_or_ids,
            const optional<bool>& subscribe = optional<bool>(),
            const optional<bool>& with_statistics = false )const;
 
      vector<extended_liquidity_pool_object> get_liquidity_pools_by_owner(
            const std::string& account_name_or_id,
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<asset_id_type>& start_id = optional<asset_id_type>(),
            const optional<bool>& with_statistics = false )const;
 
 
 
      vector<samet_fund_object> list_samet_funds(
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<samet_fund_id_type>& start_id = optional<samet_fund_id_type>() )const;
 
      vector<samet_fund_object> get_samet_funds_by_owner(
            const std::string& account_name_or_id,
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<samet_fund_id_type>& start_id = optional<samet_fund_id_type>() )const;
 
      vector<samet_fund_object> get_samet_funds_by_asset(
            const std::string& asset_symbol_or_id,
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<samet_fund_id_type>& start_id = optional<samet_fund_id_type>() )const;
 
 
 
      vector<credit_offer_object> list_credit_offers(
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<credit_offer_id_type>& start_id = optional<credit_offer_id_type>() )const;
 
      vector<credit_offer_object> get_credit_offers_by_owner(
            const std::string& account_name_or_id,
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<credit_offer_id_type>& start_id = optional<credit_offer_id_type>() )const;
 
      vector<credit_offer_object> get_credit_offers_by_asset(
            const std::string& asset_symbol_or_id,
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<credit_offer_id_type>& start_id = optional<credit_offer_id_type>() )const;
 
      vector<credit_deal_object> list_credit_deals(
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<credit_deal_id_type>& start_id = optional<credit_deal_id_type>() )const;
 
      vector<credit_deal_object> get_credit_deals_by_offer_id(
            const credit_offer_id_type& offer_id,
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<credit_deal_id_type>& start_id = optional<credit_deal_id_type>() )const;
 
      vector<credit_deal_object> get_credit_deals_by_offer_owner(
            const std::string& account_name_or_id,
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<credit_deal_id_type>& start_id = optional<credit_deal_id_type>() )const;
 
      vector<credit_deal_object> get_credit_deals_by_borrower(
            const std::string& account_name_or_id,
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<credit_deal_id_type>& start_id = optional<credit_deal_id_type>() )const;
 
      vector<credit_deal_object> get_credit_deals_by_debt_asset(
            const std::string& asset_symbol_or_id,
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<credit_deal_id_type>& start_id = optional<credit_deal_id_type>() )const;
 
      vector<credit_deal_object> get_credit_deals_by_collateral_asset(
            const std::string& asset_symbol_or_id,
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<credit_deal_id_type>& start_id = optional<credit_deal_id_type>() )const;
 
 
      // Witnesses //
 
      vector<optional<witness_object>> get_witnesses(const vector<witness_id_type>& witness_ids)const;
 
      fc::optional<witness_object> get_witness_by_account(const std::string& account_name_or_id)const;
 
      map<string, witness_id_type, std::less<>> lookup_witness_accounts( const string& lower_bound_name,
                                                                         uint32_t limit )const;
 
      uint64_t get_witness_count()const;
 
      // Committee members //
 
      vector<optional<committee_member_object>> get_committee_members(
            const vector<committee_member_id_type>& committee_member_ids)const;
 
      fc::optional<committee_member_object> get_committee_member_by_account( const string& account_name_or_id )const;
 
      map<string, committee_member_id_type, std::less<>> lookup_committee_member_accounts(
            const string& lower_bound_name,
            uint32_t limit )const;
 
      uint64_t get_committee_count()const;
 
 
      // Worker proposals  //
 
      vector<worker_object> get_all_workers( const optional<bool>& is_expired = optional<bool>() )const;
 
      vector<worker_object> get_workers_by_account(const std::string& account_name_or_id)const;
 
      uint64_t get_worker_count()const;
 
 
 
      // Votes //
 
      vector<variant> lookup_vote_ids( const vector<vote_id_type>& votes )const;
 
      // Authority / validation //
 
      std::string get_transaction_hex(const signed_transaction& trx)const;
 
      std::string get_transaction_hex_without_sig( const transaction &trx ) const;
 
      set<public_key_type> get_required_signatures( const signed_transaction& trx,
                                                    const flat_set<public_key_type>& available_keys )const;
 
      set<public_key_type> get_potential_signatures( const signed_transaction& trx )const;
 
      set<address> get_potential_address_signatures( const signed_transaction& trx )const;
 
      bool           verify_authority( const signed_transaction& trx )const;
 
      bool verify_account_authority( const string& account_name_or_id,
                                     const flat_set<public_key_type>& signers )const;
 
      processed_transaction validate_transaction( const signed_transaction& trx )const;
 
      vector< fc::variant > get_required_fees( const vector<operation>& ops,
                                               const std::string& asset_symbol_or_id )const;
 
      // Proposed transactions //
 
      vector<proposal_object> get_proposed_transactions( const std::string account_name_or_id )const;
 
      // Blinded balances //
 
      vector<blinded_balance_object> get_blinded_balances( const flat_set<commitment_type>& commitments )const;
 
      // Withdrawals //
 
      vector<withdraw_permission_object> get_withdraw_permissions_by_giver( const std::string account_name_or_id,
                                                                            withdraw_permission_id_type start,
                                                                            uint32_t limit )const;
 
      vector<withdraw_permission_object> get_withdraw_permissions_by_recipient( const std::string account_name_or_id,
                                                                                withdraw_permission_id_type start,
                                                                                uint32_t limit )const;
 
      // HTLC //
 
      optional<htlc_object> get_htlc( htlc_id_type id, optional<bool> subscribe = optional<bool>() ) const;
 
      vector<htlc_object> get_htlc_by_from( const std::string account_name_or_id,
                                            htlc_id_type start,
                                            uint32_t limit ) const;
 
      vector<htlc_object> get_htlc_by_to( const std::string account_name_or_id,
                                          htlc_id_type start,
                                          uint32_t limit ) const;
 
      vector<htlc_object> list_htlcs(const htlc_id_type start, uint32_t limit) const;
 
 
      // Tickets //
 
      vector<ticket_object> list_tickets(
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<ticket_id_type>& start_id = optional<ticket_id_type>() )const;
 
      vector<ticket_object> get_tickets_by_account(
            const std::string& account_name_or_id,
            const optional<uint32_t>& limit = optional<uint32_t>(),
            const optional<ticket_id_type>& start_id = optional<ticket_id_type>() )const;
 
private:
      std::shared_ptr< database_api_impl > my;
};
 
} }
 
extern template class fc::api<graphene::app::database_api>;
 
FC_API(graphene::app::database_api,
   // Objects
   (get_objects)
 
   // Subscriptions
   (set_subscribe_callback)
   (set_auto_subscription)
   (set_pending_transaction_callback)
   (set_block_applied_callback)
   (cancel_all_subscriptions)
 
   // Blocks and transactions
   (get_block_header)
   (get_block_header_batch)
   (get_block)
   (get_transaction)
   (get_recent_transaction_by_id)
 
   // Globals
   (get_chain_properties)
   (get_global_properties)
   (get_config)
   (get_chain_id)
   (get_dynamic_global_properties)
   (get_next_object_id)
 
   // Keys
   (get_key_references)
   (is_public_key_registered)
 
   // Accounts
   (get_account_id_from_string)
   (get_accounts)
   (get_full_accounts)
   (get_top_voters)
   (get_account_by_name)
   (get_account_references)
   (lookup_account_names)
   (lookup_accounts)
   (get_account_count)
 
   // Balances
   (get_account_balances)
   (get_named_account_balances)
   (get_balance_objects)
   (get_vested_balances)
   (get_vesting_balances)
 
   // Assets
   (get_assets)
   (list_assets)
   (lookup_asset_symbols)
   (get_asset_count)
   (get_assets_by_issuer)
   (get_asset_id_from_string)
 
   // Markets / feeds
   (get_order_book)
   (get_limit_orders)
   (get_limit_orders_by_account)
   (get_account_limit_orders)
   (get_call_orders)
   (get_call_orders_by_account)
   (get_settle_orders)
   (get_settle_orders_by_account)
   (get_margin_positions)
   (get_collateral_bids)
   (subscribe_to_market)
   (unsubscribe_from_market)
   (get_ticker)
   (get_24_volume)
   (get_top_markets)
   (get_trade_history)
   (get_trade_history_by_sequence)
 
   // Liquidity pools
   (list_liquidity_pools)
   (get_liquidity_pools_by_asset_a)
   (get_liquidity_pools_by_asset_b)
   (get_liquidity_pools_by_one_asset)
   (get_liquidity_pools_by_both_assets)
   (get_liquidity_pools)
   (get_liquidity_pools_by_share_asset)
   (get_liquidity_pools_by_owner)
 
   // SameT Funds
   (list_samet_funds)
   (get_samet_funds_by_owner)
   (get_samet_funds_by_asset)
 
   // Credit offers and credit deals
   (list_credit_offers)
   (get_credit_offers_by_owner)
   (get_credit_offers_by_asset)
   (list_credit_deals)
   (get_credit_deals_by_offer_id)
   (get_credit_deals_by_offer_owner)
   (get_credit_deals_by_borrower)
   (get_credit_deals_by_debt_asset)
   (get_credit_deals_by_collateral_asset)
 
   // Witnesses
   (get_witnesses)
   (get_witness_by_account)
   (lookup_witness_accounts)
   (get_witness_count)
 
   // Committee members
   (get_committee_members)
   (get_committee_member_by_account)
   (lookup_committee_member_accounts)
   (get_committee_count)
 
   // workers
   (get_all_workers)
   (get_workers_by_account)
   (get_worker_count)
 
   // Votes
   (lookup_vote_ids)
 
   // Authority / validation
   (get_transaction_hex)
   (get_transaction_hex_without_sig)
   (get_required_signatures)
   (get_potential_signatures)
   (get_potential_address_signatures)
   (verify_authority)
   (verify_account_authority)
   (validate_transaction)
   (get_required_fees)
 
   // Proposed transactions
   (get_proposed_transactions)
 
   // Blinded balances
   (get_blinded_balances)
 
   // Withdrawals
   (get_withdraw_permissions_by_giver)
   (get_withdraw_permissions_by_recipient)
 
   // HTLC
   (get_htlc)
   (get_htlc_by_from)
   (get_htlc_by_to)
   (list_htlcs)
 
   // Tickets
   (list_tickets)
   (get_tickets_by_account)
)