Struct IndexedPool

pub struct IndexedPool {
    applicable_by_fee: HashMap<FeeRate, HashSet<ValidCommandWithHash>>,
    all_by_sender: HashMap<AccountId, (VecDeque<ValidCommandWithHash>, Amount)>,
    all_by_fee: HashMap<FeeRate, HashSet<ValidCommandWithHash>>,
    all_by_hash: HashMap<TransactionHash, ValidCommandWithHash>,
    transactions_with_expiration: HashMap<Slot, HashSet<ValidCommandWithHash>>,
    size: usize,
    pub config: IndexedPoolConfig,
}

Fields

applicable_by_fee: HashMap<FeeRate, HashSet<ValidCommandWithHash>>

Transactions valid against the current ledger, indexed by fee per weight unit.

all_by_sender: HashMap<AccountId, (VecDeque<ValidCommandWithHash>, Amount)>

All pending transactions along with the total currency required to execute them – plus any currency spent from this account by transactions from other accounts – indexed by sender account. Ordered by nonce inside the accounts.

all_by_fee: HashMap<FeeRate, HashSet<ValidCommandWithHash>>

All transactions in the pool indexed by fee per weight unit.

all_by_hash: HashMap<TransactionHash, ValidCommandWithHash>

transactions_with_expiration: HashMap<Slot, HashSet<ValidCommandWithHash>>

Only transactions that have an expiry

size: usize

config: IndexedPoolConfig

Implementations

impl IndexedPool

fn new(constants: &ConsensusConstants) -> Self

fn size(&self) -> usize

fn min_fee(&self) -> Option<FeeRate>

fn member(&self, cmd: &ValidCommandWithHash) -> bool

pub fn get(&self, hash: &TransactionHash) -> Option<&ValidCommandWithHash>

fn check_expiry( &self, global_slot_since_genesis: Slot, cmd: &UserCommand, ) -> Result<(), CommandError>

fn map_set_insert<K, V>(map: &mut HashMap<K, HashSet<V>>, key: K, value: V)

where K: Hash + PartialEq + Eq, V: Hash + PartialEq + Eq,

Insert in a HashMap<_, HashSet<_>>

fn map_set_remove<K, V>(map: &mut HashMap<K, HashSet<V>>, key: K, value: &V)

where K: Hash + PartialEq + Eq, V: Hash + PartialEq + Eq,

Remove in a HashMap<_, HashSet<_>>

fn update_expiration_map(&mut self, cmd: ValidCommandWithHash, is_add: bool)

fn remove_from_expiration_exn(&mut self, cmd: ValidCommandWithHash)

fn add_to_expiration(&mut self, cmd: ValidCommandWithHash)

fn remove_applicable_exn(&mut self, cmd: &ValidCommandWithHash)

Remove a command from the applicable_by_fee field. This may break an invariant.

fn make_queue<T>() -> VecDeque<T>

fn add_from_backtrack( &mut self, global_slot_since_genesis: Slot, current_global_slot: Slot, cmd: ValidCommandWithHash, ) -> Result<(), CommandError>

fn update_add( &mut self, cmd: ValidCommandWithHash, fee_per_wu: FeeRate, add_to_applicable_by_fee: bool, )

fn update_remove_all_by_fee_and_hash_and_expiration<I>(&mut self, cmds: I)

where I: IntoIterator<Item = ValidCommandWithHash>,

Remove a command from the all_by_fee and all_by_hash fields, and decrement size. This may break an invariant.

fn update_remove_from_applicable_by_fee( &mut self, fee_per_wu: FeeRate, command: &ValidCommandWithHash, )

fn remove_with_dependents_exn( &mut self, cmd: &ValidCommandWithHash, ) -> Result<VecDeque<ValidCommandWithHash>, CommandError>

fn remove_with_dependents_exn_impl( &self, cmd: &ValidCommandWithHash, by_sender: &mut SenderState, updates: &mut Vec<Update>, ) -> Result<VecDeque<ValidCommandWithHash>, CommandError>

fn apply_updates(&mut self, updates: Vec<Update>)

fn set_sender(&mut self, by_sender: SenderState)

fn add_from_gossip_exn( &mut self, global_slot_since_genesis: Slot, current_global_slot: Slot, cmd: &ValidCommandWithHash, current_nonce: Nonce, balance: Balance, ) -> Result<(ValidCommandWithHash, VecDeque<ValidCommandWithHash>), CommandError>

fn add_from_gossip_exn_impl( &self, global_slot_since_genesis: Slot, current_global_slot: Slot, cmd: &ValidCommandWithHash, current_nonce: Nonce, balance: Balance, by_sender: &mut SenderState, updates: &mut Vec<Update>, ) -> Result<(ValidCommandWithHash, VecDeque<ValidCommandWithHash>), CommandError>

fn expired_by_global_slot( &self, global_slot_since_genesis: Slot, ) -> Vec<ValidCommandWithHash>

fn expired(&self, global_slot_since_genesis: Slot) -> Vec<ValidCommandWithHash>

fn remove_expired( &mut self, global_slot_since_genesis: Slot, ) -> Result<Vec<ValidCommandWithHash>, CommandError>

fn remove_lowest_fee( &mut self, ) -> Result<VecDeque<ValidCommandWithHash>, CommandError>

fn drop_until_sufficient_balance( queue: VecDeque<ValidCommandWithHash>, currency_reserved: Amount, current_balance: Amount, ) -> Result<(VecDeque<ValidCommandWithHash>, Amount, VecDeque<ValidCommandWithHash>), CommandError>

Drop commands from the end of the queue until the total currency consumed is <= the current balance.

fn revalidate<F>( &mut self, global_slot_since_genesis: Slot, kind: RevalidateKind<'_>, get_account: F, ) -> Result<Vec<ValidCommandWithHash>, CommandError>

where F: Fn(&AccountId) -> Option<Account>,

fn list_includable_transactions( &self, limit: usize, ) -> Vec<ValidCommandWithHash>

Same as transactions, but does not modify the mempool

fn transactions(&mut self, limit: usize) -> Vec<ValidCommandWithHash>

Returns a sequence of commands in the pool in descending fee order

fn get_all_transactions(&self) -> Vec<ValidCommandWithHash>

Returns all the transactions in the pool

fn get_pending_amount_and_nonce( &self, ) -> HashMap<AccountId, (Option<Nonce>, Amount)>

Trait Implementations

impl Clone for IndexedPool

fn clone(&self) -> IndexedPool

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IndexedPool

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IndexedPool

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for IndexedPool

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

where __S: Serializer,

Serialize this value into the given Serde serializer.