Struct TransactionPoolCandidatesState

pub struct TransactionPoolCandidatesState {
    by_peer: BTreeMap<PeerId, BTreeMap<TransactionHash, TransactionPoolCandidateState>>,
    by_hash: BTreeMap<TransactionHash, BTreeSet<PeerId>>,
    by_message_id: BTreeMap<P2pNetworkPubsubMessageCacheId, (PeerId, Vec<TransactionHash>)>,
}

Fields

by_peer: BTreeMap<PeerId, BTreeMap<TransactionHash, TransactionPoolCandidateState>>

by_hash: BTreeMap<TransactionHash, BTreeSet<PeerId>>

by_message_id: BTreeMap<P2pNetworkPubsubMessageCacheId, (PeerId, Vec<TransactionHash>)>

Implementations

impl TransactionPoolCandidatesState

pub fn new() -> Self

pub fn transactions_count(&self) -> usize

pub fn peer_transaction_count(&self, peer_id: &PeerId) -> usize

pub fn contains(&self, hash: &TransactionHash) -> bool

pub fn message_id_contains( &self, message_id: &P2pNetworkPubsubMessageCacheId, ) -> bool

pub fn peer_contains(&self, peer_id: PeerId, hash: &TransactionHash) -> bool

pub fn get( &self, peer_id: PeerId, hash: &TransactionHash, ) -> Option<&TransactionPoolCandidateState>

fn transactions_from_peer_or_empty( &self, peer_id: PeerId, ) -> &BTreeMap<TransactionHash, TransactionPoolCandidateState>

pub fn candidates_from_peer_iter( &self, peer_id: PeerId, ) -> impl Iterator<Item = (&TransactionHash, &TransactionPoolCandidateState)>

pub fn candidates_from_peer_with_hashes<'a, I>( &'a self, peer_id: PeerId, transaction_hashes: I, ) -> impl Iterator<Item = (&'a TransactionHash, Option<&'a TransactionPoolCandidateState>)>

where I: IntoIterator<Item = &'a TransactionHash>,

pub fn info_received( &mut self, time: Timestamp, peer_id: PeerId, info: TransactionInfo, )

pub fn peers_next_transactions_to_fetch<I, F>( &self, peers: I, get_order: F, ) -> Vec<(PeerId, TransactionHash)>

where I: IntoIterator<Item = PeerId>, F: Copy + Fn(&TransactionHash) -> usize,

pub fn fetch_pending( &mut self, time: Timestamp, peer_id: &PeerId, hash: &TransactionHash, rpc_id: P2pRpcId, )

pub fn transaction_received( &mut self, time: Timestamp, peer_id: PeerId, transaction: TransactionWithHash, )

pub fn transactions_received( &mut self, time: Timestamp, peer_id: PeerId, transactions: Vec<TransactionWithHash>, message_id: P2pNetworkPubsubMessageCacheId, )

pub fn get_batch_to_verify( &self, ) -> Option<(PeerId, Vec<TransactionWithHash>, TransactionPoolMessageSource)>

Get next batch of transactions to verify, first checks if there are any transactions to verify from pubsub after that checks for transactions from peers

fn next_batch_from_peers( &self, ) -> Option<(PeerId, Vec<TransactionWithHash>, TransactionPoolMessageSource)>

fn next_batch_from_pubsub( &self, ) -> Option<(PeerId, Vec<TransactionWithHash>, TransactionPoolMessageSource)>

pub fn verify_pending( &mut self, time: Timestamp, peer_id: &PeerId, verify_id: (), transaction_hashes: &[TransactionHash], )

pub fn verify_result( &mut self, _time: Timestamp, peer_id: &PeerId, verify_id: (), from_source: &TransactionPoolMessageSource, _result: Result<(), ()>, )

pub fn peer_remove(&mut self, peer_id: PeerId)

pub fn peer_transaction_remove( &mut self, peer_id: PeerId, hash: &TransactionHash, )

fn transaction_remove(&mut self, hash: &TransactionHash)

pub fn remove_inferior_transactions(&mut self, transaction: &Transaction)

pub fn retain<F1, F2>(&mut self, predicate: F1)

where F1: FnMut(&TransactionHash) -> F2, F2: FnMut(&TransactionPoolCandidateState) -> bool,

impl TransactionPoolCandidatesState

pub fn reducer( state_context: Substate<'_, Self>, action: TransactionPoolCandidateActionWithMetaRef<'_>, )

Trait Implementations

impl Clone for TransactionPoolCandidatesState

fn clone(&self) -> TransactionPoolCandidatesState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TransactionPoolCandidatesState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TransactionPoolCandidatesState

fn default() -> TransactionPoolCandidatesState

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TransactionPoolCandidatesState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TransactionPoolCandidatesState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SubstateAccess<TransactionPoolCandidatesState> for State

fn substate(&self) -> SubstateResult<&TransactionPoolCandidatesState>

Attempts to obtain an immutable reference to the substate.

fn substate_mut( &mut self, ) -> SubstateResult<&mut TransactionPoolCandidatesState>

Attempts to obtain a mutable reference to the substate.