Merge pull request #6330 from filecoin-project/revert-6305-asr/genesis-actor

Revert "Allow starting networks from arbitrary actor versions"

build/params_2k.go

@@ -24,20 +24,20 @@ var UpgradeIgnitionHeight = abi.ChainEpoch(-2)
 var UpgradeRefuelHeight = abi.ChainEpoch(-3)
 var UpgradeTapeHeight = abi.ChainEpoch(-4)
 
-var UpgradeActorsV2Height = abi.ChainEpoch(-5)
+var UpgradeActorsV2Height = abi.ChainEpoch(10)
-var UpgradeLiftoffHeight = abi.ChainEpoch(-6)
+var UpgradeLiftoffHeight = abi.ChainEpoch(-5)
 
-var UpgradeKumquatHeight = abi.ChainEpoch(-7)
+var UpgradeKumquatHeight = abi.ChainEpoch(15)
-var UpgradeCalicoHeight = abi.ChainEpoch(-8)
+var UpgradeCalicoHeight = abi.ChainEpoch(20)
-var UpgradePersianHeight = abi.ChainEpoch(-9)
+var UpgradePersianHeight = abi.ChainEpoch(25)
-var UpgradeOrangeHeight = abi.ChainEpoch(-10)
+var UpgradeOrangeHeight = abi.ChainEpoch(27)
-var UpgradeClausHeight = abi.ChainEpoch(-11)
+var UpgradeClausHeight = abi.ChainEpoch(30)
 
-var UpgradeActorsV3Height = abi.ChainEpoch(-12)
+var UpgradeActorsV3Height = abi.ChainEpoch(35)
 
-var UpgradeNorwegianHeight = abi.ChainEpoch(-13)
+var UpgradeNorwegianHeight = abi.ChainEpoch(40)
 
-var UpgradeActorsV4Height = abi.ChainEpoch(-14)
+var UpgradeActorsV4Height = abi.ChainEpoch(45)
 
 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 	0: DrandMainnet,

build/params_shared_vals.go

@@ -25,7 +25,7 @@ const UnixfsLinksPerLevel = 1024
 // Consensus / Network
 
 const AllowableClockDriftSecs = uint64(1)
-const NewestNetworkVersion = network.Version12
+const NewestNetworkVersion = network.Version11
 const ActorUpgradeNetworkVersion = network.Version4
 
 // Epochs

chain/actors/agen/main.go

@@ -6,26 +6,33 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
-	"strconv"
 	"text/template"
 
-	lotusactors "github.com/filecoin-project/lotus/chain/actors"
-
 	"golang.org/x/xerrors"
 )
 
+var latestVersion = 4
+
+var versions = []int{0, 2, 3, latestVersion}
+
+var versionImports = map[int]string{
+	0:             "/",
+	2:             "/v2/",
+	3:             "/v3/",
+	latestVersion: "/v4/",
+}
+
 var actors = map[string][]int{
-	"account":  lotusactors.Versions,
+	"account":  versions,
-	"cron":     lotusactors.Versions,
+	"cron":     versions,
-	"init":     lotusactors.Versions,
+	"init":     versions,
-	"market":   lotusactors.Versions,
+	"market":   versions,
-	"miner":    lotusactors.Versions,
+	"miner":    versions,
-	"multisig": lotusactors.Versions,
+	"multisig": versions,
-	"paych":    lotusactors.Versions,
+	"paych":    versions,
-	"power":    lotusactors.Versions,
+	"power":    versions,
-	"system":   lotusactors.Versions,
+	"reward":   versions,
-	"reward":   lotusactors.Versions,
+	"verifreg": versions,
-	"verifreg": lotusactors.Versions,
 }
 
 func main() {
@@ -64,14 +71,14 @@ func generateAdapters() error {
 			}
 
 			tpl := template.Must(template.New("").Funcs(template.FuncMap{
-				"import": func(v int) string { return getVersionImports()[v] },
+				"import": func(v int) string { return versionImports[v] },
 			}).Parse(string(af)))
 
 			var b bytes.Buffer
 
 			err = tpl.Execute(&b, map[string]interface{}{
 				"versions":      versions,
-				"latestVersion": lotusactors.LatestVersion,
+				"latestVersion": latestVersion,
 			})
 			if err != nil {
 				return err
@@ -96,14 +103,14 @@ func generateState(actDir string) error {
 		return xerrors.Errorf("loading state adapter template: %w", err)
 	}
 
-	for _, version := range lotusactors.Versions {
+	for _, version := range versions {
 		tpl := template.Must(template.New("").Funcs(template.FuncMap{}).Parse(string(af)))
 
 		var b bytes.Buffer
 
 		err := tpl.Execute(&b, map[string]interface{}{
 			"v":      version,
-			"import": getVersionImports()[version],
+			"import": versionImports[version],
 		})
 		if err != nil {
 			return err
@@ -127,14 +134,14 @@ func generateMessages(actDir string) error {
 		return xerrors.Errorf("loading message adapter template: %w", err)
 	}
 
-	for _, version := range lotusactors.Versions {
+	for _, version := range versions {
 		tpl := template.Must(template.New("").Funcs(template.FuncMap{}).Parse(string(af)))
 
 		var b bytes.Buffer
 
 		err := tpl.Execute(&b, map[string]interface{}{
 			"v":      version,
-			"import": getVersionImports()[version],
+			"import": versionImports[version],
 		})
 		if err != nil {
 			return err
@@ -160,13 +167,13 @@ func generatePolicy(policyPath string) error {
 	}
 
 	tpl := template.Must(template.New("").Funcs(template.FuncMap{
-		"import": func(v int) string { return getVersionImports()[v] },
+		"import": func(v int) string { return versionImports[v] },
 	}).Parse(string(pf)))
 	var b bytes.Buffer
 
 	err = tpl.Execute(&b, map[string]interface{}{
-		"versions":      lotusactors.Versions,
+		"versions":      versions,
-		"latestVersion": lotusactors.LatestVersion,
+		"latestVersion": latestVersion,
 	})
 	if err != nil {
 		return err
@@ -191,13 +198,13 @@ func generateBuiltin(builtinPath string) error {
 	}
 
 	tpl := template.Must(template.New("").Funcs(template.FuncMap{
-		"import": func(v int) string { return getVersionImports()[v] },
+		"import": func(v int) string { return versionImports[v] },
 	}).Parse(string(bf)))
 	var b bytes.Buffer
 
 	err = tpl.Execute(&b, map[string]interface{}{
-		"versions":      lotusactors.Versions,
+		"versions":      versions,
-		"latestVersion": lotusactors.LatestVersion,
+		"latestVersion": latestVersion,
 	})
 	if err != nil {
 		return err
@@ -209,16 +216,3 @@ func generateBuiltin(builtinPath string) error {
 
 	return nil
 }
-
-func getVersionImports() map[int]string {
-	versionImports := make(map[int]string, lotusactors.LatestVersion)
-	for _, v := range lotusactors.Versions {
-		if v == 0 {
-			versionImports[v] = "/"
-		} else {
-			versionImports[v] = "/v" + strconv.Itoa(v) + "/"
-		}
-	}
-
-	return versionImports
-}

chain/actors/builtin/account/account.go

@@ -1,7 +1,6 @@
 package account
 
 import (
-	"github.com/filecoin-project/lotus/chain/actors"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
@@ -61,48 +60,8 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version, addr address.Address) (State, error) {
-	switch av {
-
-	case actors.Version0:
-		return make0(store, addr)
-
-	case actors.Version2:
-		return make2(store, addr)
-
-	case actors.Version3:
-		return make3(store, addr)
-
-	case actors.Version4:
-		return make4(store, addr)
-
-	}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-
-	case actors.Version0:
-		return builtin0.AccountActorCodeID, nil
-
-	case actors.Version2:
-		return builtin2.AccountActorCodeID, nil
-
-	case actors.Version3:
-		return builtin3.AccountActorCodeID, nil
-
-	case actors.Version4:
-		return builtin4.AccountActorCodeID, nil
-
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 type State interface {
 	cbor.Marshaler
 
 	PubkeyAddress() (address.Address, error)
-	GetState() interface{}
 }

chain/actors/builtin/account/actor.go.template

@@ -1,7 +1,6 @@
 package account
 
 import (
-	"github.com/filecoin-project/lotus/chain/actors"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
@@ -35,30 +34,8 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version, addr address.Address) (State, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return make{{.}}(store, addr)
-{{end}}
-}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return builtin{{.}}.AccountActorCodeID, nil
-{{end}}
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 type State interface {
 	cbor.Marshaler
 
 	PubkeyAddress() (address.Address, error)
-	GetState() interface{}
 }

chain/actors/builtin/account/state.go.template

@@ -20,12 +20,6 @@ func load{{.v}}(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make{{.v}}(store adt.Store, addr address.Address) (State, error) {
-	out := state{{.v}}{store: store}
-	out.State = account{{.v}}.State{Address:addr}
-	return &out, nil
-}
-
 type state{{.v}} struct {
 	account{{.v}}.State
 	store adt.Store
@@ -34,7 +28,3 @@ type state{{.v}} struct {
 func (s *state{{.v}}) PubkeyAddress() (address.Address, error) {
 	return s.Address, nil
 }
-
-func (s *state{{.v}}) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/account/v0.go

@@ -20,12 +20,6 @@ func load0(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make0(store adt.Store, addr address.Address) (State, error) {
-	out := state0{store: store}
-	out.State = account0.State{Address: addr}
-	return &out, nil
-}
-
 type state0 struct {
 	account0.State
 	store adt.Store
@@ -34,7 +28,3 @@ type state0 struct {
 func (s *state0) PubkeyAddress() (address.Address, error) {
 	return s.Address, nil
 }
-
-func (s *state0) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/account/v2.go

@@ -20,12 +20,6 @@ func load2(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make2(store adt.Store, addr address.Address) (State, error) {
-	out := state2{store: store}
-	out.State = account2.State{Address: addr}
-	return &out, nil
-}
-
 type state2 struct {
 	account2.State
 	store adt.Store
@@ -34,7 +28,3 @@ type state2 struct {
 func (s *state2) PubkeyAddress() (address.Address, error) {
 	return s.Address, nil
 }
-
-func (s *state2) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/account/v3.go

@@ -20,12 +20,6 @@ func load3(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make3(store adt.Store, addr address.Address) (State, error) {
-	out := state3{store: store}
-	out.State = account3.State{Address: addr}
-	return &out, nil
-}
-
 type state3 struct {
 	account3.State
 	store adt.Store
@@ -34,7 +28,3 @@ type state3 struct {
 func (s *state3) PubkeyAddress() (address.Address, error) {
 	return s.Address, nil
 }
-
-func (s *state3) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/account/v4.go

@@ -20,12 +20,6 @@ func load4(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make4(store adt.Store, addr address.Address) (State, error) {
-	out := state4{store: store}
-	out.State = account4.State{Address: addr}
-	return &out, nil
-}
-
 type state4 struct {
 	account4.State
 	store adt.Store
@@ -34,7 +28,3 @@ type state4 struct {
 func (s *state4) PubkeyAddress() (address.Address, error) {
 	return s.Address, nil
 }
-
-func (s *state4) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/cron/actor.go.template

@@ -1,42 +1,10 @@
 package cron
 
 import (
-	"github.com/filecoin-project/lotus/chain/actors"
+	builtin{{.latestVersion}} "github.com/filecoin-project/specs-actors{{import .latestVersion}}actors/builtin"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"golang.org/x/xerrors"
-	"github.com/ipfs/go-cid"
-{{range .versions}}
-	builtin{{.}} "github.com/filecoin-project/specs-actors{{import .}}actors/builtin"
-{{end}}
 )
 
-func MakeState(store adt.Store, av actors.Version) (State, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return make{{.}}(store)
-{{end}}
-}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return builtin{{.}}.CronActorCodeID, nil
-{{end}}
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 var (
 	Address = builtin{{.latestVersion}}.CronActorAddr
 	Methods = builtin{{.latestVersion}}.MethodsCron
 )
-
-
-type State interface {
-	GetState() interface{}
-}

chain/actors/builtin/cron/cron.go

@@ -1,64 +1,10 @@
 package cron
 
 import (
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-
 	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 )
 
-func MakeState(store adt.Store, av actors.Version) (State, error) {
-	switch av {
-
-	case actors.Version0:
-		return make0(store)
-
-	case actors.Version2:
-		return make2(store)
-
-	case actors.Version3:
-		return make3(store)
-
-	case actors.Version4:
-		return make4(store)
-
-	}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-
-	case actors.Version0:
-		return builtin0.CronActorCodeID, nil
-
-	case actors.Version2:
-		return builtin2.CronActorCodeID, nil
-
-	case actors.Version3:
-		return builtin3.CronActorCodeID, nil
-
-	case actors.Version4:
-		return builtin4.CronActorCodeID, nil
-
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 var (
 	Address = builtin4.CronActorAddr
 	Methods = builtin4.MethodsCron
 )
-
-type State interface {
-	GetState() interface{}
-}

chain/actors/builtin/cron/state.go.template

@@ -1,35 +0,0 @@
-package cron
-
-import (
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	cron{{.v}} "github.com/filecoin-project/specs-actors{{.import}}actors/builtin/cron"
-)
-
-var _ State = (*state{{.v}})(nil)
-
-func load{{.v}}(store adt.Store, root cid.Cid) (State, error) {
-	out := state{{.v}}{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-func make{{.v}}(store adt.Store) (State, error) {
-	out := state{{.v}}{store: store}
-	out.State = *cron{{.v}}.ConstructState(cron{{.v}}.BuiltInEntries())
-	return &out, nil
-}
-
-type state{{.v}} struct {
-	cron{{.v}}.State
-	store adt.Store
-}
-
-func (s *state{{.v}}) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/cron/v0.go

@@ -1,35 +0,0 @@
-package cron
-
-import (
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	cron0 "github.com/filecoin-project/specs-actors/actors/builtin/cron"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-func make0(store adt.Store) (State, error) {
-	out := state0{store: store}
-	out.State = *cron0.ConstructState(cron0.BuiltInEntries())
-	return &out, nil
-}
-
-type state0 struct {
-	cron0.State
-	store adt.Store
-}
-
-func (s *state0) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/cron/v2.go

@@ -1,35 +0,0 @@
-package cron
-
-import (
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	cron2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/cron"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-func make2(store adt.Store) (State, error) {
-	out := state2{store: store}
-	out.State = *cron2.ConstructState(cron2.BuiltInEntries())
-	return &out, nil
-}
-
-type state2 struct {
-	cron2.State
-	store adt.Store
-}
-
-func (s *state2) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/cron/v3.go

@@ -1,35 +0,0 @@
-package cron
-
-import (
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	cron3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/cron"
-)
-
-var _ State = (*state3)(nil)
-
-func load3(store adt.Store, root cid.Cid) (State, error) {
-	out := state3{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-func make3(store adt.Store) (State, error) {
-	out := state3{store: store}
-	out.State = *cron3.ConstructState(cron3.BuiltInEntries())
-	return &out, nil
-}
-
-type state3 struct {
-	cron3.State
-	store adt.Store
-}
-
-func (s *state3) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/cron/v4.go

@@ -1,35 +0,0 @@
-package cron
-
-import (
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	cron4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/cron"
-)
-
-var _ State = (*state4)(nil)
-
-func load4(store adt.Store, root cid.Cid) (State, error) {
-	out := state4{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-func make4(store adt.Store) (State, error) {
-	out := state4{store: store}
-	out.State = *cron4.ConstructState(cron4.BuiltInEntries())
-	return &out, nil
-}
-
-type state4 struct {
-	cron4.State
-	store adt.Store
-}
-
-func (s *state4) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/init/actor.go.template

@@ -1,7 +1,6 @@
 package init
 
 import (
-	"github.com/filecoin-project/lotus/chain/actors"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
@@ -40,27 +39,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version, networkName string) (State, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return make{{.}}(store, networkName)
-{{end}}
-}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return builtin{{.}}.InitActorCodeID, nil
-{{end}}
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 type State interface {
 	cbor.Marshaler
 
@@ -78,12 +56,5 @@ type State interface {
 	// Sets the network's name. This should only be used on upgrade/fork.
 	SetNetworkName(name string) error
 
-	// Sets the next ID for the init actor. This should only be used for testing.
+	addressMap() (adt.Map, error)
-	SetNextID(id abi.ActorID) error
-
-	// Sets the address map for the init actor. This should only be used for testing.
-	SetAddressMap(mcid cid.Cid) error
-
-	AddressMap() (adt.Map, error)
-	GetState() interface{}
 }

chain/actors/builtin/init/diff.go

@@ -11,12 +11,12 @@ import (
 )
 
 func DiffAddressMap(pre, cur State) (*AddressMapChanges, error) {
-	prem, err := pre.AddressMap()
+	prem, err := pre.addressMap()
 	if err != nil {
 		return nil, err
 	}
 
-	curm, err := cur.AddressMap()
+	curm, err := cur.addressMap()
 	if err != nil {
 		return nil, err
 	}

chain/actors/builtin/init/init.go

@@ -1,7 +1,6 @@
 package init
 
 import (
-	"github.com/filecoin-project/lotus/chain/actors"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
@@ -66,45 +65,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version, networkName string) (State, error) {
-	switch av {
-
-	case actors.Version0:
-		return make0(store, networkName)
-
-	case actors.Version2:
-		return make2(store, networkName)
-
-	case actors.Version3:
-		return make3(store, networkName)
-
-	case actors.Version4:
-		return make4(store, networkName)
-
-	}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-
-	case actors.Version0:
-		return builtin0.InitActorCodeID, nil
-
-	case actors.Version2:
-		return builtin2.InitActorCodeID, nil
-
-	case actors.Version3:
-		return builtin3.InitActorCodeID, nil
-
-	case actors.Version4:
-		return builtin4.InitActorCodeID, nil
-
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 type State interface {
 	cbor.Marshaler
 
@@ -122,12 +82,5 @@ type State interface {
 	// Sets the network's name. This should only be used on upgrade/fork.
 	SetNetworkName(name string) error
 
-	// Sets the next ID for the init actor. This should only be used for testing.
+	addressMap() (adt.Map, error)
-	SetNextID(id abi.ActorID) error
-
-	// Sets the address map for the init actor. This should only be used for testing.
-	SetAddressMap(mcid cid.Cid) error
-
-	AddressMap() (adt.Map, error)
-	GetState() interface{}
 }

chain/actors/builtin/init/state.go.template

@@ -29,26 +29,6 @@ func load{{.v}}(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make{{.v}}(store adt.Store, networkName string) (State, error) {
-	out := state{{.v}}{store: store}
-	{{if (le .v 2)}}
-		mr, err := adt{{.v}}.MakeEmptyMap(store).Root()
-		if err != nil {
-			return nil, err
-		}
-
-		out.State = *init{{.v}}.ConstructState(mr, networkName)
-	{{else}}
-		s, err := init{{.v}}.ConstructState(store, networkName)
-		if err != nil {
-			return nil, err
-		}
-
-		out.State = *s
-	{{end}}
-	return &out, nil
-}
-
 type state{{.v}} struct {
 	init{{.v}}.State
 	store adt.Store
@@ -86,11 +66,6 @@ func (s *state{{.v}}) SetNetworkName(name string) error {
 	return nil
 }
 
-func (s *state{{.v}}) SetNextID(id abi.ActorID) error {
-	s.State.NextID = id
-	return nil
-}
-
 func (s *state{{.v}}) Remove(addrs ...address.Address) (err error) {
 	m, err := adt{{.v}}.AsMap(s.store, s.State.AddressMap{{if (ge .v 3)}}, builtin{{.v}}.DefaultHamtBitwidth{{end}})
 	if err != nil {
@@ -109,15 +84,6 @@ func (s *state{{.v}}) Remove(addrs ...address.Address) (err error) {
 	return nil
 }
 
-func (s *state{{.v}}) SetAddressMap(mcid cid.Cid) error {
+func (s *state{{.v}}) addressMap() (adt.Map, error) {
-	s.State.AddressMap = mcid
+	return adt{{.v}}.AsMap(s.store, s.AddressMap{{if (ge .v 3)}}, builtin{{.v}}.DefaultHamtBitwidth{{end}})
-	return nil
-}
-
-func (s *state{{.v}}) AddressMap() (adt.Map, error) {
-	return adt{{.v}}.AsMap(s.store, s.State.AddressMap{{if (ge .v 3)}}, builtin{{.v}}.DefaultHamtBitwidth{{end}})
-}
-
-func (s *state{{.v}}) GetState() interface{} {
-	return &s.State
 }

chain/actors/builtin/init/v0.go

@@ -25,19 +25,6 @@ func load0(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make0(store adt.Store, networkName string) (State, error) {
-	out := state0{store: store}
-
-	mr, err := adt0.MakeEmptyMap(store).Root()
-	if err != nil {
-		return nil, err
-	}
-
-	out.State = *init0.ConstructState(mr, networkName)
-
-	return &out, nil
-}
-
 type state0 struct {
 	init0.State
 	store adt.Store
@@ -75,11 +62,6 @@ func (s *state0) SetNetworkName(name string) error {
 	return nil
 }
 
-func (s *state0) SetNextID(id abi.ActorID) error {
-	s.State.NextID = id
-	return nil
-}
-
 func (s *state0) Remove(addrs ...address.Address) (err error) {
 	m, err := adt0.AsMap(s.store, s.State.AddressMap)
 	if err != nil {
@@ -98,15 +80,6 @@ func (s *state0) Remove(addrs ...address.Address) (err error) {
 	return nil
 }
 
-func (s *state0) SetAddressMap(mcid cid.Cid) error {
+func (s *state0) addressMap() (adt.Map, error) {
-	s.State.AddressMap = mcid
+	return adt0.AsMap(s.store, s.AddressMap)
-	return nil
-}
-
-func (s *state0) AddressMap() (adt.Map, error) {
-	return adt0.AsMap(s.store, s.State.AddressMap)
-}
-
-func (s *state0) GetState() interface{} {
-	return &s.State
 }

chain/actors/builtin/init/v2.go

@@ -25,19 +25,6 @@ func load2(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make2(store adt.Store, networkName string) (State, error) {
-	out := state2{store: store}
-
-	mr, err := adt2.MakeEmptyMap(store).Root()
-	if err != nil {
-		return nil, err
-	}
-
-	out.State = *init2.ConstructState(mr, networkName)
-
-	return &out, nil
-}
-
 type state2 struct {
 	init2.State
 	store adt.Store
@@ -75,11 +62,6 @@ func (s *state2) SetNetworkName(name string) error {
 	return nil
 }
 
-func (s *state2) SetNextID(id abi.ActorID) error {
-	s.State.NextID = id
-	return nil
-}
-
 func (s *state2) Remove(addrs ...address.Address) (err error) {
 	m, err := adt2.AsMap(s.store, s.State.AddressMap)
 	if err != nil {
@@ -98,15 +80,6 @@ func (s *state2) Remove(addrs ...address.Address) (err error) {
 	return nil
 }
 
-func (s *state2) SetAddressMap(mcid cid.Cid) error {
+func (s *state2) addressMap() (adt.Map, error) {
-	s.State.AddressMap = mcid
+	return adt2.AsMap(s.store, s.AddressMap)
-	return nil
-}
-
-func (s *state2) AddressMap() (adt.Map, error) {
-	return adt2.AsMap(s.store, s.State.AddressMap)
-}
-
-func (s *state2) GetState() interface{} {
-	return &s.State
 }

chain/actors/builtin/init/v3.go

@@ -27,19 +27,6 @@ func load3(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make3(store adt.Store, networkName string) (State, error) {
-	out := state3{store: store}
-
-	s, err := init3.ConstructState(store, networkName)
-	if err != nil {
-		return nil, err
-	}
-
-	out.State = *s
-
-	return &out, nil
-}
-
 type state3 struct {
 	init3.State
 	store adt.Store
@@ -77,11 +64,6 @@ func (s *state3) SetNetworkName(name string) error {
 	return nil
 }
 
-func (s *state3) SetNextID(id abi.ActorID) error {
-	s.State.NextID = id
-	return nil
-}
-
 func (s *state3) Remove(addrs ...address.Address) (err error) {
 	m, err := adt3.AsMap(s.store, s.State.AddressMap, builtin3.DefaultHamtBitwidth)
 	if err != nil {
@@ -100,15 +82,6 @@ func (s *state3) Remove(addrs ...address.Address) (err error) {
 	return nil
 }
 
-func (s *state3) SetAddressMap(mcid cid.Cid) error {
+func (s *state3) addressMap() (adt.Map, error) {
-	s.State.AddressMap = mcid
+	return adt3.AsMap(s.store, s.AddressMap, builtin3.DefaultHamtBitwidth)
-	return nil
-}
-
-func (s *state3) AddressMap() (adt.Map, error) {
-	return adt3.AsMap(s.store, s.State.AddressMap, builtin3.DefaultHamtBitwidth)
-}
-
-func (s *state3) GetState() interface{} {
-	return &s.State
 }

chain/actors/builtin/init/v4.go

@@ -27,19 +27,6 @@ func load4(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make4(store adt.Store, networkName string) (State, error) {
-	out := state4{store: store}
-
-	s, err := init4.ConstructState(store, networkName)
-	if err != nil {
-		return nil, err
-	}
-
-	out.State = *s
-
-	return &out, nil
-}
-
 type state4 struct {
 	init4.State
 	store adt.Store
@@ -77,11 +64,6 @@ func (s *state4) SetNetworkName(name string) error {
 	return nil
 }
 
-func (s *state4) SetNextID(id abi.ActorID) error {
-	s.State.NextID = id
-	return nil
-}
-
 func (s *state4) Remove(addrs ...address.Address) (err error) {
 	m, err := adt4.AsMap(s.store, s.State.AddressMap, builtin4.DefaultHamtBitwidth)
 	if err != nil {
@@ -100,15 +82,6 @@ func (s *state4) Remove(addrs ...address.Address) (err error) {
 	return nil
 }
 
-func (s *state4) SetAddressMap(mcid cid.Cid) error {
+func (s *state4) addressMap() (adt.Map, error) {
-	s.State.AddressMap = mcid
+	return adt4.AsMap(s.store, s.AddressMap, builtin4.DefaultHamtBitwidth)
-	return nil
-}
-
-func (s *state4) AddressMap() (adt.Map, error) {
-	return adt4.AsMap(s.store, s.State.AddressMap, builtin4.DefaultHamtBitwidth)
-}
-
-func (s *state4) GetState() interface{} {
-	return &s.State
 }

chain/actors/builtin/market/actor.go.template

@@ -16,7 +16,6 @@ import (
 {{end}}
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 )
@@ -43,27 +42,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version) (State, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return make{{.}}(store)
-{{end}}
-}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return builtin{{.}}.StorageMarketActorCodeID, nil
-{{end}}
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 type State interface {
 	cbor.Marshaler
 	BalancesChanged(State) (bool, error)
@@ -78,7 +56,6 @@ type State interface {
 		minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
 	) (weight, verifiedWeight abi.DealWeight, err error)
 	NextID() (abi.DealID, error)
-	GetState() interface{}
 }
 
 type BalanceTable interface {
@@ -104,6 +81,7 @@ type DealProposals interface {
 
 type PublishStorageDealsParams = market0.PublishStorageDealsParams
 type PublishStorageDealsReturn = market0.PublishStorageDealsReturn
+type VerifyDealsForActivationParams = market0.VerifyDealsForActivationParams
 type WithdrawBalanceParams = market0.WithdrawBalanceParams
 
 type ClientDealProposal = market0.ClientDealProposal

chain/actors/builtin/market/market.go

@@ -20,7 +20,6 @@ import (
 
 	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 
-	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -69,45 +68,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version) (State, error) {
-	switch av {
-
-	case actors.Version0:
-		return make0(store)
-
-	case actors.Version2:
-		return make2(store)
-
-	case actors.Version3:
-		return make3(store)
-
-	case actors.Version4:
-		return make4(store)
-
-	}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-
-	case actors.Version0:
-		return builtin0.StorageMarketActorCodeID, nil
-
-	case actors.Version2:
-		return builtin2.StorageMarketActorCodeID, nil
-
-	case actors.Version3:
-		return builtin3.StorageMarketActorCodeID, nil
-
-	case actors.Version4:
-		return builtin4.StorageMarketActorCodeID, nil
-
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 type State interface {
 	cbor.Marshaler
 	BalancesChanged(State) (bool, error)
@@ -122,7 +82,6 @@ type State interface {
 		minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
 	) (weight, verifiedWeight abi.DealWeight, err error)
 	NextID() (abi.DealID, error)
-	GetState() interface{}
 }
 
 type BalanceTable interface {
@@ -148,6 +107,7 @@ type DealProposals interface {
 
 type PublishStorageDealsParams = market0.PublishStorageDealsParams
 type PublishStorageDealsReturn = market0.PublishStorageDealsReturn
+type VerifyDealsForActivationParams = market0.VerifyDealsForActivationParams
 type WithdrawBalanceParams = market0.WithdrawBalanceParams
 
 type ClientDealProposal = market0.ClientDealProposal

chain/actors/builtin/market/state.go.template

@@ -26,31 +26,6 @@ func load{{.v}}(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make{{.v}}(store adt.Store) (State, error) {
-	out := state{{.v}}{store: store}
-	{{if (le .v 2)}}
-		ea, err := adt{{.v}}.MakeEmptyArray(store).Root()
-		if err != nil {
-			return nil, err
-		}
-
-		em, err := adt{{.v}}.MakeEmptyMap(store).Root()
-		if err != nil {
-			return nil, err
-		}
-
-		out.State = *market{{.v}}.ConstructState(ea, em, em)
-	{{else}}
-		s, err := market{{.v}}.ConstructState(store)
-		if err != nil {
-			return nil, err
-		}
-
-		out.State = *s
-	{{end}}
-	return &out, nil
-}
-
 type state{{.v}} struct {
 	market{{.v}}.State
 	store adt.Store
@@ -232,7 +207,3 @@ func (s *dealProposals{{.v}}) array() adt.Array {
 func fromV{{.v}}DealProposal(v{{.v}} market{{.v}}.DealProposal) DealProposal {
 	return (DealProposal)(v{{.v}})
 }
-
-func (s *state{{.v}}) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/market/v0.go

@@ -26,24 +26,6 @@ func load0(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make0(store adt.Store) (State, error) {
-	out := state0{store: store}
-
-	ea, err := adt0.MakeEmptyArray(store).Root()
-	if err != nil {
-		return nil, err
-	}
-
-	em, err := adt0.MakeEmptyMap(store).Root()
-	if err != nil {
-		return nil, err
-	}
-
-	out.State = *market0.ConstructState(ea, em, em)
-
-	return &out, nil
-}
-
 type state0 struct {
 	market0.State
 	store adt.Store
@@ -225,7 +207,3 @@ func (s *dealProposals0) array() adt.Array {
 func fromV0DealProposal(v0 market0.DealProposal) DealProposal {
 	return (DealProposal)(v0)
 }
-
-func (s *state0) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/market/v2.go

@@ -26,24 +26,6 @@ func load2(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make2(store adt.Store) (State, error) {
-	out := state2{store: store}
-
-	ea, err := adt2.MakeEmptyArray(store).Root()
-	if err != nil {
-		return nil, err
-	}
-
-	em, err := adt2.MakeEmptyMap(store).Root()
-	if err != nil {
-		return nil, err
-	}
-
-	out.State = *market2.ConstructState(ea, em, em)
-
-	return &out, nil
-}
-
 type state2 struct {
 	market2.State
 	store adt.Store
@@ -225,7 +207,3 @@ func (s *dealProposals2) array() adt.Array {
 func fromV2DealProposal(v2 market2.DealProposal) DealProposal {
 	return (DealProposal)(v2)
 }
-
-func (s *state2) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/market/v3.go

@@ -26,19 +26,6 @@ func load3(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make3(store adt.Store) (State, error) {
-	out := state3{store: store}
-
-	s, err := market3.ConstructState(store)
-	if err != nil {
-		return nil, err
-	}
-
-	out.State = *s
-
-	return &out, nil
-}
-
 type state3 struct {
 	market3.State
 	store adt.Store
@@ -220,7 +207,3 @@ func (s *dealProposals3) array() adt.Array {
 func fromV3DealProposal(v3 market3.DealProposal) DealProposal {
 	return (DealProposal)(v3)
 }
-
-func (s *state3) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/market/v4.go

@@ -26,19 +26,6 @@ func load4(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make4(store adt.Store) (State, error) {
-	out := state4{store: store}
-
-	s, err := market4.ConstructState(store)
-	if err != nil {
-		return nil, err
-	}
-
-	out.State = *s
-
-	return &out, nil
-}
-
 type state4 struct {
 	market4.State
 	store adt.Store
@@ -220,7 +207,3 @@ func (s *dealProposals4) array() adt.Array {
 func fromV4DealProposal(v4 market4.DealProposal) DealProposal {
 	return (DealProposal)(v4)
 }
-
-func (s *state4) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/miner/actor.go.template

@@ -3,7 +3,6 @@ package miner
 import (
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/network"
-	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/ipfs/go-cid"
 	"github.com/libp2p/go-libp2p-core/peer"
 	cbg "github.com/whyrusleeping/cbor-gen"
@@ -61,27 +60,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version) (State, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return make{{.}}(store)
-{{end}}
-}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return builtin{{.}}.StorageMinerActorCodeID, nil
-{{end}}
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 type State interface {
 	cbor.Marshaler
 
@@ -101,11 +79,6 @@ type State interface {
 	NumLiveSectors() (uint64, error)
 	IsAllocated(abi.SectorNumber) (bool, error)
 
-	// Note that ProvingPeriodStart is deprecated and will be renamed / removed in a future version of actors
-	GetProvingPeriodStart() (abi.ChainEpoch, error)
-	// Testing only
-	EraseAllUnproven() error
-
 	LoadDeadline(idx uint64) (Deadline, error)
 	ForEachDeadline(cb func(idx uint64, dl Deadline) error) error
 	NumDeadlines() (uint64, error)
@@ -122,7 +95,6 @@ type State interface {
 	decodeSectorOnChainInfo(*cbg.Deferred) (SectorOnChainInfo, error)
 	precommits() (adt.Map, error)
 	decodeSectorPreCommitOnChainInfo(*cbg.Deferred) (SectorPreCommitOnChainInfo, error)
-	GetState() interface{}
 }
 
 type Deadline interface {

chain/actors/builtin/miner/miner.go

@@ -3,7 +3,6 @@ package miner
 import (
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/network"
-	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/ipfs/go-cid"
 	"github.com/libp2p/go-libp2p-core/peer"
 	cbg "github.com/whyrusleeping/cbor-gen"
@@ -87,45 +86,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version) (State, error) {
-	switch av {
-
-	case actors.Version0:
-		return make0(store)
-
-	case actors.Version2:
-		return make2(store)
-
-	case actors.Version3:
-		return make3(store)
-
-	case actors.Version4:
-		return make4(store)
-
-	}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-
-	case actors.Version0:
-		return builtin0.StorageMinerActorCodeID, nil
-
-	case actors.Version2:
-		return builtin2.StorageMinerActorCodeID, nil
-
-	case actors.Version3:
-		return builtin3.StorageMinerActorCodeID, nil
-
-	case actors.Version4:
-		return builtin4.StorageMinerActorCodeID, nil
-
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 type State interface {
 	cbor.Marshaler
 
@@ -145,11 +105,6 @@ type State interface {
 	NumLiveSectors() (uint64, error)
 	IsAllocated(abi.SectorNumber) (bool, error)
 
-	// Note that ProvingPeriodStart is deprecated and will be renamed / removed in a future version of actors
-	GetProvingPeriodStart() (abi.ChainEpoch, error)
-	// Testing only
-	EraseAllUnproven() error
-
 	LoadDeadline(idx uint64) (Deadline, error)
 	ForEachDeadline(cb func(idx uint64, dl Deadline) error) error
 	NumDeadlines() (uint64, error)
@@ -166,7 +121,6 @@ type State interface {
 	decodeSectorOnChainInfo(*cbg.Deferred) (SectorOnChainInfo, error)
 	precommits() (adt.Map, error)
 	decodeSectorPreCommitOnChainInfo(*cbg.Deferred) (SectorPreCommitOnChainInfo, error)
-	GetState() interface{}
 }
 
 type Deadline interface {

chain/actors/builtin/miner/state.go.template

@@ -35,12 +35,6 @@ func load{{.v}}(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make{{.v}}(store adt.Store) (State, error) {
-	out := state{{.v}}{store: store}
-	out.State = miner{{.v}}.State{}
-	return &out, nil
-}
-
 type state{{.v}} struct {
 	miner{{.v}}.State
 	store adt.Store
@@ -251,10 +245,6 @@ func (s *state{{.v}}) IsAllocated(num abi.SectorNumber) (bool, error) {
 	return allocatedSectors.IsSet(uint64(num))
 }
 
-func (s *state{{.v}}) GetProvingPeriodStart() (abi.ChainEpoch, error) {
-	return s.State.ProvingPeriodStart, nil
-}
-
 func (s *state{{.v}}) LoadDeadline(idx uint64) (Deadline, error) {
 	dls, err := s.State.LoadDeadlines(s.store)
 	if err != nil {
@@ -376,45 +366,6 @@ func (s *state{{.v}}) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (Secto
 	return fromV{{.v}}SectorPreCommitOnChainInfo(sp), nil
 }
 
-func (s *state{{.v}}) EraseAllUnproven() error {
-	{{if (ge .v 2)}}
-		dls, err := s.State.LoadDeadlines(s.store)
-		if err != nil {
-			return err
-		}
-
-		err = dls.ForEach(s.store, func(dindx uint64, dl *miner{{.v}}.Deadline) error {
-			ps, err := dl.PartitionsArray(s.store)
-			if err != nil {
-				return err
-			}
-
-			var part miner{{.v}}.Partition
-			err = ps.ForEach(&part, func(pindx int64) error {
-				_ = part.ActivateUnproven()
-				err = ps.Set(uint64(pindx), &part)
-				return nil
-			})
-
-			if err != nil {
-				return err
-			}
-
-			dl.Partitions, err = ps.Root()
-			if err != nil {
-				return err
-			}
-
-			return dls.UpdateDeadline(s.store, dindx, dl)
-		})
-
-		return s.State.SaveDeadlines(s.store, dls)
-	{{else}}
-		// field doesn't exist until v2
-	{{end}}
-	return nil
-}
-
 func (d *deadline{{.v}}) LoadPartition(idx uint64) (Partition, error) {
 	p, err := d.Deadline.LoadPartition(d.store, idx)
 	if err != nil {
@@ -507,7 +458,3 @@ func fromV{{.v}}SectorPreCommitOnChainInfo(v{{.v}} miner{{.v}}.SectorPreCommitOn
 	return (SectorPreCommitOnChainInfo)(v0)
 {{end}}
 }
-
-func (s *state{{.v}}) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/miner/v0.go

@@ -32,12 +32,6 @@ func load0(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make0(store adt.Store) (State, error) {
-	out := state0{store: store}
-	out.State = miner0.State{}
-	return &out, nil
-}
-
 type state0 struct {
 	miner0.State
 	store adt.Store
@@ -248,10 +242,6 @@ func (s *state0) IsAllocated(num abi.SectorNumber) (bool, error) {
 	return allocatedSectors.IsSet(uint64(num))
 }
 
-func (s *state0) GetProvingPeriodStart() (abi.ChainEpoch, error) {
-	return s.State.ProvingPeriodStart, nil
-}
-
 func (s *state0) LoadDeadline(idx uint64) (Deadline, error) {
 	dls, err := s.State.LoadDeadlines(s.store)
 	if err != nil {
@@ -373,13 +363,6 @@ func (s *state0) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreC
 	return fromV0SectorPreCommitOnChainInfo(sp), nil
 }
 
-func (s *state0) EraseAllUnproven() error {
-
-	// field doesn't exist until v2
-
-	return nil
-}
-
 func (d *deadline0) LoadPartition(idx uint64) (Partition, error) {
 	p, err := d.Deadline.LoadPartition(d.store, idx)
 	if err != nil {
@@ -443,7 +426,3 @@ func fromV0SectorPreCommitOnChainInfo(v0 miner0.SectorPreCommitOnChainInfo) Sect
 	return (SectorPreCommitOnChainInfo)(v0)
 
 }
-
-func (s *state0) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/miner/v2.go

@@ -30,12 +30,6 @@ func load2(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make2(store adt.Store) (State, error) {
-	out := state2{store: store}
-	out.State = miner2.State{}
-	return &out, nil
-}
-
 type state2 struct {
 	miner2.State
 	store adt.Store
@@ -246,10 +240,6 @@ func (s *state2) IsAllocated(num abi.SectorNumber) (bool, error) {
 	return allocatedSectors.IsSet(uint64(num))
 }
 
-func (s *state2) GetProvingPeriodStart() (abi.ChainEpoch, error) {
-	return s.State.ProvingPeriodStart, nil
-}
-
 func (s *state2) LoadDeadline(idx uint64) (Deadline, error) {
 	dls, err := s.State.LoadDeadlines(s.store)
 	if err != nil {
@@ -371,43 +361,6 @@ func (s *state2) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreC
 	return fromV2SectorPreCommitOnChainInfo(sp), nil
 }
 
-func (s *state2) EraseAllUnproven() error {
-
-	dls, err := s.State.LoadDeadlines(s.store)
-	if err != nil {
-		return err
-	}
-
-	err = dls.ForEach(s.store, func(dindx uint64, dl *miner2.Deadline) error {
-		ps, err := dl.PartitionsArray(s.store)
-		if err != nil {
-			return err
-		}
-
-		var part miner2.Partition
-		err = ps.ForEach(&part, func(pindx int64) error {
-			_ = part.ActivateUnproven()
-			err = ps.Set(uint64(pindx), &part)
-			return nil
-		})
-
-		if err != nil {
-			return err
-		}
-
-		dl.Partitions, err = ps.Root()
-		if err != nil {
-			return err
-		}
-
-		return dls.UpdateDeadline(s.store, dindx, dl)
-	})
-
-	return s.State.SaveDeadlines(s.store, dls)
-
-	return nil
-}
-
 func (d *deadline2) LoadPartition(idx uint64) (Partition, error) {
 	p, err := d.Deadline.LoadPartition(d.store, idx)
 	if err != nil {
@@ -489,7 +442,3 @@ func fromV2SectorPreCommitOnChainInfo(v2 miner2.SectorPreCommitOnChainInfo) Sect
 	}
 
 }
-
-func (s *state2) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/miner/v3.go

@@ -32,12 +32,6 @@ func load3(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make3(store adt.Store) (State, error) {
-	out := state3{store: store}
-	out.State = miner3.State{}
-	return &out, nil
-}
-
 type state3 struct {
 	miner3.State
 	store adt.Store
@@ -248,10 +242,6 @@ func (s *state3) IsAllocated(num abi.SectorNumber) (bool, error) {
 	return allocatedSectors.IsSet(uint64(num))
 }
 
-func (s *state3) GetProvingPeriodStart() (abi.ChainEpoch, error) {
-	return s.State.ProvingPeriodStart, nil
-}
-
 func (s *state3) LoadDeadline(idx uint64) (Deadline, error) {
 	dls, err := s.State.LoadDeadlines(s.store)
 	if err != nil {
@@ -368,43 +358,6 @@ func (s *state3) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreC
 	return fromV3SectorPreCommitOnChainInfo(sp), nil
 }
 
-func (s *state3) EraseAllUnproven() error {
-
-	dls, err := s.State.LoadDeadlines(s.store)
-	if err != nil {
-		return err
-	}
-
-	err = dls.ForEach(s.store, func(dindx uint64, dl *miner3.Deadline) error {
-		ps, err := dl.PartitionsArray(s.store)
-		if err != nil {
-			return err
-		}
-
-		var part miner3.Partition
-		err = ps.ForEach(&part, func(pindx int64) error {
-			_ = part.ActivateUnproven()
-			err = ps.Set(uint64(pindx), &part)
-			return nil
-		})
-
-		if err != nil {
-			return err
-		}
-
-		dl.Partitions, err = ps.Root()
-		if err != nil {
-			return err
-		}
-
-		return dls.UpdateDeadline(s.store, dindx, dl)
-	})
-
-	return s.State.SaveDeadlines(s.store, dls)
-
-	return nil
-}
-
 func (d *deadline3) LoadPartition(idx uint64) (Partition, error) {
 	p, err := d.Deadline.LoadPartition(d.store, idx)
 	if err != nil {
@@ -490,7 +443,3 @@ func fromV3SectorPreCommitOnChainInfo(v3 miner3.SectorPreCommitOnChainInfo) Sect
 	}
 
 }
-
-func (s *state3) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/miner/v4.go

@@ -32,12 +32,6 @@ func load4(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make4(store adt.Store) (State, error) {
-	out := state4{store: store}
-	out.State = miner4.State{}
-	return &out, nil
-}
-
 type state4 struct {
 	miner4.State
 	store adt.Store
@@ -248,10 +242,6 @@ func (s *state4) IsAllocated(num abi.SectorNumber) (bool, error) {
 	return allocatedSectors.IsSet(uint64(num))
 }
 
-func (s *state4) GetProvingPeriodStart() (abi.ChainEpoch, error) {
-	return s.State.ProvingPeriodStart, nil
-}
-
 func (s *state4) LoadDeadline(idx uint64) (Deadline, error) {
 	dls, err := s.State.LoadDeadlines(s.store)
 	if err != nil {
@@ -368,43 +358,6 @@ func (s *state4) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreC
 	return fromV4SectorPreCommitOnChainInfo(sp), nil
 }
 
-func (s *state4) EraseAllUnproven() error {
-
-	dls, err := s.State.LoadDeadlines(s.store)
-	if err != nil {
-		return err
-	}
-
-	err = dls.ForEach(s.store, func(dindx uint64, dl *miner4.Deadline) error {
-		ps, err := dl.PartitionsArray(s.store)
-		if err != nil {
-			return err
-		}
-
-		var part miner4.Partition
-		err = ps.ForEach(&part, func(pindx int64) error {
-			_ = part.ActivateUnproven()
-			err = ps.Set(uint64(pindx), &part)
-			return nil
-		})
-
-		if err != nil {
-			return err
-		}
-
-		dl.Partitions, err = ps.Root()
-		if err != nil {
-			return err
-		}
-
-		return dls.UpdateDeadline(s.store, dindx, dl)
-	})
-
-	return s.State.SaveDeadlines(s.store, dls)
-
-	return nil
-}
-
 func (d *deadline4) LoadPartition(idx uint64) (Partition, error) {
 	p, err := d.Deadline.LoadPartition(d.store, idx)
 	if err != nil {
@@ -490,7 +443,3 @@ func fromV4SectorPreCommitOnChainInfo(v4 miner4.SectorPreCommitOnChainInfo) Sect
 	}
 
 }
-
-func (s *state4) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/multisig/actor.go.template

@@ -40,27 +40,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version, signers []address.Address, threshold uint64, startEpoch abi.ChainEpoch, unlockDuration abi.ChainEpoch, initialBalance abi.TokenAmount) (State, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return make{{.}}(store, signers, threshold, startEpoch, unlockDuration, initialBalance)
-{{end}}
-}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return builtin{{.}}.MultisigActorCodeID, nil
-{{end}}
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 type State interface {
 	cbor.Marshaler
 
@@ -76,7 +55,6 @@ type State interface {
 
 	transactions() (adt.Map, error)
 	decodeTransaction(val *cbg.Deferred) (Transaction, error)
-	GetState() interface{}
 }
 
 type Transaction = msig{{.latestVersion}}.Transaction

chain/actors/builtin/multisig/multisig.go

@@ -66,45 +66,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version, signers []address.Address, threshold uint64, startEpoch abi.ChainEpoch, unlockDuration abi.ChainEpoch, initialBalance abi.TokenAmount) (State, error) {
-	switch av {
-
-	case actors.Version0:
-		return make0(store, signers, threshold, startEpoch, unlockDuration, initialBalance)
-
-	case actors.Version2:
-		return make2(store, signers, threshold, startEpoch, unlockDuration, initialBalance)
-
-	case actors.Version3:
-		return make3(store, signers, threshold, startEpoch, unlockDuration, initialBalance)
-
-	case actors.Version4:
-		return make4(store, signers, threshold, startEpoch, unlockDuration, initialBalance)
-
-	}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-
-	case actors.Version0:
-		return builtin0.MultisigActorCodeID, nil
-
-	case actors.Version2:
-		return builtin2.MultisigActorCodeID, nil
-
-	case actors.Version3:
-		return builtin3.MultisigActorCodeID, nil
-
-	case actors.Version4:
-		return builtin4.MultisigActorCodeID, nil
-
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 type State interface {
 	cbor.Marshaler
 
@@ -120,7 +81,6 @@ type State interface {
 
 	transactions() (adt.Map, error)
 	decodeTransaction(val *cbg.Deferred) (Transaction, error)
-	GetState() interface{}
 }
 
 type Transaction = msig4.Transaction

chain/actors/builtin/multisig/state.go.template

@@ -31,32 +31,6 @@ func load{{.v}}(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make{{.v}}(store adt.Store, signers []address.Address, threshold uint64, startEpoch abi.ChainEpoch, unlockDuration abi.ChainEpoch, initialBalance abi.TokenAmount) (State, error) {
-	out := state{{.v}}{store: store}
-	out.State = msig{{.v}}.State{}
-	out.State.Signers = signers
-	out.State.NumApprovalsThreshold = threshold
-	out.State.StartEpoch = startEpoch
-	out.State.UnlockDuration = unlockDuration
-	out.State.InitialBalance = initialBalance
-	{{if (le .v 2)}}
-		em, err := adt{{.v}}.MakeEmptyMap(store).Root()
-		if err != nil {
-			return nil, err
-		}
-
-		out.State.PendingTxns = em
-	{{else}}
-		em, err := adt{{.v}}.StoreEmptyMap(store, builtin{{.v}}.DefaultHamtBitwidth)
-		if err != nil {
-			return nil, err
-		}
-
-		out.State.PendingTxns = em
-	{{end}}
-	return &out, nil
-}
-
 type state{{.v}} struct {
 	msig{{.v}}.State
 	store adt.Store
@@ -121,7 +95,3 @@ func (s *state{{.v}}) decodeTransaction(val *cbg.Deferred) (Transaction, error)
 	}
 	return tx, nil
 }
-
-func (s *state{{.v}}) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/multisig/v0.go

@@ -28,25 +28,6 @@ func load0(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make0(store adt.Store, signers []address.Address, threshold uint64, startEpoch abi.ChainEpoch, unlockDuration abi.ChainEpoch, initialBalance abi.TokenAmount) (State, error) {
-	out := state0{store: store}
-	out.State = msig0.State{}
-	out.State.Signers = signers
-	out.State.NumApprovalsThreshold = threshold
-	out.State.StartEpoch = startEpoch
-	out.State.UnlockDuration = unlockDuration
-	out.State.InitialBalance = initialBalance
-
-	em, err := adt0.MakeEmptyMap(store).Root()
-	if err != nil {
-		return nil, err
-	}
-
-	out.State.PendingTxns = em
-
-	return &out, nil
-}
-
 type state0 struct {
 	msig0.State
 	store adt.Store
@@ -111,7 +92,3 @@ func (s *state0) decodeTransaction(val *cbg.Deferred) (Transaction, error) {
 	}
 	return tx, nil
 }
-
-func (s *state0) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/multisig/v2.go

@@ -28,25 +28,6 @@ func load2(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make2(store adt.Store, signers []address.Address, threshold uint64, startEpoch abi.ChainEpoch, unlockDuration abi.ChainEpoch, initialBalance abi.TokenAmount) (State, error) {
-	out := state2{store: store}
-	out.State = msig2.State{}
-	out.State.Signers = signers
-	out.State.NumApprovalsThreshold = threshold
-	out.State.StartEpoch = startEpoch
-	out.State.UnlockDuration = unlockDuration
-	out.State.InitialBalance = initialBalance
-
-	em, err := adt2.MakeEmptyMap(store).Root()
-	if err != nil {
-		return nil, err
-	}
-
-	out.State.PendingTxns = em
-
-	return &out, nil
-}
-
 type state2 struct {
 	msig2.State
 	store adt.Store
@@ -111,7 +92,3 @@ func (s *state2) decodeTransaction(val *cbg.Deferred) (Transaction, error) {
 	}
 	return tx, nil
 }
-
-func (s *state2) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/multisig/v3.go

@@ -30,25 +30,6 @@ func load3(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make3(store adt.Store, signers []address.Address, threshold uint64, startEpoch abi.ChainEpoch, unlockDuration abi.ChainEpoch, initialBalance abi.TokenAmount) (State, error) {
-	out := state3{store: store}
-	out.State = msig3.State{}
-	out.State.Signers = signers
-	out.State.NumApprovalsThreshold = threshold
-	out.State.StartEpoch = startEpoch
-	out.State.UnlockDuration = unlockDuration
-	out.State.InitialBalance = initialBalance
-
-	em, err := adt3.StoreEmptyMap(store, builtin3.DefaultHamtBitwidth)
-	if err != nil {
-		return nil, err
-	}
-
-	out.State.PendingTxns = em
-
-	return &out, nil
-}
-
 type state3 struct {
 	msig3.State
 	store adt.Store
@@ -113,7 +94,3 @@ func (s *state3) decodeTransaction(val *cbg.Deferred) (Transaction, error) {
 	}
 	return tx, nil
 }
-
-func (s *state3) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/multisig/v4.go

@@ -30,25 +30,6 @@ func load4(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make4(store adt.Store, signers []address.Address, threshold uint64, startEpoch abi.ChainEpoch, unlockDuration abi.ChainEpoch, initialBalance abi.TokenAmount) (State, error) {
-	out := state4{store: store}
-	out.State = msig4.State{}
-	out.State.Signers = signers
-	out.State.NumApprovalsThreshold = threshold
-	out.State.StartEpoch = startEpoch
-	out.State.UnlockDuration = unlockDuration
-	out.State.InitialBalance = initialBalance
-
-	em, err := adt4.StoreEmptyMap(store, builtin4.DefaultHamtBitwidth)
-	if err != nil {
-		return nil, err
-	}
-
-	out.State.PendingTxns = em
-
-	return &out, nil
-}
-
 type state4 struct {
 	msig4.State
 	store adt.Store
@@ -113,7 +94,3 @@ func (s *state4) decodeTransaction(val *cbg.Deferred) (Transaction, error) {
 	}
 	return tx, nil
 }
-
-func (s *state4) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/paych/actor.go.template

@@ -42,27 +42,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version) (State, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return make{{.}}(store)
-{{end}}
-}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return builtin{{.}}.PaymentChannelActorCodeID, nil
-{{end}}
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 // State is an abstract version of payment channel state that works across
 // versions
 type State interface {
@@ -83,8 +62,6 @@ type State interface {
 
 	// Iterate lane states
 	ForEachLaneState(cb func(idx uint64, dl LaneState) error) error
-
-	GetState() interface{}
 }
 
 // LaneState is an abstract copy of the state of a single lane

chain/actors/builtin/paych/mock/mock.go

@@ -17,10 +17,6 @@ type mockState struct {
 	lanes      map[uint64]paych.LaneState
 }
 
-func (ms *mockState) GetState() interface{} {
-	panic("implement me")
-}
-
 type mockLaneState struct {
 	redeemed big.Int
 	nonce    uint64

chain/actors/builtin/paych/paych.go

@@ -68,45 +68,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version) (State, error) {
-	switch av {
-
-	case actors.Version0:
-		return make0(store)
-
-	case actors.Version2:
-		return make2(store)
-
-	case actors.Version3:
-		return make3(store)
-
-	case actors.Version4:
-		return make4(store)
-
-	}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-
-	case actors.Version0:
-		return builtin0.PaymentChannelActorCodeID, nil
-
-	case actors.Version2:
-		return builtin2.PaymentChannelActorCodeID, nil
-
-	case actors.Version3:
-		return builtin3.PaymentChannelActorCodeID, nil
-
-	case actors.Version4:
-		return builtin4.PaymentChannelActorCodeID, nil
-
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 // State is an abstract version of payment channel state that works across
 // versions
 type State interface {
@@ -127,8 +88,6 @@ type State interface {
 
 	// Iterate lane states
 	ForEachLaneState(cb func(idx uint64, dl LaneState) error) error
-
-	GetState() interface{}
 }
 
 // LaneState is an abstract copy of the state of a single lane

chain/actors/builtin/paych/state.go.template

@@ -24,12 +24,6 @@ func load{{.v}}(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make{{.v}}(store adt.Store) (State, error) {
-	out := state{{.v}}{store: store}
-	out.State = paych{{.v}}.State{}
-	return &out, nil
-}
-
 type state{{.v}} struct {
 	paych{{.v}}.State
 	store adt.Store
@@ -80,10 +74,6 @@ func (s *state{{.v}}) LaneCount() (uint64, error) {
 	return lsamt.Length(), nil
 }
 
-func (s *state{{.v}}) GetState() interface{} {
-	return &s.State
-}
-
 // Iterate lane states
 func (s *state{{.v}}) ForEachLaneState(cb func(idx uint64, dl LaneState) error) error {
 	// Get the lane state from the chain

chain/actors/builtin/paych/v0.go

@@ -24,12 +24,6 @@ func load0(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make0(store adt.Store) (State, error) {
-	out := state0{store: store}
-	out.State = paych0.State{}
-	return &out, nil
-}
-
 type state0 struct {
 	paych0.State
 	store adt.Store
@@ -80,10 +74,6 @@ func (s *state0) LaneCount() (uint64, error) {
 	return lsamt.Length(), nil
 }
 
-func (s *state0) GetState() interface{} {
-	return &s.State
-}
-
 // Iterate lane states
 func (s *state0) ForEachLaneState(cb func(idx uint64, dl LaneState) error) error {
 	// Get the lane state from the chain

chain/actors/builtin/paych/v2.go

@@ -24,12 +24,6 @@ func load2(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make2(store adt.Store) (State, error) {
-	out := state2{store: store}
-	out.State = paych2.State{}
-	return &out, nil
-}
-
 type state2 struct {
 	paych2.State
 	store adt.Store
@@ -80,10 +74,6 @@ func (s *state2) LaneCount() (uint64, error) {
 	return lsamt.Length(), nil
 }
 
-func (s *state2) GetState() interface{} {
-	return &s.State
-}
-
 // Iterate lane states
 func (s *state2) ForEachLaneState(cb func(idx uint64, dl LaneState) error) error {
 	// Get the lane state from the chain

chain/actors/builtin/paych/v3.go

@@ -24,12 +24,6 @@ func load3(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make3(store adt.Store) (State, error) {
-	out := state3{store: store}
-	out.State = paych3.State{}
-	return &out, nil
-}
-
 type state3 struct {
 	paych3.State
 	store adt.Store
@@ -80,10 +74,6 @@ func (s *state3) LaneCount() (uint64, error) {
 	return lsamt.Length(), nil
 }
 
-func (s *state3) GetState() interface{} {
-	return &s.State
-}
-
 // Iterate lane states
 func (s *state3) ForEachLaneState(cb func(idx uint64, dl LaneState) error) error {
 	// Get the lane state from the chain

chain/actors/builtin/paych/v4.go

@@ -24,12 +24,6 @@ func load4(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make4(store adt.Store) (State, error) {
-	out := state4{store: store}
-	out.State = paych4.State{}
-	return &out, nil
-}
-
 type state4 struct {
 	paych4.State
 	store adt.Store
@@ -80,10 +74,6 @@ func (s *state4) LaneCount() (uint64, error) {
 	return lsamt.Length(), nil
 }
 
-func (s *state4) GetState() interface{} {
-	return &s.State
-}
-
 // Iterate lane states
 func (s *state4) ForEachLaneState(cb func(idx uint64, dl LaneState) error) error {
 	// Get the lane state from the chain

chain/actors/builtin/power/actor.go.template

@@ -3,7 +3,6 @@ package power
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
@@ -41,27 +40,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version) (State, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return make{{.}}(store)
-{{end}}
-}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return builtin{{.}}.StoragePowerActorCodeID, nil
-{{end}}
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 type State interface {
 	cbor.Marshaler
 
@@ -69,7 +47,6 @@ type State interface {
 	TotalPower() (Claim, error)
 	TotalCommitted() (Claim, error)
 	TotalPowerSmoothed() (builtin.FilterEstimate, error)
-	GetState() interface{}
 
 	// MinerCounts returns the number of miners. Participating is the number
 	// with power above the minimum miner threshold.
@@ -80,12 +57,6 @@ type State interface {
 	ForEachClaim(func(miner address.Address, claim Claim) error) error
 	ClaimsChanged(State) (bool, error)
 
-	// Testing or genesis setup only
-	SetTotalQualityAdjPower(abi.StoragePower) error
-	SetTotalRawBytePower(abi.StoragePower) error
-	SetThisEpochQualityAdjPower(abi.StoragePower) error
-	SetThisEpochRawBytePower(abi.StoragePower) error
-
 	// Diff helpers. Used by Diff* functions internally.
 	claims() (adt.Map, error)
 	decodeClaim(*cbg.Deferred) (Claim, error)

chain/actors/builtin/power/power.go

@@ -3,7 +3,6 @@ package power
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
@@ -67,45 +66,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version) (State, error) {
-	switch av {
-
-	case actors.Version0:
-		return make0(store)
-
-	case actors.Version2:
-		return make2(store)
-
-	case actors.Version3:
-		return make3(store)
-
-	case actors.Version4:
-		return make4(store)
-
-	}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-
-	case actors.Version0:
-		return builtin0.StoragePowerActorCodeID, nil
-
-	case actors.Version2:
-		return builtin2.StoragePowerActorCodeID, nil
-
-	case actors.Version3:
-		return builtin3.StoragePowerActorCodeID, nil
-
-	case actors.Version4:
-		return builtin4.StoragePowerActorCodeID, nil
-
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 type State interface {
 	cbor.Marshaler
 
@@ -113,7 +73,6 @@ type State interface {
 	TotalPower() (Claim, error)
 	TotalCommitted() (Claim, error)
 	TotalPowerSmoothed() (builtin.FilterEstimate, error)
-	GetState() interface{}
 
 	// MinerCounts returns the number of miners. Participating is the number
 	// with power above the minimum miner threshold.
@@ -124,12 +83,6 @@ type State interface {
 	ForEachClaim(func(miner address.Address, claim Claim) error) error
 	ClaimsChanged(State) (bool, error)
 
-	// Testing or genesis setup only
-	SetTotalQualityAdjPower(abi.StoragePower) error
-	SetTotalRawBytePower(abi.StoragePower) error
-	SetThisEpochQualityAdjPower(abi.StoragePower) error
-	SetThisEpochRawBytePower(abi.StoragePower) error
-
 	// Diff helpers. Used by Diff* functions internally.
 	claims() (adt.Map, error)
 	decodeClaim(*cbg.Deferred) (Claim, error)

chain/actors/builtin/power/state.go.template

@@ -29,32 +29,6 @@ func load{{.v}}(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make{{.v}}(store adt.Store) (State, error) {
-	out := state{{.v}}{store: store}
-	{{if (le .v 2)}}
-		em, err := adt{{.v}}.MakeEmptyMap(store).Root()
-		if err != nil {
-			return nil, err
-		}
-
-		emm, err := adt{{.v}}.MakeEmptyMultimap(store).Root()
-		if err != nil {
-			return nil, err
-		}
-
-		out.State = *power{{.v}}.ConstructState(em, emm)
-	{{else}}
-		s, err := power{{.v}}.ConstructState(store)
-		if err != nil {
-			return nil, err
-		}
-
-		out.State = *s
-	{{end}}
-
-	return &out, nil
-}
-
 type state{{.v}} struct {
 	power{{.v}}.State
 	store adt.Store
@@ -157,30 +131,6 @@ func (s *state{{.v}}) ClaimsChanged(other State) (bool, error) {
 	return !s.State.Claims.Equals(other{{.v}}.State.Claims), nil
 }
 
-func (s *state{{.v}}) SetTotalQualityAdjPower(p abi.StoragePower) error {
-	s.State.TotalQualityAdjPower = p
-	return nil
-}
-
-func (s *state{{.v}}) SetTotalRawBytePower(p abi.StoragePower) error {
-	s.State.TotalRawBytePower = p
-	return nil
-}
-
-func (s *state{{.v}}) SetThisEpochQualityAdjPower(p abi.StoragePower) error {
-	s.State.ThisEpochQualityAdjPower = p
-	return nil
-}
-
-func (s *state{{.v}}) SetThisEpochRawBytePower(p abi.StoragePower) error {
-	s.State.ThisEpochRawBytePower = p
-	return nil
-}
-
-func (s *state{{.v}}) GetState() interface{} {
-	return &s.State
-}
-
 func (s *state{{.v}}) claims() (adt.Map, error) {
 	return adt{{.v}}.AsMap(s.store, s.Claims{{if (ge .v 3)}}, builtin{{.v}}.DefaultHamtBitwidth{{end}})
 }

chain/actors/builtin/power/v0.go

@@ -26,24 +26,6 @@ func load0(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make0(store adt.Store) (State, error) {
-	out := state0{store: store}
-
-	em, err := adt0.MakeEmptyMap(store).Root()
-	if err != nil {
-		return nil, err
-	}
-
-	emm, err := adt0.MakeEmptyMultimap(store).Root()
-	if err != nil {
-		return nil, err
-	}
-
-	out.State = *power0.ConstructState(em, emm)
-
-	return &out, nil
-}
-
 type state0 struct {
 	power0.State
 	store adt.Store
@@ -146,30 +128,6 @@ func (s *state0) ClaimsChanged(other State) (bool, error) {
 	return !s.State.Claims.Equals(other0.State.Claims), nil
 }
 
-func (s *state0) SetTotalQualityAdjPower(p abi.StoragePower) error {
-	s.State.TotalQualityAdjPower = p
-	return nil
-}
-
-func (s *state0) SetTotalRawBytePower(p abi.StoragePower) error {
-	s.State.TotalRawBytePower = p
-	return nil
-}
-
-func (s *state0) SetThisEpochQualityAdjPower(p abi.StoragePower) error {
-	s.State.ThisEpochQualityAdjPower = p
-	return nil
-}
-
-func (s *state0) SetThisEpochRawBytePower(p abi.StoragePower) error {
-	s.State.ThisEpochRawBytePower = p
-	return nil
-}
-
-func (s *state0) GetState() interface{} {
-	return &s.State
-}
-
 func (s *state0) claims() (adt.Map, error) {
 	return adt0.AsMap(s.store, s.Claims)
 }

chain/actors/builtin/power/v2.go

@@ -26,24 +26,6 @@ func load2(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make2(store adt.Store) (State, error) {
-	out := state2{store: store}
-
-	em, err := adt2.MakeEmptyMap(store).Root()
-	if err != nil {
-		return nil, err
-	}
-
-	emm, err := adt2.MakeEmptyMultimap(store).Root()
-	if err != nil {
-		return nil, err
-	}
-
-	out.State = *power2.ConstructState(em, emm)
-
-	return &out, nil
-}
-
 type state2 struct {
 	power2.State
 	store adt.Store
@@ -146,30 +128,6 @@ func (s *state2) ClaimsChanged(other State) (bool, error) {
 	return !s.State.Claims.Equals(other2.State.Claims), nil
 }
 
-func (s *state2) SetTotalQualityAdjPower(p abi.StoragePower) error {
-	s.State.TotalQualityAdjPower = p
-	return nil
-}
-
-func (s *state2) SetTotalRawBytePower(p abi.StoragePower) error {
-	s.State.TotalRawBytePower = p
-	return nil
-}
-
-func (s *state2) SetThisEpochQualityAdjPower(p abi.StoragePower) error {
-	s.State.ThisEpochQualityAdjPower = p
-	return nil
-}
-
-func (s *state2) SetThisEpochRawBytePower(p abi.StoragePower) error {
-	s.State.ThisEpochRawBytePower = p
-	return nil
-}
-
-func (s *state2) GetState() interface{} {
-	return &s.State
-}
-
 func (s *state2) claims() (adt.Map, error) {
 	return adt2.AsMap(s.store, s.Claims)
 }

chain/actors/builtin/power/v3.go

@@ -28,19 +28,6 @@ func load3(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make3(store adt.Store) (State, error) {
-	out := state3{store: store}
-
-	s, err := power3.ConstructState(store)
-	if err != nil {
-		return nil, err
-	}
-
-	out.State = *s
-
-	return &out, nil
-}
-
 type state3 struct {
 	power3.State
 	store adt.Store
@@ -143,30 +130,6 @@ func (s *state3) ClaimsChanged(other State) (bool, error) {
 	return !s.State.Claims.Equals(other3.State.Claims), nil
 }
 
-func (s *state3) SetTotalQualityAdjPower(p abi.StoragePower) error {
-	s.State.TotalQualityAdjPower = p
-	return nil
-}
-
-func (s *state3) SetTotalRawBytePower(p abi.StoragePower) error {
-	s.State.TotalRawBytePower = p
-	return nil
-}
-
-func (s *state3) SetThisEpochQualityAdjPower(p abi.StoragePower) error {
-	s.State.ThisEpochQualityAdjPower = p
-	return nil
-}
-
-func (s *state3) SetThisEpochRawBytePower(p abi.StoragePower) error {
-	s.State.ThisEpochRawBytePower = p
-	return nil
-}
-
-func (s *state3) GetState() interface{} {
-	return &s.State
-}
-
 func (s *state3) claims() (adt.Map, error) {
 	return adt3.AsMap(s.store, s.Claims, builtin3.DefaultHamtBitwidth)
 }

chain/actors/builtin/power/v4.go

@@ -28,19 +28,6 @@ func load4(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make4(store adt.Store) (State, error) {
-	out := state4{store: store}
-
-	s, err := power4.ConstructState(store)
-	if err != nil {
-		return nil, err
-	}
-
-	out.State = *s
-
-	return &out, nil
-}
-
 type state4 struct {
 	power4.State
 	store adt.Store
@@ -143,30 +130,6 @@ func (s *state4) ClaimsChanged(other State) (bool, error) {
 	return !s.State.Claims.Equals(other4.State.Claims), nil
 }
 
-func (s *state4) SetTotalQualityAdjPower(p abi.StoragePower) error {
-	s.State.TotalQualityAdjPower = p
-	return nil
-}
-
-func (s *state4) SetTotalRawBytePower(p abi.StoragePower) error {
-	s.State.TotalRawBytePower = p
-	return nil
-}
-
-func (s *state4) SetThisEpochQualityAdjPower(p abi.StoragePower) error {
-	s.State.ThisEpochQualityAdjPower = p
-	return nil
-}
-
-func (s *state4) SetThisEpochRawBytePower(p abi.StoragePower) error {
-	s.State.ThisEpochRawBytePower = p
-	return nil
-}
-
-func (s *state4) GetState() interface{} {
-	return &s.State
-}
-
 func (s *state4) claims() (adt.Map, error) {
 	return adt4.AsMap(s.store, s.Claims, builtin4.DefaultHamtBitwidth)
 }

chain/actors/builtin/reward/actor.go.template

@@ -4,7 +4,6 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
 	"github.com/ipfs/go-cid"
-	"github.com/filecoin-project/lotus/chain/actors"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-state-types/cbor"
@@ -39,27 +38,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version, currRealizedPower abi.StoragePower) (State, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return make{{.}}(store, currRealizedPower)
-{{end}}
-}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return builtin{{.}}.RewardActorCodeID, nil
-{{end}}
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 type State interface {
 	cbor.Marshaler
 
@@ -77,7 +55,6 @@ type State interface {
 
 	InitialPledgeForPower(abi.StoragePower, abi.TokenAmount, *builtin.FilterEstimate, abi.TokenAmount) (abi.TokenAmount, error)
 	PreCommitDepositForPower(builtin.FilterEstimate, abi.StoragePower) (abi.TokenAmount, error)
-	GetState() interface{}
 }
 
 type AwardBlockRewardParams = reward0.AwardBlockRewardParams

chain/actors/builtin/reward/reward.go

@@ -2,7 +2,6 @@ package reward
 
 import (
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors"
 	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
 	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
@@ -65,45 +64,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version, currRealizedPower abi.StoragePower) (State, error) {
-	switch av {
-
-	case actors.Version0:
-		return make0(store, currRealizedPower)
-
-	case actors.Version2:
-		return make2(store, currRealizedPower)
-
-	case actors.Version3:
-		return make3(store, currRealizedPower)
-
-	case actors.Version4:
-		return make4(store, currRealizedPower)
-
-	}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-
-	case actors.Version0:
-		return builtin0.RewardActorCodeID, nil
-
-	case actors.Version2:
-		return builtin2.RewardActorCodeID, nil
-
-	case actors.Version3:
-		return builtin3.RewardActorCodeID, nil
-
-	case actors.Version4:
-		return builtin4.RewardActorCodeID, nil
-
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 type State interface {
 	cbor.Marshaler
 
@@ -121,7 +81,6 @@ type State interface {
 
 	InitialPledgeForPower(abi.StoragePower, abi.TokenAmount, *builtin.FilterEstimate, abi.TokenAmount) (abi.TokenAmount, error)
 	PreCommitDepositForPower(builtin.FilterEstimate, abi.StoragePower) (abi.TokenAmount, error)
-	GetState() interface{}
 }
 
 type AwardBlockRewardParams = reward0.AwardBlockRewardParams

chain/actors/builtin/reward/state.go.template

@@ -23,12 +23,6 @@ func load{{.v}}(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make{{.v}}(store adt.Store, currRealizedPower abi.StoragePower) (State, error) {
-	out := state{{.v}}{store: store}
-	out.State = *reward{{.v}}.ConstructState(currRealizedPower)
-	return &out, nil
-}
-
 type state{{.v}} struct {
 	reward{{.v}}.State
 	store adt.Store
@@ -107,7 +101,3 @@ func (s *state{{.v}}) PreCommitDepositForPower(networkQAPower builtin.FilterEsti
 		},
 		sectorWeight), nil
 }
-
-func (s *state{{.v}}) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/reward/v0.go

@@ -23,12 +23,6 @@ func load0(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make0(store adt.Store, currRealizedPower abi.StoragePower) (State, error) {
-	out := state0{store: store}
-	out.State = *reward0.ConstructState(currRealizedPower)
-	return &out, nil
-}
-
 type state0 struct {
 	reward0.State
 	store adt.Store
@@ -89,7 +83,3 @@ func (s *state0) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate,
 		},
 		sectorWeight), nil
 }
-
-func (s *state0) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/reward/v2.go

@@ -23,12 +23,6 @@ func load2(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make2(store adt.Store, currRealizedPower abi.StoragePower) (State, error) {
-	out := state2{store: store}
-	out.State = *reward2.ConstructState(currRealizedPower)
-	return &out, nil
-}
-
 type state2 struct {
 	reward2.State
 	store adt.Store
@@ -92,7 +86,3 @@ func (s *state2) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate,
 		},
 		sectorWeight), nil
 }
-
-func (s *state2) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/reward/v3.go

@@ -23,12 +23,6 @@ func load3(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make3(store adt.Store, currRealizedPower abi.StoragePower) (State, error) {
-	out := state3{store: store}
-	out.State = *reward3.ConstructState(currRealizedPower)
-	return &out, nil
-}
-
 type state3 struct {
 	reward3.State
 	store adt.Store
@@ -92,7 +86,3 @@ func (s *state3) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate,
 		},
 		sectorWeight), nil
 }
-
-func (s *state3) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/reward/v4.go

@@ -23,12 +23,6 @@ func load4(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make4(store adt.Store, currRealizedPower abi.StoragePower) (State, error) {
-	out := state4{store: store}
-	out.State = *reward4.ConstructState(currRealizedPower)
-	return &out, nil
-}
-
 type state4 struct {
 	reward4.State
 	store adt.Store
@@ -92,7 +86,3 @@ func (s *state4) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate,
 		},
 		sectorWeight), nil
 }
-
-func (s *state4) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/system/actor.go.template

@@ -1,41 +0,0 @@
-package system
-
-import (
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"golang.org/x/xerrors"
-	"github.com/ipfs/go-cid"
-
-{{range .versions}}
-	builtin{{.}} "github.com/filecoin-project/specs-actors{{import .}}actors/builtin"
-{{end}}
-)
-
-var (
-	Address = builtin{{.latestVersion}}.SystemActorAddr
-)
-
-func MakeState(store adt.Store, av actors.Version) (State, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return make{{.}}(store)
-{{end}}
-}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return builtin{{.}}.SystemActorCodeID, nil
-{{end}}
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
-type State interface {
-	GetState() interface{}
-}

chain/actors/builtin/system/state.go.template

@@ -1,35 +0,0 @@
-package system
-
-import (
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	system{{.v}} "github.com/filecoin-project/specs-actors{{.import}}actors/builtin/system"
-)
-
-var _ State = (*state{{.v}})(nil)
-
-func load{{.v}}(store adt.Store, root cid.Cid) (State, error) {
-	out := state{{.v}}{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-func make{{.v}}(store adt.Store) (State, error) {
-	out := state{{.v}}{store: store}
-	out.State = system{{.v}}.State{}
-	return &out, nil
-}
-
-type state{{.v}} struct {
-	system{{.v}}.State
-	store adt.Store
-}
-
-func (s *state{{.v}}) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/system/system.go

@@ -1,63 +0,0 @@
-package system
-
-import (
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-
-	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
-)
-
-var (
-	Address = builtin4.SystemActorAddr
-)
-
-func MakeState(store adt.Store, av actors.Version) (State, error) {
-	switch av {
-
-	case actors.Version0:
-		return make0(store)
-
-	case actors.Version2:
-		return make2(store)
-
-	case actors.Version3:
-		return make3(store)
-
-	case actors.Version4:
-		return make4(store)
-
-	}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-
-	case actors.Version0:
-		return builtin0.SystemActorCodeID, nil
-
-	case actors.Version2:
-		return builtin2.SystemActorCodeID, nil
-
-	case actors.Version3:
-		return builtin3.SystemActorCodeID, nil
-
-	case actors.Version4:
-		return builtin4.SystemActorCodeID, nil
-
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
-type State interface {
-	GetState() interface{}
-}

chain/actors/builtin/system/v0.go

@@ -1,35 +0,0 @@
-package system
-
-import (
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	system0 "github.com/filecoin-project/specs-actors/actors/builtin/system"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-func make0(store adt.Store) (State, error) {
-	out := state0{store: store}
-	out.State = system0.State{}
-	return &out, nil
-}
-
-type state0 struct {
-	system0.State
-	store adt.Store
-}
-
-func (s *state0) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/system/v2.go

@@ -1,35 +0,0 @@
-package system
-
-import (
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	system2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/system"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-func make2(store adt.Store) (State, error) {
-	out := state2{store: store}
-	out.State = system2.State{}
-	return &out, nil
-}
-
-type state2 struct {
-	system2.State
-	store adt.Store
-}
-
-func (s *state2) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/system/v3.go

@@ -1,35 +0,0 @@
-package system
-
-import (
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	system3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/system"
-)
-
-var _ State = (*state3)(nil)
-
-func load3(store adt.Store, root cid.Cid) (State, error) {
-	out := state3{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-func make3(store adt.Store) (State, error) {
-	out := state3{store: store}
-	out.State = system3.State{}
-	return &out, nil
-}
-
-type state3 struct {
-	system3.State
-	store adt.Store
-}
-
-func (s *state3) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/system/v4.go

@@ -1,35 +0,0 @@
-package system
-
-import (
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	system4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/system"
-)
-
-var _ State = (*state4)(nil)
-
-func load4(store adt.Store, root cid.Cid) (State, error) {
-	out := state4{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-func make4(store adt.Store) (State, error) {
-	out := state4{store: store}
-	out.State = system4.State{}
-	return &out, nil
-}
-
-type state4 struct {
-	system4.State
-	store adt.Store
-}
-
-func (s *state4) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/verifreg/actor.go.template

@@ -14,7 +14,6 @@ import (
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
@@ -41,28 +40,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version, rootKeyAddress address.Address) (State, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return make{{.}}(store, rootKeyAddress)
-{{end}}
-}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-{{range .versions}}
-	case actors.Version{{.}}:
-		return builtin{{.}}.VerifiedRegistryActorCodeID, nil
-{{end}}
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
-
 type State interface {
 	cbor.Marshaler
 
@@ -71,5 +48,4 @@ type State interface {
 	VerifierDataCap(address.Address) (bool, abi.StoragePower, error)
 	ForEachVerifier(func(addr address.Address, dcap abi.StoragePower) error) error
 	ForEachClient(func(addr address.Address, dcap abi.StoragePower) error) error
-	GetState() interface{}
 }

chain/actors/builtin/verifreg/state.go.template

@@ -24,26 +24,6 @@ func load{{.v}}(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make{{.v}}(store adt.Store, rootKeyAddress address.Address) (State, error) {
-	out := state{{.v}}{store: store}
-	{{if (le .v 2)}}
-		em, err := adt{{.v}}.MakeEmptyMap(store).Root()
-		if err != nil {
-			return nil, err
-		}
-
-		out.State = *verifreg{{.v}}.ConstructState(em, rootKeyAddress)
-	{{else}}
-		s, err := verifreg{{.v}}.ConstructState(store, rootKeyAddress)
-		if err != nil {
-			return nil, err
-		}
-
-		out.State = *s
-	{{end}}
-	return &out, nil
-}
-
 type state{{.v}} struct {
 	verifreg{{.v}}.State
 	store adt.Store
@@ -76,7 +56,3 @@ func (s *state{{.v}}) verifiedClients() (adt.Map, error) {
 func (s *state{{.v}}) verifiers() (adt.Map, error) {
 	return adt{{.v}}.AsMap(s.store, s.Verifiers{{if (ge .v 3)}}, builtin{{.v}}.DefaultHamtBitwidth{{end}})
 }
-
-func (s *state{{.v}}) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/verifreg/v0.go

@@ -23,19 +23,6 @@ func load0(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make0(store adt.Store, rootKeyAddress address.Address) (State, error) {
-	out := state0{store: store}
-
-	em, err := adt0.MakeEmptyMap(store).Root()
-	if err != nil {
-		return nil, err
-	}
-
-	out.State = *verifreg0.ConstructState(em, rootKeyAddress)
-
-	return &out, nil
-}
-
 type state0 struct {
 	verifreg0.State
 	store adt.Store
@@ -68,7 +55,3 @@ func (s *state0) verifiedClients() (adt.Map, error) {
 func (s *state0) verifiers() (adt.Map, error) {
 	return adt0.AsMap(s.store, s.Verifiers)
 }
-
-func (s *state0) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/verifreg/v2.go

@@ -23,19 +23,6 @@ func load2(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make2(store adt.Store, rootKeyAddress address.Address) (State, error) {
-	out := state2{store: store}
-
-	em, err := adt2.MakeEmptyMap(store).Root()
-	if err != nil {
-		return nil, err
-	}
-
-	out.State = *verifreg2.ConstructState(em, rootKeyAddress)
-
-	return &out, nil
-}
-
 type state2 struct {
 	verifreg2.State
 	store adt.Store
@@ -68,7 +55,3 @@ func (s *state2) verifiedClients() (adt.Map, error) {
 func (s *state2) verifiers() (adt.Map, error) {
 	return adt2.AsMap(s.store, s.Verifiers)
 }
-
-func (s *state2) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/verifreg/v3.go

@@ -24,19 +24,6 @@ func load3(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make3(store adt.Store, rootKeyAddress address.Address) (State, error) {
-	out := state3{store: store}
-
-	s, err := verifreg3.ConstructState(store, rootKeyAddress)
-	if err != nil {
-		return nil, err
-	}
-
-	out.State = *s
-
-	return &out, nil
-}
-
 type state3 struct {
 	verifreg3.State
 	store adt.Store
@@ -69,7 +56,3 @@ func (s *state3) verifiedClients() (adt.Map, error) {
 func (s *state3) verifiers() (adt.Map, error) {
 	return adt3.AsMap(s.store, s.Verifiers, builtin3.DefaultHamtBitwidth)
 }
-
-func (s *state3) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/verifreg/v4.go

@@ -24,19 +24,6 @@ func load4(store adt.Store, root cid.Cid) (State, error) {
 	return &out, nil
 }
 
-func make4(store adt.Store, rootKeyAddress address.Address) (State, error) {
-	out := state4{store: store}
-
-	s, err := verifreg4.ConstructState(store, rootKeyAddress)
-	if err != nil {
-		return nil, err
-	}
-
-	out.State = *s
-
-	return &out, nil
-}
-
 type state4 struct {
 	verifreg4.State
 	store adt.Store
@@ -69,7 +56,3 @@ func (s *state4) verifiedClients() (adt.Map, error) {
 func (s *state4) verifiers() (adt.Map, error) {
 	return adt4.AsMap(s.store, s.Verifiers, builtin4.DefaultHamtBitwidth)
 }
-
-func (s *state4) GetState() interface{} {
-	return &s.State
-}

chain/actors/builtin/verifreg/verifreg.go

@@ -17,7 +17,6 @@ import (
 
 	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 
-	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -67,45 +66,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
 
-func MakeState(store adt.Store, av actors.Version, rootKeyAddress address.Address) (State, error) {
-	switch av {
-
-	case actors.Version0:
-		return make0(store, rootKeyAddress)
-
-	case actors.Version2:
-		return make2(store, rootKeyAddress)
-
-	case actors.Version3:
-		return make3(store, rootKeyAddress)
-
-	case actors.Version4:
-		return make4(store, rootKeyAddress)
-
-	}
-	return nil, xerrors.Errorf("unknown actor version %d", av)
-}
-
-func GetActorCodeID(av actors.Version) (cid.Cid, error) {
-	switch av {
-
-	case actors.Version0:
-		return builtin0.VerifiedRegistryActorCodeID, nil
-
-	case actors.Version2:
-		return builtin2.VerifiedRegistryActorCodeID, nil
-
-	case actors.Version3:
-		return builtin3.VerifiedRegistryActorCodeID, nil
-
-	case actors.Version4:
-		return builtin4.VerifiedRegistryActorCodeID, nil
-
-	}
-
-	return cid.Undef, xerrors.Errorf("unknown actor version %d", av)
-}
-
 type State interface {
 	cbor.Marshaler
 
@@ -114,5 +74,4 @@ type State interface {
 	VerifierDataCap(address.Address) (bool, abi.StoragePower, error)
 	ForEachVerifier(func(addr address.Address, dcap abi.StoragePower) error) error
 	ForEachClient(func(addr address.Address, dcap abi.StoragePower) error) error
-	GetState() interface{}
 }