feat: ExpectedRewardForPower builtin utility function

And `lotus-shed miner expected-reward` CLI command

Ref: #13137

Author: rvagg

chain/actors/builtin/miner/actor.go.template

@@ -12,7 +12,7 @@ import (
 	gstbuiltin "github.com/filecoin-project/go-state-types/builtin"
 	minertypes13 "github.com/filecoin-project/go-state-types/builtin/v13/miner"
 {{- range .versions}}
-	{{- if (ge . 16)}}
+	{{- if (ge . 13)}}
 		minertypes{{.}} "github.com/filecoin-project/go-state-types/builtin/v{{.}}/miner"
 		smoothing{{.}} "github.com/filecoin-project/go-state-types/builtin/v{{.}}/util/smoothing"
 	{{- end -}}
@@ -403,4 +403,38 @@ func PledgePenaltyForTermination(
     default:
         return big.Zero(), xerrors.Errorf("unsupported network version: %d", nwVer)
     }
+}
+
+func ExpectedRewardForPower(
+	nwVer network.Version,
+	rewardEstimate, networkQAPowerEstimate builtin.FilterEstimate,
+	qaSectorPower abi.StoragePower,
+	projectionDuration abi.ChainEpoch,
+) (abi.TokenAmount, error) {
+	v, err := actorstypes.VersionForNetwork(nwVer)
+	if err != nil {
+		return big.Zero(), err
+	}
+
+	switch v {
+	{{- range .versions}}
+		{{- if (ge . 13)}}
+	case actorstypes.Version{{.}}:
+		return minertypes{{.}}.ExpectedRewardForPower(
+			smoothing{{.}}.FilterEstimate{
+				PositionEstimate: rewardEstimate.PositionEstimate,
+				VelocityEstimate: rewardEstimate.VelocityEstimate,
+			},
+			smoothing{{.}}.FilterEstimate{
+				PositionEstimate: networkQAPowerEstimate.PositionEstimate,
+				VelocityEstimate: networkQAPowerEstimate.VelocityEstimate,
+			},
+			qaSectorPower,
+			projectionDuration,
+		), nil
+		{{- end}}
+	{{- end}}
+	default:
+		return big.Zero(), xerrors.Errorf("unsupported network version: %d", nwVer)
+	}
 }

chain/actors/builtin/miner/miner.go

@@ -11,6 +11,11 @@ import (
 	"github.com/filecoin-project/go-state-types/big"
 	gstbuiltin "github.com/filecoin-project/go-state-types/builtin"
 	minertypes13 "github.com/filecoin-project/go-state-types/builtin/v13/miner"
+	smoothing13 "github.com/filecoin-project/go-state-types/builtin/v13/util/smoothing"
+	minertypes14 "github.com/filecoin-project/go-state-types/builtin/v14/miner"
+	smoothing14 "github.com/filecoin-project/go-state-types/builtin/v14/util/smoothing"
+	minertypes15 "github.com/filecoin-project/go-state-types/builtin/v15/miner"
+	smoothing15 "github.com/filecoin-project/go-state-types/builtin/v15/util/smoothing"
 	minertypes16 "github.com/filecoin-project/go-state-types/builtin/v16/miner"
 	smoothing16 "github.com/filecoin-project/go-state-types/builtin/v16/util/smoothing"
 	minertypes "github.com/filecoin-project/go-state-types/builtin/v9/miner"
@@ -479,3 +484,72 @@ func PledgePenaltyForTermination(
 		return big.Zero(), xerrors.Errorf("unsupported network version: %d", nwVer)
 	}
 }
+
+func ExpectedRewardForPower(
+	nwVer network.Version,
+	rewardEstimate, networkQAPowerEstimate builtin.FilterEstimate,
+	qaSectorPower abi.StoragePower,
+	projectionDuration abi.ChainEpoch,
+) (abi.TokenAmount, error) {
+	v, err := actorstypes.VersionForNetwork(nwVer)
+	if err != nil {
+		return big.Zero(), err
+	}
+
+	switch v {
+	case actorstypes.Version13:
+		return minertypes13.ExpectedRewardForPower(
+			smoothing13.FilterEstimate{
+				PositionEstimate: rewardEstimate.PositionEstimate,
+				VelocityEstimate: rewardEstimate.VelocityEstimate,
+			},
+			smoothing13.FilterEstimate{
+				PositionEstimate: networkQAPowerEstimate.PositionEstimate,
+				VelocityEstimate: networkQAPowerEstimate.VelocityEstimate,
+			},
+			qaSectorPower,
+			projectionDuration,
+		), nil
+	case actorstypes.Version14:
+		return minertypes14.ExpectedRewardForPower(
+			smoothing14.FilterEstimate{
+				PositionEstimate: rewardEstimate.PositionEstimate,
+				VelocityEstimate: rewardEstimate.VelocityEstimate,
+			},
+			smoothing14.FilterEstimate{
+				PositionEstimate: networkQAPowerEstimate.PositionEstimate,
+				VelocityEstimate: networkQAPowerEstimate.VelocityEstimate,
+			},
+			qaSectorPower,
+			projectionDuration,
+		), nil
+	case actorstypes.Version15:
+		return minertypes15.ExpectedRewardForPower(
+			smoothing15.FilterEstimate{
+				PositionEstimate: rewardEstimate.PositionEstimate,
+				VelocityEstimate: rewardEstimate.VelocityEstimate,
+			},
+			smoothing15.FilterEstimate{
+				PositionEstimate: networkQAPowerEstimate.PositionEstimate,
+				VelocityEstimate: networkQAPowerEstimate.VelocityEstimate,
+			},
+			qaSectorPower,
+			projectionDuration,
+		), nil
+	case actorstypes.Version16:
+		return minertypes16.ExpectedRewardForPower(
+			smoothing16.FilterEstimate{
+				PositionEstimate: rewardEstimate.PositionEstimate,
+				VelocityEstimate: rewardEstimate.VelocityEstimate,
+			},
+			smoothing16.FilterEstimate{
+				PositionEstimate: networkQAPowerEstimate.PositionEstimate,
+				VelocityEstimate: networkQAPowerEstimate.VelocityEstimate,
+			},
+			qaSectorPower,
+			projectionDuration,
+		), nil
+	default:
+		return big.Zero(), xerrors.Errorf("unsupported network version: %d", nwVer)
+	}
+}

cmd/lotus-shed/miner-fees.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"fmt"
 	"sort"
+	"strconv"
 
 	cbor "github.com/ipfs/go-ipld-cbor"
 	"github.com/urfave/cli/v2"
@@ -21,6 +22,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	minertypes "github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
 	"github.com/filecoin-project/lotus/lib/must"
@@ -607,3 +609,87 @@ var minerFeesInspect = &cli.Command{
 		return nil
 	},
 }
+
+var minerExpectedRewardCmd = &cli.Command{
+	Name:  "expected-reward",
+	Usage: " [--tipset <tipset>] [qapower]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "tipset",
+			Usage: "tipset or height (@X or @head for latest)",
+			Value: "@head",
+		},
+		&cli.IntFlag{
+			Name:  "projection-period",
+			Usage: "number of epochs to project reward for",
+			Value: builtin.EpochsInDay,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetFullNodeAPIV1(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := lcli.ReqContext(cctx)
+		bstore := blockstore.NewAPIBlockstore(api)
+		adtStore := adt.WrapStore(ctx, cbor.NewCborStore(bstore))
+
+		ts, err := lcli.LoadTipSet(ctx, cctx, api)
+		if err != nil {
+			return err
+		}
+
+		if cctx.Args().Len() != 1 {
+			return xerrors.Errorf("must provide qapower")
+		}
+
+		projectionPeriod := abi.ChainEpoch(cctx.Int64("projection-period"))
+
+		powerInt, err := strconv.ParseUint(cctx.Args().Get(0), 10, 64)
+		if err != nil {
+			return xerrors.Errorf("parsing qapower: %w", err)
+		}
+		qapower := abi.NewStoragePower(int64(powerInt))
+
+		// Get the reward value for the current tipset from the reward actor
+		var rewardSmoothed builtin.FilterEstimate
+		if act, err := api.StateGetActor(ctx, reward.Address, ts.Key()); err != nil {
+			return xerrors.Errorf("loading reward actor: %w", err)
+		} else if s, err := reward.Load(adtStore, act); err != nil {
+			return xerrors.Errorf("loading reward actor state: %w", err)
+		} else if rewardSmoothed, err = s.ThisEpochRewardSmoothed(); err != nil {
+			return xerrors.Errorf("failed to determine smoothed reward: %w", err)
+		}
+
+		// Get the network power value for the current tipset from the power actor
+		var powerSmoothed builtin.FilterEstimate
+		if act, err := api.StateGetActor(ctx, power.Address, ts.Key()); err != nil {
+			return xerrors.Errorf("loading power actor: %w", err)
+		} else if s, err := power.Load(adtStore, act); err != nil {
+			return xerrors.Errorf("loading power actor state: %w", err)
+		} else if powerSmoothed, err = s.TotalPowerSmoothed(); err != nil {
+			return xerrors.Errorf("failed to determine total power: %w", err)
+		}
+
+		nv, err := api.StateNetworkVersion(ctx, ts.Key())
+		if err != nil {
+			return xerrors.Errorf("getting network version: %w", err)
+		}
+
+		rew, err := minertypes.ExpectedRewardForPower(nv, rewardSmoothed, powerSmoothed, qapower, projectionPeriod)
+		if err != nil {
+			return xerrors.Errorf("calculating expected reward: %w", err)
+		}
+		_, _ = fmt.Fprintf(
+			cctx.App.Writer,
+			"Expected reward for %s bytes of QA power @ epoch %d for %d epochs: %s attoFIL\n",
+			qapower,
+			ts.Height(),
+			projectionPeriod,
+			rew,
+		)
+		return nil
+	},
+}

cmd/lotus-shed/miner.go

@@ -60,6 +60,7 @@ var minerCmd = &cli.Command{
 		minerFeesCmd,
 		minerFeesInspect,
 		minerListBalancesCmd,
+		minerExpectedRewardCmd,
 	},
 }