Struct fil_actor_miner_state::v12::Deadline

pub struct Deadline {
    pub partitions: Cid,
    pub expirations_epochs: Cid,
    pub partitions_posted: BitField,
    pub early_terminations: BitField,
    pub live_sectors: u64,
    pub total_sectors: u64,
    pub faulty_power: PowerPair,
    pub optimistic_post_submissions: Cid,
    pub sectors_snapshot: Cid,
    pub partitions_snapshot: Cid,
    pub optimistic_post_submissions_snapshot: Cid,
}

Deadline holds the state for all sectors due at a specific deadline.

Fields

partitions: Cid

Partitions in this deadline, in order. The keys of this AMT are always sequential integers beginning with zero.

expirations_epochs: Cid

Maps epochs to partitions that may have sectors that expire in or before that epoch, either on-time or early as faults. Keys are quantized to final epochs in each proving deadline.

NOTE: Partitions MUST NOT be removed from this queue (until the associated epoch has passed) even if they no longer have sectors expiring at that epoch. Sectors expiring at this epoch may later be recovered, and this queue will not be updated at that time.

partitions_posted: BitField

early_terminations: BitField

Partitions with sectors that terminated early.

live_sectors: u64

The number of non-terminated sectors in this deadline (incl faulty).

total_sectors: u64

The total number of sectors in this deadline (incl dead).

faulty_power: PowerPair

Memoized sum of faulty power in partitions.

optimistic_post_submissions: Cid

sectors_snapshot: Cid

partitions_snapshot: Cid

optimistic_post_submissions_snapshot: Cid

Implementations

impl Deadline

pub fn new<BS: Blockstore>(store: &BS) -> Result<Self>

pub fn partitions_amt<'db, BS: Blockstore>( &self, store: &'db BS, ) -> Result<Array<'db, Partition, BS>>

pub fn optimistic_proofs_amt<'db, BS: Blockstore>( &self, store: &'db BS, ) -> Result<Array<'db, WindowedPoSt, BS>>

pub fn partitions_snapshot_amt<'db, BS: Blockstore>( &self, store: &'db BS, ) -> Result<Array<'db, Partition, BS>>

pub fn optimistic_proofs_snapshot_amt<'db, BS: Blockstore>( &self, store: &'db BS, ) -> Result<Array<'db, WindowedPoSt, BS>>

pub fn load_partition<BS: Blockstore>( &self, store: &BS, partition_idx: u64, ) -> Result<Partition>

pub fn load_partition_snapshot<BS: Blockstore>( &self, store: &BS, partition_idx: u64, ) -> Result<Partition>

pub fn add_expiration_partitions<BS: Blockstore>( &mut self, store: &BS, expiration_epoch: ChainEpoch, partitions: &[u64], quant: QuantSpec, ) -> Result<()>

Adds some partition numbers to the set expiring at an epoch.

pub fn pop_expired_sectors<BS: Blockstore>( &mut self, store: &BS, until: ChainEpoch, quant: QuantSpec, ) -> Result<ExpirationSet>

PopExpiredSectors terminates expired sectors from all partitions. Returns the expired sector aggregates.

pub fn add_sectors<BS: Blockstore>( &mut self, store: &BS, partition_size: u64, proven: bool, sectors: &[SectorOnChainInfo], sector_size: SectorSize, quant: QuantSpec, ) -> Result<PowerPair>

Adds sectors to a deadline. It’s the caller’s responsibility to make sure that this deadline isn’t currently “open” (i.e., being proved at this point in time). The sectors are assumed to be non-faulty.

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

pub fn pop_expired_partitions<BS: Blockstore>( &mut self, store: &BS, until: ChainEpoch, quant: QuantSpec, ) -> Result<(BitField, bool)>

pub fn terminate_sectors<BS: Blockstore>( &mut self, policy: &Policy, store: &BS, sectors: &Sectors<'_, BS>, epoch: ChainEpoch, partition_sectors: &mut PartitionSectorMap, sector_size: SectorSize, quant: QuantSpec, ) -> Result<PowerPair>

pub fn remove_partitions<BS: Blockstore>( &mut self, store: &BS, to_remove: &BitField, quant: QuantSpec, ) -> Result<(BitField, BitField, PowerPair), Error>

RemovePartitions removes the specified partitions, shifting the remaining ones to the left, and returning the live and dead sectors they contained.

Returns an error if any of the partitions contained faulty sectors or early terminations.

pub fn record_faults<BS: Blockstore>( &mut self, store: &BS, sectors: &Sectors<'_, BS>, sector_size: SectorSize, quant: QuantSpec, fault_expiration_epoch: ChainEpoch, partition_sectors: &mut PartitionSectorMap, ) -> Result<PowerPair>

pub fn declare_faults_recovered<BS: Blockstore>( &mut self, store: &BS, sectors: &Sectors<'_, BS>, sector_size: SectorSize, partition_sectors: &mut PartitionSectorMap, ) -> Result<()>

pub fn process_deadline_end<BS: Blockstore>( &mut self, store: &BS, quant: QuantSpec, fault_expiration_epoch: ChainEpoch, sectors: Cid, ) -> Result<(PowerPair, PowerPair), ActorError>

Processes all PoSt submissions, marking unproven sectors as faulty and clearing failed recoveries. It returns the power delta, and any power that should be penalized (new faults and failed recoveries).

pub fn for_each<BS: Blockstore>( &self, store: &BS, f: impl FnMut(u64, &Partition) -> Result<()>, ) -> Result<()>

pub fn validate_state(&self) -> Result<()>

pub fn load_partitions_for_dispute<BS: Blockstore>( &self, store: &BS, partitions: BitField, ) -> Result<DisputeInfo>

pub fn is_live(&self) -> bool

impl Deadline

pub fn record_proven_sectors<BS: Blockstore>( &mut self, store: &BS, sectors: &Sectors<'_, BS>, sector_size: SectorSize, quant: QuantSpec, fault_expiration: ChainEpoch, post_partitions: &mut [PoStPartition], ) -> Result<PoStResult>

Processes a series of posts, recording proven partitions and marking skipped sectors as faulty.

It returns a PoStResult containing the list of proven and skipped sectors and changes to power (newly faulty power, power that should have been proven recovered but wasn’t, and newly recovered power).

NOTE: This function does not actually verify any proofs. The returned sectors and ignored_sectors must subsequently be validated against the PoSt submitted by the miner.

pub fn record_post_proofs<BS: Blockstore>( &mut self, store: &BS, partitions: &BitField, proofs: &[PoStProof], ) -> Result<()>

pub fn take_post_proofs<BS: Blockstore>( &mut self, store: &BS, idx: u64, ) -> Result<(BitField, Vec<PoStProof>)>

pub fn reschedule_sector_expirations<BS: Blockstore>( &mut self, store: &BS, sectors: &Sectors<'_, BS>, expiration: ChainEpoch, partition_sectors: &mut PartitionSectorMap, sector_size: SectorSize, quant: QuantSpec, ) -> Result<Vec<SectorOnChainInfo>>

RescheduleSectorExpirations reschedules the expirations of the given sectors to the target epoch, skipping any sectors it can’t find.

The power of the rescheduled sectors is assumed to have not changed since initial scheduling.

Note: see the docs on State.RescheduleSectorExpirations for details on why we skip sectors/partitions we can’t find.

Trait Implementations

impl Debug for Deadline

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

Formats the value using the given formatter.

impl Default for Deadline

fn default() -> Deadline

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Deadline

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Deadline

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

where S: Serializer,

Serialize this value into the given Serde serializer.