Struct fil_actor_interface::Policy

source ·

pub struct Policy {Show 45 fields
    pub max_aggregated_sectors: u64,
    pub min_aggregated_sectors: u64,
    pub max_aggregated_proof_size: usize,
    pub max_replica_update_proof_size: usize,
    pub pre_commit_sector_batch_max_size: usize,
    pub prove_replica_updates_max_size: usize,
    pub expired_pre_commit_clean_up_delay: i64,
    pub wpost_proving_period: i64,
    pub wpost_challenge_window: i64,
    pub wpost_period_deadlines: u64,
    pub wpost_max_chain_commit_age: i64,
    pub wpost_dispute_window: i64,
    pub sectors_max: usize,
    pub max_partitions_per_deadline: u64,
    pub max_control_addresses: usize,
    pub max_peer_id_length: usize,
    pub max_multiaddr_data: usize,
    pub addressed_partitions_max: u64,
    pub declarations_max: u64,
    pub addressed_sectors_max: u64,
    pub posted_partitions_max: u64,
    pub max_pre_commit_randomness_lookback: i64,
    pub pre_commit_challenge_delay: i64,
    pub wpost_challenge_lookback: i64,
    pub fault_declaration_cutoff: i64,
    pub fault_max_age: i64,
    pub worker_key_change_delay: i64,
    pub min_sector_expiration: i64,
    pub max_sector_expiration_extension: i64,
    pub deal_limit_denominator: u64,
    pub consensus_fault_ineligibility_duration: i64,
    pub new_sectors_per_period_max: usize,
    pub chain_finality: i64,
    pub valid_post_proof_type: ProofSet,
    pub valid_pre_commit_proof_type: ProofSet,
    pub minimum_verified_allocation_size: BigInt,
    pub minimum_verified_allocation_term: i64,
    pub maximum_verified_allocation_term: i64,
    pub maximum_verified_allocation_expiration: i64,
    pub end_of_life_claim_drop_period: i64,
    pub deal_updates_interval: i64,
    pub prov_collateral_percent_supply_num: i64,
    pub prov_collateral_percent_supply_denom: i64,
    pub market_default_allocation_term_buffer: i64,
    pub minimum_consensus_power: BigInt,
}

Fields§

§max_aggregated_sectors: u64

Maximum amount of sectors that can be aggregated.

§min_aggregated_sectors: u64

Minimum amount of sectors that can be aggregated.

§max_aggregated_proof_size: usize

Maximum total aggregated proof size.

§max_replica_update_proof_size: usize

Maximum total replica update proof size.

§pre_commit_sector_batch_max_size: usize

The maximum number of sector pre-commitments in a single batch.

§prove_replica_updates_max_size: usize

The maximum number of sector replica updates in a single batch.

§expired_pre_commit_clean_up_delay: i64

The delay between pre commit expiration and clean up from state. This enforces that expired pre-commits stay in state for a period of time creating a grace period during which a late-running aggregated prove-commit can still prove its non-expired precommits without resubmitting a message

§wpost_proving_period: i64

The period over which all a miner’s active sectors will be challenged.

§wpost_challenge_window: i64

The duration of a deadline’s challenge window, the period before a deadline when the challenge is available. Notice that the challenge window is assumed to have the same duration as a deadline itself both in FIP and implementation.

§wpost_period_deadlines: u64

The number of non-overlapping PoSt deadlines in each proving period.

§wpost_max_chain_commit_age: i64

The maximum distance back that a valid Window PoSt must commit to the current chain.

§wpost_dispute_window: i64

WPoStDisputeWindow is the period after a Window PoSt window ends during which PoSts submitted during that period may be disputed.

§sectors_max: usize

The maximum number of sectors that a miner can have simultaneously active. This also bounds the number of faults that can be declared, etc.

§max_partitions_per_deadline: u64

Maximum number of partitions that will be assigned to a deadline.

§max_control_addresses: usize

Maximum number of control addresses a miner may register.

§max_peer_id_length: usize

MaxPeerIDLength is the maximum length allowed for any on-chain peer ID.

§max_multiaddr_data: usize

MaxMultiaddrData is the maximum amount of data that can be stored in multiaddrs.

§addressed_partitions_max: u64

The maximum number of partitions that may be required to be loaded in a single invocation. This limits the number of simultaneous fault, recovery, or sector-extension declarations.

§declarations_max: u64

Maximum number of unique “declarations” in batch operations.

§addressed_sectors_max: u64

The maximum number of sector infos that may be required to be loaded in a single invocation.

§posted_partitions_max: u64

The maximum number of partitions that can be proven in a single PoSt message.

§max_pre_commit_randomness_lookback: i64§pre_commit_challenge_delay: i64

Number of epochs between publishing the precommit and when the challenge for interactive PoRep is drawn used to ensure it is not predictable by miner.

§wpost_challenge_lookback: i64

Lookback from the deadline’s challenge window opening from which to sample chain randomness for the challenge seed.

§fault_declaration_cutoff: i64

Minimum period before a deadline’s challenge window opens that a fault must be declared for that deadline.

§fault_max_age: i64

The maximum age of a fault before the sector is terminated.

§worker_key_change_delay: i64

Staging period for a miner worker key change.

§min_sector_expiration: i64

Minimum number of epochs past the current epoch a sector may be set to expire.

§max_sector_expiration_extension: i64

Maximum number of epochs past the current epoch a sector may be set to expire. The actual maximum extension will be the minimum of CurrEpoch + MaximumSectorExpirationExtension and sector.ActivationEpoch+sealProof.SectorMaximumLifetime()

§deal_limit_denominator: u64

Ratio of sector size to maximum deals per sector. The maximum number of deals is the sector size divided by this number.

§consensus_fault_ineligibility_duration: i64

Number of epochs after a consensus fault for which a miner is ineligible for permissioned actor methods and winning block elections.

§new_sectors_per_period_max: usize

The maximum number of new sectors that may be staged by a miner during a single proving period.

§chain_finality: i64

Epochs after which chain state is final with overwhelming probability (hence the likelihood of two fork of this size is negligible).

§valid_post_proof_type: ProofSet

Allowed post proof types for new miners

§valid_pre_commit_proof_type: ProofSet

Allowed pre commit proof types for new miners

§minimum_verified_allocation_size: BigInt

Minimum verified deal size

§minimum_verified_allocation_term: i64

Minimum term for a verified data allocation (epochs)

§maximum_verified_allocation_term: i64

Maximum term for a verified data allocaion (epochs)

§maximum_verified_allocation_expiration: i64

Maximum time a verified allocation can be active without being claimed (epochs). Supports recovery of erroneous allocations and prevents indefinite squatting on datacap.

§end_of_life_claim_drop_period: i64§deal_updates_interval: i64

The number of blocks between payouts for deals

§prov_collateral_percent_supply_num: i64

Numerator of the percentage of normalized cirulating supply that must be covered by provider collateral

§prov_collateral_percent_supply_denom: i64

Denominator of the percentage of normalized cirulating supply that must be covered by provider collateral

§market_default_allocation_term_buffer: i64

The default duration after a verified deal’s nominal term to set for the corresponding allocation’s maximum term.

§minimum_consensus_power: BigInt

Minimum miner consensus power

Struct fil_actor_interface::PolicyCopy item path

Fields§

Trait Implementations§

impl Clone for Policy

fn clone(&self) -> Policy

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

impl Debug for Policy

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

impl Default for Policy

fn default() -> Policy

impl<'de> Deserialize<'de> for Policy

fn deserialize<__D>( __deserializer: __D, ) -> Result<Policy, <__D as Deserializer<'de>>::Error>where __D: Deserializer<'de>,

impl PartialEq for Policy

fn eq(&self, other: &Policy) -> bool

fn ne(&self, other: &Rhs) -> bool

impl Serialize for Policy

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where __S: Serializer,

impl Eq for Policy

impl StructuralPartialEq for Policy

Auto Trait Implementations§

impl Freeze for Policy

impl RefUnwindSafe for Policy

impl Send for Policy

impl Sync for Policy

impl Unpin for Policy

impl UnwindSafe for Policy

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> Conv for T

fn conv<T>(self) -> Twhere Self: Into<T>,

impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

fn equivalent(&self, key: &K) -> bool

impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

fn equivalent(&self, key: &K) -> bool

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self>where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>where Self: UpperHex,

fn fmt_list(self) -> FmtList<Self>where &'a Self: for<'a> IntoIterator,

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>where F: FnOnce(&Self) -> bool,

impl<T> Pipe for Twhere T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> Rwhere Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> Rwhere Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> Rwhere Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

impl<T> Pointable for T

const ALIGN: usize = _

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T> References<RawCodec> for T

fn references<R, E>(_c: RawCodec, _r: &mut R, _set: &mut E) -> Result<(), Error>where R: Read, E: Extend<Cid<64>>,

impl<T> Same for T

type Output = T

impl<T> Tap for T

fn tap(self, func: impl FnOnce(&Self)) -> Self

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Struct fil_actor_interface::Policy

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

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

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn conv<T>(self) -> T
where Self: Into<T>,

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T> Pipe for T
where T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

fn references<R, E>(_c: RawCodec, _r: &mut R, _set: &mut E) -> Result<(), Error>
where R: Read, E: Extend<Cid<64>>,

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

impl<T> ToOwned for T
where T: Clone,

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,