Struct EpochRewardsCalculator 

pub struct EpochRewardsCalculator {
    pending: Option<PendingRewards>,
    applied: Option<EpochRewardsResult>,
}

Manages a single background epoch reward calculation. Each consumer (consensus and state loop) should have its own instance.

Fields

pending: Option<PendingRewards>

The currently pending calculation, if any.

applied: Option<EpochRewardsResult>

The last result handed out. One node can apply the same epoch boundary twice (a leader builds the block, then validates it), and the second application must reuse the result: recomputing it throws away the in-memory leader counts and fetches the epoch’s last leaf through catchup instead.

Implementations

impl EpochRewardsCalculator

pub fn new() -> Self

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

Check if the result for epoch is being calculated or was already handed out.

pub async fn get_result( &mut self, epoch: EpochNumber, ) -> Option<Result<EpochRewardsResult>>

Retrieve the completed reward calculation for epoch.

Returns None when there is no pending task or earlier result for the requested epoch. Otherwise awaits the task and returns Some(Ok(result)) on success or Some(Err(..)) if it failed or panicked

pub fn discard(&mut self, epoch: EpochNumber)

Drop the result and any pending task for epoch.

Called when the result for epoch did not match the root a boundary proposal committed to. That result was computed from the leader counts of an unfinalized boundary proposal, which may have failed, so it cannot be trusted for the next proposal either. Dropping it lets the next application of the boundary start a task that recovers the counts from the epoch’s decided last leaf, which the cached result would otherwise suppress.

pub fn spawn_background_task( &mut self, epoch: EpochNumber, epoch_height: u64, reward_tree: RewardMerkleTreeV2, instance_state: NodeState, coordinator: EpochMembershipCoordinator<SeqTypes>, leader_counts: Option<LeaderCounts>, )

Start a background task that calculates epoch rewards. Does nothing if calculation is already in progress for this epoch with the same leader counts, or if leader_counts is None and a task will recover them anyway. Aborts any stale pending task since only one epoch matters at a time.

fn needs_spawn( &self, epoch: EpochNumber, leader_counts: Option<&LeaderCounts>, ) -> bool

Whether a task for epoch has to be (re)started.

Two proposals for one boundary block at different views have different leaders, so they carry different leader counts. A pending task started from one of them is replaced when the other is applied, so the task always reflects the last boundary block this node applied.

async fn fetch_and_calculate( epoch: EpochNumber, epoch_height: u64, reward_tree: RewardMerkleTreeV2, instance_state: NodeState, coordinator: EpochMembershipCoordinator<SeqTypes>, leader_counts: Option<LeaderCounts>, ) -> Result<EpochRewardsResult>

async fn calculate_all_rewards( epoch: EpochNumber, validator_leader_counts: ValidatorLeaderCounts, reward_tree: RewardMerkleTreeV2, block_reward: RewardAmount, ) -> Result<EpochRewardsResult>

Calculate all rewards for the epoch and update the reward tree.

Trait Implementations

impl Debug for EpochRewardsCalculator

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

Formats the value using the given formatter.

impl Default for EpochRewardsCalculator

fn default() -> EpochRewardsCalculator

Returns the “default value” for a type.