Generic implementation of consensus algorithm. More...

#include <Consensus.h>

Collaboration diagram for xrpl::Consensus< Adaptor >:

[legend]

Classes
class	MonitoredMode

Public Types
using	clock_type = beast::AbstractClock<std::chrono::steady_clock>
	Clock type for measuring time within the consensus code.

Public Member Functions
	Consensus (Consensus &&) noexcept=default
	Consensus (clock_type const &clock, Adaptor &adaptor, beast::Journal j)
	Constructor.
void	startRound (NetClock::time_point const &now, Ledger_t::ID const &prevLedgerID, Ledger_t prevLedger, hash_set< NodeID_t > const &nowUntrusted, bool proposing, std::unique_ptr< std::stringstream > const &clog={})
	Kick-off the next round of consensus.
bool	peerProposal (NetClock::time_point const &now, PeerPosition_t const &newProposal)
	A peer has proposed a new position, adjust our tracking.
void	timerEntry (NetClock::time_point const &now, std::unique_ptr< std::stringstream > const &clog={})
	Call periodically to drive consensus forward.
void	gotTxSet (NetClock::time_point const &now, TxSet_t const &txSet)
	Process a transaction set acquired from the network.
void	simulate (NetClock::time_point const &now, std::optional< std::chrono::milliseconds > consensusDelay)
	Simulate the consensus process without any network traffic.
Ledger_t::ID	prevLedgerID () const
	Get the previous ledger ID.
ConsensusPhase	phase () const
json::Value	getJson (bool full) const
	Get the Json state of the consensus process.

Private Types
using	Ledger_t = Adaptor::Ledger_t
using	TxSet_t = Adaptor::TxSet_t
using	NodeID_t = Adaptor::NodeID_t
using	Tx_t = TxSet_t::Tx
using	PeerPosition_t = Adaptor::PeerPosition_t
using	Proposal_t = ConsensusProposal<NodeID_t, typename Ledger_t::ID, typename TxSet_t::ID>
using	Result = ConsensusResult<Adaptor>

Private Member Functions
void	startRoundInternal (NetClock::time_point const &now, Ledger_t::ID const &prevLedgerID, Ledger_t const &prevLedger, ConsensusMode mode, std::unique_ptr< std::stringstream > const &clog)
void	handleWrongLedger (Ledger_t::ID const &lgrId, std::unique_ptr< std::stringstream > const &clog)
void	checkLedger (std::unique_ptr< std::stringstream > const &clog)
	Check if our previous ledger matches the network's.
void	playbackProposals ()
	If we radically changed our consensus context for some reason, we need to replay recent proposals so that they're not lost.
bool	peerProposalInternal (NetClock::time_point const &now, PeerPosition_t const &newProposal)
	Handle a replayed or a new peer proposal.
void	phaseOpen (std::unique_ptr< std::stringstream > const &clog)
	Handle pre-close phase.
void	phaseEstablish (std::unique_ptr< std::stringstream > const &clog)
	Handle establish phase.
bool	shouldPause (std::unique_ptr< std::stringstream > const &clog) const
	Evaluate whether pausing increases likelihood of validation.
void	closeLedger (std::unique_ptr< std::stringstream > const &clog)
void	updateOurPositions (std::unique_ptr< std::stringstream > const &clog)
bool	haveConsensus (std::unique_ptr< std::stringstream > const &clog)
void	createDisputes (TxSet_t const &o, std::unique_ptr< std::stringstream > const &clog={})
void	updateDisputes (NodeID_t const &node, TxSet_t const &other)
void	leaveConsensus (std::unique_ptr< std::stringstream > const &clog)
NetClock::time_point	asCloseTime (NetClock::time_point raw) const

Private Attributes
Adaptor &	adaptor_
ConsensusPhase	phase_ {ConsensusPhase::Accepted}
MonitoredMode	mode_ {ConsensusMode::Observing}
bool	firstRound_ = true
bool	haveCloseTimeConsensus_ = false
clock_type const &	clock_
int	convergePercent_ {0}
ConsensusTimer	openTime_
NetClock::duration	closeResolution_ = kLedgerDefaultTimeResolution
ConsensusParms::AvalancheState	closeTimeAvalancheState_ = ConsensusParms::AvalancheState::Init
std::chrono::milliseconds	prevRoundTime_ {}
NetClock::time_point	now_
NetClock::time_point	prevCloseTime_
Ledger_t::ID	prevLedgerID_
Ledger_t	previousLedger_
hash_map< typename TxSet_t::ID, TxSet_t const >	acquired_
std::optional< Result >	result_
ConsensusCloseTimes	rawCloseTimes_
std::size_t	peerUnchangedCounter_ = 0
std::size_t	establishCounter_ = 0
hash_map< NodeID_t, PeerPosition_t >	currPeerPositions_
hash_map< NodeID_t, std::deque< PeerPosition_t > >	recentPeerPositions_
std::size_t	prevProposers_ = 0
hash_set< NodeID_t >	deadNodes_
beast::Journal const	j_

Detailed Description

template<class Adaptor>
class xrpl::Consensus< Adaptor >

Generic implementation of consensus algorithm.

Achieves consensus on the next ledger.

Two things need consensus:

The set of transactions included in the ledger.
The close time for the ledger.

The basic flow:

A call to startRound places the node in the Open phase. In this phase, the node is waiting for transactions to include in its open ledger.
Successive calls to timerEntry check if the node can close the ledger. Once the node Closes the open ledger, it transitions to the Establish phase. In this phase, the node shares/receives peer proposals on which transactions should be accepted in the closed ledger.
During a subsequent call to timerEntry, the node determines it has reached consensus with its peers on which transactions to include. It transitions to the Accept phase. In this phase, the node works on applying the transactions to the prior ledger to generate a new closed ledger. Once the new ledger is completed, the node shares the validated ledger with the network, does some book-keeping, then makes a call to startRound to start the cycle again.

This class uses a generic interface to allow adapting Consensus for specific applications. The Adaptor template implements a set of helper functions that plug the consensus algorithm into a specific application. It also identifies the types that play important roles in Consensus (transactions, ledgers, ...). The code stubs below outline the interface and type requirements. The traits types must be copy constructible and assignable.

Warning: The generic implementation is not thread safe and the public methods are not intended to be run concurrently. When in a concurrent environment, the application is responsible for ensuring thread-safety. Simply locking whenever touching the Consensus instance is one option.

// A single transaction
struct Tx
{
  // Unique identifier of transaction
  using ID = ...;
 
  ID id() const;
 
};
 
// A set of transactions
struct TxSet
{
  // Unique ID of TxSet (not of Tx)
  using ID = ...;
  // Type of individual transaction comprising the TxSet
  using Tx = Tx;
 
  bool exists(Tx::ID const &) const;
  // Return value should have semantics like Tx const *
  Tx const * find(Tx::ID const &) const ;
  ID const & id() const;
 
  // Return set of transactions that are not common to this set or other
  // boolean indicates which set it was in
  std::map<Tx::ID, bool> compare(TxSet const & other) const;
 
  // A mutable view of transactions
  struct MutableTxSet
  {
      MutableTxSet(TxSet const &);
      bool insert(Tx const &);
      bool erase(Tx::ID const &);
  };
 
  // Construct from a mutable view.
  TxSet(MutableTxSet const &);
 
  // Alternatively, if the TxSet is itself mutable
  // just alias MutableTxSet = TxSet
 
};
 
// Agreed upon state that consensus transactions will modify
struct Ledger
{
  using ID = ...;
  using Seq = ...;
 
  // Unique identifier of ledger
  ID const id() const;
  Seq seq() const;
  auto closeTimeResolution() const;
  auto closeAgree() const;
  auto closeTime() const;
  auto parentCloseTime() const;
  json::Value getJson() const;
};
 
// Wraps a peer's ConsensusProposal
struct PeerPosition
{
  ConsensusProposal<
      std::uint32_t, //NodeID,
      typename Ledger::ID,
      typename TxSet::ID> const &
  proposal() const;
 
};
 
 
class Adaptor
{
public:
    //-----------------------------------------------------------------------
    // Define consensus types
    using Ledger_t = Ledger;
    using NodeID_t = std::uint32_t;
    using TxSet_t = TxSet;
    using PeerPosition_t = PeerPosition;
 
    //-----------------------------------------------------------------------
    //
    // Attempt to acquire a specific ledger.
    std::optional<Ledger> acquireLedger(Ledger::ID const & ledgerID);
 
    // Acquire the transaction set associated with a proposed position.
    std::optional<TxSet> acquireTxSet(TxSet::ID const & setID);
 
    // Whether any transactions are in the open ledger
    bool hasOpenTransactions() const;
 
    // Number of proposers that have validated the given ledger
    std::size_t proposersValidated(Ledger::ID const & prevLedger) const;
 
    // Number of proposers that have validated a ledger descended from the
    // given ledger; if prevLedger.id() != prevLedgerID, use prevLedgerID
    // for the determination
    std::size_t proposersFinished(Ledger const & prevLedger,
                                  Ledger::ID const & prevLedger) const;
 
    // Return the ID of the last closed (and validated) ledger that the
    // application thinks consensus should use as the prior ledger.
    Ledger::ID getPrevLedger(Ledger::ID const & prevLedgerID,
                    Ledger const & prevLedger,
                    Mode mode);
 
    // Called whenever consensus operating mode changes
    void onModeChange(ConsensusMode before, ConsensusMode after);
 
    // Called when ledger closes
    Result onClose(Ledger const &, Ledger const & prev, Mode mode);
 
    // Called when ledger is accepted by consensus
    void onAccept(Result const & result,
      RCLCxLedger const & prevLedger,
      NetClock::duration closeResolution,
      CloseTimes const & rawCloseTimes,
      Mode const & mode);
 
    // Called when ledger was forcibly accepted by consensus via the simulate
    // function.
    void onForceAccept(Result const & result,
      RCLCxLedger const & prevLedger,
      NetClock::duration closeResolution,
      CloseTimes const & rawCloseTimes,
      Mode const & mode);
 
    // Propose the position to peers.
    void propose(ConsensusProposal<...> const & pos);
 
    // Share a received peer proposal with other peer's.
    void share(PeerPosition_t const & prop);
 
    // Share a disputed transaction with peers
    void share(Txn const & tx);
 
    // Share given transaction set with peers
    void share(TxSet const &s);
 
    // Consensus timing parameters and constants
    ConsensusParms const &
    parms() const;
};

Template Parameters

Adaptor Defines types and provides helper functions needed to adapt Consensus to the larger application.

Definition at line 289 of file Consensus.h.

Member Typedef Documentation

◆ Ledger_t

template<class Adaptor>

using xrpl::Consensus< Adaptor >::Ledger_t = Adaptor::Ledger_t

private

Definition at line 291 of file Consensus.h.

◆ TxSet_t

template<class Adaptor>

using xrpl::Consensus< Adaptor >::TxSet_t = Adaptor::TxSet_t

private

Definition at line 292 of file Consensus.h.

◆ NodeID_t

template<class Adaptor>

using xrpl::Consensus< Adaptor >::NodeID_t = Adaptor::NodeID_t

private

Definition at line 293 of file Consensus.h.

◆ Tx_t

template<class Adaptor>

using xrpl::Consensus< Adaptor >::Tx_t = TxSet_t::Tx

private

Definition at line 294 of file Consensus.h.

◆ PeerPosition_t

template<class Adaptor>

using xrpl::Consensus< Adaptor >::PeerPosition_t = Adaptor::PeerPosition_t

private

Definition at line 295 of file Consensus.h.

◆ Proposal_t

template<class Adaptor>

using xrpl::Consensus< Adaptor >::Proposal_t = ConsensusProposal<NodeID_t, typename Ledger_t::ID, typename TxSet_t::ID>

private

Definition at line 296 of file Consensus.h.

◆ Result

template<class Adaptor>

using xrpl::Consensus< Adaptor >::Result = ConsensusResult<Adaptor>

private

Definition at line 298 of file Consensus.h.

◆ clock_type

template<class Adaptor>

using xrpl::Consensus< Adaptor >::clock_type = beast::AbstractClock<std::chrono::steady_clock>

Clock type for measuring time within the consensus code.

Definition at line 328 of file Consensus.h.

Constructor & Destructor Documentation

◆ Consensus() [1/2]

template<class Adaptor>

xrpl::Consensus< Adaptor >::Consensus ( Consensus< Adaptor > && )

defaultnoexcept

◆ Consensus() [2/2]

template<class Adaptor>

xrpl::Consensus< Adaptor >::Consensus	(	clock_type const &	clock,
		Adaptor &	adaptor,
		beast::Journal	j )

Constructor.

Parameters

clock	The clock used to internally sample consensus progress
adaptor	The instance of the adaptor class
j	The journal to log debug output

Definition at line 635 of file Consensus.h.

Member Function Documentation

◆ startRound()

template<class Adaptor>

void xrpl::Consensus< Adaptor >::startRound	(	NetClock::time_point const &	now,
		Ledger_t::ID const &	prevLedgerID,
		Ledger_t	prevLedger,
		hash_set< NodeID_t > const &	nowUntrusted,
		bool	proposing,
		std::unique_ptr< std::stringstream > const &	clog = {} )

Kick-off the next round of consensus.

Called by the client code to start each round of consensus.

Parameters

now	The network adjusted time
prevLedgerID	the ID of the last ledger
prevLedger	The last ledger
nowUntrusted	ID of nodes that are newly untrusted this round
proposing	Whether we want to send proposals to peers this round.
clog	log object to which to append

Note: prevLedgerID is not required to the ID of prevLedger since the ID may be known locally before the contents of the ledger arrive

Definition at line 643 of file Consensus.h.

◆ peerProposal()

template<class Adaptor>

bool xrpl::Consensus< Adaptor >::peerProposal	(	NetClock::time_point const &	now,
		PeerPosition_t const &	newProposal )

A peer has proposed a new position, adjust our tracking.

Parameters

now	The network adjusted time
newProposal	The new proposal from a peer

Returns: Whether we should do delayed relay of this proposal.

Definition at line 734 of file Consensus.h.

◆ timerEntry()

template<class Adaptor>

void xrpl::Consensus< Adaptor >::timerEntry	(	NetClock::time_point const &	now,
		std::unique_ptr< std::stringstream > const &	clog = {} )

Call periodically to drive consensus forward.

Parameters

now	The network adjusted time
clog	log object to which to append

Definition at line 855 of file Consensus.h.

◆ gotTxSet()

template<class Adaptor>

void xrpl::Consensus< Adaptor >::gotTxSet	(	NetClock::time_point const &	now,
		TxSet_t const &	txSet )

Process a transaction set acquired from the network.

Parameters

now	The network adjusted time
txSet	the transaction set

Definition at line 892 of file Consensus.h.

◆ simulate()

template<class Adaptor>

void xrpl::Consensus< Adaptor >::simulate	(	NetClock::time_point const &	now,
		std::optional< std::chrono::milliseconds >	consensusDelay )

Simulate the consensus process without any network traffic.

The end result, is that consensus begins and completes as if everyone had agreed with whatever we propose.

This function is only called from the rpc "ledger_accept" path with the server in standalone mode and SHOULD NOT be used during the normal consensus process.

Simulate will call onForceAccept since clients are manually driving consensus to the accept phase.

Parameters

now	The current network adjusted time.
consensusDelay	Duration to delay between closing and accepting the ledger. Uses 100ms if unspecified.

Definition at line 937 of file Consensus.h.

◆ prevLedgerID()

template<class Adaptor>

Ledger_t::ID xrpl::Consensus< Adaptor >::prevLedgerID ( ) const

Get the previous ledger ID.

The previous ledger is the last ledger seen by the consensus code and should correspond to the most recent validated ledger seen by this peer.

Returns: ID of previous ledger

Definition at line 427 of file Consensus.h.

◆ phase()

template<class Adaptor>

ConsensusPhase xrpl::Consensus< Adaptor >::phase ( ) const

nodiscard

Definition at line 433 of file Consensus.h.

◆ getJson()

template<class Adaptor>

json::Value xrpl::Consensus< Adaptor >::getJson ( bool full ) const

nodiscard

Get the Json state of the consensus process.

Called by the consensus_info RPC.

Parameters

full	True if verbose response desired.

Returns: The Json state.

Definition at line 958 of file Consensus.h.

◆ startRoundInternal()

template<class Adaptor>

void xrpl::Consensus< Adaptor >::startRoundInternal	(	NetClock::time_point const &	now,
		Ledger_t::ID const &	prevLedgerID,
		Ledger_t const &	prevLedger,
		ConsensusMode	mode,
		std::unique_ptr< std::stringstream > const &	clog )

private

Definition at line 688 of file Consensus.h.

◆ handleWrongLedger()

template<class Adaptor>

void xrpl::Consensus< Adaptor >::handleWrongLedger	(	Ledger_t::ID const &	lgrId,
		std::unique_ptr< std::stringstream > const &	clog )

private

Definition at line 1055 of file Consensus.h.

◆ checkLedger()

template<class Adaptor>

void xrpl::Consensus< Adaptor >::checkLedger ( std::unique_ptr< std::stringstream > const & clog )

private

Check if our previous ledger matches the network's.

If the previous ledger differs, we are no longer in sync with the network and need to bow out/switch modes.

Definition at line 1109 of file Consensus.h.

◆ playbackProposals()

template<class Adaptor>

void xrpl::Consensus< Adaptor >::playbackProposals ( )

private

If we radically changed our consensus context for some reason, we need to replay recent proposals so that they're not lost.

Definition at line 1138 of file Consensus.h.

◆ peerProposalInternal()

template<class Adaptor>

bool xrpl::Consensus< Adaptor >::peerProposalInternal	(	NetClock::time_point const &	now,
		PeerPosition_t const &	newProposal )

private

Handle a replayed or a new peer proposal.

Definition at line 753 of file Consensus.h.

◆ phaseOpen()

template<class Adaptor>

void xrpl::Consensus< Adaptor >::phaseOpen ( std::unique_ptr< std::stringstream > const & clog )

private

Handle pre-close phase.

In the pre-close phase, the ledger is open as we wait for new transactions. After enough time has elapsed, we will close the ledger, switch to the establish phase and start the consensus process.

Definition at line 1155 of file Consensus.h.

◆ phaseEstablish()

template<class Adaptor>

void xrpl::Consensus< Adaptor >::phaseEstablish ( std::unique_ptr< std::stringstream > const & clog )

private

Handle establish phase.

In the establish phase, the ledger has closed and we work with peers to reach consensus. Update our position only on the timer, and in this phase.

If we have consensus, move to the accepted phase.

Definition at line 1352 of file Consensus.h.

◆ shouldPause()

template<class Adaptor>

bool xrpl::Consensus< Adaptor >::shouldPause ( std::unique_ptr< std::stringstream > const & clog ) const

nodiscardprivate

Evaluate whether pausing increases likelihood of validation.

As a validator that has previously synced to the network, if our most recent locally-validated ledger did not also achieve full validation, then consider pausing for awhile based on the state of other validators.

Pausing may be beneficial in this situation if at least one validator is known to be on a sequence number earlier than ours. The minimum number of validators on the same sequence number does not guarantee consensus, and waiting for all validators may be too time-consuming. Therefore, a variable threshold is enacted based on the number of ledgers past network validation that we are on. For the first phase, the threshold is also the minimum required for quorum. For the last, no online validators can have a lower sequence number. For intermediate phases, the threshold is linear between the minimum required for quorum and 100%. For example, with 3 total phases and a quorum of 80%, the 2nd phase would be 90%. Once the final phase is reached, if consensus still fails to occur, the cycle is begun again at phase 1.

Returns: Whether to pause to wait for lagging proposers.

Maximum phase with distinct thresholds to determine how many validators must be on our same ledger sequence number. The threshold for the 1st (0) phase is >= the minimum number that can achieve quorum. Threshold for the maximum phase is 100% of all trusted validators. Progression from min to max phase is simply linear. If there are 5 phases (maxPausePhase = 4) and minimum quorum is 80%, then thresholds progress as follows: 0: >=80% 1: >=85% 2: >=90% 3: >=95% 4: =100%

No particular threshold guarantees consensus. Lower thresholds are easier to achieve than higher, but higher thresholds are more likely to reach consensus. Cycle through the phases if lack of synchronization continues.

Current information indicates that no phase is likely to be intrinsically better than any other: the lower the threshold, the less likely that up-to-date nodes will be able to reach consensus without the laggards. But the higher the threshold, the longer the likely resulting pause. 100% is slightly less desirable in the long run because the potential of a single dawdling peer to slow down everything else. So if we accept that no phase is any better than any other phase, but that all of them will potentially enable us to arrive at consensus, cycling through them seems to be appropriate. Further, if we do reach the point of having to cycle back around, then it's likely that something else out of the scope of this delay mechanism is wrong with the network.

Definition at line 1227 of file Consensus.h.

◆ closeLedger()

template<class Adaptor>

void xrpl::Consensus< Adaptor >::closeLedger ( std::unique_ptr< std::stringstream > const & clog )

private

Definition at line 1418 of file Consensus.h.

◆ updateOurPositions()

template<class Adaptor>

void xrpl::Consensus< Adaptor >::updateOurPositions ( std::unique_ptr< std::stringstream > const & clog )

private

Definition at line 1475 of file Consensus.h.

◆ haveConsensus()

template<class Adaptor>

bool xrpl::Consensus< Adaptor >::haveConsensus ( std::unique_ptr< std::stringstream > const & clog )

private

Definition at line 1663 of file Consensus.h.

◆ createDisputes()

template<class Adaptor>

void xrpl::Consensus< Adaptor >::createDisputes	(	TxSet_t const &	o,
		std::unique_ptr< std::stringstream > const &	clog = {} )

private

Definition at line 1792 of file Consensus.h.

◆ updateDisputes()

template<class Adaptor>

void xrpl::Consensus< Adaptor >::updateDisputes	(	NodeID_t const &	node,
		TxSet_t const &	other )

private

Definition at line 1861 of file Consensus.h.

◆ leaveConsensus()

template<class Adaptor>

void xrpl::Consensus< Adaptor >::leaveConsensus ( std::unique_ptr< std::stringstream > const & clog )

private

Definition at line 1774 of file Consensus.h.

◆ asCloseTime()

template<class Adaptor>

NetClock::time_point xrpl::Consensus< Adaptor >::asCloseTime ( NetClock::time_point raw ) const

nodiscardprivate

Definition at line 1883 of file Consensus.h.

Member Data Documentation

◆ adaptor_

template<class Adaptor>

Adaptor& xrpl::Consensus< Adaptor >::adaptor_

private

Definition at line 562 of file Consensus.h.

◆ phase_

template<class Adaptor>

ConsensusPhase xrpl::Consensus< Adaptor >::phase_ {ConsensusPhase::Accepted}

private

Definition at line 564 of file Consensus.h.

◆ mode_

template<class Adaptor>

MonitoredMode xrpl::Consensus< Adaptor >::mode_ {ConsensusMode::Observing}

private

Definition at line 565 of file Consensus.h.

◆ firstRound_

template<class Adaptor>

bool xrpl::Consensus< Adaptor >::firstRound_ = true

private

Definition at line 566 of file Consensus.h.

◆ haveCloseTimeConsensus_

template<class Adaptor>

bool xrpl::Consensus< Adaptor >::haveCloseTimeConsensus_ = false

private

Definition at line 567 of file Consensus.h.

◆ clock_

template<class Adaptor>

clock_type const& xrpl::Consensus< Adaptor >::clock_

private

Definition at line 569 of file Consensus.h.

◆ convergePercent_

template<class Adaptor>

int xrpl::Consensus< Adaptor >::convergePercent_ {0}

private

Definition at line 573 of file Consensus.h.

◆ openTime_

template<class Adaptor>

ConsensusTimer xrpl::Consensus< Adaptor >::openTime_

private

Definition at line 576 of file Consensus.h.

◆ closeResolution_

template<class Adaptor>

NetClock::duration xrpl::Consensus< Adaptor >::closeResolution_ = kLedgerDefaultTimeResolution

private

Definition at line 578 of file Consensus.h.

◆ closeTimeAvalancheState_

template<class Adaptor>

ConsensusParms::AvalancheState xrpl::Consensus< Adaptor >::closeTimeAvalancheState_ = ConsensusParms::AvalancheState::Init

private

Definition at line 580 of file Consensus.h.

◆ prevRoundTime_

template<class Adaptor>

std::chrono::milliseconds xrpl::Consensus< Adaptor >::prevRoundTime_ {}

private

Definition at line 583 of file Consensus.h.

◆ now_

template<class Adaptor>

NetClock::time_point xrpl::Consensus< Adaptor >::now_

private

Definition at line 590 of file Consensus.h.

◆ prevCloseTime_

template<class Adaptor>

NetClock::time_point xrpl::Consensus< Adaptor >::prevCloseTime_

private

Definition at line 591 of file Consensus.h.

◆ prevLedgerID_

template<class Adaptor>

Ledger_t::ID xrpl::Consensus< Adaptor >::prevLedgerID_

private

Definition at line 597 of file Consensus.h.

◆ previousLedger_

template<class Adaptor>

Ledger_t xrpl::Consensus< Adaptor >::previousLedger_

private

Definition at line 599 of file Consensus.h.

◆ acquired_

template<class Adaptor>

hash_map<typename TxSet_t::ID, TxSet_t const> xrpl::Consensus< Adaptor >::acquired_

private

Definition at line 602 of file Consensus.h.

◆ result_

template<class Adaptor>

std::optional<Result> xrpl::Consensus< Adaptor >::result_

private

Definition at line 604 of file Consensus.h.

◆ rawCloseTimes_

template<class Adaptor>

ConsensusCloseTimes xrpl::Consensus< Adaptor >::rawCloseTimes_

private

Definition at line 605 of file Consensus.h.

◆ peerUnchangedCounter_

template<class Adaptor>

std::size_t xrpl::Consensus< Adaptor >::peerUnchangedCounter_ = 0

private

Definition at line 609 of file Consensus.h.

◆ establishCounter_

template<class Adaptor>

std::size_t xrpl::Consensus< Adaptor >::establishCounter_ = 0

private

Definition at line 612 of file Consensus.h.

◆ currPeerPositions_

template<class Adaptor>

hash_map<NodeID_t, PeerPosition_t> xrpl::Consensus< Adaptor >::currPeerPositions_

private

Definition at line 618 of file Consensus.h.

◆ recentPeerPositions_

template<class Adaptor>

hash_map<NodeID_t, std::deque<PeerPosition_t> > xrpl::Consensus< Adaptor >::recentPeerPositions_

private

Definition at line 622 of file Consensus.h.

◆ prevProposers_

template<class Adaptor>

std::size_t xrpl::Consensus< Adaptor >::prevProposers_ = 0

private

Definition at line 625 of file Consensus.h.

◆ deadNodes_

template<class Adaptor>

hash_set<NodeID_t> xrpl::Consensus< Adaptor >::deadNodes_

private

Definition at line 628 of file Consensus.h.

◆ j_

template<class Adaptor>

beast::Journal const xrpl::Consensus< Adaptor >::j_

private

Definition at line 631 of file Consensus.h.

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Ledger_t

◆ TxSet_t

◆ NodeID_t

◆ Tx_t

◆ PeerPosition_t

◆ Proposal_t

◆ Result

◆ clock_type

Constructor & Destructor Documentation

◆ Consensus() [1/2]

◆ Consensus() [2/2]

Member Function Documentation

◆ startRound()

◆ peerProposal()

◆ timerEntry()

◆ gotTxSet()

◆ simulate()

◆ prevLedgerID()

◆ phase()

◆ getJson()

◆ startRoundInternal()

◆ handleWrongLedger()

◆ checkLedger()

◆ playbackProposals()

◆ peerProposalInternal()

◆ phaseOpen()

◆ phaseEstablish()

◆ shouldPause()

◆ closeLedger()

◆ updateOurPositions()

◆ haveConsensus()

◆ createDisputes()

◆ updateDisputes()

◆ leaveConsensus()

◆ asCloseTime()

Member Data Documentation

◆ adaptor_

◆ phase_

◆ mode_

◆ firstRound_

◆ haveCloseTimeConsensus_

◆ clock_

◆ convergePercent_

◆ openTime_

◆ closeResolution_

◆ closeTimeAvalancheState_

◆ prevRoundTime_

◆ now_

◆ prevCloseTime_

◆ prevLedgerID_

◆ previousLedger_

◆ acquired_

◆ result_

◆ rawCloseTimes_

◆ peerUnchangedCounter_

◆ establishCounter_

◆ currPeerPositions_

◆ recentPeerPositions_

◆ prevProposers_

◆ deadNodes_

◆ j_