Merge branch 'feat/nv16'

node/builder.go

@@ -384,6 +384,9 @@ func Test() Option {
 		Unset(new(*peermgr.PeerMgr)),
 		Override(new(beacon.Schedule), testing.RandomBeacon),
 		Override(new(*storageadapter.DealPublisher), storageadapter.NewDealPublisher(nil, storageadapter.PublishMsgConfig{})),
+		// use the testing bundles
+		Unset(new(dtypes.BuiltinActorsLoaded)),
+		Override(new(dtypes.BuiltinActorsLoaded), modules.LoadBuiltinActorsTesting),
 	)
 }
 

node/builder_chain.go

@@ -48,9 +48,16 @@ var ChainNode = Options(
 	// Full node or lite node
 	// TODO: Fix offline mode
 
+	// FVM: builtin actor bundle loading
+	//      Note: this has to load before the upgrade schedule, so that we can patch in the
+	//      right manifest cid.
+	//      This restriction will be lifted once we have the final actors v8 bundle and we know
+	//      the manifest cid.
+	Override(new(dtypes.BuiltinActorsLoaded), modules.LoadBuiltinActors),
+
 	// Consensus settings
 	Override(new(dtypes.DrandSchedule), modules.BuiltinDrandConfig),
-	Override(new(stmgr.UpgradeSchedule), filcns.DefaultUpgradeSchedule()),
+	Override(new(stmgr.UpgradeSchedule), modules.UpgradeSchedule),
 	Override(new(dtypes.NetworkName), modules.NetworkName),
 	Override(new(modules.Genesis), modules.ErrorGenesis),
 	Override(new(dtypes.AfterGenesisSet), modules.SetGenesis),

node/builder_miner.go

@@ -51,6 +51,10 @@ var MinerNode = Options(
 
 	// Mining / proving
 	Override(new(*storage.AddressSelector), modules.AddressSelector(nil)),
+
+	// builtin actors manifest
+	Override(new(dtypes.BuiltinActorsLoaded), modules.LoadBuiltinActors),
+	Override(new(dtypes.UniversalBlockstore), modules.MemoryBlockstore),
 )
 
 func ConfigStorageMiner(c interface{}) Option {

node/bundle/bundle.go

@@ -0,0 +1,216 @@
+package bundle
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"golang.org/x/xerrors"
+
+	logging "github.com/ipfs/go-log/v2"
+)
+
+var log = logging.Logger("bundle-fetcher")
+
+type BundleFetcher struct {
+	path string
+}
+
+func NewBundleFetcher(basepath string) (*BundleFetcher, error) {
+	path := filepath.Join(basepath, "builtin-actors")
+	if err := os.MkdirAll(path, 0755); err != nil {
+		return nil, xerrors.Errorf("error making bundle directory %s: %w", path, err)
+	}
+
+	return &BundleFetcher{path: path}, nil
+}
+
+func (b *BundleFetcher) FetchFromRelease(version int, release, netw string) (path string, err error) {
+	bundleName := fmt.Sprintf("builtin-actors-%s", netw)
+	bundleFile := fmt.Sprintf("%s.car", bundleName)
+	bundleHash := fmt.Sprintf("%s.sha256", bundleName)
+	bundleBasePath := filepath.Join(b.path, fmt.Sprintf("v%d", version), release)
+
+	if err := os.MkdirAll(bundleBasePath, 0755); err != nil {
+		return "", xerrors.Errorf("error making bundle directory %s: %w", bundleBasePath, err)
+	}
+
+	// check if it exists; if it does, check the hash
+	bundleFilePath := filepath.Join(bundleBasePath, bundleFile)
+	if _, err := os.Stat(bundleFilePath); err == nil {
+		err := b.checkRelease(bundleBasePath, bundleFile, bundleHash)
+		if err == nil {
+			return bundleFilePath, nil
+		}
+
+		log.Warnf("invalid bundle %s: %s; refetching", bundleName, err)
+	}
+
+	log.Infof("fetching bundle %s", bundleFile)
+	if err := b.fetchFromRelease(release, bundleBasePath, bundleFile, bundleHash); err != nil {
+		log.Errorf("error fetching bundle %s: %s", bundleName, err)
+		return "", xerrors.Errorf("error fetching bundle: %w", err)
+	}
+
+	if err := b.checkRelease(bundleBasePath, bundleFile, bundleHash); err != nil {
+		log.Errorf("error checking bundle %s: %s", bundleName, err)
+		return "", xerrors.Errorf("error checking bundle: %s", err)
+	}
+
+	return bundleFilePath, nil
+}
+
+func (b *BundleFetcher) FetchFromURL(version int, release, netw, url, cksum string) (path string, err error) {
+	bundleName := fmt.Sprintf("builtin-actors-%s", netw)
+	bundleFile := fmt.Sprintf("%s.car", bundleName)
+	bundleBasePath := filepath.Join(b.path, fmt.Sprintf("v%d", version), release)
+
+	if err := os.MkdirAll(bundleBasePath, 0755); err != nil {
+		return "", xerrors.Errorf("error making bundle directory %s: %w", bundleBasePath, err)
+	}
+
+	// check if it exists; if it does, check the hash
+	bundleFilePath := filepath.Join(bundleBasePath, bundleFile)
+	if _, err := os.Stat(bundleFilePath); err == nil {
+		err := b.checkHash(bundleBasePath, bundleFile, cksum)
+		if err == nil {
+			return bundleFilePath, nil
+		}
+
+		log.Warnf("invalid bundle %s: %s; refetching", bundleName, err)
+	}
+
+	log.Infof("fetching bundle %s", bundleFile)
+	if err := b.fetchFromURL(bundleBasePath, bundleFile, url); err != nil {
+		log.Errorf("error fetching bundle %s: %s", bundleName, err)
+		return "", xerrors.Errorf("error fetching bundle: %w", err)
+	}
+
+	if err := b.checkHash(bundleBasePath, bundleFile, cksum); err != nil {
+		log.Errorf("error checking bundle %s: %s", bundleName, err)
+		return "", xerrors.Errorf("error checking bundle: %s", err)
+	}
+
+	return bundleFilePath, nil
+}
+
+func (b *BundleFetcher) fetchURL(url, path string) error {
+	log.Infof("fetching URL: %s", url)
+
+	for i := 0; i < 3; i++ {
+		resp, err := http.Get(url) //nolint
+		if err != nil {
+			if isTemporary(err) {
+				log.Warnf("temporary error fetching %s: %s; retrying in 1s", url, err)
+				time.Sleep(time.Second)
+				continue
+			}
+			return xerrors.Errorf("error fetching %s: %w", url, err)
+		}
+		defer resp.Body.Close() //nolint
+
+		if resp.StatusCode != http.StatusOK {
+			log.Warnf("unexpected response fetching %s: %s (%d); retrying in 1s", url, resp.Status, resp.StatusCode)
+			time.Sleep(time.Second)
+			continue
+		}
+
+		f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
+		if err != nil {
+			return xerrors.Errorf("error opening %s for writing: %w", path, err)
+		}
+		defer f.Close() //nolint
+
+		if _, err := io.Copy(f, resp.Body); err != nil {
+			return xerrors.Errorf("error writing %s: %w", path, err)
+		}
+
+		return nil
+	}
+
+	return xerrors.Errorf("all attempts to fetch %s failed", url)
+}
+
+func (b *BundleFetcher) fetchFromRelease(release, bundleBasePath, bundleFile, bundleHash string) error {
+	bundleHashUrl := fmt.Sprintf("https://github.com/filecoin-project/builtin-actors/releases/download/%s/%s",
+		release, bundleHash)
+	bundleHashPath := filepath.Join(bundleBasePath, bundleHash)
+	if err := b.fetchURL(bundleHashUrl, bundleHashPath); err != nil {
+		return err
+	}
+
+	bundleFileUrl := fmt.Sprintf("https://github.com/filecoin-project/builtin-actors/releases/download/%s/%s",
+		release, bundleFile)
+	bundleFilePath := filepath.Join(bundleBasePath, bundleFile)
+	if err := b.fetchURL(bundleFileUrl, bundleFilePath); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (b *BundleFetcher) fetchFromURL(bundleBasePath, bundleFile, url string) error {
+	bundleFilePath := filepath.Join(bundleBasePath, bundleFile)
+	return b.fetchURL(url, bundleFilePath)
+}
+
+func (b *BundleFetcher) checkRelease(bundleBasePath, bundleFile, bundleHash string) error {
+	bundleHashPath := filepath.Join(bundleBasePath, bundleHash)
+	f, err := os.Open(bundleHashPath)
+	if err != nil {
+		return xerrors.Errorf("error opening %s: %w", bundleHashPath, err)
+	}
+	defer f.Close() //nolint
+
+	bs, err := io.ReadAll(f)
+	if err != nil {
+		return xerrors.Errorf("error reading %s: %w", bundleHashPath, err)
+	}
+
+	parts := strings.Split(string(bs), " ")
+	hashHex := parts[0]
+
+	return b.checkHash(bundleBasePath, bundleFile, hashHex)
+}
+
+func (b *BundleFetcher) checkHash(bundleBasePath, bundleFile, cksum string) error {
+	expectedDigest, err := hex.DecodeString(cksum)
+	if err != nil {
+		return xerrors.Errorf("error decoding digest from %s: %w", cksum, err)
+	}
+
+	bundleFilePath := filepath.Join(bundleBasePath, bundleFile)
+	f, err := os.Open(bundleFilePath)
+	if err != nil {
+		return xerrors.Errorf("error opening %s: %w", bundleFilePath, err)
+	}
+	defer f.Close() //nolint
+
+	h256 := sha256.New()
+	if _, err := io.Copy(h256, f); err != nil {
+		return xerrors.Errorf("error computing digest for %s: %w", bundleFilePath, err)
+	}
+	digest := h256.Sum(nil)
+
+	if !bytes.Equal(digest, expectedDigest) {
+		return xerrors.Errorf("hash mismatch")
+	}
+
+	return nil
+}
+
+func isTemporary(err error) bool {
+	if ne, ok := err.(net.Error); ok {
+		return ne.Temporary()
+	}
+
+	return false
+}

node/bundle/manifest.go

@@ -0,0 +1,127 @@
+package bundle
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/ipld/go-car"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/blockstore"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors"
+
+	cid "github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+
+	"github.com/mitchellh/go-homedir"
+)
+
+func FetchAndLoadBundleFromRelease(ctx context.Context, basePath string, bs blockstore.Blockstore, av actors.Version, rel, netw string) (cid.Cid, error) {
+	fetcher, err := NewBundleFetcher(basePath)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("error creating fetcher for builtin-actors version %d: %w", av, err)
+	}
+
+	path, err := fetcher.FetchFromRelease(int(av), rel, netw)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("error fetching bundle for builtin-actors version %d: %w", av, err)
+	}
+
+	return LoadBundle(ctx, bs, path, av)
+}
+
+func FetchAndLoadBundleFromURL(ctx context.Context, basePath string, bs blockstore.Blockstore, av actors.Version, rel, netw, url, cksum string) (cid.Cid, error) {
+	fetcher, err := NewBundleFetcher(basePath)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("error creating fetcher for builtin-actors version %d: %w", av, err)
+	}
+
+	path, err := fetcher.FetchFromURL(int(av), rel, netw, url, cksum)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("error fetching bundle for builtin-actors version %d: %w", av, err)
+	}
+
+	return LoadBundle(ctx, bs, path, av)
+}
+
+func LoadBundle(ctx context.Context, bs blockstore.Blockstore, path string, av actors.Version) (cid.Cid, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("error opening bundle for builtin-actors version %d: %w", av, err)
+	}
+	defer f.Close() //nolint
+
+	hdr, err := car.LoadCar(ctx, bs, f)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("error loading builtin actors v%d bundle: %w", av, err)
+	}
+
+	// TODO: check that this only has one root?
+	manifestCid := hdr.Roots[0]
+
+	if val, ok := build.ActorsCIDs[av]; ok {
+		if val != manifestCid {
+			return cid.Undef, xerrors.Errorf("actors V%d manifest CID %s did not match CID given in params file: %s", av, manifestCid, val)
+		}
+	}
+	actors.AddManifest(av, manifestCid)
+
+	mfCid, ok := actors.GetManifest(av)
+	if !ok {
+		return cid.Undef, xerrors.Errorf("missing manifest CID for builtin-actors vrsion %d", av)
+	}
+
+	return mfCid, nil
+}
+
+// utility for blanket loading outside DI
+func FetchAndLoadBundles(ctx context.Context, bs blockstore.Blockstore, bar map[actors.Version]build.Bundle) error {
+	netw := build.NetworkBundle
+
+	path := os.Getenv("LOTUS_PATH")
+	if path == "" {
+		var err error
+		path, err = homedir.Expand("~/.lotus")
+		if err != nil {
+			return err
+		}
+	}
+
+	for av, bd := range bar {
+		envvar := fmt.Sprintf("LOTUS_BUILTIN_ACTORS_V%d_BUNDLE", av)
+		switch {
+		case os.Getenv(envvar) != "":
+			// this is a local bundle, specified by an env var to load from the filesystem
+			path := os.Getenv(envvar)
+
+			if _, err := LoadBundle(ctx, bs, path, av); err != nil {
+				return err
+			}
+
+		case bd.Path[netw] != "":
+			if _, err := LoadBundle(ctx, bs, bd.Path[netw], av); err != nil {
+				return err
+			}
+
+		case bd.URL[netw].URL != "":
+			if _, err := FetchAndLoadBundleFromURL(ctx, path, bs, av, bd.Release, netw, bd.URL[netw].URL, bd.URL[netw].Checksum); err != nil {
+				return err
+			}
+
+		case bd.Release != "":
+			if _, err := FetchAndLoadBundleFromRelease(ctx, path, bs, av, bd.Release, netw); err != nil {
+				return err
+			}
+		}
+	}
+
+	cborStore := cbor.NewCborStore(bs)
+	if err := actors.LoadManifests(ctx, cborStore); err != nil {
+		return err
+	}
+
+	return nil
+}

node/impl/client/client.go

@@ -12,6 +12,8 @@ import (
 	"strings"
 	"time"
 
+	market8 "github.com/filecoin-project/go-state-types/builtin/v8/market"
+
 	bstore "github.com/ipfs/go-ipfs-blockstore"
 	format "github.com/ipfs/go-ipld-format"
 	unixfile "github.com/ipfs/go-unixfs/file"
@@ -60,7 +62,6 @@ import (
 	"github.com/filecoin-project/lotus/markets/storageadapter"
 
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/specs-actors/v3/actors/builtin/market"
 
 	"github.com/filecoin-project/lotus/node/config"
 	"github.com/filecoin-project/lotus/node/repo/imports"
@@ -233,12 +234,17 @@ func (a *API) dealStarter(ctx context.Context, params *api.StartDealParams, isSt
 	// stateless flow from here to the end
 	//
 
-	dealProposal := &market.DealProposal{
+	label, err := market8.NewLabelFromString(params.Data.Root.Encode(multibase.MustNewEncoder('u')))
+	if err != nil {
+		return nil, xerrors.Errorf("failed to encode label: %w", err)
+	}
+
+	dealProposal := &market8.DealProposal{
 		PieceCID:             *params.Data.PieceCid,
 		PieceSize:            params.Data.PieceSize.Padded(),
 		Client:               walletKey,
 		Provider:             params.Miner,
-		Label:                params.Data.Root.Encode(multibase.MustNewEncoder('u')),
+		Label:                label,
 		StartEpoch:           dealStart,
 		EndEpoch:             calcDealExpiration(params.MinBlocksDuration, md, dealStart),
 		StoragePricePerEpoch: big.Zero(),
@@ -265,7 +271,7 @@ func (a *API) dealStarter(ctx context.Context, params *api.StartDealParams, isSt
 		return nil, xerrors.Errorf("failed to sign proposal : %w", err)
 	}
 
-	dealProposalSigned := &market.ClientDealProposal{
+	dealProposalSigned := &market8.ClientDealProposal{
 		Proposal:        *dealProposal,
 		ClientSignature: *dealProposalSig,
 	}

node/impl/full.go

@@ -35,7 +35,6 @@ type FullNodeAPI struct {
 	full.MsigAPI
 	full.WalletAPI
 	full.SyncAPI
-	full.BeaconAPI
 
 	DS          dtypes.MetadataDS
 	NetworkName dtypes.NetworkName

node/impl/full/beacon.go

@@ -1,36 +0,0 @@
-package full
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/beacon"
-	"github.com/filecoin-project/lotus/chain/types"
-	"go.uber.org/fx"
-)
-
-type BeaconAPI struct {
-	fx.In
-
-	Beacon beacon.Schedule
-}
-
-func (a *BeaconAPI) BeaconGetEntry(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) {
-	b := a.Beacon.BeaconForEpoch(epoch)
-	rr := b.MaxBeaconRoundForEpoch(epoch)
-	e := b.Entry(ctx, rr)
-
-	select {
-	case be, ok := <-e:
-		if !ok {
-			return nil, fmt.Errorf("beacon get returned no value")
-		}
-		if be.Err != nil {
-			return nil, be.Err
-		}
-		return &be.Entry, nil
-	case <-ctx.Done():
-		return nil, ctx.Err()
-	}
-}

node/impl/full/gas.go

@@ -6,8 +6,9 @@ import (
 	"math/rand"
 	"sort"
 
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
+	lbuiltin "github.com/filecoin-project/lotus/chain/actors/builtin"
+
+	"github.com/filecoin-project/go-state-types/builtin"
 	lru "github.com/hashicorp/golang-lru"
 
 	"go.uber.org/fx"
@@ -295,31 +296,62 @@ func gasEstimateGasLimit(
 		return -1, xerrors.Errorf("message execution failed: exit %s, reason: %s", res.MsgRct.ExitCode, res.Error)
 	}
 
+	ret := res.MsgRct.GasUsed
+
+	transitionalMulti := 1.0
+	// Overestimate gas around the upgrade
+	if ts.Height() <= build.UpgradeSkyrHeight && (build.UpgradeSkyrHeight-ts.Height() <= 20) {
+		transitionalMulti = 2.0
+
+		func() {
+			st, err := smgr.ParentState(ts)
+			if err != nil {
+				return
+			}
+			act, err := st.GetActor(msg.To)
+			if err != nil {
+				return
+			}
+
+			if lbuiltin.IsStorageMinerActor(act.Code) {
+				switch msgIn.Method {
+				case 5:
+					transitionalMulti = 3.954
+				case 6:
+					transitionalMulti = 4.095
+				case 7:
+					// skip, stay at 2.0
+					//transitionalMulti = 1.289
+				case 11:
+					transitionalMulti = 17.8758
+				case 16:
+					transitionalMulti = 2.1704
+				case 25:
+					transitionalMulti = 3.1177
+				case 26:
+					transitionalMulti = 2.3322
+				default:
+				}
+			}
+
+			// skip storage market, 80th percentie for everything ~1.9, leave it at 2.0
+		}()
+	}
+	ret = (ret * int64(transitionalMulti*1024)) >> 10
+
 	// Special case for PaymentChannel collect, which is deleting actor
+	// We ignore errors in this special case since they CAN occur,
+	// and we just want to detect existing payment channel actors
 	st, err := smgr.ParentState(ts)
-	if err != nil {
-		_ = err
-		// somewhat ignore it as it can happen and we just want to detect
-		// an existing PaymentChannel actor
-		return res.MsgRct.GasUsed, nil
-	}
-	act, err := st.GetActor(msg.To)
-	if err != nil {
-		_ = err
-		// somewhat ignore it as it can happen and we just want to detect
-		// an existing PaymentChannel actor
-		return res.MsgRct.GasUsed, nil
+	if err == nil {
+		act, err := st.GetActor(msg.To)
+		if err == nil && lbuiltin.IsPaymentChannelActor(act.Code) && msgIn.Method == builtin.MethodsPaych.Collect {
+			// add the refunded gas for DestroyActor back into the gas used
+			ret += 76e3
+		}
 	}
 
-	if !builtin.IsPaymentChannelActor(act.Code) {
-		return res.MsgRct.GasUsed, nil
-	}
-	if msgIn.Method != paych.Methods.Collect {
-		return res.MsgRct.GasUsed, nil
-	}
-
-	// return GasUsed without the refund for DestoryActor
-	return res.MsgRct.GasUsed + 76e3, nil
+	return ret, nil
 }
 
 func (m *GasModule) GasEstimateMessageGas(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec, _ types.TipSetKey) (*types.Message, error) {

node/impl/full/state.go

@@ -4,8 +4,11 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"fmt"
 	"strconv"
 
+	"github.com/libp2p/go-libp2p-core/peer"
+
 	"github.com/filecoin-project/go-state-types/crypto"
 
 	"github.com/filecoin-project/go-state-types/cbor"
@@ -22,6 +25,7 @@ import (
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
 
+	minertypes "github.com/filecoin-project/go-state-types/builtin/v8/miner"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
@@ -53,7 +57,7 @@ type StateModuleAPI interface {
 	StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
 	StateMarketBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (api.MarketBalance, error)
 	StateMarketStorageDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*api.MarketDeal, error)
-	StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error)
+	StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (api.MinerInfo, error)
 	StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error)
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*api.MinerPower, error)
 	StateNetworkVersion(ctx context.Context, key types.TipSetKey) (network.Version, error)
@@ -132,27 +136,52 @@ func (a *StateAPI) StateMinerActiveSectors(ctx context.Context, maddr address.Ad
 	return mas.LoadSectors(&activeSectors)
 }
 
-func (m *StateModule) StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error) {
+func (m *StateModule) StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (api.MinerInfo, error) {
 	ts, err := m.Chain.GetTipSetFromKey(ctx, tsk)
 	if err != nil {
-		return miner.MinerInfo{}, xerrors.Errorf("failed to load tipset: %w", err)
+		return api.MinerInfo{}, xerrors.Errorf("failed to load tipset: %w", err)
 	}
 
 	act, err := m.StateManager.LoadActor(ctx, actor, ts)
 	if err != nil {
-		return miner.MinerInfo{}, xerrors.Errorf("failed to load miner actor: %w", err)
+		return api.MinerInfo{}, xerrors.Errorf("failed to load miner actor: %w", err)
 	}
 
 	mas, err := miner.Load(m.StateManager.ChainStore().ActorStore(ctx), act)
 	if err != nil {
-		return miner.MinerInfo{}, xerrors.Errorf("failed to load miner actor state: %w", err)
+		return api.MinerInfo{}, xerrors.Errorf("failed to load miner actor state: %w", err)
 	}
 
 	info, err := mas.Info()
 	if err != nil {
-		return miner.MinerInfo{}, err
+		return api.MinerInfo{}, err
 	}
-	return info, nil
+
+	var pid *peer.ID
+	if peerID, err := peer.IDFromBytes(info.PeerId); err == nil {
+		pid = &peerID
+	}
+
+	ret := api.MinerInfo{
+		Owner:                      info.Owner,
+		Worker:                     info.Worker,
+		ControlAddresses:           info.ControlAddresses,
+		NewWorker:                  address.Undef,
+		WorkerChangeEpoch:          -1,
+		PeerId:                     pid,
+		Multiaddrs:                 info.Multiaddrs,
+		WindowPoStProofType:        info.WindowPoStProofType,
+		SectorSize:                 info.SectorSize,
+		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
+		ConsensusFaultElapsed:      info.ConsensusFaultElapsed,
+	}
+
+	if info.PendingWorkerKey != nil {
+		ret.NewWorker = info.PendingWorkerKey.NewWorker
+		ret.WorkerChangeEpoch = info.PendingWorkerKey.EffectiveAt
+	}
+
+	return ret, nil
 }
 
 func (a *StateAPI) StateMinerDeadlines(ctx context.Context, m address.Address, tsk types.TipSetKey) ([]api.Deadline, error) {
@@ -680,8 +709,8 @@ func (a *StateAPI) StateMarketParticipants(ctx context.Context, tsk types.TipSet
 	return out, nil
 }
 
-func (a *StateAPI) StateMarketDeals(ctx context.Context, tsk types.TipSetKey) (map[string]api.MarketDeal, error) {
-	out := map[string]api.MarketDeal{}
+func (a *StateAPI) StateMarketDeals(ctx context.Context, tsk types.TipSetKey) (map[string]*api.MarketDeal, error) {
+	out := map[string]*api.MarketDeal{}
 
 	ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
 	if err != nil {
@@ -710,7 +739,7 @@ func (a *StateAPI) StateMarketDeals(ctx context.Context, tsk types.TipSetKey) (m
 		} else if !found {
 			s = market.EmptyDealState()
 		}
-		out[strconv.FormatInt(int64(dealID), 10)] = api.MarketDeal{
+		out[strconv.FormatInt(int64(dealID), 10)] = &api.MarketDeal{
 			Proposal: d,
 			State:    *s,
 		}
@@ -786,17 +815,17 @@ func (a *StateAPI) StateMinerSectorCount(ctx context.Context, addr address.Addre
 	return api.MinerSectors{Live: liveCount, Active: activeCount, Faulty: faultyCount}, nil
 }
 
-func (a *StateAPI) StateSectorPreCommitInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) {
+func (a *StateAPI) StateSectorPreCommitInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (minertypes.SectorPreCommitOnChainInfo, error) {
 	ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
 	if err != nil {
-		return miner.SectorPreCommitOnChainInfo{}, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+		return minertypes.SectorPreCommitOnChainInfo{}, xerrors.Errorf("loading tipset %s: %w", tsk, err)
 	}
 
 	pci, err := stmgr.PreCommitInfo(ctx, a.StateManager, maddr, n, ts)
 	if err != nil {
-		return miner.SectorPreCommitOnChainInfo{}, err
+		return minertypes.SectorPreCommitOnChainInfo{}, err
 	} else if pci == nil {
-		return miner.SectorPreCommitOnChainInfo{}, xerrors.Errorf("precommit info is not exists")
+		return minertypes.SectorPreCommitOnChainInfo{}, xerrors.Errorf("precommit info is not exists")
 	}
 
 	return *pci, err
@@ -1062,7 +1091,7 @@ func (m *StateModule) MsigGetPending(ctx context.Context, addr address.Address,
 var initialPledgeNum = types.NewInt(110)
 var initialPledgeDen = types.NewInt(100)
 
-func (a *StateAPI) StateMinerPreCommitDepositForPower(ctx context.Context, maddr address.Address, pci miner.SectorPreCommitInfo, tsk types.TipSetKey) (types.BigInt, error) {
+func (a *StateAPI) StateMinerPreCommitDepositForPower(ctx context.Context, maddr address.Address, pci minertypes.SectorPreCommitInfo, tsk types.TipSetKey) (types.BigInt, error) {
 	ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
 	if err != nil {
 		return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err)
@@ -1122,7 +1151,7 @@ func (a *StateAPI) StateMinerPreCommitDepositForPower(ctx context.Context, maddr
 	return types.BigDiv(types.BigMul(deposit, initialPledgeNum), initialPledgeDen), nil
 }
 
-func (a *StateAPI) StateMinerInitialPledgeCollateral(ctx context.Context, maddr address.Address, pci miner.SectorPreCommitInfo, tsk types.TipSetKey) (types.BigInt, error) {
+func (a *StateAPI) StateMinerInitialPledgeCollateral(ctx context.Context, maddr address.Address, pci minertypes.SectorPreCommitInfo, tsk types.TipSetKey) (types.BigInt, error) {
 	// TODO: this repeats a lot of the previous function. Fix that.
 	ts, err := a.Chain.GetTipSetFromKey(ctx, tsk)
 	if err != nil {
@@ -1440,6 +1469,25 @@ func (a *StateAPI) StateGetRandomnessFromBeacon(ctx context.Context, personaliza
 
 }
 
+func (a *StateAPI) StateGetBeaconEntry(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) {
+	b := a.Beacon.BeaconForEpoch(epoch)
+	rr := b.MaxBeaconRoundForEpoch(a.StateManager.GetNetworkVersion(ctx, epoch), epoch)
+	e := b.Entry(ctx, rr)
+
+	select {
+	case be, ok := <-e:
+		if !ok {
+			return nil, fmt.Errorf("beacon get returned no value")
+		}
+		if be.Err != nil {
+			return nil, be.Err
+		}
+		return &be.Entry, nil
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	}
+}
+
 func (a *StateAPI) StateGetNetworkParams(ctx context.Context) (*api.NetworkParams, error) {
 	networkName, err := a.StateNetworkName(ctx)
 	if err != nil {

node/impl/paych/paych.go

@@ -10,8 +10,8 @@ import (
 
 	"github.com/filecoin-project/go-address"
 
+	paychtypes "github.com/filecoin-project/go-state-types/builtin/v8/paych"
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/paychmgr"
 )
@@ -83,10 +83,10 @@ func (a *PaychAPI) PaychNewPayment(ctx context.Context, from, to address.Address
 		return nil, err
 	}
 
-	svs := make([]*paych.SignedVoucher, len(vouchers))
+	svs := make([]*paychtypes.SignedVoucher, len(vouchers))
 
 	for i, v := range vouchers {
-		sv, err := a.PaychMgr.CreateVoucher(ctx, ch.Channel, paych.SignedVoucher{
+		sv, err := a.PaychMgr.CreateVoucher(ctx, ch.Channel, paychtypes.SignedVoucher{
 			Amount: v.Amount,
 			Lane:   lane,
 
@@ -135,15 +135,15 @@ func (a *PaychAPI) PaychCollect(ctx context.Context, addr address.Address) (cid.
 	return a.PaychMgr.Collect(ctx, addr)
 }
 
-func (a *PaychAPI) PaychVoucherCheckValid(ctx context.Context, ch address.Address, sv *paych.SignedVoucher) error {
+func (a *PaychAPI) PaychVoucherCheckValid(ctx context.Context, ch address.Address, sv *paychtypes.SignedVoucher) error {
 	return a.PaychMgr.CheckVoucherValid(ctx, ch, sv)
 }
 
-func (a *PaychAPI) PaychVoucherCheckSpendable(ctx context.Context, ch address.Address, sv *paych.SignedVoucher, secret []byte, proof []byte) (bool, error) {
+func (a *PaychAPI) PaychVoucherCheckSpendable(ctx context.Context, ch address.Address, sv *paychtypes.SignedVoucher, secret []byte, proof []byte) (bool, error) {
 	return a.PaychMgr.CheckVoucherSpendable(ctx, ch, sv, secret, proof)
 }
 
-func (a *PaychAPI) PaychVoucherAdd(ctx context.Context, ch address.Address, sv *paych.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) {
+func (a *PaychAPI) PaychVoucherAdd(ctx context.Context, ch address.Address, sv *paychtypes.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) {
 	return a.PaychMgr.AddVoucherInbound(ctx, ch, sv, proof, minDelta)
 }
 
@@ -155,16 +155,16 @@ func (a *PaychAPI) PaychVoucherAdd(ctx context.Context, ch address.Address, sv *
 // If there are insufficient funds in the channel to create the voucher,
 // returns a nil voucher and the shortfall.
 func (a *PaychAPI) PaychVoucherCreate(ctx context.Context, pch address.Address, amt types.BigInt, lane uint64) (*api.VoucherCreateResult, error) {
-	return a.PaychMgr.CreateVoucher(ctx, pch, paych.SignedVoucher{Amount: amt, Lane: lane})
+	return a.PaychMgr.CreateVoucher(ctx, pch, paychtypes.SignedVoucher{Amount: amt, Lane: lane})
 }
 
-func (a *PaychAPI) PaychVoucherList(ctx context.Context, pch address.Address) ([]*paych.SignedVoucher, error) {
+func (a *PaychAPI) PaychVoucherList(ctx context.Context, pch address.Address) ([]*paychtypes.SignedVoucher, error) {
 	vi, err := a.PaychMgr.ListVouchers(ctx, pch)
 	if err != nil {
 		return nil, err
 	}
 
-	out := make([]*paych.SignedVoucher, len(vi))
+	out := make([]*paychtypes.SignedVoucher, len(vi))
 	for k, v := range vi {
 		out[k] = v.Voucher
 	}
@@ -172,6 +172,6 @@ func (a *PaychAPI) PaychVoucherList(ctx context.Context, pch address.Address) ([
 	return out, nil
 }
 
-func (a *PaychAPI) PaychVoucherSubmit(ctx context.Context, ch address.Address, sv *paych.SignedVoucher, secret []byte, proof []byte) (cid.Cid, error) {
+func (a *PaychAPI) PaychVoucherSubmit(ctx context.Context, ch address.Address, sv *paychtypes.SignedVoucher, secret []byte, proof []byte) (cid.Cid, error) {
 	return a.PaychMgr.SubmitVoucher(ctx, ch, sv, secret, proof)
 }

node/impl/storminer.go

@@ -11,12 +11,13 @@ import (
 	"strconv"
 	"time"
 
+	minertypes "github.com/filecoin-project/go-state-types/builtin/v8/miner"
+
 	"github.com/filecoin-project/dagstore"
 	"github.com/filecoin-project/dagstore/shard"
 	"github.com/filecoin-project/go-jsonrpc/auth"
 
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	lminer "github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/gen"
 
 	"github.com/google/uuid"
@@ -413,7 +414,7 @@ func (sm *StorageMinerAPI) SectorMatchPendingPiecesToOpenSectors(ctx context.Con
 	return sm.Miner.SectorMatchPendingPiecesToOpenSectors(ctx)
 }
 
-func (sm *StorageMinerAPI) ComputeWindowPoSt(ctx context.Context, dlIdx uint64, tsk types.TipSetKey) ([]lminer.SubmitWindowedPoStParams, error) {
+func (sm *StorageMinerAPI) ComputeWindowPoSt(ctx context.Context, dlIdx uint64, tsk types.TipSetKey) ([]minertypes.SubmitWindowedPoStParams, error) {
 	var ts *types.TipSet
 	var err error
 	if tsk == types.EmptyTSK {
@@ -461,7 +462,7 @@ func (sm *StorageMinerAPI) MarketImportDealData(ctx context.Context, propCid cid
 	return sm.StorageProvider.ImportDataForDeal(ctx, propCid, fi)
 }
 
-func (sm *StorageMinerAPI) listDeals(ctx context.Context) ([]api.MarketDeal, error) {
+func (sm *StorageMinerAPI) listDeals(ctx context.Context) ([]*api.MarketDeal, error) {
 	ts, err := sm.Full.ChainHead(ctx)
 	if err != nil {
 		return nil, err
@@ -472,7 +473,7 @@ func (sm *StorageMinerAPI) listDeals(ctx context.Context) ([]api.MarketDeal, err
 		return nil, err
 	}
 
-	var out []api.MarketDeal
+	var out []*api.MarketDeal
 
 	for _, deal := range allDeals {
 		if deal.Proposal.Provider == sm.Miner.Address() {
@@ -483,7 +484,7 @@ func (sm *StorageMinerAPI) listDeals(ctx context.Context) ([]api.MarketDeal, err
 	return out, nil
 }
 
-func (sm *StorageMinerAPI) MarketListDeals(ctx context.Context) ([]api.MarketDeal, error) {
+func (sm *StorageMinerAPI) MarketListDeals(ctx context.Context) ([]*api.MarketDeal, error) {
 	return sm.listDeals(ctx)
 }
 
@@ -1108,7 +1109,7 @@ func (sm *StorageMinerAPI) DagstoreLookupPieces(ctx context.Context, cid cid.Cid
 	return ret, nil
 }
 
-func (sm *StorageMinerAPI) DealsList(ctx context.Context) ([]api.MarketDeal, error) {
+func (sm *StorageMinerAPI) DealsList(ctx context.Context) ([]*api.MarketDeal, error) {
 	return sm.listDeals(ctx)
 }
 

node/modules/blockstore.go

@@ -37,6 +37,10 @@ func UniversalBlockstore(lc fx.Lifecycle, mctx helpers.MetricsCtx, r repo.Locked
 	return bs, err
 }
 
+func MemoryBlockstore() dtypes.UniversalBlockstore {
+	return blockstore.NewMemory()
+}
+
 func DiscardColdBlockstore(lc fx.Lifecycle, bs dtypes.UniversalBlockstore) (dtypes.ColdBlockstore, error) {
 	return blockstore.NewDiscardStore(bs), nil
 }

node/modules/builtin_actors.go

@@ -0,0 +1,177 @@
+package modules
+
+import (
+	"fmt"
+	"os"
+	"sync"
+
+	"go.uber.org/fx"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/node/bundle"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+	"github.com/filecoin-project/lotus/node/modules/helpers"
+	"github.com/filecoin-project/lotus/node/repo"
+
+	cid "github.com/ipfs/go-cid"
+	dstore "github.com/ipfs/go-datastore"
+	cbor "github.com/ipfs/go-ipld-cbor"
+)
+
+func LoadBuiltinActors(lc fx.Lifecycle, mctx helpers.MetricsCtx, r repo.LockedRepo, bs dtypes.UniversalBlockstore, ds dtypes.MetadataDS) (result dtypes.BuiltinActorsLoaded, err error) {
+	ctx := helpers.LifecycleCtx(mctx, lc)
+
+	// We can't put it as a dep in inputs causes a stack overflow in DI from circular dependency
+	// So we pass it through ldflags instead
+	netw := build.NetworkBundle
+
+	for av, bd := range build.BuiltinActorReleases {
+		// first check to see if we know this release
+		key := dstore.NewKey(fmt.Sprintf("/builtin-actors/v%d/%s/%s", av, bd.Release, netw))
+
+		data, err := ds.Get(ctx, key)
+		switch err {
+		case nil:
+			// ok, we do, this should be the manifest cid
+			mfCid, err := cid.Cast(data)
+			if err != nil {
+				return result, xerrors.Errorf("error parsing cid for %s: %w", key, err)
+			}
+
+			// check the blockstore for existence of the manifest
+			has, err := bs.Has(ctx, mfCid)
+			if err != nil {
+				return result, xerrors.Errorf("error checking blockstore for manifest cid %s: %w", mfCid, err)
+			}
+
+			if has {
+				// it's there, no need to reload the bundle to the blockstore; just add it to the manifest list.
+				if val, ok := build.ActorsCIDs[av]; ok {
+					if val != mfCid {
+						return result, xerrors.Errorf("actors V%d manifest CID %s did not match CID given in params file: %s", av, mfCid, val)
+					}
+				}
+				actors.AddManifest(av, mfCid)
+				continue
+			}
+
+			// we have a release key but don't have the manifest in the blockstore; maybe the user
+			// nuked his blockstore to restart from a snapshot. So fallthrough to refetch (if necessary)
+			// and reload the bundle.
+
+		case dstore.ErrNotFound:
+			// we don't have a release key, we need to load the bundle
+
+		default:
+			return result, xerrors.Errorf("error loading %s from datastore: %w", key, err)
+		}
+
+		// we haven't recorded it in the datastore, so we need to load it
+		envvar := fmt.Sprintf("LOTUS_BUILTIN_ACTORS_V%d_BUNDLE", av)
+		var mfCid cid.Cid
+		switch {
+		case os.Getenv(envvar) != "":
+			path := os.Getenv(envvar)
+
+			mfCid, err = bundle.LoadBundle(ctx, bs, path, av)
+			if err != nil {
+				return result, err
+			}
+
+		case bd.Path[netw] != "":
+			// this is a local bundle, load it directly from the filessystem
+			mfCid, err = bundle.LoadBundle(ctx, bs, bd.Path[netw], av)
+			if err != nil {
+				return result, err
+			}
+
+		case bd.URL[netw].URL != "":
+			// fetch it from the specified URL
+			mfCid, err = bundle.FetchAndLoadBundleFromURL(ctx, r.Path(), bs, av, bd.Release, netw, bd.URL[netw].URL, bd.URL[netw].Checksum)
+			if err != nil {
+				return result, err
+			}
+
+		case bd.Release != "":
+			// fetch it and add it to the blockstore
+			mfCid, err = bundle.FetchAndLoadBundleFromRelease(ctx, r.Path(), bs, av, bd.Release, netw)
+			if err != nil {
+				return result, err
+			}
+
+		default:
+			return result, xerrors.Errorf("no release or path specified for version %d bundle", av)
+		}
+
+		if bd.Development || bd.Release == "" {
+			// don't store the release key so that we always load development bundles
+			continue
+		}
+
+		// add the release key with the manifest to avoid reloading it in next restart.
+		if err := ds.Put(ctx, key, mfCid.Bytes()); err != nil {
+			return result, xerrors.Errorf("error storing manifest CID for builtin-actors vrsion %d to the datastore: %w", av, err)
+		}
+	}
+
+	// we've loaded all the bundles, now load the manifests to get actor code CIDs.
+	cborStore := cbor.NewCborStore(bs)
+	if err := actors.LoadManifests(ctx, cborStore); err != nil {
+		return result, xerrors.Errorf("error loading actor manifests: %w", err)
+	}
+
+	return result, nil
+}
+
+// for itests
+var testingBundleMx sync.Mutex
+
+func LoadBuiltinActorsTesting(lc fx.Lifecycle, mctx helpers.MetricsCtx, bs dtypes.UniversalBlockstore) (result dtypes.BuiltinActorsLoaded, err error) {
+	ctx := helpers.LifecycleCtx(mctx, lc)
+
+	var netw string
+	if build.InsecurePoStValidation {
+		netw = "testing-fake-proofs"
+	} else {
+		netw = "testing"
+	}
+
+	testingBundleMx.Lock()
+	defer testingBundleMx.Unlock()
+
+	// don't clobber the bundle during migration
+	build.NetworkBundle = netw
+
+	const basePath = "/tmp/lotus-testing"
+	for av, bd := range build.BuiltinActorReleases {
+		switch {
+		case bd.Path[netw] != "":
+			if _, err := bundle.LoadBundle(ctx, bs, bd.Path[netw], av); err != nil {
+				return result, xerrors.Errorf("error loading testing bundle for builtin-actors version %d/%s: %w", av, netw, err)
+			}
+
+		case bd.URL[netw].URL != "":
+			// fetch it from the specified URL
+			if _, err := bundle.FetchAndLoadBundleFromURL(ctx, basePath, bs, av, bd.Release, netw, bd.URL[netw].URL, bd.URL[netw].Checksum); err != nil {
+				return result, err
+			}
+
+		case bd.Release != "":
+			if _, err := bundle.FetchAndLoadBundleFromRelease(ctx, basePath, bs, av, bd.Release, netw); err != nil {
+				return result, xerrors.Errorf("error loading testing bundle for builtin-actors version %d/%s: %w", av, netw, err)
+			}
+
+		default:
+			return result, xerrors.Errorf("no path or release specified for version %d testing bundle", av)
+		}
+	}
+
+	cborStore := cbor.NewCborStore(bs)
+	if err := actors.LoadManifests(ctx, cborStore); err != nil {
+		return result, xerrors.Errorf("error loading actor manifests: %w", err)
+	}
+
+	return result, nil
+}

node/modules/chain.go

@@ -18,6 +18,7 @@ import (
 	"github.com/filecoin-project/lotus/chain"
 	"github.com/filecoin-project/lotus/chain/beacon"
 	"github.com/filecoin-project/lotus/chain/consensus"
+	"github.com/filecoin-project/lotus/chain/consensus/filcns"
 	"github.com/filecoin-project/lotus/chain/exchange"
 	"github.com/filecoin-project/lotus/chain/gen/slashfilter"
 	"github.com/filecoin-project/lotus/chain/messagepool"
@@ -176,3 +177,7 @@ func NewSyncer(params SyncerParams) (*chain.Syncer, error) {
 func NewSlashFilter(ds dtypes.MetadataDS) *slashfilter.SlashFilter {
 	return slashfilter.New(ds)
 }
+
+func UpgradeSchedule(_ dtypes.BuiltinActorsLoaded) stmgr.UpgradeSchedule {
+	return filcns.DefaultUpgradeSchedule()
+}

node/modules/dtypes/chain.go

@@ -2,3 +2,4 @@ package dtypes
 
 type NetworkName string
 type AfterGenesisSet struct{}
+type BuiltinActorsLoaded struct{}

node/modules/genesis.go

@@ -22,8 +22,8 @@ func ErrorGenesis() Genesis {
 	}
 }
 
-func LoadGenesis(genBytes []byte) func(fx.Lifecycle, helpers.MetricsCtx, dtypes.ChainBlockstore) Genesis {
-	return func(lc fx.Lifecycle, mctx helpers.MetricsCtx, bs dtypes.ChainBlockstore) Genesis {
+func LoadGenesis(genBytes []byte) func(fx.Lifecycle, helpers.MetricsCtx, dtypes.ChainBlockstore, dtypes.BuiltinActorsLoaded) Genesis {
+	return func(lc fx.Lifecycle, mctx helpers.MetricsCtx, bs dtypes.ChainBlockstore, _ dtypes.BuiltinActorsLoaded) Genesis {
 		return func() (header *types.BlockHeader, e error) {
 			ctx := helpers.LifecycleCtx(mctx, lc)
 			c, err := car.LoadCar(ctx, bs, bytes.NewReader(genBytes))
@@ -49,7 +49,7 @@ func LoadGenesis(genBytes []byte) func(fx.Lifecycle, helpers.MetricsCtx, dtypes.
 
 func DoSetGenesis(_ dtypes.AfterGenesisSet) {}
 
-func SetGenesis(lc fx.Lifecycle, mctx helpers.MetricsCtx, cs *store.ChainStore, g Genesis) (dtypes.AfterGenesisSet, error) {
+func SetGenesis(lc fx.Lifecycle, mctx helpers.MetricsCtx, cs *store.ChainStore, g Genesis, _ dtypes.BuiltinActorsLoaded) (dtypes.AfterGenesisSet, error) {
 	ctx := helpers.LifecycleCtx(mctx, lc)
 	genFromRepo, err := cs.GetGenesis(ctx)
 	if err == nil {

node/modules/storageminer.go

@@ -219,6 +219,8 @@ type StorageMinerParams struct {
 	Journal            journal.Journal
 	AddrSel            *storage.AddressSelector
 	Maddr              dtypes.MinerAddress
+
+	ManifestLoaded dtypes.BuiltinActorsLoaded
 }
 
 func StorageMiner(fc config.MinerFeeConfig) func(params StorageMinerParams) (*storage.Miner, error) {

node/modules/testing/genesis.go

@@ -30,8 +30,8 @@ import (
 
 var glog = logging.Logger("genesis")
 
-func MakeGenesisMem(out io.Writer, template genesis.Template) func(bs dtypes.ChainBlockstore, syscalls vm.SyscallBuilder, j journal.Journal) modules.Genesis {
-	return func(bs dtypes.ChainBlockstore, syscalls vm.SyscallBuilder, j journal.Journal) modules.Genesis {
+func MakeGenesisMem(out io.Writer, template genesis.Template) func(bs dtypes.ChainBlockstore, syscalls vm.SyscallBuilder, j journal.Journal, _ dtypes.BuiltinActorsLoaded) modules.Genesis {
+	return func(bs dtypes.ChainBlockstore, syscalls vm.SyscallBuilder, j journal.Journal, _ dtypes.BuiltinActorsLoaded) modules.Genesis {
 		return func() (*types.BlockHeader, error) {
 			glog.Warn("Generating new random genesis block, note that this SHOULD NOT happen unless you are setting up new network")
 			b, err := genesis2.MakeGenesisBlock(context.TODO(), j, bs, syscalls, template)
@@ -51,8 +51,8 @@ func MakeGenesisMem(out io.Writer, template genesis.Template) func(bs dtypes.Cha
 	}
 }
 
-func MakeGenesis(outFile, genesisTemplate string) func(bs dtypes.ChainBlockstore, syscalls vm.SyscallBuilder, j journal.Journal) modules.Genesis {
-	return func(bs dtypes.ChainBlockstore, syscalls vm.SyscallBuilder, j journal.Journal) modules.Genesis {
+func MakeGenesis(outFile, genesisTemplate string) func(bs dtypes.ChainBlockstore, syscalls vm.SyscallBuilder, j journal.Journal, _ dtypes.BuiltinActorsLoaded) modules.Genesis {
+	return func(bs dtypes.ChainBlockstore, syscalls vm.SyscallBuilder, j journal.Journal, _ dtypes.BuiltinActorsLoaded) modules.Genesis {
 		return func() (*types.BlockHeader, error) {
 			glog.Warn("Generating new random genesis block, note that this SHOULD NOT happen unless you are setting up new network")
 			genesisTemplate, err := homedir.Expand(genesisTemplate)