Struct EpochMembershipCoordinator

pub struct EpochMembershipCoordinator<TYPES: NodeType> {
    membership: Arc<RwLock<TYPES::Membership>>,
    catchup_map: Arc<Mutex<HashMap<<TYPES as NodeType>::Epoch, InactiveReceiver<Result<EpochMembership<TYPES>>>>>>,
    pub epoch_height: u64,
    store_drb_progress_fn: StoreDrbProgressFn,
    load_drb_progress_fn: LoadDrbProgressFn,
    store_drb_result_fn: StoreDrbResultFn<TYPES>,
    pub drb_difficulty_selector: Arc<RwLock<Option<DrbDifficultySelectorFn<TYPES>>>>,
}

Struct to Coordinate membership catchup

Fields

membership: Arc<RwLock<TYPES::Membership>>

The underlying membhersip

catchup_map: Arc<Mutex<HashMap<<TYPES as NodeType>::Epoch, InactiveReceiver<Result<EpochMembership<TYPES>>>>>>

Any in progress attempts at catching up are stored in this map Any new callers wantin an EpochMembership will await on the signal alerting them the membership is ready. The first caller for an epoch will wait for the actual catchup and allert future callers when it’s done

epoch_height: u64

Number of blocks in an epoch

store_drb_progress_fn: StoreDrbProgressFn

load_drb_progress_fn: LoadDrbProgressFn

store_drb_result_fn: StoreDrbResultFn<TYPES>

Callback function to store a drb result in storage when one is calculated during catchup

drb_difficulty_selector: Arc<RwLock<Option<DrbDifficultySelectorFn<TYPES>>>>

Callback function to select a DRB difficulty based on the view number of the seed

Implementations

impl<TYPES: NodeType> EpochMembershipCoordinator<TYPES>

where Self: Send,

pub fn new<S: Storage<TYPES>>( membership: Arc<RwLock<TYPES::Membership>>, epoch_height: u64, storage: &S, ) -> Self

Create an EpochMembershipCoordinator

pub fn membership(&self) -> &Arc<RwLock<TYPES::Membership>>

Get a reference to the membership

pub async fn set_drb_difficulty_selector( &self, drb_difficulty_selector: DrbDifficultySelectorFn<TYPES>, )

Set the DRB difficulty selector

pub async fn membership_for_epoch( &self, maybe_epoch: Option<TYPES::Epoch>, ) -> Result<EpochMembership<TYPES>>

Get a Membership for a given Epoch, which is guaranteed to have a randomized stake table for the given Epoch

pub async fn stake_table_for_epoch( &self, maybe_epoch: Option<TYPES::Epoch>, ) -> Result<EpochMembership<TYPES>>

Get a Membership for a given Epoch, which is guaranteed to have a stake table for the given Epoch

async fn catchup( self, epoch: TYPES::Epoch, epoch_tx: Sender<Result<EpochMembership<TYPES>>>, )

Catches the membership up to the epoch passed as an argument.
To do this, try to get the stake table for the epoch containing this epoch’s root and the stake table for the epoch containing this epoch’s drb result. If they do not exist, then go one by one back until we find a stake table.

If there is another catchup in progress this will not duplicate efforts e.g. if we start with only the first epoch stake table and call catchup for epoch 10, then call catchup for epoch 20 the first caller will actually do the work for to catchup to epoch 10 then the second caller will continue catching up to epoch 20

pub async fn wait_for_catchup( &self, epoch: TYPES::Epoch, ) -> Result<EpochMembership<TYPES>>

Call this method if you think catchup is in progress for a given epoch and you want to wait for it to finish and get the stake table. If it’s not, it will try to return the stake table if already available. Returns an error if the catchup failed or the catchup is not in progress and the stake table is not available.

async fn catchup_cleanup( &mut self, req_epoch: TYPES::Epoch, cancel_epochs: Vec<(<TYPES as NodeType>::Epoch, Sender<Result<EpochMembership<TYPES>>>)>, err: Error, )

Clean up after a failed catchup attempt.

This method is called when a catchup attempt fails. It cleans up the state of the EpochMembershipCoordinator by removing the failed epochs from the catchup_map and broadcasting the error to any tasks that are waiting for the catchup to complete.

async fn fetch_stake_table(&self, epoch: TYPES::Epoch) -> Result<Leaf2<TYPES>>

A helper method to the catchup method.

It tries to fetch the requested stake table from the root epoch, and updates the membership accordingly.

Arguments

• epoch - The epoch for which to fetch the stake table.

Returns

• Ok(Leaf2<TYPES>) containing the epoch root leaf if successful.
• Err(Error) if the root membership or root leaf cannot be found, or if updating the membership fails.

async fn fetch_or_calc_drb_results( &self, epoch: TYPES::Epoch, root_leaf: Leaf2<TYPES>, ) -> Result<()>

A helper method to the catchup method.

Fetch or compute the DRB (Distributed Random Beacon) result for a given epoch.

This method attempts to retrieve the DRB result for the specified epoch. If the DRB result is not available, it computes the DRB using the provided root leaf and stores the result in the membership state.

Arguments

• epoch - The epoch for which to fetch or compute the DRB result.
• root_leaf - The epoch root leaf used for DRB computation if the result is not available.

Returns

• Ok(()) if the DRB result was successfully fetched or computed and stored.
• Err(Error) if the DRB result could not be fetched, computed, or stored.

Trait Implementations

impl<TYPES: NodeType> Clone for EpochMembershipCoordinator<TYPES>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.