Merge remote-tracking branch 'origin/master' into feat/new-sb-fs

build/forks.go

@@ -5,3 +5,5 @@ const ForkBlizzardHeight = 6288
 const ForkFrigidHeight = 7950
 
 const ForkBootyBayHeight = 11000
+
+const ForkMissingSnowballs = 34000

build/parameters.go

@@ -2,4 +2,6 @@ package build
 
 import rice "github.com/GeertJohan/go.rice"
 
-var ParametersJson = rice.MustFindBox("proof-params").MustBytes("parameters.json")
+func ParametersJson() []byte {
+	return rice.MustFindBox("proof-params").MustBytes("parameters.json")
+}

build/version.go

@@ -5,7 +5,7 @@ import "fmt"
 var CurrentCommit string
 
 // BuildVersion is the local build version, set by build system
-const BuildVersion = "0.2.6"
+const BuildVersion = "0.2.7"
 
 var UserVersion = BuildVersion + CurrentCommit
 

chain/actors/actor_miner2.go

@@ -33,7 +33,10 @@ func (sma StorageMinerActor2) Exports() []interface{} {
 		//8:  sma.DePledge,
 		9:  sma.GetOwner,
 		10: sma.GetWorkerAddr,
-		11: sma.GetPower, // TODO: Remove
+		11: withUpdates(
+			update{0, sma.GetPower},
+			update{build.ForkMissingSnowballs, sma.GetPower2},
+		), // FORK
 		12: sma.GetPeerID,
 		13: sma.GetSectorSize,
 		14: sma.UpdatePeerID,
@@ -401,6 +404,20 @@ func (sma StorageMinerActor2) GetPower(act *types.Actor, vmctx types.VMContext,
 	if err != nil {
 		return nil, err
 	}
+
+	return self.Power.Bytes(), nil
+}
+
+func (sma StorageMinerActor2) GetPower2(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
+	_, self, err := loadState(vmctx)
+	if err != nil {
+		return nil, err
+	}
+
+	if self.SlashedAt != 0 {
+		return types.NewInt(0).Bytes(), nil
+	}
+
 	return self.Power.Bytes(), nil
 }
 
@@ -615,6 +632,11 @@ func (sma StorageMinerActor2) CheckMiner(act *types.Actor, vmctx types.VMContext
 	// Slash for being late
 
 	self.SlashedAt = vmctx.BlockHeight()
+	oldPower := self.Power
+
+	if vmctx.BlockHeight() > build.ForkMissingSnowballs {
+		self.Power = types.NewInt(0)
+	}
 
 	nstate, err := vmctx.Storage().Put(self)
 	if err != nil {
@@ -625,7 +647,7 @@ func (sma StorageMinerActor2) CheckMiner(act *types.Actor, vmctx types.VMContext
 	}
 
 	var out bytes.Buffer
-	if err := self.Power.MarshalCBOR(&out); err != nil {
+	if err := oldPower.MarshalCBOR(&out); err != nil {
 		return nil, aerrors.HandleExternalError(err, "marshaling return value")
 	}
 	return out.Bytes(), nil
@@ -710,6 +732,23 @@ func (sma StorageMinerActor2) SlashConsensusFault(act *types.Actor, vmctx types.
 		return nil, aerrors.Wrap(err, "failed to burn funds")
 	}
 
+	if vmctx.BlockHeight() > build.ForkMissingSnowballs {
+		oldstate, self, err := loadState(vmctx)
+		if err != nil {
+			return nil, aerrors.Wrap(err, "failed to load state for slashing")
+		}
+
+		self.Power = types.NewInt(0)
+
+		ncid, err := vmctx.Storage().Put(self)
+		if err != nil {
+			return nil, err
+		}
+		if err := vmctx.Storage().Commit(oldstate, ncid); err != nil {
+			return nil, err
+		}
+	}
+
 	// TODO: this still allows the miner to commit sectors and submit posts,
 	// their users could potentially be unaffected, but the miner will never be
 	// able to mine a block again

chain/actors/actor_storagepower.go

@@ -648,6 +648,8 @@ func checkProofSubmissionsAtH(vmctx types.VMContext, self *StoragePowerState, he
 		return aerrors.HandleExternalError(err, "failed to load proving bucket")
 	}
 
+	forRemoval := make([]address.Address, 0)
+
 	err = bhamt.ForEach(vmctx.Context(), func(k string, val interface{}) error {
 		_, span := trace.StartSpan(vmctx.Context(), "StoragePowerActor.CheckProofSubmissions.loop")
 		defer span.End()
@@ -657,6 +659,18 @@ func checkProofSubmissionsAtH(vmctx types.VMContext, self *StoragePowerState, he
 			return aerrors.Escalate(err, "parsing miner address")
 		}
 
+		if vmctx.BlockHeight() > build.ForkMissingSnowballs {
+			has, aerr := MinerSetHas(vmctx, self.Miners, maddr)
+			if aerr != nil {
+				return aerr
+			}
+
+			if !has {
+				forRemoval = append(forRemoval, maddr)
+			}
+
+		}
+
 		span.AddAttributes(trace.StringAttribute("miner", maddr.String()))
 
 		params, err := SerializeParams(&CheckMinerParams{NetworkPower: self.TotalStorage})
@@ -690,6 +704,24 @@ func checkProofSubmissionsAtH(vmctx types.VMContext, self *StoragePowerState, he
 		return aerrors.HandleExternalError(err, "iterating miners in proving bucket")
 	}
 
+	if vmctx.BlockHeight() > build.ForkMissingSnowballs && len(forRemoval) > 0 {
+		nBucket, err := MinerSetRemove(vmctx.Context(), vmctx, bucket, forRemoval...)
+
+		if err != nil {
+			return aerrors.Wrap(err, "could not remove miners from set")
+		}
+
+		eerr := buckets.Set(bucketID, nBucket)
+		if err != nil {
+			return aerrors.HandleExternalError(eerr, "could not set the bucket")
+		}
+		ncid, eerr := buckets.Flush()
+		if err != nil {
+			return aerrors.HandleExternalError(eerr, "could not flush buckets")
+		}
+		self.ProvingBuckets = ncid
+	}
+
 	return nil
 }
 
@@ -764,19 +796,21 @@ func MinerSetAdd(ctx context.Context, vmctx types.VMContext, rcid cid.Cid, maddr
 	return c, nil
 }
 
-func MinerSetRemove(ctx context.Context, vmctx types.VMContext, rcid cid.Cid, maddr address.Address) (cid.Cid, aerrors.ActorError) {
+func MinerSetRemove(ctx context.Context, vmctx types.VMContext, rcid cid.Cid, maddrs ...address.Address) (cid.Cid, aerrors.ActorError) {
 	nd, err := hamt.LoadNode(ctx, vmctx.Ipld(), rcid)
 	if err != nil {
 		return cid.Undef, aerrors.HandleExternalError(err, "failed to load miner set")
 	}
 
-	mkey := string(maddr.Bytes())
-	switch nd.Delete(ctx, mkey) {
-	default:
-		return cid.Undef, aerrors.HandleExternalError(err, "failed to delete miner from set")
-	case hamt.ErrNotFound:
-		return cid.Undef, aerrors.New(1, "miner not found in set on delete")
-	case nil:
+	for _, maddr := range maddrs {
+		mkey := string(maddr.Bytes())
+		switch nd.Delete(ctx, mkey) {
+		default:
+			return cid.Undef, aerrors.HandleExternalError(err, "failed to delete miner from set")
+		case hamt.ErrNotFound:
+			return cid.Undef, aerrors.New(1, "miner not found in set on delete")
+		case nil:
+		}
 	}
 
 	if err := nd.Flush(ctx); err != nil {

chain/actors/forks.go

@@ -26,7 +26,7 @@ func withUpdates(updates ...update) interface{} {
 		vmctx := args[1].Interface().(types.VMContext)
 
 		for _, u := range updates {
-			if vmctx.BlockHeight() >= u.start {
+			if vmctx.BlockHeight() > u.start {
 				return reflect.ValueOf(u.method).Call(args)
 			}
 		}

chain/stmgr/forks.go

@@ -7,6 +7,7 @@ import (
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/state"
+	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/ipfs/go-cid"
 	hamt "github.com/ipfs/go-hamt-ipld"
 	blockstore "github.com/ipfs/go-ipfs-blockstore"
@@ -35,12 +36,69 @@ func (sm *StateManager) handleStateForks(ctx context.Context, pstate cid.Cid, he
 			if err != nil {
 				return cid.Undef, xerrors.Errorf("booty bay bug fix failed: %w", err)
 			}
+		case build.ForkMissingSnowballs:
+			log.Warnw("Adding more snow to the world", "height", i)
+			pstate, err = fixTooFewSnowballs(ctx, sm, pstate)
+			if err != nil {
+				return cid.Undef, xerrors.Errorf("missing snowballs bug fix failed: %w", err)
+			}
 		}
 	}
 
 	return pstate, nil
 }
 
+func fixTooFewSnowballs(ctx context.Context, sm *StateManager, pstate cid.Cid) (cid.Cid, error) {
+	cst := hamt.CSTFromBstore(sm.cs.Blockstore())
+	st, err := state.LoadStateTree(cst, pstate)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	spa, err := st.GetActor(actors.StoragePowerAddress)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to get storage power actor: %w", err)
+	}
+
+	var spast actors.StoragePowerState
+	if err := cst.Get(ctx, spa.Head, &spast); err != nil {
+		return cid.Undef, err
+	}
+
+	miners, err := actors.MinerSetList(ctx, cst, spast.Miners)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	sum := types.NewInt(0)
+	for _, m := range miners {
+		mact, err := st.GetActor(m)
+		if err != nil {
+			return cid.Undef, xerrors.Errorf("getting miner actor to fix: %w", err)
+		}
+
+		var mstate actors.StorageMinerActorState
+		if err := cst.Get(ctx, mact.Head, &mstate); err != nil {
+			return cid.Undef, xerrors.Errorf("failed to load miner actor state: %w", err)
+		}
+
+		if mstate.SlashedAt != 0 {
+			continue
+		}
+		sum = types.BigAdd(sum, mstate.Power)
+	}
+
+	spast.TotalStorage = sum
+	nspahead, err := cst.Put(ctx, &spast)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	spa.Head = nspahead
+
+	return st.Flush(ctx)
+}
+
 /*
 1) Iterate through each miner in the chain:
 	1.1) Fixup their sector set and proving set

cli/chain.go

@@ -388,6 +388,14 @@ func printTipSet(format string, ts *types.TipSet) {
 		blks += fmt.Sprintf("%s: %s,", b.Cid(), b.Miner)
 	}
 	blks += " ]"
+
+	sCids := make([]string, 0, len(blks))
+
+	for _, c := range ts.Cids() {
+		sCids = append(sCids, c.String())
+	}
+
+	format = strings.ReplaceAll(format, "<tipset>", strings.Join(sCids, ","))
 	format = strings.ReplaceAll(format, "<blocks>", blks)
 	format = strings.ReplaceAll(format, "<weight>", fmt.Sprint(ts.Blocks()[0].ParentWeight))
 

cli/params.go

@@ -24,7 +24,7 @@ var fetchParamCmd = &cli.Command{
 			return err
 		}
 		sectorSize := uint64(sectorSizeInt)
-		err = paramfetch.GetParams(build.ParametersJson, sectorSize)
+		err = paramfetch.GetParams(build.ParametersJson(), sectorSize)
 		if err != nil {
 			return xerrors.Errorf("fetching proof parameters: %w", err)
 		}

cmd/lotus-bench/main.go

@@ -155,7 +155,7 @@ func main() {
 				}
 			}
 
-			if err := paramfetch.GetParams(build.ParametersJson, sectorSize); err != nil {
+			if err := paramfetch.GetParams(build.ParametersJson(), sectorSize); err != nil {
 				return xerrors.Errorf("getting params: %w", err)
 			}
 			sb, err := sectorbuilder.New(cfg, mds)

cmd/lotus-seal-worker/sub.go

@@ -41,7 +41,7 @@ func acceptJobs(ctx context.Context, api lapi.StorageMiner, endpoint string, aut
 		return err
 	}
 
-	if err := paramfetch.GetParams(build.ParametersJson, ssize); err != nil {
+	if err := paramfetch.GetParams(build.ParametersJson(), ssize); err != nil {
 		return xerrors.Errorf("get params: %w", err)
 	}
 

cmd/lotus-shed/bigint.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"encoding/base64"
+	"encoding/hex"
+	"fmt"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	"gopkg.in/urfave/cli.v2"
+)
+
+var bigIntParseCmd = &cli.Command{
+	Name:        "bigint",
+	Description: "parse encoded big ints",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "enc",
+			Value: "base64",
+			Usage: "specify input encoding to parse",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		val := cctx.Args().Get(0)
+
+		var dec []byte
+		switch cctx.String("enc") {
+		case "base64":
+			d, err := base64.StdEncoding.DecodeString(val)
+			if err != nil {
+				return fmt.Errorf("decoding base64 value: %w", err)
+			}
+			dec = d
+		case "hex":
+			d, err := hex.DecodeString(val)
+			if err != nil {
+				return fmt.Errorf("decoding hex value: %w", err)
+			}
+			dec = d
+		default:
+			return fmt.Errorf("unrecognized encoding: %s", cctx.String("enc"))
+		}
+
+		iv := types.BigFromBytes(dec)
+		fmt.Println(iv.String())
+		return nil
+	},
+}

cmd/lotus-shed/main.go

@@ -20,6 +20,7 @@ func main() {
 		keyinfoCmd,
 		peerkeyCmd,
 		noncefix,
+		bigIntParseCmd,
 	}
 
 	app := &cli.App{

cmd/lotus-storage-miner/info.go

@@ -50,8 +50,8 @@ var infoCmd = &cli.Command{
 			return err
 		}
 
-		percI := types.BigDiv(types.BigMul(pow.MinerPower, types.NewInt(1000)), pow.TotalPower)
-		fmt.Printf("Power: %s / %s (%0.4f%%)\n", pow.MinerPower.SizeStr(), pow.TotalPower.SizeStr(), float64(percI.Int64())/100000*10000)
+		percI := types.BigDiv(types.BigMul(pow.MinerPower, types.NewInt(1000000)), pow.TotalPower)
+		fmt.Printf("Power: %s / %s (%0.4f%%)\n", pow.MinerPower.SizeStr(), pow.TotalPower.SizeStr(), float64(percI.Int64())/10000)
 
 		secCounts, err := api.StateMinerSectorCount(ctx, maddr, nil)
 		if err != nil {

cmd/lotus-storage-miner/init.go

@@ -97,7 +97,7 @@ var initCmd = &cli.Command{
 		}
 
 		log.Info("Checking proof parameters")
-		if err := paramfetch.GetParams(build.ParametersJson, ssize); err != nil {
+		if err := paramfetch.GetParams(build.ParametersJson(), ssize); err != nil {
 			return xerrors.Errorf("fetching proof parameters: %w", err)
 		}
 

cmd/lotus/daemon.go

@@ -100,7 +100,7 @@ var DaemonCmd = &cli.Command{
 			return xerrors.Errorf("repo init error: %w", err)
 		}
 
-		if err := paramfetch.GetParams(build.ParametersJson, 0); err != nil {
+		if err := paramfetch.GetParams(build.ParametersJson(), 0); err != nil {
 			return xerrors.Errorf("fetching proof parameters: %w", err)
 		}
 

node/modules/storageminer.go

@@ -56,7 +56,7 @@ func minerAddrFromDS(ds dtypes.MetadataDS) (address.Address, error) {
 }
 
 func GetParams(sbc *sectorbuilder.Config) error {
-	if err := paramfetch.GetParams(build.ParametersJson, sbc.SectorSize); err != nil {
+	if err := paramfetch.GetParams(build.ParametersJson(), sbc.SectorSize); err != nil {
 		return xerrors.Errorf("fetching proof parameters: %w", err)
 	}