Update changelog.

CHANGELOG.md

@@ -1,3 +1,9 @@
+1.19.0:
+  - add "epoch summary"
+
+1.18.2:
+  - tidy up output of "block info"
+
 1.18.1:
   - do not show execution payload if empty
 

cmd/block/info/output.go

@@ -77,8 +77,9 @@ func outputBlockGeneral(ctx context.Context,
 		res.WriteString(fmt.Sprintf("State root: %#x\n", stateRoot))
 	}
 	if len(graffiti) > 0 && hex.EncodeToString(graffiti) != "0000000000000000000000000000000000000000000000000000000000000000" {
+		graffiti = bytes.TrimRight(graffiti, "\u0000")
 		if utf8.Valid(graffiti) {
-			res.WriteString(fmt.Sprintf("Graffiti: %s\n", strings.TrimRight(string(graffiti), "\u0000")))
+			res.WriteString(fmt.Sprintf("Graffiti: %s\n", string(graffiti)))
 		} else {
 			res.WriteString(fmt.Sprintf("Graffiti: %#x\n", graffiti))
 		}
@@ -530,14 +531,19 @@ func outputBlockExecutionPayload(ctx context.Context,
 		return "", nil
 	}
 
+	// If the block number is 0 then we're before the merge.
 	if payload.BlockNumber == 0 {
 		return "", nil
 	}
+
 	res := strings.Builder{}
-	res.WriteString("Execution payload:\n")
-	res.WriteString("  Execution block number: ")
-	res.WriteString(fmt.Sprintf("%d\n", payload.BlockNumber))
-	if verbose {
+	if !verbose {
+		res.WriteString("Execution block number: ")
+		res.WriteString(fmt.Sprintf("%d\n", payload.BlockNumber))
+	} else {
+		res.WriteString("Execution payload:\n")
+		res.WriteString("  Execution block number: ")
+		res.WriteString(fmt.Sprintf("%d\n", payload.BlockNumber))
 		baseFeePerGasBEBytes := make([]byte, len(payload.BaseFeePerGas))
 		for i := 0; i < 32; i++ {
 			baseFeePerGasBEBytes[i] = payload.BaseFeePerGas[32-1-i]

cmd/epoch.go

@@ -0,0 +1,40 @@
+// 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 (
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// epochCmd represents the epoch command
+var epochCmd = &cobra.Command{
+	Use:   "epoch",
+	Short: "Obtain information about Ethereum 2 epochs",
+	Long:  "Obtain information about Ethereum 2 epochs",
+}
+
+func init() {
+	RootCmd.AddCommand(epochCmd)
+}
+
+func epochFlags(cmd *cobra.Command) {
+	epochSummaryCmd.Flags().String("epoch", "", "the epoch for which to obtain information (default current, can be 'current', 'last' or a number)")
+}
+
+func epochBindings() {
+	if err := viper.BindPFlag("epoch", epochSummaryCmd.Flags().Lookup("epoch")); err != nil {
+		panic(err)
+	}
+}

cmd/epoch/summary/command.go

@@ -0,0 +1,97 @@
+// 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 epochsummary
+
+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
+
+	// Beacon node connection.
+	timeout                  time.Duration
+	connection               string
+	allowInsecureConnections bool
+
+	// Operation.
+	epoch      string
+	stream     bool
+	jsonOutput bool
+
+	// Data access.
+	eth2Client             eth2client.Service
+	chainTime              chaintime.Service
+	proposerDutiesProvider eth2client.ProposerDutiesProvider
+	blocksProvider         eth2client.SignedBeaconBlockProvider
+	syncCommitteesProvider eth2client.SyncCommitteesProvider
+
+	// 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"`
+}
+
+type epochProposal struct {
+	Slot     phase0.Slot           `json:"slot"`
+	Proposer phase0.ValidatorIndex `json:"proposer"`
+	Block    bool                  `json:"block"`
+}
+
+type epochSyncCommittee struct {
+	Index  phase0.ValidatorIndex `json:"index"`
+	Missed int                   `json:"missed"`
+}
+
+func newCommand(ctx context.Context) (*command, error) {
+	c := &command{
+		quiet:   viper.GetBool("quiet"),
+		verbose: viper.GetBool("verbose"),
+		debug:   viper.GetBool("debug"),
+		summary: &epochSummary{},
+	}
+
+	// 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.epoch = viper.GetString("epoch")
+	c.stream = viper.GetBool("stream")
+	c.jsonOutput = viper.GetBool("json")
+
+	return c, nil
+}

cmd/epoch/summary/command_internal_test.go

@@ -0,0 +1,71 @@
+// 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 epochsummary
+
+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",
+			},
+			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/epoch/summary/output.go

@@ -0,0 +1,107 @@
+// 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 epochsummary
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+func (c *command) output(ctx context.Context) (string, error) {
+	if c.quiet {
+		return "", nil
+	}
+
+	if c.jsonOutput {
+		return c.outputJSON(ctx)
+	}
+
+	return c.outputTxt(ctx)
+}
+
+func (c *command) outputJSON(_ context.Context) (string, error) {
+	data, err := json.Marshal(c.summary)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+func (c *command) outputTxt(_ context.Context) (string, error) {
+	builder := strings.Builder{}
+
+	builder.WriteString("Epoch ")
+	builder.WriteString(fmt.Sprintf("%d:\n", c.summary.Epoch))
+
+	proposedBlocks := 0
+	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)
+			}
+		}
+	}
+
+	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)))
+		}
+	} 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 len(missedSyncCommittees) > 0 {
+			builder.WriteString("  Missed sync committees (excluding missed blocks):\n")
+			for _, missedSyncCommittee := range missedSyncCommittees {
+				builder.WriteString(missedSyncCommittee)
+			}
+		}
+	}
+
+	return builder.String(), nil
+}

cmd/epoch/summary/process.go

@@ -0,0 +1,174 @@
+// 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 epochsummary
+
+import (
+	"context"
+	"fmt"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/spec"
+	"github.com/attestantio/go-eth2-client/spec/altair"
+	"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.
+	err := c.setup(ctx)
+	if err != nil {
+		return err
+	}
+
+	c.summary.Epoch, err = util.ParseEpoch(ctx, c.chainTime, c.epoch)
+	if err != nil {
+		return errors.Wrap(err, "failed to parse epoch")
+	}
+	c.summary.FirstSlot = c.chainTime.FirstSlotOfEpoch(c.summary.Epoch)
+	c.summary.LastSlot = c.chainTime.FirstSlotOfEpoch(c.summary.Epoch+1) - 1
+
+	if err := c.processProposerDuties(ctx); err != nil {
+		return err
+	}
+	if err := c.processAttesterDuties(ctx); err != nil {
+		return err
+	}
+	if err := c.processSyncCommitteeDuties(ctx); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *command) processProposerDuties(ctx context.Context) error {
+	duties, err := c.proposerDutiesProvider.ProposerDuties(ctx, c.summary.Epoch, nil)
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain proposer duties")
+	}
+	if duties == nil {
+		return errors.New("empty proposer duties")
+	}
+	for _, duty := range duties {
+		block, err := c.blocksProvider.SignedBeaconBlock(ctx, fmt.Sprintf("%d", duty.Slot))
+		if err != nil {
+			return errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", duty.Slot))
+		}
+		present := block != nil
+		c.summary.Proposals = append(c.summary.Proposals, &epochProposal{
+			Slot:     duty.Slot,
+			Proposer: duty.ValidatorIndex,
+			Block:    present,
+		})
+	}
+
+	return nil
+}
+
+func (c *command) processAttesterDuties(ctx context.Context) error {
+	// Obtain all active validators for the given epoch.
+	// Do in future.
+	return nil
+}
+
+func (c *command) processSyncCommitteeDuties(ctx context.Context) error {
+	committee, err := c.syncCommitteesProvider.SyncCommittee(ctx, fmt.Sprintf("%d", c.summary.FirstSlot))
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain sync committee")
+	}
+	if len(committee.Validators) == 0 {
+		return errors.New("empty sync committee")
+	}
+
+	missed := make(map[phase0.ValidatorIndex]int)
+	for _, index := range committee.Validators {
+		missed[index] = 0
+	}
+
+	for slot := c.summary.FirstSlot; slot <= c.summary.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 {
+			// If the block is missed we don't count the sync aggregate miss.
+			continue
+		}
+		var aggregate *altair.SyncAggregate
+		switch block.Version {
+		case spec.DataVersionPhase0:
+			// No sync committees in this fork.
+			return nil
+		case spec.DataVersionAltair:
+			aggregate = block.Altair.Message.Body.SyncAggregate
+		case spec.DataVersionBellatrix:
+			aggregate = block.Bellatrix.Message.Body.SyncAggregate
+		default:
+			return fmt.Errorf("unhandled block version %v", block.Version)
+		}
+		for i := uint64(0); i < aggregate.SyncCommitteeBits.Len(); i++ {
+			if !aggregate.SyncCommitteeBits.BitAt(i) {
+				missed[committee.Validators[int(i)]]++
+			}
+		}
+	}
+
+	c.summary.SyncCommittee = make([]*epochSyncCommittee, 0, len(missed))
+	for index, count := range missed {
+		if count > 0 {
+			c.summary.SyncCommittee = append(c.summary.SyncCommittee, &epochSyncCommittee{
+				Index:  index,
+				Missed: 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.proposerDutiesProvider, isProvider = c.eth2Client.(eth2client.ProposerDutiesProvider)
+	if !isProvider {
+		return errors.New("connection does not provide proposer duties")
+	}
+	c.blocksProvider, isProvider = c.eth2Client.(eth2client.SignedBeaconBlockProvider)
+	if !isProvider {
+		return errors.New("connection does not provide signed beacon blocks")
+	}
+	c.syncCommitteesProvider, isProvider = c.eth2Client.(eth2client.SyncCommitteesProvider)
+	if !isProvider {
+		return errors.New("connection does not provide sync committee duties")
+	}
+
+	return nil
+}

cmd/epoch/summary/process_internal_test.go

@@ -0,0 +1,62 @@
+// 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 epochsummary
+
+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",
+				"data":       "[[",
+				"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)
+			}
+			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/epoch/summary/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 epochsummary
+
+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/epochsummary.go

@@ -0,0 +1,58 @@
+// 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"
+	epochsummary "github.com/wealdtech/ethdo/cmd/epoch/summary"
+)
+
+var epochSummaryCmd = &cobra.Command{
+	Use:   "summary",
+	Short: "Obtain summary information about an epoch",
+	Long: `Obtain summary information about an epoch.  For example:
+
+    ethdo epoch summary --epoch=12345
+
+In quiet mode this will return 0 if information for the epoch is found, otherwise 1.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := epochsummary.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	epochCmd.AddCommand(epochSummaryCmd)
+	epochFlags(epochSummaryCmd)
+	epochSummaryCmd.Flags().Bool("json", false, "output data in JSON format")
+}
+
+func epochSummaryBindings() {
+	epochBindings()
+	if err := viper.BindPFlag("json", epochSummaryCmd.Flags().Lookup("json")); err != nil {
+		panic(err)
+	}
+}

cmd/root.go

@@ -97,6 +97,8 @@ func includeCommandBindings(cmd *cobra.Command) {
 		chainTimeBindings()
 	case "chain/verify/signedcontributionandproof":
 		chainVerifySignedContributionAndProofBindings(cmd)
+	case "epoch/summary":
+		epochSummaryBindings()
 	case "exit/verify":
 		exitVerifyBindings()
 	case "node/events":

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.18.1)"
+var ReleaseVersion = "local build (latest release 1.19.0)"
 
 // versionCmd represents the version command
 var versionCmd = &cobra.Command{

docs/usage.md

@@ -407,6 +407,37 @@ Deposit commands focus on information about deposit data information in a JSON f
 $ ethdo deposit verify --data=${HOME}/depositdata.json --withdrawalpubkey=0xad1868210a0cff7aff22633c003c503d4c199c8dcca13bba5b3232fc784d39d3855936e94ce184c3ce27bf15d4347695 --validatorpubkey=0xa951530887ae2494a8cc4f11cf186963b0051ac4f7942375585b9cf98324db1e532a67e521d0fcaab510edad1352394c --depositvalue=32Ether
 ```
 
+### `epoch` comands
+
+Epoch commands focus on information about a beacon chain epoch.
+
+#### `summary`
+
+`ethdo epoch summary` provides a summary of the given epoch.  Options include:
+  - `epoch`: the epoch for which to provide a summary; defaults to last complete epoch
+  - `json`: provide JSON output
+
+```sh
+$ ethdo epoch summary
+Epoch 1406:
+  Slot 44992 (0/32):
+    Proposer: 31501
+    Proposed: ✓
+  Slot 44993 (1/32):
+    Proposer: 9302
+    Proposed: ✓
+  ...
+  Sync committee validator 71248:
+    Chances: 29
+    Included: 7
+    Inclusion %: 24.14
+  Sync committee validator 87371:
+    Chances: 29
+    Included: 0
+    Inclusion %: 0.00
+  ...
+```
+
 ### `exit` comands
 
 Exit commands focus on information about validator exits generated by the `ethdo validator exit` command.

util/epoch.go

@@ -0,0 +1,42 @@
+// 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 util
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/services/chaintime"
+)
+
+// ParseEpoch parses input to calculate the desired epoch.
+func ParseEpoch(ctx context.Context, chainTime chaintime.Service, epochStr string) (phase0.Epoch, error) {
+	switch epochStr {
+	case "", "current":
+		return chainTime.CurrentEpoch(), nil
+	case "last":
+		return chainTime.CurrentEpoch() - 1, nil
+	default:
+		val, err := strconv.ParseInt(epochStr, 10, 64)
+		if err != nil {
+			return 0, errors.Wrap(err, "failed to parse epoch")
+		}
+		if val >= 0 {
+			return phase0.Epoch(val), nil
+		}
+		return chainTime.CurrentEpoch() + phase0.Epoch(val), nil
+	}
+}