Add sepolia support.

CHANGELOG.md

@@ -1,6 +1,18 @@
-dev:
+1.24.1:
+  - fix potential crash when new validators are activated
+  - add "sepolia" to the list of supported networks
+
+1.24.0:
+  - add "validator yield"
+
+1.23.1:
+  - do not fetch future state for chain eth1votes
+
+1.23.0:
   - do not fetch sync committee information for epoch summaries prior to Altair
   - ensure that "attester inclusion" without validator returns appropriate error
+  - provide more information in "epoch summary" with verbose flag
+  - add "chain eth1votes"
 
 1.22.0:
   - add "ropsten" to the list of supported networks

cmd/chain/eth1votes/command.go

@@ -0,0 +1,87 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package chaineth1votes
+
+import (
+	"context"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/services/chaintime"
+)
+
+type command struct {
+	quiet   bool
+	verbose bool
+	debug   bool
+	json    bool
+
+	// Beacon node connection.
+	timeout                  time.Duration
+	connection               string
+	allowInsecureConnections bool
+
+	// Input.
+	xepoch  string
+	xperiod string
+
+	// Data access.
+	eth2Client                eth2client.Service
+	chainTime                 chaintime.Service
+	beaconStateProvider       eth2client.BeaconStateProvider
+	slotsPerEpoch             uint64
+	epochsPerEth1VotingPeriod uint64
+
+	// Output.
+	slot          phase0.Slot
+	epoch         phase0.Epoch
+	period        uint64
+	incumbent     *phase0.ETH1Data
+	eth1DataVotes []*phase0.ETH1Data
+	votes         map[string]*vote
+}
+
+type vote struct {
+	Vote  *phase0.ETH1Data `json:"vote"`
+	Count int              `json:"count"`
+}
+
+func newCommand(ctx context.Context) (*command, error) {
+	c := &command{
+		quiet:   viper.GetBool("quiet"),
+		verbose: viper.GetBool("verbose"),
+		debug:   viper.GetBool("debug"),
+		json:    viper.GetBool("json"),
+	}
+
+	// Timeout.
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	c.timeout = viper.GetDuration("timeout")
+
+	c.xepoch = viper.GetString("epoch")
+	c.xperiod = viper.GetString("period")
+
+	if viper.GetString("connection") == "" {
+		return nil, errors.New("connection is required")
+	}
+	c.connection = viper.GetString("connection")
+	c.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
+
+	return c, nil
+}

cmd/chain/eth1votes/command_internal_test.go

@@ -0,0 +1,72 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package chaineth1votes
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestInput(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{},
+			err:  "timeout is required",
+		},
+		{
+			name: "ConnectionMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"data":    "{}",
+			},
+			err: "connection is required",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			_, err := newCommand(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/chain/eth1votes/output.go

@@ -0,0 +1,125 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package chaineth1votes
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"sort"
+	"strings"
+
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+)
+
+type jsonOutput struct {
+	Period    uint64           `json:"period"`
+	Epoch     phase0.Epoch     `json:"epoch"`
+	Slot      phase0.Slot      `json:"slot"`
+	Incumbent *phase0.ETH1Data `json:"incumbent"`
+	Votes     []*vote          `json:"votes"`
+}
+
+func (c *command) output(ctx context.Context) (string, error) {
+	if c.quiet {
+		return "", nil
+	}
+
+	if c.json {
+		return c.outputJSON(ctx)
+	}
+	return c.outputText(ctx)
+}
+
+func (c *command) outputJSON(ctx context.Context) (string, error) {
+	votes := make([]*vote, 0, len(c.votes))
+	totalVotes := 0
+	for _, vote := range c.votes {
+		votes = append(votes, vote)
+		totalVotes += vote.Count
+	}
+	sort.Slice(votes, func(i int, j int) bool {
+		if votes[i].Count != votes[j].Count {
+			return votes[i].Count > votes[j].Count
+		}
+		return votes[i].Vote.DepositCount < votes[j].Vote.DepositCount
+	})
+
+	output := &jsonOutput{
+		Period:    c.period,
+		Epoch:     c.epoch,
+		Slot:      c.slot,
+		Incumbent: c.incumbent,
+		Votes:     votes,
+	}
+	data, err := json.Marshal(output)
+	if err != nil {
+		return "", err
+	}
+
+	return string(data), nil
+}
+
+func (c *command) outputText(ctx context.Context) (string, error) {
+	builder := strings.Builder{}
+
+	builder.WriteString("Voting period: ")
+	builder.WriteString(fmt.Sprintf("%d\n", c.period))
+
+	if c.verbose {
+		builder.WriteString("Incumbent: ")
+		builder.WriteString(fmt.Sprintf("block %#x, deposit count %d\n", c.incumbent.BlockHash, c.incumbent.DepositCount))
+	}
+
+	votes := make([]*vote, 0, len(c.votes))
+	totalVotes := 0
+	for _, vote := range c.votes {
+		votes = append(votes, vote)
+		totalVotes += vote.Count
+	}
+	sort.Slice(votes, func(i int, j int) bool {
+		if votes[i].Count != votes[j].Count {
+			return votes[i].Count > votes[j].Count
+		}
+		return votes[i].Vote.DepositCount < votes[j].Vote.DepositCount
+	})
+
+	slot := c.chainTime.CurrentSlot()
+	if slot > c.slot {
+		slot = c.slot
+	}
+
+	slotsThroughPeriod := slot + 1 - phase0.Slot(c.period*(c.slotsPerEpoch*c.epochsPerEth1VotingPeriod))
+	builder.WriteString("Slots through period: ")
+	builder.WriteString(fmt.Sprintf("%d (%d)\n", slotsThroughPeriod, c.slot))
+
+	builder.WriteString("Votes this period: ")
+	builder.WriteString(fmt.Sprintf("%d\n", totalVotes))
+
+	if len(votes) > 0 {
+		if c.verbose {
+			for _, vote := range votes {
+				builder.WriteString(fmt.Sprintf("  block %#x, deposit count %d: %d vote", vote.Vote.BlockHash, vote.Vote.DepositCount, vote.Count))
+				if vote.Count != 1 {
+					builder.WriteString("s")
+				}
+				builder.WriteString(fmt.Sprintf(" (%0.2f%%)\n", 100.0*float64(vote.Count)/float64(slotsThroughPeriod)))
+			}
+		} else {
+			builder.WriteString(fmt.Sprintf("Leading vote is for block %#x with %d votes (%0.2f%%)\n", votes[0].Vote.BlockHash, votes[0].Count, 100.0*float64(votes[0].Count)/float64(slotsThroughPeriod)))
+		}
+	}
+
+	return strings.TrimSuffix(builder.String(), "\n"), nil
+}

cmd/chain/eth1votes/process.go

@@ -0,0 +1,161 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package chaineth1votes
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strconv"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/spec"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
+	"github.com/wealdtech/ethdo/util"
+)
+
+func (c *command) process(ctx context.Context) error {
+	// Obtain information we need to process.
+	if err := c.setup(ctx); err != nil {
+		return err
+	}
+
+	var err error
+	if c.xperiod != "" {
+		period, err := strconv.ParseUint(c.xperiod, 10, 64)
+		if err != nil {
+			return err
+		}
+		c.epoch = phase0.Epoch(c.epochsPerEth1VotingPeriod*(period+1)) - 1
+	} else {
+		c.epoch, err = util.ParseEpoch(ctx, c.chainTime, c.xepoch)
+		if err != nil {
+			return err
+		}
+	}
+
+	// Do not fetch from the future.
+	if c.epoch > c.chainTime.CurrentEpoch() {
+		c.epoch = c.chainTime.CurrentEpoch()
+	}
+
+	// Need to fetch the state from the last slot of the epoch.
+	fetchSlot := c.chainTime.FirstSlotOfEpoch(c.epoch+1) - 1
+	// Do not fetch from the future.
+	if fetchSlot > c.chainTime.CurrentSlot() {
+		fetchSlot = c.chainTime.CurrentSlot()
+	}
+	state, err := c.beaconStateProvider.BeaconState(ctx, fmt.Sprintf("%d", fetchSlot))
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain state")
+	}
+	if state == nil {
+		return errors.New("state not returned by beacon node")
+	}
+
+	if c.debug {
+		data, err := json.Marshal(state)
+		if err == nil {
+			fmt.Printf("%s\n", string(data))
+		}
+	}
+
+	switch state.Version {
+	case spec.DataVersionPhase0:
+		c.slot = phase0.Slot(state.Phase0.Slot)
+		c.incumbent = state.Phase0.ETH1Data
+		c.eth1DataVotes = state.Phase0.ETH1DataVotes
+	case spec.DataVersionAltair:
+		c.slot = phase0.Slot(state.Altair.Slot)
+		c.incumbent = state.Altair.ETH1Data
+		c.eth1DataVotes = state.Altair.ETH1DataVotes
+	case spec.DataVersionBellatrix:
+		c.slot = phase0.Slot(state.Bellatrix.Slot)
+		c.incumbent = state.Bellatrix.ETH1Data
+		c.eth1DataVotes = state.Bellatrix.ETH1DataVotes
+	default:
+		return fmt.Errorf("unhandled beacon state version %v", state.Version)
+	}
+
+	c.period = uint64(c.epoch) / c.epochsPerEth1VotingPeriod
+
+	c.votes = make(map[string]*vote)
+	for _, eth1Vote := range c.eth1DataVotes {
+		key := fmt.Sprintf("%#x:%d", eth1Vote.BlockHash, eth1Vote.DepositCount)
+		if _, exists := c.votes[key]; !exists {
+			c.votes[key] = &vote{
+				Vote: eth1Vote,
+			}
+		}
+		c.votes[key].Count++
+	}
+
+	return nil
+}
+
+func (c *command) setup(ctx context.Context) error {
+	var err error
+
+	// Connect to the client.
+	c.eth2Client, err = util.ConnectToBeaconNode(ctx, c.connection, c.timeout, c.allowInsecureConnections)
+	if err != nil {
+		return errors.Wrap(err, "failed to connect to beacon node")
+	}
+
+	c.chainTime, err = standardchaintime.New(ctx,
+		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
+		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+	)
+	if err != nil {
+		return errors.Wrap(err, "failed to set up chaintime service")
+	}
+
+	var isProvider bool
+	c.beaconStateProvider, isProvider = c.eth2Client.(eth2client.BeaconStateProvider)
+	if !isProvider {
+		return errors.New("connection does not provide beacon state")
+	}
+	specProvider, isProvider := c.eth2Client.(eth2client.SpecProvider)
+	if !isProvider {
+		return errors.New("connection does not provide spec information")
+	}
+
+	spec, err := specProvider.Spec(ctx)
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain spec")
+	}
+
+	tmp, exists := spec["SLOTS_PER_EPOCH"]
+	if !exists {
+		return errors.New("spec did not contain SLOTS_PER_EPOCH")
+	}
+	var good bool
+	c.slotsPerEpoch, good = tmp.(uint64)
+	if !good {
+		return errors.New("SLOTS_PER_EPOCH value invalid")
+	}
+	tmp, exists = spec["EPOCHS_PER_ETH1_VOTING_PERIOD"]
+	if !exists {
+		return errors.New("spec did not contain EPOCHS_PER_ETH1_VOTING_PERIOD")
+	}
+	c.epochsPerEth1VotingPeriod, good = tmp.(uint64)
+	if !good {
+		return errors.New("EPOCHS_PER_ETH1_VOTING_PERIOD value invalid")
+	}
+
+	return nil
+}

cmd/chain/eth1votes/process_internal_test.go

@@ -0,0 +1,66 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package chaineth1votes
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/rs/zerolog"
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestProcess(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	zerolog.SetGlobalLevel(zerolog.Disabled)
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		err  string
+	}{
+		{
+			name: "InvalidEpoch",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"epoch":      "invalid",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+			err: "failed to parse epoch: strconv.ParseInt: parsing \"invalid\": invalid syntax",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			cmd, err := newCommand(context.Background())
+			require.NoError(t, err)
+			err = cmd.process(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/chain/eth1votes/run.go

@@ -0,0 +1,50 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package chaineth1votes
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+
+	c, err := newCommand(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to set up command")
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	if err := c.process(ctx); err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := c.output(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/chaineth1votes.go

@@ -0,0 +1,67 @@
+// Copyright © 2022 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	chaineth1votes "github.com/wealdtech/ethdo/cmd/chain/eth1votes"
+)
+
+var chainEth1VotesCmd = &cobra.Command{
+	Use:   "eth1votes",
+	Short: "Show chain execution votes",
+	Long: `Show beacon chain execution votes.  For example:
+
+    ethdo chain eth1votes
+
+Note that this will fetch the votes made in blocks up to the end of the provided epoch.
+
+In quiet mode this will return 0 if there is a majority for the votes, otherwise 1.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := chaineth1votes.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	chainCmd.AddCommand(chainEth1VotesCmd)
+	chainFlags(chainEth1VotesCmd)
+	chainEth1VotesCmd.Flags().String("epoch", "", "epoch for which to fetch the votes")
+	chainEth1VotesCmd.Flags().String("period", "", "period for which to fetch the votes")
+	chainEth1VotesCmd.Flags().Bool("json", false, "output data in JSON format")
+}
+
+func chainEth1VotesBindings() {
+	if err := viper.BindPFlag("epoch", chainEth1VotesCmd.Flags().Lookup("epoch")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("period", chainEth1VotesCmd.Flags().Lookup("period")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("json", chainEth1VotesCmd.Flags().Lookup("json")); err != nil {
+		panic(err)
+	}
+}

cmd/epoch/summary/command.go

@@ -40,22 +40,27 @@ type command struct {
 	jsonOutput bool
 
 	// Data access.
-	eth2Client             eth2client.Service
-	chainTime              chaintime.Service
-	proposerDutiesProvider eth2client.ProposerDutiesProvider
-	blocksProvider         eth2client.SignedBeaconBlockProvider
-	syncCommitteesProvider eth2client.SyncCommitteesProvider
+	eth2Client               eth2client.Service
+	chainTime                chaintime.Service
+	proposerDutiesProvider   eth2client.ProposerDutiesProvider
+	blocksProvider           eth2client.SignedBeaconBlockProvider
+	syncCommitteesProvider   eth2client.SyncCommitteesProvider
+	validatorsProvider       eth2client.ValidatorsProvider
+	beaconCommitteesProvider eth2client.BeaconCommitteesProvider
 
 	// Results.
 	summary *epochSummary
 }
 
 type epochSummary struct {
-	Epoch         phase0.Epoch          `json:"epoch"`
-	FirstSlot     phase0.Slot           `json:"first_slot"`
-	LastSlot      phase0.Slot           `json:"last_slot"`
-	Proposals     []*epochProposal      `json:"proposals"`
-	SyncCommittee []*epochSyncCommittee `json:"sync_committees"`
+	Epoch                      phase0.Epoch                 `json:"epoch"`
+	FirstSlot                  phase0.Slot                  `json:"first_slot"`
+	LastSlot                   phase0.Slot                  `json:"last_slot"`
+	Proposals                  []*epochProposal             `json:"proposals"`
+	SyncCommittee              []*epochSyncCommittee        `json:"sync_committees"`
+	ActiveValidators           int                          `json:"active_validators"`
+	ParticipatingValidators    int                          `json:"participating_validators"`
+	NonParticipatingValidators []*nonParticipatingValidator `json:"nonparticipating_validators"`
 }
 
 type epochProposal struct {
@@ -69,6 +74,12 @@ type epochSyncCommittee struct {
 	Missed int                   `json:"missed"`
 }
 
+type nonParticipatingValidator struct {
+	Validator phase0.ValidatorIndex `json:"validator_index"`
+	Slot      phase0.Slot           `json:"slot"`
+	Committee phase0.CommitteeIndex `json:"committee_index"`
+}
+
 func newCommand(ctx context.Context) (*command, error) {
 	c := &command{
 		quiet:   viper.GetBool("quiet"),

cmd/epoch/summary/output.go

@@ -47,58 +47,56 @@ func (c *command) outputTxt(_ context.Context) (string, error) {
 	builder.WriteString(fmt.Sprintf("%d:\n", c.summary.Epoch))
 
 	proposedBlocks := 0
+	missedProposals := make([]string, 0, len(c.summary.Proposals))
+	for _, proposal := range c.summary.Proposals {
+		if !proposal.Block {
+			missedProposals = append(missedProposals, fmt.Sprintf("\n    Slot %d (validator %d)", proposal.Slot, proposal.Proposer))
+		} else {
+			proposedBlocks++
+		}
+	}
+	builder.WriteString(fmt.Sprintf("  Proposals: %d/%d (%0.2f%%)", proposedBlocks, len(missedProposals)+proposedBlocks, 100.0*float64(proposedBlocks)/float64(len(missedProposals)+proposedBlocks)))
 	if c.verbose {
 		for _, proposal := range c.summary.Proposals {
-			builder.WriteString("  Slot ")
-			builder.WriteString(fmt.Sprintf("%d (%d/%d):\n", proposal.Slot, uint64(proposal.Slot)%uint64(len(c.summary.Proposals)), len(c.summary.Proposals)))
-			builder.WriteString("    Proposer: ")
-			builder.WriteString(fmt.Sprintf("%d\n", proposal.Proposer))
-			builder.WriteString("    Proposed: ")
 			if proposal.Block {
-				proposedBlocks++
-				builder.WriteString("✓\n")
-			} else {
-				builder.WriteString("✕\n")
-			}
-		}
-	} else {
-		missedProposals := make([]string, 0, len(c.summary.Proposals))
-		for _, proposal := range c.summary.Proposals {
-			if !proposal.Block {
-				missedProposals = append(missedProposals, fmt.Sprintf("    Slot %d (validator %d)\n", proposal.Slot, proposal.Proposer))
-			} else {
-				proposedBlocks++
-			}
-		}
-		if len(missedProposals) > 0 {
-			builder.WriteString("  Missed proposals:\n")
-			for _, missedProposal := range missedProposals {
-				builder.WriteString(missedProposal)
+				continue
 			}
+			builder.WriteString("\n    Slot ")
+			builder.WriteString(fmt.Sprintf("%d (%d/%d)", proposal.Slot, uint64(proposal.Slot)%uint64(len(c.summary.Proposals)), len(c.summary.Proposals)))
+			builder.WriteString(" validator ")
+			builder.WriteString(fmt.Sprintf("%d", proposal.Proposer))
+			builder.WriteString(" not proposed or not included")
 		}
 	}
 
+	builder.WriteString(fmt.Sprintf("\n  Attestations: %d/%d (%0.2f%%)", c.summary.ParticipatingValidators, c.summary.ActiveValidators, 100.0*float64(c.summary.ParticipatingValidators)/float64(c.summary.ActiveValidators)))
 	if c.verbose {
-		for _, syncCommittee := range c.summary.SyncCommittee {
-			builder.WriteString("  Sync committee validator ")
-			builder.WriteString(fmt.Sprintf("%d:\n", syncCommittee.Index))
-			builder.WriteString("    Chances: ")
-			builder.WriteString(fmt.Sprintf("%d\n", proposedBlocks))
-			builder.WriteString("    Included: ")
-			builder.WriteString(fmt.Sprintf("%d\n", proposedBlocks-syncCommittee.Missed))
-			builder.WriteString("    Inclusion %: ")
-			builder.WriteString(fmt.Sprintf("%0.2f\n", 100.0*float64(proposedBlocks-syncCommittee.Missed)/float64(proposedBlocks)))
+		// Sort list by validator index.
+		for _, validator := range c.summary.NonParticipatingValidators {
+			builder.WriteString("\n    Slot ")
+			builder.WriteString(fmt.Sprintf("%d", validator.Slot))
+			builder.WriteString(" committee ")
+			builder.WriteString(fmt.Sprintf("%d", validator.Committee))
+			builder.WriteString(" validator ")
+			builder.WriteString(fmt.Sprintf("%d", validator.Validator))
+			builder.WriteString(" failed to participate")
 		}
-	} else {
-		missedSyncCommittees := make([]string, 0, len(c.summary.SyncCommittee))
-		for _, syncCommittee := range c.summary.SyncCommittee {
-			missedPct := 100.0 * float64(syncCommittee.Missed) / float64(proposedBlocks)
-			missedSyncCommittees = append(missedSyncCommittees, fmt.Sprintf("    %d (%0.2f%%) by validator %d\n", syncCommittee.Missed, missedPct, syncCommittee.Index))
+	}
+
+	if c.summary.Epoch >= c.chainTime.AltairInitialEpoch() {
+		contributions := proposedBlocks * 512 // SYNC_COMMITTEE_SIZE
+		totalMissed := 0
+		for _, contribution := range c.summary.SyncCommittee {
+			totalMissed += contribution.Missed
 		}
-		if len(missedSyncCommittees) > 0 {
-			builder.WriteString("  Missed sync committees (excluding missed blocks):\n")
-			for _, missedSyncCommittee := range missedSyncCommittees {
-				builder.WriteString(missedSyncCommittee)
+		builder.WriteString(fmt.Sprintf("\n  Sync committees: %d/%d (%0.2f%%)", contributions-totalMissed, contributions, 100.0*float64(contributions-totalMissed)/float64(contributions)))
+		if c.verbose {
+			for _, syncCommittee := range c.summary.SyncCommittee {
+				builder.WriteString("\n    Validator ")
+				builder.WriteString(fmt.Sprintf("%d", syncCommittee.Index))
+				builder.WriteString(" included ")
+				builder.WriteString(fmt.Sprintf("%d/%d", proposedBlocks-syncCommittee.Missed, proposedBlocks))
+				builder.WriteString(fmt.Sprintf(" (%0.2f%%)", 100.0*float64(proposedBlocks-syncCommittee.Missed)/float64(proposedBlocks)))
 			}
 		}
 	}

cmd/epoch/summary/process.go

@@ -16,8 +16,10 @@ package epochsummary
 import (
 	"context"
 	"fmt"
+	"sort"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
 	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/altair"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
@@ -79,7 +81,99 @@ func (c *command) processProposerDuties(ctx context.Context) error {
 
 func (c *command) processAttesterDuties(ctx context.Context) error {
 	// Obtain all active validators for the given epoch.
-	// Do in future.
+	validators, err := c.validatorsProvider.Validators(ctx, fmt.Sprintf("%d", c.chainTime.FirstSlotOfEpoch(c.summary.Epoch)), nil)
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain validators for epoch")
+	}
+	activeValidators := make(map[phase0.ValidatorIndex]*apiv1.Validator)
+	for _, validator := range validators {
+		if validator.Validator.ActivationEpoch <= c.summary.Epoch && validator.Validator.ExitEpoch > c.summary.Epoch {
+			activeValidators[validator.Index] = validator
+		}
+	}
+
+	// Obtain number of validators that voted for blocks in the epoch.
+	// These votes can be included anywhere from the second slot of
+	// the epoch to the first slot of the next-but-one epoch.
+	firstSlot := c.chainTime.FirstSlotOfEpoch(c.summary.Epoch) + 1
+	lastSlot := c.chainTime.FirstSlotOfEpoch(c.summary.Epoch + 2)
+	if lastSlot > c.chainTime.CurrentSlot() {
+		lastSlot = c.chainTime.CurrentSlot()
+	}
+
+	votes := make(map[phase0.ValidatorIndex]struct{})
+	allCommittees := make(map[phase0.Slot]map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
+	participations := make(map[phase0.ValidatorIndex]*nonParticipatingValidator)
+
+	for slot := firstSlot; slot <= lastSlot; slot++ {
+		block, err := c.blocksProvider.SignedBeaconBlock(ctx, fmt.Sprintf("%d", slot))
+		if err != nil {
+			return errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", slot))
+		}
+		if block == nil {
+			// No block at this slot; that's fine.
+			continue
+		}
+		attestations, err := block.Attestations()
+		if err != nil {
+			return err
+		}
+		for _, attestation := range attestations {
+			if attestation.Data.Slot < c.chainTime.FirstSlotOfEpoch(c.summary.Epoch) || attestation.Data.Slot >= c.chainTime.FirstSlotOfEpoch(c.summary.Epoch+1) {
+				// Outside of this epoch's range.
+				continue
+			}
+			slotCommittees, exists := allCommittees[attestation.Data.Slot]
+			if !exists {
+				beaconCommittees, err := c.beaconCommitteesProvider.BeaconCommittees(ctx, fmt.Sprintf("%d", attestation.Data.Slot))
+				if err != nil {
+					return errors.Wrap(err, fmt.Sprintf("failed to obtain committees for slot %d", attestation.Data.Slot))
+				}
+				for _, beaconCommittee := range beaconCommittees {
+					if _, exists := allCommittees[beaconCommittee.Slot]; !exists {
+						allCommittees[beaconCommittee.Slot] = make(map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
+					}
+					allCommittees[beaconCommittee.Slot][beaconCommittee.Index] = beaconCommittee.Validators
+					for _, index := range beaconCommittee.Validators {
+						participations[index] = &nonParticipatingValidator{
+							Validator: index,
+							Slot:      beaconCommittee.Slot,
+							Committee: beaconCommittee.Index,
+						}
+
+					}
+				}
+				slotCommittees = allCommittees[attestation.Data.Slot]
+			}
+			committee := slotCommittees[attestation.Data.Index]
+			for i := uint64(0); i < attestation.AggregationBits.Len(); i++ {
+				if attestation.AggregationBits.BitAt(i) {
+					votes[committee[int(i)]] = struct{}{}
+				}
+			}
+		}
+	}
+
+	c.summary.ActiveValidators = len(activeValidators)
+	c.summary.ParticipatingValidators = len(votes)
+	c.summary.NonParticipatingValidators = make([]*nonParticipatingValidator, 0, len(activeValidators)-len(votes))
+	for activeValidatorIndex := range activeValidators {
+		if _, exists := votes[activeValidatorIndex]; !exists {
+			if _, exists := participations[activeValidatorIndex]; exists {
+				c.summary.NonParticipatingValidators = append(c.summary.NonParticipatingValidators, participations[activeValidatorIndex])
+			}
+		}
+	}
+	sort.Slice(c.summary.NonParticipatingValidators, func(i int, j int) bool {
+		if c.summary.NonParticipatingValidators[i].Slot != c.summary.NonParticipatingValidators[j].Slot {
+			return c.summary.NonParticipatingValidators[i].Slot < c.summary.NonParticipatingValidators[j].Slot
+		}
+		if c.summary.NonParticipatingValidators[i].Committee != c.summary.NonParticipatingValidators[j].Committee {
+			return c.summary.NonParticipatingValidators[i].Committee < c.summary.NonParticipatingValidators[j].Committee
+		}
+		return c.summary.NonParticipatingValidators[i].Validator < c.summary.NonParticipatingValidators[j].Validator
+	})
+
 	return nil
 }
 
@@ -140,6 +234,16 @@ func (c *command) processSyncCommitteeDuties(ctx context.Context) error {
 		}
 	}
 
+	sort.Slice(c.summary.SyncCommittee, func(i int, j int) bool {
+		missedDiff := c.summary.SyncCommittee[i].Missed - c.summary.SyncCommittee[j].Missed
+		if missedDiff != 0 {
+			// Actually want to order by missed descending, so invert the expected condition.
+			return missedDiff > 0
+		}
+		// Then order by validator index.
+		return c.summary.SyncCommittee[i].Index < c.summary.SyncCommittee[j].Index
+	})
+
 	return nil
 }
 
@@ -174,6 +278,14 @@ func (c *command) setup(ctx context.Context) error {
 	if !isProvider {
 		return errors.New("connection does not provide sync committee duties")
 	}
+	c.validatorsProvider, isProvider = c.eth2Client.(eth2client.ValidatorsProvider)
+	if !isProvider {
+		return errors.New("connection does not provide validators")
+	}
+	c.beaconCommitteesProvider, isProvider = c.eth2Client.(eth2client.BeaconCommitteesProvider)
+	if !isProvider {
+		return errors.New("connection does not provide beacon committees")
+	}
 
 	return nil
 }

cmd/root.go

@@ -93,6 +93,8 @@ func includeCommandBindings(cmd *cobra.Command) {
 		blockAnalyzeBindings()
 	case "block/info":
 		blockInfoBindings()
+	case "chain/eth1votes":
+		chainEth1VotesBindings()
 	case "chain/queues":
 		chainQueuesBindings()
 	case "chain/time":
@@ -123,6 +125,8 @@ func includeCommandBindings(cmd *cobra.Command) {
 		validatorInfoBindings()
 	case "validator/keycheck":
 		validatorKeycheckBindings()
+	case "validator/yield":
+		validatorYieldBindings()
 	case "validator/expectation":
 		validatorExpectationBindings()
 	case "wallet/create":

cmd/validator/depositdata/output.go

@@ -111,6 +111,7 @@ func validatorDepositDataOutputLaunchpad(datum *dataOut) (string, error) {
 		[4]byte{0x00, 0x00, 0x20, 0x09}: "pyrmont",
 		[4]byte{0x00, 0x00, 0x10, 0x20}: "prater",
 		[4]byte{0x80, 0x00, 0x00, 0x69}: "ropsten",
+		[4]byte{0x90, 0x00, 0x00, 0x69}: "sepolia",
 	}
 
 	if datum.validatorPubKey == nil {

cmd/validator/yield/command.go

@@ -0,0 +1,84 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package validatoryield
+
+import (
+	"context"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/pkg/errors"
+	"github.com/shopspring/decimal"
+	"github.com/spf13/viper"
+)
+
+type command struct {
+	quiet   bool
+	verbose bool
+	debug   bool
+	json    bool
+
+	// Beacon node connection.
+	timeout                  time.Duration
+	connection               string
+	allowInsecureConnections bool
+
+	// Input.
+	validators string
+
+	// Data access.
+	eth2Client eth2client.Service
+
+	// Output.
+	results *output
+}
+
+type output struct {
+	BaseReward                       decimal.Decimal `json:"base_reward"`
+	ActiveValidators                 decimal.Decimal `json:"active_validators"`
+	ActiveValidatorBalance           decimal.Decimal `json:"active_validator_balance"`
+	ValidatorRewardsPerEpoch         decimal.Decimal `json:"validator_rewards_per_epoch"`
+	ValidatorRewardsPerYear          decimal.Decimal `json:"validator_rewards_per_year"`
+	ValidatorRewardsAllCorrect       decimal.Decimal `json:"validator_rewards_all_correct"`
+	ExpectedValidatorRewardsPerEpoch decimal.Decimal `json:"expected_validator_rewards_per_epoch"`
+	MaxIssuancePerEpoch              decimal.Decimal `json:"max_issuance_per_epoch"`
+	MaxIssuancePerYear               decimal.Decimal `json:"max_issuance_per_year"`
+	Yield                            decimal.Decimal `json:"yield"`
+}
+
+func newCommand(ctx context.Context) (*command, error) {
+	c := &command{
+		quiet:   viper.GetBool("quiet"),
+		verbose: viper.GetBool("verbose"),
+		debug:   viper.GetBool("debug"),
+		json:    viper.GetBool("json"),
+		results: &output{},
+	}
+
+	// Timeout.
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	c.timeout = viper.GetDuration("timeout")
+
+	if viper.GetString("connection") == "" {
+		return nil, errors.New("connection is required")
+	}
+	c.connection = viper.GetString("connection")
+	c.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
+
+	c.validators = viper.GetString("validators")
+
+	return c, nil
+}

cmd/validator/yield/command_internal_test.go

@@ -0,0 +1,73 @@
+// Copyright © 2021 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package validatoryield
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestInput(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{},
+			err:  "timeout is required",
+		},
+		{
+			name: "ConnectionMissing",
+			vars: map[string]interface{}{
+				"validators": "1",
+				"timeout":    "5s",
+			},
+			err: "connection is required",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"validators": "1",
+				"timeout":    "5s",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			_, err := newCommand(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/validator/yield/output.go

@@ -0,0 +1,67 @@
+// Copyright © 2021 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package validatoryield
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+
+	"github.com/shopspring/decimal"
+	"github.com/wealdtech/go-string2eth"
+)
+
+func (c *command) output(ctx context.Context) (string, error) {
+	if c.quiet {
+		return "", nil
+	}
+
+	if c.json {
+		data, err := json.Marshal(c.results)
+		if err != nil {
+			return "", err
+		}
+		return string(data), nil
+	}
+
+	builder := strings.Builder{}
+
+	if c.verbose {
+		builder.WriteString("Per-validator rewards per epoch: ")
+		builder.WriteString(string2eth.WeiToGWeiString(c.results.ValidatorRewardsPerEpoch.BigInt()))
+		builder.WriteString("\n")
+
+		builder.WriteString("Per-validator rewards per year: ")
+		builder.WriteString(string2eth.WeiToString(c.results.ValidatorRewardsPerYear.BigInt(), true))
+		builder.WriteString("\n")
+
+		builder.WriteString("Expected per-validator rewards per epoch (with full participation): ")
+		builder.WriteString(string2eth.WeiToGWeiString(c.results.ExpectedValidatorRewardsPerEpoch.BigInt()))
+		builder.WriteString("\n")
+
+		builder.WriteString("Maximum chain issuance per epoch: ")
+		builder.WriteString(string2eth.WeiToString(c.results.MaxIssuancePerEpoch.BigInt(), true))
+		builder.WriteString("\n")
+
+		builder.WriteString("Maximum chain issuance per year: ")
+		builder.WriteString(string2eth.WeiToString(c.results.MaxIssuancePerYear.BigInt(), true))
+		builder.WriteString("\n")
+	}
+
+	builder.WriteString("Yield: ")
+	builder.WriteString(c.results.Yield.Mul(decimal.New(100, 0)).StringFixed(2))
+	builder.WriteString("%\n")
+
+	return builder.String(), nil
+}

cmd/validator/yield/process.go

@@ -0,0 +1,170 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package validatoryield
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"strconv"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/pkg/errors"
+	"github.com/shopspring/decimal"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
+	"github.com/wealdtech/ethdo/util"
+)
+
+func (c *command) process(ctx context.Context) error {
+	// Obtain information we need to process.
+	if err := c.setup(ctx); err != nil {
+		return err
+	}
+
+	if c.debug {
+		fmt.Printf("Active validators: %v\n", c.results.ActiveValidators)
+		fmt.Printf("Active validator balance: %v\n", c.results.ActiveValidatorBalance)
+	}
+
+	return c.calculateYield(ctx)
+}
+
+var weiPerGwei = decimal.New(1e9, 0)
+var one = decimal.New(1, 0)
+var epochsPerYear = decimal.New(225*365, 0)
+
+// calculateYield calculates yield from the number of active validators.
+func (c *command) calculateYield(ctx context.Context) error {
+
+	spec, err := c.eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	if err != nil {
+		return err
+	}
+
+	tmp, exists := spec["BASE_REWARD_FACTOR"]
+	if !exists {
+		return errors.New("spec missing BASE_REWARD_FACTOR")
+	}
+	baseReward, isType := tmp.(uint64)
+	if !isType {
+		return errors.New("BASE_REWARD_FACTOR of incorrect type")
+	}
+	if c.debug {
+		fmt.Printf("Base reward: %v\n", baseReward)
+	}
+	c.results.BaseReward = decimal.New(int64(baseReward), 0)
+
+	numerator := decimal.New(32, 0).Mul(weiPerGwei).Mul(c.results.BaseReward)
+	if c.debug {
+		fmt.Printf("Numerator: %v\n", numerator)
+	}
+	activeValidatorsBalanceInGwei := c.results.ActiveValidatorBalance.Div(weiPerGwei)
+	denominator := decimal.NewFromBigInt(new(big.Int).Sqrt(activeValidatorsBalanceInGwei.BigInt()), 0)
+	if c.debug {
+		fmt.Printf("Denominator: %v\n", denominator)
+	}
+	c.results.ValidatorRewardsPerEpoch = numerator.Div(denominator).RoundDown(0).Mul(weiPerGwei)
+	if c.debug {
+		fmt.Printf("Validator rewards per epoch: %v\n", c.results.ValidatorRewardsPerEpoch)
+	}
+	c.results.ValidatorRewardsPerYear = c.results.ValidatorRewardsPerEpoch.Mul(epochsPerYear)
+	if c.debug {
+		fmt.Printf("Validator rewards per year: %v\n", c.results.ValidatorRewardsPerYear)
+	}
+	// Expected validator rewards assume that there is no proposal and no sync committee participation,
+	// but that head/source/target are correct and timely: this gives 54/64 of the reward.
+	// These values are obtained from https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/beacon-chain.md#incentivization-weights
+	c.results.ExpectedValidatorRewardsPerEpoch = c.results.ValidatorRewardsPerEpoch.Mul(decimal.New(54, 0)).Div(decimal.New(64, 0)).Div(weiPerGwei).RoundDown(0).Mul(weiPerGwei)
+	if c.debug {
+		fmt.Printf("Expected validator rewards per epoch: %v\n", c.results.ExpectedValidatorRewardsPerEpoch)
+	}
+
+	c.results.MaxIssuancePerEpoch = c.results.ValidatorRewardsPerEpoch.Mul(c.results.ActiveValidators)
+	if c.debug {
+		fmt.Printf("Chain rewards per epoch: %v\n", c.results.MaxIssuancePerEpoch)
+	}
+	c.results.MaxIssuancePerYear = c.results.MaxIssuancePerEpoch.Mul(epochsPerYear)
+	if c.debug {
+		fmt.Printf("Chain rewards per year: %v\n", c.results.MaxIssuancePerYear)
+	}
+
+	c.results.Yield = c.results.ValidatorRewardsPerYear.Div(weiPerGwei).Div(weiPerGwei).Div(decimal.New(32, 0))
+	if c.debug {
+		fmt.Printf("Yield: %v\n", c.results.Yield)
+	}
+
+	return nil
+}
+
+func (c *command) setup(ctx context.Context) error {
+	var err error
+
+	// Connect to the client.
+	c.eth2Client, err = util.ConnectToBeaconNode(ctx, c.connection, c.timeout, c.allowInsecureConnections)
+	if err != nil {
+		return errors.Wrap(err, "failed to connect to beacon node")
+	}
+
+	if c.validators == "" {
+		chainTime, err := standardchaintime.New(ctx,
+			standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
+			standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
+			standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+		)
+		if err != nil {
+			return errors.Wrap(err, "failed to set up chaintime service")
+		}
+
+		// Obtain the number of active validators.
+		var isProvider bool
+		validatorsProvider, isProvider := c.eth2Client.(eth2client.ValidatorsProvider)
+		if !isProvider {
+			return errors.New("connection does not provide validator information")
+		}
+
+		validators, err := validatorsProvider.Validators(ctx, "head", nil)
+		if err != nil {
+			return errors.Wrap(err, "failed to obtain validators")
+		}
+
+		currentEpoch := chainTime.CurrentEpoch()
+		activeValidators := decimal.Zero
+		activeValidatorBalance := decimal.Zero
+		for _, validator := range validators {
+			if validator.Validator.ActivationEpoch <= currentEpoch &&
+				validator.Validator.ExitEpoch > currentEpoch {
+				activeValidators = activeValidators.Add(one)
+				activeValidatorBalance = activeValidatorBalance.Add(decimal.NewFromInt(int64(validator.Validator.EffectiveBalance)))
+			}
+		}
+		c.results.ActiveValidators = activeValidators
+		c.results.ActiveValidatorBalance = activeValidatorBalance.Mul(weiPerGwei)
+	} else {
+		activeValidators, err := strconv.ParseInt(c.validators, 0, 64)
+		if err != nil {
+			return errors.Wrap(err, "failed to parse number of validators")
+		}
+		if activeValidators <= 0 {
+			return errors.New("number of validators must be greater than 0")
+		}
+
+		c.results.ActiveValidators = decimal.New(activeValidators, 0)
+		c.results.ActiveValidatorBalance = decimal.New(32, 0).Mul(c.results.ActiveValidators).Mul(weiPerGwei).Mul(weiPerGwei)
+		if c.debug {
+			fmt.Println("Assuming 32Ξ per validator")
+		}
+	}
+
+	return nil
+}

cmd/validator/yield/process_internal_test.go

@@ -0,0 +1,90 @@
+// Copyright © 2021 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package validatoryield
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestProcess(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		err  string
+	}{
+		{
+			name: "InvalidData",
+			vars: map[string]interface{}{
+				"timeout":    "60s",
+				"validators": "1",
+				"data":       "[[",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+		},
+		{
+			name: "ValidatorsInvalid",
+			vars: map[string]interface{}{
+				"timeout":    "60s",
+				"validators": "invalid",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+			err: "failed to parse number of validators: strconv.ParseInt: parsing \"invalid\": invalid syntax",
+		},
+		{
+			name: "ValidatorsNegative",
+			vars: map[string]interface{}{
+				"timeout":    "60s",
+				"validators": "-1",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+			err: "number of validators must be greater than 0",
+		},
+		{
+			name: "ValidatorsZero",
+			vars: map[string]interface{}{
+				"timeout":    "60s",
+				"validators": "0",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+			err: "number of validators must be greater than 0",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			cmd, err := newCommand(context.Background())
+			require.NoError(t, err)
+			err = cmd.process(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/validator/yield/run.go

@@ -0,0 +1,50 @@
+// Copyright © 2021 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package validatoryield
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+
+	c, err := newCommand(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to set up command")
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	if err := c.process(ctx); err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := c.output(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/validatorcredentials.go

@@ -20,8 +20,8 @@ import (
 // validatorCredentialsCmd represents the validator credentials command
 var validatorCredentialsCmd = &cobra.Command{
 	Use:   "credentials",
-	Short: "Manage Ethereum consensu validator credentials",
-	Long:  `Manage Ethereum consensu validator credentials.`,
+	Short: "Manage Ethereum consensus validator credentials",
+	Long:  `Manage Ethereum consensus validator credentials.`,
 }
 
 func init() {

cmd/validatorinfo.go

@@ -91,9 +91,14 @@ In quiet mode this will return 0 if the validator information can be obtained, o
 			os.Exit(_exitSuccess)
 		}
 
+		if validator.Status.IsPending() || validator.Status.HasActivated() {
+			fmt.Printf("Index: %d\n", validator.Index)
+		}
 		if verbose {
+			if validator.Status.IsPending() {
+				fmt.Printf("Activation eligibility epoch: %d\n", validator.Validator.ActivationEligibilityEpoch)
+			}
 			if validator.Status.HasActivated() {
-				fmt.Printf("Index: %d\n", validator.Index)
 				fmt.Printf("Activation epoch: %d\n", validator.Validator.ActivationEpoch)
 			}
 			fmt.Printf("Public key: %#x\n", validator.Validator.PublicKey)

cmd/validatoryield.go

@@ -0,0 +1,61 @@
+// Copyright © 2022 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	validatoryield "github.com/wealdtech/ethdo/cmd/validator/yield"
+)
+
+var validatorYieldCmd = &cobra.Command{
+	Use:   "yield",
+	Short: "Calculate yield for validators",
+	Long: `Calculate yield for validators.  For example:
+
+    ethdo validator yield
+
+It is important to understand the yield is both probabilistic and dependent on network conditions.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := validatoryield.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		res = strings.TrimRight(res, "\n")
+		fmt.Println(res)
+		return nil
+	},
+}
+
+func init() {
+	validatorCmd.AddCommand(validatorYieldCmd)
+	validatorFlags(validatorYieldCmd)
+	validatorYieldCmd.Flags().String("validators", "", "Number of active validators (default fetches from chain)")
+	validatorYieldCmd.Flags().Bool("json", false, "JSON output")
+}
+
+func validatorYieldBindings() {
+	if err := viper.BindPFlag("validators", validatorYieldCmd.Flags().Lookup("validators")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("json", validatorYieldCmd.Flags().Lookup("json")); err != nil {
+		panic(err)
+	}
+}

cmd/version.go

@@ -24,7 +24,7 @@ import (
 
 // ReleaseVersion is the release version of the codebase.
 // Usually overridden by tag names when building binaries.
-var ReleaseVersion = "local build (latest release 1.22.1)"
+var ReleaseVersion = "local build (latest release 1.24.1)"
 
 // versionCmd represents the version command
 var versionCmd = &cobra.Command{

docs/usage.md

@@ -337,6 +337,22 @@ Voluntary exits: 0
 
 Chain commands focus on providing information about Ethereum 2 chains.
 
+#### `eth1votes`
+
+`ethdo chain eth1votes` obtains information about the votes for the next Ethereum 1 block to be incorporated in to the chain for deposits.  Options include:
+  - `epoch` show the votes at the end of the given epoch
+  - `json` provide JSON output
+
+```sh
+$ ethdo chain eth1votes
+Voting period: 6
+Slots through period: 1000
+Votes this period: 959
+Leading vote is for block 0x0ae5716ac1906592dbfb243ccadf90191f706d6f8c925b4f2712d2e24687553a with 356 votes
+```
+
+Additional information is supplied when using `--verbose`
+
 #### `info`
 
 `ethdo chain info` obtains information about an Ethereum 2 chain.
@@ -682,6 +698,17 @@ $ ethdo attester inclusion --account=Validators/1 --epoch=6484
 Attestation included in block 207492 (inclusion delay 1)
 ```
 
+#### `yield`
+
+`ethdo validator yield` calculates the expected yield given the number of validators.  Options include:
+  - `validators` use a specified number of validators rather than the current number of active validators
+  - `json` obtain detailed information in JSON format
+
+```sh
+$ ethdo validator yield
+Yield: 4.64%
+```
+
 ## Maintainers
 
 Jim McDonald: [@mcdee](https://github.com/mcdee).

go.mod

@@ -22,6 +22,7 @@ require (
 	github.com/prysmaticlabs/go-bitfield v0.0.0-20210809151128-385d8c5e3fb7
 	github.com/prysmaticlabs/go-ssz v0.0.0-20210121151755-f6208871c388
 	github.com/rs/zerolog v1.26.1
+	github.com/shopspring/decimal v1.3.1
 	github.com/spf13/afero v1.8.0 // indirect
 	github.com/spf13/cobra v1.3.0
 	github.com/spf13/pflag v1.0.5
@@ -42,7 +43,7 @@ require (
 	github.com/wealdtech/go-eth2-wallet-store-s3 v1.10.0
 	github.com/wealdtech/go-eth2-wallet-store-scratch v1.7.0
 	github.com/wealdtech/go-eth2-wallet-types/v2 v2.9.0
-	github.com/wealdtech/go-string2eth v1.1.0
+	github.com/wealdtech/go-string2eth v1.2.0
 	golang.org/x/crypto v0.0.0-20220128200615-198e4374d7ed // indirect
 	golang.org/x/text v0.3.7
 	google.golang.org/genproto v0.0.0-20220126215142-9970aeb2e350 // indirect

go.sum

@@ -75,8 +75,6 @@ github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgI
 github.com/attestantio/dirk v1.1.0 h1:hwMTYZkwj/Y0um3OD0LQxg2xSl4/5xqVWV2MRePE4ec=
 github.com/attestantio/dirk v1.1.0/go.mod h1:2jkOw/XHjvIDdhDcmj+Z3kuVPpxMcQ6zxzzjSSv71PY=
 github.com/attestantio/go-eth2-client v0.8.1/go.mod h1:kEK9iAAOBoADO5wEkd84FEOzjT1zXgVWveQsqn+uBGg=
-github.com/attestantio/go-eth2-client v0.10.0 h1:nmOmzErfz4I2gEkucHKOaFwkbwD4i6JbIX38Z8Dm4Tc=
-github.com/attestantio/go-eth2-client v0.10.0/go.mod h1:ijuXoXJCBFMexUYaBOl8PXfZKwYUFJy7cV03TMdw8Bo=
 github.com/attestantio/go-eth2-client v0.11.0 h1:8/Jn5AAfd+4tOggLi+FvOv9/ORaObECv42ab7vK2FJc=
 github.com/attestantio/go-eth2-client v0.11.0/go.mod h1:zXL/BxC0cBBhxj+tP7QG7t9Ufoa8GwQLdlbvZRd9+dM=
 github.com/aws/aws-sdk-go v1.33.17/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
@@ -354,7 +352,6 @@ github.com/klauspost/compress v1.13.6 h1:P76CopJELS0TiO2mebmnzgWaajssP/EszplttgQ
 github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
 github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/klauspost/cpuid/v2 v2.0.6/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
-github.com/klauspost/cpuid/v2 v2.0.9 h1:lgaqFMSdTdQYdZ04uHyN2d/eKdOMyi2YLSvlQIBFYa4=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/klauspost/cpuid/v2 v2.0.11 h1:i2lw1Pm7Yi/4O6XCSyJWqEHI2MDw2FzUK6o/D21xn2A=
 github.com/klauspost/cpuid/v2 v2.0.11/go.mod h1:g2LTdtYhdyuGPqyWyv7qRAmj1WBqxuObKfj5c0PQa7c=
@@ -495,6 +492,8 @@ github.com/sagikazarmark/crypt v0.4.0/go.mod h1:ALv2SRj7GxYV4HO9elxH9nS6M9gW+xDN
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
 github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0 h1:Xuk8ma/ibJ1fOy4Ee11vHhUFHQNpHhrBneOCNHVXS5w=
 github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0/go.mod h1:7AwjWCpdPhkSmNAgUv5C7EJ4AbmjEB3r047r3DXWu3Y=
+github.com/shopspring/decimal v1.3.1 h1:2Usl1nmF/WZucqkFZhnfFYxxxu8LG21F6nPQBE5gKV8=
+github.com/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
 github.com/sirupsen/logrus v1.6.0 h1:UBcNElsrwanuuMsnGSlYmtmgbb23qDR5dG+6X6Oo89I=
@@ -589,6 +588,8 @@ github.com/wealdtech/go-indexer v1.0.0/go.mod h1:u1cjsbsOXsm5jzJDyLmZY7GsrdX8KYX
 github.com/wealdtech/go-majordomo v1.0.1/go.mod h1:QoT4S1nUQwdQK19+CfepDwV+Yr7cc3dbF+6JFdQnIqY=
 github.com/wealdtech/go-string2eth v1.1.0 h1:USJQmysUrBYYmZs7d45pMb90hRSyEwizP7lZaOZLDAw=
 github.com/wealdtech/go-string2eth v1.1.0/go.mod h1:RUzsLjJtbZaJ/3UKn9kY19a/vCCUHtEWoUW3uiK6yGU=
+github.com/wealdtech/go-string2eth v1.2.0 h1:C0E5p78tecZTsGccJc9r/kreFah4EfDs5uUPnS6XXMs=
+github.com/wealdtech/go-string2eth v1.2.0/go.mod h1:RUzsLjJtbZaJ/3UKn9kY19a/vCCUHtEWoUW3uiK6yGU=
 github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
 github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
@@ -843,8 +844,6 @@ golang.org/x/sys v0.0.0-20211205182925-97ca703d548d/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20211210111614-af8b64212486/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27 h1:XDXtA5hveEEV8JB2l7nhMTp3t3cHp9ZpwcdjqyEWLlo=
-golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9 h1:nhht2DYV/Sn3qOayu8lM+cU1ii9sTLUeBQwQQfUHtrs=
 golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=