pond: Fix node startup

chain/actors/actor_miner_test.go

@@ -1,285 +0,0 @@
-package actors_test
-
-import (
-	"bytes"
-	"context"
-	"math"
-	"math/rand"
-	"testing"
-
-	"github.com/filecoin-project/go-address"
-	commcid "github.com/filecoin-project/go-fil-commcid"
-	"github.com/filecoin-project/specs-actors/actors/abi"
-	"github.com/filecoin-project/specs-actors/actors/builtin/market"
-	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	"github.com/filecoin-project/specs-actors/actors/crypto"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	"github.com/stretchr/testify/assert"
-	cbg "github.com/whyrusleeping/cbor-gen"
-
-	"github.com/filecoin-project/go-sectorbuilder"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/actors/aerrors"
-	"github.com/filecoin-project/lotus/chain/stmgr"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/lib/rlepluslazy"
-)
-
-func TestMinerCommitSectors(t *testing.T) {
-	var worker, client address.Address
-	var minerAddr address.Address
-	opts := []HarnessOpt{
-		HarnessAddr(&worker, 1000000),
-		HarnessAddr(&client, 1000000),
-		HarnessActor(&minerAddr, &worker, actors.StorageMinerCodeCid,
-			func() cbg.CBORMarshaler {
-				return &actors.StorageMinerConstructorParams{
-					Owner:      worker,
-					Worker:     worker,
-					SectorSize: 1024,
-					PeerID:     "fakepeerid",
-				}
-			}),
-	}
-
-	h := NewHarness(t, opts...)
-	h.vm.Syscalls.ValidatePoRep = func(ctx context.Context, maddr address.Address, ssize abi.SectorSize, commD, commR, ticket, proof, seed []byte, sectorID abi.SectorNumber) (bool, aerrors.ActorError) {
-		// all proofs are valid
-		return true, nil
-	}
-
-	ret, _ := h.SendFunds(t, worker, minerAddr, types.NewInt(100000))
-	ApplyOK(t, ret)
-
-	ret, _ = h.InvokeWithValue(t, client, actors.StorageMarketAddress, actors.SMAMethods.AddBalance, types.NewInt(2000), nil)
-	ApplyOK(t, ret)
-
-	addSectorToMiner(h, t, minerAddr, worker, client, 1)
-
-	assertSectorIDs(h, t, minerAddr, []abi.SectorNumber{1})
-
-}
-
-type badRuns struct {
-	done bool
-}
-
-func (br *badRuns) HasNext() bool {
-	return !br.done
-}
-
-func (br *badRuns) NextRun() (rlepluslazy.Run, error) {
-	br.done = true
-	return rlepluslazy.Run{true, math.MaxInt64}, nil
-}
-
-var _ rlepluslazy.RunIterator = (*badRuns)(nil)
-
-func TestMinerSubmitBadFault(t *testing.T) {
-	oldSS, oldMin := build.SectorSizes, build.MinimumMinerPower
-	build.SectorSizes, build.MinimumMinerPower = []abi.SectorSize{1024}, 1024
-	defer func() {
-		build.SectorSizes, build.MinimumMinerPower = oldSS, oldMin
-	}()
-
-	var worker, client address.Address
-	var minerAddr address.Address
-	opts := []HarnessOpt{
-		HarnessAddr(&worker, 1000000),
-		HarnessAddr(&client, 1000000),
-		HarnessAddMiner(&minerAddr, &worker),
-	}
-
-	h := NewHarness(t, opts...)
-	h.vm.Syscalls.ValidatePoRep = func(ctx context.Context, maddr address.Address, ssize abi.SectorSize, commD, commR, ticket, proof, seed []byte, sectorID abi.SectorNumber) (bool, aerrors.ActorError) {
-		// all proofs are valid
-		return true, nil
-	}
-
-	ret, _ := h.SendFunds(t, worker, minerAddr, types.NewInt(100000))
-	ApplyOK(t, ret)
-
-	ret, _ = h.InvokeWithValue(t, client, actors.StorageMarketAddress, actors.SMAMethods.AddBalance, types.NewInt(2000), nil)
-	ApplyOK(t, ret)
-
-	addSectorToMiner(h, t, minerAddr, worker, client, 1)
-
-	assertSectorIDs(h, t, minerAddr, []abi.SectorNumber{1})
-
-	bf := types.NewBitField()
-	bf.Set(6)
-	ret, _ = h.Invoke(t, worker, minerAddr, actors.MAMethods.DeclareFaults, &actors.DeclareFaultsParams{bf})
-	ApplyOK(t, ret)
-
-	ret, _ = h.Invoke(t, actors.NetworkAddress, minerAddr, actors.MAMethods.SubmitElectionPoSt, nil)
-	ApplyOK(t, ret)
-	assertSectorIDs(h, t, minerAddr, []abi.SectorNumber{1})
-
-	st, err := getMinerState(context.TODO(), h.vm.StateTree(), h.bs, minerAddr)
-	assert.NoError(t, err)
-	expectedPower := st.Power
-	if types.BigCmp(expectedPower, types.NewInt(1024)) != 0 {
-		t.Errorf("Expected power of 1024, got %s", expectedPower)
-	}
-
-	badnum := uint64(0)
-	badnum--
-	bf = types.NewBitField()
-	bf.Set(badnum)
-	bf.Set(badnum - 1)
-	ret, _ = h.Invoke(t, worker, minerAddr, actors.MAMethods.DeclareFaults, &actors.DeclareFaultsParams{bf})
-	ApplyOK(t, ret)
-
-	ret, _ = h.Invoke(t, actors.NetworkAddress, minerAddr, actors.MAMethods.SubmitElectionPoSt, nil)
-
-	ApplyOK(t, ret)
-	assertSectorIDs(h, t, minerAddr, []abi.SectorNumber{1})
-
-	st, err = getMinerState(context.TODO(), h.vm.StateTree(), h.bs, minerAddr)
-	assert.NoError(t, err)
-	currentPower := st.Power
-	if types.BigCmp(expectedPower, currentPower) != 0 {
-		t.Errorf("power changed and shouldn't have: %s != %s", expectedPower, currentPower)
-	}
-
-	bf.Set(badnum - 2)
-	ret, _ = h.Invoke(t, worker, minerAddr, actors.MAMethods.DeclareFaults, &actors.DeclareFaultsParams{bf})
-	if ret.ExitCode != 3 {
-		t.Errorf("expected exit code 3, got %d: %+v", ret.ExitCode, ret.ActorErr)
-	}
-	assertSectorIDs(h, t, minerAddr, []abi.SectorNumber{1})
-
-	rle, err := rlepluslazy.EncodeRuns(&badRuns{}, []byte{})
-	assert.NoError(t, err)
-
-	bf, err = types.NewBitFieldFromBytes(rle)
-	assert.NoError(t, err)
-	ret, _ = h.Invoke(t, worker, minerAddr, actors.MAMethods.DeclareFaults, &actors.DeclareFaultsParams{bf})
-	if ret.ExitCode != 3 {
-		t.Errorf("expected exit code 3, got %d: %+v", ret.ExitCode, ret.ActorErr)
-	}
-	assertSectorIDs(h, t, minerAddr, []abi.SectorNumber{1})
-
-	bf = types.NewBitField()
-	bf.Set(1)
-	ret, _ = h.Invoke(t, worker, minerAddr, actors.MAMethods.DeclareFaults, &actors.DeclareFaultsParams{bf})
-	ApplyOK(t, ret)
-
-	ret, _ = h.Invoke(t, actors.NetworkAddress, minerAddr, actors.MAMethods.SubmitElectionPoSt, nil)
-	ApplyOK(t, ret)
-
-	assertSectorIDs(h, t, minerAddr, []abi.SectorNumber{})
-
-}
-
-func addSectorToMiner(h *Harness, t *testing.T, minerAddr, worker, client address.Address, sid abi.SectorNumber) {
-	t.Helper()
-	s := abi.PaddedPieceSize(1024).Unpadded()
-	deal := h.makeFakeDeal(t, minerAddr, worker, client, s)
-	ret, _ := h.Invoke(t, worker, actors.StorageMarketAddress, actors.SMAMethods.PublishStorageDeals,
-		&actors.PublishStorageDealsParams{
-			Deals: []market.ClientDealProposal{*deal},
-		})
-	ApplyOK(t, ret)
-	var dealIds actors.PublishStorageDealResponse
-	if err := dealIds.UnmarshalCBOR(bytes.NewReader(ret.Return)); err != nil {
-		t.Fatal(err)
-	}
-
-	dealid := dealIds.IDs[0]
-
-	ret, _ = h.Invoke(t, worker, minerAddr, actors.MAMethods.PreCommitSector,
-		&miner.SectorPreCommitInfo{
-			SectorNumber: sid,
-			SealedCID:    commcid.ReplicaCommitmentV1ToCID([]byte("cats")),
-			SealEpoch:    10,
-			DealIDs:      []abi.DealID{dealid},
-		})
-	ApplyOK(t, ret)
-
-	h.BlockHeight += 100
-	ret, _ = h.Invoke(t, worker, minerAddr, actors.MAMethods.ProveCommitSector,
-		&miner.ProveCommitSectorParams{
-			SectorNumber: sid,
-			Proof:        abi.SealProof{ProofBytes: []byte("prooofy")},
-		})
-	ApplyOK(t, ret)
-}
-
-func assertSectorIDs(h *Harness, t *testing.T, maddr address.Address, ids []abi.SectorNumber) {
-	t.Helper()
-	sectors, err := getMinerSectorSet(context.TODO(), h.vm.StateTree(), h.bs, maddr)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(sectors) != len(ids) {
-		t.Fatal("miner has wrong number of sectors in their sector set")
-	}
-
-	all := make(map[abi.SectorNumber]bool)
-	for _, s := range sectors {
-		all[s.SectorID] = true
-	}
-
-	for _, id := range ids {
-		if !all[id] {
-			t.Fatal("expected to find sector ID: ", id)
-		}
-	}
-}
-
-func getMinerState(ctx context.Context, st types.StateTree, bs blockstore.Blockstore, maddr address.Address) (*actors.StorageMinerActorState, error) {
-	mact, err := st.GetActor(maddr)
-	if err != nil {
-		return nil, err
-	}
-
-	cst := cbor.NewCborStore(bs)
-
-	var mstate actors.StorageMinerActorState
-	if err := cst.Get(ctx, mact.Head, &mstate); err != nil {
-		return nil, err
-	}
-	return &mstate, nil
-}
-
-func getMinerSectorSet(ctx context.Context, st types.StateTree, bs blockstore.Blockstore, maddr address.Address) ([]*api.ChainSectorInfo, error) {
-	mstate, err := getMinerState(ctx, st, bs, maddr)
-	if err != nil {
-		return nil, err
-	}
-
-	return stmgr.LoadSectorsFromSet(ctx, bs, mstate.Sectors)
-}
-
-func (h *Harness) makeFakeDeal(t *testing.T, miner, worker, client address.Address, size abi.UnpaddedPieceSize) *market.ClientDealProposal {
-	data := make([]byte, size)
-	rand.Read(data)
-	commP, err := sectorbuilder.GeneratePieceCommitment(bytes.NewReader(data), size)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	prop := market.DealProposal{
-		PieceCID:  commcid.PieceCommitmentV1ToCID(commP[:]),
-		PieceSize: size.Padded(),
-
-		Client:   client,
-		Provider: miner,
-
-		StartEpoch: 10000,
-		EndEpoch:   10150,
-
-		StoragePricePerEpoch: types.NewInt(1),
-		ProviderCollateral:   types.NewInt(0),
-	}
-
-	return &market.ClientDealProposal{
-		Proposal:        prop,
-		ClientSignature: crypto.Signature{}, // TODO: not quite correct
-	}
-}

cmd/chain-noise/main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"fmt"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
 	"math/rand"
 	"os"
 	"time"
@@ -59,7 +60,7 @@ var runCmd = &cli.Command{
 func sendSmallFundsTxs(ctx context.Context, api api.FullNode, from address.Address, rate int) error {
 	var sendSet []address.Address
 	for i := 0; i < 20; i++ {
-		naddr, err := api.WalletNew(ctx, "bls")
+		naddr, err := api.WalletNew(ctx, crypto.SigTypeSecp256k1)
 		if err != nil {
 			return err
 		}

cmd/lotus/daemon.go

@@ -4,9 +4,14 @@ package main
 
 import (
 	"context"
+	"encoding/hex"
+	"encoding/json"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/mitchellh/go-homedir"
 	"io/ioutil"
 	"os"
 	"runtime/pprof"
+	"strings"
 
 	paramfetch "github.com/filecoin-project/go-paramfetch"
 	"github.com/filecoin-project/go-sectorbuilder"
@@ -50,6 +55,11 @@ var DaemonCmd = &cli.Command{
 			Name:   preTemplateFlag,
 			Hidden: true,
 		},
+		&cli.StringFlag{
+			Name:  "import-key",
+			Usage: "on first run, import a default key from a given file",
+			Hidden: true,
+		},
 		&cli.StringFlag{
 			Name:  "genesis",
 			Usage: "genesis file to use for first node run",
@@ -157,6 +167,12 @@ var DaemonCmd = &cli.Command{
 			return xerrors.Errorf("initializing node: %w", err)
 		}
 
+		if cctx.String("import-key") != "" {
+			if err := importKey(ctx, api, cctx.String("import-key")); err != nil {
+				log.Errorf("importing key failed: %+v", err)
+			}
+		}
+
 		endpoint, err := r.APIEndpoint()
 		if err != nil {
 			return xerrors.Errorf("getting api endpoint: %w", err)
@@ -167,6 +183,40 @@ var DaemonCmd = &cli.Command{
 	},
 }
 
+func importKey(ctx context.Context, api api.FullNode, f string) error {
+	f, err := homedir.Expand(f)
+	if err != nil {
+		return err
+	}
+
+	hexdata, err := ioutil.ReadFile(f)
+	if err != nil {
+		return err
+	}
+
+	data, err := hex.DecodeString(strings.TrimSpace(string(hexdata)))
+	if err != nil {
+		return err
+	}
+
+	var ki types.KeyInfo
+	if err := json.Unmarshal(data, &ki); err != nil {
+		return err
+	}
+
+	addr, err := api.WalletImport(ctx, &ki)
+	if err != nil {
+		return err
+	}
+
+	if err := api.WalletSetDefault(ctx, addr); err != nil {
+		return err
+	}
+
+	log.Info("successfully imported key for %s", addr)
+	return nil
+}
+
 func ImportChain(r repo.Repo, fname string) error {
 	fi, err := os.Open(fname)
 	if err != nil {

lotuspond/spawn.go

@@ -1,7 +1,11 @@
 package main
 
 import (
+	"encoding/json"
 	"fmt"
+	genesis2 "github.com/filecoin-project/lotus/chain/gen/genesis"
+	"github.com/filecoin-project/lotus/genesis"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
 	"io"
 	"io/ioutil"
 	"os"
@@ -35,7 +39,7 @@ func (api *api) Spawn() (nodeInfo, error) {
 	if id == 1 {
 		// preseal
 
-		genMiner, err := address.NewIDAddress(101)
+		genMiner, err := address.NewIDAddress(genesis2.MinerStart)
 		if err != nil {
 			return nodeInfo{}, err
 		}
@@ -49,7 +53,27 @@ func (api *api) Spawn() (nodeInfo, error) {
 		if err := seed.WriteGenesisMiner(genMiner, sbroot, genm, ki); err != nil {
 			return nodeInfo{}, xerrors.Errorf("failed to write genminer info: %w", err)
 		}
-		params = append(params, "--genesis-presealed-sectors="+filepath.Join(dir, "preseal", "pre-seal-t0101.json"))
+		params = append(params, "--import-key="+filepath.Join(dir, "preseal", "pre-seal-t01000.key"))
+		params = append(params, "--genesis-template="+filepath.Join(dir, "preseal", "genesis-template.json"))
+
+		// Create template
+
+		var template genesis.Template
+		template.Miners = append(template.Miners, *genm)
+		template.Accounts = append(template.Accounts, genesis.Actor{
+			Type:    genesis.TAccount,
+			Balance: big.NewInt(100000000000000),
+			Meta:    (&genesis.AccountMeta{Owner: genm.Owner}).ActorMeta(),
+		})
+
+		tb, err := json.Marshal(&template)
+		if err != nil {
+			return nodeInfo{}, xerrors.Errorf("marshal genesis template: %w", err)
+		}
+
+		if err := ioutil.WriteFile(filepath.Join(dir, "preseal", "genesis-template.json"), tb, 0664); err != nil {
+			return nodeInfo{}, xerrors.Errorf("write genesis template: %w", err)
+		}
 
 		// make genesis
 		genf, err := ioutil.TempFile(os.TempDir(), "lotus-genesis-")
@@ -58,7 +82,7 @@ func (api *api) Spawn() (nodeInfo, error) {
 		}
 
 		api.genesis = genf.Name()
-		genParam = "--lotus-make-random-genesis=" + api.genesis
+		genParam = "--lotus-make-genesis=" + api.genesis
 
 		if err := genf.Close(); err != nil {
 			return nodeInfo{}, err
@@ -143,7 +167,7 @@ func (api *api) SpawnStorage(fullNodeRepo string) (nodeInfo, error) {
 
 	initArgs := []string{"init", "--nosync"}
 	if fullNodeRepo == api.running[1].meta.Repo {
-		initArgs = []string{"init", "--actor=t0101", "--genesis-miner", "--pre-sealed-sectors=" + filepath.Join(fullNodeRepo, "preseal")}
+		initArgs = []string{"init", "--actor=t01000", "--genesis-miner", "--pre-sealed-sectors=" + filepath.Join(fullNodeRepo, "preseal")}
 	}
 
 	id := atomic.AddInt32(&api.cmds, 1)