cerc-io/lotus
16
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 27 Wiki Activity

cmd/lotus: Fix build

Browse Source
This commit is contained in:
Łukasz Magiera 2020-02-21 19:00:10 +01:00
parent a6268f055d
commit 852e888232
3 changed files with 22 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
cmd/lotus/daemon.go
View File

@ -28,8 +28,8 @@ import (
)
const (
makeGenFlag = "lotus-make-random-genesis"
preSealedSectorsFlag = "genesis-presealed-sectors"
makeGenFlag = "lotus-make-random-genesis"
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) == "" {
return xerrors.Errorf("must also pass file with miner preseal info to `--%s`", preSealedSectorsFlag)
if cctx.String(preTemplateFlag) == "" {
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

3
node/builder.go
View File

@ -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),

86
node/modules/testing/genesis.go
View File

@ -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 {
return 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, 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)
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)
b, err := genesis2.MakeGenesisBlock(context.TODO(), bs, syscalls, template)
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 {
return 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, 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
if err := json.Unmarshal(fdata, &preseals); err != nil {
var template genesis.Template
if err := json.Unmarshal(fdata, template); err != nil {
return nil, err
}
var fakePeerIDs []peer.ID
minerAddresses := make([]address.Address, 0, len(preseals))
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()))
if template.Timestamp == 0 {
template.Timestamp = uint64(time.Now().Unix())
}
gmc := &genesis2.GenMinerCfg{
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)
b, err := genesis2.MakeGenesisBlock(context.TODO(), bs, syscalls, template)
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 {