Struct massa_execution_worker::speculative_roll_state::SpeculativeRollState

pub(crate) struct SpeculativeRollState {
    final_state: Arc<RwLock<dyn FinalStateController>>,
    active_history: Arc<RwLock<ActiveHistory>>,
    pub(crate) added_changes: PoSChanges,
    transfers_history: Arc<RwLock<Vec<TransferInfo>>>,
}

Speculative state of the rolls

Fields

final_state: Arc<RwLock<dyn FinalStateController>>

Thread-safe shared access to the final state. For reading only.

active_history: Arc<RwLock<ActiveHistory>>

History of the outputs of recently executed slots. Slots should be consecutive, newest at the back.

added_changes: PoSChanges

List of changes to the state after settling roll sell/buy

transfers_history: Arc<RwLock<Vec<TransferInfo>>>

Implementations

impl SpeculativeRollState

pub fn new( final_state: Arc<RwLock<dyn FinalStateController>>, active_history: Arc<RwLock<ActiveHistory>>, transfers_history: Arc<RwLock<Vec<TransferInfo>>>, ) -> Self

Creates a new SpeculativeRollState

Arguments

• active_history: thread-safe shared access the speculative execution history

pub fn take(&mut self) -> PoSChanges

Returns the changes caused to the SpeculativeRollState since its creation, and resets their local value to nothing.

pub fn get_snapshot(&self) -> PoSChanges

Takes a snapshot (clone) of the changes caused to the SpeculativeRollState since its creation

pub fn reset_to_snapshot(&mut self, snapshot: PoSChanges)

Resets the SpeculativeRollState to a snapshot (see get_snapshot method)

fn get_rolls(&self, addr: &Address) -> u64

Internal function to retrieve the rolls of a given address

pub fn add_rolls( &mut self, buyer_addr: &Address, roll_count: u64, _operation_id: OperationId, )

Add roll_count rolls to the buyer address. Validity checks must be performed outside of this function.

Arguments

• buyer_addr: address that will receive the rolls
• roll_count: number of rolls it will receive

pub fn try_sell_rolls( &mut self, seller_addr: &Address, slot: Slot, roll_count: u64, periods_per_cycle: u64, thread_count: u8, roll_price: Amount, _operation_id: OperationId, ) -> Result<(), ExecutionError>

Try to sell roll_count rolls from the seller address.

Arguments

• seller_addr: address to sell the rolls from
• roll_count: number of rolls to sell

Returns

• Ok(new_deferred_credits): the amount of deferred credits

pub fn try_slash_rolls( &mut self, addr: &Address, roll_count: u64, ) -> Result<u64, ExecutionError>

Try to slash roll_count rolls from the given address. If not enough roll, slash the available amount and return the value.

Arguments

• addr: address to slash the rolls from
• roll_count: number of rolls to slash

pub fn try_slash_deferred_credits( &mut self, slot: &Slot, addr: &Address, amount: &Amount, _denunciation_idx: &DenunciationIndex, ) -> Amount

Try to slash amount credits from the given address. If not enough credits, slash the available amount and return the value.

Arguments

• addr: address to slash the deferred credits from
• amount: number of deferred credits to slash

pub fn update_production_stats( &mut self, creator: &Address, slot: Slot, block_id: Option<BlockId>, )

Update production statistics of an address.

Arguments

• creator: the supposed creator
• slot: current slot
• block_id: id of the block (if some)

pub fn settle_production_stats( &mut self, slot: &Slot, periods_per_cycle: u64, thread_count: u8, roll_price: Amount, max_miss_ratio: Ratio<u64>, ) -> Vec<(Address, Amount)>

Settle the production statistics at slot.

IMPORTANT: This function should only be used at the end of a cycle.

Arguments:

slot: the final slot of the cycle to compute

pub fn get_address_deferred_credits<R>( &self, address: &Address, slot_range: R, ) -> BTreeMap<Slot, Amount>

where R: RangeBounds<Slot> + Clone,

Get deferred credits of an address starting from a given slot

fn get_address_deferred_credit_for_slot( &self, addr: &Address, slot: &Slot, ) -> Option<Amount>

Gets the deferred credits for a given address that will be credited at a given slot

pub fn get_address_cycle_infos( &self, address: &Address, periods_per_cycle: u64, cur_slot: Slot, ) -> Vec<ExecutionAddressCycleInfo>

Get the production statistics for a given address at a given cycle.

pub fn get_production_stats_at_cycle( &self, cycle: u64, periods_per_cycle: u64, thread_count: u8, cur_slot: &Slot, ) -> (PreHashMap<Address, ProductionStats>, bool)

Get the production statistics for a given cycle. Returns a 2nd boolean result indicating whether the cycle was fetched fully and successfully, or just partially.

pub fn take_unexecuted_deferred_credits( &mut self, slot: &Slot, ) -> DeferredCredits

Take the non-zero deferred credits at or before slot. Set them to zero in the speculative state.

Arguments

• slot: associated slot of the deferred credits to be executed