Struct forest_actor::miner::State

pub struct State {

    pub info: Cid,
    pub pre_commit_deposits: TokenAmount,
    pub locked_funds: TokenAmount,
    pub vesting_funds: Cid,
    pub fee_debt: TokenAmount,
    pub initial_pledge: TokenAmount,
    pub pre_committed_sectors: Cid,
    pub pre_committed_sectors_expiry: Cid,
    pub allocated_sectors: Cid,
    pub sectors: Cid,
    pub proving_period_start: ChainEpoch,
    pub current_deadline: usize,
    pub deadlines: Cid,
    pub early_terminations: BitField,
    pub deadline_cron_active: bool,
}

Balance of Miner Actor should be greater than or equal to the sum of PreCommitDeposits and LockedFunds. It is possible for balance to fall below the sum of PCD, LF and InitialPledgeRequirements, and this is a bad state (IP Debt) that limits a miner actor’s behavior (i.e. no balance withdrawals) Excess balance as computed by st.GetAvailableBalance will be withdrawable or usable for pre-commit deposit or pledge lock-up.

Fields

info: Cid

Contains static info about this miner

pre_commit_deposits: TokenAmount

Total funds locked as pre_commit_deposit

locked_funds: TokenAmount

Total rewards and added funds locked in vesting table

vesting_funds: Cid

VestingFunds (Vesting Funds schedule for the miner).

fee_debt: TokenAmount

Absolute value of debt this miner owes from unpaid fees.

initial_pledge: TokenAmount

Sum of initial pledge requirements of all active sectors

pre_committed_sectors: Cid

Sectors that have been pre-committed but not yet proven. Map, HAMT<SectorNumber, SectorPreCommitOnChainInfo>

pre_committed_sectors_expiry: Cid

PreCommittedSectorsExpiry maintains the state required to expire PreCommittedSectors.

allocated_sectors: Cid

Allocated sector IDs. Sector IDs can never be reused once allocated.

sectors: Cid

Information for all proven and not-yet-garbage-collected sectors.

Sectors are removed from this AMT when the partition to which the sector belongs is compacted.

proving_period_start: ChainEpoch

The first epoch in this miner’s current proving period. This is the first epoch in which a PoSt for a partition at the miner’s first deadline may arrive. Alternatively, it is after the last epoch at which a PoSt for the previous window is valid. Always greater than zero, this may be greater than the current epoch for genesis miners in the first WPoStProvingPeriod epochs of the chain; the epochs before the first proving period starts are exempt from Window PoSt requirements. Updated at the end of every period by a cron callback.

current_deadline: usize

Index of the deadline within the proving period beginning at ProvingPeriodStart that has not yet been finalized. Updated at the end of each deadline window by a cron callback.

deadlines: Cid

The sector numbers due for PoSt at each deadline in the current proving period, frozen at period start. New sectors are added and expired ones removed at proving period boundary. Faults are not subtracted from this in state, but on the fly.

early_terminations: BitField

Deadlines with outstanding fees for early sector termination.

deadline_cron_active: bool

Implementations

impl State

pub fn new<BS: BlockStore>(
    store: &BS,
    info_cid: Cid,
    period_start: ChainEpoch,
    deadline_idx: usize
) -> Result<Self, Box<dyn StdError>>

pub fn get_info<BS: BlockStore>(
    &self,
    store: &BS
) -> Result<MinerInfo, Box<dyn StdError>>

pub fn save_info<BS: BlockStore>(
    &mut self,
    store: &BS,
    info: &MinerInfo
) -> Result<(), Box<dyn StdError>>

pub fn deadline_info(&self, current_epoch: ChainEpoch) -> DeadlineInfo

Returns deadline calculations for the current (according to state) proving period.

pub fn recorded_deadline_info(&self, current_epoch: ChainEpoch) -> DeadlineInfo

pub fn current_proving_period_start(
    &self,
    current_epoch: ChainEpoch
) -> ChainEpoch

pub fn quant_spec_for_deadline(&self, deadline_idx: usize) -> QuantSpec

Returns deadline calculations for the current (according to state) proving period.

pub fn allocate_sector_number<BS: BlockStore>(
    &mut self,
    store: &BS,
    sector_number: SectorNumber
) -> Result<(), ActorError>

pub fn mask_sector_numbers<BS: BlockStore>(
    &mut self,
    store: &BS,
    sector_numbers: &BitField
) -> Result<(), ActorError>

pub fn put_precommitted_sector<BS: BlockStore>(
    &mut self,
    store: &BS,
    info: SectorPreCommitOnChainInfo
) -> Result<(), Box<dyn StdError>>

Stores a pre-committed sector info, failing if the sector number is already present.

pub fn get_precommitted_sector<BS: BlockStore>(
    &self,
    store: &BS,
    sector_num: SectorNumber
) -> Result<Option<SectorPreCommitOnChainInfo>, HamtError>

pub fn find_precommitted_sectors<BS: BlockStore>(
    &self,
    store: &BS,
    sector_numbers: &[SectorNumber]
) -> Result<Vec<SectorPreCommitOnChainInfo>, Box<dyn StdError>>

Gets and returns the requested pre-committed sectors, skipping missing sectors.

pub fn delete_precommitted_sectors<BS: BlockStore>(
    &mut self,
    store: &BS,
    sector_nums: &[SectorNumber]
) -> Result<(), HamtError>

pub fn has_sector_number<BS: BlockStore>(
    &self,
    store: &BS,
    sector_num: SectorNumber
) -> Result<bool, Box<dyn StdError>>

pub fn put_sectors<BS: BlockStore>(
    &mut self,
    store: &BS,
    new_sectors: Vec<SectorOnChainInfo>
) -> Result<(), Box<dyn StdError>>

pub fn get_sector<BS: BlockStore>(
    &self,
    store: &BS,
    sector_num: SectorNumber
) -> Result<Option<SectorOnChainInfo>, Box<dyn StdError>>

pub fn delete_sectors<BS: BlockStore>(
    &mut self,
    store: &BS,
    sector_nos: &BitField
) -> Result<(), AmtError>

pub fn for_each_sector<BS: BlockStore, F>(
    &self,
    store: &BS,
    f: F
) -> Result<(), Box<dyn StdError>> where
    F: FnMut(&SectorOnChainInfo) -> Result<(), Box<dyn StdError>>, 

pub fn find_sector<BS: BlockStore>(
    &self,
    store: &BS,
    sector_number: SectorNumber
) -> Result<(usize, usize), Box<dyn StdError>>

Returns the deadline and partition index for a sector number.

pub fn reschedule_sector_expirations<BS: BlockStore>(
    &mut self,
    store: &BS,
    current_epoch: ChainEpoch,
    sector_size: SectorSize,
    deadline_sectors: DeadlineSectorMap
) -> Result<Vec<SectorOnChainInfo>, Box<dyn StdError>>

Schedules each sector to expire at its next deadline end. If it can’t find any given sector, it skips it.

This method assumes that each sector’s power has not changed, despite the rescheduling.

Note: this method is used to “upgrade” sectors, rescheduling the now-replaced sectors to expire at the end of the next deadline. Given the expense of sealing a sector, this function skips missing/faulty/terminated “upgraded” sectors instead of failing. That way, the new sectors can still be proved.

pub fn assign_sectors_to_deadlines<BS: BlockStore>(
    &mut self,
    store: &BS,
    current_epoch: ChainEpoch,
    sectors: Vec<SectorOnChainInfo>,
    partition_size: u64,
    sector_size: SectorSize
) -> Result<(), Box<dyn StdError>>

Assign new sectors to deadlines.

pub fn pop_early_terminations<BS: BlockStore>(
    &mut self,
    store: &BS,
    max_partitions: u64,
    max_sectors: u64
) -> Result<(TerminationResult, bool), Box<dyn StdError>>

Pops up to max_sectors early terminated sectors from all deadlines.

Returns true if we still have more early terminations to process.

pub fn check_sector_health<BS: BlockStore>(
    &self,
    store: &BS,
    deadline_idx: usize,
    partition_idx: usize,
    sector_number: SectorNumber
) -> Result<(), Box<dyn StdError>>

pub fn load_sector_infos<BS: BlockStore>(
    &self,
    store: &BS,
    sectors: &BitField
) -> Result<Vec<SectorOnChainInfo>, Box<dyn StdError>>

Loads sector info for a sequence of sectors.

pub fn load_deadlines<BS: BlockStore>(
    &self,
    store: &BS
) -> Result<Deadlines, ActorError>

pub fn save_deadlines<BS: BlockStore>(
    &mut self,
    store: &BS,
    deadlines: Deadlines
) -> Result<(), Box<dyn StdError>>

pub fn load_vesting_funds<BS: BlockStore>(
    &self,
    store: &BS
) -> Result<VestingFunds, Box<dyn StdError>>

Loads the vesting funds table from the store.

pub fn save_vesting_funds<BS: BlockStore>(
    &mut self,
    store: &BS,
    funds: &VestingFunds
) -> Result<(), Box<dyn StdError>>

Saves the vesting table to the store.

pub fn continue_deadline_cron(&self) -> bool

pub fn add_pre_commit_deposit(
    &mut self,
    amount: &TokenAmount
) -> Result<(), String>

pub fn add_initial_pledge(&mut self, amount: &TokenAmount) -> Result<(), String>

pub fn apply_penalty(&mut self, penalty: &TokenAmount) -> Result<(), String>

pub fn add_locked_funds<BS: BlockStore>(
    &mut self,
    store: &BS,
    current_epoch: ChainEpoch,
    vesting_sum: &TokenAmount,
    spec: &VestSpec
) -> Result<TokenAmount, Box<dyn StdError>>

First vests and unlocks the vested funds AND then locks the given funds in the vesting table.

pub fn repay_partial_debt_in_priority_order<BS: BlockStore>(
    &mut self,
    store: &BS,
    current_epoch: ChainEpoch,
    curr_balance: &TokenAmount
) -> Result<(TokenAmount, TokenAmount), Box<dyn StdError>>

Draws from vesting table and unlocked funds to repay up to the fee debt. Returns the amount unlocked from the vesting table and the amount taken from current balance. If the fee debt exceeds the total amount available for repayment the fee debt field is updated to track the remaining debt. Otherwise it is set to zero.

pub fn repay_debts(
    &mut self,
    curr_balance: &TokenAmount
) -> Result<TokenAmount, Box<dyn StdError>>

Repays the full miner actor fee debt. Returns the amount that must be burnt and an error if there are not sufficient funds to cover repayment. Miner state repays from unlocked funds and fails if unlocked funds are insufficient to cover fee debt. FeeDebt will be zero after a successful call.

pub fn unlock_unvested_funds<BS: BlockStore>(
    &mut self,
    store: &BS,
    current_epoch: ChainEpoch,
    target: &TokenAmount
) -> Result<TokenAmount, Box<dyn StdError>>

Unlocks an amount of funds that have not yet vested, if possible. The soonest-vesting entries are unlocked first. Returns the amount actually unlocked.

pub fn unlock_vested_funds<BS: BlockStore>(
    &mut self,
    store: &BS,
    current_epoch: ChainEpoch
) -> Result<TokenAmount, Box<dyn StdError>>

Unlocks all vesting funds that have vested before the provided epoch. Returns the amount unlocked.

pub fn check_vested_funds<BS: BlockStore>(
    &self,
    store: &BS,
    current_epoch: ChainEpoch
) -> Result<TokenAmount, Box<dyn StdError>>

CheckVestedFunds returns the amount of vested funds that have vested before the provided epoch.

pub fn get_unlocked_balance(
    &self,
    actor_balance: &TokenAmount
) -> Result<TokenAmount, String>

Unclaimed funds that are not locked – includes funds used to cover initial pledge requirement.

pub fn get_available_balance(
    &self,
    actor_balance: &TokenAmount
) -> Result<TokenAmount, String>

Unclaimed funds. Actor balance - (locked funds, precommit deposit, ip requirement) Can go negative if the miner is in IP debt.

pub fn check_balance_invariants(
    &self,
    balance: &TokenAmount
) -> Result<(), String>

pub fn quant_spec_every_deadline(&self) -> QuantSpec

pre-commit expiry

pub fn add_pre_commit_expiry<BS: BlockStore>(
    &mut self,
    store: &BS,
    expire_epoch: ChainEpoch,
    sector_number: SectorNumber
) -> Result<(), Box<dyn StdError>>

pub fn expire_pre_commits<BS: BlockStore>(
    &mut self,
    store: &BS,
    current_epoch: ChainEpoch
) -> Result<TokenAmount, Box<dyn StdError>>

pub fn advance_deadline<BS: BlockStore>(
    &mut self,
    store: &BS,
    current_epoch: ChainEpoch
) -> Result<AdvanceDeadlineResult, Box<dyn StdError>>

Trait Implementations

impl Cbor for State

fn marshal_cbor(&self) -> Result<Vec<u8, Global>, Error>

Marshalls cbor encodable object into cbor bytes

fn unmarshal_cbor(bz: &[u8]) -> Result<Self, Error>

Unmarshals cbor encoded bytes to object

fn cid(&self) -> Result<Cid, Error>

Returns the content identifier of the raw block of data Default is Blake2b256 hash

impl Clone for State

fn clone(&self) -> State

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for State

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for State

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.