465 lines
17 KiB
C++
465 lines
17 KiB
C++
/*
|
|
* 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.
|
|
*/
|
|
#pragma once
|
|
|
|
#include <graphene/app/database_api.hpp>
|
|
|
|
#include <graphene/chain/protocol/confidential.hpp>
|
|
#include <graphene/chain/protocol/types.hpp>
|
|
|
|
#include <graphene/net/node.hpp>
|
|
|
|
#include <graphene/accounts_list/accounts_list_plugin.hpp>
|
|
#include <graphene/affiliate_stats/affiliate_stats_api.hpp>
|
|
#include <graphene/bookie/bookie_api.hpp>
|
|
#include <graphene/debug_witness/debug_api.hpp>
|
|
#include <graphene/elasticsearch/elasticsearch_plugin.hpp>
|
|
#include <graphene/market_history/market_history_plugin.hpp>
|
|
#include <graphene/peerplays_sidechain/sidechain_api.hpp>
|
|
|
|
#include <fc/api.hpp>
|
|
#include <fc/crypto/elliptic.hpp>
|
|
#include <fc/network/ip.hpp>
|
|
#include <fc/optional.hpp>
|
|
|
|
#include <boost/container/flat_set.hpp>
|
|
|
|
#include <functional>
|
|
#include <map>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace graphene { namespace app {
|
|
using namespace graphene::chain;
|
|
using namespace graphene::market_history;
|
|
using namespace graphene::accounts_list;
|
|
using namespace fc::ecc;
|
|
using namespace std;
|
|
|
|
class application;
|
|
|
|
struct verify_range_result {
|
|
bool success;
|
|
uint64_t min_val;
|
|
uint64_t max_val;
|
|
};
|
|
|
|
struct verify_range_proof_rewind_result {
|
|
bool success;
|
|
uint64_t min_val;
|
|
uint64_t max_val;
|
|
uint64_t value_out;
|
|
fc::ecc::blind_factor_type blind_out;
|
|
string message_out;
|
|
};
|
|
|
|
struct account_asset_balance {
|
|
string name;
|
|
account_id_type account_id;
|
|
share_type amount;
|
|
};
|
|
struct asset_holders {
|
|
asset_id_type asset_id;
|
|
int count;
|
|
};
|
|
|
|
/**
|
|
* @brief The history_api class implements the RPC API for account history
|
|
*
|
|
* This API contains methods to access account histories
|
|
*/
|
|
class history_api {
|
|
public:
|
|
history_api(application &app) :
|
|
_app(app),
|
|
database_api(std::ref(*app.chain_database())) {
|
|
}
|
|
|
|
/**
|
|
* @brief Get operations relevant to the specificed account
|
|
* @param account_id_or_name The account ID or name whose history should be queried
|
|
* @param stop ID of the earliest operation to retrieve
|
|
* @param limit Maximum number of operations to retrieve (must not exceed 100)
|
|
* @param start ID of the most recent operation to retrieve
|
|
* @return A list of operations performed by account, ordered from most recent to oldest.
|
|
*/
|
|
vector<operation_history_object> get_account_history(const std::string account_id_or_name,
|
|
operation_history_id_type stop = operation_history_id_type(),
|
|
unsigned limit = 100,
|
|
operation_history_id_type start = operation_history_id_type()) const;
|
|
|
|
/**
|
|
* @brief Get only asked operations relevant to the specified account
|
|
* @param account_id_or_name The account ID or name whose history should be queried
|
|
* @param operation_id The ID of the operation we want to get operations in the account( 0 = transfer , 1 = limit order create, ...)
|
|
* @param stop ID of the earliest operation to retrieve
|
|
* @param limit Maximum number of operations to retrieve (must not exceed 100)
|
|
* @param start ID of the most recent operation to retrieve
|
|
* @return A list of operations performed by account, ordered from most recent to oldest.
|
|
*/
|
|
vector<operation_history_object> get_account_history_operations(const std::string account_id_or_name,
|
|
int operation_id,
|
|
operation_history_id_type start = operation_history_id_type(),
|
|
operation_history_id_type stop = operation_history_id_type(),
|
|
unsigned limit = 100) const;
|
|
|
|
/**
|
|
* @breif Get operations relevant to the specified account referenced
|
|
* by an event numbering specific to the account. The current number of operations
|
|
* for the account can be found in the account statistics (or use 0 for start).
|
|
* @param account_id_or_name The account ID or name whose history should be queried
|
|
* @param stop Sequence number of earliest operation. 0 is default and will
|
|
* query 'limit' number of operations.
|
|
* @param limit Maximum number of operations to retrieve (must not exceed 100)
|
|
* @param start Sequence number of the most recent operation to retrieve.
|
|
* 0 is default, which will start querying from the most recent operation.
|
|
* @return A list of operations performed by account, ordered from most recent to oldest.
|
|
*/
|
|
vector<operation_history_object> get_relative_account_history(const std::string account_id_or_name,
|
|
uint32_t stop = 0,
|
|
unsigned limit = 100,
|
|
uint32_t start = 0) const;
|
|
|
|
vector<order_history_object> get_fill_order_history(std::string asset_a, std::string asset_b, uint32_t limit) const;
|
|
vector<bucket_object> 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;
|
|
vector<account_balance_object> list_core_accounts() const;
|
|
flat_set<uint32_t> get_market_history_buckets() const;
|
|
uint32_t api_limit_get_account_history_operations = 100;
|
|
uint32_t api_limit_get_account_history = 100;
|
|
uint32_t api_limit_get_relative_account_history = 100;
|
|
|
|
private:
|
|
application &_app;
|
|
graphene::app::database_api database_api;
|
|
};
|
|
|
|
/**
|
|
* @brief Block api
|
|
*/
|
|
class block_api {
|
|
public:
|
|
block_api(graphene::chain::database &db);
|
|
~block_api();
|
|
|
|
vector<optional<signed_block>> get_blocks(uint32_t block_num_from, uint32_t block_num_to) const;
|
|
|
|
private:
|
|
graphene::chain::database &_db;
|
|
};
|
|
|
|
/**
|
|
* @brief The network_broadcast_api class allows broadcasting of transactions.
|
|
*/
|
|
class network_broadcast_api : public std::enable_shared_from_this<network_broadcast_api> {
|
|
public:
|
|
network_broadcast_api(application &a);
|
|
|
|
struct transaction_confirmation {
|
|
transaction_id_type id;
|
|
uint32_t block_num;
|
|
uint32_t trx_num;
|
|
processed_transaction trx;
|
|
};
|
|
|
|
typedef std::function<void(variant /*transaction_confirmation*/)> confirmation_callback;
|
|
|
|
/**
|
|
* @brief Broadcast a transaction to the network
|
|
* @param trx The transaction to broadcast
|
|
*
|
|
* The transaction will be checked for validity in the local database prior to broadcasting. If it fails to
|
|
* apply locally, an error will be thrown and the transaction will not be broadcast.
|
|
*/
|
|
void broadcast_transaction(const signed_transaction &trx);
|
|
|
|
/** this version of broadcast transaction registers a callback method that will be called when the transaction is
|
|
* included into a block. The callback method includes the transaction id, block number, and transaction number in the
|
|
* block.
|
|
*/
|
|
void broadcast_transaction_with_callback(confirmation_callback cb, const signed_transaction &trx);
|
|
|
|
/** this version of broadcast transaction registers a callback method that will be called when the transaction is
|
|
* included into a block. The callback method includes the transaction id, block number, and transaction number in the
|
|
* block.
|
|
*/
|
|
fc::variant broadcast_transaction_synchronous(const signed_transaction &trx);
|
|
|
|
void broadcast_block(const signed_block &block);
|
|
|
|
/**
|
|
* @brief Not reflected, thus not accessible to API clients.
|
|
*
|
|
* This function is registered to receive the applied_block
|
|
* signal from the chain database when a block is received.
|
|
* It then dispatches callbacks to clients who have requested
|
|
* to be notified when a particular txid is included in a block.
|
|
*/
|
|
void on_applied_block(const signed_block &b);
|
|
|
|
private:
|
|
boost::signals2::scoped_connection _applied_block_connection;
|
|
map<transaction_id_type, confirmation_callback> _callbacks;
|
|
application &_app;
|
|
};
|
|
|
|
/**
|
|
* @brief The network_node_api class allows maintenance of p2p connections.
|
|
*/
|
|
class network_node_api {
|
|
public:
|
|
network_node_api(application &a);
|
|
|
|
/**
|
|
* @brief Return general network information, such as p2p port
|
|
*/
|
|
fc::variant_object get_info() const;
|
|
|
|
/**
|
|
* @brief add_node Connect to a new peer
|
|
* @param ep The IP/Port of the peer to connect to
|
|
*/
|
|
void add_node(const fc::ip::endpoint &ep);
|
|
|
|
/**
|
|
* @brief Get status of all current connections to peers
|
|
*/
|
|
std::vector<net::peer_status> get_connected_peers() const;
|
|
|
|
/**
|
|
* @brief Get advanced node parameters, such as desired and max
|
|
* number of connections
|
|
*/
|
|
fc::variant_object get_advanced_node_parameters() const;
|
|
|
|
/**
|
|
* @brief Set advanced node parameters, such as desired and max
|
|
* number of connections
|
|
* @param params a JSON object containing the name/value pairs for the parameters to set
|
|
*/
|
|
void set_advanced_node_parameters(const fc::variant_object ¶ms);
|
|
|
|
/**
|
|
* @brief Return list of potential peers
|
|
*/
|
|
std::vector<net::potential_peer_record> get_potential_peers() const;
|
|
|
|
/**
|
|
* @brief Return list of pending transactions.
|
|
*/
|
|
map<transaction_id_type, signed_transaction> list_pending_transactions() const;
|
|
|
|
/**
|
|
* @brief Subscribes caller for notifications about pending transactions.
|
|
* @param callback a functional object which will be called when new transaction is created.
|
|
*/
|
|
void subscribe_to_pending_transactions(std::function<void(const variant &)> callback);
|
|
|
|
/**
|
|
* @brief Unsubscribes caller from notifications about pending transactions.
|
|
*/
|
|
void unsubscribe_from_pending_transactions();
|
|
|
|
private:
|
|
application &_app;
|
|
map<transaction_id_type, signed_transaction> _pending_transactions;
|
|
boost::signals2::scoped_connection _pending_trx_connection;
|
|
boost::signals2::scoped_connection _applied_block_connection;
|
|
std::function<void(const variant &)> _on_pending_transaction;
|
|
};
|
|
|
|
/**
|
|
* @brief
|
|
*/
|
|
class asset_api {
|
|
public:
|
|
asset_api(graphene::app::application &app);
|
|
~asset_api();
|
|
|
|
/**
|
|
* @brief Get asset holders for a specific asset
|
|
* @param asset The specific asset id or symbol
|
|
* @param start The start index
|
|
* @param limit Maximum limit must not exceed 100
|
|
* @return A list of asset holders for the specified asset
|
|
*/
|
|
vector<account_asset_balance> get_asset_holders(std::string asset, uint32_t start, uint32_t limit) const;
|
|
|
|
/**
|
|
* @brief Get asset holders count for a specific asset
|
|
* @param asset The specific asset id or symbol
|
|
* @return Holders count for the specified asset
|
|
*/
|
|
int get_asset_holders_count(std::string asset) const;
|
|
|
|
/**
|
|
* @brief Get all asset holders
|
|
* @return A list of all asset holders
|
|
*/
|
|
vector<asset_holders> get_all_asset_holders() const;
|
|
|
|
uint32_t api_limit_get_asset_holders = 100;
|
|
|
|
private:
|
|
graphene::app::application &_app;
|
|
graphene::chain::database &_db;
|
|
graphene::app::database_api database_api;
|
|
};
|
|
}} // namespace graphene::app
|
|
|
|
extern template class fc::api<graphene::app::block_api>;
|
|
extern template class fc::api<graphene::app::network_broadcast_api>;
|
|
extern template class fc::api<graphene::app::network_node_api>;
|
|
extern template class fc::api<graphene::app::history_api>;
|
|
extern template class fc::api<graphene::app::asset_api>;
|
|
extern template class fc::api<graphene::debug_witness::debug_api>;
|
|
|
|
namespace graphene { namespace app {
|
|
/**
|
|
* @brief The login_api class implements the bottom layer of the RPC API
|
|
*
|
|
* All other APIs must be requested from this API.
|
|
*/
|
|
class login_api {
|
|
public:
|
|
login_api(application &a);
|
|
~login_api();
|
|
|
|
/**
|
|
* @brief Authenticate to the RPC server
|
|
* @param user Username to login with
|
|
* @param password Password to login with
|
|
* @return True if logged in successfully; false otherwise
|
|
*
|
|
* @note This must be called prior to requesting other APIs. Other APIs may not be accessible until the client
|
|
* has sucessfully authenticated.
|
|
*/
|
|
bool login(const string &user, const string &password);
|
|
/// @brief Retrieve the network block API
|
|
fc::api<block_api> block() const;
|
|
/// @brief Retrieve the network broadcast API
|
|
fc::api<network_broadcast_api> network_broadcast() const;
|
|
/// @brief Retrieve the database API
|
|
fc::api<database_api> database() const;
|
|
/// @brief Retrieve the history API
|
|
fc::api<history_api> history() const;
|
|
/// @brief Retrieve the network node API
|
|
fc::api<network_node_api> network_node() const;
|
|
/// @brief Retrieve the asset API
|
|
fc::api<asset_api> asset() const;
|
|
/// @brief Retrieve the debug API (if available)
|
|
fc::api<graphene::debug_witness::debug_api> debug() const;
|
|
/// @brief Retrieve the bookie API (if available)
|
|
fc::api<graphene::bookie::bookie_api> bookie() const;
|
|
/// @brief Retrieve the affiliate_stats API (if available)
|
|
fc::api<graphene::affiliate_stats::affiliate_stats_api> affiliate_stats() const;
|
|
/// @brief Retrieve the sidechain_api API (if available)
|
|
fc::api<graphene::peerplays_sidechain::sidechain_api> sidechain() const;
|
|
|
|
/// @brief Called to enable an API, not reflected.
|
|
void enable_api(const string &api_name);
|
|
|
|
private:
|
|
application &_app;
|
|
optional<fc::api<block_api>> _block_api;
|
|
optional<fc::api<database_api>> _database_api;
|
|
optional<fc::api<network_broadcast_api>> _network_broadcast_api;
|
|
optional<fc::api<network_node_api>> _network_node_api;
|
|
optional<fc::api<history_api>> _history_api;
|
|
optional<fc::api<asset_api>> _asset_api;
|
|
optional<fc::api<graphene::debug_witness::debug_api>> _debug_api;
|
|
optional<fc::api<graphene::bookie::bookie_api>> _bookie_api;
|
|
optional<fc::api<graphene::affiliate_stats::affiliate_stats_api>> _affiliate_stats_api;
|
|
optional<fc::api<graphene::peerplays_sidechain::sidechain_api>> _sidechain_api;
|
|
};
|
|
|
|
}} // namespace graphene::app
|
|
|
|
extern template class fc::api<graphene::app::login_api>;
|
|
|
|
// clang-format off
|
|
|
|
FC_REFLECT(graphene::app::network_broadcast_api::transaction_confirmation,
|
|
(id)(block_num)(trx_num)(trx))
|
|
|
|
FC_REFLECT(graphene::app::verify_range_result,
|
|
(success)(min_val)(max_val))
|
|
|
|
FC_REFLECT(graphene::app::verify_range_proof_rewind_result,
|
|
(success)(min_val)(max_val)(value_out)(blind_out)(message_out))
|
|
|
|
FC_REFLECT(graphene::app::account_asset_balance,
|
|
(name)(account_id)(amount));
|
|
|
|
FC_REFLECT(graphene::app::asset_holders,
|
|
(asset_id)(count));
|
|
|
|
FC_API(graphene::app::history_api,
|
|
(get_account_history)
|
|
(get_account_history_operations)
|
|
(get_relative_account_history)
|
|
(get_fill_order_history)
|
|
(get_market_history)
|
|
(get_market_history_buckets)
|
|
(list_core_accounts))
|
|
|
|
FC_API(graphene::app::block_api,
|
|
(get_blocks))
|
|
|
|
FC_API(graphene::app::network_broadcast_api,
|
|
(broadcast_transaction)
|
|
(broadcast_transaction_with_callback)
|
|
(broadcast_transaction_synchronous)
|
|
(broadcast_block))
|
|
|
|
FC_API(graphene::app::network_node_api,
|
|
(get_info)
|
|
(add_node)
|
|
(get_connected_peers)
|
|
(get_potential_peers)
|
|
(get_advanced_node_parameters)
|
|
(set_advanced_node_parameters)
|
|
(list_pending_transactions)
|
|
(subscribe_to_pending_transactions)
|
|
(unsubscribe_from_pending_transactions))
|
|
|
|
FC_API(graphene::app::asset_api,
|
|
(get_asset_holders)
|
|
(get_asset_holders_count)
|
|
(get_all_asset_holders))
|
|
|
|
FC_API(graphene::app::login_api,
|
|
(login)
|
|
(block)
|
|
(network_broadcast)
|
|
(database)
|
|
(history)
|
|
(network_node)
|
|
(asset)
|
|
(debug)
|
|
(bookie)
|
|
(affiliate_stats)
|
|
(sidechain))
|
|
|
|
// clang-format on
|