232 lines
8.9 KiB
C++
232 lines
8.9 KiB
C++
/*
|
|
* Copyright (c) 2015 Cryptonomex, Inc., and contributors.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Any modified source or binaries are used only with the BitShares network.
|
|
*
|
|
* 2. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* 3. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
|
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
#pragma once
|
|
|
|
#include <graphene/app/database_api.hpp>
|
|
|
|
#include <graphene/chain/protocol/types.hpp>
|
|
|
|
#include <graphene/market_history/market_history_plugin.hpp>
|
|
|
|
#include <graphene/net/node.hpp>
|
|
|
|
#include <fc/api.hpp>
|
|
#include <fc/optional.hpp>
|
|
#include <fc/network/ip.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 std;
|
|
|
|
class application;
|
|
|
|
|
|
/**
|
|
* @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){}
|
|
|
|
/**
|
|
* @brief Get operations relevant to the specificed account
|
|
* @param account The account 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(account_id_type account,
|
|
operation_history_id_type stop = operation_history_id_type(),
|
|
unsigned limit = 100,
|
|
operation_history_id_type start = operation_history_id_type())const;
|
|
|
|
vector<operation_history_object> get_relative_account_history( account_id_type account,
|
|
uint32_t stop = 0,
|
|
unsigned limit = 100,
|
|
uint32_t start = 0) const;
|
|
|
|
vector<order_history_object> get_fill_order_history( asset_id_type a, asset_id_type b, uint32_t limit )const;
|
|
vector<bucket_object> get_market_history( asset_id_type a, asset_id_type b, uint32_t bucket_seconds,
|
|
fc::time_point_sec start, fc::time_point_sec end )const;
|
|
flat_set<uint32_t> get_market_history_buckets()const;
|
|
private:
|
|
application& _app;
|
|
};
|
|
|
|
/**
|
|
* @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);
|
|
|
|
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 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;
|
|
|
|
private:
|
|
application& _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 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;
|
|
|
|
private:
|
|
/// @brief Called to enable an API, not reflected.
|
|
void enable_api( const string& api_name );
|
|
|
|
application& _app;
|
|
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;
|
|
};
|
|
|
|
}} // graphene::app
|
|
|
|
FC_REFLECT( graphene::app::network_broadcast_api::transaction_confirmation,
|
|
(id)(block_num)(trx_num)(trx) )
|
|
|
|
FC_API(graphene::app::history_api,
|
|
(get_account_history)
|
|
(get_fill_order_history)
|
|
(get_market_history)
|
|
(get_market_history_buckets)
|
|
)
|
|
FC_API(graphene::app::network_broadcast_api,
|
|
(broadcast_transaction)
|
|
(broadcast_transaction_with_callback)
|
|
(broadcast_block)
|
|
)
|
|
FC_API(graphene::app::network_node_api,
|
|
(get_info)
|
|
(add_node)
|
|
(get_connected_peers)
|
|
)
|
|
FC_API(graphene::app::login_api,
|
|
(login)
|
|
(network_broadcast)
|
|
(database)
|
|
(history)
|
|
(network_node)
|
|
)
|