Struct cfx_packing_pool::PackingBatch

pub struct PackingBatch<TX: PackingPoolTransaction> { /* private fields */ }

A batch of transactions that have the same sender and continuous nonces.

PackingBatch is designed to group transactions from the same sender that can be packed into the same block. This struct ensures that all transactions in the batch have the same sender and their nonces form a continuous sequence.

Implementations

impl<TX: PackingPoolTransaction> PackingBatch<TX>

pub fn new(tx: TX) -> Self

pub fn sender(&self) -> TX::Sender

pub fn start_nonce(&self) -> U256

pub fn first_gas_price(&self) -> U256

pub fn total_gas_limit(&self) -> U256

pub fn len(&self) -> usize

pub fn insert( &mut self, tx: TX, config: &PackingPoolConfig ) -> (Vec<TX>, Result<(), InsertError>)

Inserts a transaction into the pool according to PackingPoolConfig, without violating the assumptions of PackingBatch.

Returns

Returns a tuple consisting of:

• A vector of transactions that were replaced by the insertion. This can be empty if no transactions were displaced.
• A result indicating the success or failure of the insertion operation.

pub fn split_off_suffix(&mut self, index: usize) -> Result<Vec<TX>, RemoveError>

Removes transactions starting from the specified index (included) and returns them.

pub fn split_off_prefix(&mut self, index: usize) -> Result<Vec<TX>, RemoveError>

Removes transactions ending at the specified index (not included) and returns them.

pub fn split_off_by_nonce( &mut self, nonce: &U256, keep_prefix: bool ) -> Result<Vec<TX>, RemoveError>

Split transactions at the specified nonce (the specified one is in the past half). Retains a half according to keep_prefix and returns the rest half.

Trait Implementations

impl<TX: Clone + PackingPoolTransaction> Clone for PackingBatch<TX>

fn clone(&self) -> PackingBatch<TX>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<TX: Debug + PackingPoolTransaction> Debug for PackingBatch<TX>

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

Formats the value using the given formatter.

impl<TX: Default + PackingPoolTransaction> Default for PackingBatch<TX>

fn default() -> PackingBatch<TX>

Returns the “default value” for a type.

impl<TX> MallocSizeOf for PackingBatch<TX>

where TX: MallocSizeOf + PackingPoolTransaction,

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl<TX: PartialEq + PackingPoolTransaction> PartialEq for PackingBatch<TX>

fn eq(&self, other: &PackingBatch<TX>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<TX: Eq + PackingPoolTransaction> Eq for PackingBatch<TX>

impl<TX: PackingPoolTransaction> StructuralPartialEq for PackingBatch<TX>