stmgr: Update stmgr utils

chain/actors/actor_storagemarket.go

@@ -4,23 +4,6 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/builtin/market"
 )
 
-type smaMethods struct {
-	Constructor                  uint64
-	WithdrawBalance              uint64
-	AddBalance                   uint64
-	CheckLockedBalance           uint64
-	PublishStorageDeals          uint64
-	HandleCronAction             uint64
-	SettleExpiredDeals           uint64
-	ProcessStorageDealsPayment   uint64
-	SlashStorageDealCollateral   uint64
-	GetLastExpirationFromDealIDs uint64
-	ActivateStorageDeals         uint64
-	ComputeDataCommitment        uint64
-}
-
-var SMAMethods = smaMethods{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
-
 type StorageMarketState = market.State
 
 // TODO: Drop in favour of car storage

chain/stmgr/stmgr.go

@@ -300,15 +300,27 @@ func (sm *StateManager) computeTipSetState(ctx context.Context, blks []*types.Bl
 	return st, rectroot, nil
 }
 
-func (sm *StateManager) GetActor(addr address.Address, ts *types.TipSet) (*types.Actor, error) {
+func (sm *StateManager) parentState(ts *types.TipSet) cid.Cid {
 	if ts == nil {
 		ts = sm.cs.GetHeaviestTipSet()
 	}
 
-	stcid := ts.ParentState()
+	return ts.ParentState()
+}
 
+func (sm *StateManager) GetActor(addr address.Address, ts *types.TipSet) (*types.Actor, error) {
 	cst := cbor.NewCborStore(sm.cs.Blockstore())
-	state, err := state.LoadStateTree(cst, stcid)
+	state, err := state.LoadStateTree(cst, sm.parentState(ts))
+	if err != nil {
+		return nil, xerrors.Errorf("load state tree: %w", err)
+	}
+
+	return state.GetActor(addr)
+}
+
+func (sm *StateManager) getActorRaw(addr address.Address, st cid.Cid) (*types.Actor, error) {
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	state, err := state.LoadStateTree(cst, st)
 	if err != nil {
 		return nil, xerrors.Errorf("load state tree: %w", err)
 	}
@@ -345,6 +357,21 @@ func (sm *StateManager) LoadActorState(ctx context.Context, a address.Address, o
 
 	return act, nil
 }
+
+func (sm *StateManager) LoadActorStateRaw(ctx context.Context, a address.Address, out interface{}, st cid.Cid) (*types.Actor, error) {
+	act, err := sm.getActorRaw(a, st)
+	if err != nil {
+		return nil, err
+	}
+
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	if err := cst.Get(ctx, act.Head, out); err != nil {
+		return nil, err
+	}
+
+	return act, nil
+}
+
 func (sm *StateManager) ResolveToKeyAddress(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error) {
 	switch addr.Protocol() {
 	case address.BLS, address.SECP256K1:

chain/stmgr/utils.go

@@ -5,13 +5,18 @@ import (
 
 	amt "github.com/filecoin-project/go-amt-ipld/v2"
 	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
 	"github.com/filecoin-project/specs-actors/actors/builtin/market"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-actors/actors/builtin/power"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
 
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
 
-	ffi "github.com/filecoin-project/filecoin-ffi"
 	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
 
+	ffi "github.com/filecoin-project/filecoin-ffi"
+
 	"github.com/filecoin-project/go-address"
 
 	"github.com/filecoin-project/lotus/api"
@@ -29,142 +34,67 @@ import (
 )
 
 func GetMinerWorkerRaw(ctx context.Context, sm *StateManager, st cid.Cid, maddr address.Address) (address.Address, error) {
-	recp, err := sm.CallRaw(ctx, &types.Message{
+	var mas miner.State
-		To:     maddr,
+	_, err := sm.LoadActorStateRaw(ctx, maddr, &mas, st)
-		From:   maddr,
-		Method: actors.MAMethods.GetWorkerAddr,
-	}, st, nil, 0)
 	if err != nil {
-		return address.Undef, xerrors.Errorf("callRaw failed: %w", err)
+		return address.Undef, xerrors.Errorf("(get sset) failed to load miner actor state: %w", err)
 	}
 
-	if recp.ExitCode != 0 {
+	return mas.Info.Worker, nil
-		return address.Undef, xerrors.Errorf("getting miner worker addr failed (exit code %d)", recp.ExitCode)
-	}
-
-	worker, err := address.NewFromBytes(recp.Return)
-	if err != nil {
-		return address.Undef, err
-	}
-
-	if worker.Protocol() == address.ID {
-		return address.Undef, xerrors.Errorf("need to resolve worker address to a pubkeyaddr")
-	}
-
-	return worker, nil
 }
 
 func GetMinerOwner(ctx context.Context, sm *StateManager, st cid.Cid, maddr address.Address) (address.Address, error) {
-	recp, err := sm.CallRaw(ctx, &types.Message{
+	var mas miner.State
-		To:     maddr,
+	_, err := sm.LoadActorStateRaw(ctx, maddr, &mas, st)
-		From:   maddr,
-		Method: actors.MAMethods.GetOwner,
-	}, st, nil, 0)
 	if err != nil {
-		return address.Undef, xerrors.Errorf("callRaw failed: %w", err)
+		return address.Undef, xerrors.Errorf("(get sset) failed to load miner actor state: %w", err)
 	}
 
-	if recp.ExitCode != 0 {
+	return mas.Info.Owner, nil
-		return address.Undef, xerrors.Errorf("getting miner owner addr failed (exit code %d)", recp.ExitCode)
-	}
-
-	owner, err := address.NewFromBytes(recp.Return)
-	if err != nil {
-		return address.Undef, err
-	}
-
-	if owner.Protocol() == address.ID {
-		return address.Undef, xerrors.Errorf("need to resolve owner address to a pubkeyaddr")
-	}
-
-	return owner, nil
 }
 
 func GetPower(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (types.BigInt, types.BigInt, error) {
-	var err error
+	var ps power.State
-
+	_, err := sm.LoadActorState(ctx, maddr, &ps, ts)
-	var mpow types.BigInt
+	if err != nil {
+		return big.Zero(), big.Zero(), xerrors.Errorf("(get sset) failed to load miner actor state: %w", err)
+	}
 
+	var mpow big.Int
 	if maddr != address.Undef {
-		enc, aerr := actors.SerializeParams(&actors.PowerLookupParams{maddr})
+		var claim power.Claim
-		if aerr != nil {
+		if _, err := adt.AsMap(sm.cs.Store(ctx), ps.Claims).Get(adt.AddrKey(maddr), &claim); err != nil {
-			return types.EmptyInt, types.EmptyInt, aerr
+			return big.Zero(), big.Zero(), err
-		}
-		ret, err := sm.Call(ctx, &types.Message{
-			From:   maddr,
-			To:     actors.StoragePowerAddress,
-			Method: actors.SPAMethods.PowerLookup,
-			Params: enc,
-		}, ts)
-		if err != nil {
-			return types.EmptyInt, types.EmptyInt, xerrors.Errorf("failed to get miner power from chain: %w", err)
-		}
-		if ret.ExitCode != 0 {
-			return types.EmptyInt, types.EmptyInt, xerrors.Errorf("failed to get miner power from chain (exit code %d)", ret.ExitCode)
 		}
 
-		mpow = types.BigFromBytes(ret.Return)
+		mpow = claim.Power
 	}
 
-	ret, err := sm.Call(ctx, &types.Message{
+	return mpow, ps.TotalNetworkPower, nil
-		From:   actors.StoragePowerAddress,
-		To:     actors.StoragePowerAddress,
-		Method: actors.SPAMethods.GetTotalStorage,
-	}, ts)
-	if err != nil {
-		return types.EmptyInt, types.EmptyInt, xerrors.Errorf("failed to get total power from chain: %w", err)
-	}
-	if ret.ExitCode != 0 {
-		return types.EmptyInt, types.EmptyInt, xerrors.Errorf("failed to get total power from chain (exit code %d)", ret.ExitCode)
-	}
-
-	tpow := types.BigFromBytes(ret.Return)
-
-	return mpow, tpow, nil
 }
 
 func GetMinerPeerID(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (peer.ID, error) {
-	recp, err := sm.Call(ctx, &types.Message{
+	var mas miner.State
-		To:     maddr,
+	_, err := sm.LoadActorState(ctx, maddr, &mas, ts)
-		From:   maddr,
-		Method: actors.MAMethods.GetPeerID,
-	}, ts)
 	if err != nil {
-		return "", xerrors.Errorf("call failed: %w", err)
+		return "", xerrors.Errorf("(get sset) failed to load miner actor state: %w", err)
 	}
 
-	if recp.ExitCode != 0 {
+	return mas.Info.PeerId, nil
-		return "", xerrors.Errorf("getting miner peer ID failed (exit code %d)", recp.ExitCode)
-	}
-
-	return peer.IDFromBytes(recp.Return)
 }
 
 func GetMinerWorker(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (address.Address, error) {
-	recp, err := sm.Call(ctx, &types.Message{
+	return GetMinerWorkerRaw(ctx, sm, sm.parentState(ts), maddr)
-		To:     maddr,
-		From:   maddr,
-		Method: actors.MAMethods.GetWorkerAddr,
-	}, ts)
-	if err != nil {
-		return address.Undef, xerrors.Errorf("call failed: %w", err)
-	}
-
-	if recp.ExitCode != 0 {
-		return address.Undef, xerrors.Errorf("getting miner peer ID failed (exit code %d)", recp.ExitCode)
-	}
-
-	return address.NewFromBytes(recp.Return)
 }
 
-func GetMinerElectionPeriodStart(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (abi.ChainEpoch, error) {
+func GetMinerPostState(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (*miner.PoStState, error) {
 	var mas actors.StorageMinerActorState
 	_, err := sm.LoadActorState(ctx, maddr, &mas, ts)
 	if err != nil {
-		return 0, xerrors.Errorf("(get eps) failed to load miner actor state: %w", err)
+		return nil, xerrors.Errorf("(get eps) failed to load miner actor state: %w", err)
 	}
 
-	return mas.ElectionPeriodStart, nil
+	return &mas.PoStState, nil
 }
 
 func SectorSetSizes(ctx context.Context, sm *StateManager, maddr address.Address, ts *types.TipSet) (api.MinerSectors, error) {
@@ -238,23 +168,11 @@ func GetMinerSectorSize(ctx context.Context, sm *StateManager, ts *types.TipSet,
 		return 0, xerrors.Errorf("(get ssize) failed to load miner actor state: %w", err)
 	}
 
-	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	return mas.Info.SectorSize, nil
-	var minfo actors.MinerInfo
-	if err := cst.Get(ctx, mas.Info, &minfo); err != nil {
-		return 0, xerrors.Errorf("failed to read miner info: %w", err)
-	}
-
-	return minfo.SectorSize, nil
 }
 
 func GetMinerSlashed(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (uint64, error) {
-	var mas actors.StorageMinerActorState
+	panic("TODO")
-	_, err := sm.LoadActorState(ctx, maddr, &mas, ts)
-	if err != nil {
-		return 0, xerrors.Errorf("(get mslash) failed to load miner actor state: %w", err)
-	}
-
-	return mas.SlashedAt, nil
 }
 
 func GetMinerFaults(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) ([]abi.SectorNumber, error) {
@@ -320,8 +238,15 @@ func ListMinerActors(ctx context.Context, sm *StateManager, ts *types.TipSet) ([
 		return nil, err
 	}
 
-	cst := cbor.NewCborStore(sm.ChainStore().Blockstore())
+	var miners []address.Address
-	miners, err := actors.MinerSetList(ctx, cst, state.Miners)
+	err := adt.AsMap(sm.cs.Store(ctx), state.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
 	}

node/impl/full/state.go

@@ -82,7 +82,7 @@ func (a *StateAPI) StateMinerPeerID(ctx context.Context, m address.Address, ts *
 }
 
 func (a *StateAPI) StateMinerElectionPeriodStart(ctx context.Context, actor address.Address, ts *types.TipSet) (abi.ChainEpoch, error) {
-	return stmgr.GetMinerElectionPeriodStart(ctx, a.StateManager, ts, actor)
+	return stmgr.GetMinerPostState(ctx, a.StateManager, ts, actor)
 }
 
 func (a *StateAPI) StateMinerSectorSize(ctx context.Context, actor address.Address, ts *types.TipSet) (abi.SectorSize, error) {

storage/sealing/checks.go

@@ -3,6 +3,7 @@ package sealing
 import (
 	"context"
 
+	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/multiformats/go-multihash"
 	"golang.org/x/xerrors"
 
@@ -88,7 +89,7 @@ func checkSeal(ctx context.Context, maddr address.Address, si SectorInfo, api se
 		Value:    types.NewInt(0),
 		GasPrice: types.NewInt(0),
 		GasLimit: types.NewInt(9999999999),
-		Method:   actors.SMAMethods.ComputeDataCommitment,
+		Method:   builtin.MethodsMarket.ComputeDataCommitment,
 		Params:   ccparams,
 	}
 	r, err := api.StateCall(ctx, ccmt, nil)