RPCHelpers.h

#ifndef XRPL_RPC_RPCHELPERS_H_INCLUDED
#define XRPL_RPC_RPCHELPERS_H_INCLUDED
 
#include <xrpld/app/misc/NetworkOPs.h>
#include <xrpld/app/misc/TxQ.h>
#include <xrpld/rpc/Context.h>
#include <xrpld/rpc/Status.h>
#include <xrpld/rpc/detail/Tuning.h>
 
#include <xrpl/beast/core/SemanticVersion.h>
#include <xrpl/proto/org/xrpl/rpc/v1/xrp_ledger.pb.h>
#include <xrpl/protocol/ApiVersion.h>
#include <xrpl/protocol/SecretKey.h>
 
#include <optional>
#include <variant>
 
namespace Json {
class Value;
}
 
namespace ripple {
 
class ReadView;
class Transaction;
 
namespace RPC {
 
struct JsonContext;
 
std::optional<AccountID>
accountFromStringStrict(std::string const&);
 
// --> strIdent: public key, account ID, or regular seed.
// --> bStrict: Only allow account id or public key.
//
// Returns a Json::objectValue, containing error information if there was one.
Json::Value
accountFromString(
    AccountID& result,
    std::string const& strIdent,
    bool bStrict = false);
 
error_code_i
accountFromStringWithCode(
    AccountID& result,
    std::string const& strIdent,
    bool bStrict = false);
 
std::uint64_t
getStartHint(std::shared_ptr<SLE const> const& sle, AccountID const& accountID);
 
bool
isRelatedToAccount(
    ReadView const& ledger,
    std::shared_ptr<SLE const> const& sle,
    AccountID const& accountID);
 
bool
getAccountObjects(
    ReadView const& ledger,
    AccountID const& account,
    std::optional<std::vector<LedgerEntryType>> const& typeFilter,
    uint256 dirIndex,
    uint256 entryIndex,
    std::uint32_t const limit,
    Json::Value& jvResult);
 
template <class T>
Status
getLedger(T& ledger, uint256 const& ledgerHash, Context& context);
 
template <class T>
Status
getLedger(T& ledger, uint32_t ledgerIndex, Context& context);
 
enum LedgerShortcut { CURRENT, CLOSED, VALIDATED };
template <class T>
Status
getLedger(T& ledger, LedgerShortcut shortcut, Context& context);
 
Json::Value
lookupLedger(std::shared_ptr<ReadView const>&, JsonContext&);
 
Status
lookupLedger(
    std::shared_ptr<ReadView const>&,
    JsonContext&,
    Json::Value& result);
 
template <class T, class R>
Status
ledgerFromRequest(T& ledger, GRPCContext<R>& context);
 
template <class T>
Status
ledgerFromSpecifier(
    T& ledger,
    org::xrpl::rpc::v1::LedgerSpecifier const& specifier,
    Context& context);
 
hash_set<AccountID>
parseAccountIds(Json::Value const& jvArray);
 
bool
isHexTxID(std::string const& txid);
 
void
injectSLE(Json::Value& jv, SLE const& sle);
 
std::optional<Json::Value>
readLimitField(
    unsigned int& limit,
    Tuning::LimitRange const&,
    JsonContext const&);
 
std::optional<Seed>
getSeedFromRPC(Json::Value const& params, Json::Value& error);
 
std::optional<Seed>
parseRippleLibSeed(Json::Value const& params);
 
std::pair<RPC::Status, LedgerEntryType>
chooseLedgerEntryType(Json::Value const& params);
 
bool
isAccountObjectsValidType(LedgerEntryType const& type);
 
std::variant<std::shared_ptr<Ledger const>, Json::Value>
getLedgerByContext(RPC::JsonContext& context);
 
std::optional<std::pair<PublicKey, SecretKey>>
keypairForSignature(
    Json::Value const& params,
    Json::Value& error,
    unsigned int apiVersion = apiVersionIfUnspecified);
 
}  // namespace RPC
 
}  // namespace ripple
 
#endif