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" builtin5 "github.com/filecoin-project/specs-actors/v5/actors/builtin" miner5 "github.com/filecoin-project/specs-actors/v5/actors/builtin/miner" adt5 "github.com/filecoin-project/specs-actors/v5/actors/util/adt" ) var _ State = (*state5)(nil) func load5(store adt.Store, root cid.Cid) (State, error) { out := state5{store: store} err := store.Get(store.Context(), root, &out) if err != nil { return nil, err } return &out, nil } func make5(store adt.Store) (State, error) { out := state5{store: store} out.State = miner5.State{} return &out, nil } type state5 struct { miner5.State store adt.Store } type deadline5 struct { miner5.Deadline store adt.Store } type partition5 struct { miner5.Partition store adt.Store } func (s *state5) 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 *state5) VestedFunds(epoch abi.ChainEpoch) (abi.TokenAmount, error) { return s.CheckVestedFunds(s.store, epoch) } func (s *state5) LockedFunds() (LockedFunds, error) { return LockedFunds{ VestingFunds: s.State.LockedFunds, InitialPledgeRequirement: s.State.InitialPledge, PreCommitDeposits: s.State.PreCommitDeposits, }, nil } func (s *state5) FeeDebt() (abi.TokenAmount, error) { return s.State.FeeDebt, nil } func (s *state5) InitialPledge() (abi.TokenAmount, error) { return s.State.InitialPledge, nil } func (s *state5) PreCommitDeposits() (abi.TokenAmount, error) { return s.State.PreCommitDeposits, nil } func (s *state5) GetSector(num abi.SectorNumber) (*SectorOnChainInfo, error) { info, ok, err := s.State.GetSector(s.store, num) if !ok || err != nil { return nil, err } ret := fromV5SectorOnChainInfo(*info) return &ret, nil } func (s *state5) 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 *state5) 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 *miner5.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 *state5) 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 *miner5.Deadline) error { partitions, err := dl.PartitionsArray(s.store) if err != nil { return err } quant := s.State.QuantSpecForDeadline(dlIdx) var part miner5.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 := miner5.LoadExpirationQueue(s.store, part.ExpirationsEpochs, quant, miner5.PartitionExpirationAmtBitwidth) if err != nil { return err } var exp miner5.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 *state5) GetPrecommittedSector(num abi.SectorNumber) (*SectorPreCommitOnChainInfo, error) { info, ok, err := s.State.GetPrecommittedSector(s.store, num) if !ok || err != nil { return nil, err } ret := fromV5SectorPreCommitOnChainInfo(*info) return &ret, nil } func (s *state5) ForEachPrecommittedSector(cb func(SectorPreCommitOnChainInfo) error) error { precommitted, err := adt5.AsMap(s.store, s.State.PreCommittedSectors, builtin5.DefaultHamtBitwidth) if err != nil { return err } var info miner5.SectorPreCommitOnChainInfo if err := precommitted.ForEach(&info, func(_ string) error { return cb(fromV5SectorPreCommitOnChainInfo(info)) }); err != nil { return err } return nil } func (s *state5) LoadSectors(snos *bitfield.BitField) ([]*SectorOnChainInfo, error) { sectors, err := miner5.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 info5 miner5.SectorOnChainInfo if err := sectors.ForEach(&info5, func(_ int64) error { info := fromV5SectorOnChainInfo(info5) infos = append(infos, &info) return nil }); err != nil { return nil, err } return infos, nil } // Otherwise, load selected. infos5, err := sectors.Load(*snos) if err != nil { return nil, err } infos := make([]*SectorOnChainInfo, len(infos5)) for i, info5 := range infos5 { info := fromV5SectorOnChainInfo(*info5) infos[i] = &info } return infos, nil } func (s *state5) loadAllocatedSectorNumbers() (bitfield.BitField, error) { var allocatedSectors bitfield.BitField err := s.store.Get(s.store.Context(), s.State.AllocatedSectors, &allocatedSectors) return allocatedSectors, err } func (s *state5) IsAllocated(num abi.SectorNumber) (bool, error) { allocatedSectors, err := s.loadAllocatedSectorNumbers() if err != nil { return false, err } return allocatedSectors.IsSet(uint64(num)) } func (s *state5) GetProvingPeriodStart() (abi.ChainEpoch, error) { return s.State.ProvingPeriodStart, nil } func (s *state5) 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 *state5) 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 *state5) 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 &deadline5{*dl, s.store}, nil } func (s *state5) 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 *miner5.Deadline) error { return cb(i, &deadline5{*dl, s.store}) }) } func (s *state5) NumDeadlines() (uint64, error) { return miner5.WPoStPeriodDeadlines, nil } func (s *state5) DeadlinesChanged(other State) (bool, error) { other5, ok := other.(*state5) if !ok { // treat an upgrade as a change, always return true, nil } return !s.State.Deadlines.Equals(other5.Deadlines), nil } func (s *state5) MinerInfoChanged(other State) (bool, error) { other0, ok := other.(*state5) if !ok { // treat an upgrade as a change, always return true, nil } return !s.State.Info.Equals(other0.State.Info), nil } func (s *state5) 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 *state5) DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error) { return s.State.RecordedDeadlineInfo(epoch), nil } func (s *state5) DeadlineCronActive() (bool, error) { return s.State.DeadlineCronActive, nil } func (s *state5) sectors() (adt.Array, error) { return adt5.AsArray(s.store, s.Sectors, miner5.SectorsAmtBitwidth) } func (s *state5) decodeSectorOnChainInfo(val *cbg.Deferred) (SectorOnChainInfo, error) { var si miner5.SectorOnChainInfo err := si.UnmarshalCBOR(bytes.NewReader(val.Raw)) if err != nil { return SectorOnChainInfo{}, err } return fromV5SectorOnChainInfo(si), nil } func (s *state5) precommits() (adt.Map, error) { return adt5.AsMap(s.store, s.PreCommittedSectors, builtin5.DefaultHamtBitwidth) } func (s *state5) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreCommitOnChainInfo, error) { var sp miner5.SectorPreCommitOnChainInfo err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw)) if err != nil { return SectorPreCommitOnChainInfo{}, err } return fromV5SectorPreCommitOnChainInfo(sp), nil } func (s *state5) EraseAllUnproven() error { dls, err := s.State.LoadDeadlines(s.store) if err != nil { return err } err = dls.ForEach(s.store, func(dindx uint64, dl *miner5.Deadline) error { ps, err := dl.PartitionsArray(s.store) if err != nil { return err } var part miner5.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 *deadline5) LoadPartition(idx uint64) (Partition, error) { p, err := d.Deadline.LoadPartition(d.store, idx) if err != nil { return nil, err } return &partition5{*p, d.store}, nil } func (d *deadline5) ForEachPartition(cb func(uint64, Partition) error) error { ps, err := d.Deadline.PartitionsArray(d.store) if err != nil { return err } var part miner5.Partition return ps.ForEach(&part, func(i int64) error { return cb(uint64(i), &partition5{part, d.store}) }) } func (d *deadline5) PartitionsChanged(other Deadline) (bool, error) { other5, ok := other.(*deadline5) if !ok { // treat an upgrade as a change, always return true, nil } return !d.Deadline.Partitions.Equals(other5.Deadline.Partitions), nil } func (d *deadline5) PartitionsPoSted() (bitfield.BitField, error) { return d.Deadline.PartitionsPoSted, nil } func (d *deadline5) DisputableProofCount() (uint64, error) { ops, err := d.OptimisticProofsSnapshotArray(d.store) if err != nil { return 0, err } return ops.Length(), nil } func (p *partition5) AllSectors() (bitfield.BitField, error) { return p.Partition.Sectors, nil } func (p *partition5) FaultySectors() (bitfield.BitField, error) { return p.Partition.Faults, nil } func (p *partition5) RecoveringSectors() (bitfield.BitField, error) { return p.Partition.Recoveries, nil } func fromV5SectorOnChainInfo(v5 miner5.SectorOnChainInfo) SectorOnChainInfo { return SectorOnChainInfo{ SectorNumber: v5.SectorNumber, SealProof: v5.SealProof, SealedCID: v5.SealedCID, DealIDs: v5.DealIDs, Activation: v5.Activation, Expiration: v5.Expiration, DealWeight: v5.DealWeight, VerifiedDealWeight: v5.VerifiedDealWeight, InitialPledge: v5.InitialPledge, ExpectedDayReward: v5.ExpectedDayReward, ExpectedStoragePledge: v5.ExpectedStoragePledge, } } func fromV5SectorPreCommitOnChainInfo(v5 miner5.SectorPreCommitOnChainInfo) SectorPreCommitOnChainInfo { return SectorPreCommitOnChainInfo{ Info: (SectorPreCommitInfo)(v5.Info), PreCommitDeposit: v5.PreCommitDeposit, PreCommitEpoch: v5.PreCommitEpoch, DealWeight: v5.DealWeight, VerifiedDealWeight: v5.VerifiedDealWeight, } } func (s *state5) GetState() interface{} { return &s.State }