Bump version.

CHANGELOG.md

@@ -1,3 +1,11 @@
+1.25.0:
+  - add "proposer duties"
+  - add deposit signature verification to "deposit verify"
+
+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"
 

cmd/attester/duties/input_internal_test.go

@@ -73,7 +73,7 @@ func TestInput(t *testing.T) {
 				"timeout": "5s",
 				"pubkey":  "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
 			},
-			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
+			err: "failed to connect to any beacon node",
 		},
 	}
 

cmd/attester/inclusion/input_internal_test.go

@@ -73,7 +73,7 @@ func TestInput(t *testing.T) {
 				"timeout": "5s",
 				"pubkey":  "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
 			},
-			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
+			err: "failed to connect to any beacon node",
 		},
 	}
 

cmd/block/analyze/command_internal_test.go

@@ -40,24 +40,15 @@ func TestInput(t *testing.T) {
 		{
 			name: "ConnectionMissing",
 			vars: map[string]interface{}{
-				"validators": "1",
-				"timeout":    "5s",
+				"blockid": "1",
+				"timeout": "5s",
 			},
 			err: "connection is required",
 		},
-		{
-			name: "ValidatorsZero",
-			vars: map[string]interface{}{
-				"timeout":    "5s",
-				"validators": "0",
-				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
-			},
-			err: "validators must be at least 1",
-		},
 		{
 			name: "Good",
 			vars: map[string]interface{}{
-				"validators": "1",
+				"blockid":    "1",
 				"timeout":    "5s",
 				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
 			},

cmd/block/analyze/process_internal_test.go

@@ -33,13 +33,13 @@ func TestProcess(t *testing.T) {
 		err  string
 	}{
 		{
-			name: "InvalidData",
+			name: "NoBlock",
 			vars: map[string]interface{}{
 				"timeout":    "60s",
-				"validators": "1",
-				"data":       "[[",
 				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+				"blockid":    "invalid",
 			},
+			err: "failed to obtain beacon block: failed to request signed beacon block: GET failed with status 400: {\"code\":400,\"message\":\"Invalid block: invalid\"}",
 		},
 	}
 

cmd/block/info/input_internal_test.go

@@ -66,7 +66,7 @@ func TestInput(t *testing.T) {
 			vars: map[string]interface{}{
 				"timeout": "5s",
 			},
-			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
+			err: "failed to connect to any beacon node",
 		},
 		{
 			name: "ConnectionBad",
@@ -79,7 +79,7 @@ func TestInput(t *testing.T) {
 				timeout: 5 * time.Second,
 				blockID: "justified",
 			},
-			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
+			err: "failed to connect to beacon node: failed to confirm node connection: failed to fetch genesis: failed to request genesis: failed to call GET endpoint: Get \"http://localhost:1/eth/v1/beacon/genesis\": dial tcp 127.0.0.1:1: connect: connection refused",
 		},
 		{
 			name: "BlockIDNil",

cmd/depositverify.go

@@ -21,7 +21,7 @@ import (
 	"os"
 	"strings"
 
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/wealdtech/ethdo/util"
@@ -219,15 +219,15 @@ func verifyDeposit(deposit *util.DepositInfo, withdrawalCredentials []byte, vali
 		outputIf(!quiet, "Validator public key verified")
 	}
 
-	var pubKey spec.BLSPubKey
+	var pubKey phase0.BLSPubKey
 	copy(pubKey[:], deposit.PublicKey)
-	var signature spec.BLSSignature
+	var signature phase0.BLSSignature
 	copy(signature[:], deposit.Signature)
 
-	depositData := &spec.DepositData{
+	depositData := &phase0.DepositData{
 		PublicKey:             pubKey,
 		WithdrawalCredentials: deposit.WithdrawalCredentials,
-		Amount:                spec.Gwei(deposit.Amount),
+		Amount:                phase0.Gwei(deposit.Amount),
 		Signature:             signature,
 	}
 	depositDataRoot, err := depositData.HashTreeRoot()
@@ -248,7 +248,7 @@ func verifyDeposit(deposit *util.DepositInfo, withdrawalCredentials []byte, vali
 		}
 	} else {
 		if depositVerifyForkVersion == "" {
-			outputIf(!quiet, "fork version not supplied; NOT checked")
+			outputIf(!quiet, "fork version not supplied; not checked")
 		} else {
 			forkVersion, err := hex.DecodeString(strings.TrimPrefix(depositVerifyForkVersion, "0x"))
 			if err != nil {
@@ -260,6 +260,49 @@ func verifyDeposit(deposit *util.DepositInfo, withdrawalCredentials []byte, vali
 				outputIf(!quiet, "Fork version incorrect")
 				return false, nil
 			}
+
+			if len(deposit.DepositMessageRoot) != 32 {
+				outputIf(!quiet, "Deposit message root not supplied; not checked")
+			} else {
+				// We can also verify the deposit message signature.
+				depositMessage := &phase0.DepositMessage{
+					PublicKey:             pubKey,
+					WithdrawalCredentials: withdrawalCredentials,
+					Amount:                phase0.Gwei(deposit.Amount),
+				}
+				depositMessageRoot, err := depositMessage.HashTreeRoot()
+				if err != nil {
+					return false, errors.Wrap(err, "failed to generate deposit message root")
+				}
+
+				domainBytes := e2types.Domain(e2types.DomainDeposit, forkVersion, e2types.ZeroGenesisValidatorsRoot)
+				var domain phase0.Domain
+				copy(domain[:], domainBytes)
+				container := &phase0.SigningData{
+					ObjectRoot: depositMessageRoot,
+					Domain:     domain,
+				}
+				containerRoot, err := container.HashTreeRoot()
+				if err != nil {
+					return false, errors.New("failed to generate root for container")
+				}
+
+				validatorPubKey, err := e2types.BLSPublicKeyFromBytes(pubKey[:])
+				if err != nil {
+					return false, errors.Wrap(err, "failed to generate validator public key")
+				}
+				blsSig, err := e2types.BLSSignatureFromBytes(signature[:])
+				if err != nil {
+					return false, errors.New("failed to verify BLS signature")
+				}
+				signatureVerified := blsSig.Verify(containerRoot[:], validatorPubKey)
+				if signatureVerified {
+					outputIf(!quiet, "Deposit message signature verified")
+				} else {
+					outputIf(!quiet, "Deposit message signature NOT verified")
+					return false, nil
+				}
+			}
 		}
 	}
 

cmd/epoch/summary/process.go

@@ -159,7 +159,9 @@ func (c *command) processAttesterDuties(ctx context.Context) error {
 	c.summary.NonParticipatingValidators = make([]*nonParticipatingValidator, 0, len(activeValidators)-len(votes))
 	for activeValidatorIndex := range activeValidators {
 		if _, exists := votes[activeValidatorIndex]; !exists {
-			c.summary.NonParticipatingValidators = append(c.summary.NonParticipatingValidators, participations[activeValidatorIndex])
+			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 {

cmd/node/events/input_internal_test.go

@@ -66,7 +66,7 @@ func TestInput(t *testing.T) {
 			vars: map[string]interface{}{
 				"timeout": "5s",
 			},
-			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
+			err: "failed to connect to any beacon node",
 		},
 		{
 			name: "ConnectionBad",
@@ -75,7 +75,7 @@ func TestInput(t *testing.T) {
 				"connection": "localhost:1",
 				"topics":     []string{"one", "two"},
 			},
-			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
+			err: "failed to connect to beacon node: failed to confirm node connection: failed to fetch genesis: failed to request genesis: failed to call GET endpoint: Get \"http://localhost:1/eth/v1/beacon/genesis\": dial tcp 127.0.0.1:1: connect: connection refused",
 		},
 		{
 			name: "TopicsNil",

cmd/proposer.go

@@ -27,3 +27,6 @@ var proposerCmd = &cobra.Command{
 func init() {
 	RootCmd.AddCommand(proposerCmd)
 }
+
+func proposerFlags(cmd *cobra.Command) {
+}

cmd/proposer/duties/command.go

@@ -0,0 +1,80 @@
+// 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 proposerduties
+
+import (
+	"context"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
+	"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
+	jsonOutput bool
+
+	// Data access.
+	eth2Client             eth2client.Service
+	chainTime              chaintime.Service
+	proposerDutiesProvider eth2client.ProposerDutiesProvider
+
+	// Results.
+	results *results
+}
+
+type results struct {
+	Epoch  phase0.Epoch          `json:"epoch"`
+	Duties []*apiv1.ProposerDuty `json:"duties"`
+}
+
+func newCommand(ctx context.Context) (*command, error) {
+	c := &command{
+		quiet:   viper.GetBool("quiet"),
+		verbose: viper.GetBool("verbose"),
+		debug:   viper.GetBool("debug"),
+		results: &results{},
+	}
+
+	// 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.jsonOutput = viper.GetBool("json")
+
+	return c, nil
+}

cmd/proposer/duties/command_internal_test.go

@@ -0,0 +1,79 @@
+// 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 proposerduties
+
+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"),
+			},
+		},
+		{
+			name: "GoodWithEpoch",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+				"epoch":      "-1",
+			},
+		},
+	}
+
+	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/proposer/duties/output.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 proposerduties
+
+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.results)
+	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.results.Epoch))
+
+	for _, duty := range c.results.Duties {
+		builder.WriteString("  Slot ")
+		builder.WriteString(fmt.Sprintf("%d: ", duty.Slot))
+		builder.WriteString("validator ")
+		builder.WriteString(fmt.Sprintf("%d", duty.ValidatorIndex))
+		if c.verbose {
+			builder.WriteString(" (pubkey ")
+			builder.WriteString(fmt.Sprintf("%#x)", duty.PubKey))
+		}
+		builder.WriteString("\n")
+	}
+
+	return strings.TrimSuffix(builder.String(), "\n"), nil
+}

cmd/proposer/duties/process.go

@@ -0,0 +1,70 @@
+// 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 proposerduties
+
+import (
+	"context"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"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.results.Epoch, err = util.ParseEpoch(ctx, c.chainTime, c.epoch)
+	if err != nil {
+		return errors.Wrap(err, "failed to parse epoch")
+	}
+
+	c.results.Duties, err = c.proposerDutiesProvider.ProposerDuties(ctx, c.results.Epoch, nil)
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain proposer duties")
+	}
+
+	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")
+	}
+
+	return nil
+}

cmd/proposer/duties/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 proposerduties
+
+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/proposer/duties/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 proposerduties
+
+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/proposerduties.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"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	proposerduties "github.com/wealdtech/ethdo/cmd/proposer/duties"
+)
+
+var proposerDutiesCmd = &cobra.Command{
+	Use:   "duties",
+	Short: "Obtain information about duties of an proposer",
+	Long: `Obtain information about dutes of an proposer.  For example:
+
+    ethdo proposer duties --epoch=12345
+
+In quiet mode this will return 0 if duties can be obtained, otherwise 1.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := proposerduties.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	proposerCmd.AddCommand(proposerDutiesCmd)
+	proposerFlags(proposerDutiesCmd)
+	proposerDutiesCmd.Flags().String("epoch", "", "the epoch for which to fetch duties")
+	proposerDutiesCmd.Flags().Bool("json", false, "output data in JSON format")
+}
+
+func proposerDutiesBindings() {
+	if err := viper.BindPFlag("epoch", proposerDutiesCmd.Flags().Lookup("epoch")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("json", proposerDutiesCmd.Flags().Lookup("json")); err != nil {
+		panic(err)
+	}
+}

cmd/root.go

@@ -77,6 +77,7 @@ func persistentPreRunE(cmd *cobra.Command, args []string) error {
 	return util.SetupStore()
 }
 
+// nolint:gocyclo
 func includeCommandBindings(cmd *cobra.Command) {
 	switch commandPath(cmd) {
 	case "account/create":
@@ -107,6 +108,8 @@ func includeCommandBindings(cmd *cobra.Command) {
 		exitVerifyBindings()
 	case "node/events":
 		nodeEventsBindings()
+	case "proposer/duties":
+		proposerDutiesBindings()
 	case "slot/time":
 		slotTimeBindings()
 	case "synccommittee/inclusion":

cmd/slot/time/input_internal_test.go

@@ -73,7 +73,7 @@ func TestInput(t *testing.T) {
 				"timeout": "5s",
 				"slot":    "1",
 			},
-			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
+			err: "failed to connect to any beacon node",
 		},
 	}
 

cmd/synccommittee/inclusion/command.go

@@ -62,9 +62,7 @@ func newCommand(ctx context.Context) (*command, error) {
 	}
 	c.timeout = viper.GetDuration("timeout")
 
-	if viper.GetString("connection") == "" {
-		return nil, errors.New("connection is required")
-	}
+	// Connection.
 	c.connection = viper.GetString("connection")
 	c.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
 

cmd/synccommittee/inclusion/command_internal_test.go

@@ -37,14 +37,6 @@ func TestInput(t *testing.T) {
 			vars: map[string]interface{}{},
 			err:  "timeout is required",
 		},
-		{
-			name: "ConnectionMissing",
-			vars: map[string]interface{}{
-				"validators": "1",
-				"timeout":    "5s",
-			},
-			err: "connection is required",
-		},
 		{
 			name: "NoValidator",
 			vars: map[string]interface{}{

cmd/synccommittee/inclusion/process_internal_test.go

@@ -32,6 +32,14 @@ func TestProcess(t *testing.T) {
 		vars map[string]interface{}
 		err  string
 	}{
+		{
+			name: "MissingConnection",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"index":   "1",
+			},
+			err: "failed to connect to any beacon node",
+		},
 		{
 			name: "InvalidConnection",
 			vars: map[string]interface{}{
@@ -39,7 +47,7 @@ func TestProcess(t *testing.T) {
 				"index":      "1",
 				"connection": "invalid",
 			},
-			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
+			err: "failed to connect to beacon node: failed to confirm node connection: failed to fetch genesis: failed to request genesis: failed to call GET endpoint: Get \"http://invalid/eth/v1/beacon/genesis\": dial tcp: lookup invalid: no such host",
 		},
 		{
 			name: "Good",

cmd/synccommittee/members/input_internal_test.go

@@ -65,7 +65,15 @@ func TestInput(t *testing.T) {
 			vars: map[string]interface{}{
 				"timeout": "5s",
 			},
-			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
+			err: "failed to connect to any beacon node",
+		},
+		{
+			name: "ConnectionInvalid",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"connection": "localhost:1",
+			},
+			err: "failed to connect to beacon node: failed to confirm node connection: failed to fetch genesis: failed to request genesis: failed to call GET endpoint: Get \"http://localhost:1/eth/v1/beacon/genesis\": dial tcp 127.0.0.1:1: connect: connection refused",
 		},
 	}
 

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/exit/input_internal_test.go

@@ -158,7 +158,7 @@ func TestInput(t *testing.T) {
 				"timeout":                    "5s",
 				"key":                        "0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866",
 			},
-			err: "failed to connect to Ethereum 2 beacon node: failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
+			err: "failed to connect to Ethereum 2 beacon node: failed to connect to beacon node: failed to confirm node connection: failed to fetch genesis: failed to request genesis: failed to call GET endpoint: Get \"http://localhost:1/eth/v1/beacon/genesis\": dial tcp 127.0.0.1:1: connect: connection refused",
 		},
 		{
 			name: "EpochProvided",

cmd/validatorinfo.go

@@ -80,7 +80,7 @@ In quiet mode this will return 0 if the validator information can be obtained, o
 			pubKey, err := bestPublicKey(account)
 			if err == nil {
 				deposits, totalDeposited, err := graphData(network, pubKey.Marshal())
-				if err == nil {
+				if err == nil && deposits > 0 {
 					fmt.Printf("Number of deposits: %d\n", deposits)
 					fmt.Printf("Total deposited: %s\n", string2eth.GWeiToString(uint64(totalDeposited), true))
 				}

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

docs/usage.md

@@ -453,23 +453,25 @@ Epoch commands focus on information about a beacon chain epoch.
 
 ```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
-  ...
+Epoch 380:
+  Proposals: 31/32 (96.88%)
+  Attestations: 1530/1572 (97.33%)
+  Sync committees: 13086/15872 (82.45%)
+```
+
+More detailed information can be obtained with the `--verbose` flag:
+
+```sh
+$ ethdo epoch summary --verbose
+Epoch 380:
+  Proposals: 31/32 (96.88%)
+    Slot 12188 (28/32) validator 1518 not proposed or not included
+  Attestations: 1530/1572 (97.33%)
+    Slot 12160 committee 0 validator 292 failed to participate
+    Slot 12162 committee 0 validator 204 failed to participate
+    Slot 12163 committee 0 validator 297 failed to participate
+    Slot 12164 committee 0 validator 209 failed to participate
+    ...
 ```
 
 ### `exit` comands
@@ -709,6 +711,26 @@ $ ethdo validator yield
 Yield: 4.64%
 ```
 
+### `proposer` commands
+
+Proposer commands focus on Ethereum 2 validators' actions as proposers.
+
+#### `duties`
+
+`ethdo proposer duties` provides information on the proposal duties for a given epoch.  Options include:
+  - `epoch` the epoch in which to obtain the duties (defaults to current epoch)
+  - `json` obtain detailed information in JSON format
+
+```sh
+$ ethdo proposer duties --epoch=5
+Epoch 5:
+  Slot 160: validator 8221
+  Slot 161: validator 11193
+  Slot 162: validator 4116
+  Slot 163: validator 631
+  ...
+```
+
 ## Maintainers
 
 Jim McDonald: [@mcdee](https://github.com/mcdee).