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

build/params_debug.go

@@ -2,6 +2,10 @@
 
 package build
 
+func init() {
+	InsecurePoStValidation = true
+}
+
 var SectorSizes = []uint64{1024}
 
 // Seconds

cmd/lotus/debug_advance.go

@@ -0,0 +1,112 @@
+// +build debug
+
+package main
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/gen"
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/filecoin-project/lotus/miner"
+	"golang.org/x/xerrors"
+
+	"gopkg.in/urfave/cli.v2"
+)
+
+func init() {
+	AdvanceBlockCmd = &cli.Command{
+		Name: "advance-block",
+		Action: func(cctx *cli.Context) error {
+			api, closer, err := lcli.GetFullNodeAPI(cctx)
+			if err != nil {
+				return err
+			}
+			defer closer()
+
+			ctx := lcli.ReqContext(cctx)
+			head, err := api.ChainHead(ctx)
+			if err != nil {
+				return err
+			}
+			pending, err := api.MpoolPending(ctx, head)
+			if err != nil {
+				return err
+			}
+
+			msgs, err := miner.SelectMessages(ctx, api.StateGetActor, head, pending)
+			if len(msgs) > build.BlockMessageLimit {
+				log.Error("SelectMessages returned too many messages: ", len(msgs))
+				msgs = msgs[:build.BlockMessageLimit]
+			}
+
+			addr, _ := address.NewIDAddress(101)
+			var ticket *types.Ticket
+			{
+				vrfBase := head.MinTicket().VRFProof
+				ret, err := api.StateCall(ctx, &types.Message{
+					From:   addr,
+					To:     addr,
+					Method: actors.MAMethods.GetWorkerAddr,
+				}, head)
+				if err != nil {
+					return xerrors.Errorf("failed to get miner worker addr: %w", err)
+				}
+
+				if ret.ExitCode != 0 {
+					return xerrors.Errorf("failed to get miner worker addr (exit code %d)", ret.ExitCode)
+				}
+
+				w, err := address.NewFromBytes(ret.Return)
+				if err != nil {
+					return xerrors.Errorf("GetWorkerAddr returned malformed address: %w", err)
+				}
+				t, err := gen.ComputeVRF(ctx, api.WalletSign, w, addr, gen.DSepTicket, vrfBase)
+				if err != nil {
+					return xerrors.Errorf("compute vrf failed: %w", err)
+				}
+				ticket = &types.Ticket{
+					VRFProof: t,
+				}
+
+			}
+
+			epostp := &types.EPostProof{
+				Proof: []byte("valid proof"),
+				Candidates: []types.EPostTicket{
+					{
+						ChallengeIndex: 0,
+						SectorID:       1,
+					},
+				},
+			}
+
+			{
+				r, err := api.ChainGetRandomness(ctx, head.Key(), int64(head.Height()+1)-build.EcRandomnessLookback)
+				if err != nil {
+					return xerrors.Errorf("chain get randomness: %w", err)
+				}
+				mworker, err := api.StateMinerWorker(ctx, addr, head)
+				if err != nil {
+					return xerrors.Errorf("failed to get miner worker: %w", err)
+				}
+
+				vrfout, err := gen.ComputeVRF(ctx, api.WalletSign, mworker, addr, gen.DSepElectionPost, r)
+				if err != nil {
+					return xerrors.Errorf("failed to compute VRF: %w", err)
+				}
+				epostp.PostRand = vrfout
+			}
+
+			uts := head.MinTimestamp() + uint64(build.BlockDelay)
+			nheight := head.Height() + 1
+			blk, err := api.MinerCreateBlock(ctx, addr, head, ticket, epostp, msgs, nheight, uts)
+			if err != nil {
+				return xerrors.Errorf("creating block: %w", err)
+			}
+
+			return api.SyncSubmitBlock(ctx, blk)
+		},
+	}
+}

cmd/lotus/main.go

@@ -14,12 +14,18 @@ import (
 	"github.com/filecoin-project/lotus/tracing"
 )
 
+var AdvanceBlockCmd *cli.Command
+
 func main() {
 	lotuslog.SetupLogLevels()
 
 	local := []*cli.Command{
 		DaemonCmd,
 	}
+	if AdvanceBlockCmd != nil {
+		local = append(local, AdvanceBlockCmd)
+	}
+
 	jaeger := tracing.SetupJaegerTracing("lotus")
 	defer func() {
 		if jaeger != nil {

storage/sealing/utils.go

@@ -50,7 +50,7 @@ func fillersFromRem(toFill uint64) ([]uint64, error) {
 func (m *Sealing) fastPledgeCommitment(size uint64, parts uint64) (commP [sectorbuilder.CommLen]byte, err error) {
 	parts = 1 << bits.Len64(parts) // round down to nearest power of 2
 
-	piece := sectorbuilder.UserBytesForSectorSize(size / parts)
+	piece := sectorbuilder.UserBytesForSectorSize((size + size / 127) / parts)
 	out := make([]sectorbuilder.PublicPieceInfo, parts)
 	var lk sync.Mutex
 

storage/sealing/utils_test.go

@@ -49,7 +49,7 @@ func TestFastPledge(t *testing.T) {
 	sz := uint64(16 << 20)
 
 	s := Sealing{sb: sbmock.NewMockSectorBuilder(0, sz)}
-	if _, err := s.fastPledgeCommitment(sz, 5); err != nil {
+	if _, err := s.fastPledgeCommitment(sectorbuilder.UserBytesForSectorSize(sz), 5); err != nil {
 		t.Fatalf("%+v", err)
 	}
 }