Refinements to stmgr and utils

chain/actors/builtin/builtin.go

@@ -3,6 +3,9 @@ package builtin
 import (
 	"fmt"
 
+	"github.com/filecoin-project/go-state-types/abi"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+
 	smoothing0 "github.com/filecoin-project/specs-actors/actors/util/smoothing"
 
 	"github.com/filecoin-project/go-state-types/network"
@@ -30,3 +33,8 @@ type FilterEstimate = smoothing0.FilterEstimate
 func FromV0FilterEstimate(v0 smoothing0.FilterEstimate) FilterEstimate {
 	return (FilterEstimate)(v0)
 }
+
+// Doesn't change between actors v0 and v1
+func QAPowerForWeight(size abi.SectorSize, duration abi.ChainEpoch, dealWeight, verifiedWeight abi.DealWeight) abi.StoragePower {
+	return miner0.QAPowerForWeight(size, duration, dealWeight, verifiedWeight)
+}

chain/actors/builtin/reward/reward.go

@@ -2,6 +2,7 @@ package reward
 
 import (
 	"github.com/filecoin-project/go-state-types/abi"
+	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-state-types/cbor"
@@ -45,3 +46,5 @@ type State interface {
 	InitialPledgeForPower(abi.StoragePower, abi.TokenAmount, *builtin.FilterEstimate, abi.TokenAmount) (abi.TokenAmount, error)
 	PreCommitDepositForPower(builtin.FilterEstimate, abi.StoragePower) (abi.TokenAmount, error)
 }
+
+type AwardBlockRewardParams = reward0.AwardBlockRewardParams

chain/stmgr/stmgr.go

@@ -22,8 +22,7 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/network"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
 	"github.com/filecoin-project/specs-actors/actors/util/adt"
 
 	"github.com/filecoin-project/lotus/api"
@@ -169,20 +168,20 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp
 
 	runCron := func() error {
 		// TODO: this nonce-getting is a tiny bit ugly
-		ca, err := vmi.StateTree().GetActor(builtin.SystemActorAddr)
+		ca, err := vmi.StateTree().GetActor(builtin0.SystemActorAddr)
 		if err != nil {
 			return err
 		}
 
 		cronMsg := &types.Message{
-			To:         builtin.CronActorAddr,
+			To:         builtin0.CronActorAddr,
-			From:       builtin.SystemActorAddr,
+			From:       builtin0.SystemActorAddr,
 			Nonce:      ca.Nonce,
 			Value:      types.NewInt(0),
 			GasFeeCap:  types.NewInt(0),
 			GasPremium: types.NewInt(0),
 			GasLimit:   build.BlockGasLimit * 10000, // Make super sure this is never too little
-			Method:     builtin.MethodsCron.EpochTick,
+			Method:     builtin0.MethodsCron.EpochTick,
 			Params:     nil,
 		}
 		ret, err := vmi.ApplyImplicitMessage(ctx, cronMsg)
@@ -247,11 +246,7 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp
 			processedMsgs[m.Cid()] = true
 		}
 
-		var params []byte
+		params, err := actors.SerializeParams(&reward.AwardBlockRewardParams{
-
-		nv := sm.GetNtwkVersion(ctx, epoch)
-		if nv < build.ActorUpgradeNetworkVersion {
-			params, err = actors.SerializeParams(&reward0.AwardBlockRewardParams{
 			Miner:     b.Miner,
 			Penalty:   penalty,
 			GasReward: gasReward,
@@ -260,29 +255,25 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp
 		if err != nil {
 			return cid.Undef, cid.Undef, xerrors.Errorf("failed to serialize award params: %w", err)
 		}
-		} else {
-			// TODO: ActorUpgrade
-			params = nil
-		}
 
-		sysAct, err := vmi.StateTree().GetActor(builtin.SystemActorAddr)
+		sysAct, actErr := vmi.StateTree().GetActor(builtin0.SystemActorAddr)
-		if err != nil {
+		if actErr != nil {
 			return cid.Undef, cid.Undef, xerrors.Errorf("failed to get system actor: %w", err)
 		}
 
 		rwMsg := &types.Message{
-			From:       builtin.SystemActorAddr,
+			From:       builtin0.SystemActorAddr,
-			To:         builtin.RewardActorAddr,
+			To:         reward.Address,
 			Nonce:      sysAct.Nonce,
 			Value:      types.NewInt(0),
 			GasFeeCap:  types.NewInt(0),
 			GasPremium: types.NewInt(0),
 			GasLimit:   1 << 30,
-			Method:     builtin.MethodsReward.AwardBlockReward,
+			Method:     builtin0.MethodsReward.AwardBlockReward,
 			Params:     params,
 		}
-		ret, err := vmi.ApplyImplicitMessage(ctx, rwMsg)
+		ret, actErr := vmi.ApplyImplicitMessage(ctx, rwMsg)
-		if err != nil {
+		if actErr != nil {
 			return cid.Undef, cid.Undef, xerrors.Errorf("failed to apply reward message for miner %s: %w", b.Miner, err)
 		}
 		if cb != nil {
@@ -725,7 +716,7 @@ func (sm *StateManager) MarketBalance(ctx context.Context, addr address.Address,
 		return api.MarketBalance{}, err
 	}
 
-	act, err := st.GetActor(builtin.StorageMarketActorAddr)
+	act, err := st.GetActor(market.Address)
 	if err != nil {
 		return api.MarketBalance{}, err
 	}
@@ -853,7 +844,7 @@ func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
 	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
 	var act types.Actor
 	err = r.ForEach(&act, func(k string) error {
-		if act.Code == builtin.MultisigActorCodeID {
+		if act.Code == builtin0.MultisigActorCodeID {
 			var s multisig.State
 			err := sm.cs.Store(ctx).Get(ctx, act.Head, &s)
 			if err != nil {
@@ -871,7 +862,7 @@ func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
 				totalsByEpoch[s.UnlockDuration()] = s.InitialBalance()
 			}
 
-		} else if act.Code == builtin.AccountActorCodeID {
+		} else if act.Code == builtin0.AccountActorCodeID {
 			// should exclude burnt funds actor and "remainder account actor"
 			// should only ever be "faucet" accounts in testnets
 			kaddr, err := address.NewFromBytes([]byte(k))
@@ -879,7 +870,7 @@ func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
 				return xerrors.Errorf("decoding address: %w", err)
 			}
 
-			if kaddr != builtin.BurntFundsActorAddr {
+			if kaddr != builtin0.BurntFundsActorAddr {
 				kid, err := sTree.LookupID(kaddr)
 				if err != nil {
 					return xerrors.Errorf("resolving address: %w", err)
@@ -954,24 +945,24 @@ func (sm *StateManager) setupGenesisActorsTestnet(ctx context.Context) error {
 	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
 
 	// 6 months
-	sixMonths := abi.ChainEpoch(183 * builtin.EpochsInDay)
+	sixMonths := abi.ChainEpoch(183 * builtin0.EpochsInDay)
 	totalsByEpoch[sixMonths] = big.NewInt(49_929_341)
 	totalsByEpoch[sixMonths] = big.Add(totalsByEpoch[sixMonths], big.NewInt(32_787_700))
 
 	// 1 year
-	oneYear := abi.ChainEpoch(365 * builtin.EpochsInDay)
+	oneYear := abi.ChainEpoch(365 * builtin0.EpochsInDay)
 	totalsByEpoch[oneYear] = big.NewInt(22_421_712)
 
 	// 2 years
-	twoYears := abi.ChainEpoch(2 * 365 * builtin.EpochsInDay)
+	twoYears := abi.ChainEpoch(2 * 365 * builtin0.EpochsInDay)
 	totalsByEpoch[twoYears] = big.NewInt(7_223_364)
 
 	// 3 years
-	threeYears := abi.ChainEpoch(3 * 365 * builtin.EpochsInDay)
+	threeYears := abi.ChainEpoch(3 * 365 * builtin0.EpochsInDay)
 	totalsByEpoch[threeYears] = big.NewInt(87_637_883)
 
 	// 6 years
-	sixYears := abi.ChainEpoch(6 * 365 * builtin.EpochsInDay)
+	sixYears := abi.ChainEpoch(6 * 365 * builtin0.EpochsInDay)
 	totalsByEpoch[sixYears] = big.NewInt(100_000_000)
 	totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(300_000_000))
 
@@ -1020,7 +1011,7 @@ func (sm *StateManager) GetFilVested(ctx context.Context, height abi.ChainEpoch,
 }
 
 func GetFilMined(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
-	ractor, err := st.GetActor(builtin.RewardActorAddr)
+	ractor, err := st.GetActor(reward.Address)
 	if err != nil {
 		return big.Zero(), xerrors.Errorf("failed to load reward actor state: %w", err)
 	}
@@ -1034,7 +1025,7 @@ func GetFilMined(ctx context.Context, st *state.StateTree) (abi.TokenAmount, err
 }
 
 func getFilMarketLocked(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
-	act, err := st.GetActor(builtin.StorageMarketActorAddr)
+	act, err := st.GetActor(market.Address)
 	if err != nil {
 		return big.Zero(), xerrors.Errorf("failed to load market actor: %w", err)
 	}
@@ -1048,7 +1039,7 @@ func getFilMarketLocked(ctx context.Context, st *state.StateTree) (abi.TokenAmou
 }
 
 func getFilPowerLocked(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
-	pactor, err := st.GetActor(builtin.StoragePowerActorAddr)
+	pactor, err := st.GetActor(power.Address)
 	if err != nil {
 		return big.Zero(), xerrors.Errorf("failed to load power actor: %w", err)
 	}
@@ -1077,7 +1068,7 @@ func (sm *StateManager) GetFilLocked(ctx context.Context, st *state.StateTree) (
 }
 
 func GetFilBurnt(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
-	burnt, err := st.GetActor(builtin.BurntFundsActorAddr)
+	burnt, err := st.GetActor(builtin0.BurntFundsActorAddr)
 	if err != nil {
 		return big.Zero(), xerrors.Errorf("failed to load burnt actor: %w", err)
 	}

chain/stmgr/utils.go

@@ -88,8 +88,7 @@ func GetPower(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr add
 }
 
 func GetPowerRaw(ctx context.Context, sm *StateManager, st cid.Cid, maddr address.Address) (power.Claim, power.Claim, bool, error) {
-	// TODO: ActorUpgrade
+	act, err := sm.LoadActorRaw(ctx, power.Address, st)
-	act, err := sm.LoadActorRaw(ctx, builtin0.StoragePowerActorAddr, st)
 	if err != nil {
 		return power.Claim{}, power.Claim{}, false, xerrors.Errorf("(get sset) failed to load power actor state: %w", err)
 	}
@@ -281,8 +280,7 @@ func StateMinerInfo(ctx context.Context, sm *StateManager, ts *types.TipSet, mad
 }
 
 func GetMinerSlashed(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (bool, error) {
-	// TODO: ActorUpgrade
+	act, err := sm.LoadActor(ctx, power.Address, ts)
-	act, err := sm.LoadActor(ctx, builtin0.StoragePowerActorAddr, ts)
 	if err != nil {
 		return false, xerrors.Errorf("failed to load power actor: %w", err)
 	}
@@ -305,8 +303,7 @@ func GetMinerSlashed(ctx context.Context, sm *StateManager, ts *types.TipSet, ma
 }
 
 func GetStorageDeal(ctx context.Context, sm *StateManager, dealID abi.DealID, ts *types.TipSet) (*api.MarketDeal, error) {
-	// TODO: ActorUpgrade
+	act, err := sm.LoadActor(ctx, market.Address, ts)
-	act, err := sm.LoadActor(ctx, builtin0.StorageMarketActorAddr, ts)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to load market actor: %w", err)
 	}
@@ -350,8 +347,7 @@ func GetStorageDeal(ctx context.Context, sm *StateManager, dealID abi.DealID, ts
 }
 
 func ListMinerActors(ctx context.Context, sm *StateManager, ts *types.TipSet) ([]address.Address, error) {
-	// TODO: ActorUpgrade
+	act, err := sm.LoadActor(ctx, power.Address, ts)
-	act, err := sm.LoadActor(ctx, builtin0.StoragePowerActorAddr, ts)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to load power actor: %w", err)
 	}
@@ -630,8 +626,7 @@ func GetReturnType(ctx context.Context, sm *StateManager, to address.Address, me
 }
 
 func MinerHasMinPower(ctx context.Context, sm *StateManager, addr address.Address, ts *types.TipSet) (bool, error) {
-	// TODO: ActorUpgrade
+	pact, err := sm.LoadActor(ctx, power.Address, ts)
-	pact, err := sm.LoadActor(ctx, builtin0.StoragePowerActorAddr, ts)
 	if err != nil {
 		return false, xerrors.Errorf("loading power actor state: %w", err)
 	}

node/impl/full/state.go

@@ -5,11 +5,10 @@ import (
 	"context"
 	"strconv"
 
-	builtin2 "github.com/filecoin-project/lotus/chain/actors/builtin"
+	lotusbuiltin "github.com/filecoin-project/lotus/chain/actors/builtin"
 
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 
 	"github.com/filecoin-project/lotus/chain/actors/builtin/verifreg"
 
@@ -871,7 +870,7 @@ func (a *StateAPI) StateMinerPreCommitDepositForPower(ctx context.Context, maddr
 
 	var sectorWeight abi.StoragePower
 	if act, err := state.GetActor(market.Address); err != nil {
-		return types.EmptyInt, xerrors.Errorf("loading miner actor %s: %w", maddr, err)
+		return types.EmptyInt, xerrors.Errorf("loading market actor %s: %w", maddr, err)
 	} else if s, err := market.Load(store, act); err != nil {
 		return types.EmptyInt, xerrors.Errorf("loading market actor state %s: %w", maddr, err)
 	} else if w, vw, err := s.VerifyDealsForActivation(maddr, pci.DealIDs, ts.Height(), pci.Expiration); err != nil {
@@ -879,14 +878,12 @@ func (a *StateAPI) StateMinerPreCommitDepositForPower(ctx context.Context, maddr
 	} else {
 		// NB: not exactly accurate, but should always lead us to *over* estimate, not under
 		duration := pci.Expiration - ts.Height()
-
+		sectorWeight = lotusbuiltin.QAPowerForWeight(ssize, duration, w, vw)
-		// TODO: ActorUpgrade
-		sectorWeight = miner0.QAPowerForWeight(ssize, duration, w, vw)
 	}
 
-	var powerSmoothed builtin2.FilterEstimate
+	var powerSmoothed lotusbuiltin.FilterEstimate
 	if act, err := state.GetActor(power.Address); err != nil {
-		return types.EmptyInt, xerrors.Errorf("loading miner actor: %w", err)
+		return types.EmptyInt, xerrors.Errorf("loading power actor: %w", err)
 	} else if s, err := power.Load(store, act); err != nil {
 		return types.EmptyInt, xerrors.Errorf("loading power actor state: %w", err)
 	} else if p, err := s.TotalPowerSmoothed(); err != nil {
@@ -942,13 +939,11 @@ func (a *StateAPI) StateMinerInitialPledgeCollateral(ctx context.Context, maddr
 	} else {
 		// NB: not exactly accurate, but should always lead us to *over* estimate, not under
 		duration := pci.Expiration - ts.Height()
-
+		sectorWeight = lotusbuiltin.QAPowerForWeight(ssize, duration, w, vw)
-		// TODO: ActorUpgrade
-		sectorWeight = miner0.QAPowerForWeight(ssize, duration, w, vw)
 	}
 
 	var (
-		powerSmoothed    builtin2.FilterEstimate
+		powerSmoothed    lotusbuiltin.FilterEstimate
 		pledgeCollateral abi.TokenAmount
 	)
 	if act, err := state.GetActor(power.Address); err != nil {