miner

package

Go to main page

Versions in this module

v0

v0.9.47

Apr 22, 2021

v0.9.46

Apr 8, 2021

v0.9.45

Mar 30, 2021

v0.9.44

Mar 28, 2021

Changes in this version

+ var DeclaredFaultFactorNum = 214

+ var DeclaredFaultProjectionPeriod = abi.ChainEpoch((builtin.EpochsInDay * DeclaredFaultFactorNum) / DeclaredFaultFactorDenom)

+ var RewardVestingSpec = VestSpec

+ var UndeclaredFaultProjectionPeriod = abi.ChainEpoch(5) * builtin.EpochsInDay

type DeadlineInfo

+ func (d *DeadlineInfo) Last() abi.ChainEpoch

+ func (d *DeadlineInfo) NextNotElapsed() *DeadlineInfo

+ func (d *DeadlineInfo) NextOpen() abi.ChainEpoch

+ func (d *DeadlineInfo) QuantSpec() QuantSpec

v0.9.14

Mar 27, 2021

Changes in this version

+ const AddressedPartitionsMax

+ const AddressedSectorsMax

+ const ChainFinality

+ const DealLimitDenominator

+ const MaxSectorExpirationExtension

+ const MinSectorExpiration

+ const TerminationLifetimeCap

+ var DeclaredFaultFactorDenom = 100

+ var DeclaredFaultFactorNumV0 = 214

+ var DeclaredFaultFactorNumV3 = 351

+ var DeclaredFaultProjectionPeriodV0 = abi.ChainEpoch((builtin.EpochsInDay * DeclaredFaultFactorNumV0) / DeclaredFaultFactorDenom)

+ var DeclaredFaultProjectionPeriodV3 = abi.ChainEpoch((builtin.EpochsInDay * DeclaredFaultFactorNumV3) / DeclaredFaultFactorDenom)

+ var InitialPledgeFactor = 20

+ var InitialPledgeProjectionPeriod = abi.ChainEpoch(InitialPledgeFactor) * builtin.EpochsInDay

+ var LockTargetFactorDenom = big.NewInt(10)

+ var LockTargetFactorNum = big.NewInt(3)

+ var NoQuantization = NewQuantSpec(1, 0)

+ var PreCommitDepositFactor = 20

+ var PreCommitDepositProjectionPeriod = abi.ChainEpoch(PreCommitDepositFactor) * builtin.EpochsInDay

+ var RewardVestingSpecV0 = VestSpec

+ var RewardVestingSpecV1 = VestSpec

+ var SealedCIDPrefix = cid.Prefix

+ var SpaceRaceInitialPledgeMaxPerByte = big.Div(big.NewInt(1e18), big.NewInt(32 << 30))

+ var UndeclaredFaultFactorDenom = 10

+ var UndeclaredFaultFactorNumV0 = 50

+ var UndeclaredFaultFactorNumV1 = 35

+ var UndeclaredFaultProjectionPeriodV0 = abi.ChainEpoch(...)

+ var UndeclaredFaultProjectionPeriodV1 = abi.ChainEpoch(...)

+ var WPoStMaxChainCommitAge = WPoStChallengeWindow

+ func ExpectedRewardForPower(rewardEstimate, networkQAPowerEstimate *smoothing.FilterEstimate, ...) abi.TokenAmount

+ func FindSector(store adt.Store, deadlines *Deadlines, sectorNum abi.SectorNumber) (uint64, uint64, error)

+ func InitialPledgeForPower(qaPower abi.StoragePower, baselinePower abi.StoragePower, ...) abi.TokenAmount

+ func PledgePenaltyForDeclaredFault(rewardEstimate, networkQAPowerEstimate *smoothing.FilterEstimate, ...) abi.TokenAmount

+ func PledgePenaltyForTermination(dayRewardAtActivation, twentyDayRewardAtActivation abi.TokenAmount, ...) abi.TokenAmount

+ func PledgePenaltyForUndeclaredFault(rewardEstimate, networkQAPowerEstimate *smoothing.FilterEstimate, ...) abi.TokenAmount

+ func PreCommitDepositForPower(rewardEstimate, networkQAPowerEstimate *smoothing.FilterEstimate, ...) abi.TokenAmount

+ func QAPowerForSector(size abi.SectorSize, sector *SectorOnChainInfo) abi.StoragePower

+ func QAPowerForWeight(size abi.SectorSize, duration abi.ChainEpoch, ...) abi.StoragePower

+ func QualityForWeight(size abi.SectorSize, duration abi.ChainEpoch, ...) abi.SectorQuality

+ func RewardForConsensusSlashReport(elapsedEpoch abi.ChainEpoch, collateral abi.TokenAmount) abi.TokenAmount

type Actor

+ func (a Actor) Code() cid.Cid

+ func (a Actor) CompactPartitions(rt Runtime, params *CompactPartitionsParams) *abi.EmptyValue

+ func (a Actor) CompactSectorNumbers(rt Runtime, params *CompactSectorNumbersParams) *abi.EmptyValue

+ func (a Actor) State() cbor.Er

+ type BitfieldQueue struct

+ func LoadBitfieldQueue(store adt.Store, root cid.Cid, quant QuantSpec) (BitfieldQueue, error)

+ func (q BitfieldQueue) AddManyToQueueValues(values map[abi.ChainEpoch][]uint64) error

+ func (q BitfieldQueue) AddToQueue(rawEpoch abi.ChainEpoch, values bitfield.BitField) error

+ func (q BitfieldQueue) AddToQueueValues(epoch abi.ChainEpoch, values ...uint64) error

+ func (q BitfieldQueue) Cut(toCut bitfield.BitField) error

+ func (q BitfieldQueue) ForEach(cb func(epoch abi.ChainEpoch, bf bitfield.BitField) error) error

+ func (q BitfieldQueue) PopUntil(until abi.ChainEpoch) (values bitfield.BitField, modified bool, err error)

type ChangeWorkerAddressParams

+ NewControlAddrs []addr.Address

+ type CompactPartitionsParams struct

+ Deadline uint64

+ Partitions bitfield.BitField

+ func (t *CompactPartitionsParams) MarshalCBOR(w io.Writer) error

+ func (t *CompactPartitionsParams) UnmarshalCBOR(r io.Reader) error

+ type CompactSectorNumbersParams struct

+ MaskSectorNumbers bitfield.BitField

+ func (t *CompactSectorNumbersParams) MarshalCBOR(w io.Writer) error

+ func (t *CompactSectorNumbersParams) UnmarshalCBOR(r io.Reader) error

type CronEventType

+ const CronEventProcessEarlyTerminations

+ const CronEventProvingDeadline

+ type Deadline struct

+ EarlyTerminations bitfield.BitField

+ ExpirationsEpochs cid.Cid

+ FaultyPower PowerPair

+ LiveSectors uint64

+ Partitions cid.Cid

+ PostSubmissions bitfield.BitField

+ TotalSectors uint64

+ func ConstructDeadline(emptyArrayCid cid.Cid) *Deadline

+ func (d *Deadline) AddExpirationPartitions(store adt.Store, expirationEpoch abi.ChainEpoch, partitions []uint64, ...) error

+ func (d *Deadline) LoadPartition(store adt.Store, partIdx uint64) (*Partition, error)

+ func (d *Deadline) PartitionsArray(store adt.Store) (*adt.Array, error)

+ func (dl *Deadline) AddSectors(store adt.Store, partitionSize uint64, sectors []*SectorOnChainInfo, ...) (PowerPair, error)

+ func (dl *Deadline) DeclareFaults(store adt.Store, sectors Sectors, ssize abi.SectorSize, quant QuantSpec, ...) (newFaultyPower PowerPair, err error)

+ func (dl *Deadline) DeclareFaultsRecovered(store adt.Store, sectors Sectors, ssize abi.SectorSize, ...) (err error)

+ func (dl *Deadline) PopEarlyTerminations(store adt.Store, maxPartitions, maxSectors uint64) (result TerminationResult, hasMore bool, err error)

+ func (dl *Deadline) PopExpiredSectors(store adt.Store, until abi.ChainEpoch, quant QuantSpec) (*ExpirationSet, error)

+ func (dl *Deadline) ProcessDeadlineEnd(store adt.Store, quant QuantSpec, faultExpirationEpoch abi.ChainEpoch) (newFaultyPower, failedRecoveryPower PowerPair, err error)

+ func (dl *Deadline) RecordProvenSectors(store adt.Store, sectors Sectors, ssize abi.SectorSize, quant QuantSpec, ...) (*PoStResult, error)

+ func (dl *Deadline) RemovePartitions(store adt.Store, toRemove bitfield.BitField, quant QuantSpec) (live, dead bitfield.BitField, removedPower PowerPair, err error)

+ func (dl *Deadline) RescheduleSectorExpirations(store adt.Store, sectors Sectors, expiration abi.ChainEpoch, ...) error

+ func (dl *Deadline) TerminateSectors(store adt.Store, sectors Sectors, epoch abi.ChainEpoch, ...) (powerLost PowerPair, err error)

+ func (t *Deadline) MarshalCBOR(w io.Writer) error

+ func (t *Deadline) UnmarshalCBOR(r io.Reader) error

+ type DeadlineSectorMap map[uint64]PartitionSectorMap

+ func (dm DeadlineSectorMap) Add(dlIdx, partIdx uint64, sectorNos bitfield.BitField) error

+ func (dm DeadlineSectorMap) AddValues(dlIdx, partIdx uint64, sectorNos ...uint64) error

+ func (dm DeadlineSectorMap) Check(maxPartitions, maxSectors uint64) error

+ func (dm DeadlineSectorMap) Count() (partitions, sectors uint64, err error)

+ func (dm DeadlineSectorMap) Deadlines() []uint64

+ func (dm DeadlineSectorMap) ForEach(cb func(dlIdx uint64, pm PartitionSectorMap) error) error

type Deadlines

+ func (d *Deadlines) ForEach(store adt.Store, cb func(dlIdx uint64, dl *Deadline) error) error

+ func (d *Deadlines) LoadDeadline(store adt.Store, dlIdx uint64) (*Deadline, error)

+ func (d *Deadlines) UpdateDeadline(store adt.Store, dlIdx uint64, deadline *Deadline) error

+ type ExpirationExtension struct

+ Deadline uint64

+ NewExpiration abi.ChainEpoch

+ Partition uint64

+ Sectors bitfield.BitField

+ func (t *ExpirationExtension) MarshalCBOR(w io.Writer) error

+ func (t *ExpirationExtension) UnmarshalCBOR(r io.Reader) error

+ type ExpirationQueue struct

+ func LoadExpirationQueue(store adt.Store, root cid.Cid, quant QuantSpec) (ExpirationQueue, error)

+ func (q ExpirationQueue) AddActiveSectors(sectors []*SectorOnChainInfo, ssize abi.SectorSize) (bitfield.BitField, PowerPair, abi.TokenAmount, error)

+ func (q ExpirationQueue) PopUntil(until abi.ChainEpoch) (*ExpirationSet, error)

+ func (q ExpirationQueue) RemoveSectors(sectors []*SectorOnChainInfo, faults bitfield.BitField, ...) (*ExpirationSet, PowerPair, error)

+ func (q ExpirationQueue) ReplaceSectors(oldSectors, newSectors []*SectorOnChainInfo, ssize abi.SectorSize) (bitfield.BitField, bitfield.BitField, PowerPair, abi.TokenAmount, error)

+ func (q ExpirationQueue) RescheduleAllAsFaults(faultExpiration abi.ChainEpoch) error

+ func (q ExpirationQueue) RescheduleAsFaults(newExpiration abi.ChainEpoch, sectors []*SectorOnChainInfo, ...) (PowerPair, error)

+ func (q ExpirationQueue) RescheduleExpirations(newExpiration abi.ChainEpoch, sectors []*SectorOnChainInfo, ...) error

+ func (q ExpirationQueue) RescheduleRecovered(sectors []*SectorOnChainInfo, ssize abi.SectorSize) (PowerPair, error)

+ type ExpirationSet struct

+ ActivePower PowerPair

+ EarlySectors bitfield.BitField

+ FaultyPower PowerPair

+ OnTimePledge abi.TokenAmount

+ OnTimeSectors bitfield.BitField

+ func NewExpirationSet(onTimeSectors, earlySectors bitfield.BitField, onTimePledge abi.TokenAmount, ...) *ExpirationSet

+ func NewExpirationSetEmpty() *ExpirationSet

+ func (es *ExpirationSet) Add(onTimeSectors, earlySectors bitfield.BitField, onTimePledge abi.TokenAmount, ...) error

+ func (es *ExpirationSet) Count() (count uint64, err error)

+ func (es *ExpirationSet) IsEmpty() (empty bool, err error)

+ func (es *ExpirationSet) Remove(onTimeSectors, earlySectors bitfield.BitField, onTimePledge abi.TokenAmount, ...) error

+ func (t *ExpirationSet) MarshalCBOR(w io.Writer) error

+ func (t *ExpirationSet) UnmarshalCBOR(r io.Reader) error

type ExtendSectorExpirationParams

+ Extensions []ExpirationExtension

type FaultDeclaration

+ Partition uint64

type GetControlAddressesReturn

+ ControlAddrs []addr.Address

type MinerInfo

+ ControlAddresses []addr.Address

+ func ConstructMinerInfo(owner addr.Address, worker addr.Address, controlAddrs []addr.Address, ...) (*MinerInfo, error)

+ type Partition struct

+ EarlyTerminated cid.Cid

+ ExpirationsEpochs cid.Cid

+ Faults bitfield.BitField

+ FaultyPower PowerPair

+ LivePower PowerPair

+ Recoveries bitfield.BitField

+ RecoveringPower PowerPair

+ Sectors bitfield.BitField

+ Terminated bitfield.BitField

+ func ConstructPartition(emptyArray cid.Cid) *Partition

+ func (p *Partition) ActivePower() PowerPair

+ func (p *Partition) ActiveSectors() (bitfield.BitField, error)

+ func (p *Partition) AddSectors(store adt.Store, sectors []*SectorOnChainInfo, ssize abi.SectorSize, ...) (PowerPair, error)

+ func (p *Partition) DeclareFaults(store adt.Store, sectors Sectors, sectorNos bitfield.BitField, ...) (newFaults bitfield.BitField, newFaultyPower PowerPair, err error)

+ func (p *Partition) DeclareFaultsRecovered(sectors Sectors, ssize abi.SectorSize, sectorNos bitfield.BitField) (err error)

+ func (p *Partition) LiveSectors() (bitfield.BitField, error)

+ func (p *Partition) PopEarlyTerminations(store adt.Store, maxSectors uint64) (result TerminationResult, hasMore bool, err error)

+ func (p *Partition) PopExpiredSectors(store adt.Store, until abi.ChainEpoch, quant QuantSpec) (*ExpirationSet, error)

+ func (p *Partition) RecordMissedPost(store adt.Store, faultExpiration abi.ChainEpoch, quant QuantSpec) (newFaultPower, failedRecoveryPower PowerPair, err error)

+ func (p *Partition) RecordSkippedFaults(store adt.Store, sectors Sectors, ssize abi.SectorSize, quant QuantSpec, ...) (newFaultPower, retractedRecoveryPower PowerPair, err error)

+ func (p *Partition) RecoverFaults(store adt.Store, sectors Sectors, ssize abi.SectorSize, quant QuantSpec) (PowerPair, error)

+ func (p *Partition) ReplaceSectors(store adt.Store, oldSectors, newSectors []*SectorOnChainInfo, ...) (PowerPair, abi.TokenAmount, error)

+ func (p *Partition) RescheduleExpirations(store adt.Store, sectors Sectors, newExpiration abi.ChainEpoch, ...) (moved bitfield.BitField, err error)

+ func (p *Partition) TerminateSectors(store adt.Store, sectors Sectors, epoch abi.ChainEpoch, ...) (*ExpirationSet, error)

+ func (t *Partition) MarshalCBOR(w io.Writer) error

+ func (t *Partition) UnmarshalCBOR(r io.Reader) error

+ type PartitionKey struct

+ Deadline uint64

+ Partition uint64

+ type PartitionSectorMap map[uint64]bitfield.BitField

+ func (pm PartitionSectorMap) Add(partIdx uint64, sectorNos bitfield.BitField) error

+ func (pm PartitionSectorMap) AddValues(partIdx uint64, sectorNos ...uint64) error

+ func (pm PartitionSectorMap) Count() (partitions, sectors uint64, err error)

+ func (pm PartitionSectorMap) ForEach(cb func(partIdx uint64, sectorNos bitfield.BitField) error) error

+ func (pm PartitionSectorMap) Partitions() []uint64

+ type PoStPartition struct

+ Index uint64

+ Skipped bitfield.BitField

+ func (t *PoStPartition) MarshalCBOR(w io.Writer) error

+ func (t *PoStPartition) UnmarshalCBOR(r io.Reader) error

+ type PoStResult struct

+ IgnoredSectors bitfield.BitField

+ NewFaultyPower PowerPair

+ RecoveredPower PowerPair

+ RetractedRecoveryPower PowerPair

+ Sectors bitfield.BitField

+ func (p *PoStResult) PenaltyPower() PowerPair

+ func (p *PoStResult) PowerDelta() PowerPair

+ type PowerPair struct

+ QA abi.StoragePower

+ Raw abi.StoragePower

+ func NewPowerPair(raw, qa abi.StoragePower) PowerPair

+ func NewPowerPairZero() PowerPair

+ func PowerForSector(sectorSize abi.SectorSize, sector *SectorOnChainInfo) PowerPair

+ func PowerForSectors(ssize abi.SectorSize, sectors []*SectorOnChainInfo) PowerPair

+ func (pp *PowerPair) Equals(other PowerPair) bool

+ func (pp PowerPair) Add(other PowerPair) PowerPair

+ func (pp PowerPair) IsZero() bool

+ func (pp PowerPair) Neg() PowerPair

+ func (pp PowerPair) Sub(other PowerPair) PowerPair

+ func (t *PowerPair) MarshalCBOR(w io.Writer) error

+ func (t *PowerPair) UnmarshalCBOR(r io.Reader) error

+ type QuantSpec struct

+ func NewQuantSpec(unit, offset abi.ChainEpoch) QuantSpec

+ func QuantSpecForDeadline(di *dline.Info) QuantSpec

+ func (q QuantSpec) QuantizeUp(e abi.ChainEpoch) abi.ChainEpoch

type RecoveryDeclaration

+ Partition uint64

type SectorOnChainInfo

+ Activation abi.ChainEpoch

+ DealIDs []abi.DealID

+ ExpectedDayReward abi.TokenAmount

+ ExpectedStoragePledge abi.TokenAmount

+ Expiration abi.ChainEpoch

+ InitialPledge abi.TokenAmount

+ SealProof abi.RegisteredSealProof

+ SealedCID cid.Cid

+ SectorNumber abi.SectorNumber

type SectorPreCommitInfo

+ ReplaceCapacity bool

+ ReplaceSectorDeadline uint64

+ ReplaceSectorNumber abi.SectorNumber

+ ReplaceSectorPartition uint64

type SectorPreCommitOnChainInfo

+ DealWeight abi.DealWeight

+ VerifiedDealWeight abi.DealWeight

+ type Sectors struct

+ func LoadSectors(store adt.Store, root cid.Cid) (Sectors, error)

+ func (sa Sectors) Get(sectorNumber abi.SectorNumber) (info *SectorOnChainInfo, found bool, err error)

+ func (sa Sectors) Load(sectorNos bitfield.BitField) ([]*SectorOnChainInfo, error)

+ func (sa Sectors) MustGet(sectorNumber abi.SectorNumber) (info *SectorOnChainInfo, err error)

+ func (sa Sectors) Store(infos ...*SectorOnChainInfo) error

type State

+ AllocatedSectors cid.Cid

+ CurrentDeadline uint64

+ EarlyTerminations bitfield.BitField

+ InitialPledgeRequirement abi.TokenAmount

+ PreCommittedSectorsExpiry cid.Cid

+ func (st *State) AddInitialPledgeRequirement(amount abi.TokenAmount)

+ func (st *State) AddPreCommitExpiry(store adt.Store, expireEpoch abi.ChainEpoch, sectorNum abi.SectorNumber) error

+ func (st *State) AllocateSectorNumber(store adt.Store, sectorNo abi.SectorNumber) error

+ func (st *State) AssignSectorsToDeadlines(store adt.Store, currentEpoch abi.ChainEpoch, sectors []*SectorOnChainInfo, ...) (PowerPair, error)

+ func (st *State) CheckSectorHealth(store adt.Store, dlIdx, pIdx uint64, sector abi.SectorNumber) error

+ func (st *State) DeletePrecommittedSectors(store adt.Store, sectorNos ...abi.SectorNumber) error

+ func (st *State) FindPrecommittedSectors(store adt.Store, sectorNos ...abi.SectorNumber) ([]*SectorPreCommitOnChainInfo, error)

+ func (st *State) FindSector(store adt.Store, sno abi.SectorNumber) (uint64, uint64, error)

+ func (st *State) GetInfo(store adt.Store) (*MinerInfo, error)

+ func (st *State) GetUnlockedBalance(actorBalance abi.TokenAmount) abi.TokenAmount

+ func (st *State) LoadVestingFunds(store adt.Store) (*VestingFunds, error)

+ func (st *State) MaskSectorNumbers(store adt.Store, sectorNos bitfield.BitField) error

+ func (st *State) MeetsInitialPledgeCondition(balance abi.TokenAmount) bool

+ func (st *State) PenalizeFundsInPriorityOrder(store adt.Store, currEpoch abi.ChainEpoch, ...) (fromVesting abi.TokenAmount, fromBalance abi.TokenAmount, err error)

+ func (st *State) PopEarlyTerminations(store adt.Store, maxPartitions, maxSectors uint64) (result TerminationResult, hasMore bool, err error)

+ func (st *State) PutSectors(store adt.Store, newSectors ...*SectorOnChainInfo) error

+ func (st *State) QuantSpecEveryDeadline() QuantSpec

+ func (st *State) QuantSpecForDeadline(dlIdx uint64) QuantSpec

+ func (st *State) RescheduleSectorExpirations(store adt.Store, currEpoch abi.ChainEpoch, ssize abi.SectorSize, ...) error

+ func (st *State) SaveInfo(store adt.Store, info *MinerInfo) error

+ func (st *State) SaveVestingFunds(store adt.Store, funds *VestingFunds) error

type SubmitWindowedPoStParams

+ ChainCommitEpoch abi.ChainEpoch

+ ChainCommitRand abi.Randomness

type TerminateSectorsParams

+ Terminations []TerminationDeclaration

+ type TerminateSectorsReturn struct

+ Done bool

+ func (t *TerminateSectorsReturn) MarshalCBOR(w io.Writer) error

+ func (t *TerminateSectorsReturn) UnmarshalCBOR(r io.Reader) error

+ type TerminationDeclaration struct

+ Deadline uint64

+ Partition uint64

+ Sectors bitfield.BitField

+ func (t *TerminationDeclaration) MarshalCBOR(w io.Writer) error

+ func (t *TerminationDeclaration) UnmarshalCBOR(r io.Reader) error

+ type TerminationResult struct

+ PartitionsProcessed uint64

+ Sectors map[abi.ChainEpoch]bitfield.BitField

+ SectorsProcessed uint64

+ func (t *TerminationResult) Add(newResult TerminationResult) error

+ func (t *TerminationResult) BelowLimit(maxPartitions, maxSectors uint64) bool

+ func (t *TerminationResult) ForEach(cb func(epoch abi.ChainEpoch, sectors bitfield.BitField) error) error

+ func (t *TerminationResult) IsEmpty() bool

+ type VestingFund struct

+ Amount abi.TokenAmount

+ Epoch abi.ChainEpoch

+ func (t *VestingFund) MarshalCBOR(w io.Writer) error

+ func (t *VestingFund) UnmarshalCBOR(r io.Reader) error

+ type VestingFunds struct

+ Funds []VestingFund

+ func ConstructVestingFunds() *VestingFunds

+ func (t *VestingFunds) MarshalCBOR(w io.Writer) error

+ func (t *VestingFunds) UnmarshalCBOR(r io.Reader) error

v0.6.2

Mar 28, 2021

Changes in this version

+ const ChainFinalityish

+ const ElectionLookback

+ const FaultDeclarationCutoff

+ const FaultMaxAge

+ const NewSectorsPerPeriodMax

+ const PreCommitChallengeDelay

+ const SectorsMax

+ const WPoStChallengeLookback

+ const WPoStChallengeWindow

+ const WPoStPeriodDeadlines

+ const WPoStProvingPeriod

+ const WorkerKeyChangeDelay

+ var MaxSealDuration = map[abi.RegisteredSealProof]abi.ChainEpoch

+ var PledgeVestingSpec = VestSpec

+ var SupportedProofTypes = map[abi.RegisteredSealProof]struct

+ func AsStorageWeightDesc(sectorSize abi.SectorSize, sectorInfo *SectorOnChainInfo) *power.SectorStorageWeightDesc

+ func AssignNewSectors(deadlines *Deadlines, partitionSize uint64, newSectors []uint64, ...) error

+ func ComputePartitionsSectors(d *Deadlines, partitionSize uint64, deadlineIndex uint64, partitions []uint64) ([]*abi.BitField, error)

+ func DeadlineCount(d *Deadlines, partitionSize, deadlineIdx uint64) (partitionCount, sectorCount uint64, err error)

+ func EpochKey(e abi.ChainEpoch) uint64

+ func PartitionsForDeadline(d *Deadlines, partitionSize, deadlineIdx uint64) (firstPartition, sectorCount uint64, _ error)

+ func SectorKey(e abi.SectorNumber) adt.Keyer

+ type Actor struct

+ func (a Actor) AddLockedFund(rt Runtime, amountToLock *abi.TokenAmount) *adt.EmptyValue

+ func (a Actor) ChangeMultiaddrs(rt Runtime, params *ChangeMultiaddrsParams) *adt.EmptyValue

+ func (a Actor) ChangePeerID(rt Runtime, params *ChangePeerIDParams) *adt.EmptyValue

+ func (a Actor) ChangeWorkerAddress(rt Runtime, params *ChangeWorkerAddressParams) *adt.EmptyValue

+ func (a Actor) CheckSectorProven(rt Runtime, params *CheckSectorProvenParams) *adt.EmptyValue

+ func (a Actor) ConfirmSectorProofsValid(rt Runtime, params *builtin.ConfirmSectorProofsParams) *adt.EmptyValue

+ func (a Actor) Constructor(rt Runtime, params *ConstructorParams) *adt.EmptyValue

+ func (a Actor) ControlAddresses(rt Runtime, _ *adt.EmptyValue) *GetControlAddressesReturn

+ func (a Actor) DeclareFaults(rt Runtime, params *DeclareFaultsParams) *adt.EmptyValue

+ func (a Actor) DeclareFaultsRecovered(rt Runtime, params *DeclareFaultsRecoveredParams) *adt.EmptyValue

+ func (a Actor) Exports() []interface{}

+ func (a Actor) ExtendSectorExpiration(rt Runtime, params *ExtendSectorExpirationParams) *adt.EmptyValue

+ func (a Actor) OnDeferredCronEvent(rt Runtime, payload *CronEventPayload) *adt.EmptyValue

+ func (a Actor) PreCommitSector(rt Runtime, params *SectorPreCommitInfo) *adt.EmptyValue

+ func (a Actor) ProveCommitSector(rt Runtime, params *ProveCommitSectorParams) *adt.EmptyValue

+ func (a Actor) ReportConsensusFault(rt Runtime, params *ReportConsensusFaultParams) *adt.EmptyValue

+ func (a Actor) SubmitWindowedPoSt(rt Runtime, params *SubmitWindowedPoStParams) *adt.EmptyValue

+ func (a Actor) TerminateSectors(rt Runtime, params *TerminateSectorsParams) *adt.EmptyValue

+ func (a Actor) WithdrawBalance(rt Runtime, params *WithdrawBalanceParams) *adt.EmptyValue

+ type BigFrac struct

+ type ChangeMultiaddrsParams struct

+ NewMultiaddrs []abi.Multiaddrs

+ func (t *ChangeMultiaddrsParams) MarshalCBOR(w io.Writer) error

+ func (t *ChangeMultiaddrsParams) UnmarshalCBOR(r io.Reader) error

+ type ChangePeerIDParams struct

+ NewID abi.PeerID

+ func (t *ChangePeerIDParams) MarshalCBOR(w io.Writer) error

+ func (t *ChangePeerIDParams) UnmarshalCBOR(r io.Reader) error

+ type ChangeWorkerAddressParams struct

+ NewWorker addr.Address

+ func (t *ChangeWorkerAddressParams) MarshalCBOR(w io.Writer) error

+ func (t *ChangeWorkerAddressParams) UnmarshalCBOR(r io.Reader) error

+ type CheckSectorProvenParams struct

+ SectorNumber abi.SectorNumber

+ func (t *CheckSectorProvenParams) MarshalCBOR(w io.Writer) error

+ func (t *CheckSectorProvenParams) UnmarshalCBOR(r io.Reader) error

+ type ConstructorParams = power.MinerConstructorParams

+ type CronEventPayload struct

+ EventType CronEventType

+ Sectors *abi.BitField

+ func (t *CronEventPayload) MarshalCBOR(w io.Writer) error

+ func (t *CronEventPayload) UnmarshalCBOR(r io.Reader) error

+ type CronEventType int64

+ const CronEventPreCommitExpiry

+ const CronEventProvingPeriod

+ const CronEventWorkerKeyChange

+ type DeadlineInfo struct

+ Challenge abi.ChainEpoch

+ Close abi.ChainEpoch

+ CurrentEpoch abi.ChainEpoch

+ FaultCutoff abi.ChainEpoch

+ Index uint64

+ Open abi.ChainEpoch

+ PeriodStart abi.ChainEpoch

+ func ComputeProvingPeriodDeadline(periodStart, currEpoch abi.ChainEpoch) *DeadlineInfo

+ func NewDeadlineInfo(periodStart abi.ChainEpoch, deadlineIdx uint64, currEpoch abi.ChainEpoch) *DeadlineInfo

+ func (d *DeadlineInfo) FaultCutoffPassed() bool

+ func (d *DeadlineInfo) HasElapsed() bool

+ func (d *DeadlineInfo) IsOpen() bool

+ func (d *DeadlineInfo) NextPeriodStart() abi.ChainEpoch

+ func (d *DeadlineInfo) PeriodElapsed() bool

+ func (d *DeadlineInfo) PeriodEnd() abi.ChainEpoch

+ func (d *DeadlineInfo) PeriodStarted() bool

+ type Deadlines struct

+ Due [WPoStPeriodDeadlines]*abi.BitField

+ func ConstructDeadlines() *Deadlines

+ func (d *Deadlines) AddToDeadline(deadline uint64, newSectors ...uint64) (err error)

+ func (d *Deadlines) RemoveFromAllDeadlines(sectorNos *abi.BitField) (err error)

+ func (t *Deadlines) MarshalCBOR(w io.Writer) error

+ func (t *Deadlines) UnmarshalCBOR(r io.Reader) error

+ type DeclareFaultsParams struct

+ Faults []FaultDeclaration

+ func (t *DeclareFaultsParams) MarshalCBOR(w io.Writer) error

+ func (t *DeclareFaultsParams) UnmarshalCBOR(r io.Reader) error

+ type DeclareFaultsRecoveredParams struct

+ Recoveries []RecoveryDeclaration

+ func (t *DeclareFaultsRecoveredParams) MarshalCBOR(w io.Writer) error

+ func (t *DeclareFaultsRecoveredParams) UnmarshalCBOR(r io.Reader) error

+ type ExtendSectorExpirationParams struct

+ NewExpiration abi.ChainEpoch

+ SectorNumber abi.SectorNumber

+ func (t *ExtendSectorExpirationParams) MarshalCBOR(w io.Writer) error

+ func (t *ExtendSectorExpirationParams) UnmarshalCBOR(r io.Reader) error

+ type FaultDeclaration struct

+ Deadline uint64

+ Sectors *abi.BitField

+ func (t *FaultDeclaration) MarshalCBOR(w io.Writer) error

+ func (t *FaultDeclaration) UnmarshalCBOR(r io.Reader) error

+ type GetControlAddressesReturn struct

+ Owner addr.Address

+ Worker addr.Address

+ func (t *GetControlAddressesReturn) MarshalCBOR(w io.Writer) error

+ func (t *GetControlAddressesReturn) UnmarshalCBOR(r io.Reader) error

+ type MinerInfo struct

+ Multiaddrs []abi.Multiaddrs

+ Owner addr.Address

+ PeerId abi.PeerID

+ PendingWorkerKey *WorkerKeyChange

+ SealProofType abi.RegisteredSealProof

+ SectorSize abi.SectorSize

+ WindowPoStPartitionSectors uint64

+ Worker addr.Address

+ func (t *MinerInfo) MarshalCBOR(w io.Writer) error

+ func (t *MinerInfo) UnmarshalCBOR(r io.Reader) error

+ type ProveCommitSectorParams struct

+ Proof []byte

+ SectorNumber abi.SectorNumber

+ func (t *ProveCommitSectorParams) MarshalCBOR(w io.Writer) error

+ func (t *ProveCommitSectorParams) UnmarshalCBOR(r io.Reader) error

+ type RecoveryDeclaration struct

+ Deadline uint64

+ Sectors *abi.BitField

+ func (t *RecoveryDeclaration) MarshalCBOR(w io.Writer) error

+ func (t *RecoveryDeclaration) UnmarshalCBOR(r io.Reader) error

+ type ReportConsensusFaultParams struct

+ BlockHeader1 []byte

+ BlockHeader2 []byte

+ BlockHeaderExtra []byte

+ func (t *ReportConsensusFaultParams) MarshalCBOR(w io.Writer) error

+ func (t *ReportConsensusFaultParams) UnmarshalCBOR(r io.Reader) error

+ type Runtime = vmr.Runtime

+ type SealVerifyStuff struct

+ DealIDs []abi.DealID

+ InteractiveEpoch abi.ChainEpoch

+ Proof []byte

+ SealRandEpoch abi.ChainEpoch

+ SealedCID cid.Cid

+ type SectorOnChainInfo struct

+ ActivationEpoch abi.ChainEpoch

+ DealWeight abi.DealWeight

+ Info SectorPreCommitInfo

+ VerifiedDealWeight abi.DealWeight

+ func (s *SectorOnChainInfo) AsSectorInfo() abi.SectorInfo

+ func (t *SectorOnChainInfo) MarshalCBOR(w io.Writer) error

+ func (t *SectorOnChainInfo) UnmarshalCBOR(r io.Reader) error

+ type SectorPreCommitInfo struct

+ DealIDs []abi.DealID

+ Expiration abi.ChainEpoch

+ SealProof abi.RegisteredSealProof

+ SealRandEpoch abi.ChainEpoch

+ SealedCID cid.Cid

+ SectorNumber abi.SectorNumber

+ func (t *SectorPreCommitInfo) MarshalCBOR(w io.Writer) error

+ func (t *SectorPreCommitInfo) UnmarshalCBOR(r io.Reader) error

+ type SectorPreCommitOnChainInfo struct

+ Info SectorPreCommitInfo

+ PreCommitDeposit abi.TokenAmount

+ PreCommitEpoch abi.ChainEpoch

+ func (t *SectorPreCommitOnChainInfo) MarshalCBOR(w io.Writer) error

+ func (t *SectorPreCommitOnChainInfo) UnmarshalCBOR(r io.Reader) error

+ type State struct

+ Deadlines cid.Cid

+ FaultEpochs cid.Cid

+ Faults *abi.BitField

+ Info MinerInfo

+ LockedFunds abi.TokenAmount

+ NewSectors *abi.BitField

+ NextDeadlineToProcessFaults uint64

+ PostSubmissions *abi.BitField

+ PreCommitDeposits abi.TokenAmount

+ PreCommittedSectors cid.Cid

+ ProvingPeriodStart abi.ChainEpoch

+ Recoveries *abi.BitField

+ SectorExpirations cid.Cid

+ Sectors cid.Cid

+ VestingFunds cid.Cid

+ func ConstructState(emptyArrayCid, emptyMapCid, emptyDeadlinesCid cid.Cid, ...) (*State, error)

+ func (st *State) AddFaults(store adt.Store, sectorNos *abi.BitField, faultEpoch abi.ChainEpoch) (err error)

+ func (st *State) AddLockedFunds(store adt.Store, currEpoch abi.ChainEpoch, vestingSum abi.TokenAmount, ...) error

+ func (st *State) AddNewSectors(sectorNos ...abi.SectorNumber) (err error)

+ func (st *State) AddPoStSubmissions(partitionNos *abi.BitField) (err error)

+ func (st *State) AddPreCommitDeposit(amount abi.TokenAmount)

+ func (st *State) AddRecoveries(sectorNos *abi.BitField) (err error)

+ func (st *State) AddSectorExpirations(store adt.Store, expiry abi.ChainEpoch, sectors ...uint64) error

+ func (st *State) AssertBalanceInvariants(balance abi.TokenAmount)

+ func (st *State) CheckVestedFunds(store adt.Store, currEpoch abi.ChainEpoch) (abi.TokenAmount, error)

+ func (st *State) ClearFaultEpochs(store adt.Store, epochs ...abi.ChainEpoch) error

+ func (st *State) ClearPoStSubmissions() error

+ func (st *State) ClearSectorExpirations(store adt.Store, expirations ...abi.ChainEpoch) error

+ func (st *State) DeadlineInfo(currEpoch abi.ChainEpoch) *DeadlineInfo

+ func (st *State) DeletePrecommittedSector(store adt.Store, sectorNo abi.SectorNumber) error

+ func (st *State) DeleteSectors(store adt.Store, sectorNos *abi.BitField) error

+ func (st *State) ForEachFaultEpoch(store adt.Store, cb func(epoch abi.ChainEpoch, faults *abi.BitField) error) error

+ func (st *State) ForEachSector(store adt.Store, f func(*SectorOnChainInfo)) error

+ func (st *State) ForEachSectorExpiration(store adt.Store, f func(expiry abi.ChainEpoch, sectors *abi.BitField) error) error

+ func (st *State) GetAvailableBalance(actorBalance abi.TokenAmount) abi.TokenAmount

+ func (st *State) GetMaxAllowedFaults(store adt.Store) (uint64, error)

+ func (st *State) GetPrecommittedSector(store adt.Store, sectorNo abi.SectorNumber) (*SectorPreCommitOnChainInfo, bool, error)

+ func (st *State) GetSector(store adt.Store, sectorNo abi.SectorNumber) (*SectorOnChainInfo, bool, error)

+ func (st *State) GetSectorCount(store adt.Store) (uint64, error)

+ func (st *State) GetSectorExpirations(store adt.Store, expiry abi.ChainEpoch) (*abi.BitField, error)

+ func (st *State) GetSectorSize() abi.SectorSize

+ func (st *State) GetWorker() addr.Address

+ func (st *State) HasSectorNo(store adt.Store, sectorNo abi.SectorNumber) (bool, error)

+ func (st *State) LoadDeadlines(store adt.Store) (*Deadlines, error)

+ func (st *State) LoadSectorInfos(store adt.Store, sectors *abi.BitField) ([]*SectorOnChainInfo, error)

+ func (st *State) LoadSectorInfosForProof(store adt.Store, provenSectors *abi.BitField) (sectorInfos []*SectorOnChainInfo, recoveries *bitfield.BitField, err error)

+ func (st *State) LoadSectorInfosWithFaultMask(store adt.Store, sectors *abi.BitField, faults *abi.BitField, ...) ([]*SectorOnChainInfo, error)

+ func (st *State) PutPrecommittedSector(store adt.Store, info *SectorPreCommitOnChainInfo) error

+ func (st *State) PutSector(store adt.Store, sector *SectorOnChainInfo) error

+ func (st *State) RemoveFaults(store adt.Store, sectorNos *abi.BitField) error

+ func (st *State) RemoveNewSectors(sectorNos *abi.BitField) (err error)

+ func (st *State) RemoveRecoveries(sectorNos *abi.BitField) (err error)

+ func (st *State) RemoveSectorExpirations(store adt.Store, expiry abi.ChainEpoch, sectors ...uint64) error

+ func (st *State) SaveDeadlines(store adt.Store, deadlines *Deadlines) error

+ func (st *State) UnlockUnvestedFunds(store adt.Store, currEpoch abi.ChainEpoch, target abi.TokenAmount) (abi.TokenAmount, error)

+ func (st *State) UnlockVestedFunds(store adt.Store, currEpoch abi.ChainEpoch) (abi.TokenAmount, error)

+ func (t *State) MarshalCBOR(w io.Writer) error

+ func (t *State) UnmarshalCBOR(r io.Reader) error

+ type SubmitWindowedPoStParams struct

+ Deadline uint64

+ Partitions []uint64

+ Proofs []abi.PoStProof

+ Skipped abi.BitField

+ func (t *SubmitWindowedPoStParams) MarshalCBOR(w io.Writer) error

+ func (t *SubmitWindowedPoStParams) UnmarshalCBOR(r io.Reader) error

+ type TerminateSectorsParams struct

+ Sectors *abi.BitField

+ func (t *TerminateSectorsParams) MarshalCBOR(w io.Writer) error

+ func (t *TerminateSectorsParams) UnmarshalCBOR(r io.Reader) error

+ type VestSpec struct

+ InitialDelay abi.ChainEpoch

+ Quantization abi.ChainEpoch

+ StepDuration abi.ChainEpoch

+ VestPeriod abi.ChainEpoch

+ type WithdrawBalanceParams struct

+ AmountRequested abi.TokenAmount

+ func (t *WithdrawBalanceParams) MarshalCBOR(w io.Writer) error

+ func (t *WithdrawBalanceParams) UnmarshalCBOR(r io.Reader) error

+ type WorkerKeyChange struct

+ EffectiveAt abi.ChainEpoch

+ NewWorker addr.Address

+ func (t *WorkerKeyChange) MarshalCBOR(w io.Writer) error

+ func (t *WorkerKeyChange) UnmarshalCBOR(r io.Reader) error

Other modules containing this package

github.com/chenjianmei111/specs-actors/v2

github.com/chenjianmei111/specs-actors/v3

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL