refactor state utilities into StateManager package, implement proper election proofs

node/impl/full/state.go

@@ -5,15 +5,20 @@ import (
 	"fmt"
 	"strconv"
 
+	"github.com/filecoin-project/go-lotus/chain"
+	"github.com/filecoin-project/go-lotus/chain/gen"
+	"github.com/filecoin-project/go-lotus/chain/stmgr"
+	"github.com/filecoin-project/go-lotus/chain/store"
 	"github.com/filecoin-project/go-lotus/chain/types"
 	"github.com/filecoin-project/go-lotus/chain/vm"
+	"github.com/filecoin-project/go-lotus/chain/wallet"
+	"github.com/filecoin-project/go-lotus/lib/bufbstore"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-lotus/api"
 	"github.com/filecoin-project/go-lotus/chain/actors"
 	"github.com/filecoin-project/go-lotus/chain/address"
 	"github.com/filecoin-project/go-lotus/chain/state"
-	"github.com/filecoin-project/go-lotus/chain/store"
 
 	"github.com/ipfs/go-hamt-ipld"
 	cbor "github.com/ipfs/go-ipld-cbor"
@@ -23,18 +28,23 @@ import (
 type StateAPI struct {
 	fx.In
 
-	Chain *store.ChainStore
+	// TODO: the wallet here is only needed because we have the MinerCreateBlock
+	// API attached to the state API. It probably should live somewhere better
+	Wallet *wallet.Wallet
+
+	StateManager *stmgr.StateManager
+	Chain        *store.ChainStore
 }
 
 func (a *StateAPI) StateMinerSectors(ctx context.Context, addr address.Address) ([]*api.SectorInfo, error) {
-	ts := a.Chain.GetHeaviestTipSet()
+	ts := a.StateManager.ChainStore().GetHeaviestTipSet()
 
-	stc, err := a.Chain.TipSetState(ts.Cids())
+	stc, err := a.StateManager.TipSetState(ts.Cids())
 	if err != nil {
 		return nil, err
 	}
 
-	cst := hamt.CSTFromBstore(a.Chain.Blockstore())
+	cst := hamt.CSTFromBstore(a.StateManager.ChainStore().Blockstore())
 
 	st, err := state.LoadStateTree(cst, stc)
 	if err != nil {
@@ -87,7 +97,7 @@ func (a *StateAPI) StateMinerSectors(ctx context.Context, addr address.Address)
 func (a *StateAPI) StateMinerProvingSet(ctx context.Context, addr address.Address) ([]*api.SectorInfo, error) {
 	ts := a.Chain.GetHeaviestTipSet()
 
-	stc, err := a.Chain.TipSetState(ts.Cids())
+	stc, err := a.StateManager.TipSetState(ts.Cids())
 	if err != nil {
 		return nil, err
 	}
@@ -152,7 +162,7 @@ func (a *StateAPI) StateMinerPower(ctx context.Context, maddr address.Address, t
 	var mpow types.BigInt
 
 	if maddr != address.Undef {
-		ret, err := vm.Call(ctx, a.Chain, &types.Message{
+		ret, err := stmgr.Call(ctx, a.StateManager, &types.Message{
 			From:   maddr,
 			To:     actors.StorageMarketAddress,
 			Method: actors.SMAMethods.PowerLookup,
@@ -168,7 +178,7 @@ func (a *StateAPI) StateMinerPower(ctx context.Context, maddr address.Address, t
 		mpow = types.BigFromBytes(ret.Return)
 	}
 
-	ret, err := vm.Call(ctx, a.Chain, &types.Message{
+	ret, err := stmgr.Call(ctx, a.StateManager, &types.Message{
 		From:   actors.StorageMarketAddress,
 		To:     actors.StorageMarketAddress,
 		Method: actors.SMAMethods.GetTotalStorage,
@@ -189,7 +199,7 @@ func (a *StateAPI) StateMinerPower(ctx context.Context, maddr address.Address, t
 }
 
 func (a *StateAPI) StateMinerWorker(ctx context.Context, m address.Address, ts *types.TipSet) (address.Address, error) {
-	ret, err := vm.Call(ctx, a.Chain, &types.Message{
+	ret, err := stmgr.Call(ctx, a.StateManager, &types.Message{
 		From:   m,
 		To:     m,
 		Method: actors.MAMethods.GetWorkerAddr,
@@ -209,3 +219,72 @@ func (a *StateAPI) StateMinerWorker(ctx context.Context, m address.Address, ts *
 
 	return w, nil
 }
+
+func (a *StateAPI) StateCall(ctx context.Context, msg *types.Message, ts *types.TipSet) (*types.MessageReceipt, error) {
+	return stmgr.Call(ctx, a.StateManager, msg, ts)
+}
+
+func (a *StateAPI) stateForTs(ts *types.TipSet) (*state.StateTree, error) {
+	if ts == nil {
+		ts = a.Chain.GetHeaviestTipSet()
+	}
+
+	st, err := a.StateManager.TipSetState(ts.Cids())
+	if err != nil {
+		return nil, err
+	}
+
+	buf := bufbstore.NewBufferedBstore(a.Chain.Blockstore())
+	cst := hamt.CSTFromBstore(buf)
+	return state.LoadStateTree(cst, st)
+}
+
+func (a *StateAPI) StateGetActor(ctx context.Context, actor address.Address, ts *types.TipSet) (*types.Actor, error) {
+	state, err := a.stateForTs(ts)
+	if err != nil {
+		return nil, err
+	}
+
+	return state.GetActor(actor)
+}
+
+func (a *StateAPI) StateReadState(ctx context.Context, act *types.Actor, ts *types.TipSet) (*api.ActorState, error) {
+	state, err := a.stateForTs(ts)
+	if err != nil {
+		return nil, err
+	}
+
+	blk, err := state.Store.Blocks.GetBlock(ctx, act.Head)
+	if err != nil {
+		return nil, err
+	}
+
+	oif, err := vm.DumpActorState(act.Code, blk.RawData())
+	if err != nil {
+		return nil, err
+	}
+
+	return &api.ActorState{
+		Balance: act.Balance,
+		State:   oif,
+	}, nil
+}
+
+// This is on StateAPI because miner.Miner requires this, and MinerAPI requires miner.Miner
+func (a *StateAPI) MinerCreateBlock(ctx context.Context, addr address.Address, parents *types.TipSet, tickets []*types.Ticket, proof types.ElectionProof, msgs []*types.SignedMessage, ts uint64) (*chain.BlockMsg, error) {
+	fblk, err := gen.MinerCreateBlock(ctx, a.StateManager, a.Wallet, addr, parents, tickets, proof, msgs, ts)
+	if err != nil {
+		return nil, err
+	}
+
+	var out chain.BlockMsg
+	out.Header = fblk.Header
+	for _, msg := range fblk.BlsMessages {
+		out.BlsMessages = append(out.BlsMessages, msg.Cid())
+	}
+	for _, msg := range fblk.SecpkMessages {
+		out.SecpkMessages = append(out.SecpkMessages, msg.Cid())
+	}
+
+	return &out, nil
+}