Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

miner

package

Go to main page

Versions in this module

v0

v0.14.0-rc3

Jun 26, 2024

v0.14.0-rc2

Jun 24, 2024

v0.14.0-rc1

Jun 13, 2024

v0.14.0-dev5

May 8, 2024

v0.14.0-dev4

May 8, 2024

v0.14.0-dev3

May 8, 2024

v0.14.0-dev2

May 7, 2024

v0.14.0-dev

May 2, 2024

v0.13.3

Apr 22, 2024

v0.13.2

Apr 22, 2024

v0.13.1

Mar 21, 2024

Changes in this version

+ const AddressedPartitionsMax

+ const AddressedSectorsMax

+ const ChainFinality

+ const DeadlineExpirationAmtBitwidth

+ const DeadlineOptimisticPoStSubmissionsAmtBitwidth

+ const DeadlinePartitionsAmtBitwidth

+ const DeclarationsMax

+ const FaultDeclarationCutoff

+ const MaxAggregateProofSize

+ const MaxAggregatedSectors

+ const MaxPartitionsPerDeadline

+ const MaxSectorExpirationExtension

+ const MinAggregatedSectors

+ const MinSectorExpiration

+ const PartitionEarlyTerminationArrayAmtBitwidth

+ const PartitionExpirationAmtBitwidth

+ const PoStedPartitionsMax

+ const PreCommitSectorBatchMaxSize

+ const PrecommitCleanUpAmtBitwidth

+ const ProveReplicaUpdatesMaxSize

+ const SectorsAmtBitwidth

+ const WPoStChallengeLookback

+ const WPoStPeriodDeadlines

+ const WorkerKeyChangeDelay

+ var BatchBalancer = big.Mul(big.NewInt(5), builtin.OneNanoFIL)

+ var BatchDiscount = builtin.BigFrac

+ var EstimatedSinglePreCommitGasUsage = big.NewInt(16433324)

+ var EstimatedSingleProveCommitGasUsage = big.NewInt(49299973)

+ var FaultMaxAge = WPoStProvingPeriod * 42

+ var InitialPledgeFactor = 20

+ var InitialPledgeLockTarget = builtin.BigFrac

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

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

+ var MaxPreCommitRandomnessLookback = builtin.EpochsInDay + ChainFinality

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

+ var Methods = map[abi.MethodNum]builtin.MethodMeta

+ var PreCommitChallengeDelay = abi.ChainEpoch(150)

+ var PreCommitDepositFactor = 20

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

+ var SealedCIDPrefix = cid.Prefix

+ var WPoStChallengeWindow = abi.ChainEpoch(30 * 60 / builtin.EpochDurationSeconds)

+ var WPoStDisputeWindow = 2 * ChainFinality

+ var WPoStProvingPeriod = abi.ChainEpoch(builtin.EpochsInDay)

+ var WindowPoStProofTypes = map[abi.RegisteredPoStProof]struct

+ func AggregatePreCommitNetworkFee(aggregateSize int, baseFee abi.TokenAmount) abi.TokenAmount

+ func AggregateProveCommitNetworkFee(aggregateSize int, baseFee abi.TokenAmount) abi.TokenAmount

+ func CheckEarlyTerminationQueue(earlyQ util.BitfieldQueue, terminated bitfield.BitField, ...) int

+ func CheckMinerBalances(st *State, store adt.Store, balance abi.TokenAmount, ...)

+ func CheckMinerInfo(info *MinerInfo, acc *builtin.MessageAccumulator)

+ func CheckPreCommits(st *State, store adt.Store, allocatedSectorsMap map[uint64]bool, ...)

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

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

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

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

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

+ 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 QAPowerMax(size abi.SectorSize) abi.StoragePower

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

+ func QuantSpecForDeadline(di *dline.Info) builtin.QuantSpec

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

+ type ActiveBeneficiary struct

+ Beneficiary addr.Address

+ Term BeneficiaryTerm

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

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

+ type ApplyRewardParams struct

+ Penalty abi.TokenAmount

+ Reward abi.TokenAmount

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

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

+ type BatchReturn struct

+ FailCodes []FailCode

+ SuccessCount uint64

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

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

+ type BeneficiaryTerm struct

+ Expiration abi.ChainEpoch

+ Quota abi.TokenAmount

+ UsedQuota abi.TokenAmount

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

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

+ type ChangeBeneficiaryParams struct

+ NewBeneficiary addr.Address

+ NewExpiration abi.ChainEpoch

+ NewQuota abi.TokenAmount

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

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

+ type ChangeMultiaddrsParams struct

+ NewMultiaddrs []abi.Multiaddrs

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

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

+ type ChangePeerIDParams struct

+ NewID abi.PeerID

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

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

+ type ChangeWorkerAddressParams struct

+ NewControlAddrs []addr.Address

+ NewWorker addr.Address

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

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

+ type CheckSectorProvenParams struct

+ SectorNumber abi.SectorNumber

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

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

+ type CompactPartitionsParams struct

+ Deadline uint64

+ Partitions bitfield.BitField

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

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

+ type CompactSectorNumbersParams struct

+ MaskSectorNumbers bitfield.BitField

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

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

+ type ConfirmSectorProofsParams struct

+ QualityAdjPowerSmoothed smoothing.FilterEstimate

+ RewardBaselinePower abi.StoragePower

+ RewardSmoothed smoothing.FilterEstimate

+ Sectors []abi.SectorNumber

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

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

+ type CronEventPayload struct

+ EventType CronEventType

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

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

+ type CronEventType int64

+ const CronEventProcessEarlyTerminations

+ const CronEventProvingDeadline

+ const CronEventWorkerKeyChange

+ type DataActivationNotification struct

+ Address addr.Address

+ Payload []byte

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

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

+ type Deadline struct

+ EarlyTerminations bitfield.BitField

+ ExpirationsEpochs cid.Cid

+ FaultyPower PowerPair

+ LiveSectors uint64

+ OptimisticPoStSubmissions cid.Cid

+ OptimisticPoStSubmissionsSnapshot cid.Cid

+ Partitions cid.Cid

+ PartitionsPoSted bitfield.BitField

+ PartitionsSnapshot cid.Cid

+ SectorsSnapshot cid.Cid

+ TotalSectors uint64

+ func ConstructDeadline(store adt.Store) (*Deadline, error)

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

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

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

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

+ func (d *Deadline) ValidateState() error

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

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

+ type DeadlineStateSummary struct

+ ActivePower PowerPair

+ AllSectors bitfield.BitField

+ FaultyPower PowerPair

+ FaultySectors bitfield.BitField

+ LivePower PowerPair

+ LiveSectors bitfield.BitField

+ RecoveringSectors bitfield.BitField

+ TerminatedSectors bitfield.BitField

+ UnprovenSectors bitfield.BitField

+ func CheckDeadlineStateInvariants(deadline *Deadline, store adt.Store, quant builtin.QuantSpec, ...) *DeadlineStateSummary

+ type Deadlines struct

+ Due [WPoStPeriodDeadlines]cid.Cid

+ func ConstructDeadlines(emptyDeadlineCid cid.Cid) *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

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

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

+ type DealSummary struct

+ SectorExpiration abi.ChainEpoch

+ SectorNumber abi.SectorNumber

+ SectorStart abi.ChainEpoch

+ type DeclareFaultsParams struct

+ Faults []FaultDeclaration

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

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

+ type DeclareFaultsRecoveredParams struct

+ Recoveries []RecoveryDeclaration

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

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

+ type DeferredCronEventParams struct

+ EventPayload []byte

+ QualityAdjPowerSmoothed smoothing.FilterEstimate

+ RewardSmoothed smoothing.FilterEstimate

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

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

+ type DisputeWindowedPoStParams struct

+ Deadline uint64

+ PoStIndex uint64

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

+ func (t *DisputeWindowedPoStParams) UnmarshalCBOR(r io.Reader) (err 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) (err error)

+ type ExpirationExtension2 struct

+ Deadline uint64

+ NewExpiration abi.ChainEpoch

+ Partition uint64

+ Sectors bitfield.BitField

+ SectorsWithClaims []SectorClaim

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

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

+ type ExpirationQueue struct

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

+ type ExpirationQueueStateSummary struct

+ ActivePower PowerPair

+ EarlySectors bitfield.BitField

+ ExpirationEpochs []abi.ChainEpoch

+ FaultyPower PowerPair

+ OnTimePledge abi.TokenAmount

+ OnTimeSectors bitfield.BitField

+ func CheckExpirationQueue(expQ ExpirationQueue, liveSectors map[abi.SectorNumber]*SectorOnChainInfo, ...) *ExpirationQueueStateSummary

+ type ExpirationSet struct

+ ActivePower PowerPair

+ EarlySectors bitfield.BitField

+ FaultyPower PowerPair

+ OnTimePledge abi.TokenAmount

+ OnTimeSectors bitfield.BitField

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

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

+ type ExtendSectorExpiration2Params struct

+ Extensions []ExpirationExtension2

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

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

+ type ExtendSectorExpirationParams struct

+ Extensions []ExpirationExtension

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

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

+ type FailCode struct

+ Code xc.ExitCode

+ Idx uint64

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

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

+ type FaultDeclaration struct

+ Deadline uint64

+ Partition uint64

+ Sectors bitfield.BitField

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

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

+ type GetAvailableBalanceReturn = abi.TokenAmount

+ type GetBeneficiaryReturn struct

+ Active ActiveBeneficiary

+ Proposed *PendingBeneficiaryChange

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

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

+ type GetControlAddressesReturn struct

+ ControlAddrs []addr.Address

+ Owner addr.Address

+ Worker addr.Address

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

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

+ type GetMultiAddrsReturn struct

+ MultiAddrs []byte

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

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

+ type GetOwnerReturn struct

+ Owner addr.Address

+ Proposed *addr.Address

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

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

+ type GetPeerIDReturn struct

+ PeerId []byte

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

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

+ type GetSectorSizeReturn = abi.SectorSize

+ type GetVestingFundsReturn = VestingFunds

+ type IsControllingAddressParams = addr.Address

+ type IsControllingAddressReturn = cbg.CborBool

+ type MinerConstructorParams = power.MinerConstructorParams

+ type MinerInfo struct

+ Beneficiary addr.Address

+ BeneficiaryTerm BeneficiaryTerm

+ ConsensusFaultElapsed abi.ChainEpoch

+ ControlAddresses []addr.Address

+ Multiaddrs []abi.Multiaddrs

+ Owner addr.Address

+ PeerId abi.PeerID

+ PendingBeneficiaryTerm *PendingBeneficiaryChange

+ PendingOwnerAddress *addr.Address

+ PendingWorkerKey *WorkerKeyChange

+ SectorSize abi.SectorSize

+ WindowPoStPartitionSectors uint64

+ WindowPoStProofType abi.RegisteredPoStProof

+ Worker addr.Address

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

+ func (t *MinerInfo) UnmarshalCBOR(r io.Reader) (err 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

+ Unproven bitfield.BitField

+ UnprovenPower PowerPair

+ func (p *Partition) ActivateUnproven() PowerPair

+ func (p *Partition) ActivePower() PowerPair

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

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

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

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

+ type PartitionKey struct

+ Deadline uint64

+ Partition uint64

+ type PartitionStateSummary struct

+ ActivePower PowerPair

+ AllSectors bitfield.BitField

+ EarlyTerminationCount int

+ ExpirationEpochs []abi.ChainEpoch

+ FaultyPower PowerPair

+ FaultySectors bitfield.BitField

+ LivePower PowerPair

+ LiveSectors bitfield.BitField

+ RecoveringPower PowerPair

+ RecoveringSectors bitfield.BitField

+ TerminatedSectors bitfield.BitField

+ UnprovenSectors bitfield.BitField

+ func CheckPartitionStateInvariants(partition *Partition, store adt.Store, quant builtin.QuantSpec, ...) *PartitionStateSummary

+ type PendingBeneficiaryChange struct

+ ApprovedByBeneficiary bool

+ ApprovedByNominee bool

+ NewBeneficiary addr.Address

+ NewExpiration abi.ChainEpoch

+ NewQuota abi.TokenAmount

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

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

+ type PieceActivationManifest struct

+ CID cid.Cid

+ Notify []DataActivationNotification

+ Size abi.PaddedPieceSize

+ VerifiedAllocationKey *VerifiedAllocationKey

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

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

+ type PieceChange struct

+ Data cid.Cid

+ Payload []byte

+ Size abi.PaddedPieceSize

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

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

+ type PieceReturn = bool

+ type PoStPartition struct

+ Index uint64

+ Skipped bitfield.BitField

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

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

+ type PowerPair struct

+ QA abi.StoragePower

+ Raw abi.StoragePower

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

+ func NewPowerPairZero() PowerPair

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

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

+ func (pp PowerPair) IsZero() bool

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

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

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

+ type PreCommitSectorBatchParams struct

+ Sectors []PreCommitSectorParams

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

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

+ type PreCommitSectorBatchParams2 struct

+ Sectors []SectorPreCommitInfo

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

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

+ type PreCommitSectorParams struct

+ DealIDs []abi.DealID

+ Expiration abi.ChainEpoch

+ ReplaceCapacity bool

+ ReplaceSectorDeadline uint64

+ ReplaceSectorNumber abi.SectorNumber

+ ReplaceSectorPartition uint64

+ SealProof abi.RegisteredSealProof

+ SealRandEpoch abi.ChainEpoch

+ SealedCID cid.Cid

+ SectorNumber abi.SectorNumber

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

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

+ type ProveCommitAggregateParams struct

+ AggregateProof []byte

+ SectorNumbers bitfield.BitField

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

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

+ type ProveCommitSectorParams struct

+ Proof []byte

+ SectorNumber abi.SectorNumber

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

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

+ type ProveCommitSectors3Params struct

+ AggregateProof []byte

+ AggregateProofType *abi.RegisteredAggregationProof

+ RequireActivationSuccess bool

+ RequireNotificationSuccess bool

+ SectorActivations []SectorActivationManifest

+ SectorProofs [][]byte

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

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

+ type ProveCommitSectors3Return = BatchReturn

+ type ProveReplicaUpdates3Params struct

+ AggregateProof []byte

+ AggregateProofType *abi.RegisteredAggregationProof

+ RequireActivationSuccess bool

+ RequireNotificationSuccess bool

+ SectorProofs [][]byte

+ SectorUpdates []SectorUpdateManifest

+ UpdateProofsType abi.RegisteredUpdateProof

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

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

+ type ProveReplicaUpdates3Return = BatchReturn

+ type ProveReplicaUpdatesParams struct

+ Updates []ReplicaUpdate

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

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

+ type ProveReplicaUpdatesParams2 struct

+ Updates []ReplicaUpdate2

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

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

+ type RecoveryDeclaration struct

+ Deadline uint64

+ Partition uint64

+ Sectors bitfield.BitField

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

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

+ type ReplicaUpdate struct

+ Deadline uint64

+ Deals []abi.DealID

+ NewSealedSectorCID cid.Cid

+ Partition uint64

+ ReplicaProof []byte

+ SectorID abi.SectorNumber

+ UpdateProofType abi.RegisteredUpdateProof

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

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

+ type ReplicaUpdate2 struct

+ Deadline uint64

+ Deals []abi.DealID

+ NewSealedSectorCID cid.Cid

+ NewUnsealedSectorCID cid.Cid

+ Partition uint64

+ ReplicaProof []byte

+ SectorID abi.SectorNumber

+ UpdateProofType abi.RegisteredUpdateProof

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

+ func (t *ReplicaUpdate2) UnmarshalCBOR(r io.Reader) (err 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) (err error)

+ type SectorActivationManifest struct

+ Pieces []PieceActivationManifest

+ SectorNumber abi.SectorNumber

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

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

+ type SectorChanges struct

+ Added []PieceChange

+ MinimumCommitmentEpoch abi.ChainEpoch

+ Sector abi.SectorNumber

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

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

+ type SectorClaim struct

+ DropClaims []verifreg.ClaimId

+ MaintainClaims []verifreg.ClaimId

+ SectorNumber abi.SectorNumber

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

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

+ type SectorContentChangedParams = []SectorChanges

+ type SectorContentChangedReturn = []SectorReturn

+ type SectorOnChainInfo struct

+ Activation abi.ChainEpoch

+ DealIDs []abi.DealID

+ DealWeight abi.DealWeight

+ ExpectedDayReward abi.TokenAmount

+ ExpectedStoragePledge abi.TokenAmount

+ Expiration abi.ChainEpoch

+ Flags SectorOnChainInfoFlags

+ InitialPledge abi.TokenAmount

+ PowerBaseEpoch abi.ChainEpoch

+ ReplacedDayReward abi.TokenAmount

+ SealProof abi.RegisteredSealProof

+ SealedCID cid.Cid

+ SectorKeyCID *cid.Cid

+ SectorNumber abi.SectorNumber

+ VerifiedDealWeight abi.DealWeight

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

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

+ type SectorOnChainInfoFlags uint64

+ const SIMPLE_QA_POWER

+ type SectorPreCommitInfo struct

+ DealIDs []abi.DealID

+ Expiration abi.ChainEpoch

+ SealProof abi.RegisteredSealProof

+ SealRandEpoch abi.ChainEpoch

+ SealedCID cid.Cid

+ SectorNumber abi.SectorNumber

+ UnsealedCid *cid.Cid

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

+ func (t *SectorPreCommitInfo) UnmarshalCBOR(r io.Reader) (err 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) (err error)

+ type SectorReturn = []PieceReturn

+ type SectorUpdateManifest struct

+ Deadline uint64

+ NewSealedCID cid.Cid

+ Partition uint64

+ Pieces []PieceActivationManifest

+ Sector abi.SectorNumber

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

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

+ 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)

+ type State struct

+ AllocatedSectors cid.Cid

+ CurrentDeadline uint64

+ DeadlineCronActive bool

+ Deadlines cid.Cid

+ EarlyTerminations bitfield.BitField

+ FeeDebt abi.TokenAmount

+ Info cid.Cid

+ InitialPledge abi.TokenAmount

+ LockedFunds abi.TokenAmount

+ PreCommitDeposits abi.TokenAmount

+ PreCommittedSectors cid.Cid

+ PreCommittedSectorsCleanUp cid.Cid

+ ProvingPeriodStart abi.ChainEpoch

+ Sectors cid.Cid

+ VestingFunds cid.Cid

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

+ func (st *State) ContinueDeadlineCron() bool

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

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

+ func (st *State) GetInfo(store adt.Store) (*MinerInfo, 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) GetUnlockedBalance(actorBalance abi.TokenAmount) (abi.TokenAmount, error)

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

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

+ func (st *State) QuantSpecEveryDeadline() builtin.QuantSpec

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

+ func (st *State) RecordedDeadlineInfo(currEpoch abi.ChainEpoch) *dline.Info

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

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

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

+ type StateSummary struct

+ ActivePower PowerPair

+ DeadlineCronActive bool

+ Deals map[abi.DealID]DealSummary

+ FaultyPower PowerPair

+ LivePower PowerPair

+ WindowPoStProofType abi.RegisteredPoStProof

+ func CheckStateInvariants(st *State, store adt.Store, balance abi.TokenAmount) (*StateSummary, *builtin.MessageAccumulator)

+ type SubmitWindowedPoStParams struct

+ ChainCommitEpoch abi.ChainEpoch

+ ChainCommitRand abi.Randomness

+ Deadline uint64

+ Partitions []PoStPartition

+ Proofs []proof.PoStProof

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

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

+ type TerminateSectorsParams struct

+ Terminations []TerminationDeclaration

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

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

+ type TerminateSectorsReturn struct

+ Done bool

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

+ func (t *TerminateSectorsReturn) UnmarshalCBOR(r io.Reader) (err 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) (err error)

+ type VerifiedAllocationKey struct

+ Client abi.ActorID

+ ID verifreg.AllocationId

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

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

+ type VestSpec struct

+ InitialDelay abi.ChainEpoch

+ Quantization abi.ChainEpoch

+ StepDuration abi.ChainEpoch

+ VestPeriod abi.ChainEpoch

+ type VestingFund struct

+ Amount abi.TokenAmount

+ Epoch abi.ChainEpoch

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

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

+ type VestingFunds struct

+ Funds []VestingFund

+ func ConstructVestingFunds() *VestingFunds

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

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

+ type WindowedPoSt struct

+ Partitions bitfield.BitField

+ Proofs []proof.PoStProof

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

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

+ type WithdrawBalanceParams struct

+ AmountRequested abi.TokenAmount

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

+ func (t *WithdrawBalanceParams) UnmarshalCBOR(r io.Reader) (err 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) (err error)

v0.13.0-rc.4

Mar 21, 2024

v0.13.0-rc.3

Mar 15, 2024

v0.13.0-rc.2

Feb 29, 2024

v0.13.0-rc.1

Feb 28, 2024