ripple Namespace Reference

Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm. More...

Namespaces
	base64
	BuildInfo
	Versioning information for this build.
	compression
	compression_algorithms
	CrawlOptions
	cryptoconditions
	detail
	feeunit
	InnerObjectFormatsUnitTestDetail
	jss
	keylet
	Keylet computation funclets.
	ledger_trie_detail
	LedgerReplayParameters
	metrics
	NodeStore
	openssl
	path
	PeerFinder
	perf
	Dummy class for unit tests.
	reduce_relay
	Resource
	RPC
	RPCCall
	Processes Ripple RPC calls.
	STParsedJSONDetail
	test
	tests
	Tuning
	unl

Classes
class	AbstractFetchPackContainer
	An interface facilitating retrieval of fetch packs without an application or ledgermaster object. More...
class	AcceptedLedger
	A ledger that has become irrevocable. More...
class	AcceptedLedgerTx
	A transaction that is in a closed ledger. More...
class	AccountCurrencies_test
class	AccountIDCache
	Caches the base58 representations of AccountIDs. More...
class	AccountRootsNotDeleted
	Invariant: we cannot remove an account ledger entry. More...
class	AccountSet_test
class	AccountStateSF
class	AccountTxPaging_test
struct	AcquireShardSeqsHash
class	AmendmentBlocked_test
class	AmendmentSet
	The status of all amendments requested in a given window. More...
struct	AmendmentState
	Current state of an amendment. More...
class	AmendmentTable
	The amendment table stores the list of enabled and potential amendments. More...
class	AmendmentTable_test
class	AmendmentTableImpl
	Track the list of "amendments". More...
struct	AmountSpec
class	Application
class	ApplicationImp
class	Apply_test
class	ApplyContext
	State information when applying a tx. More...
class	ApplyView
	Writeable view to a ledger, for applying a transaction. More...
class	ApplyViewImpl
	Editable, discardable view that can build metadata for one tx. More...
class	AsyncCallData
class	AsyncObject
	Mix-in to track when all pending I/O is complete. More...
struct	bad_expected_access
	Expected is an approximation of std::expected (hoped for in C++23) More...
class	base64_test
class	base_uint
	Integers of any length that is a multiple of 32-bits. More...
class	BaseHTTPPeer
	Represents an active connection. More...
class	BasePeer
class	BaseWSPeer
	Represents an active WebSocket connection. More...
class	basic_semaphore
class	BasicConfig
	Holds unparsed configuration information. More...
class	BasicTaker
	State for the active party during order book or payment operations. More...
class	Book
	Specifies an order book. More...
class	BookDirs
class	BookListeners
	Listen to public/subscribe messages from a book. More...
class	BookOfferCrossingStep
class	BookPaymentStep
class	BookStep
class	BookTip
	Iterates and consumes raw offers in an order book. More...
class	Buffer
	Like std::vector<char> but better. More...
class	BuildInfo_test
class	CachedSLEs
	Caches SLEs by their digest. More...
class	CachedView
	Wraps a DigestAwareReadView to provide caching. More...
class	CancelCheck
class	CancelOffer
class	CanCvtToNotTEC
class	CanCvtToNotTEC< TEFcodes >
class	CanCvtToNotTEC< TELcodes >
class	CanCvtToNotTEC< TEMcodes >
class	CanCvtToNotTEC< TERcodes >
class	CanCvtToNotTEC< TEScodes >
class	CanCvtToTER
class	CanCvtToTER< NotTEC >
class	CanCvtToTER< TECcodes >
class	CanCvtToTER< TEFcodes >
class	CanCvtToTER< TELcodes >
class	CanCvtToTER< TEMcodes >
class	CanCvtToTER< TERcodes >
class	CanCvtToTER< TEScodes >
class	CanonicalTXSet
	Holds transactions which were deferred to the next pass of consensus. More...
class	CashCheck
class	Change
class	Check_test
class	Checkpointer
class	CheckpointersCollection
class	ClosureCounter
	The role of a ClosureCounter is to assist in shutdown by letting callers wait for the completion of callbacks (of a single type signature) that they previously scheduled. More...
class	Cluster
class	ClusterNode
class	CollectorManager
	Provides the beast::insight::Collector service. More...
class	CollectorManagerImp
class	Config
class	Config_test
struct	ConfigSection
class	ConnectAttempt
	Manages an outbound connection attempt. More...
class	Consensus
	Generic implementation of consensus algorithm. More...
struct	ConsensusCloseTimes
	Stores the set of initial close times. More...
struct	ConsensusParms
	Consensus algorithm parameters. More...
class	ConsensusProposal
	Represents a proposed position taken during a round of consensus. More...
struct	ConsensusResult
	Encapsulates the result of consensus. More...
class	ConsensusTimer
	Measures the duration of phases of consensus. More...
class	ConsensusTransSetSF
class	contract_test
struct	Coro_create_t
class	CountedObject
	Tracks the number of instances of an object. More...
class	CountedObjects
	Manages all counted object types. More...
struct	create_genesis_t
class	CreateCheck
class	CreateOffer
	Transactor specialized for creating offers in the ledger. More...
class	CreateTicket
class	CryptoPRNG_test
class	csprng_engine
	A cryptographically secure random number engine. More...
struct	DatabaseBody
class	DatabaseCon
class	DatabaseDownloader
struct	DatabasePair
struct	DatabasePairValid
class	DBConfig
	DBConfig is used when a client wants to delay opening a soci::session after parsing the config parameters. More...
class	DebugSink
class	DecayingSample
	Sampling function using exponential decay to provide a continuous value. More...
class	DecayWindow
	Sampling function using exponential decay to provide a continuous value. More...
class	DeleteAccount
class	DepositPreauth
class	DigestAwareReadView
	ReadView that associates keys with digests. More...
class	Dir
class	DirectIOfferCrossingStep
class	DirectIPaymentStep
class	DirectStepI
class	Discrepancy_test
class	DisputedTx
	A transaction discovered to be in dispute during consensus. More...
class	Door
	A listening socket. More...
class	DummyPeerSet
struct	EitherAmount
struct	equal_to
class	EscrowCancel
class	EscrowCreate
class	EscrowFinish
class	ETLLoadBalancer
	This class is used to manage connections to transaction processing processes This class spawns a listener for each etl source, which listens to messages on the ledgers stream (to keep track of which ledgers have been validated by the network, and the range of ledgers each etl source has). More...
class	ETLSource
	This class manages a connection to a single ETL source. More...
class	Expected
class	Expected< void, E >
class	Family
class	Feature_test
class	FeatureBitset
struct	Fees
	Reflects the fee settings for a particular ledger. More...
class	FeeVote
	Manager to process fee votes. More...
class	FeeVoteImpl
class	FileUtilities_test
class	FlowOfferStream
	Presents and consumes the offers in an order book. More...
class	Freeze_test
class	GetCounts_test
class	GRPCServer
class	GRPCServerImpl
struct	Handoff
	Used to indicate the result of a server connection handoff. More...
class	hardened_hash
	Seed functor once per construction. More...
class	hardened_hash_test
class	HashRouter
	Routing table for objects identified by hash. More...
class	HTTPClient
	Provides an asynchronous HTTP client implementation with optional SSL. More...
class	HTTPClientImp
class	HTTPClientSSLContext
class	HTTPDownloader
	Provides an asynchronous HTTP[S] file downloader. More...
class	HTTPStream
class	InboundLedger
class	InboundLedgers
	Manages the lifetime of inbound ledgers. More...
class	InboundLedgersImp
class	InboundTransactions
	Manages the acquisition and lifetime of transaction sets. More...
class	InboundTransactionSet
class	InboundTransactionsImp
class	InfoSub
	Manages a client's subscription to data feeds. More...
class	InnerObjectFormats
	Manages the list of known inner object formats. More...
class	InnerObjectFormatsParsedJSON_test
class	InnerObjectFormatsSerializer_test
class	InvariantChecker_PROTOTYPE
	Prototype for invariant check implementations. More...
class	Invariants_test
class	io_list
	Manages a set of objects performing asynchronous I/O. More...
class	IOUAmount
	Floating point representation of amounts with high dynamic range. More...
class	IOUAmount_test
class	Issue
	A currency issued by an account. More...
class	Issue_test
class	Job
class	JobQueue
	A pool of threads to perform work. More...
struct	JobTypeData
class	JobTypeInfo
	Holds all the 'static' information about a job, which does not change. More...
class	JobTypes
struct	json_body
	Body that holds JSON. More...
struct	json_value_test
class	JsonPropertyStream
	A PropertyStream::Sink which produces a Json::Value of type objectValue. More...
class	KeyCache
	Maintains a cache of keys with no associated data. More...
class	KeyCache_test
struct	KeyEqual
struct	Keylet
	A pair of SHAMap key and LedgerEntryType. More...
class	KnownFormats
	Manages a list of known formats. More...
class	KnownFormatToGRPC_test
class	Ledger
	Holds a ledger. More...
class	LedgerCleaner
	Check the ledger/transaction databases to make sure they have continuity. More...
class	LedgerCleanerImp
class	LedgerClosed_test
class	LedgerData_test
class	LedgerDeltaAcquire
	Manage the retrieval of a ledger delta (header and transactions) from the network. More...
class	LedgerEntryTypesMatch
	Invariant: corresponding modified ledger entries should match in type and added entries should be a valid type. More...
struct	LedgerFill
class	LedgerFormats
	Holds the list of known ledger entry formats. More...
struct	LedgerHashPair
class	LedgerHistory
	Retains historical ledgers. More...
class	LedgerHolder
	Hold a ledger in a thread-safe way. More...
struct	LedgerInfo
	Information about the notional ledger backing the view. More...
class	LedgerLoad_test
class	LedgerMaster
struct	LedgerRange
class	LedgerReplay
class	LedgerReplayer
	Manages the lifetime of ledger replay tasks. More...
class	LedgerReplayMsgHandler
class	LedgerReplayTask
class	LedgerRPC_test
class	LedgerTrie
	Ancestry trie of ledgers. More...
struct	less
class	LoadEvent
class	LoadFeeTrack
	Manages the current fee schedule. More...
class	LoadFeeTrack_test
class	LoadManager
	Manages load sources. More...
class	LoadMonitor
class	LocalTx
class	LocalTxs
class	LocalTxsImp
class	LocalValue
class	LockedSociSession
class	Logs
	Manages partitions for logging. More...
struct	Manifest
class	ManifestCache
	Remembers manifests with the highest sequence number. More...
struct	match_peer
	Select the specific peer. More...
class	Message
class	NegativeUNLVote
	Manager to create NegativeUNL votes. More...
class	NetClock
	Clock for measuring the network time. More...
class	NetworkOPs
	Provides server functionality for clients. More...
class	NetworkOPsImp
class	NetworkValidatedLedgers
	This datastructure is used to keep track of the sequence of the most recent ledger validated by the network. More...
class	NoBadOffers
	Invariant: offers should be for non-negative amounts and must not be XRP to XRP. More...
class	NodeFamily
class	NodeObject
	A simple object that the Ledger uses to store entries. More...
class	NodeStoreScheduler
	A NodeStore::Scheduler which uses the JobQueue. More...
class	NoRippleCheck_test
class	NoRippleCheckLimits_test
class	NoXRPTrustLines
	Invariant: Trust lines using XRP are not allowed. More...
class	NoZeroEscrow
	Invariant: an escrow entry must take a value between 0 and INITIAL_XRP drops exclusive. More...
class	OfferStream
	Presents and consumes the offers in an order book. More...
class	OfferStream_test
struct	open_ledger_t
	Open ledger construction tag. More...
class	OpenLedger
	Represents the open ledger. More...
struct	openssl_ripemd160_hasher
	Message digest functions used in the codebase. More...
struct	openssl_sha256_hasher
	SHA-256 digest. More...
struct	openssl_sha512_hasher
	SHA-512 digest. More...
class	OpenView
	Writable ledger view that accumulates state and tx changes. More...
struct	OptionaledField
	Indicate std::optional field semantics. More...
class	OrderBook
	Describes a serialized ledger entry for an order book. More...
class	OrderBookDB
class	Overlay
	Manages the set of connected peers. More...
class	OverlayImpl
class	OwnerInfo_test
struct	ParsedPort
struct	parsedURL
class	Pathfinder
	Calculates payment paths. More...
class	PathRequest
class	PathRequests
class	PayChanClaim
class	PayChanCreate
class	PayChanFund
class	Payment
class	PaymentSandbox
	A wrapper which makes credits unavailable to balances. More...
class	Peer
	Represents a peer connection in the overlay. More...
struct	peer_in_cluster
	Select all peers (except optional excluded) that are in our cluster. More...
struct	peer_in_set
	Select all peers that are in the specified set. More...
class	PeerImp
struct	PeerReservation
class	PeerReservationTable
class	Peers_test
class	PeerSet
	Supports data retrieval by managing a set of peers. More...
class	PeerSetBuilder
class	PeerSetBuilderImpl
class	PeerSetImpl
class	PendingSaves
	Keeps track of which ledgers haven't been fully saved. More...
class	PerfLog_test
class	PlainHTTPPeer
class	PlainWSPeer
struct	Port
	Configuration information for a Server listening port. More...
struct	PreclaimContext
	State information when determining if a tx is likely to claim a fee. More...
struct	PreclaimResult
	Describes the results of the preclaim check. More...
struct	PreflightContext
	State information when preflighting a tx. More...
struct	PreflightResult
	Describes the results of the preflight check. More...
class	Processor
class	ProtocolVersion_test
class	PublicKey
	A public key. More...
class	PublicKey_test
class	Quality_test
class	RangeSet_test
struct	Rate
	Represents a transfer rate. More...
class	RawStream
class	RawView
	Interface for ledger entry changes. More...
class	RCLCensorshipDetector
class	RCLConsensus
	Manages the generic consensus algorithm for use by the RCL. More...
class	RCLCxLedger
	Represents a ledger in RCLConsensus. More...
class	RCLCxPeerPos
	A peer's signed, proposed position for use in RCLConsensus. More...
class	RCLCxTx
	Represents a transaction in RCLConsensus. More...
class	RCLTxSet
	Represents a set of transactions in RCLConsensus. More...
class	RCLValidatedLedger
	Wraps a ledger instance for use in generic Validations LedgerTrie. More...
class	RCLValidation
	Wrapper over STValidation for generic Validation code. More...
class	RCLValidationsAdaptor
	Generic validations adaptor class for RCL. More...
class	ReadView
	A view into a ledger. More...
class	RelationalDBInterface
class	RelationalDBInterfacePostgres
class	RelationalDBInterfacePostgresImp
class	RelationalDBInterfaceSqlite
class	RelationalDBInterfaceSqliteImp
class	ReportingETL
	This class is responsible for continuously extracting data from a p2p node, and writing that data to the databases. More...
class	ReportingShouldProxy
class	Resolver
class	ResolverAsio
class	ResolverAsioImpl
class	RFC1751
struct	ripesha_hasher
	Returns the RIPEMD-160 digest of the SHA256 hash of the message. More...
class	RippleLineCache
class	RippleState
	Wraps a trust line SLE for convenience. More...
struct	RPCCallImp
class	RPCParser
class	RPCSub
	Subscription object for JSON RPC. More...
class	RPCSubImp
class	Rules
	Rules controlling protocol behavior. More...
class	Sandbox
	Discardable, editable view to a ledger. More...
struct	SavedState
class	scope_exit
class	scope_fail
class	scope_success
class	SecretKey
	A secret key. More...
class	SecretKey_test
class	Section
	Holds a collection of configuration values. More...
class	Seed
	Seeds are used to generate deterministic secret keys. More...
class	Seed_test
struct	send_always
	Sends a message to all peers. More...
struct	send_if_not_pred
	Sends a message to non-matching peers. More...
struct	send_if_pred
	Sends a message to match peers. More...
class	SeqEnforcer
	Enforce validation increasing sequence requirement. More...
class	SeqProxy
	A type that represents either a sequence value or a ticket value. More...
struct	SeqProxy_test
class	SerialIter
class	Serializer
class	Server
	A multi-protocol server. More...
class	ServerHandlerImp
class	ServerImpl
class	Session
	Persistent state information for a connection session. More...
class	SetAccount
class	SetRegularKey
class	SetRegularKey_test
class	SetSignerList
	See the README.md for an overview of the SetSignerList transaction that this class implements. More...
class	SetTrust
class	SField
	Identifies fields. More...
class	SHAMap
	A SHAMap is both a radix tree with a fan-out of 16 and a Merkle tree. More...
class	SHAMapAccountStateLeafNode
	A leaf node for a state object. More...
class	SHAMapAddNode
class	SHAMapHash
class	SHAMapInnerNode
class	SHAMapItem
class	SHAMapLeafNode
class	SHAMapMissingNode
class	SHAMapNodeID
	Identifies a node inside a SHAMap. More...
class	SHAMapStore
	class to create database, launch online delete thread, and related SQLite database More...
class	SHAMapStoreImp
class	SHAMapSyncFilter
class	SHAMapTreeNode
class	SHAMapTxLeafNode
	A leaf node for a transaction. More...
class	SHAMapTxPlusMetaLeafNode
	A leaf node for a transaction and its associated metadata. More...
class	ShardFamily
class	short_read_test
class	SignerEntries
class	SimpleWriter
	Deprecated: Writer that serializes a HTTP/1 message. More...
class	SkipListAcquire
	Manage the retrieval of a skip list in a ledger from the network. More...
class	Slice
	An immutable linear range of bytes. More...
class	SNTPClientImp
class	SNTPClock
	A clock based on system_clock and adjusted for SNTP. More...
class	SociDB_test
class	SOElement
	An element in a SOTemplate. More...
class	SOTemplate
	Defines the fields and their attributes within a STObject. More...
class	SpanTip
	The tip of a span of ledger ancestry. More...
class	SSLHTTPPeer
class	SSLStream
class	SSLWSPeer
class	STAccount
struct	STAccount_test
class	STAmount
class	STAmount_test
class	STAmountSO
	RAII class to set and restore the STAmount canonicalize switchover. More...
class	STArray
class	STBase
	A type which can be exported to a well known binary format. More...
class	STBitString
class	STBlob
class	Step
	A step in a payment path. More...
struct	STExchange
	Convert between serialized type U and C++ type T. More...
struct	STExchange< STBlob, Buffer >
struct	STExchange< STBlob, PublicKey >
struct	STExchange< STBlob, Slice >
struct	STExchange< STInteger< U >, T >
class	STInteger
class	STLedgerEntry
class	STObject
class	STObject_test
class	STParsedJSONArray
	Holds the serialized result of parsing an input JSON array. More...
class	STParsedJSONObject
	Holds the serialized result of parsing an input JSON object. More...
class	STPath
class	STPathElement
class	STPathSet
struct	StrandContext
	Context needed to build Strand Steps and for error checking. More...
struct	StrandResult
	Result of flow() execution of a single Strand. More...
class	StreambufWSMsg
class	StringUtilities_test
class	STTx
class	STTx_test
class	STValidation
class	STValidation_test
class	STVector256
class	tagged_integer
	A type-safe wrap around standard integral types. More...
class	TaggedCache
	Map/cache combination. More...
class	TaggedCache_test
class	TaggedPointer
	TaggedPointer is a combination of a pointer and a mask stored in the lowest two bits. More...
class	Taker
class	Taker_test
struct	TER_test
class	TERSubset
class	TestSuite
class	ThreadSafeQueue
	Generic thread-safe queue with an optional maximum size Note, we can't use a lockfree queue here, since we need the ability to wait for an element to be added or removed from the queue. More...
class	Ticket_test
class	TimeKeeper
	Manages various times used by the server. More...
class	TimeKeeperImpl
class	TimeoutCounter
	This class is an "active" object. More...
class	TOffer
class	TOfferBase
class	TOfferBase< STAmount, STAmount >
class	TOfferStreamBase
class	TrafficCount
class	Transaction
class	Transaction_test
class	TransactionAcquire
class	TransactionEntry_test
class	TransactionFeeCheck
	Invariant: We should never charge a transaction a negative fee or a fee that is larger than what the transaction itself specifies. More...
class	TransactionHistory_test
class	TransactionMaster
class	TransactionStateSF
class	Transactor
class	TrustAndBalance_test
struct	TrustChanges
	Changes in trusted nodes after updating validator list. More...
struct	TxArgs
class	TxConsequences
	Class describing the consequences to the account of applying a transaction if the transaction consumes the maximum XRP allowed. More...
class	TxFlag
	Transaction flags. More...
class	TxFormats
	Manages the list of known transaction formats. More...
class	TxMeta
class	TxQ
	Transaction Queue. More...
struct	TxResult
class	TxsRawView
	Interface for changing ledger entries with transactions. More...
struct	TypedField
	A field with a type known at compile time. More...
struct	types_test
class	Unexpected
class	unsigned_integer
class	UptimeClock
	Tracks program uptime to seconds precision. More...
struct	ValidationParms
	Timing parameters to control validation staleness and expiration. More...
class	Validations
	Maintains current and recent ledger validations. More...
struct	ValidatorBlobInfo
	Used to represent the information stored in the blobs_v2 Json array. More...
class	ValidatorKeys
	Validator keys and manifest as set in configuration file. More...
class	ValidatorList
class	ValidatorSite
struct	ValidatorToken
class	ValidNewAccountRoot
	Invariant: a new account root must be the consequence of a payment, must have the right starting sequence, and the payment may not create more than one new account root. More...
class	Version_test
struct	VisitData
class	Workers
	Workers is effectively a thread pool. More...
class	Workers_test
class	Writer
class	WSInfoSub
class	WSMsg
struct	WSSession
class	XRPAmount
class	XRPAmount_test
class	XRPBalanceChecks
	Invariant: An account XRP balance must be in XRP and take a value between 0 and INITIAL_XRP drops, inclusive. More...
class	XRPEndpointOfferCrossingStep
class	XRPEndpointPaymentStep
class	XRPEndpointStep
class	XRPNotCreated
	Invariant: A transaction must not create XRP and should only destroy the XRP fee. More...
class	ZeroCopyInputStream
	Implements ZeroCopyInputStream around a buffer sequence. More...
class	ZeroCopyOutputStream
	Implements ZeroCopyOutputStream around a Streambuf. More...

Typedefs
using	RCLValidations = Validations< RCLValidationsAdaptor >
	Alias for RCL-specific instantiation of generic Validations. More...
using	CachedLedger = CachedView< Ledger >
	A ledger wrapped in a CachedView. More...
using	OrderedTxs = CanonicalTXSet
using	NodeCache = TaggedCache< SHAMapHash, Blob >
using	TxnsData = RelationalDBInterface::AccountTxs
using	TxnsDataBinary = RelationalDBInterface::MetaTxsList
using	LedgerHash = RelationalDBInterface::LedgerHash
using	LedgerSequence = RelationalDBInterface::LedgerSequence
using	LedgerShortcut = RelationalDBInterface::LedgerShortcut
using	AccountTxMarker = RelationalDBInterface::AccountTxMarker
using	AccountTxArgs = RelationalDBInterface::AccountTxArgs
using	AccountTxResult = RelationalDBInterface::AccountTxResult
using	AccountTransactionsData = RelationalDBInterface::AccountTransactionsData
using	InvariantChecks = std::tuple< TransactionFeeCheck, AccountRootsNotDeleted, LedgerEntryTypesMatch, XRPBalanceChecks, XRPNotCreated, NoXRPTrustLines, NoBadOffers, NoZeroEscrow, ValidNewAccountRoot >
using	Offer = TOffer<>
using	uint128 = base_uint< 128 >
using	uint160 = base_uint< 160 >
using	uint256 = base_uint< 256 >
using	IniFileSections = std::map< std::string, std::vector< std::string > >
using	Blob = std::vector< unsigned char >
	Storage for linear binary data. More...
using	days = std::chrono::duration< int, std::ratio_multiply< std::chrono::hours::period, std::ratio< 24 > >>
using	weeks = std::chrono::duration< int, std::ratio_multiply< days::period, std::ratio< 7 > >>
using	Stopwatch = beast::abstract_clock< std::chrono::steady_clock >
	A clock for measuring elapsed time. More...
using	TestStopwatch = beast::manual_clock< std::chrono::steady_clock >
	A manual Stopwatch for unit tests. More...
template<class T >
using	FeeUnit = feeunit::TaggedFee< feeunit::feeunitTag, T >
using	FeeUnit32 = FeeUnit< std::uint32_t >
using	FeeUnit64 = FeeUnit< std::uint64_t >
template<class T >
using	FeeLevel = feeunit::TaggedFee< feeunit::feelevelTag, T >
using	FeeLevel64 = FeeLevel< std::uint64_t >
using	FeeLevelDouble = FeeLevel< double >
template<class T >
using	ClosedInterval = boost::icl::closed_interval< T >
	A closed interval over the domain T. More...
template<class T >
using	RangeSet = boost::icl::interval_set< T, std::less, ClosedInterval< T > >
	A set of closed intervals over the domain T. More...
template<class Key , class Value , class Hash = beast::uhash<>, class Pred = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key const, Value>>>
using	hash_map = std::unordered_map< Key, Value, Hash, Pred, Allocator >
template<class Key , class Value , class Hash = beast::uhash<>, class Pred = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key const, Value>>>
using	hash_multimap = std::unordered_multimap< Key, Value, Hash, Pred, Allocator >
template<class Value , class Hash = beast::uhash<>, class Pred = std::equal_to<Value>, class Allocator = std::allocator<Value>>
using	hash_set = std::unordered_set< Value, Hash, Pred, Allocator >
template<class Value , class Hash = beast::uhash<>, class Pred = std::equal_to<Value>, class Allocator = std::allocator<Value>>
using	hash_multiset = std::unordered_multiset< Value, Hash, Pred, Allocator >
using	strong_hash = beast::xxhasher
template<class Key , class Value , class Hash = hardened_hash<strong_hash>, class Pred = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key const, Value>>>
using	hardened_hash_map = std::unordered_map< Key, Value, Hash, Pred, Allocator >
template<class Key , class Value , class Hash = hardened_hash<strong_hash>, class Pred = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key const, Value>>>
using	hardened_hash_multimap = std::unordered_multimap< Key, Value, Hash, Pred, Allocator >
template<class Value , class Hash = hardened_hash<strong_hash>, class Pred = std::equal_to<Value>, class Allocator = std::allocator<Value>>
using	hardened_hash_set = std::unordered_set< Value, Hash, Pred, Allocator >
template<class Value , class Hash = hardened_hash<strong_hash>, class Pred = std::equal_to<Value>, class Allocator = std::allocator<Value>>
using	hardened_hash_multiset = std::unordered_multiset< Value, Hash, Pred, Allocator >
using	semaphore = basic_semaphore< std::mutex, std::condition_variable >
using	JobCounter = ClosureCounter< void, Job & >
using	const_iterator = Dir::const_iterator
using	majorityAmendments_t = std::map< uint256, NetClock::time_point >
using	socket_type = boost::beast::tcp_stream
using	stream_type = boost::beast::ssl_stream< socket_type >
using	request_type = boost::beast::http::request< boost::beast::http::empty_body >
using	http_request_type = boost::beast::http::request< boost::beast::http::dynamic_body >
using	http_response_type = boost::beast::http::response< boost::beast::http::dynamic_body >
using	ProtocolVersion = std::pair< std::uint16_t, std::uint16_t >
	Represents a particular version of the peer-to-peer protocol. More...
using	AccountID = base_uint< 160, detail::AccountIDTag >
	A 160-bit unsigned that uniquely identifies an account. More...
using	ripemd160_hasher = openssl_ripemd160_hasher
using	sha256_hasher = openssl_sha256_hasher
using	sha512_hasher = openssl_sha512_hasher
using	sha512_half_hasher = detail::basic_sha512_half_hasher< false >
using	sha512_half_hasher_s = detail::basic_sha512_half_hasher< true >
using	LedgerIndex = std::uint32_t
	A ledger index. More...
using	TxID = uint256
	A transaction identifier. More...
using	TxSeq = std::uint32_t
using	SF_UINT8 = TypedField< STInteger< std::uint8_t > >
using	SF_UINT16 = TypedField< STInteger< std::uint16_t > >
using	SF_UINT32 = TypedField< STInteger< std::uint32_t > >
using	SF_UINT64 = TypedField< STInteger< std::uint64_t > >
using	SF_HASH128 = TypedField< STBitString< 128 > >
using	SF_HASH160 = TypedField< STBitString< 160 > >
using	SF_HASH256 = TypedField< STBitString< 256 > >
using	SF_ACCOUNT = TypedField< STAccount >
using	SF_AMOUNT = TypedField< STAmount >
using	SF_VL = TypedField< STBlob >
using	SF_VECTOR256 = TypedField< STVector256 >
using	STHash128 = STBitString< 128 >
using	STHash160 = STBitString< 160 >
using	STHash256 = STBitString< 256 >
using	STUInt8 = STInteger< unsigned char >
using	STUInt16 = STInteger< std::uint16_t >
using	STUInt32 = STInteger< std::uint32_t >
using	STUInt64 = STInteger< std::uint64_t >
using	SLE = STLedgerEntry
using	TERUnderlyingType = int
using	NotTEC = TERSubset< CanCvtToNotTEC >
using	TER = TERSubset< CanCvtToTER >
using	Directory = base_uint< 256, detail::DirectoryTag >
	Directory is an index into the directory of offer books. More...
using	Currency = base_uint< 160, detail::CurrencyTag >
	Currency is a hash representing a specific currency. More...
using	NodeID = base_uint< 160, detail::NodeIDTag >
	NodeID is a 160-bit hash representing one node. More...
using	TxnDataBinary = RelationalDBInterface::txnMetaLedgerType
using	LedgerSpecifier = RelationalDBInterface::LedgerSpecifier
using	ServerHandler = ServerHandlerImp
using	Endpoints = std::vector< boost::asio::ip::tcp::endpoint >
using	FullBelowCache = detail::BasicFullBelowCache< uint256 >
using	TreeNodeCache = TaggedCache< uint256, SHAMapTreeNode >
using	sha256_t = unsigned_integer< 256, std::size_t >

Enumerations
enum	{   peerCountStart = 4, peerCountAdd = 2, ledgerTimeoutRetriesMax = 10, ledgerBecomeAggressiveThreshold = 6,   missingNodesFind = 256, reqNodesReply = 128, reqNodes = 8 }
enum	{ startPeers = 2, setKeepRounds = 3 }
enum	{ NORM_TIMEOUTS = 4, MAX_TIMEOUTS = 20 }
enum	ManifestDisposition {   ManifestDisposition::accepted = 0, ManifestDisposition::stale, ManifestDisposition::badMasterKey, ManifestDisposition::badEphemeralKey,   ManifestDisposition::invalid }
enum	OperatingMode {   OperatingMode::DISCONNECTED = 0, OperatingMode::CONNECTED = 1, OperatingMode::SYNCING = 2, OperatingMode::TRACKING = 3,   OperatingMode::FULL = 4 }
	Specifies the mode under which the server believes it's operating. More...
enum	TransStatus {   NEW = 0, INVALID = 1, INCLUDED = 2, CONFLICTED = 3,   COMMITTED = 4, HELD = 5, REMOVED = 6, OBSOLETE = 7,   INCOMPLETE = 8 }
enum	TxSearched { TxSearched::all, TxSearched::some, TxSearched::unknown }
enum	ListDisposition {   ListDisposition::accepted = 0, ListDisposition::expired, ListDisposition::pending, ListDisposition::same_sequence,   ListDisposition::known_sequence, ListDisposition::stale, ListDisposition::untrusted, ListDisposition::unsupported_version,   ListDisposition::invalid }
enum	PublisherStatus { PublisherStatus::available = 0, PublisherStatus::expired, PublisherStatus::unavailable, PublisherStatus::revoked }
enum	DebtDirection { DebtDirection::issues, DebtDirection::redeems }
enum	QualityDirection { QualityDirection::in, QualityDirection::out }
enum	StrandDirection { StrandDirection::forward, StrandDirection::reverse }
enum	AmendmentVote : int { AmendmentVote::up = 0, AmendmentVote::down = 1 }
enum	TableType { TableType::Ledgers, TableType::Transactions, TableType::AccountTransactions }
enum	Validity { Validity::SigBad, Validity::SigGoodOnly, Validity::Valid }
	Describes the pre-processing validity of a transaction. More...
enum	ApplyResult { ApplyResult::Success, ApplyResult::Fail, ApplyResult::Retry }
	Enum class for return value from applyTransaction More...
enum	CrossType { CrossType::XrpToIou, CrossType::IouToXrp, CrossType::IouToIou }
	The flavor of an offer crossing. More...
enum	LogSeverity {   lsINVALID = -1, lsTRACE = 0, lsDEBUG = 1, lsINFO = 2,   lsWARNING = 3, lsERROR = 4, lsFATAL = 5 }
enum	ConsensusMode { ConsensusMode::proposing, ConsensusMode::observing, ConsensusMode::wrongLedger, ConsensusMode::switchedLedger }
	Represents how a node currently participates in Consensus. More...
enum	ConsensusPhase { ConsensusPhase::open, ConsensusPhase::establish, ConsensusPhase::accepted }
	Phases of consensus for a single ledger round. More...
enum	ConsensusState { ConsensusState::No, ConsensusState::MovedOn, ConsensusState::Yes }
	Whether we have or don't have a consensus. More...
enum	ValStatus {   ValStatus::current, ValStatus::stale, ValStatus::badSeq, ValStatus::multiple,   ValStatus::conflicting }
	Status of validation we received. More...
enum	SizedItem : std::size_t {   SizedItem::sweepInterval = 0, SizedItem::treeCacheSize, SizedItem::treeCacheAge, SizedItem::ledgerSize,   SizedItem::ledgerAge, SizedItem::ledgerFetch, SizedItem::hashNodeDBCache, SizedItem::txnDBCache,   SizedItem::lgrDBCache, SizedItem::openFinalLimit, SizedItem::burstSize, SizedItem::ramSizeGB }
enum	JobType {   jtINVALID = -1, jtPACK, jtPUBOLDLEDGER, jtVALIDATION_ut,   jtTRANSACTION_l, jtREPLAY_REQ, jtLEDGER_REQ, jtPROPOSAL_ut,   jtREPLAY_TASK, jtLEDGER_DATA, jtCLIENT, jtRPC,   jtUPDATE_PF, jtTRANSACTION, jtMISSING_TXN, jtREQUESTED_TXN,   jtBATCH, jtADVANCE, jtPUBLEDGER, jtTXN_DATA,   jtWAL, jtVALIDATION_t, jtWRITE, jtACCEPT,   jtPROPOSAL_t, jtSWEEP, jtNETOP_CLUSTER, jtNETOP_TIMER,   jtADMIN, jtPEER, jtDISK, jtTXN_PROC,   jtOB_SETUP, jtPATH_FIND, jtHO_READ, jtHO_WRITE,   jtGENERIC, jtNS_SYNC_READ, jtNS_ASYNC_READ, jtNS_WRITE }
enum	ApplyFlags : std::uint32_t {   tapNONE = 0x00, tapFAIL_HARD = 0x10, tapRETRY = 0x20, tapPREFER_QUEUE = 0x40,   tapUNLIMITED = 0x400 }
enum	FreezeHandling { fhIGNORE_FREEZE, fhZERO_IF_FROZEN }
	Controls the treatment of frozen account balances. More...
enum	NodeObjectType : std::uint32_t { hotUNKNOWN = 0, hotLEDGER = 1, hotACCOUNT_NODE = 3, hotTRANSACTION_NODE = 4 }
	The types of node objects. More...
enum	ShardState : std::uint32_t {   ShardState::acquire, ShardState::complete, ShardState::finalizing, ShardState::finalized,   ShardState::queued }
	Shard states. More...
enum	ProtocolFeature { ProtocolFeature::ValidatorListPropagation, ProtocolFeature::ValidatorList2Propagation, ProtocolFeature::LedgerReplay }
enum	error_code_i {   rpcUNKNOWN = -1, rpcSUCCESS = 0, rpcBAD_SYNTAX = 1, rpcJSON_RPC = 2,   rpcFORBIDDEN = 3, rpcNO_PERMISSION = 6, rpcNO_EVENTS = 7, rpcTOO_BUSY = 9,   rpcSLOW_DOWN = 10, rpcHIGH_FEE = 11, rpcNOT_ENABLED = 12, rpcNOT_READY = 13,   rpcAMENDMENT_BLOCKED = 14, rpcNO_CLOSED = 15, rpcNO_CURRENT = 16, rpcNO_NETWORK = 17,   rpcNOT_SYNCED = 18, rpcACT_NOT_FOUND = 19, rpcLGR_NOT_FOUND = 21, rpcLGR_NOT_VALIDATED = 22,   rpcMASTER_DISABLED = 23, rpcTXN_NOT_FOUND = 29, rpcINVALID_PARAMS = 31, rpcUNKNOWN_COMMAND = 32,   rpcNO_PF_REQUEST = 33, rpcACT_MALFORMED = 35, rpcALREADY_MULTISIG = 36, rpcALREADY_SINGLE_SIG = 37,   rpcBAD_FEATURE = 40, rpcBAD_ISSUER = 41, rpcBAD_MARKET = 42, rpcBAD_SECRET = 43,   rpcBAD_SEED = 44, rpcCHANNEL_MALFORMED = 45, rpcCHANNEL_AMT_MALFORMED = 46, rpcCOMMAND_MISSING = 47,   rpcDST_ACT_MALFORMED = 48, rpcDST_ACT_MISSING = 49, rpcDST_ACT_NOT_FOUND = 50, rpcDST_AMT_MALFORMED = 51,   rpcDST_AMT_MISSING = 52, rpcDST_ISR_MALFORMED = 53, rpcLGR_IDXS_INVALID = 57, rpcLGR_IDX_MALFORMED = 58,   rpcPUBLIC_MALFORMED = 62, rpcSIGNING_MALFORMED = 63, rpcSENDMAX_MALFORMED = 64, rpcSRC_ACT_MALFORMED = 65,   rpcSRC_ACT_MISSING = 66, rpcSRC_ACT_NOT_FOUND = 67, rpcSRC_CUR_MALFORMED = 69, rpcSRC_ISR_MALFORMED = 70,   rpcSTREAM_MALFORMED = 71, rpcATX_DEPRECATED = 72, rpcINTERNAL = 73, rpcNOT_IMPL = 74,   rpcNOT_SUPPORTED = 75, rpcBAD_KEY_TYPE = 76, rpcDB_DESERIALIZATION = 77, rpcEXCESSIVE_LGR_RANGE = 78,   rpcINVALID_LGR_RANGE = 79, rpcEXPIRED_VALIDATOR_LIST = 80, rpcFAILED_TO_FORWARD = 90, rpcREPORTING_UNSUPPORTED = 91,   rpcLAST }
enum	warning_code_i { warnRPC_UNSUPPORTED_MAJORITY = 1001, warnRPC_AMENDMENT_BLOCKED = 1002, warnRPC_EXPIRED_VALIDATOR_LIST = 1003, warnRPC_REPORTING = 1004 }
	Codes returned in the warnings array of certain RPC commands. More...
enum	DefaultVote : bool { DefaultVote::no = false, DefaultVote::yes }
enum	HashPrefix : std::uint32_t {   HashPrefix::transactionID = detail::make_hash_prefix('T', 'X', 'N'), HashPrefix::txNode = detail::make_hash_prefix('S', 'N', 'D'), HashPrefix::leafNode = detail::make_hash_prefix('M', 'L', 'N'), HashPrefix::innerNode = detail::make_hash_prefix('M', 'I', 'N'),   HashPrefix::ledgerMaster = detail::make_hash_prefix('L', 'W', 'R'), HashPrefix::txSign = detail::make_hash_prefix('S', 'T', 'X'), HashPrefix::txMultiSign = detail::make_hash_prefix('S', 'M', 'T'), HashPrefix::validation = detail::make_hash_prefix('V', 'A', 'L'),   HashPrefix::proposal = detail::make_hash_prefix('P', 'R', 'P'), HashPrefix::manifest = detail::make_hash_prefix('M', 'A', 'N'), HashPrefix::paymentChannelClaim = detail::make_hash_prefix('C', 'L', 'M'), HashPrefix::shardInfo = detail::make_hash_prefix('S', 'H', 'D') }
	Prefix for hashing functions. More...
enum	LedgerNameSpace : std::uint16_t {   LedgerNameSpace::ACCOUNT = 'a', LedgerNameSpace::DIR_NODE = 'd', LedgerNameSpace::TRUST_LINE = 'r', LedgerNameSpace::OFFER = 'o',   LedgerNameSpace::OWNER_DIR = 'O', LedgerNameSpace::BOOK_DIR = 'B', LedgerNameSpace::SKIP_LIST = 's', LedgerNameSpace::ESCROW = 'u',   LedgerNameSpace::AMENDMENTS = 'f', LedgerNameSpace::FEE_SETTINGS = 'e', LedgerNameSpace::TICKET = 'T', LedgerNameSpace::SIGNER_LIST = 'S',   LedgerNameSpace::XRP_PAYMENT_CHANNEL = 'x', LedgerNameSpace::CHECK = 'C', LedgerNameSpace::DEPOSIT_PREAUTH = 'p', LedgerNameSpace::NEGATIVE_UNL = 'N',   LedgerNameSpace::CONTRACT = 'c', LedgerNameSpace::GENERATOR = 'g', LedgerNameSpace::NICKNAME = 'n' }
	Type-specific prefix for calculating ledger indices. More...
enum	KeyType { KeyType::secp256k1 = 0, KeyType::ed25519 = 1 }
enum	LedgerEntryType : std::uint16_t {   ltACCOUNT_ROOT = 0x0061, ltDIR_NODE = 0x0064, ltRIPPLE_STATE = 0x0072, ltTICKET = 0x0054,   ltSIGNER_LIST = 0x0053, ltOFFER = 0x006f, ltLEDGER_HASHES = 0x0068, ltAMENDMENTS = 0x0066,   ltFEE_SETTINGS = 0x0073, ltESCROW = 0x0075, ltPAYCHAN = 0x0078, ltCHECK = 0x0043,   ltDEPOSIT_PREAUTH = 0x0070, ltNEGATIVE_UNL = 0x004e, ltANY = 0, ltCHILD = 0x1CD2,   ltNICKNAME = 0x006e, ltCONTRACT = 0x0063, ltGENERATOR_MAP = 0x0067 }
	Identifiers for on-ledger objects. More...
enum	LedgerSpecificFlags {   lsfPasswordSpent = 0x00010000, lsfRequireDestTag, lsfRequireAuth, lsfDisallowXRP = 0x00080000,   lsfDisableMaster = 0x00100000, lsfNoFreeze = 0x00200000, lsfGlobalFreeze = 0x00400000, lsfDefaultRipple,   lsfDepositAuth = 0x01000000, lsfPassive = 0x00010000, lsfSell = 0x00020000, lsfLowReserve = 0x00010000,   lsfHighReserve = 0x00020000, lsfLowAuth = 0x00040000, lsfHighAuth = 0x00080000, lsfLowNoRipple = 0x00100000,   lsfHighNoRipple = 0x00200000, lsfLowFreeze = 0x00400000, lsfHighFreeze = 0x00800000, lsfOneOwnerCount = 0x00010000 }
enum	ECDSACanonicality { ECDSACanonicality::canonical, ECDSACanonicality::fullyCanonical }
enum	SerializedTypeID {   STI_UNKNOWN = -2, STI_DONE = -1, STI_NOTPRESENT = 0, STI_UINT16 = 1,   STI_UINT32 = 2, STI_UINT64 = 3, STI_HASH128 = 4, STI_HASH256 = 5,   STI_AMOUNT = 6, STI_VL = 7, STI_ACCOUNT = 8, STI_OBJECT = 14,   STI_ARRAY = 15, STI_UINT8 = 16, STI_HASH160 = 17, STI_PATHSET = 18,   STI_VECTOR256 = 19, STI_TRANSACTION = 10001, STI_LEDGERENTRY = 10002, STI_VALIDATION = 10003,   STI_METADATA = 10004 }
enum	SOEStyle { soeINVALID = -1, soeREQUIRED = 0, soeOPTIONAL = 1, soeDEFAULT = 2 }
	Kind of element in each entry of an SOTemplate. More...
enum	JsonOptions { JsonOptions::none = 0, JsonOptions::include_date = 1 }
enum	TxnSql : char {   txnSqlNew = 'N', txnSqlConflict = 'C', txnSqlHeld = 'H', txnSqlValidated = 'V',   txnSqlIncluded = 'I', txnSqlUnknown = 'U' }
enum	TELcodes : TERUnderlyingType {   telLOCAL_ERROR = -399, telBAD_DOMAIN, telBAD_PATH_COUNT, telBAD_PUBLIC_KEY,   telFAILED_PROCESSING, telINSUF_FEE_P, telNO_DST_PARTIAL, telCAN_NOT_QUEUE,   telCAN_NOT_QUEUE_BALANCE, telCAN_NOT_QUEUE_BLOCKS, telCAN_NOT_QUEUE_BLOCKED, telCAN_NOT_QUEUE_FEE,   telCAN_NOT_QUEUE_FULL }
enum	TEMcodes : TERUnderlyingType {   temMALFORMED = -299, temBAD_AMOUNT, temBAD_CURRENCY, temBAD_EXPIRATION,   temBAD_FEE, temBAD_ISSUER, temBAD_LIMIT, temBAD_OFFER,   temBAD_PATH, temBAD_PATH_LOOP, temBAD_REGKEY, temBAD_SEND_XRP_LIMIT,   temBAD_SEND_XRP_MAX, temBAD_SEND_XRP_NO_DIRECT, temBAD_SEND_XRP_PARTIAL, temBAD_SEND_XRP_PATHS,   temBAD_SEQUENCE, temBAD_SIGNATURE, temBAD_SRC_ACCOUNT, temBAD_TRANSFER_RATE,   temDST_IS_SRC, temDST_NEEDED, temINVALID, temINVALID_FLAG,   temREDUNDANT, temRIPPLE_EMPTY, temDISABLED, temBAD_SIGNER,   temBAD_QUORUM, temBAD_WEIGHT, temBAD_TICK_SIZE, temINVALID_ACCOUNT_ID,   temCANNOT_PREAUTH_SELF, temINVALID_COUNT, temUNCERTAIN, temUNKNOWN,   temSEQ_AND_TICKET }
enum	TEFcodes : TERUnderlyingType {   tefFAILURE = -199, tefALREADY, tefBAD_ADD_AUTH, tefBAD_AUTH,   tefBAD_LEDGER, tefCREATED, tefEXCEPTION, tefINTERNAL,   tefNO_AUTH_REQUIRED, tefPAST_SEQ, tefWRONG_PRIOR, tefMASTER_DISABLED,   tefMAX_LEDGER, tefBAD_SIGNATURE, tefBAD_QUORUM, tefNOT_MULTI_SIGNING,   tefBAD_AUTH_MASTER, tefINVARIANT_FAILED, tefTOO_BIG, tefNO_TICKET }
enum	TERcodes : TERUnderlyingType {   terRETRY = -99, terFUNDS_SPENT, terINSUF_FEE_B, terNO_ACCOUNT,   terNO_AUTH, terNO_LINE, terOWNERS, terPRE_SEQ,   terLAST, terNO_RIPPLE, terQUEUED, terPRE_TICKET }
enum	TEScodes : TERUnderlyingType { tesSUCCESS = 0 }
enum	TECcodes : TERUnderlyingType {   tecCLAIM = 100, tecPATH_PARTIAL = 101, tecUNFUNDED_ADD = 102, tecUNFUNDED_OFFER = 103,   tecUNFUNDED_PAYMENT = 104, tecFAILED_PROCESSING = 105, tecDIR_FULL = 121, tecINSUF_RESERVE_LINE = 122,   tecINSUF_RESERVE_OFFER = 123, tecNO_DST = 124, tecNO_DST_INSUF_XRP = 125, tecNO_LINE_INSUF_RESERVE = 126,   tecNO_LINE_REDUNDANT = 127, tecPATH_DRY = 128, tecUNFUNDED = 129, tecNO_ALTERNATIVE_KEY = 130,   tecNO_REGULAR_KEY = 131, tecOWNERS = 132, tecNO_ISSUER = 133, tecNO_AUTH = 134,   tecNO_LINE = 135, tecINSUFF_FEE = 136, tecFROZEN = 137, tecNO_TARGET = 138,   tecNO_PERMISSION = 139, tecNO_ENTRY = 140, tecINSUFFICIENT_RESERVE = 141, tecNEED_MASTER_KEY = 142,   tecDST_TAG_NEEDED = 143, tecINTERNAL = 144, tecOVERSIZE = 145, tecCRYPTOCONDITION_ERROR = 146,   tecINVARIANT_FAILED = 147, tecEXPIRED = 148, tecDUPLICATE = 149, tecKILLED = 150,   tecHAS_OBLIGATIONS = 151, tecTOO_SOON = 152, tecHOOK_ERROR = 153 }
enum	TokenType : std::uint8_t {   TokenType::None = 1, TokenType::NodePublic = 28, TokenType::NodePrivate = 32, TokenType::AccountID = 0,   TokenType::AccountPublic = 35, TokenType::AccountSecret = 34, TokenType::FamilyGenerator = 41, TokenType::FamilySeed = 33 }
enum	TxType : std::uint16_t {   ttPAYMENT = 0, ttESCROW_CREATE = 1, ttESCROW_FINISH = 2, ttACCOUNT_SET = 3,   ttESCROW_CANCEL = 4, ttREGULAR_KEY_SET = 5, ttNICKNAME_SET = 6, ttOFFER_CREATE = 7,   ttOFFER_CANCEL = 8, ttCONTRACT = 9, ttTICKET_CREATE = 10, ttSPINAL_TAP = 11,   ttSIGNER_LIST_SET = 12, ttPAYCHAN_CREATE = 13, ttPAYCHAN_FUND = 14, ttPAYCHAN_CLAIM = 15,   ttCHECK_CREATE = 16, ttCHECK_CASH = 17, ttCHECK_CANCEL = 18, ttDEPOSIT_PREAUTH = 19,   ttTRUST_SET = 20, ttACCOUNT_DELETE = 21, ttHOOK_SET = 22, ttAMENDMENT = 100,   ttFEE = 101, ttUNL_MODIFY = 102 }
	Transaction type identifiers. More...
enum	Role {   Role::GUEST, Role::USER, Role::IDENTIFIED, Role::ADMIN,   Role::PROXY, Role::FORBID }
	Indicates the level of administrative permission to grant. More...
enum	SHAMapState { SHAMapState::Modifying = 0, SHAMapState::Immutable = 1, SHAMapState::Synching = 2, SHAMapState::Invalid = 3 }
	Describes the current state of a given SHAMap. More...
enum	SHAMapType { SHAMapType::TRANSACTION = 1, SHAMapType::STATE = 2, SHAMapType::FREE = 3 }
enum	SHAMapNodeType { SHAMapNodeType::tnINNER = 1, SHAMapNodeType::tnTRANSACTION_NM = 2, SHAMapNodeType::tnTRANSACTION_MD = 3, SHAMapNodeType::tnACCOUNT_STATE = 4 }

Functions
uint256	proposalUniqueId (uint256 const &proposeHash, uint256 const &previousLedger, std::uint32_t proposeSeq, NetClock::time_point closeTime, Slice const &publicKey, Slice const &signature)
	Calculate a unique identifier for a signed proposal. More...
RCLValidatedLedger::Seq	mismatch (RCLValidatedLedger const &a, RCLValidatedLedger const &b)
void	handleNewValidation (Application &app, std::shared_ptr< STValidation > const &val, std::string const &source)
	Handle a new validation. More...
std::shared_ptr< Ledger >	buildLedger (std::shared_ptr< Ledger const > const &parent, NetClock::time_point closeTime, const bool closeTimeCorrect, NetClock::duration closeResolution, Application &app, CanonicalTXSet &txns, std::set< TxID > &failedTxs, beast::Journal j)
	Build a new ledger by applying consensus transactions. More...
std::shared_ptr< Ledger >	buildLedger (LedgerReplay const &replayData, ApplyFlags applyFlags, Application &app, beast::Journal j)
	Build a new ledger by replaying transactions. More...
template<class ApplyTxs >
std::shared_ptr< Ledger >	buildLedgerImpl (std::shared_ptr< Ledger const > const &parent, NetClock::time_point closeTime, const bool closeTimeCorrect, NetClock::duration closeResolution, Application &app, beast::Journal j, ApplyTxs &&applyTxs)
std::size_t	applyTransactions (Application &app, std::shared_ptr< Ledger const > const &built, CanonicalTXSet &txns, std::set< TxID > &failed, OpenView &view, beast::Journal j)
	Apply a set of consensus transactions to a ledger. More...
static std::vector< uint256 >	neededHashes (uint256 const &root, SHAMap &map, int max, SHAMapSyncFilter *filter)
LedgerInfo	deserializeHeader (Slice data, bool hasHash=false)
	Deserialize a ledger header from a byte array. More...
LedgerInfo	deserializePrefixedHeader (Slice data, bool hasHash=false)
	Deserialize a ledger header (prefixed with 4 bytes) from a byte array. More...
std::unique_ptr< InboundLedgers >	make_InboundLedgers (Application &app, InboundLedgers::clock_type &clock, beast::insight::Collector::ptr const &collector)
std::unique_ptr< InboundTransactions >	make_InboundTransactions (Application &app, beast::insight::Collector::ptr const &collector, std::function< void(std::shared_ptr< SHAMap > const &, bool)> gotSet)
std::unique_ptr< LedgerCleaner >	make_LedgerCleaner (Application &app, beast::Journal journal)
static bool	shouldAcquire (std::uint32_t const currentLedger, std::uint32_t const ledgerHistory, std::optional< LedgerIndex > const minimumOnline, std::uint32_t const candidateLedger, beast::Journal j)
static void	populateFetchPack (SHAMap const &want, SHAMap const *have, std::uint32_t cnt, protocol::TMGetObjectByHash *into, std::uint32_t seq, bool withLeaves=true)
	Populate a fetch pack with data from the map the recipient wants. More...
void	addJson (Json::Value &, LedgerFill const &)
	Given a Ledger and options, fill a Json::Object or Json::Value with a description of the ledger. More...
Json::Value	getJson (LedgerFill const &)
	Return a new Json::Value representing the ledger with given options. More...
std::unique_ptr< LocalTxs >	make_LocalTxs ()
std::string	debugTxstr (std::shared_ptr< STTx const > const &tx)
std::string	debugTostr (OrderedTxs const &set)
std::string	debugTostr (SHAMap const &set)
std::string	debugTostr (std::shared_ptr< ReadView const > const &view)
uint256	calculateLedgerHash (LedgerInfo const &info)
std::shared_ptr< STTx const >	deserializeTx (SHAMapItem const &item)
	Deserialize a SHAMapItem containing a single STTx. More...
std::pair< std::shared_ptr< STTx const >, std::shared_ptr< STObject const > >	deserializeTxPlusMeta (SHAMapItem const &item)
	Deserialize a SHAMapItem containing STTx + STObject metadata. More...
bool	isFlagLedger (LedgerIndex seq)
	Returns true if the given ledgerIndex is a flag ledgerIndex. More...
static bool	saveValidatedLedger (Application &app, std::shared_ptr< Ledger const > const &ledger, bool current)
bool	pendSaveValidated (Application &app, std::shared_ptr< Ledger const > const &ledger, bool isSynchronous, bool isCurrent)
	Save, or arrange to save, a fully-validated ledger Returns false on error. More...
std::shared_ptr< Ledger >	loadLedgerHelper (LedgerInfo const &info, Application &app, bool acquire)
static void	finishLoadByIndexOrHash (std::shared_ptr< Ledger > const &ledger, Config const &config, beast::Journal j)
std::tuple< std::shared_ptr< Ledger >, std::uint32_t, uint256 >	getLatestLedger (Application &app)
std::shared_ptr< Ledger >	loadByIndex (std::uint32_t ledgerIndex, Application &app, bool acquire)
std::shared_ptr< Ledger >	loadByHash (uint256 const &ledgerHash, Application &app, bool acquire)
std::vector< std::pair< std::shared_ptr< STTx const >, std::shared_ptr< STObject const > > >	flatFetchTransactions (Application &app, std::vector< uint256 > &nodestoreHashes)
std::vector< std::pair< std::shared_ptr< STTx const >, std::shared_ptr< STObject const > > >	flatFetchTransactions (ReadView const &ledger, Application &app)
static void	log_one (ReadView const &ledger, uint256 const &tx, char const *msg, beast::Journal &j)
static void	log_metadata_difference (ReadView const &builtLedger, ReadView const &validLedger, uint256 const &tx, beast::Journal j)
static std::vector< SHAMapItem const * >	leaves (SHAMap const &sm)
template<class Object >
Blob	serializeBlob (Object const &o)
	Serialize an object to a blob. More...
std::string	serializeHex (STObject const &o)
	Serialize an object to a hex string. More...
std::unique_ptr< Application >	make_Application (std::unique_ptr< Config > config, std::unique_ptr< Logs > logs, std::unique_ptr< TimeKeeper > timeKeeper)
std::unique_ptr< CollectorManager >	make_CollectorManager (Section const &params, beast::Journal journal)
std::unique_ptr< LoadManager >	make_LoadManager (Application &app, beast::Journal journal)
bool	adjustDescriptorLimit (int needed, beast::Journal j)
void	printHelp (const po::options_description &desc)
std::pair< PublicKey, SecretKey >	getNodeIdentity (Application &app)
	The cryptographic credentials identifying this server instance. More...
std::unique_ptr< AmendmentTable >	make_AmendmentTable (Application &app, std::chrono::seconds majorityTime, std::vector< AmendmentTable::FeatureInfo > const &supported, Section const &enabled, Section const &vetoed, beast::Journal journal)
bool	operator< (CanonicalTXSet::Key const &lhs, CanonicalTXSet::Key const &rhs)
FeeVote::Setup	setup_FeeVote (Section const &section)
	Build FeeVote::Setup from a config section. More...
std::unique_ptr< FeeVote >	make_FeeVote (FeeVote::Setup const &setup, beast::Journal journal)
	Create an instance of the FeeVote logic. More...
void	convertBlobsToTxResult (RelationalDBInterface::AccountTxs &to, std::uint32_t ledger_index, std::string const &status, Blob const &rawTxn, Blob const &rawMeta, Application &app)
void	saveLedgerAsync (Application &app, std::uint32_t seq)
static std::vector< std::pair< uint256, std::string > >	parseSection (Section const &section)
XRPAmount	scaleFeeLoad (FeeUnit64 fee, LoadFeeTrack const &feeTrack, Fees const &fees, bool bUnlimited)
std::string	to_string (Manifest const &m)
	Format the specified manifest to a string for debugging purposes. More...
template<class Stream >
Stream &	logMftAct (Stream &s, std::string const &action, PublicKey const &pk, std::uint32_t seq)
template<class Stream >
Stream &	logMftAct (Stream &s, std::string const &action, PublicKey const &pk, std::uint32_t seq, std::uint32_t oldSeq)
std::optional< ValidatorToken >	loadValidatorToken (std::vector< std::string > const &blob)
static FeeLevel64	getFeeLevelPaid (ReadView const &view, STTx const &tx)
static std::optional< LedgerIndex >	getLastLedgerSequence (STTx const &tx)
static FeeLevel64	increase (FeeLevel64 level, std::uint32_t increasePercent)
TxQ::Setup	setup_TxQ (Config const &)
	Build a TxQ::Setup object from application configuration. More...
std::string	to_string (ListDisposition disposition)
std::size_t	splitMessageParts (std::vector< ValidatorList::MessageWithHash > &messages, protocol::TMValidatorListCollection const &largeMsg, std::size_t maxSize, std::size_t begin, std::size_t end)
std::size_t	splitMessage (std::vector< ValidatorList::MessageWithHash > &messages, protocol::TMValidatorListCollection const &largeMsg, std::size_t maxSize, std::size_t begin=0, std::size_t end=0)
std::size_t	buildValidatorListMessage (std::vector< ValidatorList::MessageWithHash > &messages, std::uint32_t rawVersion, std::string const &rawManifest, ValidatorBlobInfo const &currentBlob, std::size_t maxSize)
std::size_t	buildValidatorListMessage (std::vector< ValidatorList::MessageWithHash > &messages, std::uint64_t peerSequence, std::uint32_t rawVersion, std::string const &rawManifest, std::map< std::size_t, ValidatorBlobInfo > const &blobInfos, std::size_t maxSize)
bool	operator== (Manifest const &lhs, Manifest const &rhs)
bool	operator!= (Manifest const &lhs, Manifest const &rhs)
std::string	to_string (ManifestDisposition m)
static std::uint32_t	trunc32 (std::uint64_t v)
static void	getAccounts (Json::Value const &jvObj, std::vector< AccountID > &accounts)
std::unique_ptr< NetworkOPs >	make_NetworkOPs (Application &app, NetworkOPs::clock_type &clock, bool standalone, std::size_t minPeerCount, bool startvalid, JobQueue &job_queue, LedgerMaster &ledgerMaster, ValidatorKeys const &validatorKeys, boost::asio::io_service &io_svc, beast::Journal journal, beast::insight::Collector::ptr const &collector)
std::unique_ptr< SHAMapStore >	make_SHAMapStore (Application &app, NodeStore::Scheduler &scheduler, beast::Journal journal)
template<class T >
XRPAmount	toDrops (FeeLevel< T > const &level, XRPAmount const &baseFee)
FeeLevel64	toFeeLevel (XRPAmount const &drops, XRPAmount const &baseFee)
template<class Hasher >
void	hash_append (Hasher &h, ValidatorBlobInfo const &blobInfo)
template<class Hasher >
void	hash_append (Hasher &h, std::vector< ValidatorBlobInfo > const &blobs)
template<class Hasher >
void	hash_append (Hasher &h, std::map< std::size_t, ValidatorBlobInfo > const &blobs)
hash_set< Currency >	accountSourceCurrencies (AccountID const &account, std::shared_ptr< RippleLineCache > const &lrCache, bool includeXRP)
hash_set< Currency >	accountDestCurrencies (AccountID const &account, std::shared_ptr< RippleLineCache > const &lrCache, bool includeXRP)
path::RippleCalc::Output	flow (PaymentSandbox &view, STAmount const &deliver, AccountID const &src, AccountID const &dst, STPathSet const &paths, bool defaultPaths, bool partialPayment, bool ownerPaysTransferFee, bool offerCrossing, std::optional< Quality > const &limitQuality, std::optional< STAmount > const &sendMax, beast::Journal j, path::detail::FlowDebugInfo *flowDebugInfo=nullptr)
	Make a payment from the src account to the dst account. More...
template<class T >
T &	get (EitherAmount &amt)
template<>
IOUAmount &	get< IOUAmount > (EitherAmount &amt)
template<>
XRPAmount &	get< XRPAmount > (EitherAmount &amt)
template<class T >
T const &	get (EitherAmount const &amt)
template<>
IOUAmount const &	get< IOUAmount > (EitherAmount const &amt)
template<>
XRPAmount const &	get< XRPAmount > (EitherAmount const &amt)
AmountSpec	toAmountSpec (STAmount const &amt)
EitherAmount	toEitherAmount (STAmount const &amt)
AmountSpec	toAmountSpec (EitherAmount const &ea, std::optional< Currency > const &c)
template<class TIn , class TOut >
static void	limitStepIn (Quality const &ofrQ, TAmounts< TIn, TOut > &ofrAmt, TAmounts< TIn, TOut > &stpAmt, TOut &ownerGives, std::uint32_t transferRateIn, std::uint32_t transferRateOut, TIn const &limit)
template<class TIn , class TOut >
static void	limitStepOut (Quality const &ofrQ, TAmounts< TIn, TOut > &ofrAmt, TAmounts< TIn, TOut > &stpAmt, TOut &ownerGives, std::uint32_t transferRateIn, std::uint32_t transferRateOut, TOut const &limit)
template<class TCollection >
static auto	sum (TCollection const &col)
template<class TIn , class TOut >
static std::pair< TER, std::unique_ptr< Step > >	make_BookStepHelper (StrandContext const &ctx, Issue const &in, Issue const &out)
std::pair< TER, std::unique_ptr< Step > >	make_BookStepII (StrandContext const &ctx, Issue const &in, Issue const &out)
std::pair< TER, std::unique_ptr< Step > >	make_BookStepIX (StrandContext const &ctx, Issue const &in)
std::pair< TER, std::unique_ptr< Step > >	make_BookStepXI (StrandContext const &ctx, Issue const &out)
std::pair< TER, std::unique_ptr< Step > >	make_DirectStepI (StrandContext const &ctx, AccountID const &src, AccountID const &dst, Currency const &c)
template<class T >
void	SetUnion (boost::container::flat_set< T > &dst, boost::container::flat_set< T > const &src)
	Given two flat sets dst and src, compute dst = dst union src. More...
STAmount	largestAmount (STAmount const &amt)
STAmount	convertAmount (STAmount const &amt, bool all)
bool	convertAllCheck (STAmount const &a)
bool	checkNear (IOUAmount const &expected, IOUAmount const &actual)
bool	checkNear (XRPAmount const &expected, XRPAmount const &actual)
static bool	isXRPAccount (STPathElement const &pe)
static std::pair< TER, std::unique_ptr< Step > >	toStep (StrandContext const &ctx, STPathElement const *e1, STPathElement const *e2, Issue const &curIssue)
std::pair< TER, Strand >	toStrand (ReadView const &sb, AccountID const &src, AccountID const &dst, Issue const &deliver, std::optional< Quality > const &limitQuality, std::optional< Issue > const &sendMaxIssue, STPath const &path, bool ownerPaysTransferFee, bool offerCrossing, beast::Journal j)
	Create a Strand for the specified path. More...
std::pair< TER, std::vector< Strand > >	toStrands (ReadView const &sb, AccountID const &src, AccountID const &dst, Issue const &deliver, std::optional< Quality > const &limitQuality, std::optional< Issue > const &sendMax, STPathSet const &paths, bool addDefaultPath, bool ownerPaysTransferFee, bool offerCrossing, beast::Journal j)
	Create a Strand for each specified path (including the default path, if indicated) More...
template<class InAmt , class OutAmt >
bool	isDirectXrpToXrp (Strand const &strand)
template<>
bool	isDirectXrpToXrp< XRPAmount, XRPAmount > (Strand const &strand)
template bool	isDirectXrpToXrp< XRPAmount, IOUAmount > (Strand const &strand)
template bool	isDirectXrpToXrp< IOUAmount, XRPAmount > (Strand const &strand)
template bool	isDirectXrpToXrp< IOUAmount, IOUAmount > (Strand const &strand)
TER	checkFreeze (ReadView const &view, AccountID const &src, AccountID const &dst, Currency const &currency)
TER	checkNoRipple (ReadView const &view, AccountID const &prev, AccountID const &cur, AccountID const &next, Currency const &currency, beast::Journal j)
bool	redeems (DebtDirection dir)
bool	issues (DebtDirection dir)
std::pair< TER, STPath >	normalizePath (AccountID const &src, AccountID const &dst, Issue const &deliver, std::optional< Issue > const &sendMaxIssue, STPath const &path)
template<class TInAmt , class TOutAmt >
StrandResult< TInAmt, TOutAmt >	flow (PaymentSandbox const &baseView, Strand const &strand, std::optional< TInAmt > const &maxIn, TOutAmt const &out, beast::Journal j)
	Request out amount from a strand. More...
template<class TInAmt , class TOutAmt >
FlowResult< TInAmt, TOutAmt >	flow (PaymentSandbox const &baseView, std::vector< Strand > const &strands, TOutAmt const &outReq, bool partialPayment, bool offerCrossing, std::optional< Quality > const &limitQuality, std::optional< STAmount > const &sendMaxST, beast::Journal j, path::detail::FlowDebugInfo *flowDebugInfo=nullptr)
	Request out amount from a collection of strands. More...
template<class TDerived >
bool	operator== (XRPEndpointStep< TDerived > const &lhs, XRPEndpointStep< TDerived > const &rhs)
std::pair< TER, std::unique_ptr< Step > >	make_XRPEndpointStep (StrandContext const &ctx, AccountID const &acc)
static bool	isDefaultPath (STPath const &path)
static STPath	removeIssuer (STPath const &path)
void	addUniquePath (STPathSet &pathSet, STPath const &path)
std::vector< RippleState::pointer >	getRippleStateItems (AccountID const &accountID, ReadView const &view)
std::unique_ptr< RelationalDBInterface >	getRelationalDBInterfacePostgres (Application &app, Config const &config, JobQueue &jobQueue)
std::unique_ptr< RelationalDBInterface >	getRelationalDBInterfaceSqlite (Application &app, Config const &config, JobQueue &jobQueue)
std::unique_ptr< DatabaseCon >	makeWalletDB (DatabaseCon::Setup const &setup)
	makeWalletDB Opens wallet DB and returns it. More...
std::unique_ptr< DatabaseCon >	makeTestWalletDB (DatabaseCon::Setup const &setup, std::string const &dbname)
	makeTestWalletDB Opens test wallet DB with arbitrary name. More...
void	getManifests (soci::session &session, std::string const &dbTable, ManifestCache &mCache, beast::Journal j)
	getManifests Loads manifest from wallet DB and stores it in the cache. More...
static void	saveManifest (soci::session &session, std::string const &dbTable, std::string const &serialized)
void	saveManifests (soci::session &session, std::string const &dbTable, std::function< bool(PublicKey const &)> const &isTrusted, hash_map< PublicKey, Manifest > const &map, beast::Journal j)
	saveManifests Saves all given manifests to database. More...
void	addValidatorManifest (soci::session &session, std::string const &serialized)
	addValidatorManifest Saves manifest of validator to database. More...
std::pair< PublicKey, SecretKey >	getNodeIdentity (soci::session &session)
	getNodeIdentity Returns public and private keys of this node. More...
std::unordered_set< PeerReservation, beast::uhash<>, KeyEqual >	getPeerReservationTable (soci::session &session, beast::Journal j)
	getPeerReservationTable Returns peer reservation table. More...
void	insertPeerReservation (soci::session &session, PublicKey const &nodeId, std::string const &description)
	insertPeerReservation Adds entry to peer reservation table. More...
void	deletePeerReservation (soci::session &session, PublicKey const &nodeId)
	deletePeerReservation Deletes entry from peer reservation table. More...
bool	createFeatureVotes (soci::session &session)
	createFeatureVotes Creates FeatureVote table if it is not exists. More...
void	readAmendments (soci::session &session, std::function< void( boost::optional< std::string > amendment_hash, boost::optional< std::string > amendment_name, boost::optional< AmendmentVote > vote)> const &callback)
	readAmendments Read all amendments from FeatureVotes table. More...
void	voteAmendment (soci::session &session, uint256 const &amendment, std::string const &name, AmendmentVote vote)
	voteAmendment Set veto value for particular amendment. More...
void	initStateDB (soci::session &session, BasicConfig const &config, std::string const &dbName)
	initStateDB Opens DB session with State DB. More...
LedgerIndex	getCanDelete (soci::session &session)
	getCanDelete Returns ledger sequence which can be deleted. More...
LedgerIndex	setCanDelete (soci::session &session, LedgerIndex canDelete)
	setCanDelete Updates ledger sequence which can be deleted. More...
SavedState	getSavedState (soci::session &session)
	getSavedState Returns saved state. More...
void	setSavedState (soci::session &session, SavedState const &state)
	setSavedState Saves given state. More...
void	setLastRotated (soci::session &session, LedgerIndex seq)
	setLastRotated Updates last rotated ledger sequence. More...
std::pair< std::unique_ptr< DatabaseCon >, std::optional< std::uint64_t > >	openDatabaseBodyDb (DatabaseCon::Setup const &setup, boost::filesystem::path const &path)
	openDatabaseBodyDb Opens file download DB and returns its descriptor. More...
std::uint64_t	databaseBodyDoPut (soci::session &session, std::string const &data, std::string const &path, std::uint64_t fileSize, std::uint64_t part, std::uint16_t maxRowSizePad)
	databaseBodyDoPut Saves new fragment of downloaded file. More...
void	databaseBodyFinish (soci::session &session, std::ofstream &fout)
	databaseBodyFinish Finishes download process and writes file to disk. More...
bool	doVacuumDB (DatabaseCon::Setup const &setup)
	doVacuumDB Creates, initialises DB, and performs its cleanup. More...
void	initPeerFinderDB (soci::session &session, BasicConfig const &config, beast::Journal j)
	initPeerFinderDB Opens session with peer finder database. More...
void	updatePeerFinderDB (soci::session &session, int currentSchemaVersion, beast::Journal j)
	updatePeerFinderDB Update peer finder DB to new version. More...
void	readPeerFinderDB (soci::session &session, std::function< void(std::string const &, int)> const &func)
	readPeerFinderDB Read all entries from peer finder DB and call given callback for each entry. More...
void	savePeerFinderDB (soci::session &session, std::vector< PeerFinder::Store::Entry > const &v)
	savePeerFinderDB Save new entry to peer finder DB. More...
static std::string	to_string (TableType type)
	to_string Returns name of table by table ID. More...
DatabasePairValid	makeLedgerDBs (Config const &config, DatabaseCon::Setup const &setup, DatabaseCon::CheckpointerSetup const &checkpointerSetup)
	makeLedgerDBs Opens ledger and transactions databases. More...
std::optional< LedgerIndex >	getMinLedgerSeq (soci::session &session, TableType type)
	getMinLedgerSeq Returns minimum ledger sequence in given table. More...
std::optional< LedgerIndex >	getMaxLedgerSeq (soci::session &session, TableType type)
	getMaxLedgerSeq Returns maximum ledger sequence in given table. More...
void	deleteByLedgerSeq (soci::session &session, TableType type, LedgerIndex ledgerSeq)
	deleteByLedgerSeq Deletes all entries in given table for the ledger with given sequence. More...
void	deleteBeforeLedgerSeq (soci::session &session, TableType type, LedgerIndex ledgerSeq)
	deleteBeforeLedgerSeq Deletes all entries in given table for the ledgers with given sequence and all sequences below it. More...
std::size_t	getRows (soci::session &session, TableType type)
	getRows Returns number of rows in given table. More...
RelationalDBInterface::CountMinMax	getRowsMinMax (soci::session &session, TableType type)
	getRowsMinMax Returns minumum ledger sequence, maximum ledger sequence and total number of rows in given table. More...
bool	saveValidatedLedger (DatabaseCon &ldgDB, DatabaseCon &txnDB, Application &app, std::shared_ptr< Ledger const > const &ledger, bool current)
	saveValidatedLedger Saves ledger into database. More...
static std::optional< LedgerInfo >	getLedgerInfo (soci::session &session, std::string const &sqlSuffix, beast::Journal j)
	getLedgerInfo Returns info of ledger with special condition given as SQL query. More...
std::optional< LedgerInfo >	getLedgerInfoByIndex (soci::session &session, LedgerIndex ledgerSeq, beast::Journal j)
	getLedgerInfoByIndex Returns ledger by its sequence. More...
std::optional< LedgerInfo >	getNewestLedgerInfo (soci::session &session, beast::Journal j)
	getNewestLedgerInfo Returns info of newest saved ledger. More...
std::optional< LedgerInfo >	getLimitedOldestLedgerInfo (soci::session &session, LedgerIndex ledgerFirstIndex, beast::Journal j)
	getLimitedOldestLedgerInfo Returns info of oldest ledger from ledgers with sequences greather or equal to given. More...
std::optional< LedgerInfo >	getLimitedNewestLedgerInfo (soci::session &session, LedgerIndex ledgerFirstIndex, beast::Journal j)
	getLimitedNewestLedgerInfo Returns info of newest ledger from ledgers with sequences greather or equal to given. More...
std::optional< LedgerInfo >	getLedgerInfoByHash (soci::session &session, uint256 const &ledgerHash, beast::Journal j)
	getLedgerInfoByHash Returns info of ledger with given hash. More...
uint256	getHashByIndex (soci::session &session, LedgerIndex ledgerIndex)
	getHashByIndex Returns hash of ledger with given sequence. More...
std::optional< LedgerHashPair >	getHashesByIndex (soci::session &session, LedgerIndex ledgerIndex, beast::Journal j)
	getHashesByIndex Returns hash of the ledger and hash of parent ledger for the ledger of given sequence. More...
std::map< LedgerIndex, LedgerHashPair >	getHashesByIndex (soci::session &session, LedgerIndex minSeq, LedgerIndex maxSeq, beast::Journal j)
	getHashesByIndex Returns hash of the ledger and hash of parent ledger for all ledgers with seqyences from given minimum limit to fiven maximum limit. More...
std::pair< std::vector< std::shared_ptr< Transaction > >, int >	getTxHistory (soci::session &session, Application &app, LedgerIndex startIndex, int quantity, bool count)
	getTxHistory Returns given number of most recent transactions starting from given number of entry. More...
static std::string	transactionsSQL (Application &app, std::string selection, RelationalDBInterface::AccountTxOptions const &options, std::optional< int > const &limit_used, bool descending, bool binary, bool count, beast::Journal j)
	transactionsSQL Returns SQL query to select oldest or newest transactions in decoded or binary form for given account which match given criteria starting from given offset. More...
static std::pair< RelationalDBInterface::AccountTxs, int >	getAccountTxs (soci::session &session, Application &app, LedgerMaster &ledgerMaster, RelationalDBInterface::AccountTxOptions const &options, std::optional< int > const &limit_used, bool descending, beast::Journal j)
	getAccountTxs Returns oldest or newest transactions for given account which match given criteria starting from given offset. More...
std::pair< RelationalDBInterface::AccountTxs, int >	getOldestAccountTxs (soci::session &session, Application &app, LedgerMaster &ledgerMaster, RelationalDBInterface::AccountTxOptions const &options, std::optional< int > const &limit_used, beast::Journal j)
	getOldestAccountTxs Returns oldest transactions for given account which match given criteria starting from given offset. More...
std::pair< RelationalDBInterface::AccountTxs, int >	getNewestAccountTxs (soci::session &session, Application &app, LedgerMaster &ledgerMaster, RelationalDBInterface::AccountTxOptions const &options, std::optional< int > const &limit_used, beast::Journal j)
	getNewestAccountTxs Returns newest transactions for given account which match given criteria starting from given offset. More...
static std::pair< std::vector< RelationalDBInterface::txnMetaLedgerType >, int >	getAccountTxsB (soci::session &session, Application &app, RelationalDBInterface::AccountTxOptions const &options, std::optional< int > const &limit_used, bool descending, beast::Journal j)
	getAccountTxsB Returns oldest or newset transactions in binary form for given account which match given criteria starting from given offset. More...
std::pair< std::vector< RelationalDBInterface::txnMetaLedgerType >, int >	getOldestAccountTxsB (soci::session &session, Application &app, RelationalDBInterface::AccountTxOptions const &options, std::optional< int > const &limit_used, beast::Journal j)
	getOldestAccountTxsB Returns oldest transactions in binary form for given account which match given criteria starting from given offset. More...
std::pair< std::vector< RelationalDBInterface::txnMetaLedgerType >, int >	getNewestAccountTxsB (soci::session &session, Application &app, RelationalDBInterface::AccountTxOptions const &options, std::optional< int > const &limit_used, beast::Journal j)
	getNewestAccountTxsB Returns newest transactions in binary form for given account which match given criteria starting from given offset. More...
static std::pair< std::optional< RelationalDBInterface::AccountTxMarker >, int >	accountTxPage (soci::session &session, AccountIDCache const &idCache, std::function< void(std::uint32_t)> const &onUnsavedLedger, std::function< void(std::uint32_t, std::string const &, Blob &&, Blob &&)> const &onTransaction, RelationalDBInterface::AccountTxPageOptions const &options, int limit_used, std::uint32_t page_length, bool forward)
	accountTxPage Searches oldest or newest transactions for given account which match given criteria starting from given marker and calls callback for each found transaction. More...
std::pair< std::optional< RelationalDBInterface::AccountTxMarker >, int >	oldestAccountTxPage (soci::session &session, AccountIDCache const &idCache, std::function< void(std::uint32_t)> const &onUnsavedLedger, std::function< void(std::uint32_t, std::string const &, Blob &&, Blob &&)> const &onTransaction, RelationalDBInterface::AccountTxPageOptions const &options, int limit_used, std::uint32_t page_length)
	oldestAccountTxPage Searches oldest transactions for given account which match given criteria starting from given marker and calls callback for each found transaction. More...
std::pair< std::optional< RelationalDBInterface::AccountTxMarker >, int >	newestAccountTxPage (soci::session &session, AccountIDCache const &idCache, std::function< void(std::uint32_t)> const &onUnsavedLedger, std::function< void(std::uint32_t, std::string const &, Blob &&, Blob &&)> const &onTransaction, RelationalDBInterface::AccountTxPageOptions const &options, int limit_used, std::uint32_t page_length)
	newestAccountTxPage Searches newest transactions for given account which match given criteria starting from given marker and calls callback for each found transaction. More...
std::variant< RelationalDBInterface::AccountTx, TxSearched >	getTransaction (soci::session &session, Application &app, uint256 const &id, std::optional< ClosedInterval< uint32_t >> const &range, error_code_i &ec)
	getTransaction Returns transaction with given hash. More...
bool	dbHasSpace (soci::session &session, Config const &config, beast::Journal j)
	dbHasSpace Checks if given database has available space. More...
std::optional< LedgerIndex >	getMinLedgerSeq (std::shared_ptr< PgPool > const &pgPool, beast::Journal j)
	getMinLedgerSeq Returns minimum ledger sequence from Postgres database More...
std::optional< LedgerIndex >	getMaxLedgerSeq (std::shared_ptr< PgPool > const &pgPool)
	getMaxLedgerSeq Returns maximum ledger sequence from Postgres database More...
std::string	getCompleteLedgers (std::shared_ptr< PgPool > const &pgPool)
	getCompleteLedgers Returns string which contains list of completed ledgers More...
std::chrono::seconds	getValidatedLedgerAge (std::shared_ptr< PgPool > const &pgPool, beast::Journal j)
	getValidatedLedgerAge Returns age of last validated ledger More...
static std::vector< LedgerInfo >	loadLedgerInfos (std::shared_ptr< PgPool > const &pgPool, std::variant< std::monostate, uint256, uint32_t, std::pair< uint32_t, uint32_t >> const &whichLedger, Application &app)
	loadLedgerInfos Load the ledger info for the specified ledger/s from the database More...
static std::optional< LedgerInfo >	loadLedgerHelper (std::shared_ptr< PgPool > const &pgPool, std::variant< std::monostate, uint256, uint32_t > const &whichLedger, Application &app)
	loadLedgerHelper Load a ledger info from Postgres More...
std::optional< LedgerInfo >	getNewestLedgerInfo (std::shared_ptr< PgPool > const &pgPool, Application &app)
	getNewestLedgerInfo Load latest ledger info from Postgres More...
std::optional< LedgerInfo >	getLedgerInfoByIndex (std::shared_ptr< PgPool > const &pgPool, std::uint32_t ledgerIndex, Application &app)
	getLedgerInfoByIndex Load ledger info by index (AKA sequence) from Postgres More...
std::optional< LedgerInfo >	getLedgerInfoByHash (std::shared_ptr< PgPool > const &pgPool, uint256 const &ledgerHash, Application &app)
	getLedgerInfoByHash Load ledger info by hash from Postgres More...
uint256	getHashByIndex (std::shared_ptr< PgPool > const &pgPool, std::uint32_t ledgerIndex, Application &app)
	getHashByIndex Given a ledger sequence, return the ledger hash More...
bool	getHashesByIndex (std::shared_ptr< PgPool > const &pgPool, std::uint32_t ledgerIndex, uint256 &ledgerHash, uint256 &parentHash, Application &app)
	getHashesByIndex Given a ledger sequence, return the ledger hash and the parent hash More...
std::map< std::uint32_t, LedgerHashPair >	getHashesByIndex (std::shared_ptr< PgPool > const &pgPool, std::uint32_t minSeq, std::uint32_t maxSeq, Application &app)
	getHashesByIndex Given a contiguous range of sequences, return a map of sequence -> (hash, parent hash) More...
std::vector< uint256 >	getTxHashes (std::shared_ptr< PgPool > const &pgPool, LedgerIndex seq, Application &app)
	getTxHashes Returns vector of tx hashes by given ledger sequence More...
std::pair< AccountTxResult, RPC::Status >	getAccountTx (std::shared_ptr< PgPool > const &pgPool, AccountTxArgs const &args, Application &app, beast::Journal j)
	getAccountTx Get last account transactions specifies by passed argumenrs structure. More...
Transaction::Locator	locateTransaction (std::shared_ptr< PgPool > const &pgPool, uint256 const &id, Application &app)
	locateTransaction Returns information used to locate a transaction. More...
bool	writeLedgerAndTransactions (std::shared_ptr< PgPool > const &pgPool, LedgerInfo const &info, std::vector< AccountTransactionsData > const &accountTxData, beast::Journal &j)
	writeLedgerAndTransactions Write new ledger and transaction data to Postgres. More...
std::vector< std::shared_ptr< Transaction > >	getTxHistory (std::shared_ptr< PgPool > const &pgPool, LedgerIndex startIndex, Application &app, beast::Journal j)
	getTxHistory Returns most recent 20 transactions starting from given number or entry. More...
DatabasePair	makeMetaDBs (Config const &config, DatabaseCon::Setup const &setup, DatabaseCon::CheckpointerSetup const &checkpointerSetup)
	makeMetaDBs Opens ledger and transaction 'meta' databases which map ledger hashes and transaction IDs to the index of the shard that holds the ledger or transaction. More...
bool	saveLedgerMeta (std::shared_ptr< Ledger const > const &ledger, Application &app, soci::session &lgrMetaSession, soci::session &txnMetaSession, std::uint32_t shardIndex)
	saveLedgerMeta Stores (transaction ID -> shard index) and (ledger hash -> shard index) mappings in the meta databases. More...
std::optional< std::uint32_t >	getShardIndexforLedger (soci::session &session, LedgerHash const &hash)
	getShardIndexforLedger Queries the ledger meta database to retrieve the index of the shard that contains this ledger. More...
std::optional< std::uint32_t >	getShardIndexforTransaction (soci::session &session, TxID const &id)
	getShardIndexforTransaction Queries the transaction meta database to retrieve the index of the shard that contains this transaction. More...
DatabasePair	makeShardCompleteLedgerDBs (Config const &config, DatabaseCon::Setup const &setup)
	makeShardCompleteLedgerDBs Opens shard databases for already verified shard and returns its descriptors. More...
DatabasePair	makeShardIncompleteLedgerDBs (Config const &config, DatabaseCon::Setup const &setup, DatabaseCon::CheckpointerSetup const &checkpointerSetup)
	makeShardIncompleteLedgerDBs Opens shard databases for not fully downloaded or verified shard and returns its descriptors. More...
bool	updateLedgerDBs (soci::session &txdb, soci::session &lgrdb, std::shared_ptr< Ledger const > const &ledger, std::uint32_t index, std::atomic< bool > &stop, beast::Journal j)
	updateLedgerDBs Save given ledger to shard databases. More...
std::unique_ptr< DatabaseCon >	makeAcquireDB (DatabaseCon::Setup const &setup, DatabaseCon::CheckpointerSetup const &checkpointerSetup)
	makeAcquireDB Opens shard acquire DB and returns its descriptor. More...
void	insertAcquireDBIndex (soci::session &session, std::uint32_t index)
	insertAcquireDBIndex Adds new shard index to shard acquire DB. More...
std::pair< bool, std::optional< std::string > >	selectAcquireDBLedgerSeqs (soci::session &session, std::uint32_t index)
	selectAcquireDBLedgerSeqs Returns set of acquired ledgers for given shard. More...
std::pair< bool, AcquireShardSeqsHash >	selectAcquireDBLedgerSeqsHash (soci::session &session, std::uint32_t index)
	selectAcquireDBLedgerSeqsHash Returns set of acquired ledgers and hash for given shard. More...
void	updateAcquireDB (soci::session &session, std::shared_ptr< Ledger const > const &ledger, std::uint32_t index, std::uint32_t lastSeq, std::optional< std::string > const &seqs)
	updateAcquireDB Updates information in acquire DB. More...
std::unique_ptr< DatabaseCon >	makeArchiveDB (boost::filesystem::path const &dir, std::string const &dbName)
	makeArchiveDB Opens shard archive DB and returns its descriptor. More...
void	readArchiveDB (DatabaseCon &db, std::function< void(std::string const &, int)> const &func)
	readArchiveDB Read entries from shard archive database and calls fiven callback for each entry. More...
void	insertArchiveDB (DatabaseCon &db, std::uint32_t shardIndex, std::string const &url)
	insertArchiveDB Adds entry to shard archive database. More...
void	deleteFromArchiveDB (DatabaseCon &db, std::uint32_t shardIndex)
	deleteFromArchiveDB Deletes entry from shard archive DB. More...
void	dropArchiveDB (DatabaseCon &db)
	dropArchiveDB Removes table in shard archive DB. More...
template<class T , class C >
T	rangeCheckedCast (C c)
std::vector< uint256 >	getMarkers (size_t numMarkers)
	Parititions the uint256 keyspace into numMarkers partitions, each of equal size. More...
Json::Value	forwardToP2p (RPC::JsonContext &context)
	Forward a JSON request to a p2p node and return the response. More...
std::unique_ptr< org::xrpl::rpc::v1::XRPLedgerAPIService::Stub >	getP2pForwardingStub (RPC::Context &context)
	Get stub used to forward gRPC requests to a p2p node. More...
bool	shouldForwardToP2p (RPC::JsonContext &context)
	Whether a request should be forwarded, based on request parameters. More...
template<class Request >
bool	needCurrentOrClosed (Request &request)
template<class Request >
bool	shouldForwardToP2p (RPC::GRPCContext< Request > &context, RPC::Condition condition)
	Whether a request should be forwarded, based on request parameters. More...
std::pair< Validity, std::string >	checkValidity (HashRouter &router, STTx const &tx, Rules const &rules, Config const &config)
	Checks transaction signature and local checks. More...
void	forceValidity (HashRouter &router, uint256 const &txid, Validity validity)
	Sets the validity of a given transaction in the cache. More...
std::pair< TER, bool >	apply (Application &app, OpenView &view, STTx const &tx, ApplyFlags flags, beast::Journal journal)
	Apply a transaction to an OpenView. More...
ApplyResult	applyTransaction (Application &app, OpenView &view, STTx const &tx, bool retryAssured, ApplyFlags flags, beast::Journal journal)
	Transaction application helper. More...
bool	isTecClaimHardFail (TER ter, ApplyFlags flags)
	Return true if the transaction can claim a fee (tec), and the ApplyFlags do not allow soft failures. More...
PreflightResult	preflight (Application &app, Rules const &rules, STTx const &tx, ApplyFlags flags, beast::Journal j)
	Gate a transaction based on static information. More...
PreclaimResult	preclaim (PreflightResult const &preflightResult, Application &app, OpenView const &view)
	Gate a transaction based on static ledger information. More...
FeeUnit64	calculateBaseFee (ReadView const &view, STTx const &tx)
	Compute only the expected base fee for a transaction. More...
XRPAmount	calculateDefaultBaseFee (ReadView const &view, STTx const &tx)
	Return the minimum fee that an "ordinary" transaction would pay. More...
std::pair< TER, bool >	doApply (PreclaimResult const &preclaimResult, Application &app, OpenView &view)
	Apply a prechecked transaction to an OpenView. More...
template<class T , std::enable_if_t< T::ConsequencesFactory==Transactor::Normal, int > = 0>
TxConsequences	consequences_helper (PreflightContext const &ctx)
template<class T >
std::pair< NotTEC, TxConsequences >	invoke_preflight_helper (PreflightContext const &ctx)
static std::pair< NotTEC, TxConsequences >	invoke_preflight (PreflightContext const &ctx)
template<class T >
static TER	invoke_preclaim (PreclaimContext const &ctx)
static FeeUnit64	invoke_calculateBaseFee (ReadView const &view, STTx const &tx)
static std::pair< TER, bool >	invoke_apply (ApplyContext &ctx)
static bool	after (NetClock::time_point now, std::uint32_t mark)
	Has the specified time passed? More...
static bool	checkCondition (Slice f, Slice c)
InvariantChecks	getInvariantChecks ()
	get a tuple of all invariant checks More...
template<class TIn , class TOut >
std::ostream &	operator<< (std::ostream &os, TOffer< TIn, TOut > const &offer)
static STAmount	accountFundsHelper (ReadView const &view, AccountID const &id, STAmount const &saDefault, Issue const &, FreezeHandling freezeHandling, beast::Journal j)
static IOUAmount	accountFundsHelper (ReadView const &view, AccountID const &id, IOUAmount const &amtDefault, Issue const &issue, FreezeHandling freezeHandling, beast::Journal j)
static XRPAmount	accountFundsHelper (ReadView const &view, AccountID const &id, XRPAmount const &amtDefault, Issue const &issue, FreezeHandling freezeHandling, beast::Journal j)
static TER	closeChannel (std::shared_ptr< SLE > const &slep, ApplyView &view, uint256 const &key, beast::Journal j)
static int	signerCountBasedOwnerCountDelta (std::size_t entryCount)
static TER	removeSignersFromLedger (Application &app, ApplyView &view, Keylet const &accountKeylet, Keylet const &ownerDirKeylet, Keylet const &signerListKeylet, beast::Journal j)
static std::string	format_amount (STAmount const &amount)
static STAmount	qual_div (STAmount const &amount, Quality const &quality, STAmount const &output)
static STAmount	qual_mul (STAmount const &amount, Quality const &quality, STAmount const &output)
NotTEC	preflight0 (PreflightContext const &ctx)
	Performs early sanity checks on the txid. More...
NotTEC	preflight1 (PreflightContext const &ctx)
	Performs early sanity checks on the account and fee fields. More...
NotTEC	preflight2 (PreflightContext const &ctx)
	Checks whether the signature appears valid. More...
static void	removeUnfundedOffers (ApplyView &view, std::vector< uint256 > const &offers, beast::Journal viewJ)
template<class InputIter1 , class InputIter2 , class Action , class Comp >
void	generalized_set_intersection (InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, Action action, Comp comp)
template<class FwdIter1 , class InputIter2 , class Pred , class Comp >
FwdIter1	remove_if_intersect_or_match (FwdIter1 first1, FwdIter1 last1, InputIter2 first2, InputIter2 last2, Pred pred, Comp comp)
void	extractTarLz4 (boost::filesystem::path const &src, boost::filesystem::path const &dst)
	Extract a tar archive compressed with lz4. More...
std::string	base64_encode (std::uint8_t const *data, std::size_t len)
std::string	base64_encode (std::string const &s)
std::string	base64_decode (std::string const &data)
template<std::size_t Bits, class Tag >
int	compare (base_uint< Bits, Tag > const &a, base_uint< Bits, Tag > const &b)
template<std::size_t Bits, class Tag >
bool	operator< (base_uint< Bits, Tag > const &a, base_uint< Bits, Tag > const &b)
template<std::size_t Bits, class Tag >
bool	operator<= (base_uint< Bits, Tag > const &a, base_uint< Bits, Tag > const &b)
template<std::size_t Bits, class Tag >
bool	operator> (base_uint< Bits, Tag > const &a, base_uint< Bits, Tag > const &b)
template<std::size_t Bits, class Tag >
bool	operator>= (base_uint< Bits, Tag > const &a, base_uint< Bits, Tag > const &b)
template<std::size_t Bits, class Tag >
bool	operator== (base_uint< Bits, Tag > const &a, base_uint< Bits, Tag > const &b)
template<std::size_t Bits, class Tag >
bool	operator!= (base_uint< Bits, Tag > const &a, base_uint< Bits, Tag > const &b)
template<std::size_t Bits, class Tag >
bool	operator== (base_uint< Bits, Tag > const &a, std::uint64_t b)
template<std::size_t Bits, class Tag >
bool	operator!= (base_uint< Bits, Tag > const &a, std::uint64_t b)
template<std::size_t Bits, class Tag >
const base_uint< Bits, Tag >	operator^ (base_uint< Bits, Tag > const &a, base_uint< Bits, Tag > const &b)
template<std::size_t Bits, class Tag >
const base_uint< Bits, Tag >	operator& (base_uint< Bits, Tag > const &a, base_uint< Bits, Tag > const &b)
template<std::size_t Bits, class Tag >
const base_uint< Bits, Tag >	operator| (base_uint< Bits, Tag > const &a, base_uint< Bits, Tag > const &b)
template<std::size_t Bits, class Tag >
const base_uint< Bits, Tag >	operator+ (base_uint< Bits, Tag > const &a, base_uint< Bits, Tag > const &b)
template<std::size_t Bits, class Tag >
std::string	to_string (base_uint< Bits, Tag > const &a)
template<std::size_t Bits, class Tag >
std::ostream &	operator<< (std::ostream &out, base_uint< Bits, Tag > const &u)
template<class T >
bool	set (T &target, std::string const &name, Section const &section)
	Set a value from a configuration Section If the named value is not found or doesn't parse as a T, the variable is unchanged. More...
template<class T >
bool	set (T &target, T const &defaultValue, std::string const &name, Section const &section)
	Set a value from a configuration Section If the named value is not found or doesn't cast to T, the variable is assigned the default. More...
template<class T = std::string>
T	get (Section const &section, std::string const &name, T const &defaultValue=T{})
	Retrieve a key/value pair from a section. More...
std::string	get (Section const &section, std::string const &name, const char *defaultValue)
template<class T >
bool	get_if_exists (Section const &section, std::string const &name, T &v)
template<>
bool	get_if_exists< bool > (Section const &section, std::string const &name, bool &v)
bool	operator== (Buffer const &lhs, Buffer const &rhs) noexcept
bool	operator!= (Buffer const &lhs, Buffer const &rhs) noexcept
template<class T >
constexpr auto	kilobytes (T value) noexcept
template<class T >
constexpr auto	megabytes (T value) noexcept
template<class Duration >
std::string	to_string (date::sys_time< Duration > tp)
std::string	to_string (NetClock::time_point tp)
Stopwatch &	stopwatch ()
	Returns an instance of a wall clock. More...
void	LogThrow (std::string const &title)
	Generates and logs a call stack. More...
void	Rethrow ()
	Rethrow the exception currently being handled. More...
template<class E , class... Args>
void	Throw (Args &&... args)
void	LogicError (std::string const &how) noexcept
	Called when faulty logic causes a broken invariant. More...
template<typename E , std::size_t N>
	Unexpected (E(&)[N]) -> Unexpected< E const * >
template<class Source1 , class Source2 , class Dest , class = feeunit::enable_muldiv_t<Source1, Source2, Dest>>
std::pair< bool, Dest >	mulDiv (Source1 value, Dest mul, Source2 div)
template<class Source1 , class Source2 , class Dest , class = feeunit::enable_muldiv_commute_t<Source1, Source2, Dest>>
std::pair< bool, Dest >	mulDiv (Dest value, Source1 mul, Source2 div)
template<class Dest , class = feeunit::enable_muldiv_dest_t<Dest>>
std::pair< bool, Dest >	mulDiv (std::uint64_t value, Dest mul, std::uint64_t div)
template<class Dest , class = feeunit::enable_muldiv_dest_t<Dest>>
std::pair< bool, Dest >	mulDiv (Dest value, std::uint64_t mul, std::uint64_t div)
template<class Source1 , class Source2 , class = feeunit::enable_muldiv_sources_t<Source1, Source2>>
std::pair< bool, std::uint64_t >	mulDiv (Source1 value, std::uint64_t mul, Source2 div)
template<class Source1 , class Source2 , class = feeunit::enable_muldiv_sources_t<Source1, Source2>>
std::pair< bool, std::uint64_t >	mulDiv (std::uint64_t value, Source1 mul, Source2 div)
template<class Dest , class Src >
constexpr std::enable_if_t< std::is_same_v< typename Dest::unit_type, typename Src::unit_type > &&std::is_integral_v< typename Dest::value_type > &&std::is_integral_v< typename Src::value_type >, Dest >	safe_cast (Src s) noexcept
template<class Dest , class Src >
constexpr std::enable_if_t< std::is_same_v< typename Dest::unit_type, typename Src::unit_type > &&std::is_integral_v< typename Dest::value_type > &&std::is_integral_v< typename Src::value_type >, Dest >	unsafe_cast (Src s) noexcept
std::string	getFileContents (boost::system::error_code &ec, boost::filesystem::path const &sourcePath, std::optional< std::size_t > maxSize=std::nullopt)
void	writeFileContents (boost::system::error_code &ec, boost::filesystem::path const &destPath, std::string const &contents)
std::ostream &	operator<< (std::ostream &os, Section const &section)
std::ostream &	operator<< (std::ostream &ss, BasicConfig const &c)
std::string	to_string (IOUAmount const &amount)
IOUAmount	mulRatio (IOUAmount const &amt, std::uint32_t num, std::uint32_t den, bool roundUp)
static DebugSink &	debugSink ()
std::unique_ptr< beast::Journal::Sink >	setDebugLogSink (std::unique_ptr< beast::Journal::Sink > sink)
	Set the sink for the debug journal. More...
beast::Journal	debugLog ()
	Returns a debug journal. More...
std::shared_ptr< boost::asio::ssl::context >	make_SSLContext (std::string const &cipherList)
	Create a self-signed SSL context that allows anonymous Diffie Hellman. More...
std::shared_ptr< boost::asio::ssl::context >	make_SSLContextAuthed (std::string const &keyFile, std::string const &certFile, std::string const &chainFile, std::string const &cipherList)
	Create an authenticated SSL context using the specified files. More...
std::pair< bool, std::uint64_t >	mulDiv (std::uint64_t value, std::uint64_t mul, std::uint64_t div)
	Return value*mul/div accurately. More...
std::string	sqlBlobLiteral (Blob const &blob)
	Format arbitrary binary data as an SQLite "blob literal". More...
bool	parseUrl (parsedURL &pUrl, std::string const &strUrl)
constexpr std::size_t	calculatePercent (std::size_t count, std::size_t total)
	Calculate one number divided by another number in percentage. More...
beast::xor_shift_engine &	default_prng ()
	Return the default random engine. More...
template<class T >
ClosedInterval< T >	range (T low, T high)
	Create a closed range interval. More...
template<class T >
std::string	to_string (ClosedInterval< T > const &ci)
	Convert a ClosedInterval to a styled string. More...
template<class T >
std::string	to_string (RangeSet< T > const &rs)
	Convert the given RangeSet to a styled string. More...
template<class T >
bool	from_string (RangeSet< T > &rs, std::string const &s)
	Convert the given styled string to a RangeSet. More...
template<class T >
std::optional< T >	prevMissing (RangeSet< T > const &rs, T t, T minVal=0)
	Find the largest value not in the set that is less than a given value. More...
template<class Dest , class Src >
constexpr std::enable_if_t< std::is_integral_v< Dest > &&std::is_integral_v< Src >, Dest >	safe_cast (Src s) noexcept
template<class Dest , class Src >
constexpr std::enable_if_t< std::is_enum_v< Dest > &&std::is_integral_v< Src >, Dest >	safe_cast (Src s) noexcept
template<class Dest , class Src >
constexpr std::enable_if_t< std::is_integral_v< Dest > &&std::is_enum_v< Src >, Dest >	safe_cast (Src s) noexcept
template<class Dest , class Src >
constexpr std::enable_if_t< std::is_integral_v< Dest > &&std::is_integral_v< Src >, Dest >	unsafe_cast (Src s) noexcept
template<class Dest , class Src >
constexpr std::enable_if_t< std::is_enum_v< Dest > &&std::is_integral_v< Src >, Dest >	unsafe_cast (Src s) noexcept
template<class Dest , class Src >
constexpr std::enable_if_t< std::is_integral_v< Dest > &&std::is_enum_v< Src >, Dest >	unsafe_cast (Src s) noexcept
template<class EF >
	scope_exit (EF) -> scope_exit< EF >
template<class EF >
	scope_fail (EF) -> scope_fail< EF >
template<class EF >
	scope_success (EF) -> scope_success< EF >
template<class Hasher >
void	hash_append (Hasher &h, Slice const &v)
bool	operator== (Slice const &lhs, Slice const &rhs) noexcept
bool	operator!= (Slice const &lhs, Slice const &rhs) noexcept
bool	operator< (Slice const &lhs, Slice const &rhs) noexcept
template<class Stream >
Stream &	operator<< (Stream &s, Slice const &v)
template<class T , std::size_t N>
std::enable_if_t< std::is_same< T, char >::value||std::is_same< T, unsigned char >::value, Slice >	makeSlice (std::array< T, N > const &a)
template<class T , class Alloc >
std::enable_if_t< std::is_same< T, char >::value||std::is_same< T, unsigned char >::value, Slice >	makeSlice (std::vector< T, Alloc > const &v)
template<class Traits , class Alloc >
Slice	makeSlice (std::basic_string< char, Traits, Alloc > const &s)
template<class FwdIt >
std::string	strHex (FwdIt begin, FwdIt end)
template<class T , class = decltype(std::declval<T>().begin())>
std::string	strHex (T const &from)
template<class Iterator >
std::optional< Blob >	strUnHex (std::size_t strSize, Iterator begin, Iterator end)
std::optional< Blob >	strUnHex (std::string const &strSrc)
std::optional< Blob >	strViewUnHex (boost::string_view const &strSrc)
std::string	trim_whitespace (std::string str)
std::optional< std::uint64_t >	to_uint64 (std::string const &s)
bool	isProperlyFormedTomlDomain (std::string const &domain)
	Determines if the given string looks like a TOML-file hosting domain. More...
template<class T >
std::enable_if< std::is_arithmetic< T >::value, std::string >::type	to_string (T t)
	to_string() generalizes std::to_string to handle bools, chars, and strings. More...
std::string	to_string (bool b)
std::string	to_string (char c)
std::string	to_string (std::string s)
std::string	to_string (char const *s)
template<class Char , class Traits >
std::basic_ostream< Char, Traits > &	operator<< (std::basic_ostream< Char, Traits > &os, const XRPAmount &q)
std::string	to_string (XRPAmount const &amount)
XRPAmount	mulRatio (XRPAmount const &amt, std::uint32_t num, std::uint32_t den, bool roundUp)
bool	shouldCloseLedger (bool anyTransactions, std::size_t prevProposers, std::size_t proposersClosed, std::size_t proposersValidated, std::chrono::milliseconds prevRoundTime, std::chrono::milliseconds timeSincePrevClose, std::chrono::milliseconds openTime, std::chrono::milliseconds idleInterval, ConsensusParms const &parms, beast::Journal j)
	Determines whether the current ledger should close at this time. More...
bool	checkConsensusReached (std::size_t agreeing, std::size_t total, bool count_self, std::size_t minConsensusPct)
ConsensusState	checkConsensus (std::size_t prevProposers, std::size_t currentProposers, std::size_t currentAgree, std::size_t currentFinished, std::chrono::milliseconds previousAgreeTime, std::chrono::milliseconds currentAgreeTime, ConsensusParms const &parms, bool proposing, beast::Journal j)
	Determine whether the network reached consensus and whether we joined. More...
int	participantsNeeded (int participants, int percent)
	How many of the participants must agree to reach a given threshold? More...
template<class NodeID_t , class LedgerID_t , class Position_t >
bool	operator== (ConsensusProposal< NodeID_t, LedgerID_t, Position_t > const &a, ConsensusProposal< NodeID_t, LedgerID_t, Position_t > const &b)
std::string	to_string (ConsensusMode m)
std::string	to_string (ConsensusPhase p)
template<class Rep , class Period , class Seq >
std::chrono::duration< Rep, Period >	getNextLedgerTimeResolution (std::chrono::duration< Rep, Period > previousResolution, bool previousAgree, Seq ledgerSeq)
	Calculates the close time resolution for the specified ledger. More...
template<class Clock , class Duration , class Rep , class Period >
std::chrono::time_point< Clock, Duration >	roundCloseTime (std::chrono::time_point< Clock, Duration > closeTime, std::chrono::duration< Rep, Period > closeResolution)
	Calculates the close time for a ledger, given a close time resolution. More...
template<class Clock , class Duration , class Rep , class Period >
std::chrono::time_point< Clock, Duration >	effCloseTime (std::chrono::time_point< Clock, Duration > closeTime, std::chrono::duration< Rep, Period > resolution, std::chrono::time_point< Clock, Duration > priorCloseTime)
	Calculate the effective ledger close time. More...
bool	isCurrent (ValidationParms const &p, NetClock::time_point now, NetClock::time_point signTime, NetClock::time_point seenTime)
	Whether a validation is still current. More...
std::string	to_string (ValStatus m)
std::shared_ptr< Checkpointer >	checkpointerFromId (std::uintptr_t id)
DatabaseCon::Setup	setup_DatabaseCon (Config const &c, std::optional< beast::Journal > j=std::nullopt)
IniFileSections	parseIniFile (std::string const &strInput, const bool bTrim)
IniFileSections::mapped_type *	getIniFileSection (IniFileSections &secSource, std::string const &strSection)
bool	getSingleSection (IniFileSections &secSource, std::string const &strSection, std::string &strValue, beast::Journal j)
static std::string	getEnvVar (char const *name)
std::unique_ptr< SNTPClock >	make_SNTPClock (beast::Journal j)
void	open (soci::session &s, BasicConfig const &config, std::string const &dbName)
	Open a soci session. More...
void	open (soci::session &s, std::string const &beName, std::string const &connectionString)
	Open a soci session. More...
static sqlite_api::sqlite3 *	getConnection (soci::session &s)
std::uint32_t	getKBUsedAll (soci::session &s)
std::uint32_t	getKBUsedDB (soci::session &s)
void	convert (soci::blob &from, std::vector< std::uint8_t > &to)
void	convert (soci::blob &from, std::string &to)
void	convert (std::vector< std::uint8_t > const &from, soci::blob &to)
void	convert (std::string const &from, soci::blob &to)
std::shared_ptr< Checkpointer >	makeCheckpointer (std::uintptr_t id, std::weak_ptr< soci::session >, JobQueue &, Logs &)
	Returns a new checkpointer which makes checkpoints of a soci database every checkpointPageCount pages, using a job on the job queue. More...
std::unique_ptr< TimeKeeper >	make_TimeKeeper (beast::Journal j)
csprng_engine &	crypto_prng ()
	The default cryptographically secure PRNG. More...
void	secure_erase (void *dest, std::size_t bytes)
	Attempts to clear the given blob of memory. More...
constexpr ApplyFlags	operator| (ApplyFlags const &lhs, ApplyFlags const &rhs)
constexpr ApplyFlags	operator& (ApplyFlags const &lhs, ApplyFlags const &rhs)
constexpr ApplyFlags	operator~ (ApplyFlags const &flags)
ApplyFlags	operator|= (ApplyFlags &lhs, ApplyFlags const &rhs)
ApplyFlags	operator&= (ApplyFlags &lhs, ApplyFlags const &rhs)
void	addRaw (LedgerInfo const &info, Serializer &s, bool includeHash)
bool	isGlobalFrozen (ReadView const &view, AccountID const &issuer)
bool	isFrozen (ReadView const &view, AccountID const &account, Currency const &currency, AccountID const &issuer)
STAmount	accountHolds (ReadView const &view, AccountID const &account, Currency const &currency, AccountID const &issuer, FreezeHandling zeroIfFrozen, beast::Journal j)
STAmount	accountFunds (ReadView const &view, AccountID const &id, STAmount const &saDefault, FreezeHandling freezeHandling, beast::Journal j)
static std::uint32_t	confineOwnerCount (std::uint32_t current, std::int32_t adjustment, std::optional< AccountID > const &id=std::nullopt, beast::Journal j=beast::Journal{beast::Journal::getNullSink()})
XRPAmount	xrpLiquid (ReadView const &view, AccountID const &id, std::int32_t ownerCountAdj, beast::Journal j)
void	forEachItem (ReadView const &view, AccountID const &id, std::function< void(std::shared_ptr< SLE const > const &)> f)
	Iterate all items in an account's owner directory. More...
bool	forEachItemAfter (ReadView const &view, AccountID const &id, uint256 const &after, std::uint64_t const hint, unsigned int limit, std::function< bool(std::shared_ptr< SLE const > const &)> f)
	Iterate all items after an item in an owner directory. More...
Rate	transferRate (ReadView const &view, AccountID const &issuer)
bool	areCompatible (ReadView const &validLedger, ReadView const &testLedger, beast::Journal::Stream &s, const char *reason)
	Return false if the test ledger is provably incompatible with the valid ledger, that is, they could not possibly both be valid. More...
bool	areCompatible (uint256 const &validHash, LedgerIndex validIndex, ReadView const &testLedger, beast::Journal::Stream &s, const char *reason)
bool	dirIsEmpty (ReadView const &view, Keylet const &k)
	Returns true if the directory is empty. More...
std::set< uint256 >	getEnabledAmendments (ReadView const &view)
majorityAmendments_t	getMajorityAmendments (ReadView const &view)
std::optional< uint256 >	hashOfSeq (ReadView const &ledger, LedgerIndex seq, beast::Journal journal)
	Return the hash of a ledger by sequence. More...
void	adjustOwnerCount (ApplyView &view, std::shared_ptr< SLE > const &sle, std::int32_t amount, beast::Journal j)
	Adjust the owner count up or down. More...
std::function< void(SLE::ref)>	describeOwnerDir (AccountID const &account)
TER	trustCreate (ApplyView &view, const bool bSrcHigh, AccountID const &uSrcAccountID, AccountID const &uDstAccountID, uint256 const &uIndex, SLE::ref sleAccount, const bool bAuth, const bool bNoRipple, const bool bFreeze, STAmount const &saBalance, STAmount const &saLimit, std::uint32_t uSrcQualityIn, std::uint32_t uSrcQualityOut, beast::Journal j)
	Create a trust line. More...
TER	trustDelete (ApplyView &view, std::shared_ptr< SLE > const &sleRippleState, AccountID const &uLowAccountID, AccountID const &uHighAccountID, beast::Journal j)
TER	offerDelete (ApplyView &view, std::shared_ptr< SLE > const &sle, beast::Journal j)
	Delete an offer. More...
TER	rippleCredit (ApplyView &view, AccountID const &uSenderID, AccountID const &uReceiverID, STAmount const &saAmount, bool bCheckIssuer, beast::Journal j)
static TER	rippleSend (ApplyView &view, AccountID const &uSenderID, AccountID const &uReceiverID, STAmount const &saAmount, STAmount &saActual, beast::Journal j)
TER	accountSend (ApplyView &view, AccountID const &uSenderID, AccountID const &uReceiverID, STAmount const &saAmount, beast::Journal j)
static bool	updateTrustLine (ApplyView &view, SLE::pointer state, bool bSenderHigh, AccountID const &sender, STAmount const &before, STAmount const &after, beast::Journal j)
TER	issueIOU (ApplyView &view, AccountID const &account, STAmount const &amount, Issue const &issue, beast::Journal j)
TER	redeemIOU (ApplyView &view, AccountID const &account, STAmount const &amount, Issue const &issue, beast::Journal j)
TER	transferXRP (ApplyView &view, AccountID const &from, AccountID const &to, STAmount const &amount, beast::Journal j)
bool	getCloseAgree (LedgerInfo const &info)
LedgerIndex	getCandidateLedger (LedgerIndex requested)
	Find a ledger index from which we could easily get the requested ledger. More...
std::shared_ptr< DatabaseDownloader >	make_DatabaseDownloader (boost::asio::io_service &io_service, Config const &config, beast::Journal j)
void	registerSSLCerts (boost::asio::ssl::context &, boost::system::error_code &, beast::Journal j)
	Register default SSL certificates. More...
std::string	createHTTPPost (std::string const &strHost, std::string const &strPath, std::string const &strMsg, std::unordered_map< std::string, std::string > const &mapRequestHeaders)
std::string	JSONRPCRequest (std::string const &strMethod, Json::Value const &params, Json::Value const &id)
static Json::Value	rpcCmdLineToJson (std::vector< std::string > const &args, Json::Value &retParams, beast::Journal j)
Json::Value	cmdLineToJSONRPC (std::vector< std::string > const &args, beast::Journal j)
	Given a rippled command line, return the corresponding JSON. More...
std::pair< int, Json::Value >	rpcClient (std::vector< std::string > const &args, Config const &config, Logs &logs, std::unordered_map< std::string, std::string > const &headers={})
	Internal invocation of RPC client. More...
Json::Value	rpcError (int iError, Json::Value jvResult)
bool	isRpcError (Json::Value jvResult)
std::shared_ptr< RPCSub >	make_RPCSub (InfoSub::Source &source, boost::asio::io_service &io_service, JobQueue &jobQueue, std::string const &strUrl, std::string const &strUsername, std::string const &strPassword, Logs &logs)
std::optional< std::string >	getFeatureValue (boost::beast::http::fields const &headers, std::string const &feature)
	Get feature's header value. More...
bool	isFeatureValue (boost::beast::http::fields const &headers, std::string const &feature, std::string const &value)
	Check if a feature's value is equal to the specified value. More...
bool	featureEnabled (boost::beast::http::fields const &headers, std::string const &feature)
	Check if a feature is enabled. More...
std::string	makeFeaturesRequestHeader (bool comprEnabled, bool ledgerReplayEnabled, bool txReduceRelayEnabled, bool vpReduceRelayEnabled)
	Make request header X-Protocol-Ctl value with supported features. More...
std::string	makeFeaturesResponseHeader (http_request_type const &headers, bool comprEnabled, bool ledgerReplayEnabled, bool txReduceRelayEnabled, bool vpReduceRelayEnabled)
	Make response header X-Protocol-Ctl value with supported features. More...
static std::optional< base_uint< 512 > >	hashLastMessage (SSL const *ssl, size_t(*get)(const SSL *, void *, size_t))
	Hashes the latest finished message from an SSL stream. More...
std::optional< uint256 >	makeSharedValue (stream_type &ssl, beast::Journal journal)
	Computes a shared value based on the SSL connection state. More...
void	buildHandshake (boost::beast::http::fields &h, uint256 const &sharedValue, std::optional< std::uint32_t > networkID, beast::IP::Address public_ip, beast::IP::Address remote_ip, Application &app)
	Insert fields headers necessary for upgrading the link to the peer protocol. More...
PublicKey	verifyHandshake (boost::beast::http::fields const &headers, uint256 const &sharedValue, std::optional< std::uint32_t > networkID, beast::IP::Address public_ip, beast::IP::Address remote, Application &app)
	Validate header fields necessary for upgrading the link to the peer protocol. More...
auto	makeRequest (bool crawlPublic, bool comprEnabled, bool ledgerReplayEnabled, bool txReduceRelayEnabled, bool vpReduceRelayEnabled)
	Make outbound http request. More...
http_response_type	makeResponse (bool crawlPublic, http_request_type const &req, beast::IP::Address public_ip, beast::IP::Address remote_ip, uint256 const &sharedValue, std::optional< std::uint32_t > networkID, ProtocolVersion version, Application &app)
	Make http response. More...
template<typename headers >
bool	peerFeatureEnabled (headers const &request, std::string const &feature, std::string value, bool config)
	Check if a feature should be enabled for a peer. More...
template<typename headers >
bool	peerFeatureEnabled (headers const &request, std::string const &feature, bool config)
	Wrapper for enable(1)/disable type(0) of feature. More...
std::shared_ptr< Message >	makeSquelchMessage (PublicKey const &validator, bool squelch, uint32_t squelchDuration)
Overlay::Setup	setup_Overlay (BasicConfig const &config)
std::unique_ptr< Overlay >	make_Overlay (Application &app, Overlay::Setup const &setup, ServerHandler &serverHandler, Resource::Manager &resourceManager, Resolver &resolver, boost::asio::io_service &io_service, BasicConfig const &config, beast::insight::Collector::ptr const &collector)
	Creates the implementation of Overlay. More...
static bool	stringIsUint256Sized (std::string const &pBuffStr)
static std::shared_ptr< PeerImp >	getPeerWithTree (OverlayImpl &ov, uint256 const &rootHash, PeerImp const *skip)
static std::shared_ptr< PeerImp >	getPeerWithLedger (OverlayImpl &ov, uint256 const &ledgerHash, LedgerIndex ledger, PeerImp const *skip)
std::unique_ptr< PeerSetBuilder >	make_PeerSetBuilder (Application &app)
std::unique_ptr< PeerSet >	make_DummyPeerSet (Application &app)
	Make a dummy PeerSet that does not do anything. More...
protocol::MessageType	protocolMessageType (protocol::TMGetLedger const &)
protocol::MessageType	protocolMessageType (protocol::TMReplayDeltaRequest const &)
protocol::MessageType	protocolMessageType (protocol::TMProofPathRequest const &)
template<class = void>
std::string	protocolMessageName (int type)
	Returns the name of a protocol message given its type. More...
template<class Buffers , class Handler >
std::pair< std::size_t, boost::system::error_code >	invokeProtocolMessage (Buffers const &buffers, Handler &handler, std::size_t &hint)
	Calls the handler for up to one protocol message in the passed buffers. More...
std::string	to_string (ProtocolVersion const &p)
	Print a protocol version a human-readable string. More...
std::vector< ProtocolVersion >	parseProtocolVersions (boost::beast::string_view const &s)
	Parse a set of protocol versions. More...
std::optional< ProtocolVersion >	negotiateProtocolVersion (std::vector< ProtocolVersion > const &versions)
	Given a list of supported protocol versions, choose the one we prefer. More...
std::optional< ProtocolVersion >	negotiateProtocolVersion (boost::beast::string_view const &versions)
	Given a list of supported protocol versions, choose the one we prefer. More...
std::string const &	supportedProtocolVersions ()
	The list of all the protocol versions we support. More...
bool	isProtocolSupported (ProtocolVersion const &v)
	Determine whether we support a specific protocol version. More...
constexpr ProtocolVersion	make_protocol (std::uint16_t major, std::uint16_t minor)
template<typename Predicate >
send_if_pred< Predicate >	send_if (std::shared_ptr< Message > const &m, Predicate const &f)
	Helper function to aid in type deduction. More...
template<typename Predicate >
send_if_not_pred< Predicate >	send_if_not (std::shared_ptr< Message > const &m, Predicate const &f)
	Helper function to aid in type deduction. More...
std::string	toBase58 (AccountID const &v)
	Convert AccountID to base58 checked string. More...
template<>
std::optional< AccountID >	parseBase58 (std::string const &s)
	Parse AccountID from checked, base58 string. More...
AccountID const &	xrpAccount ()
	Compute AccountID from public key. More...
AccountID const &	noAccount ()
	A placeholder for empty accounts. More...
bool	to_issuer (AccountID &, std::string const &)
	Convert hex or base58 string to AccountID. More...
bool	isXRP (AccountID const &c)
std::string	to_string (Currency const &c)
	Returns "", "XRP", or three letter ISO code. More...
std::ostream &	operator<< (std::ostream &os, AccountID const &x)
STAmount	toSTAmount (IOUAmount const &iou, Issue const &iss)
STAmount	toSTAmount (IOUAmount const &iou)
STAmount	toSTAmount (XRPAmount const &xrp)
STAmount	toSTAmount (XRPAmount const &xrp, Issue const &iss)
template<class T >
T	toAmount (STAmount const &amt)=delete
template<>
STAmount	toAmount< STAmount > (STAmount const &amt)
template<>
IOUAmount	toAmount< IOUAmount > (STAmount const &amt)
template<>
XRPAmount	toAmount< XRPAmount > (STAmount const &amt)
template<class T >
T	toAmount (IOUAmount const &amt)=delete
template<>
IOUAmount	toAmount< IOUAmount > (IOUAmount const &amt)
template<class T >
T	toAmount (XRPAmount const &amt)=delete
template<>
XRPAmount	toAmount< XRPAmount > (XRPAmount const &amt)
bool	isConsistent (Book const &book)
std::string	to_string (Book const &book)
std::ostream &	operator<< (std::ostream &os, Book const &x)
template<class Hasher >
void	hash_append (Hasher &h, Book const &b)
Book	reversed (Book const &book)
int	compare (Book const &lhs, Book const &rhs)
	Ordered comparison. More...
template<class... Args>
sha512_half_hasher::result_type	sha512Half (Args const &... args)
	Returns the SHA512-Half of a series of objects. More...
template<class... Args>
sha512_half_hasher_s::result_type	sha512Half_s (Args const &... args)
	Returns the SHA512-Half of a series of objects. More...
std::string	rpcErrorString (Json::Value const &jv)
	Returns a single string with the contents of an RPC error. More...
std::optional< uint256 >	getRegisteredFeature (std::string const &name)
size_t	featureToBitsetIndex (uint256 const &f)
uint256	bitsetIndexToFeature (size_t i)
std::string	featureToName (uint256 const &f)
template<class F >
void	foreachFeature (FeatureBitset bs, F &&f)
template<class Hasher >
void	hash_append (Hasher &h, HashPrefix const &hp) noexcept
AccountID	calcAccountID (PublicKey const &pk)
std::size_t	hash_value (ripple::uint256 const &feature)
uint256	registerFeature (std::string const &name, Supported support, DefaultVote vote)
uint256	retireFeature (std::string const &name)
bool	registrationIsDone ()
	Tell FeatureCollections when registration is complete. More...
	REGISTER_FEATURE (OwnerPaysFee, Supported::no, DefaultVote::no)
	REGISTER_FEATURE (Flow, Supported::yes, DefaultVote::yes)
	REGISTER_FEATURE (FlowCross, Supported::yes, DefaultVote::yes)
	REGISTER_FEATURE (CryptoConditionsSuite, Supported::yes, DefaultVote::no)
	REGISTER_FIX (fix1513, Supported::yes, DefaultVote::yes)
	REGISTER_FEATURE (DepositAuth, Supported::yes, DefaultVote::yes)
	REGISTER_FEATURE (Checks, Supported::yes, DefaultVote::yes)
	REGISTER_FIX (fix1571, Supported::yes, DefaultVote::yes)
	REGISTER_FIX (fix1543, Supported::yes, DefaultVote::yes)
	REGISTER_FIX (fix1623, Supported::yes, DefaultVote::yes)
	REGISTER_FEATURE (DepositPreauth, Supported::yes, DefaultVote::yes)
	REGISTER_FIX (fix1515, Supported::yes, DefaultVote::yes)
	REGISTER_FIX (fix1578, Supported::yes, DefaultVote::yes)
	REGISTER_FEATURE (MultiSignReserve, Supported::yes, DefaultVote::yes)
	REGISTER_FIX (fixTakerDryOfferRemoval, Supported::yes, DefaultVote::yes)
	REGISTER_FIX (fixMasterKeyAsRegularKey, Supported::yes, DefaultVote::yes)
	REGISTER_FIX (fixCheckThreading, Supported::yes, DefaultVote::yes)
	REGISTER_FIX (fixPayChanRecipientOwnerDir, Supported::yes, DefaultVote::yes)
	REGISTER_FEATURE (DeletableAccounts, Supported::yes, DefaultVote::yes)
	REGISTER_FIX (fixQualityUpperBound, Supported::yes, DefaultVote::yes)
	REGISTER_FEATURE (RequireFullyCanonicalSig, Supported::yes, DefaultVote::yes)
	REGISTER_FIX (fix1781, Supported::yes, DefaultVote::yes)
	REGISTER_FEATURE (HardenedValidations, Supported::yes, DefaultVote::yes)
	REGISTER_FIX (fixAmendmentMajorityCalc, Supported::yes, DefaultVote::yes)
	REGISTER_FEATURE (NegativeUNL, Supported::yes, DefaultVote::no)
	REGISTER_FEATURE (TicketBatch, Supported::yes, DefaultVote::yes)
	REGISTER_FEATURE (FlowSortStrands, Supported::yes, DefaultVote::yes)
	REGISTER_FIX (fixSTAmountCanonicalize, Supported::yes, DefaultVote::yes)
	REGISTER_FIX (fixRmSmallIncreasedQOffers, Supported::yes, DefaultVote::yes)
	REGISTER_FEATURE (CheckCashMakesTrustLine, Supported::yes, DefaultVote::no)
template<class... Args>
static uint256	indexHash (LedgerNameSpace space, Args const &... args)
uint256	getBookBase (Book const &book)
uint256	getQualityNext (uint256 const &uBase)
std::uint64_t	getQuality (uint256 const &uBase)
uint256	getTicketIndex (AccountID const &account, std::uint32_t ticketSeq)
uint256	getTicketIndex (AccountID const &account, SeqProxy ticketSeq)
bool	isConsistent (Issue const &ac)
std::string	to_string (Issue const &ac)
std::ostream &	operator<< (std::ostream &os, Issue const &x)
int	compare (Issue const &lhs, Issue const &rhs)
	Ordered comparison. More...
std::ostream &	operator<< (std::ostream &os, PublicKey const &pk)
	Print the public key to a stream. More...
template<>
std::optional< PublicKey >	parseBase58 (TokenType type, std::string const &s)
	Parse a secret key. More...
static std::optional< Slice >	sigPart (Slice &buf)
static std::string	sliceToHex (Slice const &slice)
std::optional< ECDSACanonicality >	ecdsaCanonicality (Slice const &sig)
	Determine whether a signature is canonical. More...
static bool	ed25519Canonical (Slice const &sig)
bool	verifyDigest (PublicKey const &publicKey, uint256 const &digest, Slice const &sig, bool mustBeFullyCanonical=true) noexcept
	Verify a secp256k1 signature on the digest of a message. More...
bool	verify (PublicKey const &publicKey, Slice const &m, Slice const &sig, bool mustBeFullyCanonical=true) noexcept
	Verify a signature on a message. More...
NodeID	calcNodeID (PublicKey const &)
	Calculate the 160-bit node ID from a node public key. More...
Quality	composed_quality (Quality const &lhs, Quality const &rhs)
STAmount	multiply (STAmount const &amount, Rate const &rate)
STAmount	multiplyRound (STAmount const &amount, Rate const &rate, bool roundUp)
STAmount	multiplyRound (STAmount const &amount, Rate const &rate, Issue const &issue, bool roundUp)
STAmount	divide (STAmount const &amount, Rate const &rate)
STAmount	divideRound (STAmount const &amount, Rate const &rate, bool roundUp)
STAmount	divideRound (STAmount const &amount, Rate const &rate, Issue const &issue, bool roundUp)
template<class = void>
secp256k1_context const *	secp256k1Context ()
SecretKey	randomSecretKey ()
	Create a secret key using secure random numbers. More...
SecretKey	generateSecretKey (KeyType type, Seed const &seed)
	Generate a new secret key deterministically. More...
PublicKey	derivePublicKey (KeyType type, SecretKey const &sk)
	Derive the public key from a secret key. More...
std::pair< PublicKey, SecretKey >	generateKeyPair (KeyType type, Seed const &seed)
	Generate a key pair deterministically. More...
std::pair< PublicKey, SecretKey >	randomKeyPair (KeyType type)
	Create a key pair using secure random numbers. More...
Seed	randomSeed ()
	Create a seed using secure random numbers. More...
Seed	generateSeed (std::string const &passPhrase)
	Generate a seed deterministically. More...
std::optional< Seed >	parseGenericSeed (std::string const &str)
	Attempt to parse a string as a seed. More...
std::string	seedAs1751 (Seed const &seed)
	Encode a Seed in RFC1751 format. More...
	CONSTRUCT_UNTYPED_SFIELD (sfLedgerEntry, "LedgerEntry", LEDGERENTRY, 257)
	CONSTRUCT_UNTYPED_SFIELD (sfTransaction, "Transaction", TRANSACTION, 257)
	CONSTRUCT_UNTYPED_SFIELD (sfValidation, "Validation", VALIDATION, 257)
	CONSTRUCT_UNTYPED_SFIELD (sfMetadata, "Metadata", METADATA, 257)
	CONSTRUCT_TYPED_SFIELD (sfCloseResolution, "CloseResolution", UINT8, 1)
	CONSTRUCT_TYPED_SFIELD (sfMethod, "Method", UINT8, 2)
	CONSTRUCT_TYPED_SFIELD (sfTransactionResult, "TransactionResult", UINT8, 3)
	CONSTRUCT_TYPED_SFIELD (sfTickSize, "TickSize", UINT8, 16)
	CONSTRUCT_TYPED_SFIELD (sfUNLModifyDisabling, "UNLModifyDisabling", UINT8, 17)
	CONSTRUCT_TYPED_SFIELD (sfLedgerEntryType, "LedgerEntryType", UINT16, 1, SField::sMD_Never)
	CONSTRUCT_TYPED_SFIELD (sfTransactionType, "TransactionType", UINT16, 2)
	CONSTRUCT_TYPED_SFIELD (sfSignerWeight, "SignerWeight", UINT16, 3)
	CONSTRUCT_TYPED_SFIELD (sfVersion, "Version", UINT16, 16)
	CONSTRUCT_TYPED_SFIELD (sfFlags, "Flags", UINT32, 2)
	CONSTRUCT_TYPED_SFIELD (sfSourceTag, "SourceTag", UINT32, 3)
	CONSTRUCT_TYPED_SFIELD (sfSequence, "Sequence", UINT32, 4)
	CONSTRUCT_TYPED_SFIELD (sfPreviousTxnLgrSeq, "PreviousTxnLgrSeq", UINT32, 5, SField::sMD_DeleteFinal)
	CONSTRUCT_TYPED_SFIELD (sfLedgerSequence, "LedgerSequence", UINT32, 6)
	CONSTRUCT_TYPED_SFIELD (sfCloseTime, "CloseTime", UINT32, 7)
	CONSTRUCT_TYPED_SFIELD (sfParentCloseTime, "ParentCloseTime", UINT32, 8)
	CONSTRUCT_TYPED_SFIELD (sfSigningTime, "SigningTime", UINT32, 9)
	CONSTRUCT_TYPED_SFIELD (sfExpiration, "Expiration", UINT32, 10)
	CONSTRUCT_TYPED_SFIELD (sfTransferRate, "TransferRate", UINT32, 11)
	CONSTRUCT_TYPED_SFIELD (sfWalletSize, "WalletSize", UINT32, 12)
	CONSTRUCT_TYPED_SFIELD (sfOwnerCount, "OwnerCount", UINT32, 13)
	CONSTRUCT_TYPED_SFIELD (sfDestinationTag, "DestinationTag", UINT32, 14)
	CONSTRUCT_TYPED_SFIELD (sfHighQualityIn, "HighQualityIn", UINT32, 16)
	CONSTRUCT_TYPED_SFIELD (sfHighQualityOut, "HighQualityOut", UINT32, 17)
	CONSTRUCT_TYPED_SFIELD (sfLowQualityIn, "LowQualityIn", UINT32, 18)
	CONSTRUCT_TYPED_SFIELD (sfLowQualityOut, "LowQualityOut", UINT32, 19)
	CONSTRUCT_TYPED_SFIELD (sfQualityIn, "QualityIn", UINT32, 20)
	CONSTRUCT_TYPED_SFIELD (sfQualityOut, "QualityOut", UINT32, 21)
	CONSTRUCT_TYPED_SFIELD (sfStampEscrow, "StampEscrow", UINT32, 22)
	CONSTRUCT_TYPED_SFIELD (sfBondAmount, "BondAmount", UINT32, 23)
	CONSTRUCT_TYPED_SFIELD (sfLoadFee, "LoadFee", UINT32, 24)
	CONSTRUCT_TYPED_SFIELD (sfOfferSequence, "OfferSequence", UINT32, 25)
	CONSTRUCT_TYPED_SFIELD (sfFirstLedgerSequence, "FirstLedgerSequence", UINT32, 26)
	CONSTRUCT_TYPED_SFIELD (sfLastLedgerSequence, "LastLedgerSequence", UINT32, 27)
	CONSTRUCT_TYPED_SFIELD (sfTransactionIndex, "TransactionIndex", UINT32, 28)
	CONSTRUCT_TYPED_SFIELD (sfOperationLimit, "OperationLimit", UINT32, 29)
	CONSTRUCT_TYPED_SFIELD (sfReferenceFeeUnits, "ReferenceFeeUnits", UINT32, 30)
	CONSTRUCT_TYPED_SFIELD (sfReserveBase, "ReserveBase", UINT32, 31)
	CONSTRUCT_TYPED_SFIELD (sfReserveIncrement, "ReserveIncrement", UINT32, 32)
	CONSTRUCT_TYPED_SFIELD (sfSetFlag, "SetFlag", UINT32, 33)
	CONSTRUCT_TYPED_SFIELD (sfClearFlag, "ClearFlag", UINT32, 34)
	CONSTRUCT_TYPED_SFIELD (sfSignerQuorum, "SignerQuorum", UINT32, 35)
	CONSTRUCT_TYPED_SFIELD (sfCancelAfter, "CancelAfter", UINT32, 36)
	CONSTRUCT_TYPED_SFIELD (sfFinishAfter, "FinishAfter", UINT32, 37)
	CONSTRUCT_TYPED_SFIELD (sfSignerListID, "SignerListID", UINT32, 38)
	CONSTRUCT_TYPED_SFIELD (sfSettleDelay, "SettleDelay", UINT32, 39)
	CONSTRUCT_TYPED_SFIELD (sfTicketCount, "TicketCount", UINT32, 40)
	CONSTRUCT_TYPED_SFIELD (sfTicketSequence, "TicketSequence", UINT32, 41)
	CONSTRUCT_TYPED_SFIELD (sfIndexNext, "IndexNext", UINT64, 1)
	CONSTRUCT_TYPED_SFIELD (sfIndexPrevious, "IndexPrevious", UINT64, 2)
	CONSTRUCT_TYPED_SFIELD (sfBookNode, "BookNode", UINT64, 3)
	CONSTRUCT_TYPED_SFIELD (sfOwnerNode, "OwnerNode", UINT64, 4)
	CONSTRUCT_TYPED_SFIELD (sfBaseFee, "BaseFee", UINT64, 5)
	CONSTRUCT_TYPED_SFIELD (sfExchangeRate, "ExchangeRate", UINT64, 6)
	CONSTRUCT_TYPED_SFIELD (sfLowNode, "LowNode", UINT64, 7)
	CONSTRUCT_TYPED_SFIELD (sfHighNode, "HighNode", UINT64, 8)
	CONSTRUCT_TYPED_SFIELD (sfDestinationNode, "DestinationNode", UINT64, 9)
	CONSTRUCT_TYPED_SFIELD (sfCookie, "Cookie", UINT64, 10)
	CONSTRUCT_TYPED_SFIELD (sfServerVersion, "ServerVersion", UINT64, 11)
	CONSTRUCT_TYPED_SFIELD (sfEmailHash, "EmailHash", HASH128, 1)
	CONSTRUCT_TYPED_SFIELD (sfTakerPaysCurrency, "TakerPaysCurrency", HASH160, 1)
	CONSTRUCT_TYPED_SFIELD (sfTakerPaysIssuer, "TakerPaysIssuer", HASH160, 2)
	CONSTRUCT_TYPED_SFIELD (sfTakerGetsCurrency, "TakerGetsCurrency", HASH160, 3)
	CONSTRUCT_TYPED_SFIELD (sfTakerGetsIssuer, "TakerGetsIssuer", HASH160, 4)
	CONSTRUCT_TYPED_SFIELD (sfLedgerHash, "LedgerHash", HASH256, 1)
	CONSTRUCT_TYPED_SFIELD (sfParentHash, "ParentHash", HASH256, 2)
	CONSTRUCT_TYPED_SFIELD (sfTransactionHash, "TransactionHash", HASH256, 3)
	CONSTRUCT_TYPED_SFIELD (sfAccountHash, "AccountHash", HASH256, 4)
	CONSTRUCT_TYPED_SFIELD (sfPreviousTxnID, "PreviousTxnID", HASH256, 5, SField::sMD_DeleteFinal)
	CONSTRUCT_TYPED_SFIELD (sfLedgerIndex, "LedgerIndex", HASH256, 6)
	CONSTRUCT_TYPED_SFIELD (sfWalletLocator, "WalletLocator", HASH256, 7)
	CONSTRUCT_TYPED_SFIELD (sfRootIndex, "RootIndex", HASH256, 8, SField::sMD_Always)
	CONSTRUCT_TYPED_SFIELD (sfAccountTxnID, "AccountTxnID", HASH256, 9)
	CONSTRUCT_TYPED_SFIELD (sfBookDirectory, "BookDirectory", HASH256, 16)
	CONSTRUCT_TYPED_SFIELD (sfInvoiceID, "InvoiceID", HASH256, 17)
	CONSTRUCT_TYPED_SFIELD (sfNickname, "Nickname", HASH256, 18)
	CONSTRUCT_TYPED_SFIELD (sfAmendment, "Amendment", HASH256, 19)
	CONSTRUCT_TYPED_SFIELD (sfDigest, "Digest", HASH256, 21)
	CONSTRUCT_TYPED_SFIELD (sfChannel, "Channel", HASH256, 22)
	CONSTRUCT_TYPED_SFIELD (sfConsensusHash, "ConsensusHash", HASH256, 23)
	CONSTRUCT_TYPED_SFIELD (sfCheckID, "CheckID", HASH256, 24)
	CONSTRUCT_TYPED_SFIELD (sfValidatedHash, "ValidatedHash", HASH256, 25)
	CONSTRUCT_TYPED_SFIELD (sfAmount, "Amount", AMOUNT, 1)
	CONSTRUCT_TYPED_SFIELD (sfBalance, "Balance", AMOUNT, 2)
	CONSTRUCT_TYPED_SFIELD (sfLimitAmount, "LimitAmount", AMOUNT, 3)
	CONSTRUCT_TYPED_SFIELD (sfTakerPays, "TakerPays", AMOUNT, 4)
	CONSTRUCT_TYPED_SFIELD (sfTakerGets, "TakerGets", AMOUNT, 5)
	CONSTRUCT_TYPED_SFIELD (sfLowLimit, "LowLimit", AMOUNT, 6)
	CONSTRUCT_TYPED_SFIELD (sfHighLimit, "HighLimit", AMOUNT, 7)
	CONSTRUCT_TYPED_SFIELD (sfFee, "Fee", AMOUNT, 8)
	CONSTRUCT_TYPED_SFIELD (sfSendMax, "SendMax", AMOUNT, 9)
	CONSTRUCT_TYPED_SFIELD (sfDeliverMin, "DeliverMin", AMOUNT, 10)
	CONSTRUCT_TYPED_SFIELD (sfMinimumOffer, "MinimumOffer", AMOUNT, 16)
	CONSTRUCT_TYPED_SFIELD (sfRippleEscrow, "RippleEscrow", AMOUNT, 17)
	CONSTRUCT_TYPED_SFIELD (sfDeliveredAmount, "DeliveredAmount", AMOUNT, 18)
	CONSTRUCT_TYPED_SFIELD (sfPublicKey, "PublicKey", VL, 1)
	CONSTRUCT_TYPED_SFIELD (sfMessageKey, "MessageKey", VL, 2)
	CONSTRUCT_TYPED_SFIELD (sfSigningPubKey, "SigningPubKey", VL, 3)
	CONSTRUCT_TYPED_SFIELD (sfTxnSignature, "TxnSignature", VL, 4, SField::sMD_Default, SField::notSigning)
	CONSTRUCT_TYPED_SFIELD (sfSignature, "Signature", VL, 6, SField::sMD_Default, SField::notSigning)
	CONSTRUCT_TYPED_SFIELD (sfDomain, "Domain", VL, 7)
	CONSTRUCT_TYPED_SFIELD (sfFundCode, "FundCode", VL, 8)
	CONSTRUCT_TYPED_SFIELD (sfRemoveCode, "RemoveCode", VL, 9)
	CONSTRUCT_TYPED_SFIELD (sfExpireCode, "ExpireCode", VL, 10)
	CONSTRUCT_TYPED_SFIELD (sfCreateCode, "CreateCode", VL, 11)
	CONSTRUCT_TYPED_SFIELD (sfMemoType, "MemoType", VL, 12)
	CONSTRUCT_TYPED_SFIELD (sfMemoData, "MemoData", VL, 13)
	CONSTRUCT_TYPED_SFIELD (sfMemoFormat, "MemoFormat", VL, 14)
	CONSTRUCT_TYPED_SFIELD (sfFulfillment, "Fulfillment", VL, 16)
	CONSTRUCT_TYPED_SFIELD (sfCondition, "Condition", VL, 17)
	CONSTRUCT_TYPED_SFIELD (sfMasterSignature, "MasterSignature", VL, 18, SField::sMD_Default, SField::notSigning)
	CONSTRUCT_TYPED_SFIELD (sfUNLModifyValidator, "UNLModifyValidator", VL, 19)
	CONSTRUCT_TYPED_SFIELD (sfValidatorToDisable, "ValidatorToDisable", VL, 20)
	CONSTRUCT_TYPED_SFIELD (sfValidatorToReEnable, "ValidatorToReEnable", VL, 21)
	CONSTRUCT_TYPED_SFIELD (sfAccount, "Account", ACCOUNT, 1)
	CONSTRUCT_TYPED_SFIELD (sfOwner, "Owner", ACCOUNT, 2)
	CONSTRUCT_TYPED_SFIELD (sfDestination, "Destination", ACCOUNT, 3)
	CONSTRUCT_TYPED_SFIELD (sfIssuer, "Issuer", ACCOUNT, 4)
	CONSTRUCT_TYPED_SFIELD (sfAuthorize, "Authorize", ACCOUNT, 5)
	CONSTRUCT_TYPED_SFIELD (sfUnauthorize, "Unauthorize", ACCOUNT, 6)
	CONSTRUCT_TYPED_SFIELD (sfRegularKey, "RegularKey", ACCOUNT, 8)
	CONSTRUCT_TYPED_SFIELD (sfIndexes, "Indexes", VECTOR256, 1, SField::sMD_Never)
	CONSTRUCT_TYPED_SFIELD (sfHashes, "Hashes", VECTOR256, 2)
	CONSTRUCT_TYPED_SFIELD (sfAmendments, "Amendments", VECTOR256, 3)
	CONSTRUCT_UNTYPED_SFIELD (sfPaths, "Paths", PATHSET, 1)
	CONSTRUCT_UNTYPED_SFIELD (sfTransactionMetaData, "TransactionMetaData", OBJECT, 2)
	CONSTRUCT_UNTYPED_SFIELD (sfCreatedNode, "CreatedNode", OBJECT, 3)
	CONSTRUCT_UNTYPED_SFIELD (sfDeletedNode, "DeletedNode", OBJECT, 4)
	CONSTRUCT_UNTYPED_SFIELD (sfModifiedNode, "ModifiedNode", OBJECT, 5)
	CONSTRUCT_UNTYPED_SFIELD (sfPreviousFields, "PreviousFields", OBJECT, 6)
	CONSTRUCT_UNTYPED_SFIELD (sfFinalFields, "FinalFields", OBJECT, 7)
	CONSTRUCT_UNTYPED_SFIELD (sfNewFields, "NewFields", OBJECT, 8)
	CONSTRUCT_UNTYPED_SFIELD (sfTemplateEntry, "TemplateEntry", OBJECT, 9)
	CONSTRUCT_UNTYPED_SFIELD (sfMemo, "Memo", OBJECT, 10)
	CONSTRUCT_UNTYPED_SFIELD (sfSignerEntry, "SignerEntry", OBJECT, 11)
	CONSTRUCT_UNTYPED_SFIELD (sfSigner, "Signer", OBJECT, 16)
	CONSTRUCT_UNTYPED_SFIELD (sfMajority, "Majority", OBJECT, 18)
	CONSTRUCT_UNTYPED_SFIELD (sfDisabledValidator, "DisabledValidator", OBJECT, 19)
	CONSTRUCT_UNTYPED_SFIELD (sfSigners, "Signers", ARRAY, 3, SField::sMD_Default, SField::notSigning)
	CONSTRUCT_UNTYPED_SFIELD (sfSignerEntries, "SignerEntries", ARRAY, 4)
	CONSTRUCT_UNTYPED_SFIELD (sfTemplate, "Template", ARRAY, 5)
	CONSTRUCT_UNTYPED_SFIELD (sfNecessary, "Necessary", ARRAY, 6)
	CONSTRUCT_UNTYPED_SFIELD (sfSufficient, "Sufficient", ARRAY, 7)
	CONSTRUCT_UNTYPED_SFIELD (sfAffectedNodes, "AffectedNodes", ARRAY, 8)
	CONSTRUCT_UNTYPED_SFIELD (sfMemos, "Memos", ARRAY, 9)
	CONSTRUCT_UNTYPED_SFIELD (sfMajorities, "Majorities", ARRAY, 16)
	CONSTRUCT_UNTYPED_SFIELD (sfDisabledValidators, "DisabledValidators", ARRAY, 17)
void	sign (STObject &st, HashPrefix const &prefix, KeyType type, SecretKey const &sk, SF_VL const &sigField=sfSignature)
	Sign an STObject. More...
bool	verify (STObject const &st, HashPrefix const &prefix, PublicKey const &pk, SF_VL const &sigField=sfSignature)
	Returns true if STObject contains valid signature. More...
Serializer	buildMultiSigningData (STObject const &obj, AccountID const &signingID)
	Return a Serializer suitable for computing a multisigning TxnSignature. More...
Serializer	startMultiSigningData (STObject const &obj)
	Break the multi-signing hash computation into 2 parts for optimization. More...
static std::int64_t	getSNValue (STAmount const &amount)
static bool	areComparable (STAmount const &v1, STAmount const &v2)
STAmount	operator+ (STAmount const &v1, STAmount const &v2)
STAmount	operator- (STAmount const &v1, STAmount const &v2)
std::uint64_t	getRate (STAmount const &offerOut, STAmount const &offerIn)
STAmount	amountFromQuality (std::uint64_t rate)
STAmount	amountFromString (Issue const &issue, std::string const &amount)
STAmount	amountFromJson (SField const &name, Json::Value const &v)
bool	amountFromJsonNoThrow (STAmount &result, Json::Value const &jvSource)
bool	operator== (STAmount const &lhs, STAmount const &rhs)
bool	operator< (STAmount const &lhs, STAmount const &rhs)
STAmount	operator- (STAmount const &value)
static std::uint64_t	muldiv (std::uint64_t multiplier, std::uint64_t multiplicand, std::uint64_t divisor)
static std::uint64_t	muldiv_round (std::uint64_t multiplier, std::uint64_t multiplicand, std::uint64_t divisor, std::uint64_t rounding)
STAmount	divide (STAmount const &num, STAmount const &den, Issue const &issue)
STAmount	multiply (STAmount const &v1, STAmount const &v2, Issue const &issue)
static void	canonicalizeRound (bool native, std::uint64_t &value, int &offset)
STAmount	mulRound (STAmount const &v1, STAmount const &v2, Issue const &issue, bool roundUp)
STAmount	divRound (STAmount const &num, STAmount const &den, Issue const &issue, bool roundUp)
std::ostream &	operator<< (std::ostream &out, const STBase &t)
static auto	getTxFormat (TxType type)
static Blob	getSigningData (STTx const &that)
static bool	isMemoOkay (STObject const &st, std::string &reason)
static bool	isAccountFieldOkay (STObject const &st)
bool	passesLocalChecks (STObject const &st, std::string &reason)
std::shared_ptr< STTx const >	sterilize (STTx const &stx)
	Sterilize a transaction. More...
bool	isPseudoTx (STObject const &tx)
	Check whether a transaction is a pseudo-transaction. More...
bool	transResultInfo (TER code, std::string &token, std::string &text)
std::string	transToken (TER code)
std::string	transHuman (TER code)
std::optional< TER >	transCode (std::string const &token)
template<class Hasher >
static Hasher::result_type	digest (void const *data, std::size_t size) noexcept
template<class Hasher , class T , std::size_t N, class = std::enable_if_t<sizeof(T) == 1>>
static Hasher::result_type	digest (std::array< T, N > const &v)
template<class Hasher , class... Args>
static Hasher::result_type	digest2 (Args const &... args)
static void	checksum (void *out, void const *message, std::size_t size)
	Calculate a 4-byte checksum of the data. More...
std::string	encodeBase58Token (TokenType type, void const *token, std::size_t size)
	Encode data in Base58Check format using XRPL alphabet. More...
std::string	decodeBase58Token (std::string const &s, TokenType type)
	Decode a token of given type encoded using Base58Check and the XRPL alphabet. More...
bool	to_currency (Currency &, std::string const &)
	Tries to convert a string to a Currency, returns true on success. More...
Currency	to_currency (std::string const &)
	Tries to convert a string to a Currency, returns noCurrency() on failure. More...
Currency const &	xrpCurrency ()
	XRP currency. More...
Currency const &	noCurrency ()
	A placeholder for empty currencies. More...
Currency const &	badCurrency ()
	We deliberately disallow the currency that looks like "XRP" because too many people were using it instead of the correct XRP currency. More...
template<class Hasher >
void	hash_append (Hasher &h, Issue const &r)
Issue const &	xrpIssue ()
	Returns an asset specifier that represents XRP. More...
Issue const &	noIssue ()
	Returns an asset specifier that represents no account and currency. More...
std::optional< KeyType >	keyTypeFromString (std::string const &s)
char const *	to_string (KeyType type)
template<class Stream >
Stream &	operator<< (Stream &s, KeyType type)
void	serializePayChanAuthorization (Serializer &msg, uint256 const &key, XRPAmount const &amt)
bool	operator== (PublicKey const &lhs, PublicKey const &rhs)
bool	operator< (PublicKey const &lhs, PublicKey const &rhs)
template<class Hasher >
void	hash_append (Hasher &h, PublicKey const &pk)
std::string	toBase58 (TokenType type, PublicKey const &pk)
bool	operator== (Rate const &lhs, Rate const &rhs) noexcept
bool	operator< (Rate const &lhs, Rate const &rhs) noexcept
std::ostream &	operator<< (std::ostream &os, Rate const &rate)
bool	operator== (SecretKey const &lhs, SecretKey const &rhs)
bool	operator!= (SecretKey const &lhs, SecretKey const &rhs)
std::string	toBase58 (TokenType type, SecretKey const &sk)
std::string	toBase58 (Seed const &seed)
	Format a seed as a Base58 string. More...
int	field_code (SerializedTypeID id, int index)
int	field_code (int id, int index)
template<class T >
OptionaledField< T >	operator~ (TypedField< T > const &f)
void	finishMultiSigningData (AccountID const &signingID, Serializer &s)
STAmount const &	toSTAmount (STAmount const &a)
bool	isLegalNet (STAmount const &value)
bool	operator!= (STAmount const &lhs, STAmount const &rhs)
bool	operator> (STAmount const &lhs, STAmount const &rhs)
bool	operator<= (STAmount const &lhs, STAmount const &rhs)
bool	operator>= (STAmount const &lhs, STAmount const &rhs)
bool	isXRP (STAmount const &amount)
template<class U , class T >
void	set (STObject &st, TypedField< U > const &f, T &&t)
	Set a field value in an STObject. More...
template<class Init >
void	set (STObject &st, TypedField< STBlob > const &f, std::size_t size, Init &&init)
	Set a blob field using an init function. More...
template<class = void>
void	set (STObject &st, TypedField< STBlob > const &f, void const *data, std::size_t size)
	Set a blob field from data. More...
template<class U >
void	erase (STObject &st, TypedField< U > const &f)
	Remove a field in an STObject. More...
void	throwFieldNotFound (SField const &field)
static std::string const &	systemName ()
bool	isLegalAmount (XRPAmount const &amount)
	Returns true if the amount does not exceed the initial XRP in existence. More...
static std::string const &	systemCurrencyCode ()
constexpr TERUnderlyingType	TERtoInt (TELcodes v)
constexpr TERUnderlyingType	TERtoInt (TEMcodes v)
constexpr TERUnderlyingType	TERtoInt (TEFcodes v)
constexpr TERUnderlyingType	TERtoInt (TERcodes v)
constexpr TERUnderlyingType	TERtoInt (TEScodes v)
constexpr TERUnderlyingType	TERtoInt (TECcodes v)
template<typename L , typename R >
constexpr auto	operator== (L const &lhs, R const &rhs) -> std::enable_if_t< std::is_same< decltype(TERtoInt(lhs)), int >::value &&std::is_same< decltype(TERtoInt(rhs)), int >::value, bool >
template<typename L , typename R >
constexpr auto	operator!= (L const &lhs, R const &rhs) -> std::enable_if_t< std::is_same< decltype(TERtoInt(lhs)), int >::value &&std::is_same< decltype(TERtoInt(rhs)), int >::value, bool >
template<typename L , typename R >
constexpr auto	operator< (L const &lhs, R const &rhs) -> std::enable_if_t< std::is_same< decltype(TERtoInt(lhs)), int >::value &&std::is_same< decltype(TERtoInt(rhs)), int >::value, bool >
template<typename L , typename R >
constexpr auto	operator<= (L const &lhs, R const &rhs) -> std::enable_if_t< std::is_same< decltype(TERtoInt(lhs)), int >::value &&std::is_same< decltype(TERtoInt(rhs)), int >::value, bool >
template<typename L , typename R >
constexpr auto	operator> (L const &lhs, R const &rhs) -> std::enable_if_t< std::is_same< decltype(TERtoInt(lhs)), int >::value &&std::is_same< decltype(TERtoInt(rhs)), int >::value, bool >
template<typename L , typename R >
constexpr auto	operator>= (L const &lhs, R const &rhs) -> std::enable_if_t< std::is_same< decltype(TERtoInt(lhs)), int >::value &&std::is_same< decltype(TERtoInt(rhs)), int >::value, bool >
bool	isTelLocal (TER x)
bool	isTemMalformed (TER x)
bool	isTefFailure (TER x)
bool	isTerRetry (TER x)
bool	isTesSuccess (TER x)
bool	isTecClaim (TER x)
std::pair< org::xrpl::rpc::v1::GetAccountInfoResponse, grpc::Status >	doAccountInfoGrpc (RPC::GRPCContext< org::xrpl::rpc::v1::GetAccountInfoRequest > &context)
std::pair< org::xrpl::rpc::v1::GetFeeResponse, grpc::Status >	doFeeGrpc (RPC::GRPCContext< org::xrpl::rpc::v1::GetFeeRequest > &context)
std::pair< org::xrpl::rpc::v1::SubmitTransactionResponse, grpc::Status >	doSubmitGrpc (RPC::GRPCContext< org::xrpl::rpc::v1::SubmitTransactionRequest > &context)
std::pair< org::xrpl::rpc::v1::GetTransactionResponse, grpc::Status >	doTxGrpc (RPC::GRPCContext< org::xrpl::rpc::v1::GetTransactionRequest > &context)
std::pair< org::xrpl::rpc::v1::GetAccountTransactionHistoryResponse, grpc::Status >	doAccountTxGrpc (RPC::GRPCContext< org::xrpl::rpc::v1::GetAccountTransactionHistoryRequest > &context)
std::pair< org::xrpl::rpc::v1::GetLedgerResponse, grpc::Status >	doLedgerGrpc (RPC::GRPCContext< org::xrpl::rpc::v1::GetLedgerRequest > &context)
std::pair< org::xrpl::rpc::v1::GetLedgerEntryResponse, grpc::Status >	doLedgerEntryGrpc (RPC::GRPCContext< org::xrpl::rpc::v1::GetLedgerEntryRequest > &context)
std::pair< org::xrpl::rpc::v1::GetLedgerDataResponse, grpc::Status >	doLedgerDataGrpc (RPC::GRPCContext< org::xrpl::rpc::v1::GetLedgerDataRequest > &context)
std::pair< org::xrpl::rpc::v1::GetLedgerDiffResponse, grpc::Status >	doLedgerDiffGrpc (RPC::GRPCContext< org::xrpl::rpc::v1::GetLedgerDiffRequest > &context)
void	addChannel (Json::Value &jsonLines, SLE const &line)
Json::Value	doAccountChannels (RPC::JsonContext &context)
Json::Value	doAccountCurrencies (RPC::JsonContext &context)
Json::Value	doAccountInfo (RPC::JsonContext &context)
void	addLine (Json::Value &jsonLines, RippleState const &line)
Json::Value	doAccountLines (RPC::JsonContext &context)
Json::Value	doAccountObjects (RPC::JsonContext &context)
	General RPC command that can retrieve objects in the account root. More...
void	appendOfferJson (std::shared_ptr< SLE const > const &offer, Json::Value &offers)
Json::Value	doAccountOffers (RPC::JsonContext &context)
std::variant< std::optional< LedgerSpecifier >, grpc::Status >	parseLedgerArgs (org::xrpl::rpc::v1::GetAccountTransactionHistoryRequest const &params)
std::variant< std::optional< LedgerSpecifier >, Json::Value >	parseLedgerArgs (Json::Value const &params)
std::variant< LedgerRange, RPC::Status >	getLedgerRange (RPC::Context &context, std::optional< LedgerSpecifier > const &ledgerSpecifier)
std::pair< AccountTxResult, RPC::Status >	doAccountTxHelp (RPC::Context &context, AccountTxArgs const &args)
std::pair< org::xrpl::rpc::v1::GetAccountTransactionHistoryResponse, grpc::Status >	populateProtoResponse (std::pair< AccountTxResult, RPC::Status > const &res, AccountTxArgs const &args, RPC::GRPCContext< org::xrpl::rpc::v1::GetAccountTransactionHistoryRequest > const &context)
Json::Value	populateJsonResponse (std::pair< AccountTxResult, RPC::Status > const &res, AccountTxArgs const &args, RPC::JsonContext const &context)
Json::Value	doAccountTxJson (RPC::JsonContext &context)
Json::Value	doAccountTxOld (RPC::JsonContext &context)
Json::Value	doBlackList (RPC::JsonContext &context)
Json::Value	doBookOffers (RPC::JsonContext &context)
Json::Value	doCanDelete (RPC::JsonContext &context)
Json::Value	doConnect (RPC::JsonContext &context)
Json::Value	doConsensusInfo (RPC::JsonContext &context)
Json::Value	doCrawlShards (RPC::JsonContext &context)
	RPC command that reports stored shards by nodes. More...
Json::Value	doDepositAuthorized (RPC::JsonContext &context)
Json::Value	doDownloadShard (RPC::JsonContext &context)
	RPC command that downloads and import shard archives. More...
Json::Value	doFeature (RPC::JsonContext &context)
Json::Value	doFee (RPC::JsonContext &context)
Json::Value	doFetchInfo (RPC::JsonContext &context)
Json::Value	doGatewayBalances (RPC::JsonContext &context)
static void	textTime (std::string &text, UptimeClock::time_point &seconds, const char *unitName, std::chrono::seconds unitVal)
Json::Value	getCountsJson (Application &app, int minObjectCount)
Json::Value	doGetCounts (RPC::JsonContext &context)
Json::Value	doChannelAuthorize (RPC::JsonContext &)
Json::Value	doChannelVerify (RPC::JsonContext &)
Json::Value	doLedgerAccept (RPC::JsonContext &)
Json::Value	doLedgerCleaner (RPC::JsonContext &)
Json::Value	doLedgerClosed (RPC::JsonContext &)
Json::Value	doLedgerCurrent (RPC::JsonContext &)
Json::Value	doLedgerData (RPC::JsonContext &)
Json::Value	doLedgerEntry (RPC::JsonContext &)
Json::Value	doLedgerHeader (RPC::JsonContext &)
Json::Value	doLedgerRequest (RPC::JsonContext &)
Json::Value	doLogLevel (RPC::JsonContext &)
Json::Value	doLogRotate (RPC::JsonContext &)
Json::Value	doManifest (RPC::JsonContext &)
Json::Value	doNodeToShard (RPC::JsonContext &)
Json::Value	doNoRippleCheck (RPC::JsonContext &)
Json::Value	doOwnerInfo (RPC::JsonContext &)
Json::Value	doPathFind (RPC::JsonContext &)
Json::Value	doPause (RPC::JsonContext &)
Json::Value	doPeers (RPC::JsonContext &)
Json::Value	doPing (RPC::JsonContext &)
Json::Value	doPrint (RPC::JsonContext &)
Json::Value	doRandom (RPC::JsonContext &)
Json::Value	doResume (RPC::JsonContext &)
Json::Value	doPeerReservationsAdd (RPC::JsonContext &)
Json::Value	doPeerReservationsDel (RPC::JsonContext &)
Json::Value	doPeerReservationsList (RPC::JsonContext &)
Json::Value	doRipplePathFind (RPC::JsonContext &)
Json::Value	doServerInfo (RPC::JsonContext &)
Json::Value	doServerState (RPC::JsonContext &)
Json::Value	doSign (RPC::JsonContext &)
Json::Value	doSignFor (RPC::JsonContext &)
Json::Value	doStop (RPC::JsonContext &)
Json::Value	doSubmit (RPC::JsonContext &)
Json::Value	doSubmitMultiSigned (RPC::JsonContext &)
Json::Value	doSubscribe (RPC::JsonContext &)
Json::Value	doTransactionEntry (RPC::JsonContext &)
Json::Value	doTxJson (RPC::JsonContext &)
Json::Value	doTxHistory (RPC::JsonContext &)
Json::Value	doTxReduceRelay (RPC::JsonContext &)
Json::Value	doUnlList (RPC::JsonContext &)
Json::Value	doUnsubscribe (RPC::JsonContext &)
Json::Value	doValidationCreate (RPC::JsonContext &)
Json::Value	doWalletPropose (RPC::JsonContext &)
Json::Value	doValidators (RPC::JsonContext &)
Json::Value	doValidatorListSites (RPC::JsonContext &)
Json::Value	doValidatorInfo (RPC::JsonContext &)
static void	fillTransaction (RPC::JsonContext &context, Json::Value &txArray, AccountID const &accountID, std::uint32_t &sequence, ReadView const &ledger)
static NetworkOPs::FailHard	getFailHard (RPC::JsonContext const &context)
static bool	isValidated (LedgerMaster &ledgerMaster, std::uint32_t seq, uint256 const &hash)
std::pair< TxResult, RPC::Status >	doTxPostgres (RPC::Context &context, TxArgs const &args)
std::pair< TxResult, RPC::Status >	doTxHelp (RPC::Context &context, TxArgs const &args)
std::pair< org::xrpl::rpc::v1::GetTransactionResponse, grpc::Status >	populateProtoResponse (std::pair< TxResult, RPC::Status > const &res, TxArgs const &args, RPC::GRPCContext< org::xrpl::rpc::v1::GetTransactionRequest > const &context)
Json::Value	populateJsonResponse (std::pair< TxResult, RPC::Status > const &res, TxArgs const &args, RPC::JsonContext const &context)
static std::optional< Seed >	validationSeed (Json::Value const &params)
double	estimate_entropy (std::string const &input)
Json::Value	walletPropose (Json::Value const &params)
bool	passwordUnrequiredOrSentCorrect (Port const &port, Json::Value const &params)
bool	ipAllowed (beast::IP::Address const &remoteIp, std::vector< beast::IP::Address > const &adminIp)
	True if remoteIp is in any of adminIp. More...
bool	isAdmin (Port const &port, Json::Value const &params, beast::IP::Address const &remoteIp)
Role	requestRole (Role const &required, Port const &port, Json::Value const &params, beast::IP::Endpoint const &remoteIp, boost::string_view const &user)
	Return the allowed privilege role. More...
bool	isUnlimited (Role const &role)
	ADMIN and IDENTIFIED roles shall have unlimited resources. More...
bool	isUnlimited (Role const &required, Port const &port, Json::Value const &params, beast::IP::Endpoint const &remoteIp, std::string const &user)
Resource::Consumer	requestInboundEndpoint (Resource::Manager &manager, beast::IP::Endpoint const &remoteAddress, Role const &role, boost::string_view const &user, boost::string_view const &forwardedFor)
boost::string_view	forwardedFor (http_request_type const &request)
static bool	isStatusRequest (http_request_type const &request)
static Handoff	statusRequestResponse (http_request_type const &request, boost::beast::http::status status)
static bool	authorized (Port const &port, std::map< std::string, std::string > const &h)
static Json::Output	makeOutput (Session &session)
static std::map< std::string, std::string >	build_map (boost::beast::http::fields const &h)
template<class ConstBufferSequence >
static std::string	buffers_to_string (ConstBufferSequence const &bs)
static Json::Value	make_json_error (Json::Int code, Json::Value &&message)
static Port	to_Port (ParsedPort const &parsed, std::ostream &log)
static std::vector< Port >	parse_Ports (Config const &config, std::ostream &log)
static void	setup_Client (ServerHandler::Setup &setup)
static void	setup_Overlay (ServerHandler::Setup &setup)
ServerHandler::Setup	setup_ServerHandler (Config const &config, std::ostream &&log)
std::unique_ptr< ServerHandler >	make_ServerHandler (Application &app, boost::asio::io_service &io_service, JobQueue &jobQueue, NetworkOPs &networkOPs, Resource::Manager &resourceManager, CollectorManager &cm)
bool	operator< (Port const &lhs, Port const &rhs)
std::string	getHTTPHeaderTimestamp ()
void	HTTPReply (int nStatus, std::string const &content, Json::Output const &output, beast::Journal j)
template<class T >
decltype(auto)	get_lowest_layer (T &t) noexcept
std::ostream &	operator<< (std::ostream &os, Port const &p)
static void	populate (Section const &section, std::string const &field, std::ostream &log, std::optional< std::vector< beast::IP::Address >> &ips, bool allowAllIps, std::vector< beast::IP::Address > const &admin_ip)
void	parse_Port (ParsedPort &port, Section const &section, std::ostream &log)
template<class Handler >
std::unique_ptr< Server >	make_Server (Handler &handler, boost::asio::io_service &io_service, beast::Journal journal)
	Create the HTTP server using the specified handler. More...
std::shared_ptr< SHAMapLeafNode >	makeTypedLeaf (SHAMapNodeType type, std::shared_ptr< SHAMapItem const > item, std::uint32_t owner)
static uint256 const &	depthMask (unsigned int depth)
unsigned int	selectBranch (SHAMapNodeID const &id, uint256 const &hash)
	Returns the branch that would contain the given hash. More...
static NodeStore::Database &	getShardStore (Application &app)
bool	operator== (SHAMap::const_iterator const &x, SHAMap::const_iterator const &y)
bool	operator!= (SHAMap::const_iterator const &x, SHAMap::const_iterator const &y)
std::string	to_string (SHAMapType t)
std::string	to_string (SHAMapNodeID const &node)
std::ostream &	operator<< (std::ostream &out, SHAMapNodeID const &node)
bool	operator!= (SHAMapHash const &x, SHAMapHash const &y)
	BEAST_DEFINE_TESTSUITE (AccountTxPaging, app, ripple)
	BEAST_DEFINE_TESTSUITE (AmendmentTable, app, ripple)
	BEAST_DEFINE_TESTSUITE (Check, tx, ripple)
	BEAST_DEFINE_TESTSUITE (Discrepancy, app, ripple)
	BEAST_DEFINE_TESTSUITE (Freeze, app, ripple)
	BEAST_DEFINE_TESTSUITE (LedgerLoad, app, ripple)
	BEAST_DEFINE_TESTSUITE (LoadFeeTrack, ripple_core, ripple)
	BEAST_DEFINE_TESTSUITE (OfferStream, tx, ripple)
	BEAST_DEFINE_TESTSUITE (SetRegularKey, app, ripple)
	BEAST_DEFINE_TESTSUITE (Taker, tx, ripple)
	BEAST_DEFINE_TESTSUITE (Ticket, tx, ripple)
	BEAST_DEFINE_TESTSUITE (TrustAndBalance, app, ripple)
	BEAST_DEFINE_TESTSUITE (Apply, app, ripple)
	BEAST_DEFINE_TESTSUITE (base64, ripple_basics, ripple)
	BEAST_DEFINE_TESTSUITE (contract, basics, ripple)
	BEAST_DEFINE_TESTSUITE (FileUtilities, ripple_basics, ripple)
	BEAST_DEFINE_TESTSUITE (hardened_hash, basics, ripple)
	BEAST_DEFINE_TESTSUITE (IOUAmount, protocol, ripple)
	BEAST_DEFINE_TESTSUITE (KeyCache, common, ripple)
	BEAST_DEFINE_TESTSUITE (PerfLog, basics, ripple)
	BEAST_DEFINE_TESTSUITE (RangeSet, ripple_basics, ripple)
	BEAST_DEFINE_TESTSUITE (StringUtilities, ripple_basics, ripple)
	BEAST_DEFINE_TESTSUITE (TaggedCache, common, ripple)
	BEAST_DEFINE_TESTSUITE (XRPAmount, protocol, ripple)
	BEAST_DEFINE_TESTSUITE (Config, core, ripple)
	BEAST_DEFINE_TESTSUITE (CryptoPRNG, core, ripple)
	BEAST_DEFINE_TESTSUITE (SociDB, core, ripple)
	BEAST_DEFINE_TESTSUITE (Workers, core, ripple)
	BEAST_DEFINE_TESTSUITE (json_value, json, ripple)
	BEAST_DEFINE_TESTSUITE (Invariants, ledger, ripple)
	BEAST_DEFINE_TESTSUITE (ProtocolVersion, overlay, ripple)
	BEAST_DEFINE_TESTSUITE (short_read, overlay, ripple)
	BEAST_DEFINE_TESTSUITE (BuildInfo, protocol, ripple)
	BEAST_DEFINE_TESTSUITE (InnerObjectFormatsParsedJSON, ripple_app, ripple)
	BEAST_DEFINE_TESTSUITE (Issue, protocol, ripple)
	BEAST_DEFINE_TESTSUITE (KnownFormatToGRPC, protocol, ripple)
	BEAST_DEFINE_TESTSUITE (PublicKey, protocol, ripple)
	BEAST_DEFINE_TESTSUITE (Quality, protocol, ripple)
	BEAST_DEFINE_TESTSUITE (SecretKey, protocol, ripple)
	BEAST_DEFINE_TESTSUITE (Seed, protocol, ripple)
	BEAST_DEFINE_TESTSUITE (SeqProxy, protocol, ripple)
	BEAST_DEFINE_TESTSUITE (STAccount, protocol, ripple)
	BEAST_DEFINE_TESTSUITE (STAmount, ripple_data, ripple)
	BEAST_DEFINE_TESTSUITE (STObject, protocol, ripple)
bool	matches (char const *string, char const *regex)
	Return true if the string loosely matches the regex. More...
	BEAST_DEFINE_TESTSUITE (STTx, ripple_app, ripple)
	BEAST_DEFINE_TESTSUITE (InnerObjectFormatsSerializer, ripple_app, ripple)
	BEAST_DEFINE_TESTSUITE (STValidation, protocol, ripple)
	BEAST_DEFINE_TESTSUITE (TER, protocol, ripple)
	BEAST_DEFINE_TESTSUITE (types, protocol, ripple)
	BEAST_DEFINE_TESTSUITE (AccountCurrencies, app, ripple)
	BEAST_DEFINE_TESTSUITE_PRIO (AccountSet, app, ripple, 1)
	BEAST_DEFINE_TESTSUITE (AmendmentBlocked, app, ripple)
	BEAST_DEFINE_TESTSUITE (Feature, rpc, ripple)
	BEAST_DEFINE_TESTSUITE (GetCounts, rpc, ripple)
	BEAST_DEFINE_TESTSUITE (LedgerClosed, app, ripple)
	BEAST_DEFINE_TESTSUITE_PRIO (LedgerData, app, ripple, 1)
	BEAST_DEFINE_TESTSUITE (LedgerRPC, app, ripple)
	BEAST_DEFINE_TESTSUITE (NoRippleCheck, app, ripple)
	BEAST_DEFINE_TESTSUITE_MANUAL_PRIO (NoRippleCheckLimits, app, ripple, 1)
	BEAST_DEFINE_TESTSUITE (OwnerInfo, app, ripple)
	BEAST_DEFINE_TESTSUITE (Peers, rpc, ripple)
	BEAST_DEFINE_TESTSUITE (Transaction, rpc, ripple)
	BEAST_DEFINE_TESTSUITE (TransactionEntry, rpc, ripple)
	BEAST_DEFINE_TESTSUITE (TransactionHistory, rpc, ripple)
	BEAST_DEFINE_TESTSUITE (Version, rpc, ripple)

Variables
constexpr auto	ledgerAcquireTimeout = 2500ms
static constexpr int	MAX_LEDGER_GAP {100}
static constexpr std::chrono::minutes	MAX_LEDGER_AGE_ACQUIRE {1}
static constexpr int	MAX_WRITE_LOAD_ACQUIRE {8192}
constexpr auto	TX_ACQUIRE_TIMEOUT = 250ms
const create_genesis_t	create_genesis {}
constexpr std::uint32_t	FLAG_LEDGER_INTERVAL = 256
constexpr std::chrono::seconds	CachedLedgerAge = std::chrono::minutes{2}
constexpr char const *	CommonDBPragmaJournal {"PRAGMA journal_mode=%s;"}
constexpr char const *	CommonDBPragmaSync {"PRAGMA synchronous=%s;"}
constexpr char const *	CommonDBPragmaTemp {"PRAGMA temp_store=%s;"}
constexpr std::uint32_t	SQLITE_TUNING_CUTOFF = 10'000'000
constexpr auto	LgrDBName {"ledger.db"}
constexpr std::array< char const *, 1 >	LgrDBPragma
constexpr std::array< char const *, 5 >	LgrDBInit
constexpr auto	TxDBName {"transaction.db"}
constexpr std::array	TxDBPragma
constexpr std::array< char const *, 8 >	TxDBInit
constexpr auto	LgrMetaDBName {"ledger_meta.db"}
constexpr std::array	LgrMetaDBPragma
constexpr std::array< char const *, 3 >	LgrMetaDBInit
constexpr auto	TxMetaDBName {"transaction_meta.db"}
constexpr std::array	TxMetaDBPragma
constexpr std::array< char const *, 3 >	TxMetaDBInit
constexpr auto	AcquireShardDBName {"acquire.db"}
constexpr std::array< char const *, 1 >	AcquireShardDBPragma
constexpr std::array< char const *, 1 >	AcquireShardDBInit
constexpr std::array< char const *, 2 >	FinalShardDBPragma
constexpr auto	WalletDBName {"wallet.db"}
constexpr std::array< char const *, 6 >	WalletDBInit
static constexpr auto	stateDBName {"state.db"}
static constexpr std::array< char const *, 2 >	DownloaderDBPragma
static constexpr std::array< char const *, 3 >	ShardArchiveHandlerDBInit
static constexpr std::array< char const *, 3 >	DatabaseBodyDBInit
constexpr std::size_t	fullBelowTargetSize = 524288
constexpr std::chrono::seconds	fullBelowExpiration = std::chrono::minutes{10}
constexpr auto	default_refresh_interval = std::chrono::minutes{5}
constexpr auto	error_retry_interval = std::chrono::seconds{30}
unsigned constexpr short	max_redirects = 3
static const std::array< char const *, 5 >	stateNames
static const auto	genesisAccountId
constexpr int	TableTypeCount = 3
static const std::uint32_t	defaultSignerListID_ = 0
static const std::int64_t	minMantissa = 1000000000000000ull
static const std::int64_t	maxMantissa = 9999999999999999ull
static const int	minExponent = -96
static const int	maxExponent = 80
template<class Dest , class Src >
static constexpr bool	is_safetocasttovalue_v
constexpr XRPAmount	DROPS_PER_XRP {1'000'000}
	Number of drops per 1 XRP. More...
constexpr std::chrono::seconds	ledgerPossibleTimeResolutions []
	Possible ledger close time resolutions. More...
constexpr auto	ledgerDefaultTimeResolution = ledgerPossibleTimeResolutions[2]
	Initial resolution of ledger close time. More...
constexpr auto	ledgerGenesisTimeResolution = ledgerPossibleTimeResolutions[0]
	Close time resolution in genesis ledger. More...
constexpr auto	increaseLedgerTimeResolutionEvery = 8
	How often we increase the close time resolution (in numbers of ledgers) More...
constexpr auto	decreaseLedgerTimeResolutionEvery = 1
	How often we decrease the close time resolution (in numbers of ledgers) More...
constexpr std::array< std::pair< SizedItem, std::array< int, 5 > >, 12 >	sizedItems
CheckpointersCollection	checkpointers
static uint8_t	SNTPQueryData [48]
constexpr auto	NTP_QUERY_FREQUENCY = 4min
constexpr auto	NTP_MIN_QUERY = 3min
constexpr auto	NTP_UNIX_OFFSET = 0x83AA7E80s
constexpr auto	NTP_TIMESTAMP_VALID = (NTP_QUERY_FREQUENCY + NTP_MIN_QUERY) * 2
static auto	checkpointPageCount = 1000
const open_ledger_t	open_ledger {}
static const std::uint32_t	sLCF_NoConsensusTime = 0x01
static std::optional< HTTPClientSSLContext >	httpClientSSLContext
static constexpr char	FEATURE_COMPR [] = "compr"
static constexpr char	FEATURE_VPRR [] = "vprr"
static constexpr char	FEATURE_TXRR [] = "txrr"
static constexpr char	FEATURE_LEDGER_REPLAY [] = "ledgerreplay"
static constexpr char	DELIM_FEATURE [] = ";"
static constexpr char	DELIM_VALUE [] = ","
constexpr const ProtocolVersion	supportedProtocolList []
	The list of protocol versions we speak and we prefer to use. More...
constexpr std::size_t	maximiumMessageSize = megabytes(64)
static constexpr std::uint32_t	relayLimit = 3
const uint256	featureOwnerPaysFee
const uint256	featureFlow
const uint256	featureFlowCross
const uint256	featureCryptoConditionsSuite
const uint256	fix1513
const uint256	featureDepositAuth
const uint256	featureChecks
const uint256	fix1571
const uint256	fix1543
const uint256	fix1623
const uint256	featureDepositPreauth
const uint256	fix1515
const uint256	fix1578
const uint256	featureMultiSignReserve
const uint256	fixTakerDryOfferRemoval
const uint256	fixMasterKeyAsRegularKey
const uint256	fixCheckThreading
const uint256	fixPayChanRecipientOwnerDir
const uint256	featureDeletableAccounts
const uint256	fixQualityUpperBound
const uint256	featureRequireFullyCanonicalSig
const uint256	fix1781
const uint256	featureHardenedValidations
const uint256	fixAmendmentMajorityCalc
const uint256	featureNegativeUNL
const uint256	featureTicketBatch
const uint256	featureFlowSortStrands
const uint256	fixSTAmountCanonicalize
const uint256	fixRmSmallIncreasedQOffers
const uint256	featureCheckCashMakesTrustLine
const uint256	retiredMultiSign = retireFeature("MultiSign")
const uint256	retiredTrustSetAuth = retireFeature("TrustSetAuth")
const uint256	retiredFeeEscalation = retireFeature("FeeEscalation")
const uint256	retiredPayChan = retireFeature("PayChan")
const uint256	retiredCryptoConditions = retireFeature("CryptoConditions")
const uint256	retiredTickSize = retireFeature("TickSize")
const uint256	retiredFix1368 = retireFeature("fix1368")
const uint256	retiredEscrow = retireFeature("Escrow")
const uint256	retiredFix1373 = retireFeature("fix1373")
const uint256	retiredEnforceInvariants = retireFeature("EnforceInvariants")
const uint256	retiredSortedDirectories = retireFeature("SortedDirectories")
const uint256	retiredFix1201 = retireFeature("fix1201")
const uint256	retiredFix1512 = retireFeature("fix1512")
const uint256	retiredFix1523 = retireFeature("fix1523")
const uint256	retiredFix1528 = retireFeature("fix1528")
static const bool	readOnlySet
const Rate	parityRate (QUALITY_ONE)
	A transfer rate signifying a 1:1 exchange. More...
static SField::private_access_tag_t	access
const SField	sfInvalid (access, -1)
const SField	sfGeneric (access, 0)
const SField	sfHash (access, STI_HASH256, 257, "hash")
const SField	sfIndex (access, STI_HASH256, 258, "index")
LocalValue< bool >	stAmountCanonicalizeSwitchover (true)
static const std::uint64_t	tenTo14 = 100000000000000ull
static const std::uint64_t	tenTo14m1 = tenTo14 - 1
static const std::uint64_t	tenTo17 = tenTo14 * 1000
static constexpr char const *	alphabetForward
static constexpr const std::array< int, 256 >	alphabetReverse
constexpr std::size_t	txMinSizeBytes = 32
	Protocol specific constants, types, and data. More...
constexpr std::size_t	txMaxSizeBytes = megabytes(1)
	Largest legal byte size of a transaction. More...
constexpr std::size_t	unfundedOfferRemoveLimit = 1000
	The maximum number of unfunded offers to delete at once. More...
constexpr std::size_t	oversizeMetaDataCap = 5200
	The maximum number of metadata entries allowed in one transaction. More...
constexpr std::size_t	dirNodeMaxEntries = 32
	The maximum number of entries per directory page. More...
constexpr std::uint64_t	dirNodeMaxPages = 262144
	The maximum number of pages allowed in a directory. More...
const SField	sfLedgerEntry
const SField	sfTransaction
const SField	sfValidation
const SField	sfMetadata
const SF_UINT8	sfCloseResolution
const SF_UINT8	sfMethod
const SF_UINT8	sfTransactionResult
const SF_UINT8	sfTickSize
const SF_UINT8	sfUNLModifyDisabling
const SF_UINT16	sfLedgerEntryType
const SF_UINT16	sfTransactionType
const SF_UINT16	sfSignerWeight
const SF_UINT16	sfVersion
const SF_UINT32	sfFlags
const SF_UINT32	sfSourceTag
const SF_UINT32	sfSequence
const SF_UINT32	sfPreviousTxnLgrSeq
const SF_UINT32	sfLedgerSequence
const SF_UINT32	sfCloseTime
const SF_UINT32	sfParentCloseTime
const SF_UINT32	sfSigningTime
const SF_UINT32	sfExpiration
const SF_UINT32	sfTransferRate
const SF_UINT32	sfWalletSize
const SF_UINT32	sfOwnerCount
const SF_UINT32	sfDestinationTag
const SF_UINT32	sfHighQualityIn
const SF_UINT32	sfHighQualityOut
const SF_UINT32	sfLowQualityIn
const SF_UINT32	sfLowQualityOut
const SF_UINT32	sfQualityIn
const SF_UINT32	sfQualityOut
const SF_UINT32	sfStampEscrow
const SF_UINT32	sfBondAmount
const SF_UINT32	sfLoadFee
const SF_UINT32	sfOfferSequence
const SF_UINT32	sfFirstLedgerSequence
const SF_UINT32	sfLastLedgerSequence
const SF_UINT32	sfTransactionIndex
const SF_UINT32	sfOperationLimit
const SF_UINT32	sfReferenceFeeUnits
const SF_UINT32	sfReserveBase
const SF_UINT32	sfReserveIncrement
const SF_UINT32	sfSetFlag
const SF_UINT32	sfClearFlag
const SF_UINT32	sfSignerQuorum
const SF_UINT32	sfCancelAfter
const SF_UINT32	sfFinishAfter
const SF_UINT32	sfSignerListID
const SF_UINT32	sfSettleDelay
const SF_UINT32	sfTicketCount
const SF_UINT32	sfTicketSequence
const SF_UINT64	sfIndexNext
const SF_UINT64	sfIndexPrevious
const SF_UINT64	sfBookNode
const SF_UINT64	sfOwnerNode
const SF_UINT64	sfBaseFee
const SF_UINT64	sfExchangeRate
const SF_UINT64	sfLowNode
const SF_UINT64	sfHighNode
const SF_UINT64	sfDestinationNode
const SF_UINT64	sfCookie
const SF_UINT64	sfServerVersion
const SF_HASH128	sfEmailHash
const SF_HASH160	sfTakerPaysCurrency
const SF_HASH160	sfTakerPaysIssuer
const SF_HASH160	sfTakerGetsCurrency
const SF_HASH160	sfTakerGetsIssuer
const SF_HASH256	sfLedgerHash
const SF_HASH256	sfParentHash
const SF_HASH256	sfTransactionHash
const SF_HASH256	sfAccountHash
const SF_HASH256	sfPreviousTxnID
const SF_HASH256	sfLedgerIndex
const SF_HASH256	sfWalletLocator
const SF_HASH256	sfRootIndex
const SF_HASH256	sfAccountTxnID
const SF_HASH256	sfBookDirectory
const SF_HASH256	sfInvoiceID
const SF_HASH256	sfNickname
const SF_HASH256	sfAmendment
const SF_HASH256	sfDigest
const SF_HASH256	sfChannel
const SF_HASH256	sfConsensusHash
const SF_HASH256	sfCheckID
const SF_HASH256	sfValidatedHash
const SF_AMOUNT	sfAmount
const SF_AMOUNT	sfBalance
const SF_AMOUNT	sfLimitAmount
const SF_AMOUNT	sfTakerPays
const SF_AMOUNT	sfTakerGets
const SF_AMOUNT	sfLowLimit
const SF_AMOUNT	sfHighLimit
const SF_AMOUNT	sfFee
const SF_AMOUNT	sfSendMax
const SF_AMOUNT	sfDeliverMin
const SF_AMOUNT	sfMinimumOffer
const SF_AMOUNT	sfRippleEscrow
const SF_AMOUNT	sfDeliveredAmount
const SF_VL	sfPublicKey
const SF_VL	sfMessageKey
const SF_VL	sfSigningPubKey
const SF_VL	sfTxnSignature
const SF_VL	sfSignature
const SF_VL	sfDomain
const SF_VL	sfFundCode
const SF_VL	sfRemoveCode
const SF_VL	sfExpireCode
const SF_VL	sfCreateCode
const SF_VL	sfMemoType
const SF_VL	sfMemoData
const SF_VL	sfMemoFormat
const SF_VL	sfFulfillment
const SF_VL	sfCondition
const SF_VL	sfMasterSignature
const SF_VL	sfUNLModifyValidator
const SF_VL	sfValidatorToDisable
const SF_VL	sfValidatorToReEnable
const SF_ACCOUNT	sfAccount
const SF_ACCOUNT	sfOwner
const SF_ACCOUNT	sfDestination
const SF_ACCOUNT	sfIssuer
const SF_ACCOUNT	sfAuthorize
const SF_ACCOUNT	sfUnauthorize
const SF_ACCOUNT	sfTarget
const SF_ACCOUNT	sfRegularKey
const SField	sfPaths
const SF_VECTOR256	sfIndexes
const SF_VECTOR256	sfHashes
const SF_VECTOR256	sfAmendments
const SField	sfTransactionMetaData
const SField	sfCreatedNode
const SField	sfDeletedNode
const SField	sfModifiedNode
const SField	sfPreviousFields
const SField	sfFinalFields
const SField	sfNewFields
const SField	sfTemplateEntry
const SField	sfMemo
const SField	sfSignerEntry
const SField	sfSigner
const SField	sfMajority
const SField	sfDisabledValidator
const SField	sfSigners
const SField	sfSignerEntries
const SField	sfTemplate
const SField	sfNecessary
const SField	sfSufficient
const SField	sfAffectedNodes
const SField	sfMemos
const SField	sfMajorities
const SField	sfDisabledValidators
constexpr std::uint32_t	vfFullValidation = 0x00000001
constexpr std::uint32_t	vfFullyCanonicalSig = 0x80000000
constexpr XRPAmount	INITIAL_XRP {100'000'000'000 * DROPS_PER_XRP}
	Configure the native currency. More...
static constexpr std::uint32_t	XRP_LEDGER_EARLIEST_SEQ {32570u}
	The XRP ledger network's earliest allowed sequence. More...
static constexpr std::uint32_t	DEFAULT_LEDGERS_PER_SHARD {16384u}
	The number of ledgers in a shard. More...
constexpr std::ratio< 204, 256 >	preFixAmendmentMajorityCalcThreshold
	The minimum amount of support an amendment should have. More...
constexpr std::ratio< 80, 100 >	postFixAmendmentMajorityCalcThreshold
constexpr const std::chrono::seconds	defaultAmendmentMajorityTime = weeks{2}
	The minimum amount of time an amendment must hold a majority. More...
const std::uint32_t	tfFullyCanonicalSig = 0x80000000
const std::uint32_t	tfUniversal = tfFullyCanonicalSig
const std::uint32_t	tfUniversalMask = ~tfUniversal
const std::uint32_t	tfOptionalDestTag = 0x00020000
const std::uint32_t	tfRequireAuth = 0x00040000
const std::uint32_t	tfOptionalAuth = 0x00080000
const std::uint32_t	tfDisallowXRP = 0x00100000
const std::uint32_t	tfAllowXRP = 0x00200000
const std::uint32_t	tfAccountSetMask
const std::uint32_t	asfRequireDest = 1
const std::uint32_t	asfRequireAuth = 2
const std::uint32_t	asfDisallowXRP = 3
const std::uint32_t	asfDisableMaster = 4
const std::uint32_t	asfAccountTxnID = 5
const std::uint32_t	asfNoFreeze = 6
const std::uint32_t	asfGlobalFreeze = 7
const std::uint32_t	asfDefaultRipple = 8
const std::uint32_t	asfDepositAuth = 9
const std::uint32_t	tfPassive = 0x00010000
const std::uint32_t	tfImmediateOrCancel = 0x00020000
const std::uint32_t	tfFillOrKill = 0x00040000
const std::uint32_t	tfSell = 0x00080000
const std::uint32_t	tfOfferCreateMask
const std::uint32_t	tfNoRippleDirect = 0x00010000
const std::uint32_t	tfPartialPayment = 0x00020000
const std::uint32_t	tfLimitQuality = 0x00040000
const std::uint32_t	tfPaymentMask
const std::uint32_t	tfSetfAuth = 0x00010000
const std::uint32_t	tfSetNoRipple = 0x00020000
const std::uint32_t	tfClearNoRipple = 0x00040000
const std::uint32_t	tfSetFreeze = 0x00100000
const std::uint32_t	tfClearFreeze = 0x00200000
const std::uint32_t	tfTrustSetMask
const std::uint32_t	tfGotMajority = 0x00010000
const std::uint32_t	tfLostMajority = 0x00020000
const std::uint32_t	tfRenew = 0x00010000
const std::uint32_t	tfClose = 0x00020000
const std::uint32_t	tfPayChanClaimMask = ~(tfUniversal | tfRenew | tfClose)
constexpr Json::Int	method_not_found = -32601
constexpr Json::Int	server_overloaded = -32604
constexpr Json::Int	forbidden = -32605
constexpr Json::Int	wrong_version = -32606
static const std::shared_ptr< SHAMapItem const >	no_item
static constexpr unsigned const char	wireTypeTransaction = 0
static constexpr unsigned const char	wireTypeAccountState = 1
static constexpr unsigned const char	wireTypeInner = 2
static constexpr unsigned const char	wireTypeCompressedInner = 3
static constexpr unsigned const char	wireTypeTransactionWithMeta = 4

Detailed Description

Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.

Callback for filtering SHAMap during sync.

Use hardened_hash_* containers for keys that do need a secure hashing algorithm.

The cryptographic security of containers where a hash function is used as a template parameter depends entirely on that hash function and not at all on what container it is.

Typedef Documentation

RCLValidations

typedef Validations< RCLValidationsAdaptor > ripple::RCLValidations

Alias for RCL-specific instantiation of generic Validations.

Definition at line 236 of file RCLValidations.h.

CachedLedger

using ripple::CachedLedger = typedef CachedView<Ledger>

A ledger wrapped in a CachedView.

Definition at line 414 of file Ledger.h.

OrderedTxs

using ripple::OrderedTxs = typedef CanonicalTXSet

Definition at line 44 of file OpenLedger.h.

NodeCache

using ripple::NodeCache = typedef TaggedCache<SHAMapHash, Blob>

Definition at line 96 of file Application.h.

TxnsData

typedef RelationalDBInterface::AccountTxs ripple::TxnsData

Definition at line 27 of file RelationalDBInterface_postgres.cpp.

TxnsDataBinary

typedef RelationalDBInterface::MetaTxsList ripple::TxnsDataBinary

Definition at line 28 of file RelationalDBInterface_postgres.cpp.

LedgerHash

typedef uint256 ripple::LedgerHash

Definition at line 30 of file RelationalDBInterface_postgres.cpp.

LedgerSequence

using ripple::LedgerSequence = typedef RelationalDBInterface::LedgerSequence

Definition at line 31 of file RelationalDBInterface_postgres.cpp.

LedgerShortcut

typedef RelationalDBInterface::LedgerShortcut ripple::LedgerShortcut

Definition at line 32 of file RelationalDBInterface_postgres.cpp.

AccountTxMarker

using ripple::AccountTxMarker = typedef RelationalDBInterface::AccountTxMarker

Definition at line 35 of file RelationalDBInterface_postgres.h.

AccountTxArgs

typedef RelationalDBInterface::AccountTxArgs ripple::AccountTxArgs

Definition at line 36 of file RelationalDBInterface_postgres.h.

AccountTxResult

typedef RelationalDBInterface::AccountTxResult ripple::AccountTxResult

Definition at line 37 of file RelationalDBInterface_postgres.h.

AccountTransactionsData

typedef RelationalDBInterface::AccountTransactionsData ripple::AccountTransactionsData

Definition at line 38 of file RelationalDBInterface_postgres.h.

InvariantChecks

using ripple::InvariantChecks = typedef std::tuple< TransactionFeeCheck, AccountRootsNotDeleted, LedgerEntryTypesMatch, XRPBalanceChecks, XRPNotCreated, NoXRPTrustLines, NoBadOffers, NoZeroEscrow, ValidNewAccountRoot>

Definition at line 332 of file InvariantCheck.h.

Offer

using ripple::Offer = typedef TOffer<>

Definition at line 140 of file Offer.h.

uint128

using ripple::uint128 = typedef base_uint<128>

Definition at line 527 of file base_uint.h.

uint160

using ripple::uint160 = typedef base_uint<160>

Definition at line 528 of file base_uint.h.

uint256

using ripple::uint256 = typedef base_uint<256>

Definition at line 529 of file base_uint.h.

IniFileSections

using ripple::IniFileSections = typedef std::map<std::string, std::vector<std::string> >

Definition at line 35 of file BasicConfig.h.

Blob

using ripple::Blob = typedef std::vector<unsigned char>

Storage for linear binary data.

Blocks of binary data appear often in various idioms and structures.

Definition at line 30 of file Blob.h.

days

using ripple::days = typedef std::chrono::duration< int, std::ratio_multiply<std::chrono::hours::period, std::ratio<24> >>

Definition at line 38 of file chrono.h.

weeks

using ripple::weeks = typedef std::chrono:: duration<int, std::ratio_multiply<days::period, std::ratio<7> >>

Definition at line 41 of file chrono.h.

Stopwatch

using ripple::Stopwatch = typedef beast::abstract_clock<std::chrono::steady_clock>

A clock for measuring elapsed time.

The epoch is unspecified.

Definition at line 81 of file chrono.h.

TestStopwatch

using ripple::TestStopwatch = typedef beast::manual_clock<std::chrono::steady_clock>

A manual Stopwatch for unit tests.

Definition at line 84 of file chrono.h.

FeeUnit

template<class T >

using ripple::FeeUnit = typedef feeunit::TaggedFee<feeunit::feeunitTag, T>

Definition at line 458 of file FeeUnits.h.

FeeUnit32

using ripple::FeeUnit32 = typedef FeeUnit<std::uint32_t>

Definition at line 459 of file FeeUnits.h.

FeeUnit64

using ripple::FeeUnit64 = typedef FeeUnit<std::uint64_t>

Definition at line 460 of file FeeUnits.h.

FeeLevel

template<class T >

using ripple::FeeLevel = typedef feeunit::TaggedFee<feeunit::feelevelTag, T>

Definition at line 463 of file FeeUnits.h.

FeeLevel64

using ripple::FeeLevel64 = typedef FeeLevel<std::uint64_t>

Definition at line 464 of file FeeUnits.h.

FeeLevelDouble

using ripple::FeeLevelDouble = typedef FeeLevel<double>

Definition at line 465 of file FeeUnits.h.

ClosedInterval

template<class T >

using ripple::ClosedInterval = typedef boost::icl::closed_interval<T>

A closed interval over the domain T.

For an instance ClosedInterval c, this represents the closed interval (c.first(), c.last()). A single element interval has c.first() == c.last().

This is simply a type-alias for boost interval container library interval set, so users should consult that documentation for available supporting member and free functions.

Definition at line 44 of file RangeSet.h.

RangeSet

template<class T >

using ripple::RangeSet = typedef boost::icl::interval_set<T, std::less, ClosedInterval<T> >

A set of closed intervals over the domain T.

Represents a set of values of the domain T using the minimum number of disjoint ClosedInterval<T>. This is useful to represent ranges of T where a few instances are missing, e.g. the set 1-5,8-9,11-14.

This is simply a type-alias for boost interval container library interval set, so users should consult that documentation for available supporting member and free functions.

Definition at line 69 of file RangeSet.h.

hash_map

template<class Key , class Value , class Hash = beast::uhash<>, class Pred = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key const, Value>>>

using ripple::hash_map = typedef std::unordered_map<Key, Value, Hash, Pred, Allocator>

Definition at line 52 of file UnorderedContainers.h.

hash_multimap

template<class Key , class Value , class Hash = beast::uhash<>, class Pred = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key const, Value>>>

using ripple::hash_multimap = typedef std::unordered_multimap<Key, Value, Hash, Pred, Allocator>

Definition at line 61 of file UnorderedContainers.h.

hash_set

template<class Value , class Hash = beast::uhash<>, class Pred = std::equal_to<Value>, class Allocator = std::allocator<Value>>

using ripple::hash_set = typedef std::unordered_set<Value, Hash, Pred, Allocator>

Definition at line 68 of file UnorderedContainers.h.

hash_multiset

template<class Value , class Hash = beast::uhash<>, class Pred = std::equal_to<Value>, class Allocator = std::allocator<Value>>

using ripple::hash_multiset = typedef std::unordered_multiset<Value, Hash, Pred, Allocator>

Definition at line 75 of file UnorderedContainers.h.

strong_hash

using ripple::strong_hash = typedef beast::xxhasher

Definition at line 79 of file UnorderedContainers.h.

hardened_hash_map

template<class Key , class Value , class Hash = hardened_hash<strong_hash>, class Pred = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key const, Value>>>

using ripple::hardened_hash_map = typedef std::unordered_map<Key, Value, Hash, Pred, Allocator>

Definition at line 87 of file UnorderedContainers.h.

hardened_hash_multimap

template<class Key , class Value , class Hash = hardened_hash<strong_hash>, class Pred = std::equal_to<Key>, class Allocator = std::allocator<std::pair<Key const, Value>>>

using ripple::hardened_hash_multimap = typedef std::unordered_multimap<Key, Value, Hash, Pred, Allocator>

Definition at line 96 of file UnorderedContainers.h.

hardened_hash_set

template<class Value , class Hash = hardened_hash<strong_hash>, class Pred = std::equal_to<Value>, class Allocator = std::allocator<Value>>

using ripple::hardened_hash_set = typedef std::unordered_set<Value, Hash, Pred, Allocator>

Definition at line 103 of file UnorderedContainers.h.

hardened_hash_multiset

template<class Value , class Hash = hardened_hash<strong_hash>, class Pred = std::equal_to<Value>, class Allocator = std::allocator<Value>>

using ripple::hardened_hash_multiset = typedef std::unordered_multiset<Value, Hash, Pred, Allocator>

Definition at line 111 of file UnorderedContainers.h.

semaphore

using ripple::semaphore = typedef basic_semaphore<std::mutex, std::condition_variable>

Definition at line 79 of file semaphore.h.

JobCounter

using ripple::JobCounter = typedef ClosureCounter<void, Job&>

Definition at line 163 of file Job.h.

const_iterator

using ripple::const_iterator = typedef Dir::const_iterator

Definition at line 25 of file Directory.cpp.

majorityAmendments_t

using ripple::majorityAmendments_t = typedef std::map<uint256, NetClock::time_point>

Definition at line 133 of file View.h.

socket_type

using ripple::socket_type = typedef boost::beast::tcp_stream

Definition at line 42 of file Handshake.h.

stream_type

using ripple::stream_type = typedef boost::beast::ssl_stream<socket_type>

Definition at line 43 of file Handshake.h.

request_type

using ripple::request_type = typedef boost::beast::http::request<boost::beast::http::empty_body>

Definition at line 45 of file Handshake.h.

http_request_type

typedef boost::beast::http::request< boost::beast::http::dynamic_body > ripple::http_request_type

Definition at line 47 of file Handshake.h.

http_response_type

typedef boost::beast::http::response< boost::beast::http::dynamic_body > ripple::http_response_type

Definition at line 49 of file Handshake.h.

ProtocolVersion

using ripple::ProtocolVersion = typedef std::pair<std::uint16_t, std::uint16_t>

Represents a particular version of the peer-to-peer protocol.

The protocol is represented as two pairs of 16-bit integers; a major and a minor.

Definition at line 37 of file ProtocolVersion.h.

AccountID

using ripple::AccountID = typedef base_uint<160, detail::AccountIDTag>

A 160-bit unsigned that uniquely identifies an account.

Definition at line 47 of file AccountID.h.

ripemd160_hasher

using ripple::ripemd160_hasher = typedef openssl_ripemd160_hasher

Definition at line 110 of file digest.h.

sha256_hasher

using ripple::sha256_hasher = typedef openssl_sha256_hasher

Definition at line 111 of file digest.h.

sha512_hasher

using ripple::sha512_hasher = typedef openssl_sha512_hasher

Definition at line 112 of file digest.h.

sha512_half_hasher

using ripple::sha512_half_hasher = typedef detail::basic_sha512_half_hasher<false>

Definition at line 206 of file digest.h.

sha512_half_hasher_s

using ripple::sha512_half_hasher_s = typedef detail::basic_sha512_half_hasher<true>

Definition at line 209 of file digest.h.

LedgerIndex

using ripple::LedgerIndex = typedef std::uint32_t

A ledger index.

Definition at line 57 of file Protocol.h.

TxID

using ripple::TxID = typedef uint256

A transaction identifier.

The value is computed as the hash of the canonicalized, serialized transaction object.

Definition at line 63 of file Protocol.h.

TxSeq

using ripple::TxSeq = typedef std::uint32_t

Definition at line 65 of file Protocol.h.

SF_UINT8

using ripple::SF_UINT8 = typedef TypedField<STInteger<std::uint8_t> >

Definition at line 317 of file SField.h.

SF_UINT16

using ripple::SF_UINT16 = typedef TypedField<STInteger<std::uint16_t> >

Definition at line 318 of file SField.h.

SF_UINT32

using ripple::SF_UINT32 = typedef TypedField<STInteger<std::uint32_t> >

Definition at line 319 of file SField.h.

SF_UINT64

using ripple::SF_UINT64 = typedef TypedField<STInteger<std::uint64_t> >

Definition at line 320 of file SField.h.

SF_HASH128

using ripple::SF_HASH128 = typedef TypedField<STBitString<128> >

Definition at line 321 of file SField.h.

SF_HASH160

using ripple::SF_HASH160 = typedef TypedField<STBitString<160> >

Definition at line 322 of file SField.h.

SF_HASH256

using ripple::SF_HASH256 = typedef TypedField<STBitString<256> >

Definition at line 323 of file SField.h.

SF_ACCOUNT

using ripple::SF_ACCOUNT = typedef TypedField<STAccount>

Definition at line 324 of file SField.h.

SF_AMOUNT

using ripple::SF_AMOUNT = typedef TypedField<STAmount>

Definition at line 325 of file SField.h.

SF_VL

using ripple::SF_VL = typedef TypedField<STBlob>

Definition at line 326 of file SField.h.

SF_VECTOR256

using ripple::SF_VECTOR256 = typedef TypedField<STVector256>

Definition at line 327 of file SField.h.

STHash128

using ripple::STHash128 = typedef STBitString<128>

Definition at line 117 of file STBitString.h.

STHash160

using ripple::STHash160 = typedef STBitString<160>

Definition at line 118 of file STBitString.h.

STHash256

using ripple::STHash256 = typedef STBitString<256>

Definition at line 119 of file STBitString.h.

STUInt8

using ripple::STUInt8 = typedef STInteger<unsigned char>

Definition at line 112 of file STInteger.h.

STUInt16

using ripple::STUInt16 = typedef STInteger<std::uint16_t>

Definition at line 113 of file STInteger.h.

STUInt32

using ripple::STUInt32 = typedef STInteger<std::uint32_t>

Definition at line 114 of file STInteger.h.

STUInt64

using ripple::STUInt64 = typedef STInteger<std::uint64_t>

Definition at line 115 of file STInteger.h.

SLE

using ripple::SLE = typedef STLedgerEntry

Definition at line 120 of file STLedgerEntry.h.

TERUnderlyingType

using ripple::TERUnderlyingType = typedef int

Definition at line 37 of file TER.h.

NotTEC

using ripple::NotTEC = typedef TERSubset<CanCvtToNotTEC>

Definition at line 515 of file TER.h.

TER

using ripple::TER = typedef TERSubset<CanCvtToTER>

Definition at line 555 of file TER.h.

Directory

using ripple::Directory = typedef base_uint<256, detail::DirectoryTag>

Directory is an index into the directory of offer books.

The last 64 bits of this are the quality.

Definition at line 53 of file UintTypes.h.

Currency

using ripple::Currency = typedef base_uint<160, detail::CurrencyTag>

Currency is a hash representing a specific currency.

Definition at line 56 of file UintTypes.h.

NodeID

using ripple::NodeID = typedef base_uint<160, detail::NodeIDTag>

NodeID is a 160-bit hash representing one node.

Definition at line 59 of file UintTypes.h.

TxnDataBinary

using ripple::TxnDataBinary = typedef RelationalDBInterface::txnMetaLedgerType

Definition at line 47 of file AccountTx.cpp.

LedgerSpecifier

using ripple::LedgerSpecifier = typedef RelationalDBInterface::LedgerSpecifier

Definition at line 52 of file AccountTx.cpp.

ServerHandler

using ripple::ServerHandler = typedef ServerHandlerImp

Definition at line 37 of file ServerHandler.h.

Endpoints

using ripple::Endpoints = typedef std::vector<boost::asio::ip::tcp::endpoint>

Definition at line 36 of file ServerImpl.h.

FullBelowCache

using ripple::FullBelowCache = typedef detail::BasicFullBelowCache<uint256>

Definition at line 147 of file FullBelowCache.h.

TreeNodeCache

using ripple::TreeNodeCache = typedef TaggedCache<uint256, SHAMapTreeNode>

Definition at line 27 of file TreeNodeCache.h.

sha256_t

using ripple::sha256_t = typedef unsigned_integer<256, std::size_t>

Definition at line 165 of file hardened_hash_test.cpp.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
peerCountStart
peerCountAdd
ledgerTimeoutRetriesMax
ledgerBecomeAggressiveThreshold
missingNodesFind
reqNodesReply
reqNodes

Definition at line 42 of file InboundLedger.cpp.

anonymous enum

anonymous enum

Enumerator
startPeers
setKeepRounds

Definition at line 34 of file InboundTransactions.cpp.

anonymous enum

anonymous enum

Enumerator
NORM_TIMEOUTS
MAX_TIMEOUTS

Definition at line 38 of file TransactionAcquire.cpp.

ManifestDisposition

enum ripple::ManifestDisposition

strong

Enumerator
accepted	Manifest is valid.
stale	Sequence is too old.
badMasterKey	The master key is not acceptable to us.
badEphemeralKey	The ephemeral key is not acceptable to us.
invalid	Timely, but invalid signature.

Definition at line 183 of file Manifest.h.

OperatingMode

enum ripple::OperatingMode

strong

Specifies the mode under which the server believes it's operating.

This has implications about how the server processes transactions and how it responds to requests (e.g. account balance request).

Note

Other code relies on the numerical values of these constants; do not change them without verifying each use and ensuring that it is not a breaking change.

Enumerator
DISCONNECTED	not ready to process requests
CONNECTED	convinced we are talking to the network
SYNCING	fallen slightly behind
TRACKING	convinced we agree with the network
FULL	we have the ledger and can even validate

Definition at line 66 of file NetworkOPs.h.

TransStatus

enum ripple::TransStatus

Enumerator
NEW
INVALID
INCLUDED
CONFLICTED
COMMITTED
HELD
REMOVED
OBSOLETE
INCOMPLETE

Definition at line 45 of file Transaction.h.

TxSearched

enum ripple::TxSearched

strong

Enumerator
all
some
unknown

Definition at line 57 of file Transaction.h.

ListDisposition

enum ripple::ListDisposition

strong

Enumerator
accepted	List is valid.
expired	List is expired, but has the largest non-pending sequence seen so far.
pending	List will be valid in the future.
same_sequence	Same sequence as current list.
known_sequence	Future sequence already seen.
stale	Trusted publisher key, but seq is too old.
untrusted	List signed by untrusted publisher key.
unsupported_version	List version is not supported.
invalid	Invalid format or signature.

Definition at line 55 of file ValidatorList.h.

PublisherStatus

enum ripple::PublisherStatus

strong

Enumerator
available
expired
unavailable
revoked

Definition at line 87 of file ValidatorList.h.

DebtDirection

enum ripple::DebtDirection

strong

Enumerator
issues
redeems

Definition at line 37 of file Steps.h.

QualityDirection

enum ripple::QualityDirection

strong

Enumerator
in
out

Definition at line 38 of file Steps.h.

StrandDirection

enum ripple::StrandDirection

strong

Enumerator
forward
reverse

Definition at line 39 of file Steps.h.

AmendmentVote

enum ripple::AmendmentVote : int

strong

Enumerator
up
down

Definition at line 137 of file RelationalDBInterface_global.h.

TableType

enum ripple::TableType

strong

Enumerator
Ledgers
Transactions
AccountTransactions

Definition at line 34 of file RelationalDBInterface_nodes.h.

Validity

enum ripple::Validity

strong

Describes the pre-processing validity of a transaction.

See also

checkValidity, forceValidity

Enumerator
SigBad	Signature is bad. Didn't do local checks.
SigGoodOnly	Signature is good, but local checks fail.
Valid	Signature and local checks are good / passed.

Definition at line 40 of file apply.h.

ApplyResult

enum ripple::ApplyResult

strong

Enum class for return value from applyTransaction

See also

applyTransaction

Enumerator
Success	Applied to this ledger.
Fail	Should not be retried in this ledger.
Retry	Should be retried in this ledger.

Definition at line 134 of file apply.h.

CrossType

enum ripple::CrossType

strong

The flavor of an offer crossing.

Enumerator
XrpToIou
IouToXrp
IouToIou

Definition at line 36 of file Taker.h.

LogSeverity

enum ripple::LogSeverity

Enumerator
lsINVALID
lsTRACE
lsDEBUG
lsINFO
lsWARNING
lsERROR
lsFATAL

Definition at line 35 of file Log.h.

ConsensusMode

enum ripple::ConsensusMode

strong

Represents how a node currently participates in Consensus.

A node participates in consensus in varying modes, depending on how the node was configured by its operator and how well it stays in sync with the network during consensus.

proposing               observing
   \                       /
    \---> wrongLedger <---/
               ^
               |
               |
               v
          switchedLedger

We enter the round proposing or observing. If we detect we are working on the wrong prior ledger, we go to wrongLedger and attempt to acquire the right one. Once we acquire the right one, we go to the switchedLedger mode. It is possible we fall behind again and find there is a new better ledger, moving back and forth between wrongLedger and switchLedger as we attempt to catch up.

Enumerator
proposing	We are normal participant in consensus and propose our position.
observing	We are observing peer positions, but not proposing our position.
wrongLedger	We have the wrong ledger and are attempting to acquire it.
switchedLedger	We switched ledgers since we started this consensus round but are now running on what we believe is the correct ledger. This mode is as if we entered the round observing, but is used to indicate we did have the wrongLedger at some point.

Definition at line 55 of file ConsensusTypes.h.

ConsensusPhase

enum ripple::ConsensusPhase

strong

Phases of consensus for a single ledger round.

     "close"             "accept"
open ------- > establish ---------> accepted
  ^               |                    |
  |---------------|                    |
  ^                     "startRound"   |
  |------------------------------------|

The typical transition goes from open to establish to accepted and then a call to startRound begins the process anew. However, if a wrong prior ledger is detected and recovered during the establish or accept phase, consensus will internally go back to open (see Consensus::handleWrongLedger).

Enumerator
open	We haven't closed our ledger yet, but others might have.
establish	Establishing consensus by exchanging proposals with our peers.
accepted	We have accepted a new last closed ledger and are waiting on a call to startRound to begin the next consensus round. No changes to consensus phase occur while in this phase.

Definition at line 103 of file ConsensusTypes.h.

ConsensusState

enum ripple::ConsensusState

strong

Whether we have or don't have a consensus.

Enumerator
No	We do not have consensus.
MovedOn	The network has consensus without us.
Yes	We have consensus along with the network.

Definition at line 186 of file ConsensusTypes.h.

ValStatus

enum ripple::ValStatus

strong

Status of validation we received.

Enumerator
current	This was a new validation and was added.
stale	Not current or was older than current from this node.
badSeq	A validation violates the increasing seq requirement.
multiple	Multiple validations by a validator for the same ledger.
conflicting	Multiple validations by a validator for different ledgers.

Definition at line 166 of file Validations.h.

SizedItem

enum ripple::SizedItem : std::size_t

strong

Enumerator
sweepInterval
treeCacheSize
treeCacheAge
ledgerSize
ledgerAge
ledgerFetch
hashNodeDBCache
txnDBCache
lgrDBCache
openFinalLimit
burstSize
ramSizeGB

Definition at line 48 of file Config.h.

JobType

enum ripple::JobType

Enumerator
jtINVALID
jtPACK
jtPUBOLDLEDGER
jtVALIDATION_ut
jtTRANSACTION_l
jtREPLAY_REQ
jtLEDGER_REQ
jtPROPOSAL_ut
jtREPLAY_TASK
jtLEDGER_DATA
jtCLIENT
jtRPC
jtUPDATE_PF
jtTRANSACTION
jtMISSING_TXN
jtREQUESTED_TXN
jtBATCH
jtADVANCE
jtPUBLEDGER
jtTXN_DATA
jtWAL
jtVALIDATION_t
jtWRITE
jtACCEPT
jtPROPOSAL_t
jtSWEEP
jtNETOP_CLUSTER
jtNETOP_TIMER
jtADMIN
jtPEER
jtDISK
jtTXN_PROC
jtOB_SETUP
jtPATH_FIND
jtHO_READ
jtHO_WRITE
jtGENERIC
jtNS_SYNC_READ
jtNS_ASYNC_READ
jtNS_WRITE

Definition at line 34 of file Job.h.

ApplyFlags

enum ripple::ApplyFlags : std::uint32_t

Enumerator
tapNONE
tapFAIL_HARD
tapRETRY
tapPREFER_QUEUE
tapUNLIMITED

Definition at line 29 of file ApplyView.h.

FreezeHandling

enum ripple::FreezeHandling

Controls the treatment of frozen account balances.

Enumerator
fhIGNORE_FREEZE
fhZERO_IF_FROZEN

Definition at line 52 of file View.h.

NodeObjectType

enum ripple::NodeObjectType : std::uint32_t

The types of node objects.

Enumerator
hotUNKNOWN
hotLEDGER
hotACCOUNT_NODE
hotTRANSACTION_NODE

Definition at line 32 of file NodeObject.h.

ShardState

enum ripple::ShardState : std::uint32_t

strong

Shard states.

Enumerator
acquire
complete
finalizing
finalized
queued

Definition at line 60 of file nodestore/Types.h.

ProtocolFeature

enum ripple::ProtocolFeature

strong

Enumerator
ValidatorListPropagation
ValidatorList2Propagation
LedgerReplay

Definition at line 38 of file ripple/overlay/Peer.h.

error_code_i

enum ripple::error_code_i

Enumerator
rpcUNKNOWN
rpcSUCCESS
rpcBAD_SYNTAX
rpcJSON_RPC
rpcFORBIDDEN
rpcNO_PERMISSION
rpcNO_EVENTS
rpcTOO_BUSY
rpcSLOW_DOWN
rpcHIGH_FEE
rpcNOT_ENABLED
rpcNOT_READY
rpcAMENDMENT_BLOCKED
rpcNO_CLOSED
rpcNO_CURRENT
rpcNO_NETWORK
rpcNOT_SYNCED
rpcACT_NOT_FOUND
rpcLGR_NOT_FOUND
rpcLGR_NOT_VALIDATED
rpcMASTER_DISABLED
rpcTXN_NOT_FOUND
rpcINVALID_PARAMS
rpcUNKNOWN_COMMAND
rpcNO_PF_REQUEST
rpcACT_MALFORMED
rpcALREADY_MULTISIG
rpcALREADY_SINGLE_SIG
rpcBAD_FEATURE
rpcBAD_ISSUER
rpcBAD_MARKET
rpcBAD_SECRET
rpcBAD_SEED
rpcCHANNEL_MALFORMED
rpcCHANNEL_AMT_MALFORMED
rpcCOMMAND_MISSING
rpcDST_ACT_MALFORMED
rpcDST_ACT_MISSING
rpcDST_ACT_NOT_FOUND
rpcDST_AMT_MALFORMED
rpcDST_AMT_MISSING
rpcDST_ISR_MALFORMED
rpcLGR_IDXS_INVALID
rpcLGR_IDX_MALFORMED
rpcPUBLIC_MALFORMED
rpcSIGNING_MALFORMED
rpcSENDMAX_MALFORMED
rpcSRC_ACT_MALFORMED
rpcSRC_ACT_MISSING
rpcSRC_ACT_NOT_FOUND
rpcSRC_CUR_MALFORMED
rpcSRC_ISR_MALFORMED
rpcSTREAM_MALFORMED
rpcATX_DEPRECATED
rpcINTERNAL
rpcNOT_IMPL
rpcNOT_SUPPORTED
rpcBAD_KEY_TYPE
rpcDB_DESERIALIZATION
rpcEXCESSIVE_LGR_RANGE
rpcINVALID_LGR_RANGE
rpcEXPIRED_VALIDATOR_LIST
rpcFAILED_TO_FORWARD
rpcREPORTING_UNSUPPORTED
rpcLAST

Definition at line 40 of file ErrorCodes.h.

warning_code_i

enum ripple::warning_code_i

Codes returned in the warnings array of certain RPC commands.

These values need to remain stable.

Enumerator
warnRPC_UNSUPPORTED_MAJORITY
warnRPC_AMENDMENT_BLOCKED
warnRPC_EXPIRED_VALIDATOR_LIST
warnRPC_REPORTING

Definition at line 150 of file ErrorCodes.h.

DefaultVote

enum ripple::DefaultVote : bool

strong

Enumerator
no
yes

Definition at line 69 of file Feature.h.

HashPrefix

enum ripple::HashPrefix : std::uint32_t

strong

Prefix for hashing functions.

These prefixes are inserted before the source material used to generate various hashes. This is done to put each hash in its own "space." This way, two different types of objects with the same binary data will produce different hashes.

Each prefix is a 4-byte value with the last byte set to zero and the first three bytes formed from the ASCII equivalent of some arbitrary string. For example "TXN".

Note

Hash prefixes are part of the protocol; you cannot, arbitrarily, change the type or the value of any of these without causing breakage.

Enumerator
transactionID	transaction plus signature to give transaction ID
txNode	transaction plus metadata
leafNode	account state
innerNode	inner node in V1 tree
ledgerMaster	ledger master data for signing
txSign	inner transaction to sign
txMultiSign	inner transaction to multi-sign
validation	validation for signing
proposal	proposal for signing
manifest	Manifest.
paymentChannelClaim	Payment Channel Claim.
shardInfo	shard info for signing

Definition at line 54 of file HashPrefix.h.

LedgerNameSpace

enum ripple::LedgerNameSpace : std::uint16_t

strong

Type-specific prefix for calculating ledger indices.

The identifier for a given object within the ledger is calculated based on some object-specific parameters. To ensure that different types of objects have different indices, even if they happen to use the same set of parameters, we use "tagged hashing" by adding a type-specific prefix.

Note

These values are part of the protocol and CANNOT be arbitrarily changed. If they were, on-ledger objects may no longer be able to be located or addressed.

Additions to this list are OK, but changing existing entries to assign them a different values should never be needed.

Entries that are removed should be moved to the bottom of the enum and marked as [[deprecated]] to prevent accidental reuse.

Enumerator
ACCOUNT
DIR_NODE
TRUST_LINE
OFFER
OWNER_DIR
BOOK_DIR
SKIP_LIST
ESCROW
AMENDMENTS
FEE_SETTINGS
TICKET
SIGNER_LIST
XRP_PAYMENT_CHANNEL
CHECK
DEPOSIT_PREAUTH
NEGATIVE_UNL
CONTRACT
GENERATOR
NICKNAME

Definition at line 46 of file Indexes.cpp.

KeyType

enum ripple::KeyType

strong

Enumerator
secp256k1
ed25519

Definition at line 28 of file KeyType.h.

LedgerEntryType

enum ripple::LedgerEntryType : std::uint16_t

Identifiers for on-ledger objects.

Each ledger object requires a unique type identifier, which is stored within the object itself; this makes it possible to iterate the entire ledger and determine each object's type and verify that the object you retrieved from a given hash matches the expected type.

Warning

Since these values are stored inside objects stored on the ledger they are part of the protocol. Changing them should be avoided because without special handling, this will result in a hard fork.

Note

Values outside this range may be used internally by the code for various purposes, but attempting to use such values to identify on-ledger objects will results in an invariant failure.

When retiring types, the specific values should not be removed but should be marked as [[deprecated]]. This is to avoid accidental reuse of identifiers.

Enumerator
ltACCOUNT_ROOT	A ledger object which describes an account. \sa keylet::account
ltDIR_NODE	A ledger object which contains a list of object identifiers. \sa keylet::page, keylet::quality, keylet::book, keylet::next and keylet::ownerDir
ltRIPPLE_STATE	A ledger object which describes a bidirectional trust line. @note Per Vinnie Falco this should be renamed to ltTRUST_LINE \sa keylet::line
ltTICKET	A ledger object which describes a ticket. \sa keylet::ticket
ltSIGNER_LIST	A ledger object which contains a signer list for an account. \sa keylet::signers
ltOFFER	A ledger object which describes an offer on the DEX. \sa keylet::offer
ltLEDGER_HASHES	A ledger object that contains a list of ledger hashes. This type is used to store the ledger hashes which the protocol uses to implement skip lists that allow for efficient backwards (and, in theory, forward) forward iteration across large ledger ranges. \sa keylet::skip
ltAMENDMENTS	The ledger object which lists details about amendments on the network. \note This is a singleton: only one such object exists in the ledger. \sa keylet::amendments
ltFEE_SETTINGS	The ledger object which lists the network's fee settings. \note This is a singleton: only one such object exists in the ledger. \sa keylet::fees
ltESCROW	A ledger object describing a single escrow. \sa keylet::escrow
ltPAYCHAN	A ledger object describing a single unidirectional XRP payment channel. \sa keylet::payChan
ltCHECK	A ledger object which describes a check. \sa keylet::check
ltDEPOSIT_PREAUTH	A ledger object which describes a deposit preauthorization. \sa keylet::depositPreauth
ltNEGATIVE_UNL	The ledger object which tracks the current negative UNL state. \note This is a singleton: only one such object exists in the ledger. \sa keylet::negativeUNL
ltANY	A special type, matching any ledger entry type. The value does not represent a concrete type, but rather is used in contexts where the specific type of a ledger object is unimportant, unknown or unavailable. Objects with this special type cannot be created or stored on the ledger. \sa keylet::unchecked
ltCHILD	A special type, matching any ledger type except directory nodes. The value does not represent a concrete type, but rather is used in contexts where the ledger object must not be a directory node but its specific type is otherwise unimportant, unknown or unavailable. Objects with this special type cannot be created or stored on the ledger. \sa keylet::child
ltNICKNAME	A legacy, deprecated type. \deprecated **This object type is not supported and should not be used.** Support for this type of object was never implemented. No objects of this type were ever created.
ltCONTRACT	A legacy, deprecated type. \deprecated **This object type is not supported and should not be used.** Support for this type of object was never implemented. No objects of this type were ever created.
ltGENERATOR_MAP	A legacy, deprecated type. \deprecated **This object type is not supported and should not be used.** Support for this type of object was never implemented. No objects of this type were ever created.

Definition at line 53 of file LedgerFormats.h.

LedgerSpecificFlags

enum ripple::LedgerSpecificFlags

Enumerator
lsfPasswordSpent
lsfRequireDestTag
lsfRequireAuth
lsfDisallowXRP
lsfDisableMaster
lsfNoFreeze
lsfGlobalFreeze
lsfDefaultRipple
lsfDepositAuth
lsfPassive
lsfSell
lsfLowReserve
lsfHighReserve
lsfLowAuth
lsfHighAuth
lsfLowNoRipple
lsfHighNoRipple
lsfLowFreeze
lsfHighFreeze
lsfOneOwnerCount

Definition at line 209 of file LedgerFormats.h.

ECDSACanonicality

enum ripple::ECDSACanonicality

strong

Enumerator
canonical
fullyCanonical

Definition at line 195 of file PublicKey.h.

SerializedTypeID

enum ripple::SerializedTypeID

Enumerator
STI_UNKNOWN
STI_DONE
STI_NOTPRESENT
STI_UINT16
STI_UINT32
STI_UINT64
STI_HASH128
STI_HASH256
STI_AMOUNT
STI_VL
STI_ACCOUNT
STI_OBJECT
STI_ARRAY
STI_UINT8
STI_HASH160
STI_PATHSET
STI_VECTOR256
STI_TRANSACTION
STI_LEDGERENTRY
STI_VALIDATION
STI_METADATA

Definition at line 52 of file SField.h.

SOEStyle

enum ripple::SOEStyle

Kind of element in each entry of an SOTemplate.

Enumerator
soeINVALID
soeREQUIRED
soeOPTIONAL
soeDEFAULT

Definition at line 33 of file SOTemplate.h.

JsonOptions

enum ripple::JsonOptions

strong

Enumerator
none
include_date

Definition at line 34 of file STBase.h.

TxnSql

enum ripple::TxnSql : char

Enumerator
txnSqlNew
txnSqlConflict
txnSqlHeld
txnSqlValidated
txnSqlIncluded
txnSqlUnknown

Definition at line 34 of file STTx.h.

TELcodes

enum ripple::TELcodes : TERUnderlyingType

Enumerator
telLOCAL_ERROR
telBAD_DOMAIN
telBAD_PATH_COUNT
telBAD_PUBLIC_KEY
telFAILED_PROCESSING
telINSUF_FEE_P
telNO_DST_PARTIAL
telCAN_NOT_QUEUE
telCAN_NOT_QUEUE_BALANCE
telCAN_NOT_QUEUE_BLOCKS
telCAN_NOT_QUEUE_BLOCKED
telCAN_NOT_QUEUE_FEE
telCAN_NOT_QUEUE_FULL

Definition at line 41 of file TER.h.

TEMcodes

enum ripple::TEMcodes : TERUnderlyingType

Enumerator
temMALFORMED
temBAD_AMOUNT
temBAD_CURRENCY
temBAD_EXPIRATION
temBAD_FEE
temBAD_ISSUER
temBAD_LIMIT
temBAD_OFFER
temBAD_PATH
temBAD_PATH_LOOP
temBAD_REGKEY
temBAD_SEND_XRP_LIMIT
temBAD_SEND_XRP_MAX
temBAD_SEND_XRP_NO_DIRECT
temBAD_SEND_XRP_PARTIAL
temBAD_SEND_XRP_PATHS
temBAD_SEQUENCE
temBAD_SIGNATURE
temBAD_SRC_ACCOUNT
temBAD_TRANSFER_RATE
temDST_IS_SRC
temDST_NEEDED
temINVALID
temINVALID_FLAG
temREDUNDANT
temRIPPLE_EMPTY
temDISABLED
temBAD_SIGNER
temBAD_QUORUM
temBAD_WEIGHT
temBAD_TICK_SIZE
temINVALID_ACCOUNT_ID
temCANNOT_PREAUTH_SELF
temINVALID_COUNT
temUNCERTAIN
temUNKNOWN
temSEQ_AND_TICKET

Definition at line 68 of file TER.h.

TEFcodes

enum ripple::TEFcodes : TERUnderlyingType

Enumerator
tefFAILURE
tefALREADY
tefBAD_ADD_AUTH
tefBAD_AUTH
tefBAD_LEDGER
tefCREATED
tefEXCEPTION
tefINTERNAL
tefNO_AUTH_REQUIRED
tefPAST_SEQ
tefWRONG_PRIOR
tefMASTER_DISABLED
tefMAX_LEDGER
tefBAD_SIGNATURE
tefBAD_QUORUM
tefNOT_MULTI_SIGNING
tefBAD_AUTH_MASTER
tefINVARIANT_FAILED
tefTOO_BIG
tefNO_TICKET

Definition at line 126 of file TER.h.

TERcodes

enum ripple::TERcodes : TERUnderlyingType

Enumerator
terRETRY
terFUNDS_SPENT
terINSUF_FEE_B
terNO_ACCOUNT
terNO_AUTH
terNO_LINE
terOWNERS
terPRE_SEQ
terLAST
terNO_RIPPLE
terQUEUED
terPRE_TICKET

Definition at line 168 of file TER.h.

TEScodes

enum ripple::TEScodes : TERUnderlyingType

Enumerator
tesSUCCESS

Definition at line 207 of file TER.h.

TECcodes

enum ripple::TECcodes : TERUnderlyingType

Enumerator
tecCLAIM
tecPATH_PARTIAL
tecUNFUNDED_ADD
tecUNFUNDED_OFFER
tecUNFUNDED_PAYMENT
tecFAILED_PROCESSING
tecDIR_FULL
tecINSUF_RESERVE_LINE
tecINSUF_RESERVE_OFFER
tecNO_DST
tecNO_DST_INSUF_XRP
tecNO_LINE_INSUF_RESERVE
tecNO_LINE_REDUNDANT
tecPATH_DRY
tecUNFUNDED
tecNO_ALTERNATIVE_KEY
tecNO_REGULAR_KEY
tecOWNERS
tecNO_ISSUER
tecNO_AUTH
tecNO_LINE
tecINSUFF_FEE
tecFROZEN
tecNO_TARGET
tecNO_PERMISSION
tecNO_ENTRY
tecINSUFFICIENT_RESERVE
tecNEED_MASTER_KEY
tecDST_TAG_NEEDED
tecINTERNAL
tecOVERSIZE
tecCRYPTOCONDITION_ERROR
tecINVARIANT_FAILED
tecEXPIRED
tecDUPLICATE
tecKILLED
tecHAS_OBLIGATIONS
tecTOO_SOON
tecHOOK_ERROR

Definition at line 222 of file TER.h.

TokenType

enum ripple::TokenType : std::uint8_t

strong

Enumerator
None
NodePublic
NodePrivate
AccountID
AccountPublic
AccountSecret
FamilyGenerator
FamilySeed

Definition at line 29 of file tokens.h.

TxType

enum ripple::TxType : std::uint16_t

Transaction type identifiers.

These are part of the binary message format. Transaction type identifieers

Each ledger object requires a unique type identifier, which is stored within the object itself; this makes it possible to iterate the entire ledger and determine each object's type and verify that the object you retrieved from a given hash matches the expected type.

Warning

Since these values are included in transactions, which are signed objects, and used by the code to determine the type of transaction being invoked, they are part of the protocol. Changing them should be avoided because without special handling, this will result in a hard fork.

Note

When retiring types, the specific values should not be removed but should be marked as [[deprecated]]. This is to avoid accidental reuse of identifiers.

Enumerator
ttPAYMENT	This transaction type executes a payment.
ttESCROW_CREATE	This transaction type creates an escrow object.
ttESCROW_FINISH	This transaction type completes an existing escrow.
ttACCOUNT_SET	This transaction type adjusts various account settings.
ttESCROW_CANCEL	This transaction type cancels an existing escrow.
ttREGULAR_KEY_SET	This transaction type sets or clears an account's "regular key".
ttNICKNAME_SET	This transaction type is deprecated; it is retained for historical purposes.
ttOFFER_CREATE	This transaction type creates an offer to trade one asset for another.
ttOFFER_CANCEL	This transaction type cancels existing offers to trade one asset for another.
ttCONTRACT	This transaction type is deprecated; it is retained for historical purposes.
ttTICKET_CREATE	This transaction type creates a new set of tickets.
ttSPINAL_TAP	This identifier was never used, but the slot is reserved for historical purposes.
ttSIGNER_LIST_SET	This transaction type modifies the signer list associated with an account.
ttPAYCHAN_CREATE	This transaction type creates a new unidirectional XRP payment channel.
ttPAYCHAN_FUND	This transaction type funds an existing unidirectional XRP payment channel.
ttPAYCHAN_CLAIM	This transaction type submits a claim against an existing unidirectional payment channel.
ttCHECK_CREATE	This transaction type creates a new check.
ttCHECK_CASH	This transaction type cashes an existing check.
ttCHECK_CANCEL	This transaction type cancels an existing check.
ttDEPOSIT_PREAUTH	This transaction type grants or revokes authorization to transfer funds.
ttTRUST_SET	This transaction type modifies a trustline between two accounts.
ttACCOUNT_DELETE	This transaction type deletes an existing account.
ttHOOK_SET	This transaction type installs a hook.
ttAMENDMENT	This system-generated transaction type is used to update the status of the various amendments. For details, see: https://xrpl.org/amendments.html
ttFEE	This system-generated transaction type is used to update the network's fee settings. For details, see: https://xrpl.org/fee-voting.html
ttUNL_MODIFY	This system-generated transaction type is used to update the network's negative UNL. For details, see: https://xrpl.org/negative-unl.html

Definition at line 56 of file TxFormats.h.

Role

enum ripple::Role

strong

Indicates the level of administrative permission to grant.

IDENTIFIED role has unlimited resources but cannot perform some RPC commands. ADMIN role has unlimited resources and is able to perform all RPC commands.

Enumerator
GUEST
USER
IDENTIFIED
ADMIN
PROXY
FORBID

Definition at line 40 of file Role.h.

SHAMapState

enum ripple::SHAMapState

strong

Describes the current state of a given SHAMap.

Enumerator
Modifying	The map is in flux and objects can be added and removed. Example: map underlying the open ledger.
Immutable	The map is set in stone and cannot be changed. Example: a map underlying a given closed ledger.
Synching	The map's hash is fixed but valid nodes may be missing and can be added. Example: a map that's syncing a given peer's closing ledger.
Invalid	The map is known to not be valid. Example: usually synching a corrupt ledger.

Definition at line 46 of file SHAMap.h.

SHAMapType

enum ripple::SHAMapType

strong

Enumerator
TRANSACTION
STATE
FREE

Definition at line 32 of file SHAMapMissingNode.h.

SHAMapNodeType

enum ripple::SHAMapNodeType

strong

Enumerator
tnINNER
tnTRANSACTION_NM
tnTRANSACTION_MD
tnACCOUNT_STATE

Definition at line 127 of file SHAMapTreeNode.h.

Function Documentation

proposalUniqueId()

uint256 ripple::proposalUniqueId	(	uint256 const &	proposeHash,
		uint256 const &	previousLedger,
		std::uint32_t	proposeSeq,
		NetClock::time_point	closeTime,
		Slice const &	publicKey,
		Slice const &	signature
	)

Calculate a unique identifier for a signed proposal.

The identifier is based on all the fields that contribute to the signature, as well as the signature itself. The "last closed ledger" field may be omitted, but the signer will compute the signature as if this field was present. Recipients of the proposal will inject the last closed ledger in order to validate the signature. If the last closed ledger is left out, then it is considered as all zeroes for the purposes of signing.

Parameters

proposeHash	The hash of the proposed position
previousLedger	The hash of the ledger the proposal is based upon
proposeSeq	Sequence number of the proposal
closeTime	Close time of the proposal
publicKey	Signer's public key
signature	Proposal signature

Definition at line 72 of file RCLCxPeerPos.cpp.

mismatch()

RCLValidatedLedger::Seq ripple::mismatch	(	RCLValidatedLedger const &	a,
		RCLValidatedLedger const &	b
	)

Definition at line 97 of file RCLValidations.cpp.

handleNewValidation()

void ripple::handleNewValidation	(	Application &	app,
		std::shared_ptr< STValidation > const &	val,
		std::string const &	source
	)

Handle a new validation.

Also sets the trust status of a validation based on the validating node's public key and this node's current UNL.

Parameters

app	Application object containing validations and ledgerMaster
val	The validation to add
source	Name associated with validation used in logging

Definition at line 151 of file RCLValidations.cpp.

buildLedger() [1/2]

std::shared_ptr< Ledger > ripple::buildLedger	(	std::shared_ptr< Ledger const > const &	parent,
		NetClock::time_point	closeTime,
		const bool	closeTimeCorrect,
		NetClock::duration	closeResolution,
		Application &	app,
		CanonicalTXSet &	txns,
		std::set< TxID > &	failedTxs,
		beast::Journal	j
	)

Build a new ledger by applying consensus transactions.

Build a new ledger by applying a set of transactions accepted as part of consensus.

Parameters

parent	The ledger to apply transactions to
closeTime	The time the ledger closed
closeTimeCorrect	Whether consensus agreed on close time
closeResolution	Resolution used to determine consensus close time
app	Handle to application instance
txs	On entry, transactions to apply; on exit, transactions that must be retried in next round.
failedTxs	Populated with transactions that failed in this round
j	Journal to use for logging

Returns

The newly built ledger

Definition at line 175 of file BuildLedger.cpp.

buildLedger() [2/2]

std::shared_ptr< Ledger > ripple::buildLedger	(	LedgerReplay const &	replayData,
		ApplyFlags	applyFlags,
		Application &	app,
		beast::Journal	j
	)

Build a new ledger by replaying transactions.

Build a new ledger by replaying transactions accepted into a prior ledger.

Parameters

replayData	Data of the ledger to replay
applyFlags	Flags to use when applying transactions
app	Handle to application instance
j	Journal to use for logging

Returns

The newly built ledger

Definition at line 214 of file BuildLedger.cpp.

buildLedgerImpl()

template<class ApplyTxs >

std::shared_ptr<Ledger> ripple::buildLedgerImpl	(	std::shared_ptr< Ledger const > const &	parent,
		NetClock::time_point	closeTime,
		const bool	closeTimeCorrect,
		NetClock::duration	closeResolution,
		Application &	app,
		beast::Journal	j,
		ApplyTxs &&	applyTxs
	)

Definition at line 39 of file BuildLedger.cpp.

applyTransactions()

std::size_t ripple::applyTransactions	(	Application &	app,
		std::shared_ptr< Ledger const > const &	built,
		CanonicalTXSet &	txns,
		std::set< TxID > &	failed,
		OpenView &	view,
		beast::Journal	j
	)

Apply a set of consensus transactions to a ledger.

Parameters

app	Handle to application
txns	the set of transactions to apply,
failed	set of transactions that failed to apply
view	ledger to apply to
j	Journal for logging

Returns

number of transactions applied; transactions to retry left in txns

Definition at line 95 of file BuildLedger.cpp.

neededHashes()

static std::vector<uint256> ripple::neededHashes ( uint256 const &  root, SHAMap &  map, int  max, SHAMapSyncFilter *  filter  )

static

Definition at line 231 of file InboundLedger.cpp.

deserializeHeader()

LedgerInfo ripple::deserializeHeader	(	Slice	data,
		bool	hasHash
	)

Deserialize a ledger header from a byte array.

Definition at line 269 of file InboundLedger.cpp.

deserializePrefixedHeader()

LedgerInfo ripple::deserializePrefixedHeader	(	Slice	data,
		bool	hasHash
	)

Deserialize a ledger header (prefixed with 4 bytes) from a byte array.

Definition at line 293 of file InboundLedger.cpp.

make_InboundLedgers()

std::unique_ptr< InboundLedgers > ripple::make_InboundLedgers	(	Application &	app,
		InboundLedgers::clock_type &	clock,
		beast::insight::Collector::ptr const &	collector
	)

Definition at line 419 of file InboundLedgers.cpp.

make_InboundTransactions()

std::unique_ptr< InboundTransactions > ripple::make_InboundTransactions	(	Application &	app,
		beast::insight::Collector::ptr const &	collector,
		std::function< void(std::shared_ptr< SHAMap > const &, bool)>	gotSet
	)

Definition at line 272 of file InboundTransactions.cpp.

make_LedgerCleaner()

std::unique_ptr< LedgerCleaner > ripple::make_LedgerCleaner	(	Application &	app,
		beast::Journal	journal
	)

Definition at line 455 of file LedgerCleaner.cpp.

shouldAcquire()

static bool ripple::shouldAcquire ( std::uint32_t const  currentLedger, std::uint32_t const  ledgerHistory, std::optional< LedgerIndex > const  minimumOnline, std::uint32_t const  candidateLedger, beast::Journal  j  )

static

Definition at line 158 of file LedgerMaster.cpp.

populateFetchPack()

static void ripple::populateFetchPack ( SHAMap const &  want, SHAMap const *  have, std::uint32_t  cnt, protocol::TMGetObjectByHash *  into, std::uint32_t  seq, bool  withLeaves = true  )

static

Populate a fetch pack with data from the map the recipient wants.

A recipient may or may not have the map that they are asking for. If they do, we can optimize the transfer by not including parts of the map that they are already have.

Parameters

have	The map that the recipient already has (if any).
cnt	The maximum number of nodes to return.
into	The protocol object into which we add information.
seq	The sequence number of the ledger the map is a part of.
withLeaves	True if leaf nodes should be included.

Note

: The withLeaves parameter is configurable even though the code, so far, only ever sets the parameter to true.

The rationale is that for transaction trees, it may make sense to not include the leaves if the fetch pack is being constructed for someone attempting to get a recent ledger for which they already have the transactions.

However, for historical ledgers, which is the only use we have for fetch packs right now, it makes sense to include the transactions because the caller is unlikely to have them.

Definition at line 2150 of file LedgerMaster.cpp.

addJson()

void ripple::addJson	(	Json::Value &	json,
		LedgerFill const &	fill
	)

Given a Ledger and options, fill a Json::Object or Json::Value with a description of the ledger.

Definition at line 281 of file LedgerToJson.cpp.

getJson()

Json::Value ripple::getJson

(

LedgerFill const &

fill

)

Return a new Json::Value representing the ledger with given options.

Definition at line 291 of file LedgerToJson.cpp.

make_LocalTxs()

std::unique_ptr< LocalTxs > ripple::make_LocalTxs

(

)

Definition at line 197 of file LocalTxs.cpp.

debugTxstr()

std::string ripple::debugTxstr

(

std::shared_ptr< STTx const > const &

tx

)

Definition at line 208 of file OpenLedger.cpp.

debugTostr() [1/3]

std::string ripple::debugTostr

(

OrderedTxs const &

set

)

Definition at line 216 of file OpenLedger.cpp.

debugTostr() [2/3]

std::string ripple::debugTostr

(

SHAMap const &

set

)

Definition at line 225 of file OpenLedger.cpp.

debugTostr() [3/3]

std::string ripple::debugTostr

(

std::shared_ptr< ReadView const > const &

view

)

Definition at line 245 of file OpenLedger.cpp.

calculateLedgerHash()

uint256 ripple::calculateLedgerHash

(

LedgerInfo const &

info

)

Definition at line 65 of file Ledger.cpp.

deserializeTx()

std::shared_ptr< STTx const > ripple::deserializeTx

(

SHAMapItem const &

item

)

Deserialize a SHAMapItem containing a single STTx.

Throw:

May throw on deserializaton error

Definition at line 382 of file Ledger.cpp.

deserializeTxPlusMeta()

std::pair< std::shared_ptr< STTx const >, std::shared_ptr< STObject const > > ripple::deserializeTxPlusMeta

(

SHAMapItem const &

item

)

Deserialize a SHAMapItem containing STTx + STObject metadata.

The SHAMap must contain two variable length serialization objects.

Throw:

May throw on deserializaton error

Definition at line 389 of file Ledger.cpp.

isFlagLedger()

bool ripple::isFlagLedger

(

LedgerIndex

seq

)

Returns true if the given ledgerIndex is a flag ledgerIndex.

Definition at line 910 of file Ledger.cpp.

saveValidatedLedger() [1/2]

static bool ripple::saveValidatedLedger ( Application &  app, std::shared_ptr< Ledger const > const &  ledger, bool  current  )

static

Definition at line 916 of file Ledger.cpp.

pendSaveValidated()

bool ripple::pendSaveValidated	(	Application &	app,
		std::shared_ptr< Ledger const > const &	ledger,
		bool	isSynchronous,
		bool	isCurrent
	)

Save, or arrange to save, a fully-validated ledger Returns false on error.

Definition at line 944 of file Ledger.cpp.

loadLedgerHelper() [1/2]

std::shared_ptr< Ledger > ripple::loadLedgerHelper	(	LedgerInfo const &	info,
		Application &	app,
		bool	acquire
	)

Definition at line 1017 of file Ledger.cpp.

finishLoadByIndexOrHash()

static void ripple::finishLoadByIndexOrHash ( std::shared_ptr< Ledger > const &  ledger, Config const &  config, beast::Journal  j  )

static

Definition at line 1035 of file Ledger.cpp.

getLatestLedger()

std::tuple< std::shared_ptr< Ledger >, std::uint32_t, uint256 > ripple::getLatestLedger

(

Application &

app

)

Definition at line 1051 of file Ledger.cpp.

loadByIndex()

std::shared_ptr< Ledger > ripple::loadByIndex	(	std::uint32_t	ledgerIndex,
		Application &	app,
		bool	acquire
	)

Definition at line 1061 of file Ledger.cpp.

loadByHash()

std::shared_ptr< Ledger > ripple::loadByHash	(	uint256 const &	ledgerHash,
		Application &	app,
		bool	acquire
	)

Definition at line 1074 of file Ledger.cpp.

flatFetchTransactions() [1/2]

std::vector< std::pair< std::shared_ptr< STTx const >, std::shared_ptr< STObject const > > > ripple::flatFetchTransactions	(	Application &	app,
		std::vector< uint256 > &	nodestoreHashes
	)

Definition at line 1089 of file Ledger.cpp.

flatFetchTransactions() [2/2]

std::vector< std::pair< std::shared_ptr< STTx const >, std::shared_ptr< STObject const > > > ripple::flatFetchTransactions	(	ReadView const &	ledger,
		Application &	app
	)

Definition at line 1158 of file Ledger.cpp.

log_one()

static void ripple::log_one ( ReadView const &  ledger, uint256 const &  tx, char const *  msg, beast::Journal &  j  )

static

Definition at line 150 of file LedgerHistory.cpp.

log_metadata_difference()

static void ripple::log_metadata_difference ( ReadView const &  builtLedger, ReadView const &  validLedger, uint256 const &  tx, beast::Journal  j  )

static

Definition at line 172 of file LedgerHistory.cpp.

leaves()

static std::vector<SHAMapItem const*> ripple::leaves ( SHAMap const &  sm )

static

Definition at line 310 of file LedgerHistory.cpp.

serializeBlob()

template<class Object >

Blob ripple::serializeBlob

(

Object const &

o

)

Serialize an object to a blob.

Definition at line 76 of file LedgerToJson.h.

serializeHex()

std::string ripple::serializeHex

(

STObject const &

o

)

Serialize an object to a hex string.

Definition at line 85 of file LedgerToJson.h.

make_Application()

std::unique_ptr< Application > ripple::make_Application	(	std::unique_ptr< Config >	config,
		std::unique_ptr< Logs >	logs,
		std::unique_ptr< TimeKeeper >	timeKeeper
	)

Definition at line 2138 of file Application.cpp.

make_CollectorManager()

std::unique_ptr< CollectorManager > ripple::make_CollectorManager	(	Section const &	params,
		beast::Journal	journal
	)

Definition at line 72 of file CollectorManager.cpp.

make_LoadManager()

std::unique_ptr< LoadManager > ripple::make_LoadManager	(	Application &	app,
		beast::Journal	journal
	)

Definition at line 197 of file LoadManager.cpp.

adjustDescriptorLimit()

bool ripple::adjustDescriptorLimit	(	int	needed,
		beast::Journal	j
	)

Definition at line 77 of file Main.cpp.

printHelp()

void ripple::printHelp

(

const po::options_description &

desc

)

Definition at line 122 of file Main.cpp.

getNodeIdentity() [1/2]

std::pair< PublicKey, SecretKey > ripple::getNodeIdentity

(

Application &

app

)

The cryptographic credentials identifying this server instance.

Definition at line 32 of file NodeIdentity.cpp.

make_AmendmentTable()

std::unique_ptr< AmendmentTable > ripple::make_AmendmentTable	(	Application &	app,
		std::chrono::seconds	majorityTime,
		std::vector< AmendmentTable::FeatureInfo > const &	supported,
		Section const &	enabled,
		Section const &	vetoed,
		beast::Journal	journal
	)

Definition at line 789 of file AmendmentTable.cpp.

operator<() [1/10]

bool ripple::operator<	(	CanonicalTXSet::Key const &	lhs,
		CanonicalTXSet::Key const &	rhs
	)

Definition at line 25 of file CanonicalTXSet.cpp.

setup_FeeVote()

FeeVote::Setup ripple::setup_FeeVote

(

Section const &

section

)

Build FeeVote::Setup from a config section.

Definition at line 259 of file FeeVoteImpl.cpp.

make_FeeVote()

std::unique_ptr< FeeVote > ripple::make_FeeVote	(	FeeVote::Setup const &	setup,
		beast::Journal	journal
	)

Create an instance of the FeeVote logic.

Parameters

setup	The fee schedule to vote for.
journal	Where to log.

Definition at line 279 of file FeeVoteImpl.cpp.

convertBlobsToTxResult()

void ripple::convertBlobsToTxResult	(	RelationalDBInterface::AccountTxs &	to,
		std::uint32_t	ledger_index,
		std::string const &	status,
		Blob const &	rawTxn,
		Blob const &	rawMeta,
		Application &	app
	)

Definition at line 33 of file AccountTxPaging.cpp.

saveLedgerAsync()

void ripple::saveLedgerAsync	(	Application &	app,
		std::uint32_t	seq
	)

Definition at line 57 of file AccountTxPaging.cpp.

parseSection()

static std::vector<std::pair<uint256, std::string> > ripple::parseSection ( Section const &  section )

static

Definition at line 36 of file AmendmentTable.cpp.

scaleFeeLoad()

XRPAmount ripple::scaleFeeLoad	(	FeeUnit64	fee,
		LoadFeeTrack const &	feeTrack,
		Fees const &	fees,
		bool	bUnlimited
	)

Definition at line 89 of file LoadFeeTrack.cpp.

to_string() [1/26]

std::string ripple::to_string

(

Manifest const &

m

)

Format the specified manifest to a string for debugging purposes.

Definition at line 38 of file app/misc/impl/Manifest.cpp.

deserializeManifest() [1/3]

std::optional< Manifest > ripple::deserializeManifest

(

Slice

s

)

Constructs Manifest from serialized string.

Parameters

s	Serialized manifest string

Returns

std::nullopt if string is invalid

Note

This does not verify manifest signatures. Manifest::verify should be called after constructing manifest.

Definition at line 50 of file app/misc/impl/Manifest.cpp.

logMftAct() [1/2]

template<class Stream >

Stream& ripple::logMftAct	(	Stream &	s,
		std::string const &	action,
		PublicKey const &	pk,
		std::uint32_t	seq
	)

Definition at line 156 of file app/misc/impl/Manifest.cpp.

logMftAct() [2/2]

template<class Stream >

Stream& ripple::logMftAct	(	Stream &	s,
		std::string const &	action,
		PublicKey const &	pk,
		std::uint32_t	seq,
		std::uint32_t	oldSeq
	)

Definition at line 170 of file app/misc/impl/Manifest.cpp.

loadValidatorToken()

std::optional< ValidatorToken > ripple::loadValidatorToken

(

std::vector< std::string > const &

blob

)

Definition at line 239 of file app/misc/impl/Manifest.cpp.

getFeeLevelPaid()

static FeeLevel64 ripple::getFeeLevelPaid ( ReadView const &  view, STTx const &  tx  )

static

Definition at line 38 of file TxQ.cpp.

getLastLedgerSequence()

static std::optional<LedgerIndex> ripple::getLastLedgerSequence ( STTx const &  tx )

static

Definition at line 66 of file TxQ.cpp.

increase()

static FeeLevel64 ripple::increase ( FeeLevel64  level, std::uint32_t  increasePercent  )

static

Definition at line 74 of file TxQ.cpp.

setup_TxQ()

TxQ::Setup ripple::setup_TxQ

(

Config const &

config

)

Build a TxQ::Setup object from application configuration.

Definition at line 1839 of file TxQ.cpp.

to_string() [2/26]

std::string ripple::to_string

(

ListDisposition

disposition

)

Definition at line 43 of file ValidatorList.cpp.

splitMessageParts()

std::size_t ripple::splitMessageParts	(	std::vector< ValidatorList::MessageWithHash > &	messages,
		protocol::TMValidatorListCollection const &	largeMsg,
		std::size_t	maxSize,
		std::size_t	begin,
		std::size_t	end
	)

Definition at line 477 of file ValidatorList.cpp.

splitMessage()

std::size_t ripple::splitMessage	(	std::vector< ValidatorList::MessageWithHash > &	messages,
		protocol::TMValidatorListCollection const &	largeMsg,
		std::size_t	maxSize,
		std::size_t	begin = 0,
		std::size_t	end = 0
	)

Definition at line 456 of file ValidatorList.cpp.

buildValidatorListMessage() [1/2]

std::size_t ripple::buildValidatorListMessage	(	std::vector< ValidatorList::MessageWithHash > &	messages,
		std::uint32_t	rawVersion,
		std::string const &	rawManifest,
		ValidatorBlobInfo const &	currentBlob,
		std::size_t	maxSize
	)

Definition at line 540 of file ValidatorList.cpp.

buildValidatorListMessage() [2/2]

std::size_t ripple::buildValidatorListMessage	(	std::vector< ValidatorList::MessageWithHash > &	messages,
		std::uint64_t	peerSequence,
		std::uint32_t	rawVersion,
		std::string const &	rawManifest,
		std::map< std::size_t, ValidatorBlobInfo > const &	blobInfos,
		std::size_t	maxSize
	)

Definition at line 569 of file ValidatorList.cpp.

deserializeManifest() [2/3]

std::optional<Manifest> ripple::deserializeManifest

(

std::string const &

s

)

Definition at line 142 of file Manifest.h.

deserializeManifest() [3/3]

template<class T , class = std::enable_if_t< std::is_same<T, char>::value || std::is_same<T, unsigned char>::value>>

std::optional<Manifest> ripple::deserializeManifest

(

std::vector< T > const &

v

)

Definition at line 152 of file Manifest.h.

operator==() [1/15]

bool ripple::operator==	(	Manifest const &	lhs,
		Manifest const &	rhs
	)

Definition at line 159 of file Manifest.h.

operator!=() [1/12]

bool ripple::operator!=	(	Manifest const &	lhs,
		Manifest const &	rhs
	)

Definition at line 169 of file Manifest.h.

to_string() [3/26]

std::string ripple::to_string

(

ManifestDisposition

m

)

Definition at line 201 of file Manifest.h.

trunc32()

static std::uint32_t ripple::trunc32 ( std::uint64_t  v )

static

Definition at line 2000 of file NetworkOPs.cpp.

getAccounts()

static void ripple::getAccounts ( Json::Value const &  jvObj, std::vector< AccountID > &  accounts  )

static

Definition at line 2746 of file NetworkOPs.cpp.

make_NetworkOPs()

std::unique_ptr< NetworkOPs > ripple::make_NetworkOPs	(	Application &	app,
		NetworkOPs::clock_type &	clock,
		bool	standalone,
		std::size_t	minPeerCount,
		bool	startvalid,
		JobQueue &	job_queue,
		LedgerMaster &	ledgerMaster,
		ValidatorKeys const &	validatorKeys,
		boost::asio::io_service &	io_svc,
		beast::Journal	journal,
		beast::insight::Collector::ptr const &	collector
	)

Definition at line 4431 of file NetworkOPs.cpp.

make_SHAMapStore()

std::unique_ptr< SHAMapStore > ripple::make_SHAMapStore	(	Application &	app,
		NodeStore::Scheduler &	scheduler,
		beast::Journal	journal
	)

Definition at line 738 of file SHAMapStoreImp.cpp.

toDrops()

template<class T >

XRPAmount ripple::toDrops	(	FeeLevel< T > const &	level,
		XRPAmount const &	baseFee
	)

Definition at line 827 of file TxQ.h.

toFeeLevel()

FeeLevel64 ripple::toFeeLevel	(	XRPAmount const &	drops,
		XRPAmount const &	baseFee
	)

Definition at line 836 of file TxQ.h.

hash_append() [1/8]

template<class Hasher >

void ripple::hash_append	(	Hasher &	h,
		ValidatorBlobInfo const &	blobInfo
	)

Definition at line 897 of file ValidatorList.h.

hash_append() [2/8]

template<class Hasher >

void ripple::hash_append	(	Hasher &	h,
		std::vector< ValidatorBlobInfo > const &	blobs
	)

Definition at line 909 of file ValidatorList.h.

hash_append() [3/8]

template<class Hasher >

void ripple::hash_append	(	Hasher &	h,
		std::map< std::size_t, ValidatorBlobInfo > const &	blobs
	)

Definition at line 917 of file ValidatorList.h.

accountSourceCurrencies()

hash_set< Currency > ripple::accountSourceCurrencies	(	AccountID const &	account,
		std::shared_ptr< RippleLineCache > const &	lrCache,
		bool	includeXRP
	)

Definition at line 25 of file AccountCurrencies.cpp.

accountDestCurrencies()

hash_set< Currency > ripple::accountDestCurrencies	(	AccountID const &	account,
		std::shared_ptr< RippleLineCache > const &	lrCache,
		bool	includeXRP
	)

Definition at line 64 of file AccountCurrencies.cpp.

creditLimit()

STAmount ripple::creditLimit	(	ReadView const &	view,
		AccountID const &	account,
		AccountID const &	issuer,
		Currency const &	currency
	)

Calculate the maximum amount of IOUs that an account can hold.

Parameters

ledger	the ledger to check against.
account	the account of interest.
issuer	the issuer of the IOU.
currency	the IOU to check.

Returns

The maximum amount that can be held.

Definition at line 28 of file Credit.cpp.

creditLimit2()

IOUAmount ripple::creditLimit2	(	ReadView const &	v,
		AccountID const &	acc,
		AccountID const &	iss,
		Currency const &	cur
	)

Definition at line 51 of file Credit.cpp.

creditBalance()

STAmount ripple::creditBalance	(	ReadView const &	view,
		AccountID const &	account,
		AccountID const &	issuer,
		Currency const &	currency
	)

Returns the amount of IOUs issued by issuer that are held by an account.

Parameters

ledger	the ledger to check against.
account	the account of interest.
issuer	the issuer of the IOU.
currency	the IOU to check.

Definition at line 61 of file Credit.cpp.

flow() [1/3]

path::RippleCalc::Output ripple::flow	(	PaymentSandbox &	view,
		STAmount const &	deliver,
		AccountID const &	src,
		AccountID const &	dst,
		STPathSet const &	paths,
		bool	defaultPaths,
		bool	partialPayment,
		bool	ownerPaysTransferFee,
		bool	offerCrossing,
		std::optional< Quality > const &	limitQuality,
		std::optional< STAmount > const &	sendMax,
		beast::Journal	j,
		path::detail::FlowDebugInfo *	flowDebugInfo = nullptr
	)

Make a payment from the src account to the dst account.

Parameters

view	Trust lines and balances
deliver	Amount to deliver to the dst account
src	Account providing input funds for the payment
dst	Account receiving the payment
paths	Set of paths to explore for liquidity
defaultPaths	Include defaultPaths in the path set
partialPayment	If the payment cannot deliver the entire requested amount, deliver as much as possible, given the constraints
ownerPaysTransferFee	If true then owner, not sender, pays fee
offerCrossing	If true then flow is executing offer crossing, not payments
limitQuality	Do not use liquidity below this quality threshold
sendMax	Do not spend more than this amount
j	Journal to write journal messages to
flowDebugInfo	If non-null a pointer to FlowDebugInfo for debugging

Returns

Actual amount in and out, and the result code

get() [1/6]

template<class T >

T& ripple::get

(

EitherAmount &

amt

)

Definition at line 118 of file AmountSpec.h.

get< IOUAmount >() [1/2]

template<>

IOUAmount& ripple::get< IOUAmount >

(

EitherAmount &

amt

)

Definition at line 126 of file AmountSpec.h.

get< XRPAmount >() [1/2]

template<>

XRPAmount& ripple::get< XRPAmount >

(

EitherAmount &

amt

)

Definition at line 134 of file AmountSpec.h.

get() [2/6]

template<class T >

T const& ripple::get

(

EitherAmount const &

amt

)

Definition at line 142 of file AmountSpec.h.

get< IOUAmount >() [2/2]

template<>

IOUAmount const& ripple::get< IOUAmount >

(

EitherAmount const &

amt

)

Definition at line 150 of file AmountSpec.h.

get< XRPAmount >() [2/2]

template<>

XRPAmount const& ripple::get< XRPAmount >

(

EitherAmount const &

amt

)

Definition at line 158 of file AmountSpec.h.

toAmountSpec() [1/2]

AmountSpec ripple::toAmountSpec

(

STAmount const &

amt

)

Definition at line 165 of file AmountSpec.h.

toEitherAmount()

EitherAmount ripple::toEitherAmount

(

STAmount const &

amt

)

Definition at line 189 of file AmountSpec.h.

toAmountSpec() [2/2]

AmountSpec ripple::toAmountSpec	(	EitherAmount const &	ea,
		std::optional< Currency > const &	c
	)

Definition at line 197 of file AmountSpec.h.

limitStepIn()

template<class TIn , class TOut >

static void ripple::limitStepIn ( Quality const &  ofrQ, TAmounts< TIn, TOut > &  ofrAmt, TAmounts< TIn, TOut > &  stpAmt, TOut &  ownerGives, std::uint32_t  transferRateIn, std::uint32_t  transferRateOut, TIn const &  limit  )

static

Definition at line 503 of file BookStep.cpp.

limitStepOut()

template<class TIn , class TOut >

static void ripple::limitStepOut ( Quality const &  ofrQ, TAmounts< TIn, TOut > &  ofrAmt, TAmounts< TIn, TOut > &  stpAmt, TOut &  ownerGives, std::uint32_t  transferRateIn, std::uint32_t  transferRateOut, TOut const &  limit  )

static

Definition at line 527 of file BookStep.cpp.

sum()

template<class TCollection >

static auto ripple::sum ( TCollection const &  col )

static

Definition at line 710 of file BookStep.cpp.

make_BookStepHelper()

template<class TIn , class TOut >

static std::pair<TER, std::unique_ptr<Step> > ripple::make_BookStepHelper ( StrandContext const &  ctx, Issue const &  in, Issue const &  out  )

static

Definition at line 1155 of file BookStep.cpp.

make_BookStepII()

std::pair<TER, std::unique_ptr<Step> > ripple::make_BookStepII	(	StrandContext const &	ctx,
		Issue const &	in,
		Issue const &	out
	)

Definition at line 1180 of file BookStep.cpp.

make_BookStepIX()

std::pair<TER, std::unique_ptr<Step> > ripple::make_BookStepIX	(	StrandContext const &	ctx,
		Issue const &	in
	)

Definition at line 1186 of file BookStep.cpp.

make_BookStepXI()

std::pair<TER, std::unique_ptr<Step> > ripple::make_BookStepXI	(	StrandContext const &	ctx,
		Issue const &	out
	)

Definition at line 1192 of file BookStep.cpp.

make_DirectStepI()

std::pair<TER, std::unique_ptr<Step> > ripple::make_DirectStepI	(	StrandContext const &	ctx,
		AccountID const &	src,
		AccountID const &	dst,
		Currency const &	c
	)

Definition at line 976 of file DirectStep.cpp.

SetUnion()

template<class T >

void ripple::SetUnion	(	boost::container::flat_set< T > &	dst,
		boost::container::flat_set< T > const &	src
	)

Given two flat sets dst and src, compute dst = dst union src.

Parameters

dst	set to store the resulting union, and also a source of elements for the union
src	second source of elements for the union

Definition at line 35 of file FlatSets.h.

largestAmount()

STAmount ripple::largestAmount

(

STAmount const &

amt

)

Definition at line 28 of file PathfinderUtils.h.

convertAmount()

STAmount ripple::convertAmount	(	STAmount const &	amt,
		bool	all
	)

Definition at line 37 of file PathfinderUtils.h.

convertAllCheck()

bool ripple::convertAllCheck

(

STAmount const &

a

)

Definition at line 46 of file PathfinderUtils.h.

checkNear() [1/2]

bool ripple::checkNear	(	IOUAmount const &	expected,
		IOUAmount const &	actual
	)

Definition at line 36 of file PaySteps.cpp.

checkNear() [2/2]

bool ripple::checkNear	(	XRPAmount const &	expected,
		XRPAmount const &	actual
	)

Definition at line 60 of file PaySteps.cpp.

isXRPAccount()

static bool ripple::isXRPAccount ( STPathElement const &  pe )

static

Definition at line 66 of file PaySteps.cpp.

toStep()

static std::pair<TER, std::unique_ptr<Step> > ripple::toStep ( StrandContext const &  ctx, STPathElement const *  e1, STPathElement const *  e2, Issue const &  curIssue  )

static

Definition at line 74 of file PaySteps.cpp.

toStrand()

std::pair< TER, Strand > ripple::toStrand	(	ReadView const &	sb,
		AccountID const &	src,
		AccountID const &	dst,
		Issue const &	deliver,
		std::optional< Quality > const &	limitQuality,
		std::optional< Issue > const &	sendMaxIssue,
		STPath const &	path,
		bool	ownerPaysTransferFee,
		bool	offerCrossing,
		beast::Journal	j
	)

Create a Strand for the specified path.

Parameters

sb	view for trust lines, balances, and attributes like auth and freeze
src	Account that is sending assets
dst	Account that is receiving assets
deliver	Asset the dst account will receive (if issuer of deliver == dst, then accept any issuer)
limitQuality	Offer crossing BookSteps use this value in an optimization. If, during direct offer crossing, the quality of the tip of the book drops below this value, then evaluating the strand can stop.
sendMaxIssue	Optional asset to send.
path	Liquidity sources to use for this strand of the payment. The path contains an ordered collection of the offer books to use and accounts to ripple through.
ownerPaysTransferFee	false -> charge sender; true -> charge offer owner
offerCrossing	false -> payment; true -> offer crossing
j	Journal for logging messages

Returns

Error code and constructed Strand

Definition at line 135 of file PaySteps.cpp.

toStrands()

std::pair< TER, std::vector< Strand > > ripple::toStrands	(	ReadView const &	sb,
		AccountID const &	src,
		AccountID const &	dst,
		Issue const &	deliver,
		std::optional< Quality > const &	limitQuality,
		std::optional< Issue > const &	sendMax,
		STPathSet const &	paths,
		bool	addDefaultPath,
		bool	ownerPaysTransferFee,
		bool	offerCrossing,
		beast::Journal	j
	)

Create a Strand for each specified path (including the default path, if indicated)

Parameters

sb	View for trust lines, balances, and attributes like auth and freeze
src	Account that is sending assets
dst	Account that is receiving assets
deliver	Asset the dst account will receive (if issuer of deliver == dst, then accept any issuer)
limitQuality	Offer crossing BookSteps use this value in an optimization. If, during direct offer crossing, the quality of the tip of the book drops below this value, then evaluating the strand can stop.
sendMax	Optional asset to send.
paths	Paths to use to fullfill the payment. Each path in the pathset contains an ordered collection of the offer books to use and accounts to ripple through.
addDefaultPath	Determines if the default path should be included
ownerPaysTransferFee	false -> charge sender; true -> charge offer owner
offerCrossing	false -> payment; true -> offer crossing
j	Journal for logging messages

Returns

error code and collection of strands

Definition at line 466 of file PaySteps.cpp.

isDirectXrpToXrp()

template<class InAmt , class OutAmt >

bool ripple::isDirectXrpToXrp

(

Strand const &

strand

)

Definition at line 611 of file PaySteps.cpp.

isDirectXrpToXrp< XRPAmount, XRPAmount >()

template<>

bool ripple::isDirectXrpToXrp< XRPAmount, XRPAmount >

(

Strand const &

strand

)

Definition at line 618 of file PaySteps.cpp.

isDirectXrpToXrp< XRPAmount, IOUAmount >()

template bool ripple::isDirectXrpToXrp< XRPAmount, IOUAmount >

(

Strand const &

strand

)

isDirectXrpToXrp< IOUAmount, XRPAmount >()

template bool ripple::isDirectXrpToXrp< IOUAmount, XRPAmount >

(

Strand const &

strand

)

isDirectXrpToXrp< IOUAmount, IOUAmount >()

template bool ripple::isDirectXrpToXrp< IOUAmount, IOUAmount >

(

Strand const &

strand

)

checkFreeze()

TER ripple::checkFreeze	(	ReadView const &	view,
		AccountID const &	src,
		AccountID const &	dst,
		Currency const &	currency
	)

Definition at line 32 of file StepChecks.h.

checkNoRipple()

TER ripple::checkNoRipple	(	ReadView const &	view,
		AccountID const &	prev,
		AccountID const &	cur,
		AccountID const &	next,
		Currency const &	currency,
		beast::Journal	j
	)

Definition at line 61 of file StepChecks.h.

redeems()

bool ripple::redeems

(

DebtDirection

dir

)

Definition at line 42 of file Steps.h.

issues()

bool ripple::issues

(

DebtDirection

dir

)

Definition at line 48 of file Steps.h.

normalizePath()

std::pair<TER, STPath> ripple::normalizePath	(	AccountID const &	src,
		AccountID const &	dst,
		Issue const &	deliver,
		std::optional< Issue > const &	sendMaxIssue,
		STPath const &	path
	)

flow() [2/3]

template<class TInAmt , class TOutAmt >

StrandResult<TInAmt, TOutAmt> ripple::flow	(	PaymentSandbox const &	baseView,
		Strand const &	strand,
		std::optional< TInAmt > const &	maxIn,
		TOutAmt const &	out,
		beast::Journal	j
	)

Request out amount from a strand.

Parameters

baseView	Trust lines and balances
strand	Steps of Accounts to ripple through and offer books to use
maxIn	Max amount of input allowed
out	Amount of output requested from the strand
j	Journal to write log messages to

Returns

Actual amount in and out from the strand, errors, offers to remove, and payment sandbox

Definition at line 103 of file StrandFlow.h.

flow() [3/3]

template<class TInAmt , class TOutAmt >

FlowResult<TInAmt, TOutAmt> ripple::flow	(	PaymentSandbox const &	baseView,
		std::vector< Strand > const &	strands,
		TOutAmt const &	outReq,
		bool	partialPayment,
		bool	offerCrossing,
		std::optional< Quality > const &	limitQuality,
		std::optional< STAmount > const &	sendMaxST,
		beast::Journal	j,
		path::detail::FlowDebugInfo *	flowDebugInfo = nullptr
	)

Request out amount from a collection of strands.

Attempt to fulfill the payment by using liquidity from the strands in order from least expensive to most expensive

Parameters

baseView	Trust lines and balances
strands	Each strand contains the steps of accounts to ripple through and offer books to use
outReq	Amount of output requested from the strand
partialPayment	If true allow less than the full payment
offerCrossing	If true offer crossing, not handling a standard payment
limitQuality	If present, the minimum quality for any strand taken
sendMaxST	If present, the maximum STAmount to send
j	Journal to write journal messages to
flowDebugInfo	If pointer is non-null, write flow debug info here

Returns

Actual amount in and out from the strands, errors, and payment sandbox

Definition at line 496 of file StrandFlow.h.

operator==() [2/15]

template<class TDerived >

bool ripple::operator==	(	XRPEndpointStep< TDerived > const &	lhs,
		XRPEndpointStep< TDerived > const &	rhs
	)

Definition at line 237 of file XRPEndpointStep.cpp.

make_XRPEndpointStep()

std::pair<TER, std::unique_ptr<Step> > ripple::make_XRPEndpointStep	(	StrandContext const &	ctx,
		AccountID const &	acc
	)

Definition at line 399 of file XRPEndpointStep.cpp.

isDefaultPath()

static bool ripple::isDefaultPath ( STPath const &  path )

static

Definition at line 446 of file Pathfinder.cpp.

removeIssuer()

static STPath ripple::removeIssuer ( STPath const &  path )

static

Definition at line 465 of file Pathfinder.cpp.

addUniquePath()

void ripple::addUniquePath	(	STPathSet &	pathSet,
		STPath const &	path
	)

Definition at line 880 of file Pathfinder.cpp.

getRippleStateItems()

std::vector< RippleState::pointer > ripple::getRippleStateItems	(	AccountID const &	accountID,
		ReadView const &	view
	)

Definition at line 70 of file RippleState.cpp.

getRelationalDBInterfacePostgres()

std::unique_ptr< RelationalDBInterface > ripple::getRelationalDBInterfacePostgres	(	Application &	app,
		Config const &	config,
		JobQueue &	jobQueue
	)

Definition at line 270 of file RelationalDBInterfacePostgres.cpp.

getRelationalDBInterfaceSqlite()

std::unique_ptr< RelationalDBInterface > ripple::getRelationalDBInterfaceSqlite	(	Application &	app,
		Config const &	config,
		JobQueue &	jobQueue
	)

Definition at line 1731 of file RelationalDBInterfaceSqlite.cpp.

makeWalletDB()

std::unique_ptr< DatabaseCon > ripple::makeWalletDB

(

DatabaseCon::Setup const &

setup

)

makeWalletDB Opens wallet DB and returns it.

Parameters

setup

Path to database and other opening parameters.

Returns

Unique pointer to database descriptor.

Definition at line 40 of file RelationalDBInterface_global.cpp.

makeTestWalletDB()

std::unique_ptr< DatabaseCon > ripple::makeTestWalletDB	(	DatabaseCon::Setup const &	setup,
		std::string const &	dbname
	)

makeTestWalletDB Opens test wallet DB with arbitrary name.

Parameters

setup	Path to database and other opening parameters.
dbname	Name of database.

Returns

Unique pointer to database descriptor.

Definition at line 48 of file RelationalDBInterface_global.cpp.

getManifests()

void ripple::getManifests	(	soci::session &	session,
		std::string const &	dbTable,
		ManifestCache &	mCache,
		beast::Journal	j
	)

getManifests Loads manifest from wallet DB and stores it in the cache.

Parameters

session	Session with database.
dbTable	Name of table in the database to extract manifest from.
mCache	Cache to store manifest.
j	Journal.

Definition at line 56 of file RelationalDBInterface_global.cpp.

saveManifest()

static void ripple::saveManifest ( soci::session &  session, std::string const &  dbTable, std::string const &  serialized  )

static

Definition at line 89 of file RelationalDBInterface_global.cpp.

saveManifests()

void ripple::saveManifests	(	soci::session &	session,
		std::string const &	dbTable,
		std::function< bool(PublicKey const &)> const &	isTrusted,
		hash_map< PublicKey, Manifest > const &	map,
		beast::Journal	j
	)

saveManifests Saves all given manifests to database.

Parameters

session	Session with database.
dbTable	Name of database table to save manifest into.
isTrusted	Callback returned true if key is trusted.
map	Map to save which points public keys to manifests.
j	Journal.

Definition at line 104 of file RelationalDBInterface_global.cpp.

addValidatorManifest()

void ripple::addValidatorManifest	(	soci::session &	session,
		std::string const &	serialized
	)

addValidatorManifest Saves manifest of validator to database.

Parameters

session	Session with database.
serialized	Manifest of validator in raw format.

Definition at line 129 of file RelationalDBInterface_global.cpp.

getNodeIdentity() [2/2]

std::pair< PublicKey, SecretKey > ripple::getNodeIdentity

(

soci::session &

session

)

getNodeIdentity Returns public and private keys of this node.

Parameters

session

Session with database.

Returns

Pair of public and private keys.

Definition at line 137 of file RelationalDBInterface_global.cpp.

getPeerReservationTable()

std::unordered_set< PeerReservation, beast::uhash<>, KeyEqual > ripple::getPeerReservationTable	(	soci::session &	session,
		beast::Journal	j
	)

getPeerReservationTable Returns peer reservation table.

Parameters

session	Session with database.
j	Journal.

Returns

Peer reservation hash table.

Definition at line 174 of file RelationalDBInterface_global.cpp.

insertPeerReservation()

void ripple::insertPeerReservation	(	soci::session &	session,
		PublicKey const &	nodeId,
		std::string const &	description
	)

insertPeerReservation Adds entry to peer reservation table.

Parameters

session	Session with database.
nodeId	public key of node.
description	Description of node.

Definition at line 211 of file RelationalDBInterface_global.cpp.

deletePeerReservation()

void ripple::deletePeerReservation	(	soci::session &	session,
		PublicKey const &	nodeId
	)

deletePeerReservation Deletes entry from peer reservation table.

Parameters

session	Session with database.
nodeId	Public key of node to remove.

Definition at line 225 of file RelationalDBInterface_global.cpp.

createFeatureVotes()

bool ripple::createFeatureVotes

(

soci::session &

session

)

createFeatureVotes Creates FeatureVote table if it is not exists.

Parameters

session

Session with walletDB database.

Returns

true if the table already exists

Definition at line 232 of file RelationalDBInterface_global.cpp.

readAmendments()

void ripple::readAmendments	(	soci::session &	session,
		std::function< void(boost::optional< std::string > amendment_hash, boost::optional< std::string > amendment_name, boost::optional< AmendmentVote > vote)> const &	callback
	)

readAmendments Read all amendments from FeatureVotes table.

Parameters

session	Session with walletDB database.
callback	Callback called for each amendment passing its hash, name and the flag if it should be vetoed as callback parameters

Definition at line 256 of file RelationalDBInterface_global.cpp.

voteAmendment()

void ripple::voteAmendment	(	soci::session &	session,
		uint256 const &	amendment,
		std::string const &	name,
		AmendmentVote	vote
	)

voteAmendment Set veto value for particular amendment.

Parameters

session	Session with walletDB database.
amendment	Hash of amendment.
name	Name of amendment.
vote	Whether to vote in favor of this amendment.

Definition at line 289 of file RelationalDBInterface_global.cpp.

initStateDB()

void ripple::initStateDB	(	soci::session &	session,
		BasicConfig const &	config,
		std::string const &	dbName
	)

initStateDB Opens DB session with State DB.

Parameters

session	Structure to open session in.
config	Path to database and other opening parameters.
dbName	Name of database.

Definition at line 309 of file RelationalDBInterface_global.cpp.

getCanDelete()

LedgerIndex ripple::getCanDelete

(

soci::session &

session

)

getCanDelete Returns ledger sequence which can be deleted.

Parameters

session

Session with database.

Returns

Ledger sequence.

Definition at line 365 of file RelationalDBInterface_global.cpp.

setCanDelete()

LedgerIndex ripple::setCanDelete	(	soci::session &	session,
		LedgerIndex	canDelete
	)

setCanDelete Updates ledger sequence which can be deleted.

Parameters

session	Session with database.
canDelete	Ledger sequence to save.

Returns

Previous value of ledger sequence whic can be deleted.

Definition at line 375 of file RelationalDBInterface_global.cpp.

getSavedState()

SavedState ripple::getSavedState

(

soci::session &

session

)

getSavedState Returns saved state.

Parameters

session

Session with database.

Returns

The SavedState structure which contains names of writable DB, archive DB and last rotated ledger sequence.

Definition at line 383 of file RelationalDBInterface_global.cpp.

setSavedState()

void ripple::setSavedState	(	soci::session &	session,
		SavedState const &	state
	)

setSavedState Saves given state.

Parameters

session	Session with database.
state	The SavedState structure which contains names of writable DB, archive DB and last rotated ledger sequence.

Definition at line 395 of file RelationalDBInterface_global.cpp.

setLastRotated()

void ripple::setLastRotated	(	soci::session &	session,
		LedgerIndex	seq
	)

setLastRotated Updates last rotated ledger sequence.

Parameters

session	Session with database.
seq	New value of last rotated ledger sequence.

Definition at line 407 of file RelationalDBInterface_global.cpp.

openDatabaseBodyDb()

std::pair< std::unique_ptr< DatabaseCon >, std::optional< std::uint64_t > > ripple::openDatabaseBodyDb	(	DatabaseCon::Setup const &	setup,
		boost::filesystem::path const &	path
	)

openDatabaseBodyDb Opens file download DB and returns its descriptor.

Start new download process or continue existing one.

Parameters

setup	Path to database and other opening parameters.
path	Path of new file to download.

Returns

Pair of unique pointer to database and current downloaded size if download process continues.

Definition at line 417 of file RelationalDBInterface_global.cpp.

databaseBodyDoPut()

std::uint64_t ripple::databaseBodyDoPut	(	soci::session &	session,
		std::string const &	data,
		std::string const &	path,
		std::uint64_t	fileSize,
		std::uint64_t	part,
		std::uint16_t	maxRowSizePad
	)

databaseBodyDoPut Saves new fragment of downloaded file.

Parameters

session	Session with database.
data	Downloaded piece to file data tp save.
path	Path of downloading file.
fileSize	Size of downloaded piece of file.
part	Sequence number of downloaded file part.
maxRowSizePad	Maximum size of file part to save.

Returns

Number of saved parts. Downloaded piece may be splitted into several parts of size not large that maxRowSizePad.

Definition at line 456 of file RelationalDBInterface_global.cpp.

databaseBodyFinish()

void ripple::databaseBodyFinish	(	soci::session &	session,
		std::ofstream &	fout
	)

databaseBodyFinish Finishes download process and writes file to disk.

Parameters

session	Session with database.
fout	Opened file to write downloaded data from database.

Definition at line 533 of file RelationalDBInterface_global.cpp.

doVacuumDB()

bool ripple::doVacuumDB

(

DatabaseCon::Setup const &

setup

)

doVacuumDB Creates, initialises DB, and performs its cleanup.

Parameters

setup

Path to database and other opening parameters.

Returns

True if vacuum process completed successfully.

Definition at line 546 of file RelationalDBInterface_global.cpp.

initPeerFinderDB()

void ripple::initPeerFinderDB	(	soci::session &	session,
		BasicConfig const &	config,
		beast::Journal	j
	)

initPeerFinderDB Opens session with peer finder database.

Parameters

session	Structure to open session in.
config	Path to database and other opening parameters.
j	Journal.

Definition at line 590 of file RelationalDBInterface_global.cpp.

updatePeerFinderDB()

void ripple::updatePeerFinderDB	(	soci::session &	session,
		int	currentSchemaVersion,
		beast::Journal	j
	)

updatePeerFinderDB Update peer finder DB to new version.

Parameters

session	Session with database.
currentSchemaVersion	New version of database.
j	Journal.

Definition at line 626 of file RelationalDBInterface_global.cpp.

readPeerFinderDB()

void ripple::readPeerFinderDB	(	soci::session &	session,
		std::function< void(std::string const &, int)> const &	func
	)

readPeerFinderDB Read all entries from peer finder DB and call given callback for each entry.

Parameters

session	Session with database.
func	Callback to call for each entry.

Definition at line 782 of file RelationalDBInterface_global.cpp.

savePeerFinderDB()

void ripple::savePeerFinderDB	(	soci::session &	session,
		std::vector< PeerFinder::Store::Entry > const &	v
	)

savePeerFinderDB Save new entry to peer finder DB.

Parameters

session	Session with database.
v	Entry to save which contains information about new peer.

Definition at line 804 of file RelationalDBInterface_global.cpp.

to_string() [4/26]

static std::string ripple::to_string ( TableType  type )

static

to_string Returns name of table by table ID.

Parameters

type

Table ID.

Returns

Name of the table.

Definition at line 45 of file RelationalDBInterface_nodes.cpp.

makeLedgerDBs()

DatabasePairValid ripple::makeLedgerDBs	(	Config const &	config,
		DatabaseCon::Setup const &	setup,
		DatabaseCon::CheckpointerSetup const &	checkpointerSetup
	)

makeLedgerDBs Opens ledger and transactions databases.

Parameters

config	Config object.
setup	Path to database and opening parameters.
checkpointerSetup	Database checkpointer setup.

Returns

Struct DatabasePairValid which contain unique pointers to ledger and transaction databases and flag if opening was successfull.

Definition at line 65 of file RelationalDBInterface_nodes.cpp.

getMinLedgerSeq() [1/2]

std::optional< LedgerIndex > ripple::getMinLedgerSeq	(	soci::session &	session,
		TableType	type
	)

getMinLedgerSeq Returns minimum ledger sequence in given table.

Parameters

session	Session with database.
type	Table ID for which the result is returned.

Returns

Ledger sequence or none if no ledgers exist.

Definition at line 121 of file RelationalDBInterface_nodes.cpp.

getMaxLedgerSeq() [1/2]

std::optional< LedgerIndex > ripple::getMaxLedgerSeq	(	soci::session &	session,
		TableType	type
	)

getMaxLedgerSeq Returns maximum ledger sequence in given table.

Parameters

session	Session with database.
type	Table ID for which the result is returned.

Returns

Ledger sequence or none if no ledgers exist.

Definition at line 131 of file RelationalDBInterface_nodes.cpp.

deleteByLedgerSeq()

void ripple::deleteByLedgerSeq	(	soci::session &	session,
		TableType	type,
		LedgerIndex	ledgerSeq
	)

deleteByLedgerSeq Deletes all entries in given table for the ledger with given sequence.

Parameters

session	Session with database.
type	Table ID from which entries will be deleted.
ledgerSeq	Ledger sequence.

Definition at line 141 of file RelationalDBInterface_nodes.cpp.

deleteBeforeLedgerSeq()

void ripple::deleteBeforeLedgerSeq	(	soci::session &	session,
		TableType	type,
		LedgerIndex	ledgerSeq
	)

deleteBeforeLedgerSeq Deletes all entries in given table for the ledgers with given sequence and all sequences below it.

Parameters

session	Session with database.
type	Table ID from which entries will be deleted.
ledgerSeq	Ledger sequence.

Definition at line 148 of file RelationalDBInterface_nodes.cpp.

getRows()

std::size_t ripple::getRows	(	soci::session &	session,
		TableType	type
	)

getRows Returns number of rows in given table.

Parameters

session	Session with database.
type	Table ID for which the result is returned.

Returns

Number of rows.

Definition at line 158 of file RelationalDBInterface_nodes.cpp.

getRowsMinMax()

RelationalDBInterface::CountMinMax ripple::getRowsMinMax	(	soci::session &	session,
		TableType	type
	)

getRowsMinMax Returns minumum ledger sequence, maximum ledger sequence and total number of rows in given table.

Parameters

session	Session with database.
type	Table ID for which the result is returned.

Returns

Struct CountMinMax which contain minimum sequence, maximum sequence and number of rows.

Definition at line 170 of file RelationalDBInterface_nodes.cpp.

saveValidatedLedger() [2/2]

bool ripple::saveValidatedLedger	(	DatabaseCon &	ldgDB,
		DatabaseCon &	txnDB,
		Application &	app,
		std::shared_ptr< Ledger const > const &	ledger,
		bool	current
	)

saveValidatedLedger Saves ledger into database.

Parameters

lgrDB	Link to ledgers database.
txnDB	Link to transactions database.
app	Application object.
ledger	The ledger.
current	True if ledger is current.

Returns

True is saving was successfull.

Definition at line 185 of file RelationalDBInterface_nodes.cpp.

getLedgerInfo()

static std::optional<LedgerInfo> ripple::getLedgerInfo ( soci::session &  session, std::string const &  sqlSuffix, beast::Journal  j  )

static

getLedgerInfo Returns info of ledger with special condition given as SQL query.

Parameters

session	Session with database.
sqlSuffix	Special condition for found the ledger.
j	Journal.

Returns

Ledger info or none if ledger not found.

Definition at line 385 of file RelationalDBInterface_nodes.cpp.

getLedgerInfoByIndex() [1/2]

std::optional< LedgerInfo > ripple::getLedgerInfoByIndex	(	soci::session &	session,
		LedgerIndex	ledgerSeq,
		beast::Journal	j
	)

getLedgerInfoByIndex Returns ledger by its sequence.

Parameters

session	Session with database.
ledgerSeq	Ledger sequence.
j	Journal.

Returns

Ledger or none if ledger not found.

Definition at line 455 of file RelationalDBInterface_nodes.cpp.

getNewestLedgerInfo() [1/2]

std::optional< LedgerInfo > ripple::getNewestLedgerInfo	(	soci::session &	session,
		beast::Journal	j
	)

getNewestLedgerInfo Returns info of newest saved ledger.

Parameters

session	Session with database.
j	Journal.

Returns

Ledger info or none if ledger not found.

Definition at line 466 of file RelationalDBInterface_nodes.cpp.

getLimitedOldestLedgerInfo()

std::optional< LedgerInfo > ripple::getLimitedOldestLedgerInfo	(	soci::session &	session,
		LedgerIndex	ledgerFirstIndex,
		beast::Journal	j
	)

getLimitedOldestLedgerInfo Returns info of oldest ledger from ledgers with sequences greather or equal to given.

Parameters

session	Session with database.
ledgerFirstIndex	Minimum ledger sequence.
j	Journal.

Returns

Ledger info or none if ledger not found.

Definition at line 474 of file RelationalDBInterface_nodes.cpp.

getLimitedNewestLedgerInfo()

std::optional< LedgerInfo > ripple::getLimitedNewestLedgerInfo	(	soci::session &	session,
		LedgerIndex	ledgerFirstIndex,
		beast::Journal	j
	)

getLimitedNewestLedgerInfo Returns info of newest ledger from ledgers with sequences greather or equal to given.

Parameters

session	Session with database.
ledgerFirstIndex	Minimum ledger sequence.
j	Journal.

Returns

Ledger info or none if ledger not found.

Definition at line 486 of file RelationalDBInterface_nodes.cpp.

getLedgerInfoByHash() [1/2]

std::optional< LedgerInfo > ripple::getLedgerInfoByHash	(	soci::session &	session,
		uint256 const &	ledgerHash,
		beast::Journal	j
	)

getLedgerInfoByHash Returns info of ledger with given hash.

Parameters

session	Session with database.
ledgerHash	Hash of the ledger.
j	Journal.

Returns

Ledger or none if ledger not found.

Definition at line 498 of file RelationalDBInterface_nodes.cpp.

getHashByIndex() [1/2]

uint256 ripple::getHashByIndex	(	soci::session &	session,
		LedgerIndex	ledgerIndex
	)

getHashByIndex Returns hash of ledger with given sequence.

Parameters

session	Session with database.
ledgerIndex	Ledger sequence.

Returns

Hash of the ledger.

Definition at line 509 of file RelationalDBInterface_nodes.cpp.

getHashesByIndex() [1/4]

std::optional< LedgerHashPair > ripple::getHashesByIndex	(	soci::session &	session,
		LedgerIndex	ledgerIndex,
		beast::Journal	j
	)

getHashesByIndex Returns hash of the ledger and hash of parent ledger for the ledger of given sequence.

Parameters

session	Session with database.
ledgerIndex	Ledger sequence.
j	Journal.

Returns

Struct LedgerHashPair which contain hashes of the ledger and its parent ledger.

Definition at line 539 of file RelationalDBInterface_nodes.cpp.

getHashesByIndex() [2/4]

std::map< LedgerIndex, LedgerHashPair > ripple::getHashesByIndex	(	soci::session &	session,
		LedgerIndex	minSeq,
		LedgerIndex	maxSeq,
		beast::Journal	j
	)

getHashesByIndex Returns hash of the ledger and hash of parent ledger for all ledgers with seqyences from given minimum limit to fiven maximum limit.

Parameters

session	Session with database.
minSeq	Minimum ledger sequence.
maxSeq	Maximum ledger sequence.
j	Journal.

Returns

Map which points sequence number of found ledger to the struct LedgerHashPair which contauns ledger hash and its parent hash.

Definition at line 570 of file RelationalDBInterface_nodes.cpp.

getTxHistory() [1/2]

std::pair< std::vector< std::shared_ptr< Transaction > >, int > ripple::getTxHistory	(	soci::session &	session,
		Application &	app,
		LedgerIndex	startIndex,
		int	quantity,
		bool	count
	)

getTxHistory Returns given number of most recent transactions starting from given number of entry.

Parameters

session	Session with database.
app	Application object.
startIndex	Offset of first returned entry.
quantity	Number of returned entries.
count	True if counting of all transaction in that shard required.

Returns

Vector of shared pointers to transactions sorted in descending order by ledger sequence. Also number of transactions if count == true.

Definition at line 615 of file RelationalDBInterface_nodes.cpp.

transactionsSQL()

static std::string ripple::transactionsSQL ( Application &  app, std::string  selection, RelationalDBInterface::AccountTxOptions const &  options, std::optional< int > const &  limit_used, bool  descending, bool  binary, bool  count, beast::Journal  j  )

static

transactionsSQL Returns SQL query to select oldest or newest transactions in decoded or binary form for given account which match given criteria starting from given offset.

Parameters

app	Application object.
selection	List of table fields to select from database.
options	Struct AccountTxOptions which contain criteria to match: the account, minimum and maximum ledger numbers to search, offset of first entry to return, number of transactions to return, flag if this number unlimited.
limit_used	Number of transactions already returned in calls to another shard databases, if shard databases are used. None if node database is used.
descending	True for descending order, false for ascending.
binary	True for binary form, false for decoded.
count	True for count number of transaction, false for select it.
j	Journal.

Returns

SQL query string.

Definition at line 692 of file RelationalDBInterface_nodes.cpp.

getAccountTxs()

static std::pair<RelationalDBInterface::AccountTxs, int> ripple::getAccountTxs ( soci::session &  session, Application &  app, LedgerMaster &  ledgerMaster, RelationalDBInterface::AccountTxOptions const &  options, std::optional< int > const &  limit_used, bool  descending, beast::Journal  j  )

static

getAccountTxs Returns oldest or newest transactions for given account which match given criteria starting from given offset.

Parameters

session	Session with database.
app	Application object.
ledgerMaster	LedgerMaster object.
options	Struct AccountTxOptions which contain criteria to match: the account, minimum and maximum ledger numbers to search, offset of first entry to return, number of transactions to return, flag if this number unlimited.
limit_used	Number of transactions already returned in calls to another shard databases, if shard databases are used. None if node database is used.
descending	True for descending order, false for ascending.
j	Journal.

Returns

Vector of pairs of found transactions and its metadata sorted in given order by account sequence. Also the number of transactions processed or skipped. If this number is >= 0, then it means number of transactions processed, if it is < 0, then -number means number of transactions skipped. We need to skip some quantity of transactions if option offset is > 0 in the options structure.

Definition at line 803 of file RelationalDBInterface_nodes.cpp.

getOldestAccountTxs()

std::pair< RelationalDBInterface::AccountTxs, int > ripple::getOldestAccountTxs	(	soci::session &	session,
		Application &	app,
		LedgerMaster &	ledgerMaster,
		RelationalDBInterface::AccountTxOptions const &	options,
		std::optional< int > const &	limit_used,
		beast::Journal	j
	)

getOldestAccountTxs Returns oldest transactions for given account which match given criteria starting from given offset.

Parameters

session	Session with database.
app	Application object.
ledgerMaster	LedgerMaster object.
options	Struct AccountTxOptions which contain criteria to match: the account, minimum and maximum ledger numbers to search, offset of first entry to return, number of transactions to return, flag if this number unlimited.
limit_used	Number or transactions already returned in calls to another shard databases, if shard databases are used. None if node database is used.
j	Journal.

Returns

Vector of pairs of found transactions and their metadata sorted in ascending order by account sequence. Also number of transactions processed or skipped. If this number is >= 0, then it means number of transactions processed, if it is < 0, then -number means number of transactions skipped. We need to skip some quantity of transactions if option offset is > 0 in the options structure.

Definition at line 897 of file RelationalDBInterface_nodes.cpp.

getNewestAccountTxs()

std::pair< RelationalDBInterface::AccountTxs, int > ripple::getNewestAccountTxs	(	soci::session &	session,
		Application &	app,
		LedgerMaster &	ledgerMaster,
		RelationalDBInterface::AccountTxOptions const &	options,
		std::optional< int > const &	limit_used,
		beast::Journal	j
	)

getNewestAccountTxs Returns newest transactions for given account which match given criteria starting from given offset.

Parameters

session	Session with database.
app	Application object.
ledgerMaster	LedgerMaster object.
options	Struct AccountTxOptions which contain criteria to match: the account, minimum and maximum ledger numbers to search, offset of first entry to return, number of transactions to return, flag if this number unlimited.
limit_used	Number or transactions already returned in calls to another shard databases, if shard databases are used. None if node database is used.
j	Journal.

Returns

Vector of pairs of found transactions and their metadata sorted in descending order by account sequence. Also number of transactions processed or skipped. If this number is >= 0, then it means number of transactions processed, if it is < 0, then -number means number of transactions skipped. We need to skip some quantity of transactions if option offset is > 0 in the options structure.

Definition at line 910 of file RelationalDBInterface_nodes.cpp.

getAccountTxsB()

static std::pair<std::vector<RelationalDBInterface::txnMetaLedgerType>, int> ripple::getAccountTxsB ( soci::session &  session, Application &  app, RelationalDBInterface::AccountTxOptions const &  options, std::optional< int > const &  limit_used, bool  descending, beast::Journal  j  )

static

getAccountTxsB Returns oldest or newset transactions in binary form for given account which match given criteria starting from given offset.

Parameters

session	Session with database.
app	Application object.
options	Struct AccountTxOptions which contain criteria to match: the account, minimum and maximum ledger numbers to search, offset of first entry to return, number of transactions to return, flag if this number unlimited.
limit_used	Number or transactions already returned in calls to another shard databases, if shard databases are used. None if node database is used.
descending	True for descending order, false for ascending.
j	Journal.

Returns

Vector of tuples of found transactions, its metadata and account sequences sorted in given order by account sequence. Also number of transactions processed or skipped. If this number is >= 0, then it means number of transactions processed, if it is < 0, then -number means number of transactions skipped. We need to skip some quantity of transactions if option offset is > 0 in the options structure.

Definition at line 946 of file RelationalDBInterface_nodes.cpp.

getOldestAccountTxsB()

std::pair< std::vector< RelationalDBInterface::txnMetaLedgerType >, int > ripple::getOldestAccountTxsB	(	soci::session &	session,
		Application &	app,
		RelationalDBInterface::AccountTxOptions const &	options,
		std::optional< int > const &	limit_used,
		beast::Journal	j
	)

getOldestAccountTxsB Returns oldest transactions in binary form for given account which match given criteria starting from given offset.

Parameters

session	Session with database.
app	Application object.
options	Struct AccountTxOptions which contain criteria to match: the account, minimum and maximum ledger numbers to search, offset of first entry to return, number of transactions to return, flag if this number unlimited.
limit_used	Number or transactions already returned in calls to another shard databases, if shard databases are used. None if node database is used.
j	Journal.

Returns

Vector of tuples of found transactions, their metadata and account sequences sorted in ascending order by account sequence. Also number of transactions processed or skipped. If this number is >= 0, then it means number of transactions processed, if it is < 0, then -number means number of transactions skipped. We need to skip some quantity of transactions if option offset is > 0 in the options structure.

Definition at line 1018 of file RelationalDBInterface_nodes.cpp.

getNewestAccountTxsB()

std::pair< std::vector< RelationalDBInterface::txnMetaLedgerType >, int > ripple::getNewestAccountTxsB	(	soci::session &	session,
		Application &	app,
		RelationalDBInterface::AccountTxOptions const &	options,
		std::optional< int > const &	limit_used,
		beast::Journal	j
	)

getNewestAccountTxsB Returns newest transactions in binary form for given account which match given criteria starting from given offset.

Parameters

session	Session with database.
app	Application object.
options	Struct AccountTxOptions which contain criteria to match: the account, minimum and maximum ledger numbers to search, offset of first entry to return, number of transactions to return, flag if this number unlimited.
limit_used	Number or transactions already returned in calls to another shard databases, if shard databases are used. None if node database is used.
j	Journal.

Returns

Vector of tuples of found transactions, their metadata and account sequences sorted in descending order by account sequence. Also number of transactions processed or skipped. If this number is >= 0, then it means number of transactions processed, if it is < 0, then -number means number of transactions skipped. We need to skip some quantity of transactions if option offset is > 0 in the options structure.

Definition at line 1029 of file RelationalDBInterface_nodes.cpp.

accountTxPage()

static std::pair<std::optional<RelationalDBInterface::AccountTxMarker>, int> ripple::accountTxPage ( soci::session &  session, AccountIDCache const &  idCache, std::function< void(std::uint32_t)> const &  onUnsavedLedger, std::function< void(std::uint32_t, std::string const &, Blob &&, Blob &&)> const &  onTransaction, RelationalDBInterface::AccountTxPageOptions const &  options, int  limit_used, std::uint32_t  page_length, bool  forward  )

static

accountTxPage Searches oldest or newest transactions for given account which match given criteria starting from given marker and calls callback for each found transaction.

Parameters

session	Session with database.
idCache	Account ID cache.
onUnsavedLedger	Callback function to call on each found unsaved ledger within given range.
onTransaction	Callback function to call on eahc found transaction.
options	Struct AccountTxPageOptions which contain criteria to match: the account, minimum and maximum ledger numbers to search, marker of first returned entry, number of transactions to return, flag if this number unlimited.
limit_used	Number or transactions already returned in calls to another shard databases.
page_length	Total number of transactions to return.
forward	True for ascending order, false for descending.

Returns

Vector of tuples of found transactions, its metadata and account sequences sorted in given order by account sequence and marker for next search if search not finished. Also number of transactions processed during this call.

Definition at line 1062 of file RelationalDBInterface_nodes.cpp.

oldestAccountTxPage()

std::pair< std::optional< RelationalDBInterface::AccountTxMarker >, int > ripple::oldestAccountTxPage	(	soci::session &	session,
		AccountIDCache const &	idCache,
		std::function< void(std::uint32_t)> const &	onUnsavedLedger,
		std::function< void(std::uint32_t, std::string const &, Blob &&, Blob &&)> const &	onTransaction,
		RelationalDBInterface::AccountTxPageOptions const &	options,
		int	limit_used,
		std::uint32_t	page_length
	)

oldestAccountTxPage Searches oldest transactions for given account which match given criteria starting from given marker and calls callback for each found transaction.

Parameters

session	Session with database.
idCache	Account ID cache.
onUnsavedLedger	Callback function to call on each found unsaved ledger within given range.
onTransaction	Callback function to call on each found transaction.
options	Struct AccountTxPageOptions which contain criteria to match: the account, minimum and maximum ledger numbers to search, marker of first returned entry, number of transactions to return, flag if this number unlimited.
limit_used	Number or transactions already returned in calls to another shard databases.
page_length	Total number of transactions to return.

Returns

Vector of tuples of found transactions, their metadata and account sequences sorted in ascending order by account sequence and marker for next search if search not finished. Also number of transactions processed during this call.

Definition at line 1224 of file RelationalDBInterface_nodes.cpp.

newestAccountTxPage()

std::pair< std::optional< RelationalDBInterface::AccountTxMarker >, int > ripple::newestAccountTxPage	(	soci::session &	session,
		AccountIDCache const &	idCache,
		std::function< void(std::uint32_t)> const &	onUnsavedLedger,
		std::function< void(std::uint32_t, std::string const &, Blob &&, Blob &&)> const &	onTransaction,
		RelationalDBInterface::AccountTxPageOptions const &	options,
		int	limit_used,
		std::uint32_t	page_length
	)

newestAccountTxPage Searches newest transactions for given account which match given criteria starting from given marker and calls callback for each found transaction.

Parameters

session	Session with database.
idCache	Account ID cache.
onUnsavedLedger	Callback function to call on each found unsaved ledger within given range.
onTransaction	Callback function to call on each found transaction.
options	Struct AccountTxPageOptions which contain criteria to match: the account, minimum and maximum ledger numbers to search, marker of first returned entry, number of transactions to return, flag if this number unlimited.
limit_used	Number or transactions already returned in calls to another shard databases.
page_length	Total number of transactions to return.

Returns

Vector of tuples of found transactions, their metadata and account sequences sorted in descending order by account sequence and marker for next search if search not finished. Also number of transactions processed during this call.

Definition at line 1247 of file RelationalDBInterface_nodes.cpp.

getTransaction()

std::variant< RelationalDBInterface::AccountTx, TxSearched > ripple::getTransaction	(	soci::session &	session,
		Application &	app,
		uint256 const &	id,
		std::optional< ClosedInterval< uint32_t >> const &	range,
		error_code_i &	ec
	)

getTransaction Returns transaction with given hash.

If not found and range given then check if all ledgers from the range are present in the database.

Parameters

session	Session with database.
app	Application object.
id	Hash of the transaction.
range	Range of ledgers to check, if present.
ec	Default value of error code.

Returns

Transaction and its metadata if found, TxSearched::all if range given and all ledgers from range are present in the database, TxSearched::some if range given and not all ledgers are present, TxSearched::unknown if range not given or deserializing error occured. In the last case error code modified in ec link parameter, in other cases default error code remained.

Definition at line 1270 of file RelationalDBInterface_nodes.cpp.

dbHasSpace()

bool ripple::dbHasSpace	(	soci::session &	session,
		Config const &	config,
		beast::Journal	j
	)

dbHasSpace Checks if given database has available space.

Parameters

session	Session with database.
config	Config object.
j	Journal.

Returns

True if space is available.

Definition at line 1351 of file RelationalDBInterface_nodes.cpp.

getMinLedgerSeq() [2/2]

std::optional< LedgerIndex > ripple::getMinLedgerSeq	(	std::shared_ptr< PgPool > const &	pgPool,
		beast::Journal	j
	)

getMinLedgerSeq Returns minimum ledger sequence from Postgres database

Parameters

pgPool	Link to postgres database
app	Application
j	Journal

Returns

Minimum ledger sequence if any, none if no ledgers

Definition at line 35 of file RelationalDBInterface_postgres.cpp.

getMaxLedgerSeq() [2/2]

std::optional< LedgerIndex > ripple::getMaxLedgerSeq

(

std::shared_ptr< PgPool > const &

pgPool

)

getMaxLedgerSeq Returns maximum ledger sequence from Postgres database

Parameters

pgPool	Link to postgres database
app	Application

Returns

Maximum ledger sequence if any, none if no ledgers

Definition at line 50 of file RelationalDBInterface_postgres.cpp.

getCompleteLedgers()

std::string ripple::getCompleteLedgers

(

std::shared_ptr< PgPool > const &

pgPool

)

getCompleteLedgers Returns string which contains list of completed ledgers

Parameters

pgPool	Link to postgres database
app	Application

Returns

String with completed ledgers

Definition at line 61 of file RelationalDBInterface_postgres.cpp.

getValidatedLedgerAge()

std::chrono::seconds ripple::getValidatedLedgerAge	(	std::shared_ptr< PgPool > const &	pgPool,
		beast::Journal	j
	)

getValidatedLedgerAge Returns age of last validated ledger

Parameters

pgPool	Link to postgres database
app	Application
j	Journal

Returns

Age of last validated ledger

Definition at line 72 of file RelationalDBInterface_postgres.cpp.

loadLedgerInfos()

static std::vector<LedgerInfo> ripple::loadLedgerInfos ( std::shared_ptr< PgPool > const &  pgPool, std::variant< std::monostate, uint256, uint32_t, std::pair< uint32_t, uint32_t >> const &  whichLedger, Application &  app  )

static

loadLedgerInfos Load the ledger info for the specified ledger/s from the database

Parameters

pgPool	Link to postgres database
whichLedger	Specifies the ledger to load via ledger sequence, ledger hash, a range of ledgers, or std::monostate (which loads the most recent)
app	Application

Returns

Vector of LedgerInfos

Definition at line 96 of file RelationalDBInterface_postgres.cpp.

loadLedgerHelper() [2/2]

static std::optional<LedgerInfo> ripple::loadLedgerHelper ( std::shared_ptr< PgPool > const &  pgPool, std::variant< std::monostate, uint256, uint32_t > const &  whichLedger, Application &  app  )

static

loadLedgerHelper Load a ledger info from Postgres

Parameters

pgPool	Link to postgres database
whichLedger	Specifies sequence or hash of ledger. Passing std::monostate loads the most recent ledger
app	The Application

Returns

Ledger info

Definition at line 240 of file RelationalDBInterface_postgres.cpp.

getNewestLedgerInfo() [2/2]

std::optional< LedgerInfo > ripple::getNewestLedgerInfo	(	std::shared_ptr< PgPool > const &	pgPool,
		Application &	app
	)

getNewestLedgerInfo Load latest ledger info from Postgres

Parameters

pgPool	Link to postgres database
app	reference to Application

Returns

Ledger info

Definition at line 258 of file RelationalDBInterface_postgres.cpp.

getLedgerInfoByIndex() [2/2]

std::optional< LedgerInfo > ripple::getLedgerInfoByIndex	(	std::shared_ptr< PgPool > const &	pgPool,
		std::uint32_t	ledgerIndex,
		Application &	app
	)

getLedgerInfoByIndex Load ledger info by index (AKA sequence) from Postgres

Parameters

pgPool	Link to postgres database
ledgerIndex	the ledger index (or sequence) to load
app	reference to Application

Returns

Ledger info

Definition at line 264 of file RelationalDBInterface_postgres.cpp.

getLedgerInfoByHash() [2/2]

std::optional< LedgerInfo > ripple::getLedgerInfoByHash	(	std::shared_ptr< PgPool > const &	pgPool,
		uint256 const &	ledgerHash,
		Application &	app
	)

getLedgerInfoByHash Load ledger info by hash from Postgres

Parameters

pgPool	Link to postgres database
hash	Hash of the ledger to load
app	reference to Application

Returns

Ledger info

Definition at line 273 of file RelationalDBInterface_postgres.cpp.

getHashByIndex() [2/2]

uint256 ripple::getHashByIndex	(	std::shared_ptr< PgPool > const &	pgPool,
		std::uint32_t	ledgerIndex,
		Application &	app
	)

getHashByIndex Given a ledger sequence, return the ledger hash

Parameters

pgPool	Link to postgres database
ledgerIndex	Ledger sequence
app	Application

Returns

Hash of ledger

Definition at line 282 of file RelationalDBInterface_postgres.cpp.

getHashesByIndex() [3/4]

bool ripple::getHashesByIndex	(	std::shared_ptr< PgPool > const &	pgPool,
		std::uint32_t	ledgerIndex,
		uint256 &	ledgerHash,
		uint256 &	parentHash,
		Application &	app
	)

getHashesByIndex Given a ledger sequence, return the ledger hash and the parent hash

Parameters

	pgPool	Link to postgres database
	ledgerIndex	Ledger sequence
[out]	ledgerHash	Hash of ledger
[out]	parentHash	Hash of parent ledger
	app	Application

Returns

True if the data was found

Definition at line 295 of file RelationalDBInterface_postgres.cpp.

getHashesByIndex() [4/4]

std::map< std::uint32_t, LedgerHashPair > ripple::getHashesByIndex	(	std::shared_ptr< PgPool > const &	pgPool,
		std::uint32_t	minSeq,
		std::uint32_t	maxSeq,
		Application &	app
	)

getHashesByIndex Given a contiguous range of sequences, return a map of sequence -> (hash, parent hash)

Parameters

pgPool	Link to postgres database
minSeq	Lower bound of range
maxSeq	Upper bound of range
app	Application

Returns

Mapping of all found ledger sequences to their hash and parent hash

Definition at line 314 of file RelationalDBInterface_postgres.cpp.

getTxHashes()

std::vector< uint256 > ripple::getTxHashes	(	std::shared_ptr< PgPool > const &	pgPool,
		LedgerIndex	seq,
		Application &	app
	)

getTxHashes Returns vector of tx hashes by given ledger sequence

Parameters

pgPool	Link to postgres database
seq	Ledger sequence
app	Application

Returns

Vector of tx hashes

Definition at line 330 of file RelationalDBInterface_postgres.cpp.

getAccountTx()

std::pair< AccountTxResult, RPC::Status > ripple::getAccountTx	(	std::shared_ptr< PgPool > const &	pgPool,
		AccountTxArgs const &	args,
		Application &	app,
		beast::Journal	j
	)

getAccountTx Get last account transactions specifies by passed argumenrs structure.

Parameters

pgPool	Link to postgres database
args	Arguments which specify account and whose tx to return.
app	Application
j	Journal

Returns

Vector of account transactions and RPC status of responce.

Definition at line 542 of file RelationalDBInterface_postgres.cpp.

locateTransaction()

Transaction::Locator ripple::locateTransaction	(	std::shared_ptr< PgPool > const &	pgPool,
		uint256 const &	id,
		Application &	app
	)

locateTransaction Returns information used to locate a transaction.

Function is specific to postgres backend.

Parameters

pgPool	Link to postgres database
id	Hash of the transaction.
app	Application

Returns

Information used to locate a transaction. Contains a nodestore hash and ledger sequence pair if the transaction was found. Otherwise, contains the range of ledgers present in the database at the time of search.

Definition at line 657 of file RelationalDBInterface_postgres.cpp.

writeLedgerAndTransactions()

bool ripple::writeLedgerAndTransactions	(	std::shared_ptr< PgPool > const &	pgPool,
		LedgerInfo const &	info,
		std::vector< AccountTransactionsData > const &	accountTxData,
		beast::Journal &	j
	)

writeLedgerAndTransactions Write new ledger and transaction data to Postgres.

Parameters

pgPool	Pool of Postgres connections
info	Ledger info to write.
accountTxData	Transaction data to write
j	Journal (for logging)

Returns

True if success, false if failure.

Definition at line 762 of file RelationalDBInterface_postgres.cpp.

getTxHistory() [2/2]

std::vector< std::shared_ptr< Transaction > > ripple::getTxHistory	(	std::shared_ptr< PgPool > const &	pgPool,
		LedgerIndex	startIndex,
		Application &	app,
		beast::Journal	j
	)

getTxHistory Returns most recent 20 transactions starting from given number or entry.

Parameters

pgPool	Link to postgres database
startIndex	First number of returned entry.
app	Application
j	Journal

Returns

Vector of sharded pointers to transactions sorted in descending order by ledger sequence.

Definition at line 848 of file RelationalDBInterface_postgres.cpp.

makeMetaDBs()

DatabasePair ripple::makeMetaDBs	(	Config const &	config,
		DatabaseCon::Setup const &	setup,
		DatabaseCon::CheckpointerSetup const &	checkpointerSetup
	)

makeMetaDBs Opens ledger and transaction 'meta' databases which map ledger hashes and transaction IDs to the index of the shard that holds the ledger or transaction.

Parameters

config	Config object.
setup	Path to database and opening parameters.
checkpointerSetup	Database checkpointer setup.

Returns

Struct DatabasePair which contains unique pointers to the ledger and transaction databases.

Definition at line 36 of file RelationalDBInterface_shards.cpp.

saveLedgerMeta()

bool ripple::saveLedgerMeta	(	std::shared_ptr< Ledger const > const &	ledger,
		Application &	app,
		soci::session &	lgrMetaSession,
		soci::session &	txnMetaSession,
		std::uint32_t	shardIndex
	)

saveLedgerMeta Stores (transaction ID -> shard index) and (ledger hash -> shard index) mappings in the meta databases.

Parameters

ledger	The ledger.
app	Application object.
lgrMetaSession	Session to ledger meta database.
txnMetaSession	Session to transaction meta database.
shardIndex	The index of the shard that contains this ledger.

Returns

True on success.

Definition at line 66 of file RelationalDBInterface_shards.cpp.

getShardIndexforLedger()

std::optional< std::uint32_t > ripple::getShardIndexforLedger	(	soci::session &	session,
		LedgerHash const &	hash
	)

getShardIndexforLedger Queries the ledger meta database to retrieve the index of the shard that contains this ledger.

Parameters

session	Session to the database.
hash	Hash of the ledger.

Returns

The index of the shard on success, otherwise an unseated value.

Definition at line 130 of file RelationalDBInterface_shards.cpp.

getShardIndexforTransaction()

std::optional< std::uint32_t > ripple::getShardIndexforTransaction	(	soci::session &	session,
		TxID const &	id
	)

getShardIndexforTransaction Queries the transaction meta database to retrieve the index of the shard that contains this transaction.

Parameters

session	Session to the database.
id	ID of the transaction.

Returns

The index of the shard on success, otherwise an unseated value.

Definition at line 144 of file RelationalDBInterface_shards.cpp.

makeShardCompleteLedgerDBs()

DatabasePair ripple::makeShardCompleteLedgerDBs	(	Config const &	config,
		DatabaseCon::Setup const &	setup
	)

makeShardCompleteLedgerDBs Opens shard databases for already verified shard and returns its descriptors.

Parameters

config	Config object.
setup	Path to database and other opening parameters.

Returns

Pair of unique pointers to opened ledger and transaction databases.

Definition at line 158 of file RelationalDBInterface_shards.cpp.

makeShardIncompleteLedgerDBs()

DatabasePair ripple::makeShardIncompleteLedgerDBs	(	Config const &	config,
		DatabaseCon::Setup const &	setup,
		DatabaseCon::CheckpointerSetup const &	checkpointerSetup
	)

makeShardIncompleteLedgerDBs Opens shard databases for not fully downloaded or verified shard and returns its descriptors.

Parameters

config	Config object.
setup	Path to database and other opening parameters.
checkpointerSetup	Checkpointer parameters.

Returns

Pair of unique pointers to opened ledger and transaction databases.

Definition at line 178 of file RelationalDBInterface_shards.cpp.

updateLedgerDBs()

bool ripple::updateLedgerDBs	(	soci::session &	txdb,
		soci::session &	lgrdb,
		std::shared_ptr< Ledger const > const &	ledger,
		std::uint32_t	index,
		std::atomic< bool > &	stop,
		beast::Journal	j
	)

updateLedgerDBs Save given ledger to shard databases.

Parameters

txdb	Session with transaction DB.
lgrdb	Sessiob with ledger DB.
ledger	Ledger to save.
index	Index of the shard which the ledger belonfs to.
stop	Link to atomic flag which can stop the process if raised.
j	Journal

Returns

True if ledger was successfully saved.

Definition at line 201 of file RelationalDBInterface_shards.cpp.

makeAcquireDB()

std::unique_ptr< DatabaseCon > ripple::makeAcquireDB	(	DatabaseCon::Setup const &	setup,
		DatabaseCon::CheckpointerSetup const &	checkpointerSetup
	)

makeAcquireDB Opens shard acquire DB and returns its descriptor.

Parameters

setup	Path to DB and other opening parameters.
checkpointerSetup	Checkpointer parameters.

Returns

Uniqye pointer to opened database.

Definition at line 338 of file RelationalDBInterface_shards.cpp.

insertAcquireDBIndex()

void ripple::insertAcquireDBIndex	(	soci::session &	session,
		std::uint32_t	index
	)

insertAcquireDBIndex Adds new shard index to shard acquire DB.

Parameters

session	Session with database.
index	Index to add.

Definition at line 351 of file RelationalDBInterface_shards.cpp.

selectAcquireDBLedgerSeqs()

std::pair< bool, std::optional< std::string > > ripple::selectAcquireDBLedgerSeqs	(	soci::session &	session,
		std::uint32_t	index
	)

selectAcquireDBLedgerSeqs Returns set of acquired ledgers for given shard.

Parameters

session	Session with database.
index	Shard index.

Returns

Pair which contains true if such as index found in database, and string which contains set of ledger sequences. If set of sequences was not saved than none is returned.

Definition at line 359 of file RelationalDBInterface_shards.cpp.

selectAcquireDBLedgerSeqsHash()

std::pair< bool, AcquireShardSeqsHash > ripple::selectAcquireDBLedgerSeqsHash	(	soci::session &	session,
		std::uint32_t	index
	)

selectAcquireDBLedgerSeqsHash Returns set of acquired ledgers and hash for given shard.

Parameters

session	Session with database.
index	Shard index.

Returns

Pair which contains true of such an index found in database, and the AcquireShardSeqsHash structure which contains string with ledger sequences set and string with last ledger hash. If set of sequences or hash were not saved than none is returned.

Definition at line 386 of file RelationalDBInterface_shards.cpp.

updateAcquireDB()

void ripple::updateAcquireDB	(	soci::session &	session,
		std::shared_ptr< Ledger const > const &	ledger,
		std::uint32_t	index,
		std::uint32_t	lastSeq,
		std::optional< std::string > const &	seqs
	)

updateAcquireDB Updates information in acquire DB.

Parameters

session	Session with database.
ledger	Ledger to save into database.
index	Shard index.
lastSeq	Last acqyured ledger sequence.
seqs	Current set or acquired ledger sequences if it's not empty.

Definition at line 417 of file RelationalDBInterface_shards.cpp.

makeArchiveDB()

std::unique_ptr< DatabaseCon > ripple::makeArchiveDB	(	boost::filesystem::path const &	dir,
		std::string const &	dbName
	)

makeArchiveDB Opens shard archive DB and returns its descriptor.

Parameters

dir	Path to database to open.
dbName	Name of database.

Returns

Unique pointer to opened database.

Definition at line 451 of file RelationalDBInterface_shards.cpp.

readArchiveDB()

void ripple::readArchiveDB	(	DatabaseCon &	db,
		std::function< void(std::string const &, int)> const &	func
	)

readArchiveDB Read entries from shard archive database and calls fiven callback for each entry.

Parameters

db	Session with database.
func	Callback to call for each entry.

Definition at line 458 of file RelationalDBInterface_shards.cpp.

insertArchiveDB()

void ripple::insertArchiveDB	(	DatabaseCon &	db,
		std::uint32_t	shardIndex,
		std::string const &	url
	)

insertArchiveDB Adds entry to shard archive database.

Parameters

db	Session with database.
shardIndex	Shard index to add.
url	Shard download url to add.

Definition at line 472 of file RelationalDBInterface_shards.cpp.

deleteFromArchiveDB()

void ripple::deleteFromArchiveDB	(	DatabaseCon &	db,
		std::uint32_t	shardIndex
	)

deleteFromArchiveDB Deletes entry from shard archive DB.

Parameters

db	Session with database.
shardIndex	Shard index to remove from DB.

Definition at line 482 of file RelationalDBInterface_shards.cpp.

dropArchiveDB()

void ripple::dropArchiveDB

(

DatabaseCon &

db

)

dropArchiveDB Removes table in shard archive DB.

Parameters

db	Session with database.

Definition at line 489 of file RelationalDBInterface_shards.cpp.

rangeCheckedCast()

template<class T , class C >

T ripple::rangeCheckedCast

(

C

c

)

Definition at line 246 of file RelationalDBInterface.h.

getMarkers()

std::vector<uint256> ripple::getMarkers

(

size_t

numMarkers

)

Parititions the uint256 keyspace into numMarkers partitions, each of equal size.

Definition at line 167 of file ETLHelpers.h.

forwardToP2p()

Json::Value ripple::forwardToP2p

(

RPC::JsonContext &

context

)

Forward a JSON request to a p2p node and return the response.

Parameters

context

context of the request

Returns

response from p2p node

Definition at line 28 of file P2pProxy.cpp.

getP2pForwardingStub()

std::unique_ptr< org::xrpl::rpc::v1::XRPLedgerAPIService::Stub > ripple::getP2pForwardingStub

(

RPC::Context &

context

)

Get stub used to forward gRPC requests to a p2p node.

Parameters

context

context of the request

Returns

stub to forward requests

Definition at line 35 of file P2pProxy.cpp.

shouldForwardToP2p() [1/2]

bool ripple::shouldForwardToP2p

(

RPC::JsonContext &

context

)

Whether a request should be forwarded, based on request parameters.

Parameters

context

context of the request

Returns

true if should be forwarded

Definition at line 45 of file P2pProxy.cpp.

needCurrentOrClosed()

template<class Request >

bool ripple::needCurrentOrClosed

(

Request &

request

)

Definition at line 47 of file P2pProxy.h.

shouldForwardToP2p() [2/2]

template<class Request >

bool ripple::shouldForwardToP2p	(	RPC::GRPCContext< Request > &	context,
		RPC::Condition	condition
	)

Whether a request should be forwarded, based on request parameters.

Parameters

context

context of the request @condition required condition for the request

Returns

true if should be forwarded

Definition at line 98 of file P2pProxy.h.

checkValidity()

std::pair< Validity, std::string > ripple::checkValidity	(	HashRouter &	router,
		STTx const &	tx,
		Rules const &	rules,
		Config const &	config
	)

Checks transaction signature and local checks.

Returns

A Validity enum representing how valid the STTx is and, if not Valid, a reason string.

Note

Results are cached internally, so tests will not be repeated over repeated calls, unless cache expires.

Returns

std::pair, where .first is the status, and .second is the reason if appropriate.

See also

Validity

Definition at line 37 of file apply.cpp.

forceValidity()

void ripple::forceValidity	(	HashRouter &	router,
		uint256 const &	txid,
		Validity	validity
	)

Sets the validity of a given transaction in the cache.

Warning

Use with extreme care.

Note

Can only raise the validity to a more valid state, and can not override anything cached bad.

See also

checkValidity, Validity

Definition at line 89 of file apply.cpp.

apply()

std::pair< TER, bool > ripple::apply	(	Application &	app,
		OpenView &	view,
		STTx const &	tx,
		ApplyFlags	flags,
		beast::Journal	journal
	)

Apply a transaction to an OpenView.

This function is the canonical way to apply a transaction to a ledger. It rolls the validation and application steps into one function. To do the steps manually, the correct calling order is:

preflight -> preclaim -> doApply

The result of one function must be passed to the next. The preflight result can be safely cached and reused asynchronously, but preclaim and doApply must be called in the same thread and with the same view.

Note

Does not throw.

For open ledgers, the Transactor will catch exceptions and return tefEXCEPTION. For closed ledgers, the Transactor will attempt to only charge a fee, and return tecFAILED_PROCESSING.

If the Transactor gets an exception while trying to charge the fee, it will be caught and turned into tefEXCEPTION.

For network health, a Transactor makes its best effort to at least charge a fee if the ledger is closed.

Parameters

app	The current running Application.
view	The open ledger that the transaction will attempt to be applied to.
tx	The transaction to be checked.
flags	ApplyFlags describing processing options.
journal	A journal.

See also

preflight, preclaim, doApply

Returns

A pair with the TER and a bool indicating whether or not the transaction was applied.

Definition at line 109 of file apply.cpp.

applyTransaction()

ApplyResult ripple::applyTransaction	(	Application &	app,
		OpenView &	view,
		STTx const &	tx,
		bool	retryAssured,
		ApplyFlags	flags,
		beast::Journal	journal
	)

Transaction application helper.

Provides more detailed logging and decodes the correct behavior based on the TER type

See also

ApplyResult

Definition at line 124 of file apply.cpp.

isTecClaimHardFail()

bool ripple::isTecClaimHardFail	(	TER	ter,
		ApplyFlags	flags
	)

Return true if the transaction can claim a fee (tec), and the ApplyFlags do not allow soft failures.

Definition at line 36 of file applySteps.h.

preflight()

PreflightResult ripple::preflight	(	Application &	app,
		Rules const &	rules,
		STTx const &	tx,
		ApplyFlags	flags,
		beast::Journal	j
	)

Gate a transaction based on static information.

The transaction is checked against all possible validity constraints that do not require a ledger.

Parameters

app	The current running Application.
rules	The Rules in effect at the time of the check.
tx	The transaction to be checked.
flags	ApplyFlags describing processing options.
j	A journal.

See also

PreflightResult, preclaim, doApply, apply

Returns

A PreflightResult object containing, among other things, the TER code.

Definition at line 418 of file applySteps.cpp.

preclaim()

PreclaimResult ripple::preclaim	(	PreflightResult const &	preflightResult,
		Application &	app,
		OpenView const &	view
	)

Gate a transaction based on static ledger information.

The transaction is checked against all possible validity constraints that DO require a ledger.

If preclaim succeeds, then the transaction is very likely to claim a fee. This will determine if the transaction is safe to relay without being applied to the open ledger.

"Succeeds" in this case is defined as returning a tes or tec, since both lead to claiming a fee.

Precondition

The transaction has been checked and validated using preflight

Parameters

preflightResult	The result of a previous call to preflight for the transaction.
app	The current running Application.
view	The open ledger that the transaction will attempt to be applied to.

See also

PreclaimResult, preflight, doApply, apply

Returns

A PreclaimResult object containing, among other things the TER code and the base fee value for this transaction.

Definition at line 438 of file applySteps.cpp.

calculateBaseFee()

FeeUnit64 ripple::calculateBaseFee	(	ReadView const &	view,
		STTx const &	tx
	)

Compute only the expected base fee for a transaction.

Base fees are transaction specific, so any calculation needing them must get the base fee for each transaction.

No validation is done or implied by this function.

Caller is responsible for handling any exceptions. Since none should be thrown, that will usually mean terminating.

Parameters

view	The current open ledger.
tx	The transaction to be checked.

Returns

The base fee.

Definition at line 484 of file applySteps.cpp.

calculateDefaultBaseFee()

XRPAmount ripple::calculateDefaultBaseFee	(	ReadView const &	view,
		STTx const &	tx
	)

Return the minimum fee that an "ordinary" transaction would pay.

When computing the FeeLevel for a transaction the TxQ sometimes needs the know what an "ordinary" or reference transaction would be required to pay.

Parameters

view	The current open ledger.
tx	The transaction so the correct multisigner count is used.

Returns

The base fee in XRPAmount.

Definition at line 490 of file applySteps.cpp.

doApply()

std::pair< TER, bool > ripple::doApply	(	PreclaimResult const &	preclaimResult,
		Application &	app,
		OpenView &	view
	)

Apply a prechecked transaction to an OpenView.

Precondition

The transaction has been checked and validated using preflight and preclaim

Parameters

preclaimResult	The result of a previous call to preclaim for the transaction.
app	The current running Application.
view	The open ledger that the transaction will attempt to be applied to.

See also

preflight, preclaim, apply

Returns

A pair with the TER and a bool indicating whether or not the transaction was applied.

Definition at line 496 of file applySteps.cpp.

consequences_helper()

template<class T , std::enable_if_t< T::ConsequencesFactory==Transactor::Normal, int > = 0>

TxConsequences ripple::consequences_helper

(

PreflightContext const &

ctx

)

Definition at line 53 of file applySteps.cpp.

invoke_preflight_helper()

template<class T >

std::pair<NotTEC, TxConsequences> ripple::invoke_preflight_helper

(

PreflightContext const &

ctx

)

Definition at line 80 of file applySteps.cpp.

invoke_preflight()

static std::pair<NotTEC, TxConsequences> ripple::invoke_preflight ( PreflightContext const &  ctx )

static

Definition at line 89 of file applySteps.cpp.

invoke_preclaim()

template<class T >

static TER ripple::invoke_preclaim ( PreclaimContext const &  ctx )

static

Definition at line 147 of file applySteps.cpp.

invoke_calculateBaseFee()

static FeeUnit64 ripple::invoke_calculateBaseFee ( ReadView const &  view, STTx const &  tx  )

static

Definition at line 233 of file applySteps.cpp.

invoke_apply()

static std::pair<TER, bool> ripple::invoke_apply ( ApplyContext &  ctx )

static

Definition at line 325 of file applySteps.cpp.

after()

static bool ripple::after ( NetClock::time_point  now, std::uint32_t  mark  )

static

Has the specified time passed?

Parameters

now	the current time
mark	the cutoff point

Returns

true if now refers to a time strictly after mark, else false.

Definition at line 88 of file Escrow.cpp.

checkCondition()

static bool ripple::checkCondition ( Slice  f, Slice  c  )

static

Definition at line 278 of file Escrow.cpp.

getInvariantChecks()

InvariantChecks ripple::getInvariantChecks

(

)

get a tuple of all invariant checks

Returns

std::tuple of instances that implement the required invariant check methods

See also

ripple::InvariantChecker_PROTOTYPE

Definition at line 343 of file InvariantCheck.h.

operator<<() [1/15]

template<class TIn , class TOut >

std::ostream& ripple::operator<<	(	std::ostream &	os,
		TOffer< TIn, TOut > const &	offer
	)

Definition at line 242 of file Offer.h.

accountFundsHelper() [1/3]

static STAmount ripple::accountFundsHelper ( ReadView const &  view, AccountID const &  id, STAmount const &  saDefault, Issue const &  , FreezeHandling  freezeHandling, beast::Journal  j  )

static

Definition at line 95 of file OfferStream.cpp.

accountFundsHelper() [2/3]

static IOUAmount ripple::accountFundsHelper ( ReadView const &  view, AccountID const &  id, IOUAmount const &  amtDefault, Issue const &  issue, FreezeHandling  freezeHandling, beast::Journal  j  )

static

Definition at line 107 of file OfferStream.cpp.

accountFundsHelper() [3/3]

static XRPAmount ripple::accountFundsHelper ( ReadView const &  view, AccountID const &  id, XRPAmount const &  amtDefault, Issue const &  issue, FreezeHandling  freezeHandling, beast::Journal  j  )

static

Definition at line 124 of file OfferStream.cpp.

closeChannel()

static TER ripple::closeChannel ( std::shared_ptr< SLE > const &  slep, ApplyView &  view, uint256 const &  key, beast::Journal  j  )

static

Definition at line 116 of file PayChan.cpp.

signerCountBasedOwnerCountDelta()

static int ripple::signerCountBasedOwnerCountDelta ( std::size_t  entryCount )

static

Definition at line 153 of file SetSignerList.cpp.

removeSignersFromLedger()

static TER ripple::removeSignersFromLedger ( Application &  app, ApplyView &  view, Keylet const &  accountKeylet, Keylet const &  ownerDirKeylet, Keylet const &  signerListKeylet, beast::Journal  j  )

static

Definition at line 175 of file SetSignerList.cpp.

format_amount()

static std::string ripple::format_amount ( STAmount const &  amount )

static

Definition at line 27 of file Taker.cpp.

qual_div()

static STAmount ripple::qual_div ( STAmount const &  amount, Quality const &  quality, STAmount const &  output  )

static

Definition at line 178 of file Taker.cpp.

qual_mul()

static STAmount ripple::qual_mul ( STAmount const &  amount, Quality const &  quality, STAmount const &  output  )

static

Definition at line 185 of file Taker.cpp.

preflight0()

NotTEC ripple::preflight0

(

PreflightContext const &

ctx

)

Performs early sanity checks on the txid.

Definition at line 40 of file Transactor.cpp.

preflight1()

NotTEC ripple::preflight1

(

PreflightContext const &

ctx

)

Performs early sanity checks on the account and fee fields.

Definition at line 56 of file Transactor.cpp.

preflight2()

NotTEC ripple::preflight2

(

PreflightContext const &

ctx

)

Checks whether the signature appears valid.

Definition at line 108 of file Transactor.cpp.

removeUnfundedOffers()

static void ripple::removeUnfundedOffers ( ApplyView &  view, std::vector< uint256 > const &  offers, beast::Journal  viewJ  )

static

Definition at line 696 of file Transactor.cpp.

generalized_set_intersection()

template<class InputIter1 , class InputIter2 , class Action , class Comp >

void ripple::generalized_set_intersection	(	InputIter1	first1,
		InputIter1	last1,
		InputIter2	first2,
		InputIter2	last2,
		Action	action,
		Comp	comp
	)

Definition at line 36 of file algorithm.h.

remove_if_intersect_or_match()

template<class FwdIter1 , class InputIter2 , class Pred , class Comp >

FwdIter1 ripple::remove_if_intersect_or_match	(	FwdIter1	first1,
		FwdIter1	last1,
		InputIter2	first2,
		InputIter2	last2,
		Pred	pred,
		Comp	comp
	)

Definition at line 74 of file algorithm.h.

extractTarLz4()

void ripple::extractTarLz4	(	boost::filesystem::path const &	src,
		boost::filesystem::path const &	dst
	)

Extract a tar archive compressed with lz4.

Parameters

src	the path of the archive to be extracted
dst	the directory to extract to

Exceptions

runtime_error

Definition at line 29 of file Archive.cpp.

base64_encode() [1/2]

std::string ripple::base64_encode	(	std::uint8_t const *	data,
		std::size_t	len
	)

Definition at line 236 of file base64.cpp.

base64_encode() [2/2]

std::string ripple::base64_encode

(

std::string const &

s

)

Definition at line 68 of file base64.h.

base64_decode()

std::string ripple::base64_decode

(

std::string const &

data

)

Definition at line 245 of file base64.cpp.

compare() [1/3]

template<std::size_t Bits, class Tag >

int ripple::compare	(	base_uint< Bits, Tag > const &	a,
		base_uint< Bits, Tag > const &	b
	)

Definition at line 533 of file base_uint.h.

operator<() [2/10]

template<std::size_t Bits, class Tag >

bool ripple::operator<	(	base_uint< Bits, Tag > const &	a,
		base_uint< Bits, Tag > const &	b
	)

Definition at line 550 of file base_uint.h.

operator<=() [1/5]

template<std::size_t Bits, class Tag >

bool ripple::operator<=	(	base_uint< Bits, Tag > const &	a,
		base_uint< Bits, Tag > const &	b
	)

Definition at line 557 of file base_uint.h.

operator>() [1/5]

template<std::size_t Bits, class Tag >

bool ripple::operator>	(	base_uint< Bits, Tag > const &	a,
		base_uint< Bits, Tag > const &	b
	)

Definition at line 564 of file base_uint.h.

operator>=() [1/5]

template<std::size_t Bits, class Tag >

bool ripple::operator>=	(	base_uint< Bits, Tag > const &	a,
		base_uint< Bits, Tag > const &	b
	)

Definition at line 571 of file base_uint.h.

operator==() [3/15]

template<std::size_t Bits, class Tag >

bool ripple::operator==	(	base_uint< Bits, Tag > const &	a,
		base_uint< Bits, Tag > const &	b
	)

Definition at line 578 of file base_uint.h.

operator!=() [2/12]

template<std::size_t Bits, class Tag >

bool ripple::operator!=	(	base_uint< Bits, Tag > const &	a,
		base_uint< Bits, Tag > const &	b
	)

Definition at line 585 of file base_uint.h.

operator==() [4/15]

template<std::size_t Bits, class Tag >

bool ripple::operator==	(	base_uint< Bits, Tag > const &	a,
		std::uint64_t	b
	)

Definition at line 593 of file base_uint.h.

operator!=() [3/12]

template<std::size_t Bits, class Tag >

bool ripple::operator!=	(	base_uint< Bits, Tag > const &	a,
		std::uint64_t	b
	)

Definition at line 600 of file base_uint.h.

operator^()

template<std::size_t Bits, class Tag >

const base_uint<Bits, Tag> ripple::operator^	(	base_uint< Bits, Tag > const &	a,
		base_uint< Bits, Tag > const &	b
	)

Definition at line 608 of file base_uint.h.

operator&() [1/2]

template<std::size_t Bits, class Tag >

const base_uint<Bits, Tag> ripple::operator&	(	base_uint< Bits, Tag > const &	a,
		base_uint< Bits, Tag > const &	b
	)

Definition at line 615 of file base_uint.h.

operator|() [1/2]

template<std::size_t Bits, class Tag >

const base_uint<Bits, Tag> ripple::operator|	(	base_uint< Bits, Tag > const &	a,
		base_uint< Bits, Tag > const &	b
	)

Definition at line 622 of file base_uint.h.

operator+() [1/2]

template<std::size_t Bits, class Tag >

const base_uint<Bits, Tag> ripple::operator+	(	base_uint< Bits, Tag > const &	a,
		base_uint< Bits, Tag > const &	b
	)

Definition at line 629 of file base_uint.h.

to_string() [5/26]

template<std::size_t Bits, class Tag >

std::string ripple::to_string

(

base_uint< Bits, Tag > const &

a

)

Definition at line 637 of file base_uint.h.

operator<<() [2/15]

template<std::size_t Bits, class Tag >

std::ostream& ripple::operator<<	(	std::ostream &	out,
		base_uint< Bits, Tag > const &	u
	)

Definition at line 644 of file base_uint.h.

set() [1/5]

template<class T >

bool ripple::set	(	T &	target,
		std::string const &	name,
		Section const &	section
	)

Set a value from a configuration Section If the named value is not found or doesn't parse as a T, the variable is unchanged.

Returns

true if value was set.

Definition at line 313 of file BasicConfig.h.

set() [2/5]

template<class T >

bool ripple::set	(	T &	target,
		T const &	defaultValue,
		std::string const &	name,
		Section const &	section
	)

Set a value from a configuration Section If the named value is not found or doesn't cast to T, the variable is assigned the default.

Returns

true if the named value was found and is valid.

Definition at line 335 of file BasicConfig.h.

get() [3/6]

template<class T = std::string>

T ripple::get	(	Section const &	section,
		std::string const &	name,
		T const &	defaultValue = T{}
	)

Retrieve a key/value pair from a section.

Returns

The value string converted to T if it exists and can be parsed, or else defaultValue.

Definition at line 353 of file BasicConfig.h.

get() [4/6]

std::string ripple::get	(	Section const &	section,
		std::string const &	name,
		const char *	defaultValue
	)

Definition at line 368 of file BasicConfig.h.

get_if_exists()

template<class T >

bool ripple::get_if_exists	(	Section const &	section,
		std::string const &	name,
		T &	v
	)

Definition at line 384 of file BasicConfig.h.

get_if_exists< bool >()

template<>

bool ripple::get_if_exists< bool >	(	Section const &	section,
		std::string const &	name,
		bool &	v
	)

Definition at line 391 of file BasicConfig.h.

operator==() [5/15]

bool ripple::operator== ( Buffer const &  lhs, Buffer const &  rhs  )

noexcept

Definition at line 219 of file Buffer.h.

operator!=() [4/12]

bool ripple::operator!= ( Buffer const &  lhs, Buffer const &  rhs  )

noexcept

Definition at line 231 of file Buffer.h.

kilobytes()

template<class T >

constexpr auto ripple::kilobytes ( T  value )

constexprnoexcept

Definition at line 27 of file ByteUtilities.h.

megabytes()

template<class T >

constexpr auto ripple::megabytes ( T  value )

constexprnoexcept

Definition at line 34 of file ByteUtilities.h.

to_string() [6/26]

template<class Duration >

std::string ripple::to_string

(

date::sys_time< Duration >

tp

)

Definition at line 63 of file chrono.h.

to_string() [7/26]

std::string ripple::to_string

(

NetClock::time_point

tp

)

Definition at line 69 of file chrono.h.

stopwatch()

Stopwatch& ripple::stopwatch

(

)

Returns an instance of a wall clock.

Definition at line 88 of file chrono.h.

LogThrow()

void ripple::LogThrow

(

std::string const &

title

)

Generates and logs a call stack.

Definition at line 42 of file contract.cpp.

Rethrow()

void ripple::Rethrow

(

)

Rethrow the exception currently being handled.

When called from within a catch block, it will pass control to the next matching exception handler, if any. Otherwise, std::terminate will be called.

Definition at line 48 of file contract.h.

Throw()

template<class E , class... Args>

void ripple::Throw

(

Args &&...

args

)

Definition at line 56 of file contract.h.

LogicError()

void ripple::LogicError ( std::string const &  how )

noexcept

Called when faulty logic causes a broken invariant.

Definition at line 48 of file contract.cpp.

Unexpected()

template<typename E , std::size_t N>

ripple::Unexpected

(

E(&)

[N]

)

-> Unexpected< E const * >

mulDiv() [1/7]

template<class Source1 , class Source2 , class Dest , class = feeunit::enable_muldiv_t<Source1, Source2, Dest>>

std::pair<bool, Dest> ripple::mulDiv	(	Source1	value,
		Dest	mul,
		Source2	div
	)

Definition at line 473 of file FeeUnits.h.

mulDiv() [2/7]

template<class Source1 , class Source2 , class Dest , class = feeunit::enable_muldiv_commute_t<Source1, Source2, Dest>>

std::pair<bool, Dest> ripple::mulDiv	(	Dest	value,
		Source1	mul,
		Source2	div
	)

Definition at line 484 of file FeeUnits.h.

mulDiv() [3/7]

template<class Dest , class = feeunit::enable_muldiv_dest_t<Dest>>

std::pair<bool, Dest> ripple::mulDiv	(	std::uint64_t	value,
		Dest	mul,
		std::uint64_t	div
	)

Definition at line 492 of file FeeUnits.h.

mulDiv() [4/7]

template<class Dest , class = feeunit::enable_muldiv_dest_t<Dest>>

std::pair<bool, Dest> ripple::mulDiv	(	Dest	value,
		std::uint64_t	mul,
		std::uint64_t	div
	)

Definition at line 501 of file FeeUnits.h.

mulDiv() [5/7]

template<class Source1 , class Source2 , class = feeunit::enable_muldiv_sources_t<Source1, Source2>>

std::pair<bool, std::uint64_t> ripple::mulDiv	(	Source1	value,
		std::uint64_t	mul,
		Source2	div
	)

Definition at line 512 of file FeeUnits.h.

mulDiv() [6/7]

template<class Source1 , class Source2 , class = feeunit::enable_muldiv_sources_t<Source1, Source2>>

std::pair<bool, std::uint64_t> ripple::mulDiv	(	std::uint64_t	value,
		Source1	mul,
		Source2	div
	)

Definition at line 525 of file FeeUnits.h.

safe_cast() [1/4]

template<class Dest , class Src >

constexpr std::enable_if_t< std::is_same_v<typename Dest::unit_type, typename Src::unit_type> && std::is_integral_v<typename Dest::value_type> && std::is_integral_v<typename Src::value_type>, Dest> ripple::safe_cast ( Src  s )

constexprnoexcept

Definition at line 537 of file FeeUnits.h.

unsafe_cast() [1/4]

template<class Dest , class Src >

constexpr std::enable_if_t< std::is_same_v<typename Dest::unit_type, typename Src::unit_type> && std::is_integral_v<typename Dest::value_type> && std::is_integral_v<typename Src::value_type>, Dest> ripple::unsafe_cast ( Src  s )

constexprnoexcept

Definition at line 549 of file FeeUnits.h.

getFileContents()

std::string ripple::getFileContents	(	boost::system::error_code &	ec,
		boost::filesystem::path const &	sourcePath,
		std::optional< std::size_t >	maxSize = std::nullopt
	)

Definition at line 25 of file FileUtilities.cpp.

writeFileContents()

void ripple::writeFileContents	(	boost::system::error_code &	ec,
		boost::filesystem::path const &	destPath,
		std::string const &	contents
	)

Definition at line 66 of file FileUtilities.cpp.

operator<<() [3/15]

std::ostream& ripple::operator<<	(	std::ostream &	os,
		Section const &	section
	)

Definition at line 111 of file BasicConfig.cpp.

operator<<() [4/15]

std::ostream& ripple::operator<<	(	std::ostream &	ss,
		BasicConfig const &	c
	)

Definition at line 189 of file BasicConfig.cpp.

to_string() [8/26]

std::string ripple::to_string

(

IOUAmount const &

amount

)

Definition at line 158 of file IOUAmount.cpp.

mulRatio() [1/2]

IOUAmount ripple::mulRatio	(	IOUAmount const &	amt,
		std::uint32_t	num,
		std::uint32_t	den,
		bool	roundUp
	)

Definition at line 248 of file IOUAmount.cpp.

debugSink()

static DebugSink& ripple::debugSink ( )

static

Definition at line 439 of file Log.cpp.

setDebugLogSink()

std::unique_ptr< beast::Journal::Sink > ripple::setDebugLogSink

(

std::unique_ptr< beast::Journal::Sink >

sink

)

Set the sink for the debug journal.

Parameters

sink	unique_ptr to new debug Sink.

Returns

unique_ptr to the previous Sink. nullptr if there was no Sink.

Definition at line 446 of file Log.cpp.

debugLog()

beast::Journal ripple::debugLog

(

)

Returns a debug journal.

The journal may drain to a null sink, so its output may never be seen. Never use it for critical information.

Definition at line 452 of file Log.cpp.

make_SSLContext()

std::shared_ptr< boost::asio::ssl::context > ripple::make_SSLContext

(

std::string const &

cipherList

)

Create a self-signed SSL context that allows anonymous Diffie Hellman.

Definition at line 400 of file make_SSLContext.cpp.

make_SSLContextAuthed()

std::shared_ptr< boost::asio::ssl::context > ripple::make_SSLContextAuthed	(	std::string const &	keyFile,
		std::string const &	certFile,
		std::string const &	chainFile,
		std::string const &	cipherList
	)

Create an authenticated SSL context using the specified files.

Definition at line 411 of file make_SSLContext.cpp.

mulDiv() [7/7]

std::pair< bool, std::uint64_t > ripple::mulDiv	(	std::uint64_t	value,
		std::uint64_t	mul,
		std::uint64_t	div
	)

Return value*mul/div accurately.

Computes the result of the multiplication and division in a single step, avoiding overflow and retaining precision. Throws: None Returns: std::pair: first is false if the calculation overflows, true if the calculation is safe. second is the result of the calculation if first is false, max value of uint64_t if true.

Definition at line 29 of file mulDiv.cpp.

charUnHex() [1/2]

int ripple::charUnHex

(

unsigned char

c

)

Converts a hex digit to the corresponding integer.

Parameters

cDigit

one of '0'-'9', 'A'-'F' or 'a'-'f'

Returns

an integer from 0 to 15 on success; -1 on failure.

Definition at line 26 of file strHex.cpp.

sqlBlobLiteral()

std::string ripple::sqlBlobLiteral

(

Blob const &

blob

)

Format arbitrary binary data as an SQLite "blob literal".

In SQLite, blob literals must be encoded when used in a query. Per https://sqlite.org/lang_expr.html#literal_values_constants_ they are encoded as string literals containing hexadecimal data and preceded by a single 'X' character.

Parameters

blob	An arbitrary blob of binary data

Returns

The input, encoded as a blob literal.

Definition at line 33 of file StringUtilities.cpp.

parseUrl()

bool ripple::parseUrl	(	parsedURL &	pUrl,
		std::string const &	strUrl
	)

Definition at line 47 of file StringUtilities.cpp.

calculatePercent()

constexpr std::size_t ripple::calculatePercent ( std::size_t  count, std::size_t  total  )

constexpr

Calculate one number divided by another number in percentage.

The result is rounded up to the next integer, and capped in the range [0,100] E.g. calculatePercent(1, 100) = 1 because 1/100 = 0.010000 calculatePercent(1, 99) = 2 because 1/99 = 0.010101 calculatePercent(0, 100) = 0 calculatePercent(100, 100) = 100 calculatePercent(200, 100) = 100 because the result is capped to 100

Parameters

count	dividend
total	divisor

Returns

the percentage, in [0, 100]

Note

total cannot be zero.

Definition at line 44 of file MathUtilities.h.

default_prng()

beast::xor_shift_engine& ripple::default_prng

(

)

Return the default random engine.

This engine is guaranteed to be deterministic, but by default will be randomly seeded. It is NOT cryptographically secure and MUST NOT be used to generate randomness that will be used for keys, secure cookies, IVs, padding, etc.

Each thread gets its own instance of the engine which will be randomly seeded.

Definition at line 65 of file ripple/basics/random.h.

rand_int() [1/6]

template<class Engine , class Integral >

std::enable_if_t< std::is_integral<Integral>::value && detail::is_engine<Engine>::value, Integral> ripple::rand_int	(	Engine &	engine,
		Integral	min,
		Integral	max
	)

Return a uniformly distributed random integer.

Parameters

min	The smallest value to return. If not specified the value defaults to 0.
max	The largest value to return. If not specified the value defaults to the largest value that can be represented.

The randomness is generated by the specified engine (or the default engine if one is not specified). The result is cryptographically secure only when the engine passed into the function is cryptographically secure.

Note

The range is always a closed interval, so calling rand_int(-5, 15) can return any integer in the closed interval [-5, 15]; similarly, calling rand_int(7) can return any integer in the closed interval [0, 7].

Definition at line 115 of file ripple/basics/random.h.

rand_int() [2/6]

template<class Integral >

std::enable_if_t<std::is_integral<Integral>::value, Integral> ripple::rand_int	(	Integral	min,
		Integral	max
	)

Definition at line 127 of file ripple/basics/random.h.

rand_int() [3/6]

template<class Engine , class Integral >

std::enable_if_t< std::is_integral<Integral>::value && detail::is_engine<Engine>::value, Integral> ripple::rand_int	(	Engine &	engine,
		Integral	max
	)

Definition at line 136 of file ripple/basics/random.h.

rand_int() [4/6]

template<class Integral >

std::enable_if_t<std::is_integral<Integral>::value, Integral> ripple::rand_int

(

Integral

max

)

Definition at line 143 of file ripple/basics/random.h.

rand_int() [5/6]

template<class Integral , class Engine >

std::enable_if_t< std::is_integral<Integral>::value && detail::is_engine<Engine>::value, Integral> ripple::rand_int

(

Engine &

engine

)

Definition at line 152 of file ripple/basics/random.h.

rand_int() [6/6]

template<class Integral = int>

std::enable_if_t<std::is_integral<Integral>::value, Integral> ripple::rand_int

(

)

Definition at line 159 of file ripple/basics/random.h.

rand_byte() [1/2]

template<class Byte , class Engine >

std::enable_if_t< (std::is_same<Byte, unsigned char>::value || std::is_same<Byte, std::uint8_t>::value) && detail::is_engine<Engine>::value, Byte> ripple::rand_byte

(

Engine &

engine

)

Return a random byte.

Definition at line 173 of file ripple/basics/random.h.

rand_byte() [2/2]

template<class Byte = std::uint8_t>

std::enable_if_t< (std::is_same<Byte, unsigned char>::value || std::is_same<Byte, std::uint8_t>::value), Byte> ripple::rand_byte

(

)

Definition at line 186 of file ripple/basics/random.h.

rand_bool() [1/2]

template<class Engine >

bool ripple::rand_bool

(

Engine &

engine

)

Return a random boolean value.

Definition at line 196 of file ripple/basics/random.h.

rand_bool() [2/2]

bool ripple::rand_bool

(

)

Definition at line 202 of file ripple/basics/random.h.

range()

template<class T >

ClosedInterval<T> ripple::range	(	T	low,
		T	high
	)

Create a closed range interval.

Helper function to create a closed range interval without having to qualify the template argument.

Definition at line 53 of file RangeSet.h.

to_string() [9/26]

template<class T >

std::string ripple::to_string

(

ClosedInterval< T > const &

ci

)

Convert a ClosedInterval to a styled string.

The styled string is "c.first()-c.last()" if c.first() != c.last() "c.first()" if c.first() == c.last()

Parameters

ci	The closed interval to convert

Returns

The style string

Definition at line 82 of file RangeSet.h.

to_string() [10/26]

template<class T >

std::string ripple::to_string

(

RangeSet< T > const &

rs

)

Convert the given RangeSet to a styled string.

The styled string representation is the set of disjoint intervals joined by commas. The string "empty" is returned if the set is empty.

Parameters

rs	The rangeset to convert

Returns

The styled string

Definition at line 99 of file RangeSet.h.

from_string()

template<class T >

bool ripple::from_string	(	RangeSet< T > &	rs,
		std::string const &	s
	)

Convert the given styled string to a RangeSet.

The styled string representation is the set of disjoint intervals joined by commas.

Parameters

rs	The set to be populated
s	The styled string to convert

Returns

True on successfully converting styled string

Definition at line 123 of file RangeSet.h.

prevMissing()

template<class T >

std::optional<T> ripple::prevMissing	(	RangeSet< T > const &	rs,
		T	t,
		T	minVal = 0
	)

Find the largest value not in the set that is less than a given value.

Parameters

rs	The set of interest
t	The value that must be larger than the result
minVal	(Default is 0) The smallest allowed value

Returns

The largest v such that minV <= v < t and !contains(rs, v) or std::nullopt if no such v exists.

Definition at line 182 of file RangeSet.h.

safe_cast() [2/4]

template<class Dest , class Src >

constexpr std:: enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest> ripple::safe_cast ( Src  s )

constexprnoexcept

Definition at line 42 of file safe_cast.h.

safe_cast() [3/4]

template<class Dest , class Src >

constexpr std:: enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest> ripple::safe_cast ( Src  s )

constexprnoexcept

Definition at line 58 of file safe_cast.h.

safe_cast() [4/4]

template<class Dest , class Src >

constexpr std:: enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest> ripple::safe_cast ( Src  s )

constexprnoexcept

Definition at line 66 of file safe_cast.h.

unsafe_cast() [2/4]

template<class Dest , class Src >

constexpr std:: enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest> ripple::unsafe_cast ( Src  s )

constexprnoexcept

Definition at line 78 of file safe_cast.h.

unsafe_cast() [3/4]

template<class Dest , class Src >

constexpr std:: enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest> ripple::unsafe_cast ( Src  s )

constexprnoexcept

Definition at line 90 of file safe_cast.h.

unsafe_cast() [4/4]

template<class Dest , class Src >

constexpr std:: enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest> ripple::unsafe_cast ( Src  s )

constexprnoexcept

Definition at line 98 of file safe_cast.h.

scope_exit()

template<class EF >

ripple::scope_exit

(

EF

)

-> scope_exit< EF >

scope_fail()

template<class EF >

ripple::scope_fail

(

EF

)

-> scope_fail< EF >

scope_success()

template<class EF >

ripple::scope_success

(

EF

)

-> scope_success< EF >

hash_append() [4/8]

template<class Hasher >

void ripple::hash_append	(	Hasher &	h,
		Slice const &	v
	)

Definition at line 195 of file Slice.h.

operator==() [6/15]

bool ripple::operator== ( Slice const &  lhs, Slice const &  rhs  )

noexcept

Definition at line 201 of file Slice.h.

operator!=() [5/12]

bool ripple::operator!= ( Slice const &  lhs, Slice const &  rhs  )

noexcept

Definition at line 213 of file Slice.h.

operator<() [3/10]

bool ripple::operator< ( Slice const &  lhs, Slice const &  rhs  )

noexcept

Definition at line 219 of file Slice.h.

operator<<() [5/15]

template<class Stream >

Stream& ripple::operator<<	(	Stream &	s,
		Slice const &	v
	)

Definition at line 230 of file Slice.h.

makeSlice() [1/3]

template<class T , std::size_t N>

std::enable_if_t< std::is_same<T, char>::value || std::is_same<T, unsigned char>::value, Slice> ripple::makeSlice

(

std::array< T, N > const &

a

)

Definition at line 240 of file Slice.h.

makeSlice() [2/3]

template<class T , class Alloc >

std::enable_if_t< std::is_same<T, char>::value || std::is_same<T, unsigned char>::value, Slice> ripple::makeSlice

(

std::vector< T, Alloc > const &

v

)

Definition at line 249 of file Slice.h.

makeSlice() [3/3]

template<class Traits , class Alloc >

Slice ripple::makeSlice

(

std::basic_string< char, Traits, Alloc > const &

s

)

Definition at line 256 of file Slice.h.

charUnHex() [2/2]

int ripple::charUnHex

(

char

c

)

Definition at line 37 of file strHex.h.

strHex() [1/2]

template<class FwdIt >

std::string ripple::strHex	(	FwdIt	begin,
		FwdIt	end
	)

Definition at line 45 of file strHex.h.

strHex() [2/2]

template<class T , class = decltype(std::declval<T>().begin())>

std::string ripple::strHex

(

T const &

from

)

Definition at line 60 of file strHex.h.

strUnHex() [1/2]

template<class Iterator >

std::optional<Blob> ripple::strUnHex	(	std::size_t	strSize,
		Iterator	begin,
		Iterator	end
	)

Definition at line 49 of file StringUtilities.h.

strUnHex() [2/2]

std::optional<Blob> ripple::strUnHex

(

std::string const &

strSrc

)

Definition at line 89 of file StringUtilities.h.

strViewUnHex()

std::optional<Blob> ripple::strViewUnHex

(

boost::string_view const &

strSrc

)

Definition at line 95 of file StringUtilities.h.

trim_whitespace()

std::string ripple::trim_whitespace

(

std::string

str

)

to_uint64()

std::optional<std::uint64_t> ripple::to_uint64

(

std::string const &

s

)

isProperlyFormedTomlDomain()

bool ripple::isProperlyFormedTomlDomain

(

std::string const &

domain

)

Determines if the given string looks like a TOML-file hosting domain.

Do not use this function to determine if a particular string is a valid domain, as this function may reject domains that are otherwise valid and doesn't check whether the TLD is valid.

to_string() [11/26]

template<class T >

std::enable_if<std::is_arithmetic<T>::value, std::string>::type ripple::to_string

(

T

t

)

to_string() generalizes std::to_string to handle bools, chars, and strings.

It's also possible to provide implementation of to_string for a class which needs a string implementation.

Definition at line 36 of file ToString.h.

to_string() [12/26]

std::string ripple::to_string

(

bool

b

)

Definition at line 42 of file ToString.h.

to_string() [13/26]

std::string ripple::to_string

(

char

c

)

Definition at line 48 of file ToString.h.

to_string() [14/26]

std::string ripple::to_string

(

std::string

s

)

Definition at line 54 of file ToString.h.

to_string() [15/26]

std::string ripple::to_string

(

char const *

s

)

Definition at line 60 of file ToString.h.

operator<<() [6/15]

template<class Char , class Traits >

std::basic_ostream<Char, Traits>& ripple::operator<<	(	std::basic_ostream< Char, Traits > &	os,
		const XRPAmount &	q
	)

Definition at line 261 of file XRPAmount.h.

to_string() [16/26]

std::string ripple::to_string

(

XRPAmount const &

amount

)

Definition at line 267 of file XRPAmount.h.

mulRatio() [2/2]

XRPAmount ripple::mulRatio	(	XRPAmount const &	amt,
		std::uint32_t	num,
		std::uint32_t	den,
		bool	roundUp
	)

Definition at line 273 of file XRPAmount.h.

shouldCloseLedger()

bool ripple::shouldCloseLedger	(	bool	anyTransactions,
		std::size_t	prevProposers,
		std::size_t	proposersClosed,
		std::size_t	proposersValidated,
		std::chrono::milliseconds	prevRoundTime,
		std::chrono::milliseconds	timeSincePrevClose,
		std::chrono::milliseconds	openTime,
		std::chrono::milliseconds	idleInterval,
		ConsensusParms const &	parms,
		beast::Journal	j
	)

Determines whether the current ledger should close at this time.

This function should be called when a ledger is open and there is no close in progress, or when a transaction is received and no close is in progress.

Parameters

anyTransactions	indicates whether any transactions have been received
prevProposers	proposers in the last closing
proposersClosed	proposers who have currently closed this ledger
proposersValidated	proposers who have validated the last closed ledger
prevRoundTime	time for the previous ledger to reach consensus
timeSincePrevClose	time since the previous ledger's (possibly rounded) close time
openTime	duration this ledger has been open
idleInterval	the network's desired idle interval
parms	Consensus constant parameters
j	journal for logging

Definition at line 26 of file Consensus.cpp.

checkConsensusReached()

bool ripple::checkConsensusReached	(	std::size_t	agreeing,
		std::size_t	total,
		bool	count_self,
		std::size_t	minConsensusPct
	)

Definition at line 86 of file Consensus.cpp.

checkConsensus()

ConsensusState ripple::checkConsensus	(	std::size_t	prevProposers,
		std::size_t	currentProposers,
		std::size_t	currentAgree,
		std::size_t	currentFinished,
		std::chrono::milliseconds	previousAgreeTime,
		std::chrono::milliseconds	currentAgreeTime,
		ConsensusParms const &	parms,
		bool	proposing,
		beast::Journal	j
	)

Determine whether the network reached consensus and whether we joined.

Parameters

prevProposers	proposers in the last closing (not including us)
currentProposers	proposers in this closing so far (not including us)
currentAgree	proposers who agree with us
currentFinished	proposers who have validated a ledger after this one
previousAgreeTime	how long, in milliseconds, it took to agree on the last ledger
currentAgreeTime	how long, in milliseconds, we've been trying to agree
parms	Consensus constant parameters
proposing	whether we should count ourselves
j	journal for logging

Definition at line 108 of file Consensus.cpp.

participantsNeeded()

int ripple::participantsNeeded	(	int	participants,
		int	percent
	)

How many of the participants must agree to reach a given threshold?

Note that the number may not precisely yield the requested percentage. For example, with with size = 5 and percent = 70, we return 3, but 3 out of 5 works out to 60%. There are no security implications to this.

Parameters

participants	The number of participants (i.e. validators)
percent	The percent that we want to reach

Returns

the number of participants which must agree

Definition at line 1347 of file Consensus.h.

operator==() [7/15]

template<class NodeID_t , class LedgerID_t , class Position_t >

bool ripple::operator==	(	ConsensusProposal< NodeID_t, LedgerID_t, Position_t > const &	a,
		ConsensusProposal< NodeID_t, LedgerID_t, Position_t > const &	b
	)

Definition at line 235 of file ConsensusProposal.h.

to_string() [17/26]

std::string ripple::to_string

(

ConsensusMode

m

)

Definition at line 70 of file ConsensusTypes.h.

to_string() [18/26]

std::string ripple::to_string

(

ConsensusPhase

p

)

Definition at line 117 of file ConsensusTypes.h.

getNextLedgerTimeResolution()

template<class Rep , class Period , class Seq >

std::chrono::duration<Rep, Period> ripple::getNextLedgerTimeResolution	(	std::chrono::duration< Rep, Period >	previousResolution,
		bool	previousAgree,
		Seq	ledgerSeq
	)

Calculates the close time resolution for the specified ledger.

The Ripple protocol uses binning to represent time intervals using only one timestamp. This allows servers to derive a common time for the next ledger, without the need for perfectly synchronized clocks. The time resolution (i.e. the size of the intervals) is adjusted dynamically based on what happened in the last ledger, to try to avoid disagreements.

Parameters

previousResolution	the resolution used for the prior ledger
previousAgree	whether consensus agreed on the close time of the prior ledger
ledgerSeq	the sequence number of the new ledger

Precondition

previousResolution must be a valid bin from ledgerPossibleTimeResolutions

Template Parameters

Rep	Type representing number of ticks in std::chrono::duration
Period	An std::ratio representing tick period in std::chrono::duration
Seq	Unsigned integer-like type corresponding to the ledger sequence number. It should be comparable to 0 and support modular division. Built-in and tagged_integers are supported.

Definition at line 80 of file LedgerTiming.h.

roundCloseTime()

template<class Clock , class Duration , class Rep , class Period >

std::chrono::time_point<Clock, Duration> ripple::roundCloseTime	(	std::chrono::time_point< Clock, Duration >	closeTime,
		std::chrono::duration< Rep, Period >	closeResolution
	)

Calculates the close time for a ledger, given a close time resolution.

Parameters

closeTime	The time to be rounded
closeResolution	The resolution

Returns

closeTime rounded to the nearest multiple of closeResolution. Rounds up if closeTime is midway between multiples of closeResolution.

Definition at line 129 of file LedgerTiming.h.

effCloseTime()

template<class Clock , class Duration , class Rep , class Period >

std::chrono::time_point<Clock, Duration> ripple::effCloseTime	(	std::chrono::time_point< Clock, Duration >	closeTime,
		std::chrono::duration< Rep, Period >	resolution,
		std::chrono::time_point< Clock, Duration >	priorCloseTime
	)

Calculate the effective ledger close time.

After adjusting the ledger close time based on the current resolution, also ensure it is sufficiently separated from the prior close time.

Parameters

closeTime	The raw ledger close time
resolution	The current close time resolution
priorCloseTime	The close time of the prior ledger

Definition at line 152 of file LedgerTiming.h.

isCurrent()

bool ripple::isCurrent	(	ValidationParms const &	p,
		NetClock::time_point	now,
		NetClock::time_point	signTime,
		NetClock::time_point	seenTime
	)

Whether a validation is still current.

Determines whether a validation can still be considered the current validation from a node based on when it was signed by that node and first seen by this node.

Parameters

p	ValidationParms with timing parameters
now	Current time
signTime	When the validation was signed
seenTime	When the validation was first seen locally

Definition at line 146 of file Validations.h.

to_string() [19/26]

std::string ripple::to_string

(

ValStatus

m

)

Definition at line 180 of file Validations.h.

checkpointerFromId()

std::shared_ptr< Checkpointer > ripple::checkpointerFromId

(

std::uintptr_t

id

)

Definition at line 79 of file DatabaseCon.cpp.

setup_DatabaseCon()

DatabaseCon::Setup ripple::setup_DatabaseCon	(	Config const &	c,
		std::optional< beast::Journal >	j = std::nullopt
	)

Definition at line 106 of file DatabaseCon.cpp.

parseIniFile()

IniFileSections ripple::parseIniFile	(	std::string const &	strInput,
		const bool	bTrim
	)

Definition at line 159 of file Config.cpp.

getIniFileSection()

IniFileSections::mapped_type* ripple::getIniFileSection	(	IniFileSections &	secSource,
		std::string const &	strSection
	)

Definition at line 207 of file Config.cpp.

getSingleSection()

bool ripple::getSingleSection	(	IniFileSections &	secSource,
		std::string const &	strSection,
		std::string &	strValue,
		beast::Journal	j
	)

Definition at line 220 of file Config.cpp.

getEnvVar()

static std::string ripple::getEnvVar ( char const *  name )

static

Definition at line 255 of file Config.cpp.

make_SNTPClock()

std::unique_ptr< SNTPClock > ripple::make_SNTPClock

(

beast::Journal

j

)

Definition at line 486 of file SNTPClock.cpp.

open() [1/2]

void ripple::open	(	soci::session &	s,
		BasicConfig const &	config,
		std::string const &	dbName
	)

Open a soci session.

Parameters

s	Session to open.
config	Parameters to pick the soci backend and how to connect to that backend.
dbName	Name of the database. This has different meaning for different backends. Sometimes it is part of a filename (sqlite3), other times it is a database name (postgresql).

Definition at line 98 of file SociDB.cpp.

open() [2/2]

void ripple::open	(	soci::session &	s,
		std::string const &	beName,
		std::string const &	connectionString
	)

Open a soci session.

Parameters

s	Session to open.
beName	Backend name.
connectionString	Connection string to forward to soci::open. see the soci::open documentation for how to use this.

Definition at line 104 of file SociDB.cpp.

getConnection()

static sqlite_api::sqlite3* ripple::getConnection ( soci::session &  s )

static

Definition at line 116 of file SociDB.cpp.

getKBUsedAll()

std::uint32_t ripple::getKBUsedAll

(

soci::session &

s

)

Definition at line 130 of file SociDB.cpp.

getKBUsedDB()

std::uint32_t ripple::getKBUsedDB

(

soci::session &

s

)

Definition at line 139 of file SociDB.cpp.

convert() [1/4]

void ripple::convert	(	soci::blob &	from,
		std::vector< std::uint8_t > &	to
	)

Definition at line 154 of file SociDB.cpp.

convert() [2/4]

void ripple::convert	(	soci::blob &	from,
		std::string &	to
	)

Definition at line 163 of file SociDB.cpp.

convert() [3/4]

void ripple::convert	(	std::vector< std::uint8_t > const &	from,
		soci::blob &	to
	)

Definition at line 171 of file SociDB.cpp.

convert() [4/4]

void ripple::convert	(	std::string const &	from,
		soci::blob &	to
	)

Definition at line 180 of file SociDB.cpp.

makeCheckpointer()

std::shared_ptr< Checkpointer > ripple::makeCheckpointer	(	std::uintptr_t	id,
		std::weak_ptr< soci::session >	,
		JobQueue &	,
		Logs &
	)

Returns a new checkpointer which makes checkpoints of a soci database every checkpointPageCount pages, using a job on the job queue.

The checkpointer contains references to the session and job queue and so must outlive them both.

Definition at line 333 of file SociDB.cpp.

make_TimeKeeper()

std::unique_ptr< TimeKeeper > ripple::make_TimeKeeper

(

beast::Journal

j

)

Definition at line 119 of file TimeKeeper.cpp.

crypto_prng()

csprng_engine & ripple::crypto_prng

(

)

The default cryptographically secure PRNG.

Use this when you need to generate random numbers or data that will be used for encryption or passed into cryptographic routines.

This meets the requirements of UniformRandomNumberEngine

Definition at line 108 of file csprng.cpp.

secure_erase()

void ripple::secure_erase	(	void *	dest,
		std::size_t	bytes
	)

Attempts to clear the given blob of memory.

The underlying implementation of this function takes pains to attempt to outsmart the compiler from optimizing the clearing away. Please note that, despite that, remnants of content may remain floating around in memory as well as registers, caches and more.

For a more in-depth discussion of the subject please see the below posts by Colin Percival:

http://www.daemonology.net/blog/2014-09-04-how-to-zero-a-buffer.html http://www.daemonology.net/blog/2014-09-06-zeroing-buffers-is-insufficient.html

Definition at line 26 of file secure_erase.cpp.

operator|() [2/2]

constexpr ApplyFlags ripple::operator| ( ApplyFlags const &  lhs, ApplyFlags const &  rhs  )

constexpr

Definition at line 50 of file ApplyView.h.

operator&() [2/2]

constexpr ApplyFlags ripple::operator& ( ApplyFlags const &  lhs, ApplyFlags const &  rhs  )

constexpr

Definition at line 65 of file ApplyView.h.

operator~() [1/2]

constexpr ApplyFlags ripple::operator~ ( ApplyFlags const &  flags )

constexpr

Definition at line 76 of file ApplyView.h.

operator|=()

ApplyFlags ripple::operator|=	(	ApplyFlags &	lhs,
		ApplyFlags const &	rhs
	)

Definition at line 87 of file ApplyView.h.

operator&=()

ApplyFlags ripple::operator&=	(	ApplyFlags &	lhs,
		ApplyFlags const &	rhs
	)

Definition at line 94 of file ApplyView.h.

dirFirst()

bool ripple::dirFirst	(	ApplyView &	view,
		uint256 const &	root,
		std::shared_ptr< SLE > &	page,
		unsigned int &	index,
		uint256 &	entry
	)

Definition at line 114 of file View.cpp.

dirNext()

bool ripple::dirNext	(	ApplyView &	view,
		uint256 const &	root,
		std::shared_ptr< SLE > &	page,
		unsigned int &	index,
		uint256 &	entry
	)

Definition at line 125 of file View.cpp.

cdirFirst()

bool ripple::cdirFirst	(	ReadView const &	view,
		uint256 const &	root,
		std::shared_ptr< SLE const > &	page,
		unsigned int &	index,
		uint256 &	entry
	)

Returns the first entry in the directory, advancing the index.

Parameters

view	The view against which to operate
root	The root (i.e. first page) of the directory to iterate
page	The current page
index	The index inside the current page
entry	The entry at the current index

Returns

true if the directory isn't empty; false otherwise

Definition at line 136 of file View.cpp.

cdirNext()

bool ripple::cdirNext	(	ReadView const &	view,
		uint256 const &	root,
		std::shared_ptr< SLE const > &	page,
		unsigned int &	index,
		uint256 &	entry
	)

Returns the next entry in the directory, advancing the index.

Parameters

view	The view against which to operate
root	The root (i.e. first page) of the directory to iterate
page	The current page
index	The index inside the current page
entry	The entry at the current index

Returns

true if the directory isn't empty; false otherwise

Definition at line 147 of file View.cpp.

addRaw()

void ripple::addRaw	(	LedgerInfo const &	info,
		Serializer &	s,
		bool	includeHash
	)

Definition at line 164 of file View.cpp.

isGlobalFrozen()

bool ripple::isGlobalFrozen	(	ReadView const &	view,
		AccountID const &	issuer
	)

Definition at line 181 of file View.cpp.

isFrozen()

bool ripple::isFrozen	(	ReadView const &	view,
		AccountID const &	account,
		Currency const &	currency,
		AccountID const &	issuer
	)

Definition at line 193 of file View.cpp.

accountHolds()

STAmount ripple::accountHolds	(	ReadView const &	view,
		AccountID const &	account,
		Currency const &	currency,
		AccountID const &	issuer,
		FreezeHandling	zeroIfFrozen,
		beast::Journal	j
	)

Definition at line 216 of file View.cpp.

accountFunds()

STAmount ripple::accountFunds	(	ReadView const &	view,
		AccountID const &	id,
		STAmount const &	saDefault,
		FreezeHandling	freezeHandling,
		beast::Journal	j
	)

Definition at line 260 of file View.cpp.

confineOwnerCount()

static std::uint32_t ripple::confineOwnerCount ( std::uint32_t  current, std::int32_t  adjustment, std::optional< AccountID > const &  id = std::nullopt, beast::Journal  j = beast::Journal{beast::Journal::getNullSink()}  )

static

Definition at line 301 of file View.cpp.

xrpLiquid()

XRPAmount ripple::xrpLiquid	(	ReadView const &	view,
		AccountID const &	id,
		std::int32_t	ownerCountAdj,
		beast::Journal	j
	)

Definition at line 339 of file View.cpp.

forEachItem()

void ripple::forEachItem	(	ReadView const &	view,
		AccountID const &	id,
		std::function< void(std::shared_ptr< SLE const > const &)>	f
	)

Iterate all items in an account's owner directory.

Definition at line 375 of file View.cpp.

forEachItemAfter()

bool ripple::forEachItemAfter	(	ReadView const &	view,
		AccountID const &	id,
		uint256 const &	after,
		std::uint64_t const	hint,
		unsigned int	limit,
		std::function< bool(std::shared_ptr< SLE const > const &)>	f
	)

Iterate all items after an item in an owner directory.

Parameters

after	The key of the item to start after
hint	The directory page containing after
limit	The maximum number of items to return

Returns

false if the iteration failed

Definition at line 398 of file View.cpp.

transferRate()

Rate ripple::transferRate	(	ReadView const &	view,
		AccountID const &	issuer
	)

Definition at line 471 of file View.cpp.

areCompatible() [1/2]

bool ripple::areCompatible	(	ReadView const &	validLedger,
		ReadView const &	testLedger,
		beast::Journal::Stream &	s,
		const char *	reason
	)

Return false if the test ledger is provably incompatible with the valid ledger, that is, they could not possibly both be valid.

Use the first form if you have both ledgers, use the second form if you have not acquired the valid ledger yet

Definition at line 482 of file View.cpp.

areCompatible() [2/2]

bool ripple::areCompatible	(	uint256 const &	validHash,
		LedgerIndex	validIndex,
		ReadView const &	testLedger,
		beast::Journal::Stream &	s,
		const char *	reason
	)

Definition at line 545 of file View.cpp.

dirIsEmpty()

bool ripple::dirIsEmpty	(	ReadView const &	view,
		Keylet const &	k
	)

Returns true if the directory is empty.

Parameters

key	The key of the directory

Definition at line 590 of file View.cpp.

getEnabledAmendments()

std::set< uint256 > ripple::getEnabledAmendments

(

ReadView const &

view

)

Definition at line 604 of file View.cpp.

getMajorityAmendments()

majorityAmendments_t ripple::getMajorityAmendments

(

ReadView const &

view

)

Definition at line 621 of file View.cpp.

hashOfSeq()

std::optional< uint256 > ripple::hashOfSeq	(	ReadView const &	ledger,
		LedgerIndex	seq,
		beast::Journal	journal
	)

Return the hash of a ledger by sequence.

The hash is retrieved by looking up the "skip list" in the passed ledger. As the skip list is limited in size, if the requested ledger sequence number is out of the range of ledgers represented in the skip list, then std::nullopt is returned.

Returns

The hash of the ledger with the given sequence number or std::nullopt.

Definition at line 644 of file View.cpp.

adjustOwnerCount()

void ripple::adjustOwnerCount	(	ApplyView &	view,
		std::shared_ptr< SLE > const &	sle,
		std::int32_t	amount,
		beast::Journal	j
	)

Adjust the owner count up or down.

Definition at line 713 of file View.cpp.

describeOwnerDir()

std::function< void(SLE::ref)> ripple::describeOwnerDir

(

AccountID const &

account

)

Definition at line 731 of file View.cpp.

trustCreate()

TER ripple::trustCreate	(	ApplyView &	view,
		const bool	bSrcHigh,
		AccountID const &	uSrcAccountID,
		AccountID const &	uDstAccountID,
		uint256 const &	uIndex,
		SLE::ref	sleAccount,
		const bool	bAuth,
		const bool	bNoRipple,
		const bool	bFreeze,
		STAmount const &	saBalance,
		STAmount const &	saLimit,
		std::uint32_t	uSrcQualityIn,
		std::uint32_t	uSrcQualityOut,
		beast::Journal	j
	)

Create a trust line.

This can set an initial balance.

Definition at line 739 of file View.cpp.

trustDelete()

TER ripple::trustDelete	(	ApplyView &	view,
		std::shared_ptr< SLE > const &	sleRippleState,
		AccountID const &	uLowAccountID,
		AccountID const &	uHighAccountID,
		beast::Journal	j
	)

Definition at line 853 of file View.cpp.

offerDelete()

TER ripple::offerDelete	(	ApplyView &	view,
		std::shared_ptr< SLE > const &	sle,
		beast::Journal	j
	)

Delete an offer.

Requirements: The passed sle be obtained from a prior call to view.peek()

Definition at line 893 of file View.cpp.

rippleCredit()

TER ripple::rippleCredit	(	ApplyView &	view,
		AccountID const &	uSenderID,
		AccountID const &	uReceiverID,
		STAmount const &	saAmount,
		bool	bCheckIssuer,
		beast::Journal	j
	)

Definition at line 933 of file View.cpp.

rippleSend()

static TER ripple::rippleSend ( ApplyView &  view, AccountID const &  uSenderID, AccountID const &  uReceiverID, STAmount const &  saAmount, STAmount &  saActual, beast::Journal  j  )

static

Definition at line 1078 of file View.cpp.

accountSend()

TER ripple::accountSend	(	ApplyView &	view,
		AccountID const &	uSenderID,
		AccountID const &	uReceiverID,
		STAmount const &	saAmount,
		beast::Journal	j
	)

Definition at line 1122 of file View.cpp.

updateTrustLine()

static bool ripple::updateTrustLine ( ApplyView &  view, SLE::pointer  state, bool  bSenderHigh, AccountID const &  sender, STAmount const &  before, STAmount const &  after, beast::Journal  j  )

static

Definition at line 1228 of file View.cpp.

issueIOU()

TER ripple::issueIOU	(	ApplyView &	view,
		AccountID const &	account,
		STAmount const &	amount,
		Issue const &	issue,
		beast::Journal	j
	)

Definition at line 1281 of file View.cpp.

redeemIOU()

TER ripple::redeemIOU	(	ApplyView &	view,
		AccountID const &	account,
		STAmount const &	amount,
		Issue const &	issue,
		beast::Journal	j
	)

Definition at line 1377 of file View.cpp.

transferXRP()

TER ripple::transferXRP	(	ApplyView &	view,
		AccountID const &	from,
		AccountID const &	to,
		STAmount const &	amount,
		beast::Journal	j
	)

Definition at line 1447 of file View.cpp.

getCloseAgree()

bool ripple::getCloseAgree

(

LedgerInfo const &

info

)

Definition at line 418 of file ReadView.h.

getCandidateLedger()

LedgerIndex ripple::getCandidateLedger

(

LedgerIndex

requested

)

Find a ledger index from which we could easily get the requested ledger.

The index that we return should meet two requirements: 1) It must be the index of a ledger that has the hash of the ledger we are looking for. This means that its sequence must be equal to greater than the sequence that we want but not more than 256 greater since each ledger contains the hashes of the 256 previous ledgers.

2) Its hash must be easy for us to find. This means it must be 0 mod 256 because every such ledger is permanently enshrined in a LedgerHashes page which we can easily retrieve via the skip list.

Definition at line 162 of file View.h.

make_DatabaseDownloader()

std::shared_ptr< DatabaseDownloader > ripple::make_DatabaseDownloader	(	boost::asio::io_service &	io_service,
		Config const &	config,
		beast::Journal	j
	)

Definition at line 25 of file DatabaseDownloader.cpp.

registerSSLCerts()

void ripple::registerSSLCerts	(	boost::asio::ssl::context &	,
		boost::system::error_code &	,
		beast::Journal	j
	)

Register default SSL certificates.

Register the system default SSL root certificates. On linux/mac, this just calls asio's set_default_verify_paths to look in standard operating system locations. On windows, it uses the OS certificate store accessible via CryptoAPI.

Definition at line 35 of file RegisterSSLCerts.cpp.

createHTTPPost()

std::string ripple::createHTTPPost	(	std::string const &	strHost,
		std::string const &	strPath,
		std::string const &	strMsg,
		std::unordered_map< std::string, std::string > const &	mapRequestHeaders
	)

Definition at line 64 of file RPCCall.cpp.

JSONRPCRequest()

std::string ripple::JSONRPCRequest	(	std::string const &	strMethod,
		Json::Value const &	params,
		Json::Value const &	id
	)

Definition at line 1354 of file RPCCall.cpp.

rpcCmdLineToJson()

static Json::Value ripple::rpcCmdLineToJson ( std::vector< std::string > const &  args, Json::Value &  retParams, beast::Journal  j  )

static

Definition at line 1462 of file RPCCall.cpp.

cmdLineToJSONRPC()

Json::Value ripple::cmdLineToJSONRPC	(	std::vector< std::string > const &	args,
		beast::Journal	j
	)

Given a rippled command line, return the corresponding JSON.

Definition at line 1500 of file RPCCall.cpp.

rpcClient()

std::pair< int, Json::Value > ripple::rpcClient	(	std::vector< std::string > const &	args,
		Config const &	config,
		Logs &	logs,
		std::unordered_map< std::string, std::string > const &	headers
	)

Internal invocation of RPC client.

Definition at line 1531 of file RPCCall.cpp.

rpcError()

Json::Value ripple::rpcError	(	int	iError,
		Json::Value	jvResult
	)

Definition at line 29 of file RPCErr.cpp.

isRpcError()

bool ripple::isRpcError

(

Json::Value

jvResult

)

Definition at line 37 of file RPCErr.cpp.

make_RPCSub()

std::shared_ptr< RPCSub > ripple::make_RPCSub	(	InfoSub::Source &	source,
		boost::asio::io_service &	io_service,
		JobQueue &	jobQueue,
		std::string const &	strUrl,
		std::string const &	strUsername,
		std::string const &	strPassword,
		Logs &	logs
	)

Definition at line 213 of file RPCSub.cpp.

getFeatureValue()

std::optional< std::string > ripple::getFeatureValue	(	boost::beast::http::fields const &	headers,
		std::string const &	feature
	)

Get feature's header value.

Parameters

headers	request/response header
feature	name

Returns

seated optional with feature's value if the feature is found in the header, unseated optional otherwise

Definition at line 38 of file Handshake.cpp.

isFeatureValue()

bool ripple::isFeatureValue	(	boost::beast::http::fields const &	headers,
		std::string const &	feature,
		std::string const &	value
	)

Check if a feature's value is equal to the specified value.

Parameters

headers	request/response header
feature	to check
value	of the feature to check, must be a single value; i.e. not value1,value2...

Returns

true if the feature's value matches the specified value, false if doesn't match or the feature is not found in the header

Definition at line 54 of file Handshake.cpp.

featureEnabled()

bool ripple::featureEnabled	(	boost::beast::http::fields const &	headers,
		std::string const &	feature
	)

Check if a feature is enabled.

Parameters

headers	request/response header
feature	to check

Returns

true if enabled

Definition at line 66 of file Handshake.cpp.

makeFeaturesRequestHeader()

std::string ripple::makeFeaturesRequestHeader	(	bool	comprEnabled,
		bool	ledgerReplayEnabled,
		bool	txReduceRelayEnabled,
		bool	vpReduceRelayEnabled
	)

Make request header X-Protocol-Ctl value with supported features.

Parameters

comprEnabled	if true then compression feature is enabled
ledgerReplayEnabled	if true then ledger-replay feature is enabled
txReduceRelayEnabled	if true then transaction reduce-relay feature is enabled
vpReduceRelayEnabled	if true then validation/proposal reduce-relay feature is enabled

Returns

X-Protocol-Ctl header value

Definition at line 74 of file Handshake.cpp.

makeFeaturesResponseHeader()

std::string ripple::makeFeaturesResponseHeader	(	http_request_type const &	headers,
		bool	comprEnabled,
		bool	ledgerReplayEnabled,
		bool	txReduceRelayEnabled,
		bool	vpReduceRelayEnabled
	)

Make response header X-Protocol-Ctl value with supported features.

If the request has a feature that we support enabled and the feature's configuration is enabled then enable this feature in the response header.

Parameters

header	request's header
comprEnabled	if true then compression feature is enabled
ledgerReplayEnabled	if true then ledger-replay feature is enabled
txReduceRelayEnabled	if true then transaction reduce-relay feature is enabled
vpReduceRelayEnabled	if true then validation/proposal reduce-relay feature is enabled
vpReduceRelayEnabled	if true then reduce-relay feature is enabled

Returns

X-Protocol-Ctl header value

Definition at line 93 of file Handshake.cpp.

hashLastMessage()

static std::optional<base_uint<512> > ripple::hashLastMessage ( SSL const *  ssl, size_t(*)(const SSL *, void *, size_t)  get  )

static

Hashes the latest finished message from an SSL stream.

Parameters

ssl	the session to get the message from.
get	a pointer to the function to call to retrieve the finished message. This can be either: SSL_get_finished or SSL_get_peer_finished.

Returns

true if successful, false otherwise.

Note

This construct is non-standard. There are potential "standard" alternatives that should be considered. For a discussion, on this topic, see https://github.com/openssl/openssl/issues/5509 and https://github.com/ripple/rippled/issues/2413.

Definition at line 127 of file Handshake.cpp.

makeSharedValue()

std::optional< uint256 > ripple::makeSharedValue	(	stream_type &	ssl,
		beast::Journal	journal
	)

Computes a shared value based on the SSL connection state.

When there is no man in the middle, both sides will compute the same value. In the presence of an attacker, the computed values will be different.

Parameters

ssl	the SSL/TLS connection state.

Returns

A 256-bit value on success; an unseated optional otherwise.

Definition at line 145 of file Handshake.cpp.

buildHandshake()

void ripple::buildHandshake	(	boost::beast::http::fields &	h,
		ripple::uint256 const &	sharedValue,
		std::optional< std::uint32_t >	networkID,
		beast::IP::Address	public_ip,
		beast::IP::Address	remote_ip,
		Application &	app
	)

Insert fields headers necessary for upgrading the link to the peer protocol.

Definition at line 177 of file Handshake.cpp.

verifyHandshake()

PublicKey ripple::verifyHandshake	(	boost::beast::http::fields const &	headers,
		uint256 const &	sharedValue,
		std::optional< std::uint32_t >	networkID,
		beast::IP::Address	public_ip,
		beast::IP::Address	remote,
		Application &	app
	)

Validate header fields necessary for upgrading the link to the peer protocol.

This performs critical security checks that ensure that prevent MITM attacks on our peer-to-peer links and that the remote peer has the private keys that correspond to the public identity it claims.

Returns

The public key of the remote peer.

Exceptions

A	class derived from std::exception.

Definition at line 230 of file Handshake.cpp.

makeRequest()

request_type ripple::makeRequest	(	bool	crawlPublic,
		bool	comprEnabled,
		bool	ledgerReplayEnabled,
		bool	txReduceRelayEnabled,
		bool	vpReduceRelayEnabled
	)

Make outbound http request.

Parameters

crawlPublic	if true then server's IP/Port are included in crawl
comprEnabled	if true then compression feature is enabled
ledgerReplayEnabled	if true then ledger-replay feature is enabled
txReduceRelayEnabled	if true then transaction reduce-relay feature is enabled
vpReduceRelayEnabled	if true then validation/proposal reduce-relay feature is enabled

Returns

http request with empty body

Definition at line 369 of file Handshake.cpp.

makeResponse()

http_response_type ripple::makeResponse	(	bool	crawlPublic,
		http_request_type const &	req,
		beast::IP::Address	public_ip,
		beast::IP::Address	remote_ip,
		uint256 const &	sharedValue,
		std::optional< std::uint32_t >	networkID,
		ProtocolVersion	version,
		Application &	app
	)

Make http response.

Parameters

crawlPublic	if true then server's IP/Port are included in crawl
req	incoming http request
public_ip	server's public IP
remote_ip	peer's IP
sharedValue	shared value based on the SSL connection state
networkID	specifies what network we intend to connect to
version	supported protocol version
app	Application's reference to access some common properties

Returns

http response

Definition at line 396 of file Handshake.cpp.

peerFeatureEnabled() [1/2]

template<typename headers >

bool ripple::peerFeatureEnabled	(	headers const &	request,
		std::string const &	feature,
		std::string	value,
		bool	config
	)

Check if a feature should be enabled for a peer.

The feature is enabled if its configured value is true and the http header has the specified feature value.

Template Parameters

headers

request (inbound) or response (outbound) header

Parameters

request	http headers
feature	to check
config	feature's configuration value
value	feature's value to check in the headers

Returns

true if the feature is enabled

Definition at line 199 of file Handshake.h.

peerFeatureEnabled() [2/2]

template<typename headers >

bool ripple::peerFeatureEnabled	(	headers const &	request,
		std::string const &	feature,
		bool	config
	)

Wrapper for enable(1)/disable type(0) of feature.

Definition at line 211 of file Handshake.h.

makeSquelchMessage()

std::shared_ptr<Message> ripple::makeSquelchMessage	(	PublicKey const &	validator,
		bool	squelch,
		uint32_t	squelchDuration
	)

Definition at line 1445 of file OverlayImpl.cpp.

setup_Overlay() [1/2]

Overlay::Setup ripple::setup_Overlay

(

BasicConfig const &

config

)

Definition at line 1537 of file OverlayImpl.cpp.

make_Overlay()

std::unique_ptr< Overlay > ripple::make_Overlay	(	Application &	app,
		Overlay::Setup const &	setup,
		ServerHandler &	serverHandler,
		Resource::Manager &	resourceManager,
		Resolver &	resolver,
		boost::asio::io_service &	io_service,
		BasicConfig const &	config,
		beast::insight::Collector::ptr const &	collector
	)

Creates the implementation of Overlay.

Definition at line 1642 of file OverlayImpl.cpp.

stringIsUint256Sized()

static bool ripple::stringIsUint256Sized ( std::string const &  pBuffStr )

static

Definition at line 151 of file PeerImp.cpp.

getPeerWithTree()

static std::shared_ptr<PeerImp> ripple::getPeerWithTree ( OverlayImpl &  ov, uint256 const &  rootHash, PeerImp const *  skip  )

static

Definition at line 3175 of file PeerImp.cpp.

getPeerWithLedger()

static std::shared_ptr<PeerImp> ripple::getPeerWithLedger ( OverlayImpl &  ov, uint256 const &  ledgerHash, LedgerIndex  ledger, PeerImp const *  skip  )

static

Definition at line 3199 of file PeerImp.cpp.

make_PeerSetBuilder()

std::unique_ptr< PeerSetBuilder > ripple::make_PeerSetBuilder

(

Application &

app

)

Definition at line 144 of file PeerSet.cpp.

make_DummyPeerSet()

std::unique_ptr< PeerSet > ripple::make_DummyPeerSet

(

Application &

app

)

Make a dummy PeerSet that does not do anything.

Note

For the use case of InboundLedger in ApplicationImp::loadOldLedger(), where a real PeerSet is not needed.

Definition at line 187 of file PeerSet.cpp.

protocolMessageType() [1/3]

protocol::MessageType ripple::protocolMessageType

(

protocol::TMGetLedger const &

)

Definition at line 42 of file ProtocolMessage.h.

protocolMessageType() [2/3]

protocol::MessageType ripple::protocolMessageType

(

protocol::TMReplayDeltaRequest const &

)

Definition at line 48 of file ProtocolMessage.h.

protocolMessageType() [3/3]

protocol::MessageType ripple::protocolMessageType

(

protocol::TMProofPathRequest const &

)

Definition at line 54 of file ProtocolMessage.h.

protocolMessageName()

template<class = void>

std::string ripple::protocolMessageName

(

int

type

)

Returns the name of a protocol message given its type.

Definition at line 62 of file ProtocolMessage.h.

invokeProtocolMessage()

template<class Buffers , class Handler >

std::pair<std::size_t, boost::system::error_code> ripple::invokeProtocolMessage	(	Buffers const &	buffers,
		Handler &	handler,
		std::size_t &	hint
	)

Calls the handler for up to one protocol message in the passed buffers.

If there is insufficient data to produce a complete protocol message, zero is returned for the number of bytes consumed.

Parameters

buffers	The buffer that contains the data we've received
handler	The handler that will be used to process the message
hint	If possible, a hint as to the amount of data to read next. The returned value MAY be zero, which means "no hint"

Returns

The number of bytes consumed, or the error code if any.

Definition at line 343 of file ProtocolMessage.h.

to_string() [20/26]

std::string ripple::to_string

(

ProtocolVersion const &

p

)

Print a protocol version a human-readable string.

Definition at line 73 of file ProtocolVersion.cpp.

parseProtocolVersions()

std::vector< ProtocolVersion > ripple::parseProtocolVersions

(

boost::beast::string_view const &

s

)

Parse a set of protocol versions.

Given a comma-separated string, extract and return all those that look like valid protocol versions (i.e. XRPL/2.0 and later). Strings that are not parseable as valid protocol strings are excluded from the result set.

Returns

A list of all apparently valid protocol versions.

Note

The returned list of protocol versions is guaranteed to contain no duplicates and will be sorted in ascending protocol order.

Definition at line 79 of file ProtocolVersion.cpp.

negotiateProtocolVersion() [1/2]

std::optional< ProtocolVersion > ripple::negotiateProtocolVersion

(

std::vector< ProtocolVersion > const &

versions

)

Given a list of supported protocol versions, choose the one we prefer.

Definition at line 126 of file ProtocolVersion.cpp.

negotiateProtocolVersion() [2/2]

std::optional< ProtocolVersion > ripple::negotiateProtocolVersion

(

boost::beast::string_view const &

versions

)

Given a list of supported protocol versions, choose the one we prefer.

Definition at line 149 of file ProtocolVersion.cpp.

supportedProtocolVersions()

std::string const & ripple::supportedProtocolVersions

(

)

The list of all the protocol versions we support.

Definition at line 157 of file ProtocolVersion.cpp.

isProtocolSupported()

bool ripple::isProtocolSupported

(

ProtocolVersion const &

v

)

Determine whether we support a specific protocol version.

Definition at line 175 of file ProtocolVersion.cpp.

make_protocol()

constexpr ProtocolVersion ripple::make_protocol ( std::uint16_t  major, std::uint16_t  minor  )

constexpr

Definition at line 40 of file ProtocolVersion.h.

send_if()

template<typename Predicate >

send_if_pred<Predicate> ripple::send_if	(	std::shared_ptr< Message > const &	m,
		Predicate const &	f
	)

Helper function to aid in type deduction.

Definition at line 75 of file predicates.h.

send_if_not()

template<typename Predicate >

send_if_not_pred<Predicate> ripple::send_if_not	(	std::shared_ptr< Message > const &	m,
		Predicate const &	f
	)

Helper function to aid in type deduction.

Definition at line 107 of file predicates.h.

toBase58() [1/4]

std::string ripple::toBase58

(

AccountID const &

v

)

Convert AccountID to base58 checked string.

Definition at line 29 of file AccountID.cpp.

parseBase58() [1/2]

template<>

std::optional< Seed > ripple::parseBase58

(

std::string const &

s

)

Parse AccountID from checked, base58 string.

Parse a Base58 encoded string into a seed.

Returns

std::nullopt if a parse error occurs

Definition at line 36 of file AccountID.cpp.

xrpAccount()

AccountID const & ripple::xrpAccount

(

)

Compute AccountID from public key.

The account ID is computed as the 160-bit hash of the public key data. This excludes the version byte and guard bytes included in the base58 representation. A special account that's used as the "issuer" for XRP.

Definition at line 90 of file AccountID.cpp.

noAccount()

AccountID const & ripple::noAccount

(

)

A placeholder for empty accounts.

Definition at line 97 of file AccountID.cpp.

to_issuer()

bool ripple::to_issuer	(	AccountID &	issuer,
		std::string const &	s
	)

Convert hex or base58 string to AccountID.

Returns

true if the parsing was successful.

Definition at line 104 of file AccountID.cpp.

isXRP() [1/2]

bool ripple::isXRP

(

AccountID const &

c

)

Definition at line 89 of file AccountID.h.

to_string() [21/26]

std::string ripple::to_string

(

AccountID const &

account

)

Returns "", "XRP", or three letter ISO code.

Definition at line 96 of file AccountID.h.

operator<<() [7/15]

std::ostream& ripple::operator<<	(	std::ostream &	os,
		AccountID const &	x
	)

Definition at line 103 of file AccountID.h.

toSTAmount() [1/5]

STAmount ripple::toSTAmount	(	IOUAmount const &	iou,
		Issue const &	iss
	)

Definition at line 30 of file AmountConversions.h.

toSTAmount() [2/5]

STAmount ripple::toSTAmount

(

IOUAmount const &

iou

)

Definition at line 44 of file AmountConversions.h.

toSTAmount() [3/5]

STAmount ripple::toSTAmount

(

XRPAmount const &

xrp

)

Definition at line 50 of file AmountConversions.h.

toSTAmount() [4/5]

STAmount ripple::toSTAmount	(	XRPAmount const &	xrp,
		Issue const &	iss
	)

Definition at line 58 of file AmountConversions.h.

toAmount() [1/3]

template<class T >

T ripple::toAmount ( STAmount const &  amt )

delete

toAmount< STAmount >()

template<>

STAmount ripple::toAmount< STAmount >

(

STAmount const &

amt

)

Definition at line 70 of file AmountConversions.h.

toAmount< IOUAmount >() [1/2]

template<>

IOUAmount ripple::toAmount< IOUAmount >

(

STAmount const &

amt

)

Definition at line 77 of file AmountConversions.h.

toAmount< XRPAmount >() [1/2]

template<>

XRPAmount ripple::toAmount< XRPAmount >

(

STAmount const &

amt

)

Definition at line 90 of file AmountConversions.h.

toAmount() [2/3]

template<class T >

T ripple::toAmount ( IOUAmount const &  amt )

delete

toAmount< IOUAmount >() [2/2]

template<>

IOUAmount ripple::toAmount< IOUAmount >

(

IOUAmount const &

amt

)

Definition at line 107 of file AmountConversions.h.

toAmount() [3/3]

template<class T >

T ripple::toAmount ( XRPAmount const &  amt )

delete

toAmount< XRPAmount >() [2/2]

template<>

XRPAmount ripple::toAmount< XRPAmount >

(

XRPAmount const &

amt

)

Definition at line 118 of file AmountConversions.h.

isConsistent() [1/2]

bool ripple::isConsistent

(

Book const &

book

)

Definition at line 25 of file Book.cpp.

to_string() [22/26]

std::string ripple::to_string

(

Book const &

book

)

Definition at line 32 of file Book.cpp.

operator<<() [8/15]

std::ostream & ripple::operator<<	(	std::ostream &	os,
		Book const &	x
	)

Definition at line 38 of file Book.cpp.

hash_append() [5/8]

template<class Hasher >

void ripple::hash_append	(	Hasher &	h,
		Book const &	b
	)

Definition at line 58 of file Book.h.

reversed()

Book ripple::reversed

(

Book const &

book

)

Definition at line 45 of file Book.cpp.

compare() [2/3]

int ripple::compare	(	Book const &	lhs,
		Book const &	rhs
	)

Ordered comparison.

Definition at line 52 of file Book.cpp.

operator==() [8/15]

bool ripple::operator==	(	Book const &	lhs,
		Book const &	rhs
	)

Equality comparison.

Definition at line 63 of file Book.cpp.

operator!=() [6/12]

bool ripple::operator!=	(	Book const &	lhs,
		Book const &	rhs
	)

Definition at line 69 of file Book.cpp.

operator<() [4/10]

bool ripple::operator<	(	Book const &	lhs,
		Book const &	rhs
	)

Strict weak ordering.

Definition at line 78 of file Book.cpp.

operator>() [2/5]

bool ripple::operator>	(	Book const &	lhs,
		Book const &	rhs
	)

Definition at line 87 of file Book.cpp.

operator>=() [2/5]

bool ripple::operator>=	(	Book const &	lhs,
		Book const &	rhs
	)

Definition at line 93 of file Book.cpp.

operator<=() [2/5]

bool ripple::operator<=	(	Book const &	lhs,
		Book const &	rhs
	)

Definition at line 99 of file Book.cpp.

sha512Half()

template<class... Args>

sha512_half_hasher::result_type ripple::sha512Half

(

Args const &...

args

)

Returns the SHA512-Half of a series of objects.

Definition at line 216 of file digest.h.

sha512Half_s()

template<class... Args>

sha512_half_hasher_s::result_type ripple::sha512Half_s

(

Args const &...

args

)

Returns the SHA512-Half of a series of objects.

Postconditions: Temporary memory storing copies of input messages will be cleared.

Definition at line 232 of file digest.h.

rpcErrorString()

std::string ripple::rpcErrorString

(

Json::Value const &

jv

)

Returns a single string with the contents of an RPC error.

Definition at line 235 of file ErrorCodes.cpp.

getRegisteredFeature()

std::optional< uint256 > ripple::getRegisteredFeature

(

std::string const &

name

)

Definition at line 336 of file Feature.cpp.

featureToBitsetIndex()

size_t ripple::featureToBitsetIndex

(

uint256 const &

f

)

Definition at line 363 of file Feature.cpp.

bitsetIndexToFeature()

uint256 ripple::bitsetIndexToFeature

(

size_t

i

)

Definition at line 369 of file Feature.cpp.

featureToName()

std::string ripple::featureToName

(

uint256 const &

f

)

Definition at line 375 of file Feature.cpp.

foreachFeature()

template<class F >

void ripple::foreachFeature	(	FeatureBitset	bs,
		F &&	f
	)

Definition at line 299 of file Feature.h.

hash_append() [6/8]

template<class Hasher >

void ripple::hash_append ( Hasher &  h, HashPrefix const &  hp  )

noexcept

Definition at line 94 of file HashPrefix.h.

calcAccountID()

AccountID ripple::calcAccountID

(

PublicKey const &

pk

)

Definition at line 80 of file AccountID.cpp.

hash_value()

std::size_t ripple::hash_value

(

ripple::uint256 const &

feature

)

Definition at line 35 of file Feature.cpp.

registerFeature()

uint256 ripple::registerFeature	(	std::string const &	name,
		Supported	support,
		DefaultVote	vote
	)

Definition at line 342 of file Feature.cpp.

retireFeature()

uint256 ripple::retireFeature

(

std::string const &

name

)

Definition at line 350 of file Feature.cpp.

registrationIsDone()

bool ripple::registrationIsDone

(

)

Tell FeatureCollections when registration is complete.

Definition at line 357 of file Feature.cpp.

REGISTER_FEATURE() [1/15]

ripple::REGISTER_FEATURE	(	OwnerPaysFee	,
		Supported::no	,
		DefaultVote::no
	)

REGISTER_FEATURE() [2/15]

ripple::REGISTER_FEATURE	(	Flow	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FEATURE() [3/15]

ripple::REGISTER_FEATURE	(	FlowCross	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FEATURE() [4/15]

ripple::REGISTER_FEATURE	(	CryptoConditionsSuite	,
		Supported::yes	,
		DefaultVote::no
	)

REGISTER_FIX() [1/15]

ripple::REGISTER_FIX	(	fix1513	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FEATURE() [5/15]

ripple::REGISTER_FEATURE	(	DepositAuth	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FEATURE() [6/15]

ripple::REGISTER_FEATURE	(	Checks	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FIX() [2/15]

ripple::REGISTER_FIX	(	fix1571	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FIX() [3/15]

ripple::REGISTER_FIX	(	fix1543	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FIX() [4/15]

ripple::REGISTER_FIX	(	fix1623	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FEATURE() [7/15]

ripple::REGISTER_FEATURE	(	DepositPreauth	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FIX() [5/15]

ripple::REGISTER_FIX	(	fix1515	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FIX() [6/15]

ripple::REGISTER_FIX	(	fix1578	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FEATURE() [8/15]

ripple::REGISTER_FEATURE	(	MultiSignReserve	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FIX() [7/15]

ripple::REGISTER_FIX	(	fixTakerDryOfferRemoval	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FIX() [8/15]

ripple::REGISTER_FIX	(	fixMasterKeyAsRegularKey	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FIX() [9/15]

ripple::REGISTER_FIX	(	fixCheckThreading	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FIX() [10/15]

ripple::REGISTER_FIX	(	fixPayChanRecipientOwnerDir	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FEATURE() [9/15]

ripple::REGISTER_FEATURE	(	DeletableAccounts	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FIX() [11/15]

ripple::REGISTER_FIX	(	fixQualityUpperBound	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FEATURE() [10/15]

ripple::REGISTER_FEATURE	(	RequireFullyCanonicalSig	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FIX() [12/15]

ripple::REGISTER_FIX	(	fix1781	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FEATURE() [11/15]

ripple::REGISTER_FEATURE	(	HardenedValidations	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FIX() [13/15]

ripple::REGISTER_FIX	(	fixAmendmentMajorityCalc	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FEATURE() [12/15]

ripple::REGISTER_FEATURE	(	NegativeUNL	,
		Supported::yes	,
		DefaultVote::no
	)

REGISTER_FEATURE() [13/15]

ripple::REGISTER_FEATURE	(	TicketBatch	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FEATURE() [14/15]

ripple::REGISTER_FEATURE	(	FlowSortStrands	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FIX() [14/15]

ripple::REGISTER_FIX	(	fixSTAmountCanonicalize	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FIX() [15/15]

ripple::REGISTER_FIX	(	fixRmSmallIncreasedQOffers	,
		Supported::yes	,
		DefaultVote::yes
	)

REGISTER_FEATURE() [15/15]

ripple::REGISTER_FEATURE	(	CheckCashMakesTrustLine	,
		Supported::yes	,
		DefaultVote::no
	)

indexHash()

template<class... Args>

static uint256 ripple::indexHash ( LedgerNameSpace  space, Args const &...  args  )

static

Definition at line 73 of file Indexes.cpp.

getBookBase()

uint256 ripple::getBookBase

(

Book const &

book

)

Definition at line 79 of file Indexes.cpp.

getQualityNext()

uint256 ripple::getQualityNext

(

uint256 const &

uBase

)

Definition at line 97 of file Indexes.cpp.

getQuality()

std::uint64_t ripple::getQuality

(

uint256 const &

uBase

)

Definition at line 105 of file Indexes.cpp.

getTicketIndex() [1/2]

uint256 ripple::getTicketIndex	(	AccountID const &	account,
		std::uint32_t	ticketSeq
	)

Definition at line 112 of file Indexes.cpp.

getTicketIndex() [2/2]

uint256 ripple::getTicketIndex	(	AccountID const &	account,
		SeqProxy	ticketSeq
	)

Definition at line 119 of file Indexes.cpp.

isConsistent() [2/2]

bool ripple::isConsistent

(

Issue const &

ac

)

Definition at line 25 of file Issue.cpp.

to_string() [23/26]

std::string ripple::to_string

(

Issue const &

ac

)

Definition at line 31 of file Issue.cpp.

operator<<() [9/15]

std::ostream & ripple::operator<<	(	std::ostream &	os,
		Issue const &	x
	)

Definition at line 40 of file Issue.cpp.

compare() [3/3]

int ripple::compare	(	Issue const &	lhs,
		Issue const &	rhs
	)

Ordered comparison.

The assets are ordered first by currency and then by account, if the currency is not XRP.

Definition at line 51 of file Issue.cpp.

operator==() [9/15]

bool ripple::operator==	(	Issue const &	lhs,
		Issue const &	rhs
	)

Equality comparison.

Definition at line 64 of file Issue.cpp.

operator!=() [7/12]

bool ripple::operator!=	(	Issue const &	lhs,
		Issue const &	rhs
	)

Definition at line 70 of file Issue.cpp.

operator<() [5/10]

bool ripple::operator<	(	Issue const &	lhs,
		Issue const &	rhs
	)

Strict weak ordering.

Definition at line 79 of file Issue.cpp.

operator>() [3/5]

bool ripple::operator>	(	Issue const &	lhs,
		Issue const &	rhs
	)

Definition at line 85 of file Issue.cpp.

operator>=() [3/5]

bool ripple::operator>=	(	Issue const &	lhs,
		Issue const &	rhs
	)

Definition at line 91 of file Issue.cpp.

operator<=() [3/5]

bool ripple::operator<=	(	Issue const &	lhs,
		Issue const &	rhs
	)

Definition at line 97 of file Issue.cpp.

operator<<() [10/15]

std::ostream & ripple::operator<<	(	std::ostream &	os,
		PublicKey const &	pk
	)

Print the public key to a stream.

Definition at line 32 of file PublicKey.cpp.

parseBase58() [2/2]

template<>

std::optional< SecretKey > ripple::parseBase58	(	TokenType	type,
		std::string const &	s
	)

Parse a secret key.

Definition at line 40 of file PublicKey.cpp.

sigPart()

static std::optional<Slice> ripple::sigPart ( Slice &  buf )

static

Definition at line 54 of file PublicKey.cpp.

sliceToHex()

static std::string ripple::sliceToHex ( Slice const &  slice )

static

Definition at line 80 of file PublicKey.cpp.

ecdsaCanonicality()

std::optional< ECDSACanonicality > ripple::ecdsaCanonicality

(

Slice const &

sig

)

Determine whether a signature is canonical.

Determines the canonicality of a signature.

Canonical signatures are important to protect against signature morphing attacks.

Parameters

vSig	the signature data
sigLen	the length of the signature
strict_param	whether to enforce strictly canonical semantics

Note

For more details please see: https://xrpl.org/transaction-malleability.html https://bitcointalk.org/index.php?topic=8392.msg127623#msg127623 https://github.com/sipa/bitcoin/commit/58bc86e37fda1aec270bccb3df6c20fbd2a6591c

A canonical signature is in its most reduced form. For example the R and S components do not contain additional leading zeroes. However, even in canonical form, (R,S) and (R,G-S) are both valid signatures for message M.

Therefore, to prevent malleability attacks we define a fully canonical signature as one where:

R < G - S

where G is the curve order.

This routine returns std::nullopt if the format of the signature is invalid (for example, the points are encoded incorrectly).

Returns

std::nullopt if the signature fails validity checks.

Note

Only the format of the signature is checked, no verification cryptography is performed.

Definition at line 114 of file PublicKey.cpp.

ed25519Canonical()

static bool ripple::ed25519Canonical ( Slice const &  sig )

static

Definition at line 156 of file PublicKey.cpp.

publicKeyType() [1/2]

std::optional< KeyType > ripple::publicKeyType

(

Slice const &

slice

)

Returns the type of public key.

Returns

std::nullopt If the public key does not represent a known type.

Definition at line 203 of file PublicKey.cpp.

verifyDigest()

bool ripple::verifyDigest ( PublicKey const &  publicKey, uint256 const &  digest, Slice const &  sig, bool  mustBeFullyCanonical  )

noexcept

Verify a secp256k1 signature on the digest of a message.

Definition at line 218 of file PublicKey.cpp.

verify() [1/2]

bool ripple::verify ( PublicKey const &  publicKey, Slice const &  m, Slice const &  sig, bool  mustBeFullyCanonical = true  )

noexcept

Verify a signature on a message.

With secp256k1 signatures, the data is first hashed with SHA512-Half, and the resulting digest is signed.

Definition at line 268 of file PublicKey.cpp.

calcNodeID()

NodeID ripple::calcNodeID

(

PublicKey const &

pk

)

Calculate the 160-bit node ID from a node public key.

Definition at line 299 of file PublicKey.cpp.

composed_quality()

Quality ripple::composed_quality	(	Quality const &	lhs,
		Quality const &	rhs
	)

Definition at line 101 of file Quality.cpp.

multiply() [1/2]

STAmount ripple::multiply	(	STAmount const &	amount,
		Rate const &	rate
	)

Definition at line 38 of file Rate2.cpp.

multiplyRound() [1/2]

STAmount ripple::multiplyRound	(	STAmount const &	amount,
		Rate const &	rate,
		bool	roundUp
	)

Definition at line 49 of file Rate2.cpp.

multiplyRound() [2/2]

STAmount ripple::multiplyRound	(	STAmount const &	amount,
		Rate const &	rate,
		Issue const &	issue,
		bool	roundUp
	)

Definition at line 60 of file Rate2.cpp.

divide() [1/2]

STAmount ripple::divide	(	STAmount const &	amount,
		Rate const &	rate
	)

Definition at line 77 of file Rate2.cpp.

divideRound() [1/2]

STAmount ripple::divideRound	(	STAmount const &	amount,
		Rate const &	rate,
		bool	roundUp
	)

Definition at line 88 of file Rate2.cpp.

divideRound() [2/2]

STAmount ripple::divideRound	(	STAmount const &	amount,
		Rate const &	rate,
		Issue const &	issue,
		bool	roundUp
	)

Definition at line 99 of file Rate2.cpp.

secp256k1Context()

template<class = void>

secp256k1_context const* ripple::secp256k1Context

(

)

Definition at line 29 of file secp256k1.h.

signDigest() [1/2]

Buffer ripple::signDigest	(	PublicKey const &	pk,
		SecretKey const &	sk,
		uint256 const &	digest
	)

Generate a signature for a message digest.

This can only be used with secp256k1 since Ed25519's security properties come, in part, from how the message is hashed.

Definition at line 212 of file SecretKey.cpp.

sign() [1/3]

Buffer ripple::sign	(	PublicKey const &	pk,
		SecretKey const &	sk,
		Slice const &	message
	)

Generate a signature for a message.

With secp256k1 signatures, the data is first hashed with SHA512-Half, and the resulting digest is signed.

Definition at line 238 of file SecretKey.cpp.

randomSecretKey()

SecretKey ripple::randomSecretKey

(

)

Create a secret key using secure random numbers.

Definition at line 281 of file SecretKey.cpp.

generateSecretKey()

SecretKey ripple::generateSecretKey	(	KeyType	type,
		Seed const &	seed
	)

Generate a new secret key deterministically.

Definition at line 291 of file SecretKey.cpp.

derivePublicKey()

PublicKey ripple::derivePublicKey	(	KeyType	type,
		SecretKey const &	sk
	)

Derive the public key from a secret key.

Definition at line 313 of file SecretKey.cpp.

generateKeyPair()

std::pair< PublicKey, SecretKey > ripple::generateKeyPair	(	KeyType	type,
		Seed const &	seed
	)

Generate a key pair deterministically.

This algorithm is specific to Ripple:

For secp256k1 key pairs, the seed is converted to a Generator and used to compute the key pair corresponding to ordinal 0 for the generator.

Definition at line 351 of file SecretKey.cpp.

randomKeyPair()

std::pair< PublicKey, SecretKey > ripple::randomKeyPair

(

KeyType

type

)

Create a key pair using secure random numbers.

Definition at line 368 of file SecretKey.cpp.

randomSeed()

Seed ripple::randomSeed

(

)

Create a seed using secure random numbers.

Definition at line 59 of file Seed.cpp.

generateSeed()

Seed ripple::generateSeed

(

std::string const &

passPhrase

)

Generate a seed deterministically.

The algorithm is specific to Ripple:

The seed is calculated as the first 128 bits
of the SHA512-Half of the string text excluding
any terminating null.

Note

This will not attempt to determine the format of the string (e.g. hex or base58).

Definition at line 69 of file Seed.cpp.

parseGenericSeed()

std::optional< Seed > ripple::parseGenericSeed

(

std::string const &

str

)

Attempt to parse a string as a seed.

Definition at line 90 of file Seed.cpp.

seedAs1751()

std::string ripple::seedAs1751

(

Seed const &

seed

)

Encode a Seed in RFC1751 format.

Definition at line 127 of file Seed.cpp.

CONSTRUCT_UNTYPED_SFIELD() [1/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfLedgerEntry	,
		"LedgerEntry"	,
		LEDGERENTRY	,
		257
	)

CONSTRUCT_UNTYPED_SFIELD() [2/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfTransaction	,
		"Transaction"	,
		TRANSACTION	,
		257
	)

CONSTRUCT_UNTYPED_SFIELD() [3/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfValidation	,
		"Validation"	,
		VALIDATION	,
		257
	)

CONSTRUCT_UNTYPED_SFIELD() [4/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfMetadata	,
		"Metadata"	,
		METADATA	,
		257
	)

CONSTRUCT_TYPED_SFIELD() [1/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfCloseResolution	,
		"CloseResolution"	,
		UINT8	,
		1
	)

CONSTRUCT_TYPED_SFIELD() [2/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfMethod	,
		"Method"	,
		UINT8	,
		2
	)

CONSTRUCT_TYPED_SFIELD() [3/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfTransactionResult	,
		"TransactionResult"	,
		UINT8	,
		3
	)

CONSTRUCT_TYPED_SFIELD() [4/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfTickSize	,
		"TickSize"	,
		UINT8	,
		16
	)

CONSTRUCT_TYPED_SFIELD() [5/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfUNLModifyDisabling	,
		"UNLModifyDisabling"	,
		UINT8	,
		17
	)

CONSTRUCT_TYPED_SFIELD() [6/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfLedgerEntryType	,
		"LedgerEntryType"	,
		UINT16	,
		1	,
		SField::sMD_Never
	)

CONSTRUCT_TYPED_SFIELD() [7/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfTransactionType	,
		"TransactionType"	,
		UINT16	,
		2
	)

CONSTRUCT_TYPED_SFIELD() [8/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfSignerWeight	,
		"SignerWeight"	,
		UINT16	,
		3
	)

CONSTRUCT_TYPED_SFIELD() [9/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfVersion	,
		"Version"	,
		UINT16	,
		16
	)

CONSTRUCT_TYPED_SFIELD() [10/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfFlags	,
		"Flags"	,
		UINT32	,
		2
	)

CONSTRUCT_TYPED_SFIELD() [11/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfSourceTag	,
		"SourceTag"	,
		UINT32	,
		3
	)

CONSTRUCT_TYPED_SFIELD() [12/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfSequence	,
		"Sequence"	,
		UINT32	,
		4
	)

CONSTRUCT_TYPED_SFIELD() [13/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfPreviousTxnLgrSeq	,
		"PreviousTxnLgrSeq"	,
		UINT32	,
		5	,
		SField::sMD_DeleteFinal
	)

CONSTRUCT_TYPED_SFIELD() [14/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfLedgerSequence	,
		"LedgerSequence"	,
		UINT32	,
		6
	)

CONSTRUCT_TYPED_SFIELD() [15/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfCloseTime	,
		"CloseTime"	,
		UINT32	,
		7
	)

CONSTRUCT_TYPED_SFIELD() [16/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfParentCloseTime	,
		"ParentCloseTime"	,
		UINT32	,
		8
	)

CONSTRUCT_TYPED_SFIELD() [17/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfSigningTime	,
		"SigningTime"	,
		UINT32	,
		9
	)

CONSTRUCT_TYPED_SFIELD() [18/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfExpiration	,
		"Expiration"	,
		UINT32	,
		10
	)

CONSTRUCT_TYPED_SFIELD() [19/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfTransferRate	,
		"TransferRate"	,
		UINT32	,
		11
	)

CONSTRUCT_TYPED_SFIELD() [20/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfWalletSize	,
		"WalletSize"	,
		UINT32	,
		12
	)

CONSTRUCT_TYPED_SFIELD() [21/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfOwnerCount	,
		"OwnerCount"	,
		UINT32	,
		13
	)

CONSTRUCT_TYPED_SFIELD() [22/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfDestinationTag	,
		"DestinationTag"	,
		UINT32	,
		14
	)

CONSTRUCT_TYPED_SFIELD() [23/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfHighQualityIn	,
		"HighQualityIn"	,
		UINT32	,
		16
	)

CONSTRUCT_TYPED_SFIELD() [24/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfHighQualityOut	,
		"HighQualityOut"	,
		UINT32	,
		17
	)

CONSTRUCT_TYPED_SFIELD() [25/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfLowQualityIn	,
		"LowQualityIn"	,
		UINT32	,
		18
	)

CONSTRUCT_TYPED_SFIELD() [26/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfLowQualityOut	,
		"LowQualityOut"	,
		UINT32	,
		19
	)

CONSTRUCT_TYPED_SFIELD() [27/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfQualityIn	,
		"QualityIn"	,
		UINT32	,
		20
	)

CONSTRUCT_TYPED_SFIELD() [28/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfQualityOut	,
		"QualityOut"	,
		UINT32	,
		21
	)

CONSTRUCT_TYPED_SFIELD() [29/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfStampEscrow	,
		"StampEscrow"	,
		UINT32	,
		22
	)

CONSTRUCT_TYPED_SFIELD() [30/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfBondAmount	,
		"BondAmount"	,
		UINT32	,
		23
	)

CONSTRUCT_TYPED_SFIELD() [31/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfLoadFee	,
		"LoadFee"	,
		UINT32	,
		24
	)

CONSTRUCT_TYPED_SFIELD() [32/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfOfferSequence	,
		"OfferSequence"	,
		UINT32	,
		25
	)

CONSTRUCT_TYPED_SFIELD() [33/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfFirstLedgerSequence	,
		"FirstLedgerSequence"	,
		UINT32	,
		26
	)

CONSTRUCT_TYPED_SFIELD() [34/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfLastLedgerSequence	,
		"LastLedgerSequence"	,
		UINT32	,
		27
	)

CONSTRUCT_TYPED_SFIELD() [35/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfTransactionIndex	,
		"TransactionIndex"	,
		UINT32	,
		28
	)

CONSTRUCT_TYPED_SFIELD() [36/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfOperationLimit	,
		"OperationLimit"	,
		UINT32	,
		29
	)

CONSTRUCT_TYPED_SFIELD() [37/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfReferenceFeeUnits	,
		"ReferenceFeeUnits"	,
		UINT32	,
		30
	)

CONSTRUCT_TYPED_SFIELD() [38/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfReserveBase	,
		"ReserveBase"	,
		UINT32	,
		31
	)

CONSTRUCT_TYPED_SFIELD() [39/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfReserveIncrement	,
		"ReserveIncrement"	,
		UINT32	,
		32
	)

CONSTRUCT_TYPED_SFIELD() [40/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfSetFlag	,
		"SetFlag"	,
		UINT32	,
		33
	)

CONSTRUCT_TYPED_SFIELD() [41/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfClearFlag	,
		"ClearFlag"	,
		UINT32	,
		34
	)

CONSTRUCT_TYPED_SFIELD() [42/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfSignerQuorum	,
		"SignerQuorum"	,
		UINT32	,
		35
	)

CONSTRUCT_TYPED_SFIELD() [43/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfCancelAfter	,
		"CancelAfter"	,
		UINT32	,
		36
	)

CONSTRUCT_TYPED_SFIELD() [44/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfFinishAfter	,
		"FinishAfter"	,
		UINT32	,
		37
	)

CONSTRUCT_TYPED_SFIELD() [45/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfSignerListID	,
		"SignerListID"	,
		UINT32	,
		38
	)

CONSTRUCT_TYPED_SFIELD() [46/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfSettleDelay	,
		"SettleDelay"	,
		UINT32	,
		39
	)

CONSTRUCT_TYPED_SFIELD() [47/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfTicketCount	,
		"TicketCount"	,
		UINT32	,
		40
	)

CONSTRUCT_TYPED_SFIELD() [48/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfTicketSequence	,
		"TicketSequence"	,
		UINT32	,
		41
	)

CONSTRUCT_TYPED_SFIELD() [49/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfIndexNext	,
		"IndexNext"	,
		UINT64	,
		1
	)

CONSTRUCT_TYPED_SFIELD() [50/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfIndexPrevious	,
		"IndexPrevious"	,
		UINT64	,
		2
	)

CONSTRUCT_TYPED_SFIELD() [51/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfBookNode	,
		"BookNode"	,
		UINT64	,
		3
	)

CONSTRUCT_TYPED_SFIELD() [52/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfOwnerNode	,
		"OwnerNode"	,
		UINT64	,
		4
	)

CONSTRUCT_TYPED_SFIELD() [53/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfBaseFee	,
		"BaseFee"	,
		UINT64	,
		5
	)

CONSTRUCT_TYPED_SFIELD() [54/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfExchangeRate	,
		"ExchangeRate"	,
		UINT64	,
		6
	)

CONSTRUCT_TYPED_SFIELD() [55/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfLowNode	,
		"LowNode"	,
		UINT64	,
		7
	)

CONSTRUCT_TYPED_SFIELD() [56/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfHighNode	,
		"HighNode"	,
		UINT64	,
		8
	)

CONSTRUCT_TYPED_SFIELD() [57/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfDestinationNode	,
		"DestinationNode"	,
		UINT64	,
		9
	)

CONSTRUCT_TYPED_SFIELD() [58/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfCookie	,
		"Cookie"	,
		UINT64	,
		10
	)

CONSTRUCT_TYPED_SFIELD() [59/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfServerVersion	,
		"ServerVersion"	,
		UINT64	,
		11
	)

CONSTRUCT_TYPED_SFIELD() [60/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfEmailHash	,
		"EmailHash"	,
		HASH128	,
		1
	)

CONSTRUCT_TYPED_SFIELD() [61/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfTakerPaysCurrency	,
		"TakerPaysCurrency"	,
		HASH160	,
		1
	)

CONSTRUCT_TYPED_SFIELD() [62/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfTakerPaysIssuer	,
		"TakerPaysIssuer"	,
		HASH160	,
		2
	)

CONSTRUCT_TYPED_SFIELD() [63/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfTakerGetsCurrency	,
		"TakerGetsCurrency"	,
		HASH160	,
		3
	)

CONSTRUCT_TYPED_SFIELD() [64/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfTakerGetsIssuer	,
		"TakerGetsIssuer"	,
		HASH160	,
		4
	)

CONSTRUCT_TYPED_SFIELD() [65/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfLedgerHash	,
		"LedgerHash"	,
		HASH256	,
		1
	)

CONSTRUCT_TYPED_SFIELD() [66/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfParentHash	,
		"ParentHash"	,
		HASH256	,
		2
	)

CONSTRUCT_TYPED_SFIELD() [67/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfTransactionHash	,
		"TransactionHash"	,
		HASH256	,
		3
	)

CONSTRUCT_TYPED_SFIELD() [68/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfAccountHash	,
		"AccountHash"	,
		HASH256	,
		4
	)

CONSTRUCT_TYPED_SFIELD() [69/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfPreviousTxnID	,
		"PreviousTxnID"	,
		HASH256	,
		5	,
		SField::sMD_DeleteFinal
	)

CONSTRUCT_TYPED_SFIELD() [70/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfLedgerIndex	,
		"LedgerIndex"	,
		HASH256	,
		6
	)

CONSTRUCT_TYPED_SFIELD() [71/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfWalletLocator	,
		"WalletLocator"	,
		HASH256	,
		7
	)

CONSTRUCT_TYPED_SFIELD() [72/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfRootIndex	,
		"RootIndex"	,
		HASH256	,
		8	,
		SField::sMD_Always
	)

CONSTRUCT_TYPED_SFIELD() [73/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfAccountTxnID	,
		"AccountTxnID"	,
		HASH256	,
		9
	)

CONSTRUCT_TYPED_SFIELD() [74/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfBookDirectory	,
		"BookDirectory"	,
		HASH256	,
		16
	)

CONSTRUCT_TYPED_SFIELD() [75/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfInvoiceID	,
		"InvoiceID"	,
		HASH256	,
		17
	)

CONSTRUCT_TYPED_SFIELD() [76/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfNickname	,
		"Nickname"	,
		HASH256	,
		18
	)

CONSTRUCT_TYPED_SFIELD() [77/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfAmendment	,
		"Amendment"	,
		HASH256	,
		19
	)

CONSTRUCT_TYPED_SFIELD() [78/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfDigest	,
		"Digest"	,
		HASH256	,
		21
	)

CONSTRUCT_TYPED_SFIELD() [79/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfChannel	,
		"Channel"	,
		HASH256	,
		22
	)

CONSTRUCT_TYPED_SFIELD() [80/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfConsensusHash	,
		"ConsensusHash"	,
		HASH256	,
		23
	)

CONSTRUCT_TYPED_SFIELD() [81/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfCheckID	,
		"CheckID"	,
		HASH256	,
		24
	)

CONSTRUCT_TYPED_SFIELD() [82/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfValidatedHash	,
		"ValidatedHash"	,
		HASH256	,
		25
	)

CONSTRUCT_TYPED_SFIELD() [83/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfAmount	,
		"Amount"	,
		AMOUNT	,
		1
	)

CONSTRUCT_TYPED_SFIELD() [84/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfBalance	,
		"Balance"	,
		AMOUNT	,
		2
	)

CONSTRUCT_TYPED_SFIELD() [85/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfLimitAmount	,
		"LimitAmount"	,
		AMOUNT	,
		3
	)

CONSTRUCT_TYPED_SFIELD() [86/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfTakerPays	,
		"TakerPays"	,
		AMOUNT	,
		4
	)

CONSTRUCT_TYPED_SFIELD() [87/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfTakerGets	,
		"TakerGets"	,
		AMOUNT	,
		5
	)

CONSTRUCT_TYPED_SFIELD() [88/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfLowLimit	,
		"LowLimit"	,
		AMOUNT	,
		6
	)

CONSTRUCT_TYPED_SFIELD() [89/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfHighLimit	,
		"HighLimit"	,
		AMOUNT	,
		7
	)

CONSTRUCT_TYPED_SFIELD() [90/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfFee	,
		"Fee"	,
		AMOUNT	,
		8
	)

CONSTRUCT_TYPED_SFIELD() [91/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfSendMax	,
		"SendMax"	,
		AMOUNT	,
		9
	)

CONSTRUCT_TYPED_SFIELD() [92/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfDeliverMin	,
		"DeliverMin"	,
		AMOUNT	,
		10
	)

CONSTRUCT_TYPED_SFIELD() [93/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfMinimumOffer	,
		"MinimumOffer"	,
		AMOUNT	,
		16
	)

CONSTRUCT_TYPED_SFIELD() [94/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfRippleEscrow	,
		"RippleEscrow"	,
		AMOUNT	,
		17
	)

CONSTRUCT_TYPED_SFIELD() [95/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfDeliveredAmount	,
		"DeliveredAmount"	,
		AMOUNT	,
		18
	)

CONSTRUCT_TYPED_SFIELD() [96/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfPublicKey	,
		"PublicKey"	,
		VL	,
		1
	)

CONSTRUCT_TYPED_SFIELD() [97/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfMessageKey	,
		"MessageKey"	,
		VL	,
		2
	)

CONSTRUCT_TYPED_SFIELD() [98/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfSigningPubKey	,
		"SigningPubKey"	,
		VL	,
		3
	)

CONSTRUCT_TYPED_SFIELD() [99/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfTxnSignature	,
		"TxnSignature"	,
		VL	,
		4	,
		SField::sMD_Default	,
		SField::notSigning
	)

CONSTRUCT_TYPED_SFIELD() [100/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfSignature	,
		"Signature"	,
		VL	,
		6	,
		SField::sMD_Default	,
		SField::notSigning
	)

CONSTRUCT_TYPED_SFIELD() [101/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfDomain	,
		"Domain"	,
		VL	,
		7
	)

CONSTRUCT_TYPED_SFIELD() [102/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfFundCode	,
		"FundCode"	,
		VL	,
		8
	)

CONSTRUCT_TYPED_SFIELD() [103/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfRemoveCode	,
		"RemoveCode"	,
		VL	,
		9
	)

CONSTRUCT_TYPED_SFIELD() [104/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfExpireCode	,
		"ExpireCode"	,
		VL	,
		10
	)

CONSTRUCT_TYPED_SFIELD() [105/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfCreateCode	,
		"CreateCode"	,
		VL	,
		11
	)

CONSTRUCT_TYPED_SFIELD() [106/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfMemoType	,
		"MemoType"	,
		VL	,
		12
	)

CONSTRUCT_TYPED_SFIELD() [107/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfMemoData	,
		"MemoData"	,
		VL	,
		13
	)

CONSTRUCT_TYPED_SFIELD() [108/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfMemoFormat	,
		"MemoFormat"	,
		VL	,
		14
	)

CONSTRUCT_TYPED_SFIELD() [109/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfFulfillment	,
		"Fulfillment"	,
		VL	,
		16
	)

CONSTRUCT_TYPED_SFIELD() [110/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfCondition	,
		"Condition"	,
		VL	,
		17
	)

CONSTRUCT_TYPED_SFIELD() [111/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfMasterSignature	,
		"MasterSignature"	,
		VL	,
		18	,
		SField::sMD_Default	,
		SField::notSigning
	)

CONSTRUCT_TYPED_SFIELD() [112/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfUNLModifyValidator	,
		"UNLModifyValidator"	,
		VL	,
		19
	)

CONSTRUCT_TYPED_SFIELD() [113/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfValidatorToDisable	,
		"ValidatorToDisable"	,
		VL	,
		20
	)

CONSTRUCT_TYPED_SFIELD() [114/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfValidatorToReEnable	,
		"ValidatorToReEnable"	,
		VL	,
		21
	)

CONSTRUCT_TYPED_SFIELD() [115/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfAccount	,
		"Account"	,
		ACCOUNT	,
		1
	)

CONSTRUCT_TYPED_SFIELD() [116/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfOwner	,
		"Owner"	,
		ACCOUNT	,
		2
	)

CONSTRUCT_TYPED_SFIELD() [117/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfDestination	,
		"Destination"	,
		ACCOUNT	,
		3
	)

CONSTRUCT_TYPED_SFIELD() [118/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfIssuer	,
		"Issuer"	,
		ACCOUNT	,
		4
	)

CONSTRUCT_TYPED_SFIELD() [119/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfAuthorize	,
		"Authorize"	,
		ACCOUNT	,
		5
	)

CONSTRUCT_TYPED_SFIELD() [120/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfUnauthorize	,
		"Unauthorize"	,
		ACCOUNT	,
		6
	)

CONSTRUCT_TYPED_SFIELD() [121/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfRegularKey	,
		"RegularKey"	,
		ACCOUNT	,
		8
	)

CONSTRUCT_TYPED_SFIELD() [122/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfIndexes	,
		"Indexes"	,
		VECTOR256	,
		1	,
		SField::sMD_Never
	)

CONSTRUCT_TYPED_SFIELD() [123/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfHashes	,
		"Hashes"	,
		VECTOR256	,
		2
	)

CONSTRUCT_TYPED_SFIELD() [124/124]

ripple::CONSTRUCT_TYPED_SFIELD	(	sfAmendments	,
		"Amendments"	,
		VECTOR256	,
		3
	)

CONSTRUCT_UNTYPED_SFIELD() [5/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfPaths	,
		"Paths"	,
		PATHSET	,
		1
	)

CONSTRUCT_UNTYPED_SFIELD() [6/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfTransactionMetaData	,
		"TransactionMetaData"	,
		OBJECT	,
		2
	)

CONSTRUCT_UNTYPED_SFIELD() [7/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfCreatedNode	,
		"CreatedNode"	,
		OBJECT	,
		3
	)

CONSTRUCT_UNTYPED_SFIELD() [8/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfDeletedNode	,
		"DeletedNode"	,
		OBJECT	,
		4
	)

CONSTRUCT_UNTYPED_SFIELD() [9/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfModifiedNode	,
		"ModifiedNode"	,
		OBJECT	,
		5
	)

CONSTRUCT_UNTYPED_SFIELD() [10/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfPreviousFields	,
		"PreviousFields"	,
		OBJECT	,
		6
	)

CONSTRUCT_UNTYPED_SFIELD() [11/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfFinalFields	,
		"FinalFields"	,
		OBJECT	,
		7
	)

CONSTRUCT_UNTYPED_SFIELD() [12/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfNewFields	,
		"NewFields"	,
		OBJECT	,
		8
	)

CONSTRUCT_UNTYPED_SFIELD() [13/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfTemplateEntry	,
		"TemplateEntry"	,
		OBJECT	,
		9
	)

CONSTRUCT_UNTYPED_SFIELD() [14/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfMemo	,
		"Memo"	,
		OBJECT	,
		10
	)

CONSTRUCT_UNTYPED_SFIELD() [15/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfSignerEntry	,
		"SignerEntry"	,
		OBJECT	,
		11
	)

CONSTRUCT_UNTYPED_SFIELD() [16/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfSigner	,
		"Signer"	,
		OBJECT	,
		16
	)

CONSTRUCT_UNTYPED_SFIELD() [17/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfMajority	,
		"Majority"	,
		OBJECT	,
		18
	)

CONSTRUCT_UNTYPED_SFIELD() [18/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfDisabledValidator	,
		"DisabledValidator"	,
		OBJECT	,
		19
	)

CONSTRUCT_UNTYPED_SFIELD() [19/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfSigners	,
		"Signers"	,
		ARRAY	,
		3	,
		SField::sMD_Default	,
		SField::notSigning
	)

CONSTRUCT_UNTYPED_SFIELD() [20/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfSignerEntries	,
		"SignerEntries"	,
		ARRAY	,
		4
	)

CONSTRUCT_UNTYPED_SFIELD() [21/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfTemplate	,
		"Template"	,
		ARRAY	,
		5
	)

CONSTRUCT_UNTYPED_SFIELD() [22/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfNecessary	,
		"Necessary"	,
		ARRAY	,
		6
	)

CONSTRUCT_UNTYPED_SFIELD() [23/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfSufficient	,
		"Sufficient"	,
		ARRAY	,
		7
	)

CONSTRUCT_UNTYPED_SFIELD() [24/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfAffectedNodes	,
		"AffectedNodes"	,
		ARRAY	,
		8
	)

CONSTRUCT_UNTYPED_SFIELD() [25/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfMemos	,
		"Memos"	,
		ARRAY	,
		9
	)

CONSTRUCT_UNTYPED_SFIELD() [26/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfMajorities	,
		"Majorities"	,
		ARRAY	,
		16
	)

CONSTRUCT_UNTYPED_SFIELD() [27/27]

ripple::CONSTRUCT_UNTYPED_SFIELD	(	sfDisabledValidators	,
		"DisabledValidators"	,
		ARRAY	,
		17
	)

sign() [2/3]

void ripple::sign	(	STObject &	st,
		HashPrefix const &	prefix,
		KeyType	type,
		SecretKey const &	sk,
		SF_VL const &	sigField = sfSignature
	)

Sign an STObject.

Parameters

st	Object to sign
prefix	Prefix to insert before serialized object when hashing
type	Signing key type used to derive public key
sk	Signing secret key
sigField	Field in which to store the signature on the object. If not specified the value defaults to sfSignature.

Note

If a signature already exists, it is overwritten.

Definition at line 25 of file Sign.cpp.

verify() [2/2]

bool ripple::verify	(	STObject const &	st,
		HashPrefix const &	prefix,
		PublicKey const &	pk,
		SF_VL const &	sigField = sfSignature
	)

Returns true if STObject contains valid signature.

Parameters

st	Signed object
prefix	Prefix inserted before serialized object when hashing
pk	Public key for verifying signature
sigField	Object's field containing the signature. If not specified the value defaults to sfSignature.

Definition at line 39 of file Sign.cpp.

buildMultiSigningData()

Serializer ripple::buildMultiSigningData	(	STObject const &	obj,
		AccountID const &	signingID
	)

Return a Serializer suitable for computing a multisigning TxnSignature.

Definition at line 87 of file Sign.cpp.

startMultiSigningData()

Serializer ripple::startMultiSigningData

(

STObject const &

obj

)

Break the multi-signing hash computation into 2 parts for optimization.

We can optimize verifying multiple multisignatures by splitting the data building into two parts; o A large part that is shared by all of the computations. o A small part that is unique to each signer in the multisignature.

The following methods support that optimization:

1. startMultiSigningData provides the large part which can be shared.
2. finishMuiltiSigningData caps the passed in serializer with each signer's unique data.

Definition at line 95 of file Sign.cpp.

getSNValue()

static std::int64_t ripple::getSNValue ( STAmount const &  amount )

static

Definition at line 45 of file STAmount.cpp.

areComparable()

static bool ripple::areComparable ( STAmount const &  v1, STAmount const &  v2  )

static

Definition at line 61 of file STAmount.cpp.

operator+() [2/2]

STAmount ripple::operator+	(	STAmount const &	v1,
		STAmount const &	v2
	)

Definition at line 351 of file STAmount.cpp.

operator-() [1/2]

STAmount ripple::operator-	(	STAmount const &	v1,
		STAmount const &	v2
	)

Definition at line 416 of file STAmount.cpp.

getRate()

std::uint64_t ripple::getRate	(	STAmount const &	offerOut,
		STAmount const &	offerIn
	)

Definition at line 442 of file STAmount.cpp.

amountFromQuality()

STAmount ripple::amountFromQuality

(

std::uint64_t

rate

)

Definition at line 769 of file STAmount.cpp.

amountFromString()

STAmount ripple::amountFromString	(	Issue const &	issue,
		std::string const &	amount
	)

Definition at line 781 of file STAmount.cpp.

amountFromJson()

STAmount ripple::amountFromJson	(	SField const &	name,
		Json::Value const &	v
	)

Definition at line 846 of file STAmount.cpp.

amountFromJsonNoThrow()

bool ripple::amountFromJsonNoThrow	(	STAmount &	result,
		Json::Value const &	jvSource
	)

Definition at line 951 of file STAmount.cpp.

operator==() [10/15]

bool ripple::operator==	(	STAmount const &	lhs,
		STAmount const &	rhs
	)

Definition at line 973 of file STAmount.cpp.

operator<() [6/10]

bool ripple::operator<	(	STAmount const &	lhs,
		STAmount const &	rhs
	)

Definition at line 980 of file STAmount.cpp.

operator-() [2/2]

STAmount ripple::operator-

(

STAmount const &

value

)

Definition at line 1015 of file STAmount.cpp.

muldiv()

static std::uint64_t ripple::muldiv ( std::uint64_t  multiplier, std::uint64_t  multiplicand, std::uint64_t  divisor  )

static

Definition at line 1038 of file STAmount.cpp.

muldiv_round()

static std::uint64_t ripple::muldiv_round ( std::uint64_t  multiplier, std::uint64_t  multiplicand, std::uint64_t  divisor, std::uint64_t  rounding  )

static

Definition at line 1059 of file STAmount.cpp.

divide() [2/2]

STAmount ripple::divide	(	STAmount const &	num,
		STAmount const &	den,
		Issue const &	issue
	)

Definition at line 1083 of file STAmount.cpp.

multiply() [2/2]

STAmount ripple::multiply	(	STAmount const &	v1,
		STAmount const &	v2,
		Issue const &	issue
	)

Definition at line 1128 of file STAmount.cpp.

canonicalizeRound()

static void ripple::canonicalizeRound ( bool  native, std::uint64_t &  value, int &  offset  )

static

Definition at line 1184 of file STAmount.cpp.

mulRound()

STAmount ripple::mulRound	(	STAmount const &	v1,
		STAmount const &	v2,
		Issue const &	issue,
		bool	roundUp
	)

Definition at line 1219 of file STAmount.cpp.

divRound()

STAmount ripple::divRound	(	STAmount const &	num,
		STAmount const &	den,
		Issue const &	issue,
		bool	roundUp
	)

Definition at line 1305 of file STAmount.cpp.

operator<<() [11/15]

std::ostream & ripple::operator<<	(	std::ostream &	out,
		const STBase &	t
	)

Definition at line 135 of file STBase.cpp.

getTxFormat()

static auto ripple::getTxFormat ( TxType  type )

static

Definition at line 45 of file STTx.cpp.

getSigningData()

static Blob ripple::getSigningData ( STTx const &  that )

static

Definition at line 136 of file STTx.cpp.

isMemoOkay()

static bool ripple::isMemoOkay ( STObject const &  st, std::string &  reason  )

static

Definition at line 400 of file STTx.cpp.

isAccountFieldOkay()

static bool ripple::isAccountFieldOkay ( STObject const &  st )

static

Definition at line 493 of file STTx.cpp.

passesLocalChecks()

bool ripple::passesLocalChecks	(	STObject const &	st,
		std::string &	reason
	)

Definition at line 506 of file STTx.cpp.

sterilize()

std::shared_ptr< STTx const > ripple::sterilize

(

STTx const &

stx

)

Sterilize a transaction.

The transaction is serialized and then deserialized, ensuring that all equivalent transactions are in canonical form. This also ensures that program metadata such as the transaction's digest, are all computed.

Definition at line 526 of file STTx.cpp.

isPseudoTx()

bool ripple::isPseudoTx

(

STObject const &

tx

)

Check whether a transaction is a pseudo-transaction.

Definition at line 535 of file STTx.cpp.

transResultInfo()

bool ripple::transResultInfo	(	TER	code,
		std::string &	token,
		std::string &	text
	)

Definition at line 181 of file TER.cpp.

transToken()

std::string ripple::transToken

(

TER

code

)

Definition at line 196 of file TER.cpp.

transHuman()

std::string ripple::transHuman

(

TER

code

)

Definition at line 205 of file TER.cpp.

transCode()

std::optional< TER > ripple::transCode

(

std::string const &

token

)

Definition at line 214 of file TER.cpp.

digest() [1/2]

template<class Hasher >

static Hasher::result_type ripple::digest ( void const *  data, std::size_t  size  )

staticnoexcept

Definition at line 47 of file tokens.cpp.

digest() [2/2]

template<class Hasher , class T , std::size_t N, class = std::enable_if_t<sizeof(T) == 1>>

static Hasher::result_type ripple::digest ( std::array< T, N > const &  v )

static

Definition at line 60 of file tokens.cpp.

digest2()

template<class Hasher , class... Args>

static Hasher::result_type ripple::digest2 ( Args const &...  args )

static

Definition at line 68 of file tokens.cpp.

checksum()

static void ripple::checksum ( void *  out, void const *  message, std::size_t  size  )

static

Calculate a 4-byte checksum of the data.

The checksum is calculated as the first 4 bytes of the SHA256 digest of the message. This is added to the base58 encoding of identifiers to detect user error in data entry.

Note

This checksum algorithm is part of the client API

Definition at line 83 of file tokens.cpp.

encodeBase58Token()

std::string ripple::encodeBase58Token	(	TokenType	type,
		void const *	token,
		std::size_t	size
	)

Encode data in Base58Check format using XRPL alphabet.

For details on the format see https://xrpl.org/base58-encodings.html#base58-encodings

Parameters

type	The type of token to encode.
token	Pointer to the data to encode.
size	The size of the data to encode.

Returns

the encoded token.

Definition at line 199 of file tokens.cpp.

decodeBase58Token()

std::string ripple::decodeBase58Token	(	std::string const &	s,
		TokenType	type
	)

Decode a token of given type encoded using Base58Check and the XRPL alphabet.

Parameters

s	The encoded token
type	The type expected for this token.

Returns

If the encoded token decodes correctly, the token data without the type or checksum. And empty string otherwise.

Definition at line 223 of file tokens.cpp.

to_currency() [1/2]

bool ripple::to_currency	(	Currency &	,
		std::string const &
	)

Tries to convert a string to a Currency, returns true on success.

Note

This function will return success if the resulting currency is badCurrency(). This legacy behavior is unfortunate; changing this will require very careful checking everywhere and may mean having to rewrite some unit test code.

Definition at line 80 of file UintTypes.cpp.

to_currency() [2/2]

Currency ripple::to_currency

(

std::string const &

)

Tries to convert a string to a Currency, returns noCurrency() on failure.

Note

This function can return badCurrency(). This legacy behavior is unfortunate; changing this will require very careful checking everywhere and may mean having to rewrite some unit test code.

Definition at line 112 of file UintTypes.cpp.

xrpCurrency()

Currency const & ripple::xrpCurrency

(

)

XRP currency.

Definition at line 121 of file UintTypes.cpp.

noCurrency()

Currency const & ripple::noCurrency

(

)

A placeholder for empty currencies.

Definition at line 128 of file UintTypes.cpp.

badCurrency()

Currency const & ripple::badCurrency

(

)

We deliberately disallow the currency that looks like "XRP" because too many people were using it instead of the correct XRP currency.

Definition at line 135 of file UintTypes.cpp.

hash_append() [7/8]

template<class Hasher >

void ripple::hash_append	(	Hasher &	h,
		Issue const &	r
	)

Definition at line 60 of file Issue.h.

xrpIssue()

Issue const& ripple::xrpIssue

(

)

Returns an asset specifier that represents XRP.

Definition at line 97 of file Issue.h.

noIssue()

Issue const& ripple::noIssue

(

)

Returns an asset specifier that represents no account and currency.

Definition at line 105 of file Issue.h.

keyTypeFromString()

std::optional<KeyType> ripple::keyTypeFromString

(

std::string const &

s

)

Definition at line 34 of file KeyType.h.

to_string() [24/26]

char const* ripple::to_string

(

KeyType

type

)

Definition at line 46 of file KeyType.h.

operator<<() [12/15]

template<class Stream >

Stream& ripple::operator<<	(	Stream &	s,
		KeyType	type
	)

Definition at line 59 of file KeyType.h.

serializePayChanAuthorization()

void ripple::serializePayChanAuthorization	(	Serializer &	msg,
		uint256 const &	key,
		XRPAmount const &	amt
	)

Definition at line 31 of file protocol/PayChan.h.

operator==() [11/15]

bool ripple::operator==	(	PublicKey const &	lhs,
		PublicKey const &	rhs
	)

Definition at line 140 of file PublicKey.h.

operator<() [7/10]

bool ripple::operator<	(	PublicKey const &	lhs,
		PublicKey const &	rhs
	)

Definition at line 147 of file PublicKey.h.

hash_append() [8/8]

template<class Hasher >

void ripple::hash_append	(	Hasher &	h,
		PublicKey const &	pk
	)

Definition at line 158 of file PublicKey.h.

toBase58() [2/4]

std::string ripple::toBase58	(	TokenType	type,
		PublicKey const &	pk
	)

Definition at line 186 of file PublicKey.h.

publicKeyType() [2/2]

std::optional<KeyType> ripple::publicKeyType

(

PublicKey const &

publicKey

)

Definition at line 235 of file PublicKey.h.

operator==() [12/15]

bool ripple::operator== ( Rate const &  lhs, Rate const &  rhs  )

noexcept

Definition at line 49 of file Rate.h.

operator<() [8/10]

bool ripple::operator< ( Rate const &  lhs, Rate const &  rhs  )

noexcept

Definition at line 55 of file Rate.h.

operator<<() [13/15]

std::ostream& ripple::operator<<	(	std::ostream &	os,
		Rate const &	rate
	)

Definition at line 61 of file Rate.h.

operator==() [13/15]

bool ripple::operator==	(	SecretKey const &	lhs,
		SecretKey const &	rhs
	)

Definition at line 100 of file SecretKey.h.

operator!=() [8/12]

bool ripple::operator!=	(	SecretKey const &	lhs,
		SecretKey const &	rhs
	)

Definition at line 107 of file SecretKey.h.

toBase58() [3/4]

std::string ripple::toBase58	(	TokenType	type,
		SecretKey const &	sk
	)

Definition at line 120 of file SecretKey.h.

signDigest() [2/2]

Buffer ripple::signDigest	(	KeyType	type,
		SecretKey const &	sk,
		uint256 const &	digest
	)

Definition at line 162 of file SecretKey.h.

sign() [3/3]

Buffer ripple::sign	(	KeyType	type,
		SecretKey const &	sk,
		Slice const &	message
	)

Definition at line 177 of file SecretKey.h.

toBase58() [4/4]

std::string ripple::toBase58

(

Seed const &

seed

)

Format a seed as a Base58 string.

Definition at line 129 of file Seed.h.

field_code() [1/2]

int ripple::field_code	(	SerializedTypeID	id,
		int	index
	)

Definition at line 87 of file SField.h.

field_code() [2/2]

int ripple::field_code	(	int	id,
		int	index
	)

Definition at line 94 of file SField.h.

operator~() [2/2]

template<class T >

OptionaledField<T> ripple::operator~

(

TypedField< T > const &

f

)

Definition at line 308 of file SField.h.

finishMultiSigningData()

void ripple::finishMultiSigningData	(	AccountID const &	signingID,
		Serializer &	s
	)

Definition at line 85 of file Sign.h.

toSTAmount() [5/5]

STAmount const& ripple::toSTAmount

(

STAmount const &

a

)

Definition at line 374 of file STAmount.h.

isLegalNet()

bool ripple::isLegalNet

(

STAmount const &

value

)

Definition at line 386 of file STAmount.h.

operator!=() [9/12]

bool ripple::operator!=	(	STAmount const &	lhs,
		STAmount const &	rhs
	)

Definition at line 403 of file STAmount.h.

operator>() [4/5]

bool ripple::operator>	(	STAmount const &	lhs,
		STAmount const &	rhs
	)

Definition at line 409 of file STAmount.h.

operator<=() [4/5]

bool ripple::operator<=	(	STAmount const &	lhs,
		STAmount const &	rhs
	)

Definition at line 415 of file STAmount.h.

operator>=() [4/5]

bool ripple::operator>=	(	STAmount const &	lhs,
		STAmount const &	rhs
	)

Definition at line 421 of file STAmount.h.

isXRP() [2/2]

bool ripple::isXRP

(

STAmount const &

amount

)

Definition at line 470 of file STAmount.h.

get() [5/6]

template<class T , class U >

std::optional<T> ripple::get	(	STObject const &	st,
		TypedField< U > const &	f
	)

Return the value of a field in an STObject as a given type.

Definition at line 115 of file STExchange.h.

get() [6/6]

template<class U >

std::optional<typename STExchange<U, typename U::value_type>::value_type> ripple::get	(	STObject const &	st,
		TypedField< U > const &	f
	)

Definition at line 134 of file STExchange.h.

set() [3/5]

template<class U , class T >

void ripple::set	(	STObject &	st,
		TypedField< U > const &	f,
		T &&	t
	)

Set a field value in an STObject.

Definition at line 143 of file STExchange.h.

set() [4/5]

template<class Init >

void ripple::set	(	STObject &	st,
		TypedField< STBlob > const &	f,
		std::size_t	size,
		Init &&	init
	)

Set a blob field using an init function.

Definition at line 152 of file STExchange.h.

set() [5/5]

template<class = void>

void ripple::set	(	STObject &	st,
		TypedField< STBlob > const &	f,
		void const *	data,
		std::size_t	size
	)

Set a blob field from data.

Definition at line 160 of file STExchange.h.

erase()

template<class U >

void ripple::erase	(	STObject &	st,
		TypedField< U > const &	f
	)

Remove a field in an STObject.

Definition at line 171 of file STExchange.h.

throwFieldNotFound()

void ripple::throwFieldNotFound

(

SField const &

field

)

Definition at line 46 of file STObject.h.

systemName()

static std::string const& ripple::systemName ( )

static

Definition at line 34 of file SystemParameters.h.

isLegalAmount()

bool ripple::isLegalAmount

(

XRPAmount const &

amount

)

Returns true if the amount does not exceed the initial XRP in existence.

Definition at line 47 of file SystemParameters.h.

systemCurrencyCode()

static std::string const& ripple::systemCurrencyCode ( )

static

Definition at line 54 of file SystemParameters.h.

TERtoInt() [1/6]

constexpr TERUnderlyingType ripple::TERtoInt ( TELcodes  v )

constexpr

Definition at line 288 of file TER.h.

TERtoInt() [2/6]

constexpr TERUnderlyingType ripple::TERtoInt ( TEMcodes  v )

constexpr

Definition at line 294 of file TER.h.

TERtoInt() [3/6]

constexpr TERUnderlyingType ripple::TERtoInt ( TEFcodes  v )

constexpr

Definition at line 300 of file TER.h.

TERtoInt() [4/6]

constexpr TERUnderlyingType ripple::TERtoInt ( TERcodes  v )

constexpr

Definition at line 306 of file TER.h.

TERtoInt() [5/6]

constexpr TERUnderlyingType ripple::TERtoInt ( TEScodes  v )

constexpr

Definition at line 312 of file TER.h.

TERtoInt() [6/6]

constexpr TERUnderlyingType ripple::TERtoInt ( TECcodes  v )

constexpr

Definition at line 318 of file TER.h.

operator==() [14/15]

template<typename L , typename R >

constexpr auto ripple::operator== ( L const &  lhs, R const &  rhs  ) -> std::enable_if_t< std::is_same<decltype(TERtoInt(lhs)), int>::value && std::is_same<decltype(TERtoInt(rhs)), int>::value, bool>

constexpr

Definition at line 422 of file TER.h.

operator!=() [10/12]

template<typename L , typename R >

constexpr auto ripple::operator!= ( L const &  lhs, R const &  rhs  ) -> std::enable_if_t< std::is_same<decltype(TERtoInt(lhs)), int>::value && std::is_same<decltype(TERtoInt(rhs)), int>::value, bool>

constexpr

Definition at line 432 of file TER.h.

operator<() [9/10]

template<typename L , typename R >

constexpr auto ripple::operator< ( L const &  lhs, R const &  rhs  ) -> std::enable_if_t< std::is_same<decltype(TERtoInt(lhs)), int>::value && std::is_same<decltype(TERtoInt(rhs)), int>::value, bool>

constexpr

Definition at line 442 of file TER.h.

operator<=() [5/5]

template<typename L , typename R >

constexpr auto ripple::operator<= ( L const &  lhs, R const &  rhs  ) -> std::enable_if_t< std::is_same<decltype(TERtoInt(lhs)), int>::value && std::is_same<decltype(TERtoInt(rhs)), int>::value, bool>

constexpr

Definition at line 452 of file TER.h.

operator>() [5/5]

template<typename L , typename R >

constexpr auto ripple::operator> ( L const &  lhs, R const &  rhs  ) -> std::enable_if_t< std::is_same<decltype(TERtoInt(lhs)), int>::value && std::is_same<decltype(TERtoInt(rhs)), int>::value, bool>

constexpr

Definition at line 462 of file TER.h.

operator>=() [5/5]

template<typename L , typename R >

constexpr auto ripple::operator>= ( L const &  lhs, R const &  rhs  ) -> std::enable_if_t< std::is_same<decltype(TERtoInt(lhs)), int>::value && std::is_same<decltype(TERtoInt(rhs)), int>::value, bool>

constexpr

Definition at line 472 of file TER.h.

isTelLocal()

bool ripple::isTelLocal

(

TER

x

)

Definition at line 560 of file TER.h.

isTemMalformed()

bool ripple::isTemMalformed

(

TER

x

)

Definition at line 566 of file TER.h.

isTefFailure()

bool ripple::isTefFailure

(

TER

x

)

Definition at line 572 of file TER.h.

isTerRetry()

bool ripple::isTerRetry

(

TER

x

)

Definition at line 578 of file TER.h.

isTesSuccess()

bool ripple::isTesSuccess

(

TER

x

)

Definition at line 584 of file TER.h.

isTecClaim()

bool ripple::isTecClaim

(

TER

x

)

Definition at line 590 of file TER.h.

doAccountInfoGrpc()

std::pair< org::xrpl::rpc::v1::GetAccountInfoResponse, grpc::Status > ripple::doAccountInfoGrpc

(

RPC::GRPCContext< org::xrpl::rpc::v1::GetAccountInfoRequest > &

context

)

Definition at line 227 of file AccountInfo.cpp.

doFeeGrpc()

std::pair< org::xrpl::rpc::v1::GetFeeResponse, grpc::Status > ripple::doFeeGrpc

(

RPC::GRPCContext< org::xrpl::rpc::v1::GetFeeRequest > &

context

)

Definition at line 42 of file Fee1.cpp.

doSubmitGrpc()

std::pair< org::xrpl::rpc::v1::SubmitTransactionResponse, grpc::Status > ripple::doSubmitGrpc

(

RPC::GRPCContext< org::xrpl::rpc::v1::SubmitTransactionRequest > &

context

)

Definition at line 198 of file Submit.cpp.

doTxGrpc()

std::pair< org::xrpl::rpc::v1::GetTransactionResponse, grpc::Status > ripple::doTxGrpc

(

RPC::GRPCContext< org::xrpl::rpc::v1::GetTransactionRequest > &

context

)

Definition at line 441 of file Tx.cpp.

doAccountTxGrpc()

std::pair< org::xrpl::rpc::v1::GetAccountTransactionHistoryResponse, grpc::Status > ripple::doAccountTxGrpc

(

RPC::GRPCContext< org::xrpl::rpc::v1::GetAccountTransactionHistoryRequest > &

context

)

Definition at line 599 of file AccountTx.cpp.

doLedgerGrpc()

std::pair< org::xrpl::rpc::v1::GetLedgerResponse, grpc::Status > ripple::doLedgerGrpc

(

RPC::GRPCContext< org::xrpl::rpc::v1::GetLedgerRequest > &

context

)

Definition at line 106 of file LedgerHandler.cpp.

doLedgerEntryGrpc()

std::pair< org::xrpl::rpc::v1::GetLedgerEntryResponse, grpc::Status > ripple::doLedgerEntryGrpc

(

RPC::GRPCContext< org::xrpl::rpc::v1::GetLedgerEntryRequest > &

context

)

Definition at line 372 of file LedgerEntry.cpp.

doLedgerDataGrpc()

std::pair< org::xrpl::rpc::v1::GetLedgerDataResponse, grpc::Status > ripple::doLedgerDataGrpc

(

RPC::GRPCContext< org::xrpl::rpc::v1::GetLedgerDataRequest > &

context

)

Definition at line 132 of file LedgerData.cpp.

doLedgerDiffGrpc()

std::pair< org::xrpl::rpc::v1::GetLedgerDiffResponse, grpc::Status > ripple::doLedgerDiffGrpc

(

RPC::GRPCContext< org::xrpl::rpc::v1::GetLedgerDiffRequest > &

context

)

Definition at line 6 of file LedgerDiff.cpp.

addChannel()

void ripple::addChannel	(	Json::Value &	jsonLines,
		SLE const &	line
	)

Definition at line 35 of file AccountChannels.cpp.

doAccountChannels()

Json::Value ripple::doAccountChannels

(

RPC::JsonContext &

context

)

Definition at line 68 of file AccountChannels.cpp.

doAccountCurrencies()

Json::Value ripple::doAccountCurrencies

(

RPC::JsonContext &

context

)

Definition at line 32 of file AccountCurrenciesHandler.cpp.

doAccountInfo()

Json::Value ripple::doAccountInfo

(

RPC::JsonContext &

context

)

Definition at line 53 of file AccountInfo.cpp.

addLine()

void ripple::addLine	(	Json::Value &	jsonLines,
		RippleState const &	line
	)

Definition at line 42 of file AccountLines.cpp.

doAccountLines()

Json::Value ripple::doAccountLines

(

RPC::JsonContext &

context

)

Definition at line 83 of file AccountLines.cpp.

doAccountObjects()

Json::Value ripple::doAccountObjects

(

RPC::JsonContext &

context

)

General RPC command that can retrieve objects in the account root.

{ account: <account>|<account_public_key> ledger_hash: <string> // optional ledger_index: <string | unsigned integer> // optional type: <string> // optional, defaults to all account objects types limit: <integer> // optional marker: <opaque> // optional, resume previous query }

Definition at line 50 of file AccountObjects.cpp.

appendOfferJson()

void ripple::appendOfferJson	(	std::shared_ptr< SLE const > const &	offer,
		Json::Value &	offers
	)

Definition at line 35 of file AccountOffers.cpp.

doAccountOffers()

Json::Value ripple::doAccountOffers

(

RPC::JsonContext &

context

)

Definition at line 57 of file AccountOffers.cpp.

parseLedgerArgs() [1/2]

std::variant<std::optional<LedgerSpecifier>, grpc::Status> ripple::parseLedgerArgs

(

org::xrpl::rpc::v1::GetAccountTransactionHistoryRequest const &

params

)

Definition at line 56 of file AccountTx.cpp.

parseLedgerArgs() [2/2]

std::variant<std::optional<LedgerSpecifier>, Json::Value> ripple::parseLedgerArgs

(

Json::Value const &

params

)

Definition at line 119 of file AccountTx.cpp.

getLedgerRange()

std::variant<LedgerRange, RPC::Status> ripple::getLedgerRange	(	RPC::Context &	context,
		std::optional< LedgerSpecifier > const &	ledgerSpecifier
	)

Definition at line 184 of file AccountTx.cpp.

doAccountTxHelp()

std::pair<AccountTxResult, RPC::Status> ripple::doAccountTxHelp	(	RPC::Context &	context,
		AccountTxArgs const &	args
	)

Definition at line 256 of file AccountTx.cpp.

populateProtoResponse() [1/2]

std::pair< org::xrpl::rpc::v1::GetAccountTransactionHistoryResponse, grpc::Status> ripple::populateProtoResponse	(	std::pair< AccountTxResult, RPC::Status > const &	res,
		AccountTxArgs const &	args,
		RPC::GRPCContext< org::xrpl::rpc::v1::GetAccountTransactionHistoryRequest > const &	context
	)

Definition at line 333 of file AccountTx.cpp.

populateJsonResponse() [1/2]

Json::Value ripple::populateJsonResponse	(	std::pair< AccountTxResult, RPC::Status > const &	res,
		AccountTxArgs const &	args,
		RPC::JsonContext const &	context
	)

Definition at line 456 of file AccountTx.cpp.

doAccountTxJson()

Json::Value ripple::doAccountTxJson

(

RPC::JsonContext &

context

)

Definition at line 540 of file AccountTx.cpp.

doAccountTxOld()

Json::Value ripple::doAccountTxOld

(

RPC::JsonContext &

context

)

Definition at line 48 of file AccountTxOld.cpp.

doBlackList()

Json::Value ripple::doBlackList

(

RPC::JsonContext &

context

)

Definition at line 28 of file BlackList.cpp.

doBookOffers()

Json::Value ripple::doBookOffers

(

RPC::JsonContext &

context

)

Definition at line 35 of file BookOffers.cpp.

doCanDelete()

Json::Value ripple::doCanDelete

(

RPC::JsonContext &

context

)

Definition at line 35 of file CanDelete.cpp.

doConnect()

Json::Value ripple::doConnect

(

RPC::JsonContext &

context

)

Definition at line 38 of file Connect.cpp.

doConsensusInfo()

Json::Value ripple::doConsensusInfo

(

RPC::JsonContext &

context

)

Definition at line 31 of file ConsensusInfo.cpp.

doCrawlShards()

Json::Value ripple::doCrawlShards

(

RPC::JsonContext &

context

)

RPC command that reports stored shards by nodes.

{ Determines if the result includes node public key. optional, default is false public_key: <bool>

The maximum number of peer hops to attempt. optional, default is zero, maximum is 3 limit: <integer> }

Definition at line 44 of file CrawlShards.cpp.

doDepositAuthorized()

Json::Value ripple::doDepositAuthorized

(

RPC::JsonContext &

context

)

Definition at line 37 of file DepositAuthorized.cpp.

doDownloadShard()

Json::Value ripple::doDownloadShard

(

RPC::JsonContext &

context

)

RPC command that downloads and import shard archives.

{ shards: [{index: <integer>, url: <string>}] }

example: { "command": "download_shard", "shards": [ {"index": 1, "url": "https://domain.com/1.tar.lz4"}, {"index": 5, "url": "https://domain.com/5.tar.lz4"} ] }

Definition at line 49 of file DownloadShard.cpp.

doFeature()

Json::Value ripple::doFeature

(

RPC::JsonContext &

context

)

Definition at line 35 of file Feature1.cpp.

doFee()

Json::Value ripple::doFee

(

RPC::JsonContext &

context

)

Definition at line 31 of file Fee1.cpp.

doFetchInfo()

Json::Value ripple::doFetchInfo

(

RPC::JsonContext &

context

)

Definition at line 31 of file FetchInfo.cpp.

doGatewayBalances()

Json::Value ripple::doGatewayBalances

(

RPC::JsonContext &

context

)

Definition at line 53 of file GatewayBalances.cpp.

textTime()

static void ripple::textTime ( std::string &  text, UptimeClock::time_point &  seconds, const char *  unitName, std::chrono::seconds  unitVal  )

static

Definition at line 40 of file GetCounts.cpp.

getCountsJson()

Json::Value ripple::getCountsJson	(	Application &	app,
		int	minObjectCount
	)

Definition at line 65 of file GetCounts.cpp.

doGetCounts()

Json::Value ripple::doGetCounts

(

RPC::JsonContext &

context

)

Definition at line 160 of file GetCounts.cpp.

doChannelAuthorize()

Json::Value ripple::doChannelAuthorize

(

RPC::JsonContext &

context

)

Definition at line 44 of file PayChanClaim.cpp.

doChannelVerify()

Json::Value ripple::doChannelVerify

(

RPC::JsonContext &

context

)

Definition at line 98 of file PayChanClaim.cpp.

doLedgerAccept()

Json::Value ripple::doLedgerAccept

(

RPC::JsonContext &

context

)

Definition at line 35 of file LedgerAccept.cpp.

doLedgerCleaner()

Json::Value ripple::doLedgerCleaner

(

RPC::JsonContext &

context

)

Definition at line 29 of file LedgerCleanerHandler.cpp.

doLedgerClosed()

Json::Value ripple::doLedgerClosed

(

RPC::JsonContext &

context

)

Definition at line 29 of file LedgerClosed.cpp.

doLedgerCurrent()

Json::Value ripple::doLedgerCurrent

(

RPC::JsonContext &

context

)

Definition at line 30 of file LedgerCurrent.cpp.

doLedgerData()

Json::Value ripple::doLedgerData

(

RPC::JsonContext &

context

)

Definition at line 46 of file LedgerData.cpp.

doLedgerEntry()

Json::Value ripple::doLedgerEntry

(

RPC::JsonContext &

context

)

Definition at line 41 of file LedgerEntry.cpp.

doLedgerHeader()

Json::Value ripple::doLedgerHeader

(

RPC::JsonContext &

context

)

Definition at line 33 of file LedgerHeader.cpp.

doLedgerRequest()

Json::Value ripple::doLedgerRequest

(

RPC::JsonContext &

context

)

Definition at line 38 of file LedgerRequest.cpp.

doLogLevel()

Json::Value ripple::doLogLevel

(

RPC::JsonContext &

context

)

Definition at line 32 of file LogLevel.cpp.

doLogRotate()

Json::Value ripple::doLogRotate

(

RPC::JsonContext &

context

)

Definition at line 28 of file LogRotate.cpp.

doManifest()

Json::Value ripple::doManifest

(

RPC::JsonContext &

context

)

Definition at line 30 of file rpc/handlers/Manifest.cpp.

doNodeToShard()

Json::Value ripple::doNodeToShard

(

RPC::JsonContext &

context

)

Definition at line 33 of file NodeToShard.cpp.

doNoRippleCheck()

Json::Value ripple::doNoRippleCheck

(

RPC::JsonContext &

context

)

Definition at line 61 of file NoRippleCheck.cpp.

doOwnerInfo()

Json::Value ripple::doOwnerInfo

(

RPC::JsonContext &

context

)

Definition at line 34 of file OwnerInfo.cpp.

doPathFind()

Json::Value ripple::doPathFind

(

RPC::JsonContext &

context

)

Definition at line 33 of file PathFind.cpp.

doPause()

Json::Value ripple::doPause

(

RPC::JsonContext &

)

doPeers()

Json::Value ripple::doPeers

(

RPC::JsonContext &

context

)

Definition at line 32 of file Peers.cpp.

doPing()

Json::Value ripple::doPing

(

RPC::JsonContext &

context

)

Definition at line 32 of file Ping.cpp.

doPrint()

Json::Value ripple::doPrint

(

RPC::JsonContext &

context

)

Definition at line 29 of file Print.cpp.

doRandom()

Json::Value ripple::doRandom

(

RPC::JsonContext &

context

)

Definition at line 39 of file Random.cpp.

doResume()

Json::Value ripple::doResume

(

RPC::JsonContext &

)

doPeerReservationsAdd()

Json::Value ripple::doPeerReservationsAdd

(

RPC::JsonContext &

context

)

Definition at line 35 of file Reservations.cpp.

doPeerReservationsDel()

Json::Value ripple::doPeerReservationsDel

(

RPC::JsonContext &

context

)

Definition at line 91 of file Reservations.cpp.

doPeerReservationsList()

Json::Value ripple::doPeerReservationsList

(

RPC::JsonContext &

context

)

Definition at line 121 of file Reservations.cpp.

doRipplePathFind()

Json::Value ripple::doRipplePathFind

(

RPC::JsonContext &

context

)

Definition at line 32 of file RipplePathFind.cpp.

doServerInfo()

Json::Value ripple::doServerInfo

(

RPC::JsonContext &

context

)

Definition at line 33 of file ServerInfo.cpp.

doServerState()

Json::Value ripple::doServerState

(

RPC::JsonContext &

context

)

Definition at line 31 of file ServerState.cpp.

doSign()

Json::Value ripple::doSign

(

RPC::JsonContext &

context

)

Definition at line 33 of file SignHandler.cpp.

doSignFor()

Json::Value ripple::doSignFor

(

RPC::JsonContext &

context

)

Definition at line 35 of file SignFor.cpp.

doStop()

Json::Value ripple::doStop

(

RPC::JsonContext &

context

)

Definition at line 33 of file Stop.cpp.

doSubmit()

Json::Value ripple::doSubmit

(

RPC::JsonContext &

context

)

Definition at line 48 of file Submit.cpp.

doSubmitMultiSigned()

Json::Value ripple::doSubmitMultiSigned

(

RPC::JsonContext &

context

)

Definition at line 34 of file SubmitMultiSigned.cpp.

doSubscribe()

Json::Value ripple::doSubscribe

(

RPC::JsonContext &

context

)

Definition at line 37 of file Subscribe.cpp.

doTransactionEntry()

Json::Value ripple::doTransactionEntry

(

RPC::JsonContext &

context

)

Definition at line 36 of file TransactionEntry.cpp.

doTxJson()

Json::Value ripple::doTxJson

(

RPC::JsonContext &

context

)

Definition at line 402 of file Tx.cpp.

doTxHistory()

Json::Value ripple::doTxHistory

(

RPC::JsonContext &

context

)

Definition at line 42 of file TxHistory.cpp.

doTxReduceRelay()

Json::Value ripple::doTxReduceRelay

(

RPC::JsonContext &

context

)

Definition at line 28 of file TxReduceRelay.cpp.

doUnlList()

Json::Value ripple::doUnlList

(

RPC::JsonContext &

context

)

Definition at line 30 of file UnlList.cpp.

doUnsubscribe()

Json::Value ripple::doUnsubscribe

(

RPC::JsonContext &

context

)

Definition at line 32 of file Unsubscribe.cpp.

doValidationCreate()

Json::Value ripple::doValidationCreate

(

RPC::JsonContext &

context

)

Definition at line 45 of file ValidationCreate.cpp.

doWalletPropose()

Json::Value ripple::doWalletPropose

(

RPC::JsonContext &

context

)

Definition at line 67 of file WalletPropose.cpp.

doValidators()

Json::Value ripple::doValidators

(

RPC::JsonContext &

context

)

Definition at line 29 of file Validators.cpp.

doValidatorListSites()

Json::Value ripple::doValidatorListSites

(

RPC::JsonContext &

context

)

Definition at line 29 of file ValidatorListSites.cpp.

doValidatorInfo()

Json::Value ripple::doValidatorInfo

(

RPC::JsonContext &

context

)

Definition at line 30 of file ValidatorInfo.cpp.

fillTransaction()

static void ripple::fillTransaction ( RPC::JsonContext &  context, Json::Value &  txArray, AccountID const &  accountID, std::uint32_t &  sequence, ReadView const &  ledger  )

static

Definition at line 35 of file NoRippleCheck.cpp.

getFailHard()

static NetworkOPs::FailHard ripple::getFailHard ( RPC::JsonContext const &  context )

static

Definition at line 36 of file Submit.cpp.

isValidated()

static bool ripple::isValidated ( LedgerMaster &  ledgerMaster, std::uint32_t  seq, uint256 const &  hash  )

static

Definition at line 41 of file Tx.cpp.

doTxPostgres()

std::pair<TxResult, RPC::Status> ripple::doTxPostgres	(	RPC::Context &	context,
		TxArgs const &	args
	)

Definition at line 68 of file Tx.cpp.

doTxHelp()

std::pair<TxResult, RPC::Status> ripple::doTxHelp	(	RPC::Context &	context,
		TxArgs const &	args
	)

Definition at line 171 of file Tx.cpp.

populateProtoResponse() [2/2]

std::pair<org::xrpl::rpc::v1::GetTransactionResponse, grpc::Status> ripple::populateProtoResponse	(	std::pair< TxResult, RPC::Status > const &	res,
		TxArgs const &	args,
		RPC::GRPCContext< org::xrpl::rpc::v1::GetTransactionRequest > const &	context
	)

Definition at line 255 of file Tx.cpp.

populateJsonResponse() [2/2]

Json::Value ripple::populateJsonResponse	(	std::pair< TxResult, RPC::Status > const &	res,
		TxArgs const &	args,
		RPC::JsonContext const &	context
	)

Definition at line 350 of file Tx.cpp.

validationSeed()

static std::optional<Seed> ripple::validationSeed ( Json::Value const &  params )

static

Definition at line 30 of file ValidationCreate.cpp.

estimate_entropy()

double ripple::estimate_entropy

(

std::string const &

input

)

Definition at line 38 of file WalletPropose.cpp.

walletPropose()

Json::Value ripple::walletPropose

(

Json::Value const &

params

)

Definition at line 73 of file WalletPropose.cpp.

passwordUnrequiredOrSentCorrect()

bool ripple::passwordUnrequiredOrSentCorrect	(	Port const &	port,
		Json::Value const &	params
	)

Definition at line 30 of file Role.cpp.

ipAllowed()

bool ripple::ipAllowed	(	beast::IP::Address const &	remoteIp,
		std::vector< beast::IP::Address > const &	adminIp
	)

True if remoteIp is in any of adminIp.

Parameters

remoteIp	Remote address for which to search.
adminIp	List of IP's in which to search.

Returns

Whether remoteIp is in adminIp.

Definition at line 44 of file Role.cpp.

isAdmin()

bool ripple::isAdmin	(	Port const &	port,
		Json::Value const &	params,
		beast::IP::Address const &	remoteIp
	)

Definition at line 57 of file Role.cpp.

requestRole()

Role ripple::requestRole	(	Role const &	required,
		Port const &	port,
		Json::Value const &	params,
		beast::IP::Endpoint const &	remoteIp,
		boost::string_view const &	user
	)

Return the allowed privilege role.

params must meet the requirements of the JSON-RPC specification. It must be of type Object, containing the key params which is an array with at least one object. Inside this object are the optional keys 'admin_user' and 'admin_password' used to validate the credentials. If user is non-blank, it's username passed in the HTTP header by a secure_gateway proxy.

Definition at line 67 of file Role.cpp.

isUnlimited() [1/2]

bool ripple::isUnlimited

(

Role const &

role

)

ADMIN and IDENTIFIED roles shall have unlimited resources.

Check if the role entitles the user to unlimited resources.

Definition at line 94 of file Role.cpp.

isUnlimited() [2/2]

bool ripple::isUnlimited	(	Role const &	required,
		Port const &	port,
		Json::Value const &	params,
		beast::IP::Endpoint const &	remoteIp,
		std::string const &	user
	)

Definition at line 100 of file Role.cpp.

requestInboundEndpoint()

Resource::Consumer ripple::requestInboundEndpoint	(	Resource::Manager &	manager,
		beast::IP::Endpoint const &	remoteAddress,
		Role const &	role,
		boost::string_view const &	user,
		boost::string_view const &	forwardedFor
	)

Definition at line 111 of file Role.cpp.

forwardedFor()

boost::string_view ripple::forwardedFor

(

http_request_type const &

request

)

Definition at line 126 of file Role.cpp.

isStatusRequest()

static bool ripple::isStatusRequest ( http_request_type const &  request )

static

Definition at line 56 of file ServerHandlerImp.cpp.

statusRequestResponse()

static Handoff ripple::statusRequestResponse ( http_request_type const &  request, boost::beast::http::status  status  )

static

Definition at line 64 of file ServerHandlerImp.cpp.

authorized()

static bool ripple::authorized ( Port const &  port, std::map< std::string, std::string > const &  h  )

static

Definition at line 84 of file ServerHandlerImp.cpp.

makeOutput()

static Json::Output ripple::makeOutput ( Session &  session )

static

Definition at line 236 of file ServerHandlerImp.cpp.

build_map()

static std::map<std::string, std::string> ripple::build_map ( boost::beast::http::fields const &  h )

static

Definition at line 244 of file ServerHandlerImp.cpp.

buffers_to_string()

template<class ConstBufferSequence >

static std::string ripple::buffers_to_string ( ConstBufferSequence const &  bs )

static

Definition at line 260 of file ServerHandlerImp.cpp.

make_json_error()

static Json::Value ripple::make_json_error ( Json::Int  code, Json::Value &&  message  )

static

Definition at line 550 of file ServerHandlerImp.cpp.

to_Port()

static Port ripple::to_Port ( ParsedPort const &  parsed, std::ostream &  log  )

static

Definition at line 1014 of file ServerHandlerImp.cpp.

parse_Ports()

static std::vector<Port> ripple::parse_Ports ( Config const &  config, std::ostream &  log  )

static

Definition at line 1065 of file ServerHandlerImp.cpp.

setup_Client()

static void ripple::setup_Client ( ServerHandler::Setup &  setup )

static

Definition at line 1131 of file ServerHandlerImp.cpp.

setup_Overlay() [2/2]

static void ripple::setup_Overlay ( ServerHandler::Setup &  setup )

static

Definition at line 1155 of file ServerHandlerImp.cpp.

setup_ServerHandler()

ServerHandler::Setup ripple::setup_ServerHandler	(	Config const &	config,
		std::ostream &&	log
	)

Definition at line 1171 of file ServerHandlerImp.cpp.

make_ServerHandler()

std::unique_ptr< ServerHandler > ripple::make_ServerHandler	(	Application &	app,
		boost::asio::io_service &	io_service,
		JobQueue &	jobQueue,
		NetworkOPs &	networkOPs,
		Resource::Manager &	resourceManager,
		CollectorManager &	cm
	)

Definition at line 1183 of file ServerHandlerImp.cpp.

operator<() [10/10]

bool ripple::operator<	(	Port const &	lhs,
		Port const &	rhs
	)

Definition at line 42 of file ServerHandlerImp.h.

getHTTPHeaderTimestamp()

std::string ripple::getHTTPHeaderTimestamp

(

)

Definition at line 31 of file JSONRPCUtil.cpp.

HTTPReply()

void ripple::HTTPReply	(	int	nStatus,
		std::string const &	content,
		Json::Output const &	output,
		beast::Journal	j
	)

Definition at line 56 of file JSONRPCUtil.cpp.

get_lowest_layer()

template<class T >

decltype(auto) ripple::get_lowest_layer ( T &  t )

noexcept

Definition at line 35 of file LowestLayer.h.

operator<<() [14/15]

std::ostream & ripple::operator<<	(	std::ostream &	os,
		Port const &	p
	)

Definition at line 46 of file Port.cpp.

populate()

static void ripple::populate ( Section const &  section, std::string const &  field, std::ostream &  log, std::optional< std::vector< beast::IP::Address >> &  ips, bool  allowAllIps, std::vector< beast::IP::Address > const &  admin_ip  )

static

Definition at line 71 of file Port.cpp.

parse_Port()

void ripple::parse_Port	(	ParsedPort &	port,
		Section const &	section,
		std::ostream &	log
	)

Definition at line 139 of file Port.cpp.

make_Server()

template<class Handler >

std::unique_ptr<Server> ripple::make_Server	(	Handler &	handler,
		boost::asio::io_service &	io_service,
		beast::Journal	journal
	)

Create the HTTP server using the specified handler.

Definition at line 34 of file Server.h.

makeTypedLeaf()

std::shared_ptr<SHAMapLeafNode> ripple::makeTypedLeaf	(	SHAMapNodeType	type,
		std::shared_ptr< SHAMapItem const >	item,
		std::uint32_t	owner
	)

Definition at line 31 of file SHAMap.cpp.

depthMask()

static uint256 const& ripple::depthMask ( unsigned int  depth )

static

Definition at line 30 of file SHAMapNodeID.cpp.

deserializeSHAMapNodeID() [1/2]

std::optional< SHAMapNodeID > ripple::deserializeSHAMapNodeID	(	void const *	data,
		std::size_t	size
	)

Return an object representing a serialized SHAMap Node ID.

Parameters

s	A string of bytes
data	a non-null pointer to a buffer of
size	bytes.
size	the size, in bytes, of the buffer pointed to by
data.

Returns

A seated optional if the buffer contained a serialized SHAMap node ID and an unseated optional otherwise.

Definition at line 101 of file SHAMapNodeID.cpp.

selectBranch()

unsigned int ripple::selectBranch	(	SHAMapNodeID const &	id,
		uint256 const &	hash
	)

Returns the branch that would contain the given hash.

Definition at line 121 of file SHAMapNodeID.cpp.

getShardStore()

static NodeStore::Database& ripple::getShardStore ( Application &  app )

static

Definition at line 29 of file ShardFamily.cpp.

operator==() [15/15]

bool ripple::operator==	(	SHAMap::const_iterator const &	x,
		SHAMap::const_iterator const &	y
	)

Definition at line 688 of file SHAMap.h.

operator!=() [11/12]

bool ripple::operator!=	(	SHAMap::const_iterator const &	x,
		SHAMap::const_iterator const &	y
	)

Definition at line 695 of file SHAMap.h.

to_string() [25/26]

std::string ripple::to_string

(

SHAMapType

t

)

Definition at line 39 of file SHAMapMissingNode.h.

to_string() [26/26]

std::string ripple::to_string

(

SHAMapNodeID const &

node

)

Definition at line 123 of file SHAMapNodeID.h.

operator<<() [15/15]

std::ostream& ripple::operator<<	(	std::ostream &	out,
		SHAMapNodeID const &	node
	)

Definition at line 133 of file SHAMapNodeID.h.

deserializeSHAMapNodeID() [2/2]

std::optional<SHAMapNodeID> ripple::deserializeSHAMapNodeID

(

std::string const &

s

)

Definition at line 151 of file SHAMapNodeID.h.

operator!=() [12/12]

bool ripple::operator!=	(	SHAMapHash const &	x,
		SHAMapHash const &	y
	)

Definition at line 122 of file SHAMapTreeNode.h.

BEAST_DEFINE_TESTSUITE() [1/62]

ripple::BEAST_DEFINE_TESTSUITE	(	AccountTxPaging	,
		app	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [2/62]

ripple::BEAST_DEFINE_TESTSUITE	(	AmendmentTable	,
		app	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [3/62]

ripple::BEAST_DEFINE_TESTSUITE	(	Check	,
		tx	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [4/62]

ripple::BEAST_DEFINE_TESTSUITE	(	Discrepancy	,
		app	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [5/62]

ripple::BEAST_DEFINE_TESTSUITE	(	Freeze	,
		app	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [6/62]

ripple::BEAST_DEFINE_TESTSUITE	(	LedgerLoad	,
		app	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [7/62]

ripple::BEAST_DEFINE_TESTSUITE	(	LoadFeeTrack	,
		ripple_core	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [8/62]

ripple::BEAST_DEFINE_TESTSUITE	(	OfferStream	,
		tx	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [9/62]

ripple::BEAST_DEFINE_TESTSUITE	(	SetRegularKey	,
		app	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [10/62]

ripple::BEAST_DEFINE_TESTSUITE	(	Taker	,
		tx	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [11/62]

ripple::BEAST_DEFINE_TESTSUITE	(	Ticket	,
		tx	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [12/62]

ripple::BEAST_DEFINE_TESTSUITE	(	TrustAndBalance	,
		app	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [13/62]

ripple::BEAST_DEFINE_TESTSUITE	(	Apply	,
		app	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [14/62]

ripple::BEAST_DEFINE_TESTSUITE	(	base64	,
		ripple_basics	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [15/62]

ripple::BEAST_DEFINE_TESTSUITE	(	contract	,
		basics	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [16/62]

ripple::BEAST_DEFINE_TESTSUITE	(	FileUtilities	,
		ripple_basics	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [17/62]

ripple::BEAST_DEFINE_TESTSUITE	(	hardened_hash	,
		basics	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [18/62]

ripple::BEAST_DEFINE_TESTSUITE	(	IOUAmount	,
		protocol	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [19/62]

ripple::BEAST_DEFINE_TESTSUITE	(	KeyCache	,
		common	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [20/62]

ripple::BEAST_DEFINE_TESTSUITE	(	PerfLog	,
		basics	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [21/62]

ripple::BEAST_DEFINE_TESTSUITE	(	RangeSet	,
		ripple_basics	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [22/62]

ripple::BEAST_DEFINE_TESTSUITE	(	StringUtilities	,
		ripple_basics	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [23/62]

ripple::BEAST_DEFINE_TESTSUITE	(	TaggedCache	,
		common	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [24/62]

ripple::BEAST_DEFINE_TESTSUITE	(	XRPAmount	,
		protocol	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [25/62]

ripple::BEAST_DEFINE_TESTSUITE	(	Config	,
		core	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [26/62]

ripple::BEAST_DEFINE_TESTSUITE	(	CryptoPRNG	,
		core	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [27/62]

ripple::BEAST_DEFINE_TESTSUITE	(	SociDB	,
		core	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [28/62]

ripple::BEAST_DEFINE_TESTSUITE	(	Workers	,
		core	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [29/62]

ripple::BEAST_DEFINE_TESTSUITE	(	json_value	,
		json	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [30/62]

ripple::BEAST_DEFINE_TESTSUITE	(	Invariants	,
		ledger	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [31/62]

ripple::BEAST_DEFINE_TESTSUITE	(	ProtocolVersion	,
		overlay	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [32/62]

ripple::BEAST_DEFINE_TESTSUITE	(	short_read	,
		overlay	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [33/62]

ripple::BEAST_DEFINE_TESTSUITE	(	BuildInfo	,
		protocol	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [34/62]

ripple::BEAST_DEFINE_TESTSUITE	(	InnerObjectFormatsParsedJSON	,
		ripple_app	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [35/62]

ripple::BEAST_DEFINE_TESTSUITE	(	Issue	,
		protocol	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [36/62]

ripple::BEAST_DEFINE_TESTSUITE	(	KnownFormatToGRPC	,
		protocol	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [37/62]

ripple::BEAST_DEFINE_TESTSUITE	(	PublicKey	,
		protocol	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [38/62]

ripple::BEAST_DEFINE_TESTSUITE	(	Quality	,
		protocol	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [39/62]

ripple::BEAST_DEFINE_TESTSUITE	(	SecretKey	,
		protocol	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [40/62]

ripple::BEAST_DEFINE_TESTSUITE	(	Seed	,
		protocol	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [41/62]

ripple::BEAST_DEFINE_TESTSUITE	(	SeqProxy	,
		protocol	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [42/62]

ripple::BEAST_DEFINE_TESTSUITE	(	STAccount	,
		protocol	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [43/62]

ripple::BEAST_DEFINE_TESTSUITE	(	STAmount	,
		ripple_data	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [44/62]

ripple::BEAST_DEFINE_TESTSUITE	(	STObject	,
		protocol	,
		ripple
	)

matches()

bool ripple::matches	(	char const *	string,
		char const *	regex
	)

Return true if the string loosely matches the regex.

Meant for testing human-readable strings that may change over time.

Definition at line 42 of file STTx_test.cpp.

BEAST_DEFINE_TESTSUITE() [45/62]

ripple::BEAST_DEFINE_TESTSUITE	(	STTx	,
		ripple_app	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [46/62]

ripple::BEAST_DEFINE_TESTSUITE	(	InnerObjectFormatsSerializer	,
		ripple_app	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [47/62]

ripple::BEAST_DEFINE_TESTSUITE	(	STValidation	,
		protocol	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [48/62]

ripple::BEAST_DEFINE_TESTSUITE	(	TER	,
		protocol	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [49/62]

ripple::BEAST_DEFINE_TESTSUITE	(	types	,
		protocol	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [50/62]

ripple::BEAST_DEFINE_TESTSUITE	(	AccountCurrencies	,
		app	,
		ripple
	)

BEAST_DEFINE_TESTSUITE_PRIO() [1/2]

ripple::BEAST_DEFINE_TESTSUITE_PRIO	(	AccountSet	,
		app	,
		ripple	,
		1
	)

BEAST_DEFINE_TESTSUITE() [51/62]

ripple::BEAST_DEFINE_TESTSUITE	(	AmendmentBlocked	,
		app	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [52/62]

ripple::BEAST_DEFINE_TESTSUITE	(	Feature	,
		rpc	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [53/62]

ripple::BEAST_DEFINE_TESTSUITE	(	GetCounts	,
		rpc	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [54/62]

ripple::BEAST_DEFINE_TESTSUITE	(	LedgerClosed	,
		app	,
		ripple
	)

BEAST_DEFINE_TESTSUITE_PRIO() [2/2]

ripple::BEAST_DEFINE_TESTSUITE_PRIO	(	LedgerData	,
		app	,
		ripple	,
		1
	)

BEAST_DEFINE_TESTSUITE() [55/62]

ripple::BEAST_DEFINE_TESTSUITE	(	LedgerRPC	,
		app	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [56/62]

ripple::BEAST_DEFINE_TESTSUITE	(	NoRippleCheck	,
		app	,
		ripple
	)

BEAST_DEFINE_TESTSUITE_MANUAL_PRIO()

ripple::BEAST_DEFINE_TESTSUITE_MANUAL_PRIO	(	NoRippleCheckLimits	,
		app	,
		ripple	,
		1
	)

BEAST_DEFINE_TESTSUITE() [57/62]

ripple::BEAST_DEFINE_TESTSUITE	(	OwnerInfo	,
		app	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [58/62]

ripple::BEAST_DEFINE_TESTSUITE	(	Peers	,
		rpc	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [59/62]

ripple::BEAST_DEFINE_TESTSUITE	(	Transaction	,
		rpc	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [60/62]

ripple::BEAST_DEFINE_TESTSUITE	(	TransactionEntry	,
		rpc	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [61/62]

ripple::BEAST_DEFINE_TESTSUITE	(	TransactionHistory	,
		rpc	,
		ripple
	)

BEAST_DEFINE_TESTSUITE() [62/62]

ripple::BEAST_DEFINE_TESTSUITE	(	Version	,
		rpc	,
		ripple
	)

Variable Documentation

ledgerAcquireTimeout

constexpr auto ripple::ledgerAcquireTimeout = 2500ms

constexpr

Definition at line 72 of file InboundLedger.cpp.

MAX_LEDGER_GAP

constexpr int ripple::MAX_LEDGER_GAP {100}

staticconstexpr

Definition at line 147 of file LedgerMaster.cpp.

MAX_LEDGER_AGE_ACQUIRE

constexpr std::chrono::minutes ripple::MAX_LEDGER_AGE_ACQUIRE {1}

staticconstexpr

Definition at line 150 of file LedgerMaster.cpp.

MAX_WRITE_LOAD_ACQUIRE

constexpr int ripple::MAX_WRITE_LOAD_ACQUIRE {8192}

staticconstexpr

Definition at line 153 of file LedgerMaster.cpp.

TX_ACQUIRE_TIMEOUT

constexpr auto ripple::TX_ACQUIRE_TIMEOUT = 250ms

constexpr

Definition at line 36 of file TransactionAcquire.cpp.

create_genesis

const create_genesis_t ripple::create_genesis {}

Definition at line 62 of file Ledger.cpp.

FLAG_LEDGER_INTERVAL

constexpr std::uint32_t ripple::FLAG_LEDGER_INTERVAL = 256

constexpr

Definition at line 416 of file Ledger.h.

CachedLedgerAge

constexpr std::chrono::seconds ripple::CachedLedgerAge = std::chrono::minutes{2}

constexpr

Definition at line 35 of file LedgerHistory.cpp.

CommonDBPragmaJournal

constexpr char const* ripple::CommonDBPragmaJournal {"PRAGMA journal_mode=%s;"}

constexpr

Definition at line 32 of file DBInit.h.

CommonDBPragmaSync

constexpr char const* ripple::CommonDBPragmaSync {"PRAGMA synchronous=%s;"}

constexpr

Definition at line 33 of file DBInit.h.

CommonDBPragmaTemp

constexpr char const* ripple::CommonDBPragmaTemp {"PRAGMA temp_store=%s;"}

constexpr

Definition at line 34 of file DBInit.h.

SQLITE_TUNING_CUTOFF

constexpr std::uint32_t ripple::SQLITE_TUNING_CUTOFF = 10'000'000

constexpr

Definition at line 40 of file DBInit.h.

LgrDBName

constexpr auto ripple::LgrDBName {"ledger.db"}

constexpr

Definition at line 43 of file DBInit.h.

LgrDBPragma

constexpr std::array<char const*, 1> ripple::LgrDBPragma

constexpr

Initial value:

{
    {"PRAGMA journal_size_limit=1582080;"}}

Definition at line 45 of file DBInit.h.

LgrDBInit

constexpr std::array<char const*, 5> ripple::LgrDBInit

constexpr

Initial value:

{
    {"BEGIN TRANSACTION;",
 
     "CREATE TABLE IF NOT EXISTS Ledgers (           \
        LedgerHash      CHARACTER(64) PRIMARY KEY,  \
        LedgerSeq       BIGINT UNSIGNED,            \
        PrevHash        CHARACTER(64),              \
        TotalCoins      BIGINT UNSIGNED,            \
        ClosingTime     BIGINT UNSIGNED,            \
        PrevClosingTime BIGINT UNSIGNED,            \
        CloseTimeRes    BIGINT UNSIGNED,            \
        CloseFlags      BIGINT UNSIGNED,            \
        AccountSetHash  CHARACTER(64),              \
        TransSetHash    CHARACTER(64)               \
    );",
     "CREATE INDEX IF NOT EXISTS SeqLedger ON Ledgers(LedgerSeq);",
 
     
     "DROP TABLE IF EXISTS Validations;",
 
     "END TRANSACTION;"}}

Definition at line 48 of file DBInit.h.

TxDBName

constexpr auto ripple::TxDBName {"transaction.db"}

constexpr

Definition at line 73 of file DBInit.h.

TxDBPragma

constexpr std::array ripple::TxDBPragma

constexpr

Initial value:

{
    "PRAGMA page_size=4096;", "PRAGMA journal_size_limit=1582080;",
        "PRAGMA max_page_count=2147483646;",
 
 
 
}

Definition at line 76 of file DBInit.h.

TxDBInit

constexpr std::array<char const*, 8> ripple::TxDBInit

constexpr

Initial value:

{
    {"BEGIN TRANSACTION;",
 
     "CREATE TABLE IF NOT EXISTS Transactions (          \
        TransID     CHARACTER(64) PRIMARY KEY,          \
        TransType   CHARACTER(24),                      \
        FromAcct    CHARACTER(35),                      \
        FromSeq     BIGINT UNSIGNED,                    \
        LedgerSeq   BIGINT UNSIGNED,                    \
        Status      CHARACTER(1),                       \
        RawTxn      BLOB,                               \
        TxnMeta     BLOB                                \
    );",
     "CREATE INDEX IF NOT EXISTS TxLgrIndex ON           \
        Transactions(LedgerSeq);",
 
     "CREATE TABLE IF NOT EXISTS AccountTransactions (   \
        TransID     CHARACTER(64),                      \
        Account     CHARACTER(64),                      \
        LedgerSeq   BIGINT UNSIGNED,                    \
        TxnSeq      INTEGER                             \
    );",
     "CREATE INDEX IF NOT EXISTS AcctTxIDIndex ON        \
        AccountTransactions(TransID);",
     "CREATE INDEX IF NOT EXISTS AcctTxIndex ON          \
        AccountTransactions(Account, LedgerSeq, TxnSeq, TransID);",
     "CREATE INDEX IF NOT EXISTS AcctLgrIndex ON         \
        AccountTransactions(LedgerSeq, Account, TransID);",
 
     "END TRANSACTION;"}}

Definition at line 84 of file DBInit.h.

LgrMetaDBName

constexpr auto ripple::LgrMetaDBName {"ledger_meta.db"}

constexpr

Definition at line 118 of file DBInit.h.

LgrMetaDBPragma

constexpr std::array ripple::LgrMetaDBPragma

constexpr

Initial value:

{
    "PRAGMA page_size=4096;", "PRAGMA journal_size_limit=1582080;",
        "PRAGMA max_page_count=2147483646;",
 
 
 
}

Definition at line 121 of file DBInit.h.

LgrMetaDBInit

constexpr std::array<char const*, 3> ripple::LgrMetaDBInit

constexpr

Initial value:

{
    {"BEGIN TRANSACTION;",
 
     "CREATE TABLE IF NOT EXISTS LedgerMeta (        \
        LedgerHash  CHARACTER(64) PRIMARY KEY,       \
        ShardIndex  INTEGER                          \
    );",
 
     "END TRANSACTION;"}}

Definition at line 129 of file DBInit.h.

TxMetaDBName

constexpr auto ripple::TxMetaDBName {"transaction_meta.db"}

constexpr

Definition at line 142 of file DBInit.h.

TxMetaDBPragma

constexpr std::array ripple::TxMetaDBPragma

constexpr

Initial value:

{
    "PRAGMA page_size=4096;", "PRAGMA journal_size_limit=1582080;",
        "PRAGMA max_page_count=2147483646;",
 
 
 
}

Definition at line 145 of file DBInit.h.

TxMetaDBInit

constexpr std::array<char const*, 3> ripple::TxMetaDBInit

constexpr

Initial value:

{
    {"BEGIN TRANSACTION;",
 
     "CREATE TABLE IF NOT EXISTS TransactionMeta (      \
        TransID     CHARACTER(64) PRIMARY KEY,          \
        ShardIndex  INTEGER                             \
    );",
 
     "END TRANSACTION;"}}

Definition at line 153 of file DBInit.h.

AcquireShardDBName

constexpr auto ripple::AcquireShardDBName {"acquire.db"}

constexpr

Definition at line 166 of file DBInit.h.

AcquireShardDBPragma

constexpr std::array<char const*, 1> ripple::AcquireShardDBPragma

constexpr

Initial value:

{
    {"PRAGMA journal_size_limit=1582080;"}}

Definition at line 168 of file DBInit.h.

AcquireShardDBInit

constexpr std::array<char const*, 1> ripple::AcquireShardDBInit

constexpr

Initial value:

{
    {"CREATE TABLE IF NOT EXISTS Shard (             \
        ShardIndex          INTEGER PRIMARY KEY,    \
        LastLedgerHash      CHARACTER(64),          \
        StoredLedgerSeqs    BLOB                    \
    );"}}

Definition at line 171 of file DBInit.h.

FinalShardDBPragma

constexpr std::array<char const*, 2> ripple::FinalShardDBPragma

constexpr

Initial value:

{
    {"PRAGMA synchronous=OFF;", "PRAGMA journal_mode=OFF;"}}

Definition at line 182 of file DBInit.h.

WalletDBName

constexpr auto ripple::WalletDBName {"wallet.db"}

constexpr

Definition at line 187 of file DBInit.h.

WalletDBInit

constexpr std::array<char const*, 6> ripple::WalletDBInit

constexpr

Initial value:

{
    {"BEGIN TRANSACTION;",
 
     
     
     
     
     
     
     "CREATE TABLE IF NOT EXISTS NodeIdentity (         \
        PublicKey       CHARACTER(53),                  \
        PrivateKey      CHARACTER(52)                   \
    );",
 
     
     "CREATE TABLE IF NOT EXISTS PeerReservations (     \
        PublicKey       CHARACTER(53) UNIQUE NOT NULL,  \
        Description     CHARACTER(64) NOT NULL          \
    );",
 
     
     "CREATE TABLE IF NOT EXISTS ValidatorManifests (   \
        RawData          BLOB NOT NULL                  \
    );",
 
     "CREATE TABLE IF NOT EXISTS PublisherManifests (   \
        RawData          BLOB NOT NULL                  \
    );",
 
     "END TRANSACTION;"}}

Definition at line 189 of file DBInit.h.

stateDBName

constexpr auto ripple::stateDBName {"state.db"}

staticconstexpr

Definition at line 222 of file DBInit.h.

DownloaderDBPragma

constexpr std::array<char const*, 2> ripple::DownloaderDBPragma

staticconstexpr

Initial value:

{
    {"PRAGMA synchronous=FULL;", "PRAGMA journal_mode=DELETE;"}}

Definition at line 225 of file DBInit.h.

ShardArchiveHandlerDBInit

constexpr std::array<char const*, 3> ripple::ShardArchiveHandlerDBInit

staticconstexpr

Initial value:

{
    {"BEGIN TRANSACTION;",
 
     "CREATE TABLE IF NOT EXISTS State (     \
         ShardIndex  INTEGER PRIMARY KEY,   \
         URL         TEXT                   \
     );",
 
     "END TRANSACTION;"}}

Definition at line 228 of file DBInit.h.

DatabaseBodyDBInit

constexpr std::array<char const*, 3> ripple::DatabaseBodyDBInit

staticconstexpr

Initial value:

{
    {"BEGIN TRANSACTION;",
 
     "CREATE TABLE IF NOT EXISTS download (      \
        Path        TEXT,                       \
        Data        BLOB,                       \
        Size        BIGINT UNSIGNED,            \
        Part        BIGINT UNSIGNED PRIMARY KEY \
    );",
 
     "END TRANSACTION;"}}

Definition at line 238 of file DBInit.h.

fullBelowTargetSize

constexpr std::size_t ripple::fullBelowTargetSize = 524288

constexpr

Definition at line 25 of file app/main/Tuning.h.

fullBelowExpiration

constexpr std::chrono::seconds ripple::fullBelowExpiration = std::chrono::minutes{10}

constexpr

Definition at line 26 of file app/main/Tuning.h.

default_refresh_interval

constexpr auto ripple::default_refresh_interval = std::chrono::minutes{5}

constexpr

Definition at line 34 of file ValidatorSite.cpp.

error_retry_interval

constexpr auto ripple::error_retry_interval = std::chrono::seconds{30}

constexpr

Definition at line 35 of file ValidatorSite.cpp.

max_redirects

unsigned constexpr short ripple::max_redirects = 3

constexpr

Definition at line 36 of file ValidatorSite.cpp.

stateNames

const std::array<char const*, 5> ripple::stateNames

static

Initial value:

{
    {"disconnected", "connected", "syncing", "tracking", "full"}}

Definition at line 827 of file NetworkOPs.cpp.

genesisAccountId

const auto ripple::genesisAccountId

static

Initial value:

= calcAccountID(
    generateKeyPair(KeyType::secp256k1, generateSeed("masterpassphrase"))
        .first)

Definition at line 840 of file NetworkOPs.cpp.

TableTypeCount

constexpr int ripple::TableTypeCount = 3

constexpr

Definition at line 35 of file RelationalDBInterface_nodes.h.

defaultSignerListID_

const std::uint32_t ripple::defaultSignerListID_ = 0

static

Definition at line 38 of file SetSignerList.cpp.

minMantissa

const std::int64_t ripple::minMantissa = 1000000000000000ull

static

Definition at line 31 of file IOUAmount.cpp.

maxMantissa

const std::int64_t ripple::maxMantissa = 9999999999999999ull

static

Definition at line 32 of file IOUAmount.cpp.

minExponent

const int ripple::minExponent = -96

static

Definition at line 34 of file IOUAmount.cpp.

maxExponent

const int ripple::maxExponent = 80

static

Definition at line 35 of file IOUAmount.cpp.

is_safetocasttovalue_v

template<class Dest , class Src >

constexpr bool ripple::is_safetocasttovalue_v

staticconstexpr

Initial value:

=
    (std::is_integral_v<Src> && std::is_integral_v<Dest>)&&(
        std::is_signed<Src>::value || std::is_unsigned<Dest>::value) &&
    (std::is_signed<Src>::value != std::is_signed<Dest>::value
         ? sizeof(Dest) > sizeof(Src)
         : sizeof(Dest) >= sizeof(Src))

Definition at line 32 of file safe_cast.h.

DROPS_PER_XRP

constexpr XRPAmount ripple::DROPS_PER_XRP {1'000'000}

constexpr

Number of drops per 1 XRP.

Definition at line 250 of file XRPAmount.h.

ledgerPossibleTimeResolutions

constexpr std::chrono::seconds ripple::ledgerPossibleTimeResolutions[]

constexpr

Initial value:

= {
    std::chrono::seconds{10},
    std::chrono::seconds{20},
    std::chrono::seconds{30},
    std::chrono::seconds{60},
    std::chrono::seconds{90},
    std::chrono::seconds{120}}

Possible ledger close time resolutions.

Values should not be duplicated.

See also

getNextLedgerTimeResolution

Definition at line 35 of file LedgerTiming.h.

ledgerDefaultTimeResolution

constexpr auto ripple::ledgerDefaultTimeResolution = ledgerPossibleTimeResolutions[2]

constexpr

Initial resolution of ledger close time.

Definition at line 44 of file LedgerTiming.h.

ledgerGenesisTimeResolution

constexpr auto ripple::ledgerGenesisTimeResolution = ledgerPossibleTimeResolutions[0]

constexpr

Close time resolution in genesis ledger.

Definition at line 47 of file LedgerTiming.h.

increaseLedgerTimeResolutionEvery

constexpr auto ripple::increaseLedgerTimeResolutionEvery = 8

constexpr

How often we increase the close time resolution (in numbers of ledgers)

Definition at line 50 of file LedgerTiming.h.

decreaseLedgerTimeResolutionEvery

constexpr auto ripple::decreaseLedgerTimeResolutionEvery = 1

constexpr

How often we decrease the close time resolution (in numbers of ledgers)

Definition at line 53 of file LedgerTiming.h.

sizedItems

constexpr std::array<std::pair<SizedItem, std::array<int, 5> >, 12> ripple::sizedItems

constexpr

Initial value:

{{
    
    
    
 
    
    {SizedItem::sweepInterval,   {{     10,      30,      60,      90,      120 }}},
    {SizedItem::treeCacheSize,   {{ 128000,  256000,  512000,  768000,  2048000 }}},
    {SizedItem::treeCacheAge,    {{     30,      60,      90,     120,      900 }}},
    {SizedItem::ledgerSize,      {{     32,     128,     256,     384,      768 }}},
    {SizedItem::ledgerAge,       {{     30,      90,     180,     240,      900 }}},
    {SizedItem::ledgerFetch,     {{      2,       3,       4,       5,        8 }}},
    {SizedItem::hashNodeDBCache, {{      4,      12,      24,      64,      128 }}},
    {SizedItem::txnDBCache,      {{      4,      12,      24,      64,      128 }}},
    {SizedItem::lgrDBCache,      {{      4,       8,      16,      32,      128 }}},
    {SizedItem::openFinalLimit,  {{      8,      16,      32,      64,      128 }}},
    {SizedItem::burstSize,       {{      4,       8,      16,      32,       48 }}},
    {SizedItem::ramSizeGB,       {{      8,      12,      16,      24,       32 }}},
}}

Definition at line 113 of file Config.cpp.

checkpointers

CheckpointersCollection ripple::checkpointers

Definition at line 76 of file DatabaseCon.cpp.

SNTPQueryData

uint8_t ripple::SNTPQueryData[48]

static

Initial value:

= {
    0x1B, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0,    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}

Definition at line 35 of file SNTPClock.cpp.

NTP_QUERY_FREQUENCY

constexpr auto ripple::NTP_QUERY_FREQUENCY = 4min

constexpr

Definition at line 41 of file SNTPClock.cpp.

NTP_MIN_QUERY

constexpr auto ripple::NTP_MIN_QUERY = 3min

constexpr

Definition at line 44 of file SNTPClock.cpp.

NTP_UNIX_OFFSET

constexpr auto ripple::NTP_UNIX_OFFSET = 0x83AA7E80s

constexpr

Definition at line 50 of file SNTPClock.cpp.

NTP_TIMESTAMP_VALID

constexpr auto ripple::NTP_TIMESTAMP_VALID = (NTP_QUERY_FREQUENCY + NTP_MIN_QUERY) * 2

constexpr

Definition at line 53 of file SNTPClock.cpp.

checkpointPageCount

auto ripple::checkpointPageCount = 1000

static

Definition at line 37 of file SociDB.cpp.

open_ledger

const open_ledger_t ripple::open_ledger {}

Definition at line 25 of file OpenView.cpp.

sLCF_NoConsensusTime

const std::uint32_t ripple::sLCF_NoConsensusTime = 0x01

static

Definition at line 415 of file ReadView.h.

httpClientSSLContext

std::optional<HTTPClientSSLContext> ripple::httpClientSSLContext

static

Definition at line 35 of file HTTPClient.cpp.

FEATURE_COMPR

constexpr char ripple::FEATURE_COMPR[] = "compr"

staticconstexpr

Definition at line 142 of file Handshake.h.

FEATURE_VPRR

constexpr char ripple::FEATURE_VPRR[] = "vprr"

staticconstexpr

Definition at line 144 of file Handshake.h.

FEATURE_TXRR

constexpr char ripple::FEATURE_TXRR[] = "txrr"

staticconstexpr

Definition at line 146 of file Handshake.h.

FEATURE_LEDGER_REPLAY

constexpr char ripple::FEATURE_LEDGER_REPLAY[] = "ledgerreplay"

staticconstexpr

Definition at line 148 of file Handshake.h.

DELIM_FEATURE

constexpr char ripple::DELIM_FEATURE[] = ";"

staticconstexpr

Definition at line 149 of file Handshake.h.

DELIM_VALUE

constexpr char ripple::DELIM_VALUE[] = ","

staticconstexpr

Definition at line 150 of file Handshake.h.

supportedProtocolList

constexpr const ProtocolVersion ripple::supportedProtocolList[]

constexpr

Initial value:

{
    {2, 0},
    {2, 1},
    {2, 2}
}

The list of protocol versions we speak and we prefer to use.

Note

The list must be sorted in strictly ascending order (and so it may not contain any duplicates!)

Definition at line 38 of file ProtocolVersion.cpp.

maximiumMessageSize

constexpr std::size_t ripple::maximiumMessageSize = megabytes(64)

constexpr

Definition at line 38 of file overlay/Message.h.

relayLimit

constexpr std::uint32_t ripple::relayLimit = 3

staticconstexpr

Definition at line 36 of file ripple/overlay/Peer.h.

featureOwnerPaysFee

const uint256 ripple::featureOwnerPaysFee

featureFlow

const uint256 ripple::featureFlow

featureFlowCross

const uint256 ripple::featureFlowCross

featureCryptoConditionsSuite

const uint256 ripple::featureCryptoConditionsSuite

fix1513

const uint256 ripple::fix1513

featureDepositAuth

const uint256 ripple::featureDepositAuth

featureChecks

const uint256 ripple::featureChecks

fix1571

const uint256 ripple::fix1571

fix1543

const uint256 ripple::fix1543

fix1623

const uint256 ripple::fix1623

featureDepositPreauth

const uint256 ripple::featureDepositPreauth

fix1515

const uint256 ripple::fix1515

fix1578

const uint256 ripple::fix1578

featureMultiSignReserve

const uint256 ripple::featureMultiSignReserve

fixTakerDryOfferRemoval

const uint256 ripple::fixTakerDryOfferRemoval

fixMasterKeyAsRegularKey

const uint256 ripple::fixMasterKeyAsRegularKey

fixCheckThreading

const uint256 ripple::fixCheckThreading

fixPayChanRecipientOwnerDir

const uint256 ripple::fixPayChanRecipientOwnerDir

featureDeletableAccounts

const uint256 ripple::featureDeletableAccounts

fixQualityUpperBound

const uint256 ripple::fixQualityUpperBound

featureRequireFullyCanonicalSig

const uint256 ripple::featureRequireFullyCanonicalSig

fix1781

const uint256 ripple::fix1781

featureHardenedValidations

const uint256 ripple::featureHardenedValidations

fixAmendmentMajorityCalc

const uint256 ripple::fixAmendmentMajorityCalc

featureNegativeUNL

const uint256 ripple::featureNegativeUNL

featureTicketBatch

const uint256 ripple::featureTicketBatch

featureFlowSortStrands

const uint256 ripple::featureFlowSortStrands

fixSTAmountCanonicalize

const uint256 ripple::fixSTAmountCanonicalize

fixRmSmallIncreasedQOffers

const uint256 ripple::fixRmSmallIncreasedQOffers

featureCheckCashMakesTrustLine

const uint256 ripple::featureCheckCashMakesTrustLine

retiredMultiSign

const uint256 ripple::retiredMultiSign = retireFeature("MultiSign")

Definition at line 447 of file Feature.cpp.

retiredTrustSetAuth

const uint256 ripple::retiredTrustSetAuth = retireFeature("TrustSetAuth")

Definition at line 448 of file Feature.cpp.

retiredFeeEscalation

const uint256 ripple::retiredFeeEscalation = retireFeature("FeeEscalation")

Definition at line 449 of file Feature.cpp.

retiredPayChan

const uint256 ripple::retiredPayChan = retireFeature("PayChan")

Definition at line 450 of file Feature.cpp.

retiredCryptoConditions

const uint256 ripple::retiredCryptoConditions = retireFeature("CryptoConditions")

Definition at line 451 of file Feature.cpp.

retiredTickSize

const uint256 ripple::retiredTickSize = retireFeature("TickSize")

Definition at line 452 of file Feature.cpp.

retiredFix1368

const uint256 ripple::retiredFix1368 = retireFeature("fix1368")

Definition at line 453 of file Feature.cpp.

retiredEscrow

const uint256 ripple::retiredEscrow = retireFeature("Escrow")

Definition at line 454 of file Feature.cpp.

retiredFix1373

const uint256 ripple::retiredFix1373 = retireFeature("fix1373")

Definition at line 455 of file Feature.cpp.

retiredEnforceInvariants

const uint256 ripple::retiredEnforceInvariants = retireFeature("EnforceInvariants")

Definition at line 456 of file Feature.cpp.

retiredSortedDirectories

const uint256 ripple::retiredSortedDirectories = retireFeature("SortedDirectories")

Definition at line 457 of file Feature.cpp.

retiredFix1201

const uint256 ripple::retiredFix1201 = retireFeature("fix1201")

Definition at line 458 of file Feature.cpp.

retiredFix1512

const uint256 ripple::retiredFix1512 = retireFeature("fix1512")

Definition at line 459 of file Feature.cpp.

retiredFix1523

const uint256 ripple::retiredFix1523 = retireFeature("fix1523")

Definition at line 460 of file Feature.cpp.

retiredFix1528

const uint256 ripple::retiredFix1528 = retireFeature("fix1528")

Definition at line 461 of file Feature.cpp.

readOnlySet

const bool ripple::readOnlySet

static

Initial value:

=
    featureCollections.registrationIsDone()

Definition at line 476 of file Feature.cpp.

parityRate

const Rate ripple::parityRate

A transfer rate signifying a 1:1 exchange.

Definition at line 94 of file Rate.h.

access

SField::private_access_tag_t ripple::access

static

Definition at line 39 of file SField.cpp.

sfInvalid

const SField ripple::sfInvalid

Definition at line 331 of file SField.h.

sfGeneric

const SField ripple::sfGeneric

Definition at line 332 of file SField.h.

sfHash

const SField ripple::sfHash(access, STI_HASH256, 257, "hash")

sfIndex

const SField ripple::sfIndex(access, STI_HASH256, 258, "index")

stAmountCanonicalizeSwitchover

LocalValue< bool > ripple::stAmountCanonicalizeSwitchover

Definition at line 479 of file STAmount.h.

tenTo14

const std::uint64_t ripple::tenTo14 = 100000000000000ull

static

Definition at line 39 of file STAmount.cpp.

tenTo14m1

const std::uint64_t ripple::tenTo14m1 = tenTo14 - 1

static

Definition at line 40 of file STAmount.cpp.

tenTo17

const std::uint64_t ripple::tenTo17 = tenTo14 * 1000

static

Definition at line 41 of file STAmount.cpp.

alphabetForward

constexpr char const* ripple::alphabetForward

staticconstexpr

Initial value:

=
    "rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz"

Definition at line 33 of file tokens.cpp.

alphabetReverse

constexpr const std::array<int, 256> ripple::alphabetReverse

staticconstexpr

Initial value:

= []() {
    std::array<int, 256> map{};
    for (auto& m : map)
        m = -1;
    for (int i = 0, j = 0; alphabetForward[i] != 0; ++i)
        map[static_cast<unsigned char>(alphabetForward[i])] = j++;
    return map;
}()

Definition at line 36 of file tokens.cpp.

txMinSizeBytes

constexpr std::size_t ripple::txMinSizeBytes = 32

constexpr

Protocol specific constants, types, and data.

This information is, implicitly, part of the Ripple protocol.

Note

Changing these values without adding code to the server to detect "pre-change" and "post-change" will result in a hard fork. Smallest legal byte size of a transaction.

Definition at line 39 of file Protocol.h.

txMaxSizeBytes

constexpr std::size_t ripple::txMaxSizeBytes = megabytes(1)

constexpr

Largest legal byte size of a transaction.

Definition at line 42 of file Protocol.h.

unfundedOfferRemoveLimit

constexpr std::size_t ripple::unfundedOfferRemoveLimit = 1000

constexpr

The maximum number of unfunded offers to delete at once.

Definition at line 45 of file Protocol.h.

oversizeMetaDataCap

constexpr std::size_t ripple::oversizeMetaDataCap = 5200

constexpr

The maximum number of metadata entries allowed in one transaction.

Definition at line 48 of file Protocol.h.

dirNodeMaxEntries

constexpr std::size_t ripple::dirNodeMaxEntries = 32

constexpr

The maximum number of entries per directory page.

Definition at line 51 of file Protocol.h.

dirNodeMaxPages

constexpr std::uint64_t ripple::dirNodeMaxPages = 262144

constexpr

The maximum number of pages allowed in a directory.

Definition at line 54 of file Protocol.h.

sfLedgerEntry

const SField ripple::sfLedgerEntry

sfTransaction

const SField ripple::sfTransaction

sfValidation

const SField ripple::sfValidation

sfMetadata

const SField ripple::sfMetadata

sfCloseResolution

const SF_UINT8 ripple::sfCloseResolution

sfMethod

const SF_UINT8 ripple::sfMethod

sfTransactionResult

const SF_UINT8 ripple::sfTransactionResult

sfTickSize

const SF_UINT8 ripple::sfTickSize

sfUNLModifyDisabling

const SF_UINT8 ripple::sfUNLModifyDisabling

sfLedgerEntryType

const SF_UINT16 ripple::sfLedgerEntryType

sfTransactionType

const SF_UINT16 ripple::sfTransactionType

sfSignerWeight

const SF_UINT16 ripple::sfSignerWeight

sfVersion

const SF_UINT16 ripple::sfVersion

sfFlags

const SF_UINT32 ripple::sfFlags

sfSourceTag

const SF_UINT32 ripple::sfSourceTag

sfSequence

const SF_UINT32 ripple::sfSequence

sfPreviousTxnLgrSeq

const SF_UINT32 ripple::sfPreviousTxnLgrSeq

sfLedgerSequence

const SF_UINT32 ripple::sfLedgerSequence

sfCloseTime

const SF_UINT32 ripple::sfCloseTime

sfParentCloseTime

const SF_UINT32 ripple::sfParentCloseTime

sfSigningTime

const SF_UINT32 ripple::sfSigningTime

sfExpiration

const SF_UINT32 ripple::sfExpiration

sfTransferRate

const SF_UINT32 ripple::sfTransferRate

sfWalletSize

const SF_UINT32 ripple::sfWalletSize

sfOwnerCount

const SF_UINT32 ripple::sfOwnerCount

sfDestinationTag

const SF_UINT32 ripple::sfDestinationTag

sfHighQualityIn

const SF_UINT32 ripple::sfHighQualityIn

sfHighQualityOut

const SF_UINT32 ripple::sfHighQualityOut

sfLowQualityIn

const SF_UINT32 ripple::sfLowQualityIn

sfLowQualityOut

const SF_UINT32 ripple::sfLowQualityOut

sfQualityIn

const SF_UINT32 ripple::sfQualityIn

sfQualityOut

const SF_UINT32 ripple::sfQualityOut

sfStampEscrow

const SF_UINT32 ripple::sfStampEscrow

sfBondAmount

const SF_UINT32 ripple::sfBondAmount

sfLoadFee

const SF_UINT32 ripple::sfLoadFee

sfOfferSequence

const SF_UINT32 ripple::sfOfferSequence

sfFirstLedgerSequence

const SF_UINT32 ripple::sfFirstLedgerSequence

sfLastLedgerSequence

const SF_UINT32 ripple::sfLastLedgerSequence

sfTransactionIndex

const SF_UINT32 ripple::sfTransactionIndex

sfOperationLimit

const SF_UINT32 ripple::sfOperationLimit

sfReferenceFeeUnits

const SF_UINT32 ripple::sfReferenceFeeUnits

sfReserveBase

const SF_UINT32 ripple::sfReserveBase

sfReserveIncrement

const SF_UINT32 ripple::sfReserveIncrement

sfSetFlag

const SF_UINT32 ripple::sfSetFlag

sfClearFlag

const SF_UINT32 ripple::sfClearFlag

sfSignerQuorum

const SF_UINT32 ripple::sfSignerQuorum

sfCancelAfter

const SF_UINT32 ripple::sfCancelAfter

sfFinishAfter

const SF_UINT32 ripple::sfFinishAfter

sfSignerListID

const SF_UINT32 ripple::sfSignerListID

sfSettleDelay

const SF_UINT32 ripple::sfSettleDelay

sfTicketCount

const SF_UINT32 ripple::sfTicketCount

sfTicketSequence

const SF_UINT32 ripple::sfTicketSequence

sfIndexNext

const SF_UINT64 ripple::sfIndexNext

sfIndexPrevious

const SF_UINT64 ripple::sfIndexPrevious

sfBookNode

const SF_UINT64 ripple::sfBookNode

sfOwnerNode

const SF_UINT64 ripple::sfOwnerNode

sfBaseFee

const SF_UINT64 ripple::sfBaseFee

sfExchangeRate

const SF_UINT64 ripple::sfExchangeRate

sfLowNode

const SF_UINT64 ripple::sfLowNode

sfHighNode

const SF_UINT64 ripple::sfHighNode

sfDestinationNode

const SF_UINT64 ripple::sfDestinationNode

sfCookie

const SF_UINT64 ripple::sfCookie

sfServerVersion

const SF_UINT64 ripple::sfServerVersion

sfEmailHash

const SF_HASH128 ripple::sfEmailHash

sfTakerPaysCurrency

const SF_HASH160 ripple::sfTakerPaysCurrency

sfTakerPaysIssuer

const SF_HASH160 ripple::sfTakerPaysIssuer

sfTakerGetsCurrency

const SF_HASH160 ripple::sfTakerGetsCurrency

sfTakerGetsIssuer

const SF_HASH160 ripple::sfTakerGetsIssuer

sfLedgerHash

const SF_HASH256 ripple::sfLedgerHash

sfParentHash

const SF_HASH256 ripple::sfParentHash

sfTransactionHash

const SF_HASH256 ripple::sfTransactionHash

sfAccountHash

const SF_HASH256 ripple::sfAccountHash

sfPreviousTxnID

const SF_HASH256 ripple::sfPreviousTxnID

sfLedgerIndex

const SF_HASH256 ripple::sfLedgerIndex

sfWalletLocator

const SF_HASH256 ripple::sfWalletLocator

sfRootIndex

const SF_HASH256 ripple::sfRootIndex

sfAccountTxnID

const SF_HASH256 ripple::sfAccountTxnID

sfBookDirectory

const SF_HASH256 ripple::sfBookDirectory

sfInvoiceID

const SF_HASH256 ripple::sfInvoiceID

sfNickname

const SF_HASH256 ripple::sfNickname

sfAmendment

const SF_HASH256 ripple::sfAmendment

sfDigest

const SF_HASH256 ripple::sfDigest

sfChannel

const SF_HASH256 ripple::sfChannel

sfConsensusHash

const SF_HASH256 ripple::sfConsensusHash

sfCheckID

const SF_HASH256 ripple::sfCheckID

sfValidatedHash

const SF_HASH256 ripple::sfValidatedHash

sfAmount

const SF_AMOUNT ripple::sfAmount

sfBalance

const SF_AMOUNT ripple::sfBalance

sfLimitAmount

const SF_AMOUNT ripple::sfLimitAmount

sfTakerPays

const SF_AMOUNT ripple::sfTakerPays

sfTakerGets

const SF_AMOUNT ripple::sfTakerGets

sfLowLimit

const SF_AMOUNT ripple::sfLowLimit

sfHighLimit

const SF_AMOUNT ripple::sfHighLimit

sfFee

const SF_AMOUNT ripple::sfFee

sfSendMax

const SF_AMOUNT ripple::sfSendMax

sfDeliverMin

const SF_AMOUNT ripple::sfDeliverMin

sfMinimumOffer

const SF_AMOUNT ripple::sfMinimumOffer

sfRippleEscrow

const SF_AMOUNT ripple::sfRippleEscrow

sfDeliveredAmount

const SF_AMOUNT ripple::sfDeliveredAmount

sfPublicKey

const SF_VL ripple::sfPublicKey

sfMessageKey

const SF_VL ripple::sfMessageKey

sfSigningPubKey

const SF_VL ripple::sfSigningPubKey

sfTxnSignature

const SF_VL ripple::sfTxnSignature

sfSignature

const SF_VL ripple::sfSignature

sfDomain

const SF_VL ripple::sfDomain

sfFundCode

const SF_VL ripple::sfFundCode

sfRemoveCode

const SF_VL ripple::sfRemoveCode

sfExpireCode

const SF_VL ripple::sfExpireCode

sfCreateCode

const SF_VL ripple::sfCreateCode

sfMemoType

const SF_VL ripple::sfMemoType

sfMemoData

const SF_VL ripple::sfMemoData

sfMemoFormat

const SF_VL ripple::sfMemoFormat

sfFulfillment

const SF_VL ripple::sfFulfillment

sfCondition

const SF_VL ripple::sfCondition

sfMasterSignature

const SF_VL ripple::sfMasterSignature

sfUNLModifyValidator

const SF_VL ripple::sfUNLModifyValidator

sfValidatorToDisable

const SF_VL ripple::sfValidatorToDisable

sfValidatorToReEnable

const SF_VL ripple::sfValidatorToReEnable

sfAccount

const SF_ACCOUNT ripple::sfAccount

sfOwner

const SF_ACCOUNT ripple::sfOwner

sfDestination

const SF_ACCOUNT ripple::sfDestination

sfIssuer

const SF_ACCOUNT ripple::sfIssuer

sfAuthorize

const SF_ACCOUNT ripple::sfAuthorize

sfUnauthorize

const SF_ACCOUNT ripple::sfUnauthorize

sfTarget

const SF_ACCOUNT ripple::sfTarget

sfRegularKey

const SF_ACCOUNT ripple::sfRegularKey

sfPaths

const SField ripple::sfPaths

sfIndexes

const SF_VECTOR256 ripple::sfIndexes

sfHashes

const SF_VECTOR256 ripple::sfHashes

sfAmendments

const SF_VECTOR256 ripple::sfAmendments

sfTransactionMetaData

const SField ripple::sfTransactionMetaData

sfCreatedNode

const SField ripple::sfCreatedNode

sfDeletedNode

const SField ripple::sfDeletedNode

sfModifiedNode

const SField ripple::sfModifiedNode

sfPreviousFields

const SField ripple::sfPreviousFields

sfFinalFields

const SField ripple::sfFinalFields

sfNewFields

const SField ripple::sfNewFields

sfTemplateEntry

const SField ripple::sfTemplateEntry

sfMemo

const SField ripple::sfMemo

sfSignerEntry

const SField ripple::sfSignerEntry

sfSigner

const SField ripple::sfSigner

sfMajority

const SField ripple::sfMajority

sfDisabledValidator

const SField ripple::sfDisabledValidator

sfSigners

const SField ripple::sfSigners

sfSignerEntries

const SField ripple::sfSignerEntries

sfTemplate

const SField ripple::sfTemplate

sfNecessary

const SField ripple::sfNecessary

sfSufficient

const SField ripple::sfSufficient

sfAffectedNodes

const SField ripple::sfAffectedNodes

sfMemos

const SField ripple::sfMemos

sfMajorities

const SField ripple::sfMajorities

sfDisabledValidators

const SField ripple::sfDisabledValidators

vfFullValidation

constexpr std::uint32_t ripple::vfFullValidation = 0x00000001

constexpr

Definition at line 39 of file STValidation.h.

vfFullyCanonicalSig

constexpr std::uint32_t ripple::vfFullyCanonicalSig = 0x80000000

constexpr

Definition at line 42 of file STValidation.h.

INITIAL_XRP

constexpr XRPAmount ripple::INITIAL_XRP {100'000'000'000 * DROPS_PER_XRP}

constexpr

Configure the native currency.

Number of drops in the genesis account.

Definition at line 43 of file SystemParameters.h.

XRP_LEDGER_EARLIEST_SEQ

constexpr std::uint32_t ripple::XRP_LEDGER_EARLIEST_SEQ {32570u}

staticconstexpr

The XRP ledger network's earliest allowed sequence.

Definition at line 61 of file SystemParameters.h.

DEFAULT_LEDGERS_PER_SHARD

constexpr std::uint32_t ripple::DEFAULT_LEDGERS_PER_SHARD {16384u}

staticconstexpr

The number of ledgers in a shard.

Definition at line 64 of file SystemParameters.h.

preFixAmendmentMajorityCalcThreshold

constexpr std::ratio<204, 256> ripple::preFixAmendmentMajorityCalcThreshold

constexpr

The minimum amount of support an amendment should have.

Note

This value is used by legacy code and will become obsolete once the fixAmendmentMajorityCalc amendment activates.

Definition at line 71 of file SystemParameters.h.

postFixAmendmentMajorityCalcThreshold

constexpr std::ratio<80, 100> ripple::postFixAmendmentMajorityCalcThreshold

constexpr

Definition at line 73 of file SystemParameters.h.

defaultAmendmentMajorityTime

constexpr const std::chrono::seconds ripple::defaultAmendmentMajorityTime = weeks{2}

constexpr

The minimum amount of time an amendment must hold a majority.

Definition at line 76 of file SystemParameters.h.

tfFullyCanonicalSig

const std::uint32_t ripple::tfFullyCanonicalSig = 0x80000000

Definition at line 48 of file TxFlags.h.

tfUniversal

const std::uint32_t ripple::tfUniversal = tfFullyCanonicalSig

Definition at line 49 of file TxFlags.h.

tfUniversalMask

const std::uint32_t ripple::tfUniversalMask = ~tfUniversal

Definition at line 50 of file TxFlags.h.

tfOptionalDestTag

const std::uint32_t ripple::tfOptionalDestTag = 0x00020000

Definition at line 55 of file TxFlags.h.

tfRequireAuth

const std::uint32_t ripple::tfRequireAuth = 0x00040000

Definition at line 56 of file TxFlags.h.

tfOptionalAuth

const std::uint32_t ripple::tfOptionalAuth = 0x00080000

Definition at line 57 of file TxFlags.h.

tfDisallowXRP

const std::uint32_t ripple::tfDisallowXRP = 0x00100000

Definition at line 58 of file TxFlags.h.

tfAllowXRP

const std::uint32_t ripple::tfAllowXRP = 0x00200000

Definition at line 59 of file TxFlags.h.

tfAccountSetMask

const std::uint32_t ripple::tfAccountSetMask

Initial value:

=
    ~(tfUniversal | TxFlag::requireDestTag | tfOptionalDestTag | tfRequireAuth |
      tfOptionalAuth | tfDisallowXRP | tfAllowXRP)

Definition at line 60 of file TxFlags.h.

asfRequireDest

const std::uint32_t ripple::asfRequireDest = 1

Definition at line 65 of file TxFlags.h.

asfRequireAuth

const std::uint32_t ripple::asfRequireAuth = 2

Definition at line 66 of file TxFlags.h.

asfDisallowXRP

const std::uint32_t ripple::asfDisallowXRP = 3

Definition at line 67 of file TxFlags.h.

asfDisableMaster

const std::uint32_t ripple::asfDisableMaster = 4

Definition at line 68 of file TxFlags.h.

asfAccountTxnID

const std::uint32_t ripple::asfAccountTxnID = 5

Definition at line 69 of file TxFlags.h.

asfNoFreeze

const std::uint32_t ripple::asfNoFreeze = 6

Definition at line 70 of file TxFlags.h.

asfGlobalFreeze

const std::uint32_t ripple::asfGlobalFreeze = 7

Definition at line 71 of file TxFlags.h.

asfDefaultRipple

const std::uint32_t ripple::asfDefaultRipple = 8

Definition at line 72 of file TxFlags.h.

asfDepositAuth

const std::uint32_t ripple::asfDepositAuth = 9

Definition at line 73 of file TxFlags.h.

tfPassive

const std::uint32_t ripple::tfPassive = 0x00010000

Definition at line 76 of file TxFlags.h.

tfImmediateOrCancel

const std::uint32_t ripple::tfImmediateOrCancel = 0x00020000

Definition at line 77 of file TxFlags.h.

tfFillOrKill

const std::uint32_t ripple::tfFillOrKill = 0x00040000

Definition at line 78 of file TxFlags.h.

tfSell

const std::uint32_t ripple::tfSell = 0x00080000

Definition at line 79 of file TxFlags.h.

tfOfferCreateMask

const std::uint32_t ripple::tfOfferCreateMask

Initial value:

=
    ~(tfUniversal | tfPassive | tfImmediateOrCancel | tfFillOrKill | tfSell)

Definition at line 80 of file TxFlags.h.

tfNoRippleDirect

const std::uint32_t ripple::tfNoRippleDirect = 0x00010000

Definition at line 84 of file TxFlags.h.

tfPartialPayment

const std::uint32_t ripple::tfPartialPayment = 0x00020000

Definition at line 85 of file TxFlags.h.

tfLimitQuality

const std::uint32_t ripple::tfLimitQuality = 0x00040000

Definition at line 86 of file TxFlags.h.

tfPaymentMask

const std::uint32_t ripple::tfPaymentMask

Initial value:

=
    ~(tfUniversal | tfPartialPayment | tfLimitQuality | tfNoRippleDirect)

Definition at line 87 of file TxFlags.h.

tfSetfAuth

const std::uint32_t ripple::tfSetfAuth = 0x00010000

Definition at line 91 of file TxFlags.h.

tfSetNoRipple

const std::uint32_t ripple::tfSetNoRipple = 0x00020000

Definition at line 92 of file TxFlags.h.

tfClearNoRipple

const std::uint32_t ripple::tfClearNoRipple = 0x00040000

Definition at line 93 of file TxFlags.h.

tfSetFreeze

const std::uint32_t ripple::tfSetFreeze = 0x00100000

Definition at line 94 of file TxFlags.h.

tfClearFreeze

const std::uint32_t ripple::tfClearFreeze = 0x00200000

Definition at line 95 of file TxFlags.h.

tfTrustSetMask

const std::uint32_t ripple::tfTrustSetMask

Initial value:

=
    ~(tfUniversal | tfSetfAuth | tfSetNoRipple | tfClearNoRipple | tfSetFreeze |
      tfClearFreeze)

Definition at line 96 of file TxFlags.h.

tfGotMajority

const std::uint32_t ripple::tfGotMajority = 0x00010000

Definition at line 101 of file TxFlags.h.

tfLostMajority

const std::uint32_t ripple::tfLostMajority = 0x00020000

Definition at line 102 of file TxFlags.h.

tfRenew

const std::uint32_t ripple::tfRenew = 0x00010000

Definition at line 105 of file TxFlags.h.

tfClose

const std::uint32_t ripple::tfClose = 0x00020000

Definition at line 106 of file TxFlags.h.

tfPayChanClaimMask

const std::uint32_t ripple::tfPayChanClaimMask = ~(tfUniversal | tfRenew | tfClose)

Definition at line 107 of file TxFlags.h.

method_not_found

constexpr Json::Int ripple::method_not_found = -32601

constexpr

Definition at line 560 of file ServerHandlerImp.cpp.

server_overloaded

constexpr Json::Int ripple::server_overloaded = -32604

constexpr

Definition at line 561 of file ServerHandlerImp.cpp.

forbidden

constexpr Json::Int ripple::forbidden = -32605

constexpr

Definition at line 562 of file ServerHandlerImp.cpp.

wrong_version

constexpr Json::Int ripple::wrong_version = -32606

constexpr

Definition at line 563 of file ServerHandlerImp.cpp.

no_item

const std::shared_ptr<SHAMapItem const> ripple::no_item

static

Definition at line 479 of file SHAMap.cpp.

wireTypeTransaction

constexpr unsigned const char ripple::wireTypeTransaction = 0

staticconstexpr

Definition at line 39 of file SHAMapTreeNode.h.

wireTypeAccountState

constexpr unsigned const char ripple::wireTypeAccountState = 1

staticconstexpr

Definition at line 40 of file SHAMapTreeNode.h.

wireTypeInner

constexpr unsigned const char ripple::wireTypeInner = 2

staticconstexpr

Definition at line 41 of file SHAMapTreeNode.h.

wireTypeCompressedInner

constexpr unsigned const char ripple::wireTypeCompressedInner = 3

staticconstexpr

Definition at line 42 of file SHAMapTreeNode.h.

wireTypeTransactionWithMeta

constexpr unsigned const char ripple::wireTypeTransactionWithMeta = 4

staticconstexpr

Definition at line 43 of file SHAMapTreeNode.h.