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/builtin.go.template

@@ -6,9 +6,9 @@ import (
 	"golang.org/x/xerrors"
 
 	{{range .versions}}
-		builtin{{.}} "github.com/filecoin-project/specs-actors{{import .}}actors/builtin"
+        builtin{{.}} "github.com/filecoin-project/specs-actors{{import .}}actors/builtin"
-		smoothing{{.}} "github.com/filecoin-project/specs-actors{{import .}}actors/util/smoothing"
+        smoothing{{.}} "github.com/filecoin-project/specs-actors{{import .}}actors/util/smoothing"
-	{{end}}
+    {{end}}
 
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
@@ -17,7 +17,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 
 	miner{{.latestVersion}} "github.com/filecoin-project/specs-actors{{import .latestVersion}}actors/builtin/miner"
-	proof{{.latestVersion}}	 "github.com/filecoin-project/specs-actors{{import .latestVersion}}actors/runtime/proof"
+	proof{{.latestVersion}}  "github.com/filecoin-project/specs-actors{{import .latestVersion}}actors/runtime/proof"
 )
 
 var SystemActorAddr = builtin{{.latestVersion}}.SystemActorAddr
@@ -33,12 +33,12 @@ var (
 
 const (
 	EpochDurationSeconds = builtin{{.latestVersion}}.EpochDurationSeconds
-	EpochsInDay			 = builtin{{.latestVersion}}.EpochsInDay
+	EpochsInDay          = builtin{{.latestVersion}}.EpochsInDay
-	SecondsInDay		 = builtin{{.latestVersion}}.SecondsInDay
+	SecondsInDay         = builtin{{.latestVersion}}.SecondsInDay
 )
 
 const (
-	MethodSend		  = builtin{{.latestVersion}}.MethodSend
+	MethodSend        = builtin{{.latestVersion}}.MethodSend
 	MethodConstructor = builtin{{.latestVersion}}.MethodConstructor
 )
 
@@ -53,13 +53,13 @@ func QAPowerForWeight(size abi.SectorSize, duration abi.ChainEpoch, dealWeight,
 }
 
 {{range .versions}}
-	func FromV{{.}}FilterEstimate(v{{.}} smoothing{{.}}.FilterEstimate) FilterEstimate {
+    func FromV{{.}}FilterEstimate(v{{.}} smoothing{{.}}.FilterEstimate) FilterEstimate {
 	{{if (eq . 0)}}
-		return (FilterEstimate)(v{{.}}) //nolint:unconvert
+	    return (FilterEstimate)(v{{.}}) //nolint:unconvert
-	{{else}}
+    {{else}}
-		return (FilterEstimate)(v{{.}})
+        return (FilterEstimate)(v{{.}})
-	{{end}}
+    {{end}}
-	}
+    }
 {{end}}
 
 type ActorStateLoader func(store adt.Store, root cid.Cid) (cbor.Marshaler, error)
@@ -80,58 +80,58 @@ func Load(store adt.Store, act *types.Actor) (cbor.Marshaler, error) {
 
 func ActorNameByCode(c cid.Cid) string {
 	switch {
-		{{range .versions}}
+        {{range .versions}}
-			case builtin{{.}}.IsBuiltinActor(c):
+            case builtin{{.}}.IsBuiltinActor(c):
-			return builtin{{.}}.ActorNameByCode(c)
+            return builtin{{.}}.ActorNameByCode(c)
-		{{end}}
+        {{end}}
 	default:
 		return "<unknown>"
 	}
 }
 
 func IsBuiltinActor(c cid.Cid) bool {
-	{{range .versions}}
+    {{range .versions}}
-		if builtin{{.}}.IsBuiltinActor(c) {
+        if builtin{{.}}.IsBuiltinActor(c) {
-			return true
+            return true
-		}
+        }
-	{{end}}
+    {{end}}
-	return false
+    return false
 }
 
 func IsAccountActor(c cid.Cid) bool {
-	{{range .versions}}
+    {{range .versions}}
-		if c == builtin{{.}}.AccountActorCodeID {
+        if c == builtin{{.}}.AccountActorCodeID {
-			return true
+            return true
-		}
+        }
-	{{end}}
+    {{end}}
-	return false
+    return false
 }
 
 func IsStorageMinerActor(c cid.Cid) bool {
-	{{range .versions}}
+    {{range .versions}}
-		if c == builtin{{.}}.StorageMinerActorCodeID {
+        if c == builtin{{.}}.StorageMinerActorCodeID {
-			return true
+            return true
-		}
+        }
-	{{end}}
+    {{end}}
-	return false
+    return false
 }
 
 func IsMultisigActor(c cid.Cid) bool {
-	{{range .versions}}
+    {{range .versions}}
-		if c == builtin{{.}}.MultisigActorCodeID {
+        if c == builtin{{.}}.MultisigActorCodeID {
-			return true
+            return true
-		}
+        }
-	{{end}}
+    {{end}}
-	return false
+    return false
 }
 
 func IsPaymentChannelActor(c cid.Cid) bool {
-	{{range .versions}}
+    {{range .versions}}
-		if c == builtin{{.}}.PaymentChannelActorCodeID {
+        if c == builtin{{.}}.PaymentChannelActorCodeID {
-			return true
+            return true
-		}
+        }
-	{{end}}
+    {{end}}
-	return false
+    return false
 }
 
 func makeAddress(addr string) address.Address {

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
@@ -111,71 +89,71 @@ type ClientDealProposal = market0.ClientDealProposal
 type DealState struct {
 	SectorStartEpoch abi.ChainEpoch // -1 if not yet included in proven sector
 	LastUpdatedEpoch abi.ChainEpoch // -1 if deal state never updated
-	SlashEpoch		 abi.ChainEpoch // -1 if deal never slashed
+	SlashEpoch       abi.ChainEpoch // -1 if deal never slashed
 }
 
 type DealProposal struct {
-	PieceCID			 cid.Cid
+	PieceCID             cid.Cid
-	PieceSize			 abi.PaddedPieceSize
+	PieceSize            abi.PaddedPieceSize
-	VerifiedDeal		 bool
+	VerifiedDeal         bool
-	Client				 address.Address
+	Client               address.Address
-	Provider			 address.Address
+	Provider             address.Address
-	Label				 string
+	Label                string
-	StartEpoch			 abi.ChainEpoch
+	StartEpoch           abi.ChainEpoch
-	EndEpoch			 abi.ChainEpoch
+	EndEpoch             abi.ChainEpoch
 	StoragePricePerEpoch abi.TokenAmount
-	ProviderCollateral	 abi.TokenAmount
+	ProviderCollateral   abi.TokenAmount
-	ClientCollateral	 abi.TokenAmount
+	ClientCollateral     abi.TokenAmount
 }
 
 type DealStateChanges struct {
-	Added	 []DealIDState
+	Added    []DealIDState
 	Modified []DealStateChange
-	Removed	 []DealIDState
+	Removed  []DealIDState
 }
 
 type DealIDState struct {
-	ID	 abi.DealID
+	ID   abi.DealID
 	Deal DealState
 }
 
 // DealStateChange is a change in deal state from -> to
 type DealStateChange struct {
-	ID	 abi.DealID
+	ID   abi.DealID
 	From *DealState
-	To	 *DealState
+	To   *DealState
 }
 
 type DealProposalChanges struct {
-	Added	[]ProposalIDState
+	Added   []ProposalIDState
 	Removed []ProposalIDState
 }
 
 type ProposalIDState struct {
-	ID		 abi.DealID
+	ID       abi.DealID
 	Proposal DealProposal
 }
 
 func EmptyDealState() *DealState {
 	return &DealState{
 		SectorStartEpoch: -1,
-		SlashEpoch:		  -1,
+		SlashEpoch:       -1,
 		LastUpdatedEpoch: -1,
 	}
 }
 
 // returns the earned fees and pending fees for a given deal
 func (deal DealProposal) GetDealFees(height abi.ChainEpoch) (abi.TokenAmount, abi.TokenAmount) {
-	   tf := big.Mul(deal.StoragePricePerEpoch, big.NewInt(int64(deal.EndEpoch-deal.StartEpoch)))
+       tf := big.Mul(deal.StoragePricePerEpoch, big.NewInt(int64(deal.EndEpoch-deal.StartEpoch)))
 
-	   ef := big.Mul(deal.StoragePricePerEpoch, big.NewInt(int64(height-deal.StartEpoch)))
+       ef := big.Mul(deal.StoragePricePerEpoch, big.NewInt(int64(height-deal.StartEpoch)))
-	   if ef.LessThan(big.Zero()) {
+       if ef.LessThan(big.Zero()) {
-			   ef = big.Zero()
+               ef = big.Zero()
-	   }
+       }
 
-	   if ef.GreaterThan(tf) {
+       if ef.GreaterThan(tf) {
-			   ef = tf
+               ef = tf
-	   }
+       }
 
-	   return ef, big.Sub(tf, ef)
+       return ef, big.Sub(tf, ef)
 }

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 {
@@ -143,26 +115,26 @@ type Partition interface {
 }
 
 type SectorOnChainInfo struct {
-	SectorNumber		  abi.SectorNumber
+	SectorNumber          abi.SectorNumber
-	SealProof			  abi.RegisteredSealProof
+	SealProof             abi.RegisteredSealProof
-	SealedCID			  cid.Cid
+	SealedCID             cid.Cid
-	DealIDs				  []abi.DealID
+	DealIDs               []abi.DealID
-	Activation			  abi.ChainEpoch
+	Activation            abi.ChainEpoch
-	Expiration			  abi.ChainEpoch
+	Expiration            abi.ChainEpoch
-	DealWeight			  abi.DealWeight
+	DealWeight            abi.DealWeight
-	VerifiedDealWeight	  abi.DealWeight
+	VerifiedDealWeight    abi.DealWeight
-	InitialPledge		  abi.TokenAmount
+	InitialPledge         abi.TokenAmount
-	ExpectedDayReward	  abi.TokenAmount
+	ExpectedDayReward     abi.TokenAmount
 	ExpectedStoragePledge abi.TokenAmount
 }
 
 type SectorPreCommitInfo = miner0.SectorPreCommitInfo
 
 type SectorPreCommitOnChainInfo struct {
-	Info			   SectorPreCommitInfo
+	Info               SectorPreCommitInfo
 	PreCommitDeposit   abi.TokenAmount
-	PreCommitEpoch	   abi.ChainEpoch
+	PreCommitEpoch     abi.ChainEpoch
-	DealWeight		   abi.DealWeight
+	DealWeight         abi.DealWeight
 	VerifiedDealWeight abi.DealWeight
 }
 
@@ -231,17 +203,17 @@ func WinningPoStProofTypeFromWindowPoStProofType(nver network.Version, proof abi
 }
 
 type MinerInfo struct {
-	Owner					   address.Address	 // Must be an ID-address.
+	Owner                      address.Address   // Must be an ID-address.
-	Worker					   address.Address	 // Must be an ID-address.
+	Worker                     address.Address   // Must be an ID-address.
-	NewWorker				   address.Address	 // Must be an ID-address.
+	NewWorker                  address.Address   // Must be an ID-address.
-	ControlAddresses		   []address.Address // Must be an ID-addresses.
+	ControlAddresses           []address.Address // Must be an ID-addresses.
-	WorkerChangeEpoch		   abi.ChainEpoch
+	WorkerChangeEpoch          abi.ChainEpoch
-	PeerId					   *peer.ID
+	PeerId                     *peer.ID
-	Multiaddrs				   []abi.Multiaddrs
+	Multiaddrs                 []abi.Multiaddrs
-	WindowPoStProofType		   abi.RegisteredPoStProof
+	WindowPoStProofType        abi.RegisteredPoStProof
-	SectorSize				   abi.SectorSize
+	SectorSize                 abi.SectorSize
 	WindowPoStPartitionSectors uint64
-	ConsensusFaultElapsed	   abi.ChainEpoch
+	ConsensusFaultElapsed      abi.ChainEpoch
 }
 
 func (mi MinerInfo) IsController(addr address.Address) bool {
@@ -272,25 +244,25 @@ type SectorLocation struct {
 }
 
 type SectorChanges struct {
-	Added	 []SectorOnChainInfo
+	Added    []SectorOnChainInfo
 	Extended []SectorExtensions
-	Removed	 []SectorOnChainInfo
+	Removed  []SectorOnChainInfo
 }
 
 type SectorExtensions struct {
 	From SectorOnChainInfo
-	To	 SectorOnChainInfo
+	To   SectorOnChainInfo
 }
 
 type PreCommitChanges struct {
-	Added	[]SectorPreCommitOnChainInfo
+	Added   []SectorPreCommitOnChainInfo
 	Removed []SectorPreCommitOnChainInfo
 }
 
 type LockedFunds struct {
-	VestingFunds			 abi.TokenAmount
+	VestingFunds             abi.TokenAmount
 	InitialPledgeRequirement abi.TokenAmount
-	PreCommitDeposits		 abi.TokenAmount
+	PreCommitDeposits        abi.TokenAmount
 }
 
 func (lf LockedFunds) TotalLockedFunds() abi.TokenAmount {

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
@@ -74,9 +68,9 @@ func (s *state{{.v}}) VestedFunds(epoch abi.ChainEpoch) (abi.TokenAmount, error)
 
 func (s *state{{.v}}) LockedFunds() (LockedFunds, error) {
 	return LockedFunds{
-		VestingFunds:			  s.State.LockedFunds,
+		VestingFunds:             s.State.LockedFunds,
 		InitialPledgeRequirement: s.State.InitialPledge{{if (le .v 1)}}Requirement{{end}},
-		PreCommitDeposits:		  s.State.PreCommitDeposits,
+		PreCommitDeposits:        s.State.PreCommitDeposits,
 	}, nil
 }
 
@@ -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 {
@@ -317,19 +307,19 @@ func (s *state{{.v}}) Info() (MinerInfo, error) {
 	}
 {{end}}
 	mi := MinerInfo{
-		Owner:			  info.Owner,
+		Owner:            info.Owner,
-		Worker:			  info.Worker,
+		Worker:           info.Worker,
 		ControlAddresses: info.ControlAddresses,
 
-		NewWorker:		   address.Undef,
+		NewWorker:         address.Undef,
 		WorkerChangeEpoch: -1,
 
-		PeerId:						pid,
+		PeerId:                     pid,
-		Multiaddrs:					info.Multiaddrs,
+		Multiaddrs:                 info.Multiaddrs,
-		WindowPoStProofType:		{{if (ge .v 3)}}info.WindowPoStProofType{{else}}wpp{{end}},
+		WindowPoStProofType:        {{if (ge .v 3)}}info.WindowPoStProofType{{else}}wpp{{end}},
-		SectorSize:					info.SectorSize,
+		SectorSize:                 info.SectorSize,
 		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
-		ConsensusFaultElapsed:		{{if (ge .v 2)}}info.ConsensusFaultElapsed{{else}}-1{{end}},
+		ConsensusFaultElapsed:      {{if (ge .v 2)}}info.ConsensusFaultElapsed{{else}}-1{{end}},
 	}
 
 	if info.PendingWorkerKey != 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 {
@@ -477,16 +428,16 @@ func (p *partition{{.v}}) RecoveringSectors() (bitfield.BitField, error) {
 func fromV{{.v}}SectorOnChainInfo(v{{.v}} miner{{.v}}.SectorOnChainInfo) SectorOnChainInfo {
 {{if (ge .v 2)}}
 	return SectorOnChainInfo{
-		SectorNumber:		   v{{.v}}.SectorNumber,
+		SectorNumber:          v{{.v}}.SectorNumber,
-		SealProof:			   v{{.v}}.SealProof,
+		SealProof:             v{{.v}}.SealProof,
-		SealedCID:			   v{{.v}}.SealedCID,
+		SealedCID:             v{{.v}}.SealedCID,
-		DealIDs:			   v{{.v}}.DealIDs,
+		DealIDs:               v{{.v}}.DealIDs,
-		Activation:			   v{{.v}}.Activation,
+		Activation:            v{{.v}}.Activation,
-		Expiration:			   v{{.v}}.Expiration,
+		Expiration:            v{{.v}}.Expiration,
-		DealWeight:			   v{{.v}}.DealWeight,
+		DealWeight:            v{{.v}}.DealWeight,
-		VerifiedDealWeight:	   v{{.v}}.VerifiedDealWeight,
+		VerifiedDealWeight:    v{{.v}}.VerifiedDealWeight,
-		InitialPledge:		   v{{.v}}.InitialPledge,
+		InitialPledge:         v{{.v}}.InitialPledge,
-		ExpectedDayReward:	   v{{.v}}.ExpectedDayReward,
+		ExpectedDayReward:     v{{.v}}.ExpectedDayReward,
 		ExpectedStoragePledge: v{{.v}}.ExpectedStoragePledge,
 	}
 {{else}}
@@ -497,17 +448,13 @@ func fromV{{.v}}SectorOnChainInfo(v{{.v}} miner{{.v}}.SectorOnChainInfo) SectorO
 func fromV{{.v}}SectorPreCommitOnChainInfo(v{{.v}} miner{{.v}}.SectorPreCommitOnChainInfo) SectorPreCommitOnChainInfo {
 {{if (ge .v 2)}}
 	return SectorPreCommitOnChainInfo{
-		Info:				(SectorPreCommitInfo)(v{{.v}}.Info),
+		Info:               (SectorPreCommitInfo)(v{{.v}}.Info),
-		PreCommitDeposit:	v{{.v}}.PreCommitDeposit,
+		PreCommitDeposit:   v{{.v}}.PreCommitDeposit,
-		PreCommitEpoch:		v{{.v}}.PreCommitEpoch,
+		PreCommitEpoch:     v{{.v}}.PreCommitEpoch,
-		DealWeight:			v{{.v}}.DealWeight,
+		DealWeight:         v{{.v}}.DealWeight,
 		VerifiedDealWeight: v{{.v}}.VerifiedDealWeight,
 	}
 {{else}}
 	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
@@ -88,7 +66,7 @@ func Message(version actors.Version, from address.Address) MessageBuilder {
 {{range .versions}}
 	case actors.Version{{.}}:
 		return message{{.}}{{"{"}}{{if (ge . 2)}}message0{from}{{else}}from{{end}}}
-{{end}} default:
+{{end}}	default:
 		panic(fmt.Sprintf("unsupported actors version: %d", version))
 	}
 }

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

@@ -43,10 +43,10 @@ func (m message{{.v}}) Create(
 {{end}}
 	// Set up constructor parameters for multisig
 	msigParams := &multisig{{.v}}.ConstructorParams{
-		Signers:			   signers,
+		Signers:               signers,
 		NumApprovalsThreshold: threshold,
-		UnlockDuration:		   unlockDuration,{{if (ge .v 2)}}
+		UnlockDuration:        unlockDuration,{{if (ge .v 2)}}
-		StartEpoch:			   unlockStart,{{end}}
+		StartEpoch:            unlockStart,{{end}}
 	}
 
 	enc, actErr := actors.SerializeParams(msigParams)
@@ -56,7 +56,7 @@ func (m message{{.v}}) Create(
 
 	// new actors are created by invoking 'exec' on the init actor with the constructor params
 	execParams := &init{{.v}}.ExecParams{
-		CodeCID:		   builtin{{.v}}.MultisigActorCodeID,
+		CodeCID:           builtin{{.v}}.MultisigActorCodeID,
 		ConstructorParams: enc,
 	}
 
@@ -66,11 +66,11 @@ func (m message{{.v}}) Create(
 	}
 
 	return &types.Message{
-		To:		init_.Address,
+		To:     init_.Address,
-		From:	m.from,
+		From:   m.from,
 		Method: builtin{{.v}}.MethodsInit.Exec,
 		Params: enc,
-		Value:	initialAmount,
+		Value:  initialAmount,
 	}, nil
 }
 
@@ -96,8 +96,8 @@ func (m message0) Propose(msig, to address.Address, amt abi.TokenAmount,
 	}
 
 	enc, actErr := actors.SerializeParams(&multisig0.ProposeParams{
-		To:		to,
+		To:     to,
-		Value:	amt,
+		Value:  amt,
 		Method: method,
 		Params: params,
 	})
@@ -106,9 +106,9 @@ func (m message0) Propose(msig, to address.Address, amt abi.TokenAmount,
 	}
 
 	return &types.Message{
-		To:		msig,
+		To:     msig,
-		From:	m.from,
+		From:   m.from,
-		Value:	abi.NewTokenAmount(0),
+		Value:  abi.NewTokenAmount(0),
 		Method: builtin0.MethodsMultisig.Propose,
 		Params: enc,
 	}, nil
@@ -121,9 +121,9 @@ func (m message0) Approve(msig address.Address, txID uint64, hashData *ProposalH
 	}
 
 	return &types.Message{
-		To:		msig,
+		To:     msig,
-		From:	m.from,
+		From:   m.from,
-		Value:	types.NewInt(0),
+		Value:  types.NewInt(0),
 		Method: builtin0.MethodsMultisig.Approve,
 		Params: enc,
 	}, nil
@@ -136,9 +136,9 @@ func (m message0) Cancel(msig address.Address, txID uint64, hashData *ProposalHa
 	}
 
 	return &types.Message{
-		To:		msig,
+		To:     msig,
-		From:	m.from,
+		From:   m.from,
-		Value:	types.NewInt(0),
+		Value:  types.NewInt(0),
 		Method: builtin0.MethodsMultisig.Cancel,
 		Params: enc,
 	}, nil

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/message.go.template

@@ -21,7 +21,7 @@ func (m message{{.v}}) Create(to address.Address, initialAmount abi.TokenAmount)
 		return nil, aerr
 	}
 	enc, aerr := actors.SerializeParams(&init{{.v}}.ExecParams{
-		CodeCID:		   builtin{{.v}}.PaymentChannelActorCodeID,
+		CodeCID:           builtin{{.v}}.PaymentChannelActorCodeID,
 		ConstructorParams: params,
 	})
 	if aerr != nil {
@@ -29,9 +29,9 @@ func (m message{{.v}}) Create(to address.Address, initialAmount abi.TokenAmount)
 	}
 
 	return &types.Message{
-		To:		init_.Address,
+		To:     init_.Address,
-		From:	m.from,
+		From:   m.from,
-		Value:	initialAmount,
+		Value:  initialAmount,
 		Method: builtin{{.v}}.MethodsInit.Exec,
 		Params: enc,
 	}, nil
@@ -39,7 +39,7 @@ func (m message{{.v}}) Create(to address.Address, initialAmount abi.TokenAmount)
 
 func (m message{{.v}}) Update(paych address.Address, sv *SignedVoucher, secret []byte) (*types.Message, error) {
 	params, aerr := actors.SerializeParams(&paych{{.v}}.UpdateChannelStateParams{
-		Sv:		*sv,
+		Sv:     *sv,
 		Secret: secret,
 	})
 	if aerr != nil {
@@ -47,9 +47,9 @@ func (m message{{.v}}) Update(paych address.Address, sv *SignedVoucher, secret [
 	}
 
 	return &types.Message{
-		To:		paych,
+		To:     paych,
-		From:	m.from,
+		From:   m.from,
-		Value:	abi.NewTokenAmount(0),
+		Value:  abi.NewTokenAmount(0),
 		Method: builtin{{.v}}.MethodsPaych.UpdateChannelState,
 		Params: params,
 	}, nil
@@ -57,18 +57,18 @@ func (m message{{.v}}) Update(paych address.Address, sv *SignedVoucher, secret [
 
 func (m message{{.v}}) Settle(paych address.Address) (*types.Message, error) {
 	return &types.Message{
-		To:		paych,
+		To:     paych,
-		From:	m.from,
+		From:   m.from,
-		Value:	abi.NewTokenAmount(0),
+		Value:  abi.NewTokenAmount(0),
 		Method: builtin{{.v}}.MethodsPaych.Settle,
 	}, nil
 }
 
 func (m message{{.v}}) Collect(paych address.Address) (*types.Message, error) {
 	return &types.Message{
-		To:		paych,
+		To:     paych,
-		From:	m.from,
+		From:   m.from,
-		Value:	abi.NewTokenAmount(0),
+		Value:  abi.NewTokenAmount(0),
 		Method: builtin{{.v}}.MethodsPaych.Collect,
 	}, nil
 }

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)
@@ -101,7 +72,7 @@ type Claim struct {
 
 func AddClaims(a Claim, b Claim) Claim {
 	return Claim{
-		RawBytePower:	 big.Add(a.RawBytePower, b.RawBytePower),
+		RawBytePower:    big.Add(a.RawBytePower, b.RawBytePower),
 		QualityAdjPower: big.Add(a.QualityAdjPower, b.QualityAdjPower),
 	}
 }

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
@@ -66,7 +40,7 @@ func (s *state{{.v}}) TotalLocked() (abi.TokenAmount, error) {
 
 func (s *state{{.v}}) TotalPower() (Claim, error) {
 	return Claim{
-		RawBytePower:	 s.TotalRawBytePower,
+		RawBytePower:    s.TotalRawBytePower,
 		QualityAdjPower: s.TotalQualityAdjPower,
 	}, nil
 }
@@ -74,7 +48,7 @@ func (s *state{{.v}}) TotalPower() (Claim, error) {
 // Committed power to the network. Includes miners below the minimum threshold.
 func (s *state{{.v}}) TotalCommitted() (Claim, error) {
 	return Claim{
-		RawBytePower:	 s.TotalBytesCommitted,
+		RawBytePower:    s.TotalBytesCommitted,
 		QualityAdjPower: s.TotalQABytesCommitted,
 	}, nil
 }
@@ -90,7 +64,7 @@ func (s *state{{.v}}) MinerPower(addr address.Address) (Claim, bool, error) {
 		return Claim{}, false, err
 	}
 	return Claim{
-		RawBytePower:	 claim.RawBytePower,
+		RawBytePower:    claim.RawBytePower,
 		QualityAdjPower: claim.QualityAdjPower,
 	}, ok, nil
 }
@@ -142,7 +116,7 @@ func (s *state{{.v}}) ForEachClaim(cb func(miner address.Address, claim Claim) e
 			return err
 		}
 		return cb(a, Claim{
-			RawBytePower:	 claim.RawBytePower,
+			RawBytePower:    claim.RawBytePower,
 			QualityAdjPower: claim.QualityAdjPower,
 		})
 	})
@@ -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}})
 }
@@ -195,7 +145,7 @@ func (s *state{{.v}}) decodeClaim(val *cbg.Deferred) (Claim, error) {
 
 func fromV{{.v}}Claim(v{{.v}} power{{.v}}.Claim) Claim {
 	return Claim{
-		RawBytePower:	 v{{.v}}.RawBytePower,
+		RawBytePower:    v{{.v}}.RawBytePower,
 		QualityAdjPower: v{{.v}}.QualityAdjPower,
 	}
 }

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

@@ -9,7 +9,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 
 {{if (ge .v 3)}}	builtin{{.v}} "github.com/filecoin-project/specs-actors{{.import}}actors/builtin"
-{{end}} verifreg{{.v}} "github.com/filecoin-project/specs-actors{{.import}}actors/builtin/verifreg"
+{{end}}	verifreg{{.v}} "github.com/filecoin-project/specs-actors{{.import}}actors/builtin/verifreg"
 	adt{{.v}} "github.com/filecoin-project/specs-actors{{.import}}actors/util/adt"
 )
 
@@ -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
-}