// {
// account: <indent>,
// account_index : <index> // optional
// strict: <bool> // true, only allow public keys and addresses. false, default.
// ledger_hash : <ledger>
// ledger_index : <ledger_index>
// }
Json::Value doAccountInfo (RPC::Context& context)
{
auto& params = context.params_;
Ledger::pointer ledger;
Json::Value result = RPC::lookupLedger (params, ledger, context.netOps_);
if (!ledger)
return result;
if (!params.isMember ("account") && !params.isMember ("ident"))
return RPC::missing_field_error ("account");
std::string strIdent = params.isMember ("account")
? params["account"].asString () : params["ident"].asString ();
bool bIndex;
int iIndex = params.isMember ("account_index")
? params["account_index"].asUInt () : 0;
bool bStrict = params.isMember ("strict") && params["strict"].asBool ();
RippleAddress naAccount;
// Get info on account.
Json::Value jvAccepted = RPC::accountFromString (
ledger, naAccount, bIndex, strIdent, iIndex, bStrict, context.netOps_);
if (!jvAccepted.empty ())
return jvAccepted;
auto asAccepted = context.netOps_.getAccountState (ledger, naAccount);
if (asAccepted)
{
asAccepted->addJson (jvAccepted);
result["account_data"] = jvAccepted;
}
else
{
result["account"] = naAccount.humanAccountID ();
result = rpcError (rpcACT_NOT_FOUND, result);
}
return result;
}
bool EffectHandler::save(JsonArray& array, uint8_t ID, const char * name)
{
//Serial.printf("[EffectHandler::save] Effect = %s, ID = %s\n", _name, ID);
int index = 0;
for (JsonArray::iterator it = array.begin(); it != array.end(); ++it) {
// *it contains the JsonVariant which can be casted as usuals
//const char* value = *it;
JsonObject& preset = *it;
if (preset.containsKey("ID")) {
if ( preset["ID"] == ID) {
array.removeAt(index) ;
DebugEffectHandlerf("[EffectHandler::save] preset %u removed\n", ID);
break;
}
}
index++;
// this also works:
//value = it->as<const char*>();
}
JsonObject& current = array.createNestedObject();
current["ID"] = ID;
current["name"] = name;
current["effect"] = _name;
if (addJson(current)) {
return true;
} else {
return false;
}
};
// {
// ledger_hash : <ledger>
// ledger_index : <ledger_index>
// }
Json::Value doLedgerRequest (RPC::Context& context)
{
auto const hasHash = context.params.isMember (jss::ledger_hash);
auto const hasIndex = context.params.isMember (jss::ledger_index);
auto& ledgerMaster = getApp().getLedgerMaster();
LedgerHash ledgerHash;
if ((hasHash && hasIndex) || !(hasHash || hasIndex))
{
return RPC::make_param_error(
"Exactly one of ledger_hash and ledger_index can be set.");
}
if (hasHash)
{
auto const& jsonHash = context.params[jss::ledger_hash];
if (!jsonHash.isString() || !ledgerHash.SetHex (jsonHash.asString ()))
return RPC::invalid_field_message (jss::ledger_hash);
} else {
auto const& jsonIndex = context.params[jss::ledger_index];
if (!jsonIndex.isNumeric ())
return RPC::invalid_field_message (jss::ledger_index);
// We need a validated ledger to get the hash from the sequence
if (ledgerMaster.getValidatedLedgerAge() > 120)
return rpcError (rpcNO_CURRENT);
auto ledgerIndex = jsonIndex.asInt();
auto ledger = ledgerMaster.getValidatedLedger();
if (ledgerIndex >= ledger->getLedgerSeq())
return RPC::make_param_error("Ledger index too large");
// Try to get the hash of the desired ledger from the validated ledger
ledgerHash = ledger->getLedgerHash (ledgerIndex);
if (ledgerHash == zero)
{
// Find a ledger more likely to have the hash of the desired ledger
auto refIndex = (ledgerIndex + 255) & (~255);
auto refHash = ledger->getLedgerHash (refIndex);
assert (refHash.isNonZero ());
ledger = ledgerMaster.getLedgerByHash (refHash);
if (!ledger)
{
// We don't have the ledger we need to figure out which ledger
// they want. Try to get it.
if (auto il = getApp().getInboundLedgers().acquire (
refHash, refIndex, InboundLedger::fcGENERIC))
return getJson (LedgerFill (*il));
if (auto il = getApp().getInboundLedgers().find (refHash))
{
Json::Value jvResult = il->getJson (0);
jvResult[jss::error] = "ledgerNotFound";
return jvResult;
}
// Likely the app is shutting down
return Json::Value();
}
ledgerHash = ledger->getLedgerHash (ledgerIndex);
assert (ledgerHash.isNonZero ());
}
}
auto ledger = ledgerMaster.getLedgerByHash (ledgerHash);
if (ledger)
{
// We already have the ledger they want
Json::Value jvResult;
jvResult[jss::ledger_index] = ledger->getLedgerSeq();
addJson (jvResult, {*ledger, 0});
return jvResult;
}
else
{
// Try to get the desired ledger
if (auto il = getApp ().getInboundLedgers ().acquire (
ledgerHash, 0, InboundLedger::fcGENERIC))
return getJson (LedgerFill (*il));
if (auto il = getApp().getInboundLedgers().find (ledgerHash))
return il->getJson (0);
return RPC::make_error (
rpcNOT_READY, "findCreate failed to return an inbound ledger");
}
}
void AccountState::dump ()
{
Json::Value j (Json::objectValue);
addJson (j);
WriteLog (lsINFO, Ledger) << j;
}