Struct MessagePool 

pub struct MessagePool<T> {
    local_addrs: Arc<RwLock<Vec<Address>>>,
    pub pending: Arc<RwLock<HashMap<Address, MsgSet>>>,
    pub cur_tipset: Arc<RwLock<Tipset>>,
    pub api: Arc<T>,
    pub network_sender: Sender<NetworkMessage>,
    pub bls_sig_cache: Arc<SizeTrackingLruCache<CidWrapper, Signature>>,
    pub sig_val_cache: Arc<SizeTrackingLruCache<CidWrapper, ()>>,
    pub republished: Arc<RwLock<HashSet<Cid>>>,
    pub repub_trigger: Sender<()>,
    local_msgs: Arc<RwLock<HashSet<SignedMessage>>>,
    pub config: MpoolConfig,
    pub chain_config: Arc<ChainConfig>,
}

This contains all necessary information needed for the message pool. Keeps track of messages to apply, as well as context needed for verifying transactions.

Fields

local_addrs: Arc<RwLock<Vec<Address>>>

The local address of the client

pending: Arc<RwLock<HashMap<Address, MsgSet>>>

A map of pending messages where the key is the address

cur_tipset: Arc<RwLock<Tipset>>

The current tipset (a set of blocks)

api: Arc<T>

The underlying provider

network_sender: Sender<NetworkMessage>

Sender half to send messages to other components

bls_sig_cache: Arc<SizeTrackingLruCache<CidWrapper, Signature>>

A cache for BLS signature keyed by Cid

sig_val_cache: Arc<SizeTrackingLruCache<CidWrapper, ()>>

A cache for BLS signature keyed by Cid

republished: Arc<RwLock<HashSet<Cid>>>

A set of republished messages identified by their Cid

repub_trigger: Sender<()>

Acts as a signal to republish messages from the republished set of messages

local_msgs: Arc<RwLock<HashSet<SignedMessage>>>

config: MpoolConfig

Configurable parameters of the message pool

chain_config: Arc<ChainConfig>

Chain configuration

Implementations

impl<T> MessagePool<T>

where T: Provider,

pub fn current_tipset(&self) -> Tipset

Gets the current tipset

fn add_local(&self, m: SignedMessage) -> Result<(), Error>

Add a signed message to the pool and its address.

pub async fn push(&self, msg: SignedMessage) -> Result<Cid, Error>

Push a signed message to the MessagePool. Additionally performs basic checks on the validity of a message.

fn check_message(&self, msg: &SignedMessage) -> Result<(), Error>

pub fn add(&self, msg: SignedMessage) -> Result<(), Error>

This is a helper to push that will help to make sure that the message fits the parameters to be pushed to the MessagePool.

fn verify_msg_sig(&self, msg: &SignedMessage) -> Result<(), Error>

Verify the message signature. first check if it has already been verified and put into cache. If it has not, then manually verify it then put it into cache for future use.

fn add_tipset( &self, msg: SignedMessage, cur_ts: &Tipset, local: bool, ) -> Result<bool, Error>

Verify the state_sequence and balance for the sender of the message given then call add_locked to finish adding the signed_message to pending.

fn add_helper(&self, msg: SignedMessage) -> Result<(), Error>

Finish verifying signed message before adding it to the pending mset hash-map. If an entry in the hash-map does not yet exist, create a new mset that will correspond to the from message and push it to the pending hash-map.

pub fn get_sequence(&self, addr: &Address) -> Result<u64, Error>

Get the sequence for a given address, return Error if there is a failure to retrieve the respective sequence.

fn get_state_sequence( &self, addr: &Address, cur_ts: &Tipset, ) -> Result<u64, Error>

Get the state of the sequence for a given address in cur_ts.

fn get_state_balance( &self, addr: &Address, ts: &Tipset, ) -> Result<TokenAmount, Error>

Get the state balance for the actor that corresponds to the supplied address and tipset, if this actor does not exist, return an error.

pub fn pending(&self) -> Result<(Vec<SignedMessage>, Tipset), Error>

Return a tuple that contains a vector of all signed messages and the current tipset for self.

pub fn pending_for(&self, a: &Address) -> Option<Vec<SignedMessage>>

Return a Vector of signed messages for a given from address. This vector will be sorted by each message’s sequence. If no corresponding messages found, return None result type.

pub fn messages_for_blocks<'a>( &self, blks: impl Iterator<Item = &'a CachingBlockHeader>, ) -> Result<Vec<SignedMessage>, Error>

Return Vector of signed messages given a block header for self.

pub fn load_local(&mut self) -> Result<(), Error>

Loads local messages to the message pool to be applied.

impl<T> MessagePool<T>

where T: Provider + Send + Sync + 'static,

pub fn new( api: T, network_sender: Sender<NetworkMessage>, config: MpoolConfig, chain_config: Arc<ChainConfig>, services: &mut JoinSet<Result<()>>, ) -> Result<MessagePool<T>, Error>

where T: Provider,

Creates a new MessagePool instance.

impl<T> MessagePool<T>

where T: Provider,

pub fn select_messages( &self, ts: &Tipset, tq: f64, ) -> Result<Vec<SignedMessage>, Error>

Forest employs a sophisticated algorithm for selecting messages for inclusion from the pool, given the ticket quality of a miner. This method selects messages for including in a block.

fn select_messages_greedy( &self, cur_ts: &Tipset, ts: &Tipset, ) -> Result<SelectedMessages, Error>

fn select_messages_optimal( &self, cur_ts: &Tipset, target_tipset: &Tipset, ticket_quality: f64, ) -> Result<SelectedMessages, Error>

fn get_pending_messages( &self, cur_ts: &Tipset, ts: &Tipset, ) -> Result<HashMap<Address, HashMap<u64, SignedMessage>>, Error>

fn select_priority_messages( &self, pending: &mut HashMap<Address, HashMap<u64, SignedMessage>>, base_fee: &TokenAmount, ts: &Tipset, ) -> Result<SelectedMessages, Error>