Struct EpochCommittees 

pub struct EpochCommittees {
    non_epoch_committee: NonEpochCommittee,
    state: HashMap<EpochNumber, EpochCommittee>,
    all_validators: BTreeMap<EpochNumber, RegisteredValidatorMap>,
    randomized_committees: BTreeMap<EpochNumber, RandomizedCommittee<StakeTableEntry<PubKey>>>,
    da_committees: BTreeMap<u64, DaCommittee>,
    first_epoch: Option<EpochNumber>,
    epoch_height: u64,
    fixed_block_reward: Option<RewardAmount>,
    fetcher: Arc<Fetcher>,
}

Type to describe DA and Stake memberships

Fields

non_epoch_committee: NonEpochCommittee

Committee used when we’re in pre-epoch state

state: HashMap<EpochNumber, EpochCommittee>

Holds Stake table and da stake

all_validators: BTreeMap<EpochNumber, RegisteredValidatorMap>

holds the full validator candidate sets temporarily, until we store them

randomized_committees: BTreeMap<EpochNumber, RandomizedCommittee<StakeTableEntry<PubKey>>>

Randomized committees, filled when we receive the DrbResult

da_committees: BTreeMap<u64, DaCommittee>

DA committees, indexed by the first epoch in which they apply

first_epoch: Option<EpochNumber>

epoch_height: u64

fixed_block_reward: Option<RewardAmount>

Fixed block reward (used only in V3). starting from V4, block reward is dynamic

fetcher: Arc<Fetcher>

Implementations

impl EpochCommittees

pub fn first_epoch(&self) -> Option<EpochNumber>

pub fn fetcher(&self) -> &Fetcher

pub fn fixed_block_reward(&self) -> Option<RewardAmount>

async fn fetch_and_update_fixed_block_reward( membership: Arc<RwLock<Self>>, epoch: EpochNumber, ) -> Result<RewardAmount>

Fetch the fixed block reward and update it if its None. We used a fixed block reward for version v3 Version v4 uses the dynamic block reward Assumes the stake table contract proxy address does not change

pub fn compute_block_reward( epoch: &EpochNumber, total_supply: U256, total_stake: U256, avg_block_time_ms: u64, ) -> Result<RewardAmount>

pub async fn fetch_and_calculate_block_reward( current_epoch: EpochNumber, coordinator: EpochMembershipCoordinator<SeqTypes>, ) -> Result<RewardAmount>

returns the block reward for the given epoch.

Reward depends on the epoch root header version: V3: Returns the fixed block reward as V3 only supports fixed reward

= V4 : Returns the dynamic block reward

It also attempts catchup for the root header if not present in the committee, and also for the stake table of the previous epoch before computing the dynamic block reward

async fn calculate_dynamic_block_reward( &self, epoch: &EpochNumber, header: &Header, validators: &AuthenticatedValidatorMap, ) -> Result<Option<RewardAmount>>

Calculates the dynamic block reward for a given block header within an epoch.

The reward is based on a dynamic inflation rate computed from the current stake ratio (p), where p = total_stake / total_supply. The inflation function R(p) is defined piecewise:

• If p <= 0.01: R(p) = 0.03 / sqrt(2 * 0.01)
• Else: R(p) = 0.03 / sqrt(2 * p)

pub fn epoch_block_reward(&self, epoch: EpochNumber) -> Option<RewardAmount>

This function just returns the stored block reward in epoch committee

fn insert_committee( &mut self, epoch: EpochNumber, validators: AuthenticatedValidatorMap, block_reward: Option<RewardAmount>, hash: Option<StakeTableHash>, header: Option<Header>, )

Updates Self.stake_table with stake_table for Self.contract_address at l1_block_height. This is intended to be called before calling self.stake() so that Self.stake_table only needs to be updated once in a given life-cycle but may be read from many times.

pub fn active_validators( &self, epoch: &EpochNumber, ) -> Result<AuthenticatedValidatorMap>

pub fn address( &self, epoch: &EpochNumber, bls_key: BLSPubKey, ) -> Result<Address>

pub fn get_validator_config( &self, epoch: &EpochNumber, key: BLSPubKey, ) -> Result<AuthenticatedValidator<BLSPubKey>>

pub fn new_stake( committee_members: Vec<PeerConfig<SeqTypes>>, da_members: Vec<PeerConfig<SeqTypes>>, fixed_block_reward: Option<RewardAmount>, fetcher: Fetcher, epoch_height: u64, ) -> Self

pub async fn reload_stake(&mut self, limit: u64)

fn get_stake_table( &self, epoch: &Option<EpochNumber>, ) -> Option<Vec<PeerConfig<SeqTypes>>>

fn get_da_committee(&self, epoch: Option<EpochNumber>) -> DaCommittee

fn get_header(&self, epoch: EpochNumber) -> Option<&Header>

Get root leaf header for a given epoch

Trait Implementations

impl Clone for EpochCommittees

fn clone(&self) -> EpochCommittees

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EpochCommittees

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

Formats the value using the given formatter.

impl Membership<SeqTypes> for EpochCommittees

fn stake_table(&self, epoch: Option<EpochNumber>) -> HSStakeTable<SeqTypes>

Get the stake table for the current view

fn da_stake_table(&self, epoch: Option<EpochNumber>) -> HSStakeTable<SeqTypes>

Get the stake table for the current view

fn committee_members( &self, _view_number: ViewNumber, epoch: Option<EpochNumber>, ) -> BTreeSet<PubKey>

Get all members of the committee for the current view

fn da_committee_members( &self, _view_number: ViewNumber, epoch: Option<EpochNumber>, ) -> BTreeSet<PubKey>

Get all members of the committee for the current view

fn stake( &self, pub_key: &PubKey, epoch: Option<EpochNumber>, ) -> Option<PeerConfig<SeqTypes>>

Get the stake table entry for a public key

fn da_stake( &self, pub_key: &PubKey, epoch: Option<EpochNumber>, ) -> Option<PeerConfig<SeqTypes>>

Get the DA stake table entry for a public key

fn has_stake(&self, pub_key: &PubKey, epoch: Option<EpochNumber>) -> bool

Check if a node has stake in the committee

fn has_da_stake(&self, pub_key: &PubKey, epoch: Option<EpochNumber>) -> bool

Check if a node has stake in the committee

fn lookup_leader( &self, view_number: ViewNumber, epoch: Option<EpochNumber>, ) -> Result<PubKey, Self::Error>

Returns the leader’s public key for a given view number and epoch.

If an epoch is provided and a randomized committee exists for that epoch, the leader is selected from the randomized committee. Otherwise, the leader is selected from the non-epoch committee.

Arguments

• view_number - The view number to index into the committee.
• epoch - The epoch for which to determine the leader. If None, uses the non-epoch committee.

Errors

Returns LeaderLookupError if the epoch is before the first epoch or if the committee is missing.

fn total_nodes(&self, epoch: Option<EpochNumber>) -> usize

Get the total number of nodes in the committee

fn da_total_nodes(&self, epoch: Option<EpochNumber>) -> usize

Get the total number of DA nodes in the committee

async fn add_epoch_root( membership: Arc<RwLock<Self>>, block_header: Header, ) -> Result<()>

Adds the epoch committee and block reward for a given epoch, either by fetching from L1 or using local state if available. It also calculates and stores the block reward based on header version.

fn has_randomized_stake_table(&self, epoch: EpochNumber) -> Result<bool>

Checks if the randomized stake table is available for the given epoch.

Returns Ok(true) if a randomized committee exists for the specified epoch and the epoch is not before the first epoch. Returns an error if first_epoch is None or if the provided epoch is before the first epoch.

Arguments

• epoch - The epoch for which to check the presence of a randomized stake table.

Errors

Returns an error if first_epoch is None or if epoch is before first_epoch.

type Error = LeaderLookupError

The error type returned by methods like lookup_leader.

type Storage = ()

Storage type used by the underlying fetcher

type StakeTableHash = StakeTableState

fn new<I: NodeImplementation<SeqTypes>>( _committee_members: Vec<PeerConfig<SeqTypes>>, _da_members: Vec<PeerConfig<SeqTypes>>, _storage: Self::Storage, _network: Arc<<I as NodeImplementation<SeqTypes>>::Network>, _public_key: <SeqTypes as NodeType>::SignatureKey, _epoch_height: u64, ) -> Self

Create a committee

fn has_stake_table(&self, epoch: EpochNumber) -> bool

Returns if the stake table is available for the given epoch

async fn get_epoch_root( membership: Arc<RwLock<Self>>, epoch: EpochNumber, ) -> Result<Leaf2>

Gets the validated block header and epoch number of the epoch root at the given block height

async fn get_epoch_drb( membership: Arc<RwLock<Self>>, epoch: EpochNumber, ) -> Result<DrbResult>

Gets the DRB result for the given epoch

fn add_drb_result(&mut self, epoch: EpochNumber, drb: DrbResult)

Called to notify the Membership when a new DRB result has been calculated. Observes the same semantics as add_epoch_root

fn set_first_epoch(&mut self, epoch: EpochNumber, initial_drb_result: DrbResult)

Called to notify the Membership that Epochs are enabled. Implementations should copy the pre-epoch stake table into epoch and epoch+1 when this is called. The value of initial_drb_result should be used for DRB calculations for epochs (epoch+1) and earlier.

fn first_epoch(&self) -> Option<EpochNumber>

Get first epoch if epochs are enabled, None otherwise

fn stake_table_hash(&self, epoch: EpochNumber) -> Option<StakeTableHash>

Returns the commitment of the stake table for the given epoch, Errors if the stake table is not available for the given epoch

fn add_da_committee( &mut self, first_epoch: u64, committee: Vec<PeerConfig<SeqTypes>>, )

fn set_external_channel( &mut self, _external_channel: Receiver<Event<TYPES>>, ) -> impl Future<Output = ()> + Send

fn total_stake(&self, epoch: Option<EpochNumber>) -> Uint<256, 4>

fn total_da_stake(&self, epoch: Option<EpochNumber>) -> Uint<256, 4>

fn leader( &self, view: ViewNumber, epoch: Option<EpochNumber>, ) -> Result<<TYPES as NodeType>::SignatureKey, Error>

The leader of the committee for view view_number in epoch.

fn success_threshold(&self, epoch: Option<EpochNumber>) -> Uint<256, 4>

Returns the threshold for a specific Membership implementation

fn da_success_threshold(&self, epoch: Option<EpochNumber>) -> Uint<256, 4>

Returns the DA threshold for a specific Membership implementation

fn failure_threshold(&self, epoch: Option<EpochNumber>) -> Uint<256, 4>

Returns the threshold for a specific Membership implementation

fn upgrade_threshold(&self, epoch: Option<EpochNumber>) -> Uint<256, 4>

Returns the threshold required to upgrade the network protocol