api.hpp

Go to the documentation of this file.

/*
 * 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 <scorum/app/api_context.hpp>
#include <scorum/app/database_api.hpp>
#include <scorum/protocol/types.hpp>
 
#include <graphene/net/node.hpp>
 
#include <fc/api.hpp>
#include <fc/optional.hpp>
#include <fc/crypto/elliptic.hpp>
#include <fc/network/ip.hpp>
 
#include <boost/container/flat_set.hpp>
 
#include <functional>
#include <map>
#include <string>
#include <vector>
 
namespace scorum {
namespace app {
using namespace scorum::chain;
using namespace fc::ecc;
 
class application;
struct api_context;
 
class network_broadcast_api : public std::enable_shared_from_this<network_broadcast_api>
{
public:
    network_broadcast_api(const api_context& a);
 
    struct transaction_confirmation
    {
        transaction_confirmation(transaction_id_type txid, int32_t bn, int32_t tn, bool ex)
            : id(txid)
            , block_num(bn)
            , trx_num(tn)
            , expired(ex)
        {
        }
 
        transaction_id_type id;
        int32_t block_num = 0;
        int32_t trx_num = 0;
        bool expired = false;
    };
 
    typedef std::function<void(variant /*transaction_confirmation*/)> confirmation_callback;
 
    void broadcast_transaction(const signed_transaction& trx);
 
    void broadcast_transaction_with_callback(confirmation_callback cb, const signed_transaction& trx);
 
    fc::variant broadcast_transaction_synchronous(const signed_transaction& trx);
 
    void broadcast_block(const signed_block& block);
 
    void set_max_block_age(int32_t max_block_age);
 
    // implementation detail, not reflected
    bool check_max_block_age(int32_t max_block_age);
 
    void on_applied_block(const signed_block& b);
 
    void on_api_startup();
 
private:
    boost::signals2::scoped_connection _applied_block_connection;
 
    std::map<transaction_id_type, confirmation_callback> _callbacks;
    std::map<time_point_sec, std::vector<transaction_id_type>> _callbacks_expirations;
 
    int32_t _max_block_age = -1;
 
    application& _app;
};
 
class network_node_api
{
public:
    network_node_api(const api_context& a);
 
    fc::variant_object get_info() const;
 
    void add_node(const fc::ip::endpoint& ep);
 
    std::vector<graphene::net::peer_status> get_connected_peers() const;
 
    fc::variant_object get_advanced_node_parameters() const;
 
    void set_advanced_node_parameters(const fc::variant_object& params);
 
    std::vector<graphene::net::potential_peer_record> get_potential_peers() const;
 
    void on_api_startup();
 
private:
    application& _app;
};
 
struct scorum_version_info
{
    scorum_version_info()
    {
    }
    scorum_version_info(fc::string bc_v, fc::string s_v, fc::string fc_v)
        : blockchain_version(bc_v)
        , scorum_revision(s_v)
        , fc_revision(fc_v)
    {
    }
 
    fc::string blockchain_version;
    fc::string scorum_revision;
    fc::string fc_revision;
};
 
class login_api
{
public:
    login_api(const api_context& ctx);
    virtual ~login_api();
 
    bool login(const std::string& user, const std::string& password);
 
    fc::api_ptr get_api_by_name(const std::string& api_name) const;
 
    scorum_version_info get_version();
 
    void on_api_startup();
 
private:
    api_context _ctx;
};
}
} // scorum::app
 
FC_REFLECT(scorum::app::network_broadcast_api::transaction_confirmation, (id)(block_num)(trx_num)(expired))
FC_REFLECT(scorum::app::scorum_version_info, (blockchain_version)(scorum_revision)(fc_revision))
// FC_REFLECT_TYPENAME( fc::ecc::compact_signature );
// FC_REFLECT_TYPENAME( fc::ecc::commitment_type );
 
FC_API(scorum::app::network_broadcast_api,
       (broadcast_transaction)(broadcast_transaction_with_callback)(broadcast_transaction_synchronous)(broadcast_block)(
           set_max_block_age))
FC_API(scorum::app::network_node_api,
       (get_info)(add_node)(get_connected_peers)(get_potential_peers)(get_advanced_node_parameters)(
           set_advanced_node_parameters))
FC_API(scorum::app::login_api, (login)(get_api_by_name)(get_version))