database_api.hpp

Go to the documentation of this file.

#pragma once
 
#define API_DATABASE "database_api"
 
#include <scorum/app/state.hpp>
 
#include <scorum/chain/database/database.hpp>
#include <scorum/chain/schema/scorum_objects.hpp>
#include <scorum/chain/schema/scorum_object_types.hpp>
 
#include <scorum/app/scorum_api_objects.hpp>
 
#include <scorum/tags/tags_plugin.hpp>
 
#include <scorum/witness/witness_plugin.hpp>
 
#include <fc/api.hpp>
#include <fc/optional.hpp>
#include <fc/variant_object.hpp>
 
#include <fc/network/ip.hpp>
 
#include <boost/container/flat_set.hpp>
 
#include <functional>
#include <map>
#include <memory>
#include <vector>
 
namespace scorum {
namespace app {
 
using namespace scorum::chain;
using namespace scorum::protocol;
 
struct api_context;
 
struct withdraw_route
{
    std::string from_account;
    std::string to_account;
    uint16_t percent;
    bool auto_vest;
};
 
enum withdraw_route_type
{
    incoming,
    outgoing,
    all
};
 
class database_api_impl;
 
class database_api
{
public:
    database_api(const scorum::app::api_context& ctx);
    ~database_api();
 
    // Handlers - not exposed //
    void on_api_startup();
 
 
    void set_block_applied_callback(std::function<void(const variant& block_header)> cb);
 
 
 
    fc::variant_object get_config() const;
 
    chain_id_type get_chain_id() const;
 
    dynamic_global_property_api_obj get_dynamic_global_properties() const;
 
    witness_schedule_api_obj get_witness_schedule() const;
 
 
 
    std::vector<std::set<std::string>> get_key_references(std::vector<public_key_type> key) const;
 
    std::vector<extended_account> get_accounts(const std::vector<std::string>& names) const;
 
    std::vector<account_id_type> get_account_references(account_id_type account_id) const;
 
    std::vector<optional<account_api_obj>> lookup_account_names(const std::vector<std::string>& account_names) const;
 
    std::set<std::string> lookup_accounts(const std::string& lower_bound_name, uint32_t limit) const;
 
    uint64_t get_account_count() const;
 
    std::vector<owner_authority_history_api_obj> get_owner_history(const std::string& account) const;
 
    optional<account_recovery_request_api_obj> get_recovery_request(const std::string& account) const;
 
    optional<escrow_api_obj> get_escrow(const std::string& from, uint32_t escrow_id) const;
 
    std::vector<withdraw_route> get_withdraw_routes(const std::string& account,
                                                    withdraw_route_type type = outgoing) const;
 
    optional<account_bandwidth_api_obj> get_account_bandwidth(const std::string& account,
                                                              witness::bandwidth_type type) const;
 
    std::vector<scorumpower_delegation_api_obj> get_scorumpower_delegations(const std::string& account,
                                                                            const std::string& from,
                                                                            uint32_t limit = 100) const;
 
    std::vector<scorumpower_delegation_expiration_api_obj> get_expiring_scorumpower_delegations(
        const std::string& account, time_point_sec from, uint32_t limit = 100) const;
 
 
 
    std::vector<budget_api_obj> get_budgets(const budget_type, const std::set<std::string>& account_names) const;
 
    std::set<std::string>
    lookup_budget_owners(const budget_type, const std::string& lower_bound_name, uint32_t limit) const;
 
 
 
    std::vector<atomicswap_contract_api_obj> get_atomicswap_contracts(const std::string& owner) const;
 
    atomicswap_contract_info_api_obj
    get_atomicswap_contract(const std::string& from, const std::string& to, const std::string& secret_hash) const;
 
 
 
    std::vector<optional<witness_api_obj>> get_witnesses(const std::vector<witness_id_type>& witness_ids) const;
 
    fc::optional<witness_api_obj> get_witness_by_account(const std::string& account_name) const;
 
    std::vector<witness_api_obj> get_witnesses_by_vote(const std::string& from, uint32_t limit) const;
 
    std::set<account_name_type> lookup_witness_accounts(const std::string& lower_bound_name, uint32_t limit) const;
 
    std::vector<account_name_type> get_active_witnesses() const;
 
    uint64_t get_witness_count() const;
 
 
 
    std::set<account_name_type> lookup_registration_committee_members(const std::string& lower_bound_name,
                                                                      uint32_t limit) const;
 
    std::set<account_name_type> lookup_development_committee_members(const std::string& lower_bound_name,
                                                                     uint32_t limit) const;
 
    std::vector<proposal_api_obj> lookup_proposals() const;
 
    development_committee_api_obj get_development_committee() const;
 
    registration_committee_api_obj get_registration_committee() const;
 
    advertising_property_api_obj get_advertising_property() const;
 
 
 
    std::string get_transaction_hex(const signed_transaction& trx) const;
 
    std::set<public_key_type> get_required_signatures(const signed_transaction& trx,
                                                      const flat_set<public_key_type>& available_keys) const;
 
    std::set<public_key_type> get_potential_signatures(const signed_transaction& trx) const;
 
    bool verify_authority(const signed_transaction& trx) const;
 
    /*
     * @return true if the signers have enough authority to authorize an account
     */
    bool verify_account_authority(const std::string& name_or_id, const flat_set<public_key_type>& signers) const;
 
 
 
    std::vector<vote_state> get_active_votes(const std::string& author, const std::string& permlink) const;
    std::vector<account_vote> get_account_votes(const std::string& voter) const;
 
 
 
    nft_api_obj get_nft_by_id(int64_t id) const;
 
    nft_api_obj get_nft_by_name(const account_name_type& name) const;
 
    nft_api_obj get_nft_by_uuid(const uuid_type& uuid) const;
 
    std::vector<nft_api_obj> lookup_nft(int64_t from, uint32_t limit) const;
 
    game_round_api_obj get_game_round_by_uuid(const uuid_type& uuid) const;
 
    std::vector<game_round_api_obj> lookup_game_round(int64_t id, uint32_t limit) const;
 
 
private:
    std::shared_ptr<database_api_impl> my;
};
} // namespace app
} // namespace scorum
 
// clang-format off
 
FC_REFLECT( scorum::app::withdraw_route, (from_account)(to_account)(percent)(auto_vest) )
 
FC_REFLECT_ENUM( scorum::app::withdraw_route_type, (incoming)(outgoing)(all) )
 
FC_API(scorum::app::database_api,
   // Subscriptions
   (set_block_applied_callback)
 
   // Globals
   (get_config)
   (get_chain_id)
   (get_dynamic_global_properties)
   (get_witness_schedule)
 
   // Accounts
   (get_key_references)
   (get_accounts)
   (get_account_references)
   (lookup_account_names)
   (lookup_accounts)
   (get_account_count)
   (get_owner_history)
   (get_recovery_request)
   (get_escrow)
   (get_withdraw_routes)
   (get_account_bandwidth)
   (get_scorumpower_delegations)
   (get_expiring_scorumpower_delegations)
 
   // Authority / validation
   (get_transaction_hex)
   (get_required_signatures)
   (get_potential_signatures)
   (verify_authority)
   (verify_account_authority)
 
   // votes
   (get_active_votes)
   (get_account_votes)
 
   // Witnesses
   (get_witnesses)
   (get_witness_by_account)
   (get_witnesses_by_vote)
   (lookup_witness_accounts)
 
   (get_active_witnesses)
   (get_witness_count)
 
    // Budget
   (get_budgets)
   (lookup_budget_owners)
 
   // Committee
   (lookup_registration_committee_members)
   (lookup_development_committee_members)
   (lookup_proposals)
   (get_registration_committee)
   (get_development_committee)
   (get_advertising_property)
 
    // Atomic Swap
   (get_atomicswap_contracts)
   (get_atomicswap_contract)
 
    // NFT
    (get_nft_by_id)
    (get_nft_by_name)
    (get_nft_by_uuid)
    (lookup_nft)
    (get_game_round_by_uuid)
    (lookup_game_round)
)
 
// clang-format on