Merge pull request #6309 from filecoin-project/feat/better_mining_projection_and_accuracy

Adjust various CLI display ratios to arbitrary precision

testplans/lotus-soup/rfwp/chain_state.go

@@ -7,6 +7,8 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"math"
+	corebig "math/big"
 	"os"
 	"sort"
 	"text/tabwriter"
@@ -27,6 +29,7 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
 
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	tstats "github.com/filecoin-project/lotus/tools/stats"
 )
@@ -581,18 +584,24 @@ func (i *MinerInfo) MarshalPlainText() ([]byte, error) {
 	fmt.Fprintf(w, "Sector Size: %s\n", i.SectorSize)
 
 	pow := i.MinerPower
-	rpercI := types.BigDiv(types.BigMul(pow.MinerPower.RawBytePower, types.NewInt(1000000)), pow.TotalPower.RawBytePower)
-	qpercI := types.BigDiv(types.BigMul(pow.MinerPower.QualityAdjPower, types.NewInt(1000000)), pow.TotalPower.QualityAdjPower)
 
 	fmt.Fprintf(w, "Byte Power:   %s / %s (%0.4f%%)\n",
 		types.SizeStr(pow.MinerPower.RawBytePower),
 		types.SizeStr(pow.TotalPower.RawBytePower),
-		float64(rpercI.Int64())/10000)
+		types.BigDivFloat(
+			types.BigMul(pow.MinerPower.RawBytePower, big.NewInt(100)),
+			pow.TotalPower.RawBytePower,
+		),
+	)
 
 	fmt.Fprintf(w, "Actual Power: %s / %s (%0.4f%%)\n",
 		types.DeciStr(pow.MinerPower.QualityAdjPower),
 		types.DeciStr(pow.TotalPower.QualityAdjPower),
-		float64(qpercI.Int64())/10000)
+		types.BigDivFloat(
+			types.BigMul(pow.MinerPower.QualityAdjPower, big.NewInt(100)),
+			pow.TotalPower.QualityAdjPower,
+		),
+	)
 
 	fmt.Fprintf(w, "\tCommitted: %s\n", types.SizeStr(i.CommittedBytes))
 
@@ -608,16 +617,50 @@ func (i *MinerInfo) MarshalPlainText() ([]byte, error) {
 	if !i.MinerPower.HasMinPower {
 		fmt.Fprintf(w, "Below minimum power threshold, no blocks will be won\n")
 	} else {
-		expWinChance := float64(types.BigMul(qpercI, types.NewInt(build.BlocksPerEpoch)).Int64()) / 1000000
-		if expWinChance > 0 {
-			if expWinChance > 1 {
-				expWinChance = 1
-			}
-			winRate := time.Duration(float64(time.Second*time.Duration(build.BlockDelaySecs)) / expWinChance)
-			winPerDay := float64(time.Hour*24) / float64(winRate)
 
-			fmt.Fprintln(w, "Expected block win rate: ")
-			fmt.Fprintf(w, "%.4f/day (every %s)\n", winPerDay, winRate.Truncate(time.Second))
+		winRatio := new(corebig.Rat).SetFrac(
+			types.BigMul(pow.MinerPower.QualityAdjPower, types.NewInt(build.BlocksPerEpoch)).Int,
+			pow.TotalPower.QualityAdjPower.Int,
+		)
+
+		if winRatioFloat, _ := winRatio.Float64(); winRatioFloat > 0 {
+
+			// if the corresponding poisson distribution isn't infinitely small then
+			// throw it into the mix as well, accounting for multi-wins
+			winRationWithPoissonFloat := -math.Expm1(-winRatioFloat)
+			winRationWithPoisson := new(corebig.Rat).SetFloat64(winRationWithPoissonFloat)
+			if winRationWithPoisson != nil {
+				winRatio = winRationWithPoisson
+				winRatioFloat = winRationWithPoissonFloat
+			}
+
+			weekly, _ := new(corebig.Rat).Mul(
+				winRatio,
+				new(corebig.Rat).SetInt64(7*builtin.EpochsInDay),
+			).Float64()
+
+			avgDuration, _ := new(corebig.Rat).Mul(
+				new(corebig.Rat).SetInt64(builtin.EpochDurationSeconds),
+				new(corebig.Rat).Inv(winRatio),
+			).Float64()
+
+			fmt.Fprintf(w, "Projected average block win rate: %.02f/week (every %s)\n",
+				weekly,
+				(time.Second * time.Duration(avgDuration)).Truncate(time.Second).String(),
+			)
+
+			// Geometric distribution of P(Y < k) calculated as described in https://en.wikipedia.org/wiki/Geometric_distribution#Probability_Outcomes_Examples
+			// https://www.wolframalpha.com/input/?i=t+%3E+0%3B+p+%3E+0%3B+p+%3C+1%3B+c+%3E+0%3B+c+%3C1%3B+1-%281-p%29%5E%28t%29%3Dc%3B+solve+t
+			// t == how many dice-rolls (epochs) before win
+			// p == winRate == ( minerPower / netPower )
+			// c == target probability of win ( 99.9% in this case )
+			fmt.Fprintf(w, "Projected block win with 99.9%% probability every %s\n",
+				(time.Second * time.Duration(
+					builtin.EpochDurationSeconds*math.Log(1-0.999)/
+						math.Log(1-winRatioFloat),
+				)).Truncate(time.Second).String(),
+			)
+			fmt.Fprintln(w, "(projections DO NOT account for future network and miner growth)")
 		}
 	}