571 lines
14 KiB
Go
571 lines
14 KiB
Go
|
package miner
|
||
|
|
|
||
|
|
import (
|
||
|
|
"bytes"
|
||
|
|
"errors"
|
||
|
|
|
||
|
|
"github.com/filecoin-project/go-address"
|
||
|
|
"github.com/filecoin-project/go-bitfield"
|
||
|
|
rle "github.com/filecoin-project/go-bitfield/rle"
|
||
|
|
"github.com/filecoin-project/go-state-types/abi"
|
||
|
|
"github.com/filecoin-project/go-state-types/dline"
|
||
|
|
"github.com/ipfs/go-cid"
|
||
|
|
"github.com/libp2p/go-libp2p-core/peer"
|
||
|
|
cbg "github.com/whyrusleeping/cbor-gen"
|
||
|
|
"golang.org/x/xerrors"
|
||
|
|
|
||
|
|
"github.com/filecoin-project/lotus/chain/actors/adt"
|
||
|
|
|
||
|
|
builtin6 "github.com/filecoin-project/specs-actors/v6/actors/builtin"
|
||
|
|
|
||
|
|
miner6 "github.com/filecoin-project/specs-actors/v6/actors/builtin/miner"
|
||
|
|
adt6 "github.com/filecoin-project/specs-actors/v6/actors/util/adt"
|
||
|
|
)
|
||
|
|
|
||
|
|
var _ State = (*state6)(nil)
|
||
|
|
|
||
|
|
func load6(store adt.Store, root cid.Cid) (State, error) {
|
||
|
|
out := state6{store: store}
|
||
|
|
err := store.Get(store.Context(), root, &out)
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
return &out, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func make6(store adt.Store) (State, error) {
|
||
|
|
out := state6{store: store}
|
||
|
|
out.State = miner6.State{}
|
||
|
|
return &out, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
type state6 struct {
|
||
|
|
miner6.State
|
||
|
|
store adt.Store
|
||
|
|
}
|
||
|
|
|
||
|
|
type deadline6 struct {
|
||
|
|
miner6.Deadline
|
||
|
|
store adt.Store
|
||
|
|
}
|
||
|
|
|
||
|
|
type partition6 struct {
|
||
|
|
miner6.Partition
|
||
|
|
store adt.Store
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmount, err error) {
|
||
|
|
defer func() {
|
||
|
|
if r := recover(); r != nil {
|
||
|
|
err = xerrors.Errorf("failed to get available balance: %w", r)
|
||
|
|
available = abi.NewTokenAmount(0)
|
||
|
|
}
|
||
|
|
}()
|
||
|
|
// this panics if the miner doesnt have enough funds to cover their locked pledge
|
||
|
|
available, err = s.GetAvailableBalance(bal)
|
||
|
|
return available, err
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) VestedFunds(epoch abi.ChainEpoch) (abi.TokenAmount, error) {
|
||
|
|
return s.CheckVestedFunds(s.store, epoch)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) LockedFunds() (LockedFunds, error) {
|
||
|
|
return LockedFunds{
|
||
|
|
VestingFunds: s.State.LockedFunds,
|
||
|
|
InitialPledgeRequirement: s.State.InitialPledge,
|
||
|
|
PreCommitDeposits: s.State.PreCommitDeposits,
|
||
|
|
}, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) FeeDebt() (abi.TokenAmount, error) {
|
||
|
|
return s.State.FeeDebt, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) InitialPledge() (abi.TokenAmount, error) {
|
||
|
|
return s.State.InitialPledge, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) PreCommitDeposits() (abi.TokenAmount, error) {
|
||
|
|
return s.State.PreCommitDeposits, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) GetSector(num abi.SectorNumber) (*SectorOnChainInfo, error) {
|
||
|
|
info, ok, err := s.State.GetSector(s.store, num)
|
||
|
|
if !ok || err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
ret := fromV6SectorOnChainInfo(*info)
|
||
|
|
return &ret, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) FindSector(num abi.SectorNumber) (*SectorLocation, error) {
|
||
|
|
dlIdx, partIdx, err := s.State.FindSector(s.store, num)
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
return &SectorLocation{
|
||
|
|
Deadline: dlIdx,
|
||
|
|
Partition: partIdx,
|
||
|
|
}, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) NumLiveSectors() (uint64, error) {
|
||
|
|
dls, err := s.State.LoadDeadlines(s.store)
|
||
|
|
if err != nil {
|
||
|
|
return 0, err
|
||
|
|
}
|
||
|
|
var total uint64
|
||
|
|
if err := dls.ForEach(s.store, func(dlIdx uint64, dl *miner6.Deadline) error {
|
||
|
|
total += dl.LiveSectors
|
||
|
|
return nil
|
||
|
|
}); err != nil {
|
||
|
|
return 0, err
|
||
|
|
}
|
||
|
|
return total, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// GetSectorExpiration returns the effective expiration of the given sector.
|
||
|
|
//
|
||
|
|
// If the sector does not expire early, the Early expiration field is 0.
|
||
|
|
func (s *state6) GetSectorExpiration(num abi.SectorNumber) (*SectorExpiration, error) {
|
||
|
|
dls, err := s.State.LoadDeadlines(s.store)
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
// NOTE: this can be optimized significantly.
|
||
|
|
// 1. If the sector is non-faulty, it will either expire on-time (can be
|
||
|
|
// learned from the sector info), or in the next quantized expiration
|
||
|
|
// epoch (i.e., the first element in the partition's expiration queue.
|
||
|
|
// 2. If it's faulty, it will expire early within the first 14 entries
|
||
|
|
// of the expiration queue.
|
||
|
|
stopErr := errors.New("stop")
|
||
|
|
out := SectorExpiration{}
|
||
|
|
err = dls.ForEach(s.store, func(dlIdx uint64, dl *miner6.Deadline) error {
|
||
|
|
partitions, err := dl.PartitionsArray(s.store)
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
quant := s.State.QuantSpecForDeadline(dlIdx)
|
||
|
|
var part miner6.Partition
|
||
|
|
return partitions.ForEach(&part, func(partIdx int64) error {
|
||
|
|
if found, err := part.Sectors.IsSet(uint64(num)); err != nil {
|
||
|
|
return err
|
||
|
|
} else if !found {
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
if found, err := part.Terminated.IsSet(uint64(num)); err != nil {
|
||
|
|
return err
|
||
|
|
} else if found {
|
||
|
|
// already terminated
|
||
|
|
return stopErr
|
||
|
|
}
|
||
|
|
|
||
|
|
q, err := miner6.LoadExpirationQueue(s.store, part.ExpirationsEpochs, quant, miner6.PartitionExpirationAmtBitwidth)
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
var exp miner6.ExpirationSet
|
||
|
|
return q.ForEach(&exp, func(epoch int64) error {
|
||
|
|
if early, err := exp.EarlySectors.IsSet(uint64(num)); err != nil {
|
||
|
|
return err
|
||
|
|
} else if early {
|
||
|
|
out.Early = abi.ChainEpoch(epoch)
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
if onTime, err := exp.OnTimeSectors.IsSet(uint64(num)); err != nil {
|
||
|
|
return err
|
||
|
|
} else if onTime {
|
||
|
|
out.OnTime = abi.ChainEpoch(epoch)
|
||
|
|
return stopErr
|
||
|
|
}
|
||
|
|
return nil
|
||
|
|
})
|
||
|
|
})
|
||
|
|
})
|
||
|
|
if err == stopErr {
|
||
|
|
err = nil
|
||
|
|
}
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
if out.Early == 0 && out.OnTime == 0 {
|
||
|
|
return nil, xerrors.Errorf("failed to find sector %d", num)
|
||
|
|
}
|
||
|
|
return &out, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) GetPrecommittedSector(num abi.SectorNumber) (*SectorPreCommitOnChainInfo, error) {
|
||
|
|
info, ok, err := s.State.GetPrecommittedSector(s.store, num)
|
||
|
|
if !ok || err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
ret := fromV6SectorPreCommitOnChainInfo(*info)
|
||
|
|
|
||
|
|
return &ret, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) ForEachPrecommittedSector(cb func(SectorPreCommitOnChainInfo) error) error {
|
||
|
|
precommitted, err := adt6.AsMap(s.store, s.State.PreCommittedSectors, builtin6.DefaultHamtBitwidth)
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
|
||
|
|
var info miner6.SectorPreCommitOnChainInfo
|
||
|
|
if err := precommitted.ForEach(&info, func(_ string) error {
|
||
|
|
return cb(fromV6SectorPreCommitOnChainInfo(info))
|
||
|
|
}); err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) LoadSectors(snos *bitfield.BitField) ([]*SectorOnChainInfo, error) {
|
||
|
|
sectors, err := miner6.LoadSectors(s.store, s.State.Sectors)
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
// If no sector numbers are specified, load all.
|
||
|
|
if snos == nil {
|
||
|
|
infos := make([]*SectorOnChainInfo, 0, sectors.Length())
|
||
|
|
var info6 miner6.SectorOnChainInfo
|
||
|
|
if err := sectors.ForEach(&info6, func(_ int64) error {
|
||
|
|
info := fromV6SectorOnChainInfo(info6)
|
||
|
|
infos = append(infos, &info)
|
||
|
|
return nil
|
||
|
|
}); err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
return infos, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// Otherwise, load selected.
|
||
|
|
infos6, err := sectors.Load(*snos)
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
infos := make([]*SectorOnChainInfo, len(infos6))
|
||
|
|
for i, info6 := range infos6 {
|
||
|
|
info := fromV6SectorOnChainInfo(*info6)
|
||
|
|
infos[i] = &info
|
||
|
|
}
|
||
|
|
return infos, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) loadAllocatedSectorNumbers() (bitfield.BitField, error) {
|
||
|
|
var allocatedSectors bitfield.BitField
|
||
|
|
err := s.store.Get(s.store.Context(), s.State.AllocatedSectors, &allocatedSectors)
|
||
|
|
return allocatedSectors, err
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) IsAllocated(num abi.SectorNumber) (bool, error) {
|
||
|
|
allocatedSectors, err := s.loadAllocatedSectorNumbers()
|
||
|
|
if err != nil {
|
||
|
|
return false, err
|
||
|
|
}
|
||
|
|
|
||
|
|
return allocatedSectors.IsSet(uint64(num))
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) GetProvingPeriodStart() (abi.ChainEpoch, error) {
|
||
|
|
return s.State.ProvingPeriodStart, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) UnallocatedSectorNumbers(count int) ([]abi.SectorNumber, error) {
|
||
|
|
allocatedSectors, err := s.loadAllocatedSectorNumbers()
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
allocatedRuns, err := allocatedSectors.RunIterator()
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
unallocatedRuns, err := rle.Subtract(
|
||
|
|
&rle.RunSliceIterator{Runs: []rle.Run{{Val: true, Len: abi.MaxSectorNumber}}},
|
||
|
|
allocatedRuns,
|
||
|
|
)
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
iter, err := rle.BitsFromRuns(unallocatedRuns)
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
sectors := make([]abi.SectorNumber, 0, count)
|
||
|
|
for iter.HasNext() && len(sectors) < count {
|
||
|
|
nextNo, err := iter.Next()
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
sectors = append(sectors, abi.SectorNumber(nextNo))
|
||
|
|
}
|
||
|
|
|
||
|
|
return sectors, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) GetAllocatedSectors() (*bitfield.BitField, error) {
|
||
|
|
var allocatedSectors bitfield.BitField
|
||
|
|
if err := s.store.Get(s.store.Context(), s.State.AllocatedSectors, &allocatedSectors); err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
return &allocatedSectors, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) LoadDeadline(idx uint64) (Deadline, error) {
|
||
|
|
dls, err := s.State.LoadDeadlines(s.store)
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
dl, err := dls.LoadDeadline(s.store, idx)
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
return &deadline6{*dl, s.store}, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) ForEachDeadline(cb func(uint64, Deadline) error) error {
|
||
|
|
dls, err := s.State.LoadDeadlines(s.store)
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
return dls.ForEach(s.store, func(i uint64, dl *miner6.Deadline) error {
|
||
|
|
return cb(i, &deadline6{*dl, s.store})
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) NumDeadlines() (uint64, error) {
|
||
|
|
return miner6.WPoStPeriodDeadlines, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) DeadlinesChanged(other State) (bool, error) {
|
||
|
|
other6, ok := other.(*state6)
|
||
|
|
if !ok {
|
||
|
|
// treat an upgrade as a change, always
|
||
|
|
return true, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
return !s.State.Deadlines.Equals(other6.Deadlines), nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) MinerInfoChanged(other State) (bool, error) {
|
||
|
|
other0, ok := other.(*state6)
|
||
|
|
if !ok {
|
||
|
|
// treat an upgrade as a change, always
|
||
|
|
return true, nil
|
||
|
|
}
|
||
|
|
return !s.State.Info.Equals(other0.State.Info), nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) Info() (MinerInfo, error) {
|
||
|
|
info, err := s.State.GetInfo(s.store)
|
||
|
|
if err != nil {
|
||
|
|
return MinerInfo{}, err
|
||
|
|
}
|
||
|
|
|
||
|
|
var pid *peer.ID
|
||
|
|
if peerID, err := peer.IDFromBytes(info.PeerId); err == nil {
|
||
|
|
pid = &peerID
|
||
|
|
}
|
||
|
|
|
||
|
|
mi := MinerInfo{
|
||
|
|
Owner: info.Owner,
|
||
|
|
Worker: info.Worker,
|
||
|
|
ControlAddresses: info.ControlAddresses,
|
||
|
|
|
||
|
|
NewWorker: address.Undef,
|
||
|
|
WorkerChangeEpoch: -1,
|
||
|
|
|
||
|
|
PeerId: pid,
|
||
|
|
Multiaddrs: info.Multiaddrs,
|
||
|
|
WindowPoStProofType: info.WindowPoStProofType,
|
||
|
|
SectorSize: info.SectorSize,
|
||
|
|
WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
|
||
|
|
ConsensusFaultElapsed: info.ConsensusFaultElapsed,
|
||
|
|
}
|
||
|
|
|
||
|
|
if info.PendingWorkerKey != nil {
|
||
|
|
mi.NewWorker = info.PendingWorkerKey.NewWorker
|
||
|
|
mi.WorkerChangeEpoch = info.PendingWorkerKey.EffectiveAt
|
||
|
|
}
|
||
|
|
|
||
|
|
return mi, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error) {
|
||
|
|
return s.State.RecordedDeadlineInfo(epoch), nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) DeadlineCronActive() (bool, error) {
|
||
|
|
return s.State.DeadlineCronActive, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) sectors() (adt.Array, error) {
|
||
|
|
return adt6.AsArray(s.store, s.Sectors, miner6.SectorsAmtBitwidth)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) decodeSectorOnChainInfo(val *cbg.Deferred) (SectorOnChainInfo, error) {
|
||
|
|
var si miner6.SectorOnChainInfo
|
||
|
|
err := si.UnmarshalCBOR(bytes.NewReader(val.Raw))
|
||
|
|
if err != nil {
|
||
|
|
return SectorOnChainInfo{}, err
|
||
|
|
}
|
||
|
|
|
||
|
|
return fromV6SectorOnChainInfo(si), nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) precommits() (adt.Map, error) {
|
||
|
|
return adt6.AsMap(s.store, s.PreCommittedSectors, builtin6.DefaultHamtBitwidth)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreCommitOnChainInfo, error) {
|
||
|
|
var sp miner6.SectorPreCommitOnChainInfo
|
||
|
|
err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw))
|
||
|
|
if err != nil {
|
||
|
|
return SectorPreCommitOnChainInfo{}, err
|
||
|
|
}
|
||
|
|
|
||
|
|
return fromV6SectorPreCommitOnChainInfo(sp), nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) EraseAllUnproven() error {
|
||
|
|
|
||
|
|
dls, err := s.State.LoadDeadlines(s.store)
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
|
||
|
|
err = dls.ForEach(s.store, func(dindx uint64, dl *miner6.Deadline) error {
|
||
|
|
ps, err := dl.PartitionsArray(s.store)
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
|
||
|
|
var part miner6.Partition
|
||
|
|
err = ps.ForEach(&part, func(pindx int64) error {
|
||
|
|
_ = part.ActivateUnproven()
|
||
|
|
err = ps.Set(uint64(pindx), &part)
|
||
|
|
return nil
|
||
|
|
})
|
||
|
|
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
|
||
|
|
dl.Partitions, err = ps.Root()
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
|
||
|
|
return dls.UpdateDeadline(s.store, dindx, dl)
|
||
|
|
})
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
|
||
|
|
return s.State.SaveDeadlines(s.store, dls)
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
func (d *deadline6) LoadPartition(idx uint64) (Partition, error) {
|
||
|
|
p, err := d.Deadline.LoadPartition(d.store, idx)
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
return &partition6{*p, d.store}, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (d *deadline6) ForEachPartition(cb func(uint64, Partition) error) error {
|
||
|
|
ps, err := d.Deadline.PartitionsArray(d.store)
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
var part miner6.Partition
|
||
|
|
return ps.ForEach(&part, func(i int64) error {
|
||
|
|
return cb(uint64(i), &partition6{part, d.store})
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
func (d *deadline6) PartitionsChanged(other Deadline) (bool, error) {
|
||
|
|
other6, ok := other.(*deadline6)
|
||
|
|
if !ok {
|
||
|
|
// treat an upgrade as a change, always
|
||
|
|
return true, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
return !d.Deadline.Partitions.Equals(other6.Deadline.Partitions), nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (d *deadline6) PartitionsPoSted() (bitfield.BitField, error) {
|
||
|
|
return d.Deadline.PartitionsPoSted, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (d *deadline6) DisputableProofCount() (uint64, error) {
|
||
|
|
|
||
|
|
ops, err := d.OptimisticProofsSnapshotArray(d.store)
|
||
|
|
if err != nil {
|
||
|
|
return 0, err
|
||
|
|
}
|
||
|
|
|
||
|
|
return ops.Length(), nil
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
func (p *partition6) AllSectors() (bitfield.BitField, error) {
|
||
|
|
return p.Partition.Sectors, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (p *partition6) FaultySectors() (bitfield.BitField, error) {
|
||
|
|
return p.Partition.Faults, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (p *partition6) RecoveringSectors() (bitfield.BitField, error) {
|
||
|
|
return p.Partition.Recoveries, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (p *partition6) UnprovenSectors() (bitfield.BitField, error) {
|
||
|
|
return p.Partition.Unproven, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func fromV6SectorOnChainInfo(v6 miner6.SectorOnChainInfo) SectorOnChainInfo {
|
||
|
|
|
||
|
|
return SectorOnChainInfo{
|
||
|
|
SectorNumber: v6.SectorNumber,
|
||
|
|
SealProof: v6.SealProof,
|
||
|
|
SealedCID: v6.SealedCID,
|
||
|
|
DealIDs: v6.DealIDs,
|
||
|
|
Activation: v6.Activation,
|
||
|
|
Expiration: v6.Expiration,
|
||
|
|
DealWeight: v6.DealWeight,
|
||
|
|
VerifiedDealWeight: v6.VerifiedDealWeight,
|
||
|
|
InitialPledge: v6.InitialPledge,
|
||
|
|
ExpectedDayReward: v6.ExpectedDayReward,
|
||
|
|
ExpectedStoragePledge: v6.ExpectedStoragePledge,
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
func fromV6SectorPreCommitOnChainInfo(v6 miner6.SectorPreCommitOnChainInfo) SectorPreCommitOnChainInfo {
|
||
|
|
|
||
|
|
return SectorPreCommitOnChainInfo{
|
||
|
|
Info: (SectorPreCommitInfo)(v6.Info),
|
||
|
|
PreCommitDeposit: v6.PreCommitDeposit,
|
||
|
|
PreCommitEpoch: v6.PreCommitEpoch,
|
||
|
|
DealWeight: v6.DealWeight,
|
||
|
|
VerifiedDealWeight: v6.VerifiedDealWeight,
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *state6) GetState() interface{} {
|
||
|
|
return &s.State
|
||
|
|
}
|