server.h

Go to the documentation of this file.

// Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin developers
// Copyright (c) 2015-2022 The PIVX Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef PIVX_RPC_SERVER_H
#define PIVX_RPC_SERVER_H
 
#include "amount.h"
#include "rpc/protocol.h"
#include "uint256.h"
 
#include <list>
#include <map>
#include <stdint.h>
#include <string>
 
#include <univalue.h>
 
class CRPCCommand;
 
namespace RPCServer
{
    void OnStarted(std::function<void ()> slot);
    void OnStopped(std::function<void ()> slot);
    void OnPreCommand(std::function<void (const CRPCCommand&)> slot);
}
 
class CBlockIndex;
class CNetAddr;
 
struct UniValueType {
    UniValueType(UniValue::VType _type) : typeAny(false), type(_type) {}
    UniValueType() : typeAny(true) {}
    bool typeAny;
    UniValue::VType type{UniValue::VNULL};
};
 
class JSONRPCRequest
{
public:
    UniValue id;
    std::string strMethod;
    UniValue params;
    bool fHelp;
    std::string URI;
    std::string authUser;
 
    JSONRPCRequest() { id = NullUniValue; params = NullUniValue; fHelp = false; }
    void parse(const UniValue& valRequest);
};
 
bool IsRPCRunning();
 
void SetRPCWarmupStatus(const std::string& newStatus);
/* Mark warmup as done.  RPC calls will be processed from now on.  */
void SetRPCWarmupFinished();
 
/* returns the current warmup state.  */
bool RPCIsInWarmup(std::string* statusOut);
 
void RPCTypeCheck(const UniValue& params,
                  const std::list<UniValue::VType>& typesExpected, bool fAllowNull=false);
 
void RPCTypeCheckArgument(const UniValue& value, const UniValueType& typeExpected);
 
void RPCTypeCheckObj(const UniValue& o,
    const std::map<std::string, UniValueType>& typesExpected,
    bool fAllowNull=false,
    bool fStrict=false);
 
class RPCTimerBase
{
public:
    virtual ~RPCTimerBase() {}
};
 
class RPCTimerInterface
{
public:
    virtual ~RPCTimerInterface() {}
    virtual const char *Name() = 0;
    virtual RPCTimerBase* NewTimer(std::function<void(void)>& func, int64_t millis) = 0;
};
 
void RPCSetTimerInterface(RPCTimerInterface *iface);
void RPCSetTimerInterfaceIfUnset(RPCTimerInterface *iface);
void RPCUnsetTimerInterface(RPCTimerInterface *iface);
 
void RPCRunLater(const std::string& name, std::function<void(void)> func, int64_t nSeconds);
 
typedef UniValue(*rpcfn_type)(const JSONRPCRequest& jsonRequest);
 
class CRPCCommand
{
public:
    std::string category;
    std::string name;
    rpcfn_type actor;
    bool okSafeMode;
    std::vector<std::string> argNames;
};
 
class CRPCTable
{
private:
    std::map<std::string, const CRPCCommand*> mapCommands;
 
public:
    CRPCTable();
    const CRPCCommand* operator[](const std::string& name) const;
    std::string help(const std::string& name, const JSONRPCRequest& helpreq) const;
 
    UniValue execute(const JSONRPCRequest &request) const;
 
    std::vector<std::string> listCommands() const;
 
    bool appendCommand(const std::string& name, const CRPCCommand* pcmd);
};
 
bool IsDeprecatedRPCEnabled(const std::string& method);
 
extern CRPCTable tableRPC;
 
extern uint256 ParseHashV(const UniValue& v, std::string strName);
extern uint256 ParseHashO(const UniValue& o, std::string strKey);
extern std::vector<unsigned char> ParseHexV(const UniValue& v, std::string strName);
extern std::vector<unsigned char> ParseHexO(const UniValue& o, std::string strKey);
extern int ParseInt(const UniValue& o, std::string strKey);
extern bool ParseBool(const UniValue& o, std::string strKey);
extern double ParseDoubleV(const UniValue& v, const std::string &strName);
 
extern CAmount AmountFromValue(const UniValue& value);
extern UniValue ValueFromAmount(const CAmount& amount);
extern double GetDifficulty(const CBlockIndex* blockindex = nullptr);
extern std::string HelpExampleCli(std::string methodname, std::string args);
extern std::string HelpExampleRpc(std::string methodname, std::string args);
 
bool StartRPC();
void InterruptRPC();
void StopRPC();
std::string JSONRPCExecBatch(const UniValue& vReq);
void RPCNotifyBlockChange(bool fInitialDownload, const CBlockIndex* pindex);
 
#endif // PIVX_RPC_SERVER_H