cmd/lotus: Fix build

cmd/lotus/daemon.go

@@ -28,8 +28,8 @@ import (
 )
 
 const (
-	makeGenFlag          = "lotus-make-random-genesis"
+	makeGenFlag     = "lotus-make-random-genesis"
-	preSealedSectorsFlag = "genesis-presealed-sectors"
+	preTemplateFlag = "genesis-template"
 )
 
 // DaemonCmd is the `go-lotus daemon` command
@@ -47,7 +47,7 @@ var DaemonCmd = &cli.Command{
 			Hidden: true,
 		},
 		&cli.StringFlag{
-			Name:   preSealedSectorsFlag,
+			Name:   preTemplateFlag,
 			Hidden: true,
 		},
 		&cli.StringFlag{
@@ -128,10 +128,10 @@ var DaemonCmd = &cli.Command{
 			genesis = node.Override(new(modules.Genesis), modules.LoadGenesis(genBytes))
 		}
 		if cctx.String(makeGenFlag) != "" {
-			if cctx.String(preSealedSectorsFlag) == "" {
+			if cctx.String(preTemplateFlag) == "" {
-				return xerrors.Errorf("must also pass file with miner preseal info to `--%s`", preSealedSectorsFlag)
+				return xerrors.Errorf("must also pass file with genesis template to `--%s`", preTemplateFlag)
 			}
-			genesis = node.Override(new(modules.Genesis), testing.MakeGenesis(cctx.String(makeGenFlag), cctx.String(preSealedSectorsFlag), cctx.String("genesis-timestamp")))
+			genesis = node.Override(new(modules.Genesis), testing.MakeGenesis(cctx.String(makeGenFlag), cctx.String(preTemplateFlag)))
 		}
 
 		var api api.FullNode

node/builder.go

@@ -3,6 +3,7 @@ package node
 import (
 	"context"
 	"errors"
+	"github.com/filecoin-project/specs-actors/actors/runtime"
 	"time"
 
 	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
@@ -202,7 +203,7 @@ func Online() Option {
 			Override(HandleIncomingMessagesKey, modules.HandleIncomingMessages),
 
 			Override(new(sectorbuilder.Verifier), sectorbuilder.ProofVerifier),
-			Override(new(*types.VMSyscalls), vm.Syscalls),
+			Override(new(runtime.Syscalls), vm.Syscalls),
 			Override(new(*store.ChainStore), modules.ChainStore),
 			Override(new(*stmgr.StateManager), stmgr.NewStateManager),
 			Override(new(*wallet.Wallet), wallet.NewWallet),

node/modules/testing/genesis.go

@@ -15,15 +15,13 @@ import (
 	offline "github.com/ipfs/go-ipfs-exchange-offline"
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/ipfs/go-merkledag"
-	"github.com/libp2p/go-libp2p-core/peer"
 	"github.com/mitchellh/go-homedir"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/specs-actors/actors/runtime"
 
 	genesis2 "github.com/filecoin-project/lotus/chain/gen/genesis"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/wallet"
 	"github.com/filecoin-project/lotus/genesis"
 	"github.com/filecoin-project/lotus/node/modules"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
@@ -31,28 +29,11 @@ import (
 
 var glog = logging.Logger("genesis")
 
-func MakeGenesisMem(out io.Writer, gmc *genesis2.GenMinerCfg) func(bs dtypes.ChainBlockstore, w *wallet.Wallet, syscalls *types.VMSyscalls) modules.Genesis {
+func MakeGenesisMem(out io.Writer, template genesis.Template) func(bs dtypes.ChainBlockstore, syscalls runtime.Syscalls) modules.Genesis {
-	return func(bs dtypes.ChainBlockstore, w *wallet.Wallet, syscalls *types.VMSyscalls) modules.Genesis {
+	return func(bs dtypes.ChainBlockstore, syscalls runtime.Syscalls) modules.Genesis {
 		return func() (*types.BlockHeader, error) {
 			glog.Warn("Generating new random genesis block, note that this SHOULD NOT happen unless you are setting up new network")
-			defk, err := w.GenerateKey(types.KTBLS)
+			b, err := genesis2.MakeGenesisBlock(context.TODO(), bs, syscalls, template)
-			if err != nil {
-				return nil, err
-			}
-
-			alloc := map[address.Address]types.BigInt{
-				defk: types.FromFil(1000),
-			}
-
-			for _, genm := range gmc.PreSeals {
-				waddr, err := w.Import(&genm.Key)
-				if err != nil {
-					return nil, err
-				}
-				alloc[waddr] = types.FromFil(10000)
-			}
-
-			b, err := genesis2.MakeGenesisBlock(bs, syscalls, alloc, gmc, 100000)
 			if err != nil {
 				return nil, err
 			}
@@ -69,74 +50,35 @@ func MakeGenesisMem(out io.Writer, gmc *genesis2.GenMinerCfg) func(bs dtypes.Cha
 	}
 }
 
-func MakeGenesis(outFile, presealInfo, timestamp string) func(bs dtypes.ChainBlockstore, w *wallet.Wallet, syscalls *types.VMSyscalls) modules.Genesis {
+func MakeGenesis(outFile, genesisTemplate string) func(bs dtypes.ChainBlockstore, syscalls runtime.Syscalls) modules.Genesis {
-	return func(bs dtypes.ChainBlockstore, w *wallet.Wallet, syscalls *types.VMSyscalls) modules.Genesis {
+	return func(bs dtypes.ChainBlockstore, syscalls runtime.Syscalls) modules.Genesis {
 		return func() (*types.BlockHeader, error) {
 			glog.Warn("Generating new random genesis block, note that this SHOULD NOT happen unless you are setting up new network")
-			presealInfo, err := homedir.Expand(presealInfo)
+			genesisTemplate, err := homedir.Expand(genesisTemplate)
 			if err != nil {
 				return nil, err
 			}
 
-			fdata, err := ioutil.ReadFile(presealInfo)
+			fdata, err := ioutil.ReadFile(genesisTemplate)
 			if err != nil {
 				return nil, xerrors.Errorf("reading preseals json: %w", err)
 			}
 
-			var preseals map[string]genesis.Miner
+			var template genesis.Template
-			if err := json.Unmarshal(fdata, &preseals); err != nil {
+			if err := json.Unmarshal(fdata, template); err != nil {
 				return nil, err
 			}
 
-			var fakePeerIDs []peer.ID
+			if template.Timestamp == 0 {
-			minerAddresses := make([]address.Address, 0, len(preseals))
+				template.Timestamp = uint64(time.Now().Unix())
-			for s := range preseals {
-				a, err := address.NewFromString(s)
-				if err != nil {
-					return nil, err
-				}
-				if a.Protocol() != address.ID {
-					return nil, xerrors.New("expected ID address")
-				}
-				minerAddresses = append(minerAddresses, a)
-				fakePeerIDs = append(fakePeerIDs, peer.ID("peer"+a.String()))
 			}
 
-			gmc := &genesis2.GenMinerCfg{
+			b, err := genesis2.MakeGenesisBlock(context.TODO(), bs, syscalls, template)
-				PeerIDs:    fakePeerIDs,
-				PreSeals:   preseals,
-				MinerAddrs: minerAddresses,
-			}
-
-			addrs := map[address.Address]types.BigInt{}
-
-			for _, miner := range preseals {
-				if _, err := w.Import(&miner.Key); err != nil {
-					return nil, xerrors.Errorf("importing miner key: %w", err)
-				}
-
-				_ = w.SetDefault(miner.Worker)
-
-				addrs[miner.Worker] = types.FromFil(100000)
-			}
-
-			ts := uint64(time.Now().Unix())
-			if timestamp != "" {
-				t, err := time.Parse(time.RFC3339, timestamp)
-				if err != nil {
-					return nil, xerrors.Errorf("parsing input genesis timestamp: %w", err)
-				}
-
-				glog.Infof("will use %s as the genesis timestamp", t)
-				ts = uint64(t.Unix())
-			}
-
-			b, err := genesis2.MakeGenesisBlock(bs, syscalls, addrs, gmc, ts)
 			if err != nil {
 				return nil, err
 			}
 
-			fmt.Println("GENESIS MINER ADDRESS: ", gmc.MinerAddrs[0].String())
+			fmt.Printf("GENESIS MINER ADDRESS: t0%d\n", genesis2.MinerStart)
 
 			f, err := os.OpenFile(outFile, os.O_CREATE|os.O_WRONLY, 0644)
 			if err != nil {