miner

type Deadline interface {
	LoadPartition(idx uint64) (Partition, error)
	ForEachPartition(cb func(idx uint64, part Partition) error) error
	PartitionsPoSted() (bitfield.BitField, error)

	PartitionsChanged(Deadline) (bool, error)
	DisputableProofCount() (uint64, error)
}

type DeadlineDiff map[uint64]*PartitionDiff

type DeadlinesDiff map[uint64]DeadlineDiff

type DeclareFaultsParams = miner3.DeclareFaultsParams

type DeclareFaultsRecoveredParams = miner3.DeclareFaultsRecoveredParams

type DisputeWindowedPoStParams = miner3.DisputeWindowedPoStParams

type FaultDeclaration = miner3.FaultDeclaration

type Funds struct {
	MiningPledge       abi.TokenAmount
	MiningPledgors     map[string]abi.TokenAmount
	MiningPledgeLocked map[string]PledgeLocked
	FeeDebt            abi.TokenAmount
	ReporterDebts      map[string]abi.TokenAmount
}

type MinerInfo struct {
	Owner                      address.Address   // Must be an ID-address.
	Worker                     address.Address   // Must be an ID-address.
	NewWorker                  address.Address   // Must be an ID-address.
	ControlAddresses           []address.Address // Must be an ID-addresses.
	Coinbase                   address.Address   // Must be an ID-address.
	WorkerChangeEpoch          abi.ChainEpoch
	PeerId                     *peer.ID
	Multiaddrs                 []abi.Multiaddrs
	WindowPoStProofType        abi.RegisteredPoStProof
	SectorSize                 abi.SectorSize
	WindowPoStPartitionSectors uint64
	ConsensusFaultElapsed      abi.ChainEpoch
	RetrievalPledger           address.Address
	TotalMined                 abi.TokenAmount
}

type Partition interface {
	AllSectors() (bitfield.BitField, error)
	FaultySectors() (bitfield.BitField, error)
	RecoveringSectors() (bitfield.BitField, error)
	LiveSectors() (bitfield.BitField, error)
	ActiveSectors() (bitfield.BitField, error)
}

type PartitionDiff struct {
	Removed    bitfield.BitField
	Recovered  bitfield.BitField
	Faulted    bitfield.BitField
	Recovering bitfield.BitField
}

type PledgeLocked = miner3.PledgeLocked

type PoStPartition = miner3.PoStPartition

type PreCommitChanges struct {
	Added   []SectorPreCommitOnChainInfo
	Removed []SectorPreCommitOnChainInfo
}

type ProveCommitSectorParams = miner3.ProveCommitSectorParams

type RecoveryDeclaration = miner3.RecoveryDeclaration

type SectorChanges struct {
	Added   []SectorOnChainInfo
	Removed []SectorOnChainInfo
}

type SectorExpiration struct {
	OnTime abi.ChainEpoch

	// non-zero if sector is faulty, epoch at which it will be permanently
	// removed if it doesn't recover
	Early abi.ChainEpoch
}

type SectorLocation struct {
	Deadline  uint64
	Partition uint64
}

type SectorOnChainInfo struct {
	SectorNumber abi.SectorNumber
	SealProof    abi.RegisteredSealProof
	SealedCID    cid.Cid
	DealIDs      []abi.DealID
	Activation   abi.ChainEpoch
	PieceSizes   []abi.PaddedPieceSize
	DealWins     []builtin3.BoolValue
}

type SectorPreCommitInfo = miner3.SectorPreCommitInfo

type SectorPreCommitOnChainInfo struct {
	Info           SectorPreCommitInfo
	PreCommitEpoch abi.ChainEpoch
	PieceSizes     []abi.PaddedPieceSize
}

type State interface {
	cbor.Marshaler

	Funds() (Funds, error)

	GetSector(abi.SectorNumber) (*SectorOnChainInfo, error)
	FindSector(abi.SectorNumber) (*SectorLocation, error)
	GetSectorExpiration(abi.SectorNumber) (*SectorExpiration, error)
	GetPrecommittedSector(abi.SectorNumber) (*SectorPreCommitOnChainInfo, error)
	LoadSectors(sectorNos *bitfield.BitField) ([]*SectorOnChainInfo, error)
	NumLiveSectors() (uint64, error)
	IsAllocated(abi.SectorNumber) (bool, error)

	LoadDeadline(idx uint64) (Deadline, error)
	ForEachDeadline(cb func(idx uint64, dl Deadline) error) error
	NumDeadlines() (uint64, error)
	DeadlinesChanged(State) (bool, error)

	Info() (MinerInfo, error)
	MinerInfoChanged(State) (bool, error)

	DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error)

	ContainsAnyPiece([]cid.Cid) (bool, error)
	// contains filtered or unexported methods
}

type SubmitWindowedPoStParams = miner3.SubmitWindowedPoStParams