diff --git a/api/api_full.go b/api/api_full.go
index 49878f8d1..985d2f279 100644
--- a/api/api_full.go
+++ b/api/api_full.go
@@ -120,10 +120,8 @@ type FullNode interface {
 	StateMinerSectors(context.Context, address.Address, *abi.BitField, types.TipSetKey) ([]*ChainSectorInfo, error)
 	StateMinerProvingSet(context.Context, address.Address, types.TipSetKey) ([]*ChainSectorInfo, error)
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*MinerPower, error)
-	StateMinerWorker(context.Context, address.Address, types.TipSetKey) (address.Address, error)
+	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error)
 	StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) (*miner.Deadlines, error)
-	StateMinerPeerID(ctx context.Context, m address.Address, tsk types.TipSetKey) (peer.ID, error)
-	StateMinerSectorSize(context.Context, address.Address, types.TipSetKey) (abi.SectorSize, error)
 	StateMinerFaults(context.Context, address.Address, types.TipSetKey) ([]abi.SectorNumber, error)
 	StateSectorPreCommitInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error)
 	StatePledgeCollateral(context.Context, types.TipSetKey) (types.BigInt, error)
diff --git a/api/apistruct/struct.go b/api/apistruct/struct.go
index 2e6be9f71..aeb0f3dac 100644
--- a/api/apistruct/struct.go
+++ b/api/apistruct/struct.go
@@ -116,9 +116,7 @@ type FullNodeStruct struct {
 		StateMinerSectors        func(context.Context, address.Address, *abi.BitField, types.TipSetKey) ([]*api.ChainSectorInfo, error)              `perm:"read"`
 		StateMinerProvingSet     func(context.Context, address.Address, types.TipSetKey) ([]*api.ChainSectorInfo, error)                             `perm:"read"`
 		StateMinerPower          func(context.Context, address.Address, types.TipSetKey) (*api.MinerPower, error)                                    `perm:"read"`
-		StateMinerWorker         func(context.Context, address.Address, types.TipSetKey) (address.Address, error)                                    `perm:"read"`
-		StateMinerPeerID         func(ctx context.Context, m address.Address, tsk types.TipSetKey) (peer.ID, error)                                  `perm:"read"`
-		StateMinerSectorSize     func(context.Context, address.Address, types.TipSetKey) (abi.SectorSize, error)                                     `perm:"read"`
+		StateMinerInfo     func(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error)                                     `perm:"read"`
 		StateMinerDeadlines      func(context.Context, address.Address, types.TipSetKey) (*miner.Deadlines, error)                                   `perm:"read"`
 		StateMinerFaults         func(context.Context, address.Address, types.TipSetKey) ([]abi.SectorNumber, error)                                 `perm:"read"`
 		StateSectorPreCommitInfo func(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) `perm:"read"`
@@ -492,16 +490,8 @@ func (c *FullNodeStruct) StateMinerPower(ctx context.Context, a address.Address,
 	return c.Internal.StateMinerPower(ctx, a, tsk)
 }
 
-func (c *FullNodeStruct) StateMinerWorker(ctx context.Context, m address.Address, tsk types.TipSetKey) (address.Address, error) {
-	return c.Internal.StateMinerWorker(ctx, m, tsk)
-}
-
-func (c *FullNodeStruct) StateMinerPeerID(ctx context.Context, m address.Address, tsk types.TipSetKey) (peer.ID, error) {
-	return c.Internal.StateMinerPeerID(ctx, m, tsk)
-}
-
-func (c *FullNodeStruct) StateMinerSectorSize(ctx context.Context, actor address.Address, tsk types.TipSetKey) (abi.SectorSize, error) {
-	return c.Internal.StateMinerSectorSize(ctx, actor, tsk)
+func (c *FullNodeStruct) StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error) {
+	return c.Internal.StateMinerInfo(ctx, actor, tsk)
 }
 
 func (c *FullNodeStruct) StateMinerDeadlines(ctx context.Context, m address.Address, tsk types.TipSetKey) (*miner.Deadlines, error) {
diff --git a/build/version.go b/build/version.go
index a0ee2aa93..b704f2e80 100644
--- a/build/version.go
+++ b/build/version.go
@@ -31,7 +31,7 @@ func (ve Version) EqMajorMinor(v2 Version) bool {
 }
 
 // APIVersion is a semver version of the rpc api exposed
-var APIVersion Version = newVer(0, 2, 0)
+var APIVersion Version = newVer(0, 3, 0)
 
 const (
 	majorMask = 0xff0000
diff --git a/chain/stmgr/utils.go b/chain/stmgr/utils.go
index 56df6f711..2c298a26e 100644
--- a/chain/stmgr/utils.go
+++ b/chain/stmgr/utils.go
@@ -25,7 +25,6 @@ import (
 	cid "github.com/ipfs/go-cid"
 	blockstore "github.com/ipfs/go-ipfs-blockstore"
 	cbor "github.com/ipfs/go-ipld-cbor"
-	"github.com/libp2p/go-libp2p-core/peer"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 )
@@ -56,22 +55,6 @@ func GetMinerWorkerRaw(ctx context.Context, sm *StateManager, st cid.Cid, maddr
 	return vm.ResolveToKeyAddr(state, cst, mas.Info.Worker)
 }
 
-func GetMinerOwner(ctx context.Context, sm *StateManager, st cid.Cid, maddr address.Address) (address.Address, error) {
-	var mas miner.State
-	_, err := sm.LoadActorStateRaw(ctx, maddr, &mas, st)
-	if err != nil {
-		return address.Undef, xerrors.Errorf("(get sset) failed to load miner actor state: %w", err)
-	}
-
-	cst := cbor.NewCborStore(sm.cs.Blockstore())
-	state, err := state.LoadStateTree(cst, st)
-	if err != nil {
-		return address.Undef, xerrors.Errorf("load state tree: %w", err)
-	}
-
-	return vm.ResolveToKeyAddr(state, cst, mas.Info.Owner)
-}
-
 func GetPower(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (types.BigInt, types.BigInt, error) {
 	return getPowerRaw(ctx, sm, ts.ParentState(), maddr)
 }
@@ -101,20 +84,6 @@ func getPowerRaw(ctx context.Context, sm *StateManager, st cid.Cid, maddr addres
 	return mpow, ps.TotalQualityAdjPower, nil
 }
 
-func GetMinerPeerID(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (peer.ID, error) {
-	var mas miner.State
-	_, err := sm.LoadActorState(ctx, maddr, &mas, ts)
-	if err != nil {
-		return "", xerrors.Errorf("(get sset) failed to load miner actor state: %w", err)
-	}
-
-	return mas.Info.PeerId, nil
-}
-
-func GetMinerWorker(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (address.Address, error) {
-	return GetMinerWorkerRaw(ctx, sm, sm.parentState(ts), maddr)
-}
-
 func SectorSetSizes(ctx context.Context, sm *StateManager, maddr address.Address, ts *types.TipSet) (api.MinerSectors, error) {
 	var mas miner.State
 	_, err := sm.LoadActorState(ctx, maddr, &mas, ts)
@@ -161,8 +130,14 @@ func GetMinerSectorSet(ctx context.Context, sm *StateManager, ts *types.TipSet,
 	return LoadSectorsFromSet(ctx, sm.ChainStore().Blockstore(), mas.Sectors, filter)
 }
 
-func GetMinerSectorSize(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (abi.SectorSize, error) {
-	return getMinerSectorSizeRaw(ctx, sm, ts.ParentState(), maddr)
+func StateMinerInfo(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (miner.MinerInfo, error) {
+	var mas miner.State
+	_, err := sm.LoadActorStateRaw(ctx, maddr, &mas, ts.ParentState())
+	if err != nil {
+		return miner.MinerInfo{}, xerrors.Errorf("(get ssize) failed to load miner actor state: %w", err)
+	}
+
+	return mas.Info, nil
 }
 
 func getMinerSectorSizeRaw(ctx context.Context, sm *StateManager, st cid.Cid, maddr address.Address) (abi.SectorSize, error) {
diff --git a/cli/client.go b/cli/client.go
index 9f6b12e69..3ea509103 100644
--- a/cli/client.go
+++ b/cli/client.go
@@ -375,16 +375,16 @@ var clientQueryAskCmd = &cli.Command{
 			}
 			pid = p
 		} else {
-			p, err := api.StateMinerPeerID(ctx, maddr, types.EmptyTSK)
+			mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
 			if err != nil {
 				return xerrors.Errorf("failed to get peerID for miner: %w", err)
 			}
 
-			if p == peer.ID("SETME") {
+			if mi.PeerId == peer.ID("SETME") {
 				return fmt.Errorf("the miner hasn't initialized yet")
 			}
 
-			pid = p
+			pid = mi.PeerId
 		}
 
 		ask, err := api.ClientQueryAsk(ctx, pid, maddr)
diff --git a/cli/state.go b/cli/state.go
index 3abb8f23b..c5dbe6257 100644
--- a/cli/state.go
+++ b/cli/state.go
@@ -594,12 +594,12 @@ var stateSectorSizeCmd = &cli.Command{
 			return err
 		}
 
-		ssize, err := api.StateMinerSectorSize(ctx, addr, ts.Key())
+		mi, err := api.StateMinerInfo(ctx, addr, ts.Key())
 		if err != nil {
 			return err
 		}
 
-		fmt.Printf("%d\n", ssize)
+		fmt.Printf("%d\n", mi.SectorSize)
 		return nil
 	},
 }
diff --git a/cmd/lotus-storage-miner/info.go b/cmd/lotus-storage-miner/info.go
index d725c0871..404176cbd 100644
--- a/cmd/lotus-storage-miner/info.go
+++ b/cmd/lotus-storage-miner/info.go
@@ -38,12 +38,12 @@ var infoCmd = &cli.Command{
 		fmt.Printf("Miner: %s\n", maddr)
 
 		// Sector size
-		sizeByte, err := api.StateMinerSectorSize(ctx, maddr, types.EmptyTSK)
+		mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
 		if err != nil {
 			return err
 		}
 
-		fmt.Printf("Sector Size: %s\n", types.SizeStr(types.NewInt(uint64(sizeByte))))
+		fmt.Printf("Sector Size: %s\n", types.SizeStr(types.NewInt(uint64(mi.SectorSize))))
 
 		pow, err := api.StateMinerPower(ctx, maddr, types.EmptyTSK)
 		if err != nil {
@@ -62,13 +62,13 @@ var infoCmd = &cli.Command{
 			return err
 		}
 
-		fmt.Printf("\tCommitted: %s\n", types.SizeStr(types.BigMul(types.NewInt(secCounts.Sset), types.NewInt(uint64(sizeByte)))))
+		fmt.Printf("\tCommitted: %s\n", types.SizeStr(types.BigMul(types.NewInt(secCounts.Sset), types.NewInt(uint64(mi.SectorSize)))))
 		if len(faults) == 0 {
-			fmt.Printf("\tProving: %s\n", types.SizeStr(types.BigMul(types.NewInt(secCounts.Pset), types.NewInt(uint64(sizeByte)))))
+			fmt.Printf("\tProving: %s\n", types.SizeStr(types.BigMul(types.NewInt(secCounts.Pset), types.NewInt(uint64(mi.SectorSize)))))
 		} else {
 			fmt.Printf("\tProving: %s (%s Faulty, %.2f%%)\n",
-				types.SizeStr(types.BigMul(types.NewInt(secCounts.Pset-uint64(len(faults))), types.NewInt(uint64(sizeByte)))),
-				types.SizeStr(types.BigMul(types.NewInt(uint64(len(faults))), types.NewInt(uint64(sizeByte)))),
+				types.SizeStr(types.BigMul(types.NewInt(secCounts.Pset-uint64(len(faults))), types.NewInt(uint64(mi.SectorSize)))),
+				types.SizeStr(types.BigMul(types.NewInt(uint64(len(faults))), types.NewInt(uint64(mi.SectorSize)))),
 				float64(10000*uint64(len(faults))/secCounts.Pset)/100.)
 		}
 
diff --git a/cmd/lotus-storage-miner/init.go b/cmd/lotus-storage-miner/init.go
index b96eb8bd1..2f3c5e663 100644
--- a/cmd/lotus-storage-miner/init.go
+++ b/cmd/lotus-storage-miner/init.go
@@ -544,7 +544,7 @@ func makeHostKey(lr repo.LockedRepo) (crypto.PrivKey, error) {
 }
 
 func configureStorageMiner(ctx context.Context, api lapi.FullNode, addr address.Address, peerid peer.ID, gasPrice types.BigInt) error {
-	waddr, err := api.StateMinerWorker(ctx, addr, types.EmptyTSK)
+	mi, err := api.StateMinerInfo(ctx, addr, types.EmptyTSK)
 	if err != nil {
 		return xerrors.Errorf("getWorkerAddr returned bad address: %w", err)
 	}
@@ -556,7 +556,7 @@ func configureStorageMiner(ctx context.Context, api lapi.FullNode, addr address.
 
 	msg := &types.Message{
 		To:       addr,
-		From:     waddr,
+		From:     mi.Worker,
 		Method:   builtin.MethodsMiner.ChangePeerID,
 		Params:   enc,
 		Value:    types.NewInt(0),
diff --git a/cmd/lotus-storage-miner/rewards.go b/cmd/lotus-storage-miner/rewards.go
index 83c6eecf2..12743a8da 100644
--- a/cmd/lotus-storage-miner/rewards.go
+++ b/cmd/lotus-storage-miner/rewards.go
@@ -42,7 +42,7 @@ var rewardsRedeemCmd = &cli.Command{
 			return err
 		}
 
-		worker, err := api.StateMinerWorker(ctx, maddr, types.EmptyTSK)
+		mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
 		if err != nil {
 			return err
 		}
@@ -52,16 +52,16 @@ var rewardsRedeemCmd = &cli.Command{
 			return err
 		}
 
-		workerNonce, err := api.MpoolGetNonce(ctx, worker)
+		workerNonce, err := api.MpoolGetNonce(ctx, mi.Worker)
 		if err != nil {
 			return err
 		}
 
 		panic("todo correct method; call miner actor")
 
-		smsg, err := api.WalletSignMessage(ctx, worker, &types.Message{
+		smsg, err := api.WalletSignMessage(ctx, mi.Worker, &types.Message{
 			To:       builtin.RewardActorAddr,
-			From:     worker,
+			From:     mi.Worker,
 			Nonce:    workerNonce,
 			Value:    types.NewInt(0),
 			GasPrice: types.NewInt(1),
diff --git a/markets/retrievaladapter/provider.go b/markets/retrievaladapter/provider.go
index a4133a751..1917d8119 100644
--- a/markets/retrievaladapter/provider.go
+++ b/markets/retrievaladapter/provider.go
@@ -35,8 +35,8 @@ func (rpn *retrievalProviderNode) GetMinerWorkerAddress(ctx context.Context, min
 		return address.Undef, err
 	}
 
-	addr, err := rpn.full.StateMinerWorker(ctx, miner, tsk)
-	return addr, err
+	mi, err := rpn.full.StateMinerInfo(ctx, miner, tsk)
+	return mi.Worker, err
 }
 
 func (rpn *retrievalProviderNode) UnsealSector(ctx context.Context, sectorID uint64, offset uint64, length uint64) (io.ReadCloser, error) {
diff --git a/markets/storageadapter/client.go b/markets/storageadapter/client.go
index 91e589c09..33b624364 100644
--- a/markets/storageadapter/client.go
+++ b/markets/storageadapter/client.go
@@ -72,21 +72,12 @@ func (n *ClientNodeAdapter) ListStorageProviders(ctx context.Context, encodedTs
 	var out []*storagemarket.StorageProviderInfo
 
 	for _, addr := range addresses {
-		workerAddr, err := n.StateMinerWorker(ctx, addr, tsk)
+		mi, err := n.StateMinerInfo(ctx, addr, tsk)
 		if err != nil {
 			return nil, err
 		}
 
-		sectorSize, err := n.StateMinerSectorSize(ctx, addr, tsk)
-		if err != nil {
-			return nil, err
-		}
-
-		peerID, err := n.StateMinerPeerID(ctx, addr, tsk)
-		if err != nil {
-			return nil, err
-		}
-		storageProviderInfo := utils.NewStorageProviderInfo(addr, workerAddr, sectorSize, peerID)
+		storageProviderInfo := utils.NewStorageProviderInfo(addr, mi.Worker, mi.SectorSize, mi.PeerId)
 		out = append(out, &storageProviderInfo)
 	}
 
@@ -176,12 +167,12 @@ func (c *ClientNodeAdapter) ValidatePublishedDeal(ctx context.Context, deal stor
 		return 0, xerrors.Errorf("getting deal pubsish message: %w", err)
 	}
 
-	pw, err := stmgr.GetMinerWorker(ctx, c.sm, nil, deal.Proposal.Provider)
+	mi, err := stmgr.StateMinerInfo(ctx, c.sm, nil, deal.Proposal.Provider)
 	if err != nil {
 		return 0, xerrors.Errorf("getting miner worker failed: %w", err)
 	}
 
-	if pubmsg.From != pw {
+	if pubmsg.From != mi.Worker {
 		return 0, xerrors.Errorf("deal wasn't published by storage provider: from=%s, provider=%s", pubmsg.From, deal.Proposal.Provider)
 	}
 
@@ -363,7 +354,7 @@ func (n *ClientNodeAdapter) ValidateAskSignature(ctx context.Context, ask *stora
 		return false, err
 	}
 
-	w, err := n.StateMinerWorker(ctx, ask.Ask.Miner, tsk)
+	mi, err := n.StateMinerInfo(ctx, ask.Ask.Miner, tsk)
 	if err != nil {
 		return false, xerrors.Errorf("failed to get worker for miner in ask", err)
 	}
@@ -373,7 +364,7 @@ func (n *ClientNodeAdapter) ValidateAskSignature(ctx context.Context, ask *stora
 		return false, xerrors.Errorf("failed to re-serialize ask")
 	}
 
-	err = sigs.Verify(ask.Signature, w, sigb)
+	err = sigs.Verify(ask.Signature, mi.Worker, sigb)
 	return err == nil, err
 }
 
diff --git a/markets/storageadapter/provider.go b/markets/storageadapter/provider.go
index 3bd146a68..14a8a3a85 100644
--- a/markets/storageadapter/provider.go
+++ b/markets/storageadapter/provider.go
@@ -56,7 +56,7 @@ func NewProviderNodeAdapter(dag dtypes.StagingDAG, secb *sectorblocks.SectorBloc
 func (n *ProviderNodeAdapter) PublishDeals(ctx context.Context, deal storagemarket.MinerDeal) (abi.DealID, cid.Cid, error) {
 	log.Info("publishing deal")
 
-	worker, err := n.StateMinerWorker(ctx, deal.Proposal.Provider, types.EmptyTSK)
+	mi, err := n.StateMinerInfo(ctx, deal.Proposal.Provider, types.EmptyTSK)
 	if err != nil {
 		return 0, cid.Undef, err
 	}
@@ -72,7 +72,7 @@ func (n *ProviderNodeAdapter) PublishDeals(ctx context.Context, deal storagemark
 	// TODO: We may want this to happen after fetching data
 	smsg, err := n.MpoolPushMessage(ctx, &types.Message{
 		To:       builtin.StorageMarketActorAddr,
-		From:     worker,
+		From:     mi.Worker,
 		Value:    types.NewInt(0),
 		GasPrice: types.NewInt(0),
 		GasLimit: 1000000,
@@ -150,7 +150,11 @@ func (n *ProviderNodeAdapter) GetMinerWorkerAddress(ctx context.Context, miner a
 		return address.Undef, err
 	}
 
-	return n.StateMinerWorker(ctx, miner, tsk)
+	mi, err := n.StateMinerInfo(ctx, miner, tsk)
+	if err != nil {
+		return address.Address{}, err
+	}
+	return mi.Worker, nil
 }
 
 func (n *ProviderNodeAdapter) SignBytes(ctx context.Context, signer address.Address, b []byte) (*crypto.Signature, error) {
diff --git a/miner/miner.go b/miner/miner.go
index 2d4131794..6a0773d25 100644
--- a/miner/miner.go
+++ b/miner/miner.go
@@ -361,7 +361,7 @@ func (m *Miner) mineOne(ctx context.Context, addr address.Address, base *MiningB
 }
 
 func (m *Miner) computeTicket(ctx context.Context, addr address.Address, brand *types.BeaconEntry, base *MiningBase) (*types.Ticket, error) {
-	w, err := m.api.StateMinerWorker(ctx, addr, types.EmptyTSK)
+	mi, err := m.api.StateMinerInfo(ctx, addr, types.EmptyTSK)
 	if err != nil {
 		return nil, err
 	}
@@ -376,7 +376,7 @@ func (m *Miner) computeTicket(ctx context.Context, addr address.Address, brand *
 		return nil, err
 	}
 
-	vrfOut, err := gen.ComputeVRF(ctx, m.api.WalletSign, w, input)
+	vrfOut, err := gen.ComputeVRF(ctx, m.api.WalletSign, mi.Worker, input)
 	if err != nil {
 		return nil, err
 	}
diff --git a/node/impl/client/client.go b/node/impl/client/client.go
index c37e3eeeb..47658bde3 100644
--- a/node/impl/client/client.go
+++ b/node/impl/client/client.go
@@ -70,27 +70,17 @@ func (a *API) ClientStartDeal(ctx context.Context, params *api.StartDealParams)
 		return nil, xerrors.Errorf("provided address doesn't exist in wallet")
 	}
 
-	pid, err := a.StateMinerPeerID(ctx, params.Miner, types.EmptyTSK)
+	mi, err := a.StateMinerInfo(ctx, params.Miner, types.EmptyTSK)
 	if err != nil {
 		return nil, xerrors.Errorf("failed getting peer ID: %w", err)
 	}
 
-	mw, err := a.StateMinerWorker(ctx, params.Miner, types.EmptyTSK)
-	if err != nil {
-		return nil, xerrors.Errorf("failed getting miner worker: %w", err)
-	}
-
-	ssize, err := a.StateMinerSectorSize(ctx, params.Miner, types.EmptyTSK)
-	if err != nil {
-		return nil, xerrors.Errorf("failed checking miners sector size: %w", err)
-	}
-
-	rt, err := ffiwrapper.SealProofTypeFromSectorSize(ssize)
+	rt, err := ffiwrapper.SealProofTypeFromSectorSize(mi.SectorSize)
 	if err != nil {
 		return nil, xerrors.Errorf("bad sector size: %w", err)
 	}
 
-	providerInfo := utils.NewStorageProviderInfo(params.Miner, mw, 0, pid)
+	providerInfo := utils.NewStorageProviderInfo(params.Miner, mi.Worker, 0, mi.PeerId)
 	ts, err := a.ChainHead(ctx)
 	if err != nil {
 		return nil, xerrors.Errorf("failed getting chain height: %w", err)
@@ -333,12 +323,12 @@ func (a *API) ClientListImports(ctx context.Context) ([]api.Import, error) {
 
 func (a *API) ClientRetrieve(ctx context.Context, order api.RetrievalOrder, ref api.FileRef) error {
 	if order.MinerPeerID == "" {
-		pid, err := a.StateMinerPeerID(ctx, order.Miner, types.EmptyTSK)
+		mi, err := a.StateMinerInfo(ctx, order.Miner, types.EmptyTSK)
 		if err != nil {
 			return err
 		}
 
-		order.MinerPeerID = pid
+		order.MinerPeerID = mi.PeerId
 	}
 
 	if order.Size == 0 {
diff --git a/node/impl/full/state.go b/node/impl/full/state.go
index 9cf850f49..f393debda 100644
--- a/node/impl/full/state.go
+++ b/node/impl/full/state.go
@@ -9,7 +9,6 @@ import (
 	cid "github.com/ipfs/go-cid"
 	"github.com/ipfs/go-hamt-ipld"
 	cbor "github.com/ipfs/go-ipld-cbor"
-	"github.com/libp2p/go-libp2p-core/peer"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"go.uber.org/fx"
 	"golang.org/x/xerrors"
@@ -72,28 +71,12 @@ func (a *StateAPI) StateMinerProvingSet(ctx context.Context, addr address.Addres
 	return stmgr.GetProvingSetRaw(ctx, a.StateManager, mas)
 }
 
-func (a *StateAPI) StateMinerWorker(ctx context.Context, m address.Address, tsk types.TipSetKey) (address.Address, error) {
+func (a *StateAPI) StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error) {
 	ts, err := a.Chain.GetTipSetFromKey(tsk)
 	if err != nil {
-		return address.Undef, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+		return miner.MinerInfo{}, xerrors.Errorf("loading tipset %s: %w", tsk, err)
 	}
-	return stmgr.GetMinerWorker(ctx, a.StateManager, ts, m)
-}
-
-func (a *StateAPI) StateMinerPeerID(ctx context.Context, m address.Address, tsk types.TipSetKey) (peer.ID, error) {
-	ts, err := a.Chain.GetTipSetFromKey(tsk)
-	if err != nil {
-		return "", xerrors.Errorf("loading tipset %s: %w", tsk, err)
-	}
-	return stmgr.GetMinerPeerID(ctx, a.StateManager, ts, m)
-}
-
-func (a *StateAPI) StateMinerSectorSize(ctx context.Context, actor address.Address, tsk types.TipSetKey) (abi.SectorSize, error) {
-	ts, err := a.Chain.GetTipSetFromKey(tsk)
-	if err != nil {
-		return 0, xerrors.Errorf("loading tipset %s: %w", tsk, err)
-	}
-	return stmgr.GetMinerSectorSize(ctx, a.StateManager, ts, actor)
+	return stmgr.StateMinerInfo(ctx, a.StateManager, ts, actor)
 }
 
 func (a *StateAPI) StateMinerDeadlines(ctx context.Context, m address.Address, tsk types.TipSetKey) (*miner.Deadlines, error) {
diff --git a/node/impl/storminer.go b/node/impl/storminer.go
index 0ee0799e4..db06bb6d1 100644
--- a/node/impl/storminer.go
+++ b/node/impl/storminer.go
@@ -60,7 +60,11 @@ func (sm *StorageMinerAPI) ActorAddress(context.Context) (address.Address, error
 }
 
 func (sm *StorageMinerAPI) ActorSectorSize(ctx context.Context, addr address.Address) (abi.SectorSize, error) {
-	return sm.Full.StateMinerSectorSize(ctx, addr, types.EmptyTSK)
+	mi, err := sm.Full.StateMinerInfo(ctx, addr, types.EmptyTSK)
+	if err != nil {
+		return 0, err
+	}
+	return mi.SectorSize, nil
 }
 
 func (sm *StorageMinerAPI) PledgeSector(ctx context.Context) error {
diff --git a/node/modules/storageminer.go b/node/modules/storageminer.go
index 0aa3c18d2..9e31e452f 100644
--- a/node/modules/storageminer.go
+++ b/node/modules/storageminer.go
@@ -91,12 +91,12 @@ func StorageNetworkName(ctx helpers.MetricsCtx, a lapi.FullNode) (dtypes.Network
 }
 
 func ProofsConfig(maddr dtypes.MinerAddress, fnapi lapi.FullNode) (*ffiwrapper.Config, error) {
-	ssize, err := fnapi.StateMinerSectorSize(context.TODO(), address.Address(maddr), types.EmptyTSK)
+	mi, err := fnapi.StateMinerInfo(context.TODO(), address.Address(maddr), types.EmptyTSK)
 	if err != nil {
 		return nil, err
 	}
 
-	spt, err := ffiwrapper.SealProofTypeFromSectorSize(ssize)
+	spt, err := ffiwrapper.SealProofTypeFromSectorSize(mi.SectorSize)
 	if err != nil {
 		return nil, xerrors.Errorf("bad sector size: %w", err)
 	}
@@ -130,17 +130,17 @@ func StorageMiner(mctx helpers.MetricsCtx, lc fx.Lifecycle, api lapi.FullNode, h
 
 	ctx := helpers.LifecycleCtx(mctx, lc)
 
-	worker, err := api.StateMinerWorker(ctx, maddr, types.EmptyTSK)
+	mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
 	if err != nil {
 		return nil, err
 	}
 
-	fps, err := storage.NewWindowedPoStScheduler(api, sealer, maddr, worker)
+	fps, err := storage.NewWindowedPoStScheduler(api, sealer, maddr, mi.Worker)
 	if err != nil {
 		return nil, err
 	}
 
-	sm, err := storage.NewMiner(api, maddr, worker, h, ds, sealer, sc, verif, tktFn)
+	sm, err := storage.NewMiner(api, maddr, mi.Worker, h, ds, sealer, sc, verif, tktFn)
 	if err != nil {
 		return nil, err
 	}
@@ -317,12 +317,12 @@ func StorageProvider(ctx helpers.MetricsCtx, fapi lapi.FullNode, h host.Host, ds
 		return nil, err
 	}
 
-	ssize, err := fapi.StateMinerSectorSize(ctx, minerAddress, types.EmptyTSK)
+	mi, err := fapi.StateMinerInfo(ctx, minerAddress, types.EmptyTSK)
 	if err != nil {
 		return nil, err
 	}
 
-	rt, err := ffiwrapper.SealProofTypeFromSectorSize(ssize)
+	rt, err := ffiwrapper.SealProofTypeFromSectorSize(mi.SectorSize)
 	if err != nil {
 		return nil, err
 	}
diff --git a/storage/adapter_storage_miner.go b/storage/adapter_storage_miner.go
index c256519de..e8d0e090d 100644
--- a/storage/adapter_storage_miner.go
+++ b/storage/adapter_storage_miner.go
@@ -40,7 +40,12 @@ func (s SealingAPIAdapter) StateMinerSectorSize(ctx context.Context, maddr addre
 		return 0, xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err)
 	}
 
-	return s.delegate.StateMinerSectorSize(ctx, maddr, tsk)
+	// TODO: update storage-fsm to just StateMinerInfo
+	mi, err := s.delegate.StateMinerInfo(ctx, maddr, tsk)
+	if err != nil {
+		return 0, err
+	}
+	return mi.SectorSize, nil
 }
 
 func (s SealingAPIAdapter) StateMinerWorkerAddress(ctx context.Context, maddr address.Address, tok sealing.TipSetToken) (address.Address, error) {
@@ -49,7 +54,12 @@ func (s SealingAPIAdapter) StateMinerWorkerAddress(ctx context.Context, maddr ad
 		return address.Undef, xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err)
 	}
 
-	return s.delegate.StateMinerWorker(ctx, maddr, tsk)
+	// TODO: update storage-fsm to just StateMinerInfo
+	mi, err := s.delegate.StateMinerInfo(ctx, maddr, tsk)
+	if err != nil {
+		return address.Undef, err
+	}
+	return mi.Worker, nil
 }
 
 func (s SealingAPIAdapter) StateMinerDeadlines(ctx context.Context, maddr address.Address, tok sealing.TipSetToken) (*miner.Deadlines, error) {
diff --git a/storage/miner.go b/storage/miner.go
index 7b4fdc88d..4c9b66f16 100644
--- a/storage/miner.go
+++ b/storage/miner.go
@@ -49,11 +49,10 @@ type Miner struct {
 type storageMinerApi interface {
 	// Call a read only method on actors (no interaction with the chain required)
 	StateCall(context.Context, *types.Message, types.TipSetKey) (*api.InvocResult, error)
-	StateMinerWorker(context.Context, address.Address, types.TipSetKey) (address.Address, error)
 	StateMinerDeadlines(ctx context.Context, maddr address.Address, tok types.TipSetKey) (*miner.Deadlines, error)
 	StateMinerSectors(context.Context, address.Address, *abi.BitField, types.TipSetKey) ([]*api.ChainSectorInfo, error)
-	StateMinerSectorSize(context.Context, address.Address, types.TipSetKey) (abi.SectorSize, error)
 	StateSectorPreCommitInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error)
+	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error)
 	StateWaitMsg(context.Context, cid.Cid) (*api.MsgLookup, error) // TODO: removeme eventually
 	StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error)
 	StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error)
@@ -138,12 +137,12 @@ func NewWinningPoStProver(api api.FullNode, sb storage.Prover, miner dtypes.Mine
 		return nil, err
 	}
 
-	mss, err := api.StateMinerSectorSize(context.TODO(), ma, types.EmptyTSK)
+	mi, err := api.StateMinerInfo(context.TODO(), ma, types.EmptyTSK)
 	if err != nil {
 		return nil, xerrors.Errorf("getting sector size: %w", err)
 	}
 
-	spt, err := ffiwrapper.SealProofTypeFromSectorSize(mss)
+	spt, err := ffiwrapper.SealProofTypeFromSectorSize(mi.SectorSize)
 	if err != nil {
 		return nil, err
 	}
diff --git a/storage/wdpost_sched.go b/storage/wdpost_sched.go
index 0a2243462..3288a7e78 100644
--- a/storage/wdpost_sched.go
+++ b/storage/wdpost_sched.go
@@ -37,12 +37,12 @@ type WindowPoStScheduler struct {
 }
 
 func NewWindowedPoStScheduler(api storageMinerApi, sb storage.Prover, actor address.Address, worker address.Address) (*WindowPoStScheduler, error) {
-	mss, err := api.StateMinerSectorSize(context.TODO(), actor, types.EmptyTSK)
+	mi, err := api.StateMinerInfo(context.TODO(), actor, types.EmptyTSK)
 	if err != nil {
 		return nil, xerrors.Errorf("getting sector size: %w", err)
 	}
 
-	spt, err := ffiwrapper.SealProofTypeFromSectorSize(mss)
+	spt, err := ffiwrapper.SealProofTypeFromSectorSize(mi.SectorSize)
 	if err != nil {
 		return nil, err
 	}