ARCHIVE/xahaud
3
0
Fork 0
mirror of https://github.com/Xahau/xahaud.git synced 2025-11-19 18:15:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'richardah/BookChanges191' into develop

Browse Source
This commit is contained in:
Richard Holland
2022-06-21 10:31:13 +00:00
parent 8dd5490fb6 27846df19c
commit 043bdaf379
18 changed files with 511 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
RELEASENOTES.md
View File

@@ -7,6 +7,84 @@ This document contains the release notes for `rippled`, the reference server imp
Have new ideas? Need help with setting up your node? Come visit us [here](https://github.com/ripple/rippled/issues/new/choose)
# Introducing XRP Ledger version 1.9.1
Version 1.9.1 of `rippled`, the reference server implementation of the XRP Ledger protocol, is now available. This release includes several important fixes, including a fix for a syncing issue from 1.9.0, a new fix amendment to correct a bug in the new Non-Fungible Tokens (NFTs) code, and a new amendment to allow multi-signing by up to 32 signers.
<!-- BREAK -->
## Action Required
This release introduces two new amendments to the XRP Ledger protocol. These amendments are now open for voting according to the XRP Ledger's [amendment process](https://xrpl.org/amendments.html), which enables protocol changes following two weeks of >80% support from trusted validators.
If you operate an XRP Ledger server, then you should upgrade to version 1.9.1 within two weeks, to ensure service continuity. The exact time that protocol changes take effect depends on the voting decisions of the decentralized network.
The **fixNFTokenDirV1** amendment fixes a bug in code associated with the **NonFungibleTokensV1** amendment, so the fixNFTokenDirV1 amendment should be enabled first. All validator operators are encouraged to [configure amendment voting](https://xrpl.org/configure-amendment-voting.html) to oppose the NonFungibleTokensV1 amendment until _after_ the fixNFTokenDirV1 amendment has become enabled. For more information about NFTs on the XRP Ledger, see [NFT Conceptual Overview](https://xrpl.org/nft-conceptual-overview.html).
The **ExpandedSignerList** amendment extends the ledger's built-in multi-signing functionality so that each list can contain up to 32 entries instead of the current limit of 8. Additionally, this amendment allows each signer to have an arbitrary 256-bit data field associated with it. This data can be used to identify the signer or provide other metadata that is useful for organizations, smart contracts, or other purposes.
## Install / Upgrade
On supported platforms, see the [instructions on installing or updating `rippled`](https://xrpl.org/install-rippled.html).
## Changelog
This release contains the following features and improvements.
## New Features and Amendments
- **Introduce fixNFTokenDirV1 Amendment** - This amendment fixes an off-by-one error that occurred in some corner cases when determining which `NFTokenPage` an `NFToken` object belongs on. It also adjusts the constraints of `NFTokenPage` invariant checks, so that certain error cases fail with a suitable error code such as `tecNO_SUITABLE_TOKEN_PAGE` instead of failing with a `tecINVARIANT_FAILED` error code. ([#4155](https://github.com/ripple/rippled/pull/4155))
- **Introduce ExpandedSignerList Amendment** - This amendment expands the maximum signer list size to 32 entries and allows each signer to have an optional 256-bit `WalletLocator` field containing arbitrary data. ([#4097](https://github.com/ripple/rippled/pull/4097))
- **Pause online deletion rather than canceling it if the server fails health check** - The server stops performing online deletion of old ledger history if the server fails its internal health check during this time. Online deletion can now resume after the server recovers, rather than having to start over. ([#4139](https://github.com/ripple/rippled/pull/4139))
## Bug Fixes and Performance Improvements
- **Fix performance issues introduced in 1.9.0** - Readjusts some parameters of the ledger acquisition engine to revert some changes introduced in 1.9.0 that had adverse effects on some systems, including causing some systems to fail to sync to the network. ([#4152](https://github.com/ripple/rippled/pull/4152))
- **Improve Memory Efficiency of Path Finding** - Finding paths for cross-currency payments is a resource-intensive operation. While that remains true, this fix improves memory usage of pathfinding by discarding trust line results that cannot be used before those results are fully loaded or cached. ([#4111](https://github.com/ripple/rippled/pull/4111))
- **Fix incorrect CMake behavior on Windows when platform is unspecified or x64** - Fixes handling of platform selection when using the cmake-gui tool to build on Windows. The generator expects `Win64` but the GUI only provides `x64` as an option, which raises an error. This fix only raises an error if the platform is `Win32` instead, allowing the generation of solution files to succeed. ([#4150](https://github.com/ripple/rippled/pull/4150))
- **Fix test failures with newer MSVC compilers on Windows** - Fixes some cases where the API handler code used string pointer comparisons, which may not work correctly with some versions of the MSVC compiler. ([#4149](https://github.com/ripple/rippled/pull/4149))
- **Update minimum Boost version to 1.71.0** - This release is compatible with Boost library versions 1.71.0 through 1.77.0. The build configuration and documentation have been updated to reflect this. ([#4134](https://github.com/ripple/rippled/pull/4134))
- **Fix unit test failures for DatabaseDownloader** - Increases a timeout in the `DatabaseDownloader` code and adjusts unit tests so that the code does not return spurious failures, and more data is logged if it does fail. ([#4021](https://github.com/ripple/rippled/pull/4021))
- **Refactor relational database interface** - Improves code comments, naming, and organization of the module that interfaces with relational databases (such as the SQLite database used for tracking transaction history). ([#3965](https://github.com/ripple/rippled/pull/3965))
## Contributions
### GitHub
The public source code repository for `rippled` is hosted on GitHub at <https://github.com/ripple/rippled>.
We welcome contributions, big and small, and invite everyone to join the community of XRP Ledger developers and help us build the Internet of Value.
### Credits
The following people contributed directly to this release:
- Devon White <dwhite@ripple.com>
- Ed Hennis <ed@ripple.com>
- Gregory Popovitch <greg7mdp@gmail.com>
- Mark Travis <mtravis@ripple.com>
- Manoj Doshi <mdoshi@ripple.com>
- Nik Bougalis <nikb@bougalis.net>
- Richard Holland <richard.holland@starstone.co.nz>
- Scott Schurr <scott@ripple.com>
For a real-time view of all lifetime contributors, including links to the commits made by each, please visit the "Contributors" section of the GitHub repository: <https://github.com/ripple/rippled/graphs/contributors>.
We welcome external contributions and are excited to see the broader XRP Ledger community continue to grow and thrive.
# Change log
- API version 2 will now return `signer_lists` in the root of the `account_info` response, no longer nested under `account_data`.

1
src/ripple/app/main/Main.cpp
View File

@@ -134,6 +134,7 @@ printHelp(const po::options_description& desc)
"[strict]\n"
" account_tx accountID [ledger_min [ledger_max [limit "
"[offset]]]] [binary] [count] [descending]\n"
" book_changes [<ledger hash|id>]\n"
" book_offers <taker_pays> <taker_gets> [<taker [<ledger> "
"[<limit> [<proof> [<marker>]]]]]\n"
" can_delete [<ledgerid>|<ledgerhash>|now|always|never]\n"

47
src/ripple/app/misc/NetworkOPs.cpp
View File

@@ -63,6 +63,7 @@
#include <ripple/protocol/STParsedJSON.h>
#include <ripple/resource/Fees.h>
#include <ripple/resource/ResourceManager.h>
#include <ripple/rpc/BookChanges.h>
#include <ripple/rpc/DeliveredAmount.h>
#include <ripple/rpc/impl/RPCHelpers.h>
#include <boost/asio/ip/host_name.hpp>
@@ -503,6 +504,11 @@ public:
bool
unsubLedger(std::uint64_t uListener) override;
bool
subBookChanges(InfoSub::ref ispListener) override;
bool
unsubBookChanges(std::uint64_t uListener) override;
bool
subServer(InfoSub::ref ispListener, Json::Value& jvResult, bool admin)
override;
@@ -744,9 +750,10 @@ private:
sValidations, // Received validations.
sPeerStatus, // Peer status changes.
sConsensusPhase, // Consensus phase
sBookChanges, // Per-ledger order book changes
sLastEntry = sConsensusPhase // as this name implies, any new entry
// must be ADDED ABOVE this one
sLastEntry = sBookChanges // as this name implies, any new entry
// must be ADDED ABOVE this one
};
std::array<SubMapType, SubTypes::sLastEntry + 1> mStreamMaps;
@@ -2964,6 +2971,24 @@ NetworkOPsImp::pubLedger(std::shared_ptr<ReadView const> const& lpAccepted)
}
}
if (!mStreamMaps[sBookChanges].empty())
{
Json::Value jvObj = ripple::RPC::computeBookChanges(lpAccepted);
auto it = mStreamMaps[sBookChanges].begin();
while (it != mStreamMaps[sBookChanges].end())
{
InfoSub::pointer p = it->second.lock();
if (p)
{
p->send(jvObj, true);
++it;
}
else
it = mStreamMaps[sBookChanges].erase(it);
}
}
{
static bool firstTime = true;
if (firstTime)
@@ -3942,6 +3967,16 @@ NetworkOPsImp::subLedger(InfoSub::ref isrListener, Json::Value& jvResult)
.second;
}
// <-- bool: true=added, false=already there
bool
NetworkOPsImp::subBookChanges(InfoSub::ref isrListener)
{
std::lock_guard sl(mSubLock);
return mStreamMaps[sBookChanges]
.emplace(isrListener->getSeq(), isrListener)
.second;
}
// <-- bool: true=erased, false=was not there
bool
NetworkOPsImp::unsubLedger(std::uint64_t uSeq)
@@ -3950,6 +3985,14 @@ NetworkOPsImp::unsubLedger(std::uint64_t uSeq)
return mStreamMaps[sLedger].erase(uSeq);
}
// <-- bool: true=erased, false=was not there
bool
NetworkOPsImp::unsubBookChanges(std::uint64_t uSeq)
{
std::lock_guard sl(mSubLock);
return mStreamMaps[sBookChanges].erase(uSeq);
}
// <-- bool: true=added, false=already there
bool
NetworkOPsImp::subManifests(InfoSub::ref isrListener)

2
src/ripple/basics/MathUtilities.h
View File

@@ -21,7 +21,7 @@
#define RIPPLE_BASICS_MATHUTILITIES_H_INCLUDED
#include <algorithm>
#include <assert.h>
#include <cassert>
#include <cstddef>
namespace ripple {

1
src/ripple/beast/utility/rngfill.h
View File

@@ -21,6 +21,7 @@
#define BEAST_RANDOM_RNGFILL_H_INCLUDED
#include <array>
#include <cassert>
#include <cstdint>
#include <cstring>
#include <type_traits>

5
src/ripple/net/InfoSub.h
View File

@@ -128,6 +128,11 @@ public:
virtual bool
unsubLedger(std::uint64_t uListener) = 0;
virtual bool
subBookChanges(ref ispListener) = 0;
virtual bool
unsubBookChanges(std::uint64_t uListener) = 0;
virtual bool
subManifests(ref ispListener) = 0;
virtual bool

1
src/ripple/net/impl/RPCCall.cpp
View File

@@ -1324,6 +1324,7 @@ public:
{"account_objects", &RPCParser::parseAccountItems, 1, 5},
{"account_offers", &RPCParser::parseAccountItems, 1, 4},
{"account_tx", &RPCParser::parseAccountTransactions, 1, 8},
{"book_changes", &RPCParser::parseLedgerId, 1, 1},
{"book_offers", &RPCParser::parseBookOffers, 2, 7},
{"can_delete", &RPCParser::parseCanDelete, 0, 1},
{"channel_authorize", &RPCParser::parseChannelAuthorize, 3, 4},

2
src/ripple/protocol/impl/BuildInfo.cpp
View File

@@ -33,7 +33,7 @@ namespace BuildInfo {
// and follow the format described at http://semver.org/
//------------------------------------------------------------------------------
// clang-format off
char const* const versionString = "1.9.1-rc1"
char const* const versionString = "1.9.1"
// clang-format on
"-hooks"

8
src/ripple/protocol/jss.h
View File

@@ -172,11 +172,13 @@ JSS(build_path); // in: TransactionSign
JSS(build_version); // out: NetworkOPs
JSS(cancel_after); // out: AccountChannels
JSS(can_delete); // out: CanDelete
JSS(changes); // out: BookChanges
JSS(channel_id); // out: AccountChannels
JSS(channels); // out: AccountChannels
JSS(check); // in: AccountObjects
JSS(check_nodes); // in: LedgerCleaner
JSS(clear); // in/out: FetchInfo
JSS(close); // out: BookChanges
JSS(close_flags); // out: LedgerToJson
JSS(close_time); // in: Application, out: NetworkOPs,
// RCLCxPeerPos, LedgerToJson
@@ -199,6 +201,8 @@ JSS(converge_time_s); // out: NetworkOPs
JSS(cookie); // out: NetworkOPs
JSS(count); // in: AccountTx*, ValidatorList
JSS(counters); // in/out: retrieve counters
JSS(cur_a); // out: BookChanges
JSS(cur_b); // out: BookChanges
JSS(currentShard); // out: NodeToShardStatus
JSS(currentShardIndex); // out: NodeToShardStatus
JSS(currency); // in: paths/PathRequest, STAmount
@@ -289,6 +293,7 @@ JSS(hashes); // in: AccountObjects
JSS(have_header); // out: InboundLedger
JSS(have_state); // out: InboundLedger
JSS(have_transactions); // out: InboundLedger
JSS(high); // out: BookChanges
JSS(highest_sequence); // out: AccountInfo
JSS(highest_ticket); // out: AccountInfo
JSS(historical_perminute); // historical_perminute.
@@ -371,6 +376,7 @@ JSS(load_fee); // out: LoadFeeTrackImp, NetworkOPs
JSS(local); // out: resource/Logic.h
JSS(local_txs); // out: GetCounts
JSS(local_static_keys); // out: ValidatorList
JSS(low); // out: BookChanges
JSS(lowest_sequence); // out: AccountInfo
JSS(lowest_ticket); // out: AccountInfo
JSS(majority); // out: RPC feature
@@ -649,6 +655,8 @@ JSS(validator_sites); // out: ValidatorSites
JSS(value); // out: STAmount
JSS(version); // out: RPCVersion
JSS(vetoed); // out: AmendmentTableImpl
JSS(vol_a); // out: BookChanges
JSS(vol_b); // out: BookChanges
JSS(vote); // in: Feature
JSS(warning); // rpc:
JSS(warnings); // out: server_info, server_state

213
src/ripple/rpc/BookChanges.h Normal file
View File

@@ -0,0 +1,213 @@
//------------------------------------------------------------------------------
/*
This file is part of rippled: https://github.com/ripple/rippled
Copyright (c) 2019 Ripple Labs Inc.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
#ifndef RIPPLE_RPC_BOOKCHANGES_H_INCLUDED
#define RIPPLE_RPC_BOOKCAHNGES_H_INCLUDED
namespace Json {
class Value;
}
namespace ripple {
class ReadView;
class Transaction;
class TxMeta;
class STTx;
namespace RPC {
template <class L>
Json::Value
computeBookChanges(std::shared_ptr<L const> const& lpAccepted)
{
std::map<
std::string,
std::tuple<
STAmount, // side A volume
STAmount, // side B volume
STAmount, // high rate
STAmount, // low rate
STAmount, // open rate
STAmount // close rate
>>
tally;
for (auto& tx : lpAccepted->txs)
{
if (!tx.first || !tx.second ||
!tx.first->isFieldPresent(sfTransactionType))
continue;
std::optional<uint32_t> offerCancel;
uint16_t tt = tx.first->getFieldU16(sfTransactionType);
switch (tt)
{
case ttOFFER_CANCEL:
case ttOFFER_CREATE: {
if (tx.first->isFieldPresent(sfOfferSequence))
offerCancel = tx.first->getFieldU32(sfOfferSequence);
break;
}
// in future if any other ways emerge to cancel an offer
// this switch makes them easy to add
default:
break;
}
for (auto const& node : tx.second->getFieldArray(sfAffectedNodes))
{
SField const& metaType = node.getFName();
uint16_t nodeType = node.getFieldU16(sfLedgerEntryType);
// we only care about ltOFFER objects being modified or
// deleted
if (nodeType != ltOFFER || metaType == sfCreatedNode)
continue;
// if either FF or PF are missing we can't compute
// but generally these are cancelled rather than crossed
// so skipping them is consistent
if (!node.isFieldPresent(sfFinalFields) ||
!node.isFieldPresent(sfPreviousFields))
continue;
STObject& finalFields = (const_cast<STObject&>(node))
.getField(sfFinalFields)
.downcast<STObject>();
STObject& previousFields = (const_cast<STObject&>(node))
.getField(sfPreviousFields)
.downcast<STObject>();
// defensive case that should never be hit
if (!finalFields.isFieldPresent(sfTakerGets) ||
!finalFields.isFieldPresent(sfTakerPays) ||
!previousFields.isFieldPresent(sfTakerGets) ||
!previousFields.isFieldPresent(sfTakerPays))
continue;
// filter out any offers deleted by explicit offer cancels
if (metaType == sfDeletedNode && offerCancel &&
finalFields.getFieldU32(sfSequence) == *offerCancel)
continue;
// compute the difference in gets and pays actually
// affected onto the offer
STAmount deltaGets = finalFields.getFieldAmount(sfTakerGets) -
previousFields.getFieldAmount(sfTakerGets);
STAmount deltaPays = finalFields.getFieldAmount(sfTakerPays) -
previousFields.getFieldAmount(sfTakerPays);
std::string g{to_string(deltaGets.issue())};
std::string p{to_string(deltaPays.issue())};
bool const noswap =
isXRP(deltaGets) ? true : (isXRP(deltaPays) ? false : (g < p));
STAmount first = noswap ? deltaGets : deltaPays;
STAmount second = noswap ? deltaPays : deltaGets;
// defensively programmed, should (probably) never happen
if (second == beast::zero)
continue;
STAmount rate = divide(first, second, noIssue());
if (first < beast::zero)
first = -first;
if (second < beast::zero)
second = -second;
std::stringstream ss;
if (noswap)
ss << g << "|" << p;
else
ss << p << "|" << g;
std::string key{ss.str()};
if (tally.find(key) == tally.end())
tally[key] = {
first, // side A vol
second, // side B vol
rate, // high
rate, // low
rate, // open
rate // close
};
else
{
// increment volume
auto& entry = tally[key];
std::get<0>(entry) += first; // side A vol
std::get<1>(entry) += second; // side B vol
if (std::get<2>(entry) < rate) // high
std::get<2>(entry) = rate;
if (std::get<3>(entry) > rate) // low
std::get<3>(entry) = rate;
std::get<5>(entry) = rate; // close
}
}
}
Json::Value jvObj(Json::objectValue);
jvObj[jss::type] = "bookChanges";
jvObj[jss::ledger_index] = lpAccepted->info().seq;
jvObj[jss::ledger_hash] = to_string(lpAccepted->info().hash);
jvObj[jss::ledger_time] = Json::Value::UInt(
lpAccepted->info().closeTime.time_since_epoch().count());
jvObj[jss::changes] = Json::arrayValue;
for (auto const& entry : tally)
{
Json::Value& inner = jvObj[jss::changes].append(Json::objectValue);
STAmount volA = std::get<0>(entry.second);
STAmount volB = std::get<1>(entry.second);
inner[jss::cur_a] =
(isXRP(volA) ? "XRP_drops" : to_string(volA.issue()));
inner[jss::cur_b] =
(isXRP(volB) ? "XRP_drops" : to_string(volB.issue()));
inner[jss::vol_a] =
(isXRP(volA) ? to_string(volA.xrp()) : to_string(volA.iou()));
inner[jss::vol_b] =
(isXRP(volB) ? to_string(volB.xrp()) : to_string(volB.iou()));
inner[jss::high] = to_string(std::get<2>(entry.second).iou());
inner[jss::low] = to_string(std::get<3>(entry.second).iou());
inner[jss::open] = to_string(std::get<4>(entry.second).iou());
inner[jss::close] = to_string(std::get<5>(entry.second).iou());
}
return jvObj;
}
} // namespace RPC
} // namespace ripple
#endif

13
src/ripple/rpc/handlers/BookOffers.cpp
View File

@@ -26,6 +26,7 @@
#include <ripple/protocol/UintTypes.h>
#include <ripple/protocol/jss.h>
#include <ripple/resource/Fees.h>
#include <ripple/rpc/BookChanges.h>
#include <ripple/rpc/Context.h>
#include <ripple/rpc/impl/RPCHelpers.h>
@@ -200,4 +201,16 @@ doBookOffers(RPC::JsonContext& context)
return jvResult;
}
Json::Value
doBookChanges(RPC::JsonContext& context)
{
auto res = RPC::getLedgerByContext(context);
if (std::holds_alternative<Json::Value>(res))
return std::get<Json::Value>(res);
return RPC::computeBookChanges(
std::get<std::shared_ptr<Ledger const>>(res));
}
} // namespace ripple

2
src/ripple/rpc/handlers/Handlers.h
View File

@@ -45,6 +45,8 @@ doAccountTxJson(RPC::JsonContext&);
Json::Value
doBookOffers(RPC::JsonContext&);
Json::Value
doBookChanges(RPC::JsonContext&);
Json::Value
doBlackList(RPC::JsonContext&);
Json::Value
doCanDelete(RPC::JsonContext&);

123
src/ripple/rpc/handlers/LedgerRequest.cpp
View File

@@ -26,7 +26,9 @@
#include <ripple/protocol/jss.h>
#include <ripple/resource/Fees.h>
#include <ripple/rpc/Context.h>
#include <ripple/rpc/impl/RPCHelpers.h>
#include <ripple/rpc/impl/Tuning.h>
#include <variant>
namespace ripple {
@@ -37,122 +39,17 @@ namespace ripple {
Json::Value
doLedgerRequest(RPC::JsonContext& context)
{
if (context.app.config().reporting())
return rpcError(rpcREPORTING_UNSUPPORTED);
auto res = getLedgerByContext(context);
auto const hasHash = context.params.isMember(jss::ledger_hash);
auto const hasIndex = context.params.isMember(jss::ledger_index);
std::uint32_t ledgerIndex = 0;
if (std::holds_alternative<Json::Value>(res))
return std::get<Json::Value>(res);
auto& ledgerMaster = context.app.getLedgerMaster();
LedgerHash ledgerHash;
auto const& ledger = std::get<std::shared_ptr<Ledger const>>(res);
if ((hasHash && hasIndex) || !(hasHash || hasIndex))
{
return RPC::make_param_error(
"Exactly one of ledger_hash and ledger_index can be set.");
}
context.loadType = Resource::feeHighBurdenRPC;
if (hasHash)
{
auto const& jsonHash = context.params[jss::ledger_hash];
if (!jsonHash.isString() || !ledgerHash.parseHex(jsonHash.asString()))
return RPC::invalid_field_error(jss::ledger_hash);
}
else
{
auto const& jsonIndex = context.params[jss::ledger_index];
if (!jsonIndex.isInt())
return RPC::invalid_field_error(jss::ledger_index);
// We need a validated ledger to get the hash from the sequence
if (ledgerMaster.getValidatedLedgerAge() >
RPC::Tuning::maxValidatedLedgerAge)
{
if (context.apiVersion == 1)
return rpcError(rpcNO_CURRENT);
return rpcError(rpcNOT_SYNCED);
}
ledgerIndex = jsonIndex.asInt();
auto ledger = ledgerMaster.getValidatedLedger();
if (ledgerIndex >= ledger->info().seq)
return RPC::make_param_error("Ledger index too large");
if (ledgerIndex <= 0)
return RPC::make_param_error("Ledger index too small");
auto const j = context.app.journal("RPCHandler");
// Try to get the hash of the desired ledger from the validated ledger
auto neededHash = hashOfSeq(*ledger, ledgerIndex, j);
if (!neededHash)
{
// Find a ledger more likely to have the hash of the desired ledger
auto const refIndex = getCandidateLedger(ledgerIndex);
auto refHash = hashOfSeq(*ledger, refIndex, j);
assert(refHash);
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 = context.app.getInboundLedgers().acquire(
*refHash, refIndex, InboundLedger::Reason::GENERIC))
{
Json::Value jvResult = RPC::make_error(
rpcLGR_NOT_FOUND,
"acquiring ledger containing requested index");
jvResult[jss::acquiring] =
getJson(LedgerFill(*il, &context));
return jvResult;
}
if (auto il = context.app.getInboundLedgers().find(*refHash))
{
Json::Value jvResult = RPC::make_error(
rpcLGR_NOT_FOUND,
"acquiring ledger containing requested index");
jvResult[jss::acquiring] = il->getJson(0);
return jvResult;
}
// Likely the app is shutting down
return Json::Value();
}
neededHash = hashOfSeq(*ledger, ledgerIndex, j);
}
assert(neededHash);
ledgerHash = neededHash ? *neededHash : beast::zero; // kludge
}
// Try to get the desired ledger
// Verify all nodes even if we think we have it
auto ledger = context.app.getInboundLedgers().acquire(
ledgerHash, ledgerIndex, InboundLedger::Reason::GENERIC);
// In standalone mode, accept the ledger from the ledger cache
if (!ledger && context.app.config().standalone())
ledger = ledgerMaster.getLedgerByHash(ledgerHash);
if (ledger)
{
// We already had the entire ledger verified/acquired
Json::Value jvResult;
jvResult[jss::ledger_index] = ledger->info().seq;
addJson(jvResult, {*ledger, &context, 0});
return jvResult;
}
if (auto il = context.app.getInboundLedgers().find(ledgerHash))
return il->getJson(0);
return RPC::make_error(
rpcNOT_READY, "findCreate failed to return an inbound ledger");
Json::Value jvResult;
jvResult[jss::ledger_index] = ledger->info().seq;
addJson(jvResult, {*ledger, &context, 0});
return jvResult;
}
} // namespace ripple

4
src/ripple/rpc/handlers/Subscribe.cpp
View File

@@ -136,6 +136,10 @@ doSubscribe(RPC::JsonContext& context)
{
context.netOps.subLedger(ispSub, jvResult);
}
else if (streamName == "book_changes")
{
context.netOps.subBookChanges(ispSub);
}
else if (streamName == "manifests")
{
context.netOps.subManifests(ispSub);

1
src/ripple/rpc/impl/Handler.cpp
View File

@@ -73,6 +73,7 @@ Handler const handlerArray[]{
{"account_offers", byRef(&doAccountOffers), Role::USER, NO_CONDITION},
{"account_tx", byRef(&doAccountTxJson), Role::USER, NO_CONDITION},
{"blacklist", byRef(&doBlackList), Role::ADMIN, NO_CONDITION},
{"book_changes", byRef(&doBookChanges), Role::USER, NO_CONDITION},
{"book_offers", byRef(&doBookOffers), Role::USER, NO_CONDITION},
{"can_delete", byRef(&doCanDelete), Role::ADMIN, NO_CONDITION},
{"channel_authorize", byRef(&doChannelAuthorize), Role::USER, NO_CONDITION},

5
src/ripple/rpc/impl/RPCHandler.cpp
View File

@@ -17,7 +17,9 @@
*/
//==============================================================================
#include <ripple/app/ledger/InboundLedgers.h>
#include <ripple/app/ledger/LedgerMaster.h>
#include <ripple/app/ledger/LedgerToJson.h>
#include <ripple/app/main/Application.h>
#include <ripple/app/misc/NetworkOPs.h>
#include <ripple/app/reporting/P2pProxy.h>
@@ -30,14 +32,17 @@
#include <ripple/json/to_string.h>
#include <ripple/net/InfoSub.h>
#include <ripple/net/RPCErr.h>
#include <ripple/protocol/ErrorCodes.h>
#include <ripple/protocol/jss.h>
#include <ripple/resource/Fees.h>
#include <ripple/rpc/Context.h>
#include <ripple/rpc/RPCHandler.h>
#include <ripple/rpc/Role.h>
#include <ripple/rpc/impl/Handler.h>
#include <ripple/rpc/impl/Tuning.h>
#include <atomic>
#include <chrono>
#include <variant>
namespace ripple {
namespace RPC {

116
src/ripple/rpc/impl/RPCHelpers.cpp
View File

@@ -18,6 +18,7 @@
//==============================================================================
#include <ripple/app/ledger/LedgerMaster.h>
#include <ripple/app/ledger/LedgerToJson.h>
#include <ripple/app/ledger/OpenLedger.h>
#include <ripple/app/misc/Transaction.h>
#include <ripple/app/paths/TrustLine.h>
@@ -31,6 +32,7 @@
#include <ripple/rpc/impl/RPCHelpers.h>
#include <boost/algorithm/string/case_conv.hpp>
#include <ripple/resource/Fees.h>
#include <ripple/rpc/impl/GRPCHelpers.h>
namespace ripple {
@@ -1039,5 +1041,119 @@ getAPIVersionNumber(Json::Value const& jv, bool betaEnabled)
return requestedVersion.asUInt();
}
std::variant<std::shared_ptr<Ledger const>, Json::Value>
getLedgerByContext(RPC::JsonContext& context)
{
if (context.app.config().reporting())
return rpcError(rpcREPORTING_UNSUPPORTED);
auto const hasHash = context.params.isMember(jss::ledger_hash);
auto const hasIndex = context.params.isMember(jss::ledger_index);
std::uint32_t ledgerIndex = 0;
auto& ledgerMaster = context.app.getLedgerMaster();
LedgerHash ledgerHash;
if ((hasHash && hasIndex) || !(hasHash || hasIndex))
{
return RPC::make_param_error(
"Exactly one of ledger_hash and ledger_index can be set.");
}
context.loadType = Resource::feeHighBurdenRPC;
if (hasHash)
{
auto const& jsonHash = context.params[jss::ledger_hash];
if (!jsonHash.isString() || !ledgerHash.parseHex(jsonHash.asString()))
return RPC::invalid_field_error(jss::ledger_hash);
}
else
{
auto const& jsonIndex = context.params[jss::ledger_index];
if (!jsonIndex.isInt())
return RPC::invalid_field_error(jss::ledger_index);
// We need a validated ledger to get the hash from the sequence
if (ledgerMaster.getValidatedLedgerAge() >
RPC::Tuning::maxValidatedLedgerAge)
{
if (context.apiVersion == 1)
return rpcError(rpcNO_CURRENT);
return rpcError(rpcNOT_SYNCED);
}
ledgerIndex = jsonIndex.asInt();
auto ledger = ledgerMaster.getValidatedLedger();
if (ledgerIndex >= ledger->info().seq)
return RPC::make_param_error("Ledger index too large");
if (ledgerIndex <= 0)
return RPC::make_param_error("Ledger index too small");
auto const j = context.app.journal("RPCHandler");
// Try to get the hash of the desired ledger from the validated ledger
auto neededHash = hashOfSeq(*ledger, ledgerIndex, j);
if (!neededHash)
{
// Find a ledger more likely to have the hash of the desired ledger
auto const refIndex = getCandidateLedger(ledgerIndex);
auto refHash = hashOfSeq(*ledger, refIndex, j);
assert(refHash);
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 = context.app.getInboundLedgers().acquire(
*refHash, refIndex, InboundLedger::Reason::GENERIC))
{
Json::Value jvResult = RPC::make_error(
rpcLGR_NOT_FOUND,
"acquiring ledger containing requested index");
jvResult[jss::acquiring] =
getJson(LedgerFill(*il, &context));
return jvResult;
}
if (auto il = context.app.getInboundLedgers().find(*refHash))
{
Json::Value jvResult = RPC::make_error(
rpcLGR_NOT_FOUND,
"acquiring ledger containing requested index");
jvResult[jss::acquiring] = il->getJson(0);
return jvResult;
}
// Likely the app is shutting down
return Json::Value();
}
neededHash = hashOfSeq(*ledger, ledgerIndex, j);
}
assert(neededHash);
ledgerHash = neededHash ? *neededHash : beast::zero; // kludge
}
// Try to get the desired ledger
// Verify all nodes even if we think we have it
auto ledger = context.app.getInboundLedgers().acquire(
ledgerHash, ledgerIndex, InboundLedger::Reason::GENERIC);
// In standalone mode, accept the ledger from the ledger cache
if (!ledger && context.app.config().standalone())
ledger = ledgerMaster.getLedgerByHash(ledgerHash);
if (ledger)
return ledger;
if (auto il = context.app.getInboundLedgers().find(ledgerHash))
return il->getJson(0);
return RPC::make_error(
rpcNOT_READY, "findCreate failed to return an inbound ledger");
}
} // namespace RPC
} // namespace ripple

6
src/ripple/rpc/impl/RPCHelpers.h
View File

@@ -31,6 +31,7 @@
#include <ripple/rpc/impl/Tuning.h>
#include <optional>
#include <org/xrpl/rpc/v1/xrp_ledger.pb.h>
#include <variant>
namespace Json {
class Value;
@@ -306,6 +307,11 @@ chooseLedgerEntryType(Json::Value const& params);
unsigned int
getAPIVersionNumber(const Json::Value& value, bool betaEnabled);
/** Return a ledger based on ledger_hash or ledger_index,
or an RPC error */
std::variant<std::shared_ptr<Ledger const>, Json::Value>
getLedgerByContext(RPC::JsonContext& context);
} // namespace RPC
} // namespace ripple