Wire up miner control addresses, use for post

api/types.go

@@ -52,6 +52,7 @@ type MinerInfo struct {
 	Owner                      address.Address // Must be an ID-address.
 	Worker                     address.Address // Must be an ID-address.
 	NewWorker                  address.Address // Must be an ID-address.
+	ControlAddresses           []address.Address // Must be an ID-addresses.
 	WorkerChangeEpoch          abi.ChainEpoch
 	PeerId                     *peer.ID
 	Multiaddrs                 []abi.Multiaddrs
@@ -67,10 +68,13 @@ func NewApiMinerInfo(info *miner.MinerInfo) MinerInfo {
 	}
 
 	mi := MinerInfo{
-		Owner:                      info.Owner,
+		Owner:            info.Owner,
-		Worker:                     info.Worker,
+		Worker:           info.Worker,
-		NewWorker:                  address.Undef,
+		ControlAddresses: info.ControlAddresses,
-		WorkerChangeEpoch:          -1,
+
+		NewWorker:         address.Undef,
+		WorkerChangeEpoch: -1,
+
 		PeerId:                     pid,
 		Multiaddrs:                 info.Multiaddrs,
 		SealProofType:              info.SealProofType,

cli/state.go

@@ -105,6 +105,9 @@ var stateMinerInfo = &cli.Command{
 
 		fmt.Printf("Owner:\t%s\n", mi.Owner)
 		fmt.Printf("Worker:\t%s\n", mi.Worker)
+		for i, controlAddress := range mi.ControlAddresses {
+			fmt.Printf("Control %d: \t%s\n", i, controlAddress)
+		}
 		fmt.Printf("PeerID:\t%s\n", mi.PeerId)
 		fmt.Printf("SectorSize:\t%s (%d)\n", types.SizeStr(types.NewInt(uint64(mi.SectorSize))), mi.SectorSize)
 		fmt.Printf("Multiaddrs: \t")

cmd/lotus-storage-miner/actor.go

@@ -2,19 +2,26 @@ package main
 
 import (
 	"fmt"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"os"
-	"github.com/libp2p/go-libp2p-core/peer"
+	"strings"
-	"golang.org/x/xerrors"
 
+	"github.com/fatih/color"
+	"github.com/libp2p/go-libp2p-core/peer"
 	ma "github.com/multiformats/go-multiaddr"
 	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
 
+	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/filecoin-project/lotus/lib/tablewriter"
+	"github.com/filecoin-project/lotus/storage"
 )
 
 var actorCmd = &cli.Command{
@@ -24,6 +31,7 @@ var actorCmd = &cli.Command{
 		actorSetAddrsCmd,
 		actorWithdrawCmd,
 		actorSetPeeridCmd,
+		actorControl,
 	},
 }
 
@@ -240,3 +248,232 @@ var actorWithdrawCmd = &cli.Command{
 		return nil
 	},
 }
+
+var actorControl = &cli.Command{
+	Name:      "control",
+	Usage:     "Manage control addresses",
+	Subcommands: []*cli.Command{
+		actorControlList,
+		actorControlSet,
+	},
+}
+
+var actorControlList = &cli.Command{
+	Name:      "list",
+	Usage:     "Get currently set control addresses",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name: "verbose",
+		},
+		&cli.BoolFlag{
+			Name: "color",
+			Value: true,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		color.NoColor = !cctx.Bool("color")
+
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		api, acloser, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer acloser()
+
+		ctx := lcli.ReqContext(cctx)
+
+		maddr, err := nodeApi.ActorAddress(ctx)
+		if err != nil {
+			return err
+		}
+
+		mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		tw := tablewriter.New(
+			tablewriter.Col("name"),
+			tablewriter.Col("ID"),
+			tablewriter.Col("key"),
+			tablewriter.Col("use"),
+			tablewriter.Col("balance"),
+		)
+
+		postAddr, err := storage.AddressFor(ctx, api, mi, storage.PoStAddr, types.FromFil(1))
+		if err != nil {
+			return xerrors.Errorf("getting address for post: %w", err)
+		}
+
+		printKey := func(name string, a address.Address) {
+			b, err := api.WalletBalance(ctx, a)
+			if err != nil {
+				fmt.Printf("%s\t%s: error getting balance: %s\n", name, a, err)
+				return
+			}
+
+			k, err := api.StateAccountKey(ctx, a, types.EmptyTSK)
+			if err != nil {
+				fmt.Printf("%s\t%s: error getting account key: %s\n", name, a, err)
+				return
+			}
+
+			kstr := k.String()
+			if !cctx.Bool("verbose") {
+				kstr = kstr[:9] + "..."
+			}
+
+			bstr := types.FIL(b).String()
+			switch {
+			case b.LessThan(types.FromFil(10)):
+				bstr = color.RedString(bstr)
+			case b.LessThan(types.FromFil(50)):
+				bstr = color.YellowString(bstr)
+			default:
+				bstr = color.GreenString(bstr)
+			}
+
+			var uses []string
+			if a == mi.Worker {
+				uses = append(uses, color.YellowString("other"))
+			}
+			if a == postAddr {
+				uses = append(uses, color.GreenString("post"))
+			}
+
+			tw.Write(map[string]interface{}{
+				"name": name,
+				"ID": a,
+				"key": kstr,
+				"use": strings.Join(uses, " "),
+				"balance": bstr,
+			})
+		}
+
+		printKey("owner", mi.Owner)
+		printKey("worker", mi.Worker)
+		for i, ca := range mi.ControlAddresses {
+			printKey(fmt.Sprintf("control-%d", i), ca)
+		}
+
+		return tw.Flush(os.Stdout)
+	},
+}
+
+var actorControlSet = &cli.Command{
+	Name:      "set",
+	Usage:     "Set control address(-es)",
+	ArgsUsage: "[...address]",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name: "really-do-it",
+			Usage: "Actually send transaction performing the action",
+			Value: false,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		api, acloser, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer acloser()
+
+		ctx := lcli.ReqContext(cctx)
+
+		maddr, err := nodeApi.ActorAddress(ctx)
+		if err != nil {
+			return err
+		}
+
+		mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		del := map[address.Address]struct{}{}
+		existing := map[address.Address]struct{}{}
+		for _, controlAddress := range mi.ControlAddresses {
+			ka, err := api.StateAccountKey(ctx, controlAddress, types.EmptyTSK)
+			if err != nil {
+				return err
+			}
+
+			del[ka] = struct{}{}
+			existing[ka] = struct{}{}
+		}
+
+		var toSet []address.Address
+
+		for i, as := range cctx.Args().Slice() {
+			a, err := address.NewFromString(as)
+			if err != nil {
+				return xerrors.Errorf("parsing address %d: %w", i, err)
+			}
+
+			ka, err := api.StateAccountKey(ctx, a, types.EmptyTSK)
+			if err != nil {
+				return err
+			}
+
+			// make sure the address exists on chain
+			_, err = api.StateLookupID(ctx, ka, types.EmptyTSK)
+			if err != nil {
+				return xerrors.Errorf("looking up %s: %w", ka, err)
+			}
+
+			delete(del, ka)
+			toSet = append(toSet, ka)
+		}
+
+		for a := range del {
+			fmt.Println("Remove", a)
+		}
+		for _, a := range toSet {
+			if _, exists := existing[a]; !exists {
+				fmt.Println("Add", a)
+			}
+		}
+
+		if !cctx.Bool("really-do-it") {
+			fmt.Println("Pass --really-do-it to actually execute this action")
+			return nil
+		}
+
+		cwp := &miner.ChangeWorkerAddressParams{
+			NewWorker:       mi.Worker,
+			NewControlAddrs: toSet,
+		}
+
+		sp, err := actors.SerializeParams(cwp)
+		if err != nil {
+			return xerrors.Errorf("serializing params: %w", err)
+		}
+
+		smsg, err := api.MpoolPushMessage(ctx, &types.Message{
+			From: mi.Owner,
+			To: maddr,
+			Method: builtin.MethodsMiner.ChangeWorkerAddress,
+
+			Value: big.Zero(),
+			Params: sp,
+		}, nil)
+		if err != nil {
+			return xerrors.Errorf("mpool push: %w", err)
+		}
+
+		fmt.Println("Message CID:", smsg.Cid())
+
+		return nil
+	},
+}

storage/addresses.go

@@ -0,0 +1,92 @@
+package storage
+
+import (
+	"context"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+type AddrUse int
+
+const (
+	PreCommitAddr AddrUse = iota
+	CommitAddr
+	PoStAddr
+)
+
+type addrSelectApi interface {
+	WalletBalance(context.Context, address.Address) (types.BigInt, error)
+	WalletHas(context.Context, address.Address) (bool, error)
+
+	StateAccountKey(context.Context, address.Address, types.TipSetKey) (address.Address, error)
+}
+
+func AddressFor(ctx context.Context, a addrSelectApi, mi api.MinerInfo, use AddrUse, minFunds abi.TokenAmount) (address.Address, error) {
+	switch use {
+	case PreCommitAddr, CommitAddr:
+		// always use worker, at least for now
+		return mi.Worker, nil
+	}
+
+	for _, addr := range mi.ControlAddresses {
+		b, err := a.WalletBalance(ctx, addr)
+		if err != nil {
+			return address.Undef, xerrors.Errorf("checking control address balance: %w", err)
+		}
+
+		if b.GreaterThanEqual(minFunds) {
+			k, err := a.StateAccountKey(ctx, addr, types.EmptyTSK)
+			if err != nil {
+				log.Errorw("getting account key", "error", err)
+				continue
+			}
+
+			have, err := a.WalletHas(ctx, k)
+			if err != nil {
+				return address.Undef, xerrors.Errorf("failed to check control address: %w", err)
+			}
+
+			if !have {
+				log.Errorw("don't have key", "key", k)
+				continue
+			}
+
+			return addr, nil
+		}
+
+		log.Warnw("control address didn't have enough funds for PoSt message", "address", addr, "required", types.FIL(minFunds), "balance", types.FIL(b))
+	}
+
+	// Try to use the owner account if we can, fallback to worker if we can't
+
+	b, err := a.WalletBalance(ctx, mi.Owner)
+	if err != nil {
+		return address.Undef, xerrors.Errorf("checking owner balance: %w", err)
+	}
+
+	if !b.GreaterThanEqual(minFunds) {
+		return mi.Worker, nil
+	}
+
+	k, err := a.StateAccountKey(ctx, mi.Owner, types.EmptyTSK)
+	if err != nil {
+		log.Errorw("getting owner account key", "error", err)
+		return mi.Worker, nil
+	}
+
+	have, err := a.WalletHas(ctx, k)
+	if err != nil {
+		return address.Undef, xerrors.Errorf("failed to check owner address: %w", err)
+	}
+
+	if !have {
+		return mi.Worker, nil
+	}
+
+	return mi.Owner, nil
+}

storage/miner.go

@@ -67,6 +67,7 @@ type storageMinerApi interface {
 	StateMarketStorageDeal(context.Context, abi.DealID, types.TipSetKey) (*api.MarketDeal, error)
 	StateMinerFaults(context.Context, address.Address, types.TipSetKey) (abi.BitField, error)
 	StateMinerRecoveries(context.Context, address.Address, types.TipSetKey) (abi.BitField, error)
+	StateAccountKey(context.Context, address.Address, types.TipSetKey) (address.Address, error)
 
 	MpoolPushMessage(context.Context, *types.Message, *api.MessageSendSpec) (*types.SignedMessage, error)
 

storage/wdpost_run.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"errors"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
 	"time"
 
 	"github.com/filecoin-project/go-bitfield"
@@ -172,11 +173,11 @@ func (s *WindowPoStScheduler) checkNextRecoveries(ctx context.Context, dlIdx uin
 
 	msg := &types.Message{
 		To:     s.actor,
-		From:   s.worker,
 		Method: builtin.MethodsMiner.DeclareFaultsRecovered,
 		Params: enc,
 		Value:  types.NewInt(0),
 	}
+	s.setSender(ctx, msg)
 
 	sm, err := s.api.MpoolPushMessage(ctx, msg, &api.MessageSendSpec{MaxFee: abi.TokenAmount(s.feeCfg.MaxWindowPoStGasFee)})
 	if err != nil {
@@ -254,11 +255,11 @@ func (s *WindowPoStScheduler) checkNextFaults(ctx context.Context, dlIdx uint64,
 
 	msg := &types.Message{
 		To:     s.actor,
-		From:   s.worker,
 		Method: builtin.MethodsMiner.DeclareFaults,
 		Params: enc,
 		Value:  types.NewInt(0), // TODO: Is there a fee?
 	}
+	s.setSender(ctx, msg)
 
 	sm, err := s.api.MpoolPushMessage(ctx, msg, &api.MessageSendSpec{MaxFee: abi.TokenAmount(s.feeCfg.MaxWindowPoStGasFee)})
 	if err != nil {
@@ -460,11 +461,11 @@ func (s *WindowPoStScheduler) submitPost(ctx context.Context, proof *miner.Submi
 
 	msg := &types.Message{
 		To:     s.actor,
-		From:   s.worker,
 		Method: builtin.MethodsMiner.SubmitWindowedPoSt,
 		Params: enc,
 		Value:  types.NewInt(1000), // currently hard-coded late fee in actor, returned if not late
 	}
+	s.setSender(ctx, msg)
 
 	// TODO: consider maybe caring about the output
 	sm, err := s.api.MpoolPushMessage(ctx, msg, &api.MessageSendSpec{MaxFee: abi.TokenAmount(s.feeCfg.MaxWindowPoStGasFee)})
@@ -490,3 +491,25 @@ func (s *WindowPoStScheduler) submitPost(ctx context.Context, proof *miner.Submi
 
 	return nil
 }
+
+func (s *WindowPoStScheduler) setSender(ctx context.Context, msg *types.Message) {
+	mi, err := s.api.StateMinerInfo(ctx, s.actor, types.EmptyTSK)
+	if err != nil {
+		log.Errorw("error getting miner info", "error", err)
+
+		// better than just failing
+		msg.From = s.worker
+		return
+	}
+
+	minFunds := big.Add(msg.RequiredFunds(), msg.Value)
+
+	pa, err := AddressFor(ctx, s.api, mi, PoStAddr, minFunds)
+	if err != nil {
+		log.Errorw("error selecting address for post", "error", err)
+		msg.From = s.worker
+		return
+	}
+
+	msg.From = pa
+}