More terraforming in chain/

chain/actors/builtin/power/power.go

@@ -1,6 +1,7 @@
 package power
 
 import (
+	"github.com/filecoin-project/go-address"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-state-types/abi"
@@ -28,4 +29,5 @@ type State interface {
 	cbor.Marshaler
 
 	TotalLocked() (abi.TokenAmount, error)
+	MinerNominalPowerMeetsConsensusMinimum(adt.Store, address.Address) (bool, error)
 }

chain/actors/builtin/power/v0.go

@@ -1,6 +1,7 @@
 package power
 
 import (
+	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/specs-actors/actors/builtin/power"
@@ -14,3 +15,7 @@ type v0State struct {
 func (s *v0State) TotalLocked() (abi.TokenAmount, error) {
 	return s.TotalPledgeCollateral, nil
 }
+
+func (s *v0State) MinerNominalPowerMeetsConsensusMinimum(st adt.Store, a address.Address) (bool, error) {
+	return s.State.MinerNominalPowerMeetsConsensusMinimum(st, a)
+}

chain/gen/genesis/genesis.go

@@ -17,7 +17,6 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"
-	"github.com/filecoin-project/go-state-types/network"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/account"
 	"github.com/filecoin-project/specs-actors/actors/builtin/multisig"
@@ -115,7 +114,7 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
 		return nil, nil, xerrors.Errorf("putting empty object: %w", err)
 	}
 
-	state, err := state.NewStateTree(cst)
+	state, err := state.NewStateTree(cst, GenesisNetworkVersion)
 	if err != nil {
 		return nil, nil, xerrors.Errorf("making new state tree: %w", err)
 	}
@@ -405,10 +404,6 @@ func VerifyPreSealedData(ctx context.Context, cs *store.ChainStore, stateroot ci
 	verifNeeds := make(map[address.Address]abi.PaddedPieceSize)
 	var sum abi.PaddedPieceSize
 
-	nwv := func(context.Context, abi.ChainEpoch) network.Version {
-		return network.Version1
-	}
-
 	vmopt := vm.VMOpts{
 		StateBase:      stateroot,
 		Epoch:          0,
@@ -416,10 +411,10 @@ func VerifyPreSealedData(ctx context.Context, cs *store.ChainStore, stateroot ci
 		Bstore:         cs.Blockstore(),
 		Syscalls:       mkFakedSigSyscalls(cs.VMSys()),
 		CircSupplyCalc: nil,
-		NtwkVersion:    nwv,
+		NtwkVersion:    genesisNetworkVersion,
 		BaseFee:        types.NewInt(0),
 	}
-	vm, err := vm.NewVM(&vmopt)
+	vm, err := vm.NewVM(ctx, &vmopt)
 	if err != nil {
 		return cid.Undef, xerrors.Errorf("failed to create NewVM: %w", err)
 	}

chain/gen/genesis/miners.go

@@ -61,10 +61,6 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 		return big.Zero(), nil
 	}
 
-	nwv := func(context.Context, abi.ChainEpoch) network.Version {
-		return network.Version1
-	}
-
 	vmopt := &vm.VMOpts{
 		StateBase:      sroot,
 		Epoch:          0,
@@ -72,11 +68,11 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 		Bstore:         cs.Blockstore(),
 		Syscalls:       mkFakedSigSyscalls(cs.VMSys()),
 		CircSupplyCalc: csc,
-		NtwkVersion:    nwv,
+		NtwkVersion:    genesisNetworkVersion,
 		BaseFee:        types.NewInt(0),
 	}
 
-	vm, err := vm.NewVM(vmopt)
+	vm, err := vm.NewVM(ctx, vmopt)
 	if err != nil {
 		return cid.Undef, xerrors.Errorf("failed to create NewVM: %w", err)
 	}

chain/gen/genesis/util.go

@@ -2,6 +2,7 @@ package genesis
 
 import (
 	"context"
+	"github.com/filecoin-project/go-state-types/network"
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
@@ -46,3 +47,8 @@ func doExecValue(ctx context.Context, vm *vm.VM, to, from address.Address, value
 
 	return ret.Return, nil
 }
+
+var GenesisNetworkVersion = network.Version1
+func genesisNetworkVersion(context.Context, abi.ChainEpoch) network.Version {
+	return GenesisNetworkVersion // TODO: Get from build/
+}

chain/stmgr/call.go

@@ -33,7 +33,7 @@ func (sm *StateManager) CallRaw(ctx context.Context, msg *types.Message, bstate
 		BaseFee:        types.NewInt(0),
 	}
 
-	vmi, err := vm.NewVM(vmopt)
+	vmi, err := vm.NewVM(ctx, vmopt)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to set up vm: %w", err)
 	}
@@ -134,7 +134,7 @@ func (sm *StateManager) CallWithGas(ctx context.Context, msg *types.Message, pri
 		NtwkVersion:    sm.GetNtwkVersion,
 		BaseFee:        ts.Blocks()[0].ParentBaseFee,
 	}
-	vmi, err := vm.NewVM(vmopt)
+	vmi, err := vm.NewVM(ctx, vmopt)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to set up vm: %w", err)
 	}

chain/stmgr/forks.go

@@ -7,11 +7,10 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
-	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	v0miner "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	"github.com/filecoin-project/specs-actors/actors/builtin/power"
+	v0power "github.com/filecoin-project/specs-actors/actors/builtin/power"
 	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	"golang.org/x/xerrors"
@@ -96,11 +95,8 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
 		return xerrors.Errorf("failed to get tipset at lookback height: %w", err)
 	}
 
-	var lbtree *state.StateTree
+	lbtree, err := sm.ParentState(lbts)
-	if err = sm.WithStateTree(lbts.ParentState(), func(state *state.StateTree) error {
+	if err != nil {
-		lbtree = state
-		return nil
-	}); err != nil {
 		return xerrors.Errorf("loading state tree failed: %w", err)
 	}
 
@@ -139,8 +135,8 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
 				})
 			}
 		case builtin.StorageMinerActorCodeID:
-			var st miner.State
+			var st v0miner.State
-			if err := sm.WithActorState(ctx, &st)(act); err != nil {
+			if err := sm.ChainStore().Store(ctx).Get(ctx, act.Head, &st); err != nil {
 				return xerrors.Errorf("failed to load miner state: %w", err)
 			}
 
@@ -176,7 +172,7 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
 	}
 
 	// pull up power table to give miners back some funds proportional to their power
-	var ps power.State
+	var ps v0power.State
 	powAct, err := tree.GetActor(builtin.StoragePowerActorAddr)
 	if err != nil {
 		return xerrors.Errorf("failed to load power actor: %w", err)
@@ -215,12 +211,12 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
 				})
 			}
 		case builtin.StorageMinerActorCodeID:
-			var st miner.State
+			var st v0miner.State
-			if err := sm.WithActorState(ctx, &st)(act); err != nil {
+			if err := sm.ChainStore().Store(ctx).Get(ctx, act.Head, &st); err != nil {
 				return xerrors.Errorf("failed to load miner state: %w", err)
 			}
 
-			var minfo miner.MinerInfo
+			var minfo v0miner.MinerInfo
 			if err := cst.Get(ctx, st.Info, &minfo); err != nil {
 				return xerrors.Errorf("failed to get miner info: %w", err)
 			}
@@ -244,8 +240,8 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
 			// Now make sure to give each miner who had power at the lookback some FIL
 			lbact, err := lbtree.GetActor(addr)
 			if err == nil {
-				var lbst miner.State
+				var lbst v0miner.State
-				if err := sm.WithActorState(ctx, &lbst)(lbact); err != nil {
+				if err := sm.ChainStore().Store(ctx).Get(ctx, lbact.Head, &lbst); err != nil {
 					return xerrors.Errorf("failed to load miner state: %w", err)
 				}
 

chain/stmgr/read.go

@@ -2,8 +2,6 @@ package stmgr
 
 import (
 	"context"
-	"reflect"
-
 	"golang.org/x/xerrors"
 
 	"github.com/ipfs/go-cid"
@@ -13,8 +11,6 @@ import (
 	"github.com/filecoin-project/go-state-types/network"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
 )
 
 func (sm *StateManager) ParentStateTsk(tsk types.TipSetKey) (*state.StateTree, error) {
@@ -22,7 +18,7 @@ func (sm *StateManager) ParentStateTsk(tsk types.TipSetKey) (*state.StateTree, e
 	if err != nil {
 		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
 	}
-	return sm.ParentState(ts, cb)
+	return sm.ParentState(ts)
 }
 
 func (sm *StateManager) ParentState(ts *types.TipSet) (*state.StateTree, error) {

chain/stmgr/stmgr.go

@@ -41,7 +41,7 @@ type StateManager struct {
 	compWait      map[string]chan struct{}
 	stlk          sync.Mutex
 	genesisMsigLk sync.Mutex
-	newVM         func(*vm.VMOpts) (*vm.VM, error)
+	newVM         func(context.Context, *vm.VMOpts) (*vm.VM, error)
 	genInfo       *genesisInfo
 }
 
@@ -156,7 +156,7 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp
 		BaseFee:        baseFee,
 	}
 
-	vmi, err := sm.newVM(vmopt)
+	vmi, err := sm.newVM(ctx, vmopt)
 	if err != nil {
 		return cid.Undef, cid.Undef, xerrors.Errorf("instantiating VM failed: %w", err)
 	}
@@ -383,7 +383,7 @@ func (sm *StateManager) ResolveToKeyAddress(ctx context.Context, addr address.Ad
 	}
 
 	cst := cbor.NewCborStore(sm.cs.Blockstore())
-	tree, err := state.LoadStateTree(cst, st)
+	tree, err := state.LoadStateTree(cst, st, sm.GetNtwkVersion(ctx, ts.Height()))
 	if err != nil {
 		return address.Undef, xerrors.Errorf("failed to load state tree")
 	}
@@ -406,7 +406,7 @@ func (sm *StateManager) GetBlsPublicKey(ctx context.Context, addr address.Addres
 
 func (sm *StateManager) LookupID(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error) {
 	cst := cbor.NewCborStore(sm.cs.Blockstore())
-	state, err := state.LoadStateTree(cst, sm.parentState(ts))
+	state, err := state.LoadStateTree(cst, sm.parentState(ts), sm.GetNtwkVersion(ctx, ts.Height()))
 	if err != nil {
 		return address.Undef, xerrors.Errorf("load state tree: %w", err)
 	}
@@ -598,10 +598,9 @@ func (sm *StateManager) searchBackForMsg(ctx context.Context, from *types.TipSet
 		default:
 		}
 
-		var act types.Actor
+		act, err := sm.LoadActor(ctx, m.VMMessage().From, cur)
-		err := sm.WithParentState(cur, sm.WithActor(m.VMMessage().From, GetActor(&act)))
 		if err != nil {
-			return nil, nil, cid.Undef, err
+			return nil, nil, cid.Cid{}, err
 		}
 
 		// we either have no messages from the sender, or the latest message we found has a lower nonce than the one being searched for,
@@ -712,9 +711,15 @@ func (sm *StateManager) MarketBalance(ctx context.Context, addr address.Address,
 	if err != nil {
 		return api.MarketBalance{}, err
 	}
+
 	act, err := st.GetActor(builtin.StorageMarketActorAddr)
 	if err != nil {
-		return nil, err
+		return api.MarketBalance{}, err
+	}
+
+	mstate, err := market.Load(sm.cs.Store(ctx), act)
+	if err != nil {
+		return api.MarketBalance{}, err
 	}
 
 	addr, err = sm.LookupID(ctx, addr, ts)
@@ -724,7 +729,7 @@ func (sm *StateManager) MarketBalance(ctx context.Context, addr address.Address,
 
 	var out api.MarketBalance
 
-	et, err := adt.AsBalanceTable(sm.cs.Store(ctx), state.EscrowTable)
+	et, err := mstate.EscrowTable()
 	if err != nil {
 		return api.MarketBalance{}, err
 	}
@@ -733,7 +738,7 @@ func (sm *StateManager) MarketBalance(ctx context.Context, addr address.Address,
 		return api.MarketBalance{}, xerrors.Errorf("getting escrow balance: %w", err)
 	}
 
-	lt, err := adt.AsBalanceTable(sm.cs.Store(ctx), state.LockedTable)
+	lt, err := mstate.LockedTable()
 	if err != nil {
 		return api.MarketBalance{}, err
 	}
@@ -774,7 +779,7 @@ func (sm *StateManager) ValidateChain(ctx context.Context, ts *types.TipSet) err
 	return nil
 }
 
-func (sm *StateManager) SetVMConstructor(nvm func(*vm.VMOpts) (*vm.VM, error)) {
+func (sm *StateManager) SetVMConstructor(nvm func(context.Context, *vm.VMOpts) (*vm.VM, error)) {
 	sm.newVM = nvm
 }
 
@@ -812,7 +817,7 @@ func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
 	}
 
 	cst := cbor.NewCborStore(sm.cs.Blockstore())
-	sTree, err := state.LoadStateTree(cst, st)
+	sTree, err := state.LoadStateTree(cst, st, sm.GetNtwkVersion(ctx, gts.Height()))
 	if err != nil {
 		return xerrors.Errorf("loading state tree: %w", err)
 	}
@@ -918,7 +923,7 @@ func (sm *StateManager) setupGenesisActorsTestnet(ctx context.Context) error {
 	}
 
 	cst := cbor.NewCborStore(sm.cs.Blockstore())
-	sTree, err := state.LoadStateTree(cst, st)
+	sTree, err := state.LoadStateTree(cst, st, sm.GetNtwkVersion(ctx, gts.Height()))
 	if err != nil {
 		return xerrors.Errorf("loading state tree: %w", err)
 	}
@@ -1035,12 +1040,12 @@ func getFilPowerLocked(ctx context.Context, st *state.StateTree) (abi.TokenAmoun
 		return big.Zero(), xerrors.Errorf("failed to load power actor: %w", err)
 	}
 
-	pst, err := power.Load(adt.WrapStore(ctx, st.Store), act)
+	pst, err := power.Load(adt.WrapStore(ctx, st.Store), pactor)
 	if err != nil {
 		return big.Zero(), xerrors.Errorf("failed to load power state: %w", err)
 	}
 
-	return pst.TotalLocked(), nil
+	return pst.TotalLocked()
 }
 
 func (sm *StateManager) GetFilLocked(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
@@ -1124,6 +1129,8 @@ func (sm *StateManager) GetCirculatingSupply(ctx context.Context, height abi.Cha
 }
 
 func (sm *StateManager) GetNtwkVersion(ctx context.Context, height abi.ChainEpoch) network.Version {
+	// TODO: move hard fork epoch checks to a schedule defined in build/
+
 	if build.UpgradeBreezeHeight == 0 {
 		return network.Version1
 	}

chain/stmgr/utils.go

@@ -21,6 +21,7 @@ import (
 	"github.com/filecoin-project/go-bitfield"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/crypto"
+	power2 "github.com/filecoin-project/lotus/chain/actors/builtin/power"
 	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/account"
@@ -670,17 +671,21 @@ 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) {
-	var ps power.State
+	pact, err := sm.LoadActor(ctx, builtin.StoragePowerActorAddr, ts)
-	_, err := sm.LoadActorState(ctx, builtin.StoragePowerActorAddr, &ps, ts)
 	if err != nil {
 		return false, xerrors.Errorf("loading power actor state: %w", err)
 	}
 
+	ps, err := power2.Load(sm.cs.Store(ctx), pact)
+	if err != nil {
+		return false, err
+	}
+
 	return ps.MinerNominalPowerMeetsConsensusMinimum(sm.ChainStore().Store(ctx), addr)
 }
 
 func CheckTotalFIL(ctx context.Context, sm *StateManager, ts *types.TipSet) (abi.TokenAmount, error) {
-	str, err := state.LoadStateTree(sm.ChainStore().Store(ctx), ts.ParentState())
+	str, err := state.LoadStateTree(sm.ChainStore().Store(ctx), ts.ParentState(), sm.GetNtwkVersion(ctx, ts.Height()))
 	if err != nil {
 		return abi.TokenAmount{}, err
 	}

chain/store/store.go

@@ -5,6 +5,8 @@ import (
 	"context"
 	"encoding/binary"
 	"encoding/json"
+	"github.com/filecoin-project/go-state-types/network"
+	"github.com/filecoin-project/lotus/build"
 	"io"
 	"os"
 	"strconv"
@@ -741,11 +743,29 @@ type BlockMessages struct {
 	WinCount      int64
 }
 
+// TODO: temp hack until #3682 is merged
+func hackgetNtwkVersionhack(ctx context.Context, height abi.ChainEpoch) network.Version {
+	// TODO: move hard fork epoch checks to a schedule defined in build/
+
+	if build.UpgradeBreezeHeight == 0 {
+		return network.Version1
+	}
+
+	if height <= build.UpgradeBreezeHeight {
+		return network.Version0
+	}
+
+	return network.Version1
+}
+
 func (cs *ChainStore) BlockMsgsForTipset(ts *types.TipSet) ([]BlockMessages, error) {
 	applied := make(map[address.Address]uint64)
 
 	cst := cbor.NewCborStore(cs.bs)
-	st, err := state.LoadStateTree(cst, ts.Blocks()[0].ParentStateRoot)
+
+	nv := hackgetNtwkVersionhack(context.TODO(), ts.Height()) // TODO: part of the temp hack from above
+
+	st, err := state.LoadStateTree(cst, ts.Blocks()[0].ParentStateRoot, nv)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to load state tree")
 	}

chain/store/weight.go

@@ -29,7 +29,7 @@ func (cs *ChainStore) Weight(ctx context.Context, ts *types.TipSet) (types.BigIn
 	tpow := big2.Zero()
 	{
 		cst := cbor.NewCborStore(cs.Blockstore())
-		state, err := state.LoadStateTree(cst, ts.ParentState())
+		state, err := state.LoadStateTree(cst, ts.ParentState(), hackgetNtwkVersionhack(nil, ts.Height())) // TODO: hackgetNtwkVersionhack: HELP
 		if err != nil {
 			return types.NewInt(0), xerrors.Errorf("load state tree: %w", err)
 		}

chain/vm/vm.go

@@ -163,7 +163,7 @@ type VMOpts struct {
 	Bstore         bstore.Blockstore
 	Syscalls       SyscallBuilder
 	CircSupplyCalc CircSupplyCalculator
-	NtwkVersion    NtwkVersionGetter
+	NtwkVersion    NtwkVersionGetter // TODO: stebalien: In what cases do we actually need this? It seems like even when creating new networks we want to use the 'global'/build-default version getter
 	BaseFee        abi.TokenAmount
 }