2d57bfe273
* Use local GST Use local GST * Import actors and define upgrade heights Creatin a mock actor-bundle and define upgrade heights * Generate adapters Updates gen/inlinegen-data.json, and runs make actors-gen * Add schedule and migration Add schedule and migration * Add upgrade and network version fields/params Add upgrade and network version fields/params * Run make gen / make docsgen-cli Run make gen / make docsgen-cli * Update filecoin-ffi Update filecoin-ffi to the v1.28.0-dev tag, which supports the nv23 skeleton. * Update GST to v0.14.0-dev Update GST to v0.14.0-dev, which includes the nv23 skeleton * Add support for actor version 14 in actor registry Add support for actor version 14 in actor registry
208 lines
4.9 KiB
Go
Generated
208 lines
4.9 KiB
Go
Generated
package power
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
|
|
"github.com/ipfs/go-cid"
|
|
cbg "github.com/whyrusleeping/cbor-gen"
|
|
|
|
"github.com/filecoin-project/go-address"
|
|
"github.com/filecoin-project/go-state-types/abi"
|
|
actorstypes "github.com/filecoin-project/go-state-types/actors"
|
|
builtin14 "github.com/filecoin-project/go-state-types/builtin"
|
|
power14 "github.com/filecoin-project/go-state-types/builtin/v14/power"
|
|
adt14 "github.com/filecoin-project/go-state-types/builtin/v14/util/adt"
|
|
"github.com/filecoin-project/go-state-types/manifest"
|
|
|
|
"github.com/filecoin-project/lotus/chain/actors"
|
|
"github.com/filecoin-project/lotus/chain/actors/adt"
|
|
"github.com/filecoin-project/lotus/chain/actors/builtin"
|
|
)
|
|
|
|
var _ State = (*state14)(nil)
|
|
|
|
func load14(store adt.Store, root cid.Cid) (State, error) {
|
|
out := state14{store: store}
|
|
err := store.Get(store.Context(), root, &out)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &out, nil
|
|
}
|
|
|
|
func make14(store adt.Store) (State, error) {
|
|
out := state14{store: store}
|
|
|
|
s, err := power14.ConstructState(store)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
out.State = *s
|
|
|
|
return &out, nil
|
|
}
|
|
|
|
type state14 struct {
|
|
power14.State
|
|
store adt.Store
|
|
}
|
|
|
|
func (s *state14) TotalLocked() (abi.TokenAmount, error) {
|
|
return s.TotalPledgeCollateral, nil
|
|
}
|
|
|
|
func (s *state14) TotalPower() (Claim, error) {
|
|
return Claim{
|
|
RawBytePower: s.TotalRawBytePower,
|
|
QualityAdjPower: s.TotalQualityAdjPower,
|
|
}, nil
|
|
}
|
|
|
|
// Committed power to the network. Includes miners below the minimum threshold.
|
|
func (s *state14) TotalCommitted() (Claim, error) {
|
|
return Claim{
|
|
RawBytePower: s.TotalBytesCommitted,
|
|
QualityAdjPower: s.TotalQABytesCommitted,
|
|
}, nil
|
|
}
|
|
|
|
func (s *state14) MinerPower(addr address.Address) (Claim, bool, error) {
|
|
claims, err := s.claims()
|
|
if err != nil {
|
|
return Claim{}, false, err
|
|
}
|
|
var claim power14.Claim
|
|
ok, err := claims.Get(abi.AddrKey(addr), &claim)
|
|
if err != nil {
|
|
return Claim{}, false, err
|
|
}
|
|
return Claim{
|
|
RawBytePower: claim.RawBytePower,
|
|
QualityAdjPower: claim.QualityAdjPower,
|
|
}, ok, nil
|
|
}
|
|
|
|
func (s *state14) MinerNominalPowerMeetsConsensusMinimum(a address.Address) (bool, error) {
|
|
return s.State.MinerNominalPowerMeetsConsensusMinimum(s.store, a)
|
|
}
|
|
|
|
func (s *state14) TotalPowerSmoothed() (builtin.FilterEstimate, error) {
|
|
return builtin.FilterEstimate(s.State.ThisEpochQAPowerSmoothed), nil
|
|
}
|
|
|
|
func (s *state14) MinerCounts() (uint64, uint64, error) {
|
|
return uint64(s.State.MinerAboveMinPowerCount), uint64(s.State.MinerCount), nil
|
|
}
|
|
|
|
func (s *state14) ListAllMiners() ([]address.Address, error) {
|
|
claims, err := s.claims()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var miners []address.Address
|
|
err = claims.ForEach(nil, func(k string) error {
|
|
a, err := address.NewFromBytes([]byte(k))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
miners = append(miners, a)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return miners, nil
|
|
}
|
|
|
|
func (s *state14) ForEachClaim(cb func(miner address.Address, claim Claim) error) error {
|
|
claims, err := s.claims()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var claim power14.Claim
|
|
return claims.ForEach(&claim, func(k string) error {
|
|
a, err := address.NewFromBytes([]byte(k))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return cb(a, Claim{
|
|
RawBytePower: claim.RawBytePower,
|
|
QualityAdjPower: claim.QualityAdjPower,
|
|
})
|
|
})
|
|
}
|
|
|
|
func (s *state14) ClaimsChanged(other State) (bool, error) {
|
|
other14, ok := other.(*state14)
|
|
if !ok {
|
|
// treat an upgrade as a change, always
|
|
return true, nil
|
|
}
|
|
return !s.State.Claims.Equals(other14.State.Claims), nil
|
|
}
|
|
|
|
func (s *state14) SetTotalQualityAdjPower(p abi.StoragePower) error {
|
|
s.State.TotalQualityAdjPower = p
|
|
return nil
|
|
}
|
|
|
|
func (s *state14) SetTotalRawBytePower(p abi.StoragePower) error {
|
|
s.State.TotalRawBytePower = p
|
|
return nil
|
|
}
|
|
|
|
func (s *state14) SetThisEpochQualityAdjPower(p abi.StoragePower) error {
|
|
s.State.ThisEpochQualityAdjPower = p
|
|
return nil
|
|
}
|
|
|
|
func (s *state14) SetThisEpochRawBytePower(p abi.StoragePower) error {
|
|
s.State.ThisEpochRawBytePower = p
|
|
return nil
|
|
}
|
|
|
|
func (s *state14) GetState() interface{} {
|
|
return &s.State
|
|
}
|
|
|
|
func (s *state14) claims() (adt.Map, error) {
|
|
return adt14.AsMap(s.store, s.Claims, builtin14.DefaultHamtBitwidth)
|
|
}
|
|
|
|
func (s *state14) decodeClaim(val *cbg.Deferred) (Claim, error) {
|
|
var ci power14.Claim
|
|
if err := ci.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
|
|
return Claim{}, err
|
|
}
|
|
return fromV14Claim(ci), nil
|
|
}
|
|
|
|
func fromV14Claim(v14 power14.Claim) Claim {
|
|
return Claim{
|
|
RawBytePower: v14.RawBytePower,
|
|
QualityAdjPower: v14.QualityAdjPower,
|
|
}
|
|
}
|
|
|
|
func (s *state14) ActorKey() string {
|
|
return manifest.PowerKey
|
|
}
|
|
|
|
func (s *state14) ActorVersion() actorstypes.Version {
|
|
return actorstypes.Version14
|
|
}
|
|
|
|
func (s *state14) Code() cid.Cid {
|
|
code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey())
|
|
if !ok {
|
|
panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion()))
|
|
}
|
|
|
|
return code
|
|
}
|