Return on error.

Add maxDistance as an input parameter

.github/workflows/docker.yml

@@ -6,7 +6,7 @@ on:
 jobs:
   # Set variables that will be available to all builds.
   env_vars:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     outputs:
       release_version: ${{ steps.release_version.outputs.release_version }}
       binary: ${{ steps.binary.outputs.binary }}
@@ -22,7 +22,7 @@ jobs:
 
   # Build.
   build:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     needs: [env_vars]
     steps:
       - name: Check out repository into the Go module directory

.github/workflows/golangci-lint.yml

@@ -1,23 +1,23 @@
 name: golangci-lint
 on:
   push:
+    tags:
+      - v*
     branches:
     - master
   pull_request:
-
 permissions:
   contents: read
-
 jobs:
   golangci:
     name: lint
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v4
         with:
-          go-version: '1.20'
-      - uses: actions/checkout@v3
+          go-version: '^1.21'
+      - uses: actions/checkout@v4
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v3
+        uses: golangci/golangci-lint-action@v4
         with:
-          args: --timeout=60m
+          only-new-issues: true

.github/workflows/release.yml

@@ -44,12 +44,12 @@ jobs:
     needs: [create_release, env_vars]
     steps:
       - name: Set up Go
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v4
         with:
-          go-version: '^1.20'
+          go-version: '^1.21'
 
       - name: Check out repository into the Go module directory
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Select correct tag
         run: git checkout ${{ github.ref_name }}
@@ -119,12 +119,12 @@ jobs:
     needs: [create_release, env_vars]
     steps:
       - name: Set up Go
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v4
         with:
-          go-version: '^1.20'
+          go-version: '^1.21'
 
       - name: Check out repository into the Go module directory
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Select correct tag
         run: git checkout ${{ github.ref_name }}
@@ -164,12 +164,12 @@ jobs:
     needs: [create_release, env_vars]
     steps:
       - name: Set up Go
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v4
         with:
-          go-version: '^1.20'
+          go-version: '^1.21'
 
       - name: Check out repository into the Go module directory
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Select correct tag
         run: git checkout ${{ github.ref_name }}

.github/workflows/test.yml

@@ -6,10 +6,10 @@ on:
   pull_request:
 jobs:
   test:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v4
         with:
-          go-version: '1.20'
-      - uses: actions/checkout@v3
+          go-version: '^1.21'
+      - uses: actions/checkout@v4
       - uses: n8maninger/action-golang-test@v1

.golangci.yml

@@ -4,6 +4,16 @@
 # This file is not a configuration example,
 # it contains the exhaustive configuration with explanations of the options.
 
+issues:
+  # Which files to exclude: they will be analyzed, but issues from them won't be reported.
+  # There is no need to include all autogenerated files,
+  # we confidently recognize autogenerated files.
+  # If it's not, please let us know.
+  # "/" will be replaced by current OS file path separator to properly work on Windows.
+  # Default: []
+  exclude-files:
+    - ".*_ssz\\.go$"
+
 # Options for analysis running.
 run:
   # The default concurrency value is the number of available CPU.
@@ -39,15 +49,6 @@ run:
   # Default: true
   # skip-dirs-use-default: false
 
-  # Which files to skip: they will be analyzed, but issues from them won't be reported.
-  # Default value is empty list,
-  # but there is no need to include all autogenerated files,
-  # we confidently recognize autogenerated files.
-  # If it's not please let us know.
-  # "/" will be replaced by current OS file path separator to properly work on Windows.
-  skip-files:
-    - ".*_ssz\\.go$"
-
   # If set we pass it to "go list -mod={option}". From "go help modules":
   # If invoked with -mod=readonly, the go command is disallowed from the implicit
   # automatic updating of go.mod described above. Instead, it fails when any changes
@@ -68,7 +69,7 @@ run:
   # Define the Go version limit.
   # Mainly related to generics support since go1.18.
   # Default: use Go version from the go.mod file, fallback on the env var `GOVERSION`, fallback on 1.18
-  go: '1.19'
+  # go: '1.19'
 
 
 # output configuration options
@@ -130,7 +131,9 @@ linters:
     - deadcode
     - depguard
     - dupl
+    - err113
     - errorlint
+    - execinquery
     - exhaustive
     - exhaustivestruct
     - exhaustruct
@@ -142,7 +145,6 @@ linters:
     - gochecknoinits
     - gocognit
     - goconst
-    - goerr113
     - goheader
     - golint
     - gomnd
@@ -152,12 +154,14 @@ linters:
     - lll
     - maintidx
     - maligned
+    - mnd
     - musttag
     - nestif
     - nilnil
     - nlreturn
     - nolintlint
     - nosnakecase
+    - perfsprint
     - promlinter
     - rowserrcheck
     - scopelint

CHANGELOG.md

@@ -1,3 +1,29 @@
+dev:
+  - provide better error message on context deadlline exceeded
+  - update launchpad output to match latest version
+  - add deposit contract address to "chain info"
+
+1.35.2:
+  - update dependencies
+
+1.35.1:
+  - fix output for various commands that may encounter an empty slot
+
+1.35.0:
+  - support Deneb
+  - add start and end dates for eth1votes period
+
+1.34.1:
+  - fix period parsing for "synccommittee members" command
+
+1.34.0:
+  - update dependencies
+  - use Capella fork for all exits
+  - support Deneb beta 5
+
+1.33.2:
+  - fix windows build
+
 1.33.1:
   - add "slot" to "proposer duties" command
   - add activation epoch and time to "validator info" command where applicable

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.20-bullseye as builder
+FROM golang:1.21-bookworm as builder
 
 WORKDIR /app
 
@@ -10,7 +10,7 @@ COPY . .
 
 RUN go build
 
-FROM debian:bullseye-slim
+FROM debian:bookworm-slim
 
 RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt install -y ca-certificates && apt-get clean && rm -rf /var/lib/apt/lists/*
 

README.md

@@ -38,7 +38,7 @@ docker pull wealdtech/ethdo
 go install github.com/wealdtech/ethdo@latest
 ```
 
-Note that `ethdo` requires at least version 1.13 of go to operate.  The version of go can be found with `go version`.
+Note that `ethdo` requires at least version 1.20 of go to operate.  The version of go can be found with `go version`.
 
 If this does not work please see the [troubleshooting](https://github.com/wealdtech/ethdo/blob/master/docs/troubleshooting.md) page.
 

beacon/chaininfo.go

@@ -18,10 +18,12 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
+	"sort"
 	"strconv"
 	"strings"
 
 	consensusclient "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/wealdtech/ethdo/services/chaintime"
@@ -34,6 +36,7 @@ type ChainInfo struct {
 	GenesisValidatorsRoot          phase0.Root
 	Epoch                          phase0.Epoch
 	GenesisForkVersion             phase0.Version
+	ExitForkVersion                phase0.Version
 	CurrentForkVersion             phase0.Version
 	BLSToExecutionChangeDomainType phase0.DomainType
 	VoluntaryExitDomainType        phase0.DomainType
@@ -45,6 +48,7 @@ type chainInfoJSON struct {
 	GenesisValidatorsRoot          string           `json:"genesis_validators_root"`
 	Epoch                          string           `json:"epoch"`
 	GenesisForkVersion             string           `json:"genesis_fork_version"`
+	ExitForkVersion                string           `json:"exit_fork_version"`
 	CurrentForkVersion             string           `json:"current_fork_version"`
 	BLSToExecutionChangeDomainType string           `json:"bls_to_execution_change_domain_type"`
 	VoluntaryExitDomainType        string           `json:"voluntary_exit_domain_type"`
@@ -57,11 +61,12 @@ type chainInfoVersionJSON struct {
 // MarshalJSON implements json.Marshaler.
 func (c *ChainInfo) MarshalJSON() ([]byte, error) {
 	return json.Marshal(&chainInfoJSON{
-		Version:                        fmt.Sprintf("%d", c.Version),
+		Version:                        strconv.FormatUint(c.Version, 10),
 		Validators:                     c.Validators,
 		GenesisValidatorsRoot:          fmt.Sprintf("%#x", c.GenesisValidatorsRoot),
 		Epoch:                          fmt.Sprintf("%d", c.Epoch),
 		GenesisForkVersion:             fmt.Sprintf("%#x", c.GenesisForkVersion),
+		ExitForkVersion:                fmt.Sprintf("%#x", c.ExitForkVersion),
 		CurrentForkVersion:             fmt.Sprintf("%#x", c.CurrentForkVersion),
 		BLSToExecutionChangeDomainType: fmt.Sprintf("%#x", c.BLSToExecutionChangeDomainType),
 		VoluntaryExitDomainType:        fmt.Sprintf("%#x", c.VoluntaryExitDomainType),
@@ -82,7 +87,7 @@ func (c *ChainInfo) UnmarshalJSON(input []byte) error {
 	if err != nil {
 		return errors.Wrap(err, "version invalid")
 	}
-	if version < 2 {
+	if version < 3 {
 		return errors.New("outdated version; please regenerate your offline data")
 	}
 	c.Version = version
@@ -130,6 +135,18 @@ func (c *ChainInfo) UnmarshalJSON(input []byte) error {
 	}
 	copy(c.GenesisForkVersion[:], genesisForkVersionBytes)
 
+	if data.ExitForkVersion == "" {
+		return errors.New("exit fork version missing")
+	}
+	exitForkVersionBytes, err := hex.DecodeString(strings.TrimPrefix(data.ExitForkVersion, "0x"))
+	if err != nil {
+		return errors.Wrap(err, "exit fork version invalid")
+	}
+	if len(exitForkVersionBytes) != phase0.ForkVersionLength {
+		return errors.New("exit fork version incorrect length")
+	}
+	copy(c.ExitForkVersion[:], exitForkVersionBytes)
+
 	if data.CurrentForkVersion == "" {
 		return errors.New("current fork version missing")
 	}
@@ -235,18 +252,18 @@ func ObtainChainInfoFromNode(ctx context.Context,
 	error,
 ) {
 	res := &ChainInfo{
-		Version:    2,
+		Version:    3,
 		Validators: make([]*ValidatorInfo, 0),
 		Epoch:      chainTime.CurrentEpoch(),
 	}
 
 	// Obtain validators.
-	validators, err := consensusClient.(consensusclient.ValidatorsProvider).Validators(ctx, "head", nil)
+	validatorsResponse, err := consensusClient.(consensusclient.ValidatorsProvider).Validators(ctx, &api.ValidatorsOpts{State: "head"})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain validators")
 	}
 
-	for _, validator := range validators {
+	for _, validator := range validatorsResponse.Data {
 		res.Validators = append(res.Validators, &ValidatorInfo{
 			Index:                 validator.Index,
 			Pubkey:                validator.Validator.PublicKey,
@@ -254,20 +271,24 @@ func ObtainChainInfoFromNode(ctx context.Context,
 			State:                 validator.Status,
 		})
 	}
+	// Order validators by index.
+	sort.Slice(res.Validators, func(i int, j int) bool {
+		return res.Validators[i].Index < res.Validators[j].Index
+	})
 
 	// Genesis validators root obtained from beacon node.
-	genesis, err := consensusClient.(consensusclient.GenesisProvider).Genesis(ctx)
+	genesisResponse, err := consensusClient.(consensusclient.GenesisProvider).Genesis(ctx, &api.GenesisOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain genesis information")
 	}
-	res.GenesisValidatorsRoot = genesis.GenesisValidatorsRoot
+	res.GenesisValidatorsRoot = genesisResponse.Data.GenesisValidatorsRoot
 
 	// Fetch the genesis fork version from the specification.
-	spec, err := consensusClient.(consensusclient.SpecProvider).Spec(ctx)
+	specResponse, err := consensusClient.(consensusclient.SpecProvider).Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain spec")
 	}
-	tmp, exists := spec["GENESIS_FORK_VERSION"]
+	tmp, exists := specResponse.Data["GENESIS_FORK_VERSION"]
 	if !exists {
 		return nil, errors.New("genesis fork version not known by chain")
 	}
@@ -277,24 +298,34 @@ func ObtainChainInfoFromNode(ctx context.Context,
 		return nil, errors.New("could not obtain GENESIS_FORK_VERSION")
 	}
 
+	// Fetch the exit fork version (Capella) from the specification.
+	tmp, exists = specResponse.Data["CAPELLA_FORK_VERSION"]
+	if !exists {
+		return nil, errors.New("capella fork version not known by chain")
+	}
+	res.ExitForkVersion, isForkVersion = tmp.(phase0.Version)
+	if !isForkVersion {
+		return nil, errors.New("could not obtain CAPELLA_FORK_VERSION")
+	}
+
 	// Fetch the current fork version from the fork schedule.
-	forkSchedule, err := consensusClient.(consensusclient.ForkScheduleProvider).ForkSchedule(ctx)
+	forkScheduleResponse, err := consensusClient.(consensusclient.ForkScheduleProvider).ForkSchedule(ctx, &api.ForkScheduleOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain fork schedule")
 	}
-	for i := range forkSchedule {
-		if forkSchedule[i].Epoch <= res.Epoch {
-			res.CurrentForkVersion = forkSchedule[i].CurrentVersion
+	for i := range forkScheduleResponse.Data {
+		if forkScheduleResponse.Data[i].Epoch <= res.Epoch {
+			res.CurrentForkVersion = forkScheduleResponse.Data[i].CurrentVersion
 		}
 	}
 
-	blsToExecutionChangeDomainType, exists := spec["DOMAIN_BLS_TO_EXECUTION_CHANGE"].(phase0.DomainType)
+	blsToExecutionChangeDomainType, exists := specResponse.Data["DOMAIN_BLS_TO_EXECUTION_CHANGE"].(phase0.DomainType)
 	if !exists {
 		return nil, errors.New("failed to obtain DOMAIN_BLS_TO_EXECUTION_CHANGE")
 	}
 	copy(res.BLSToExecutionChangeDomainType[:], blsToExecutionChangeDomainType[:])
 
-	voluntaryExitDomainType, exists := spec["DOMAIN_VOLUNTARY_EXIT"].(phase0.DomainType)
+	voluntaryExitDomainType, exists := specResponse.Data["DOMAIN_VOLUNTARY_EXIT"].(phase0.DomainType)
 	if !exists {
 		return nil, errors.New("failed to obtain DOMAIN_VOLUNTARY_EXIT")
 	}

cmd/account/create/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019 - 2024 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
@@ -15,8 +15,8 @@ package accountcreate
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -26,7 +26,7 @@ func Run(cmd *cobra.Command) (string, error) {
 	ctx := context.Background()
 	dataIn, err := input(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain input")
+		return "", errors.Join(errors.New("failed to set up command"), err)
 	}
 
 	// Further errors do not need a usage report.
@@ -34,7 +34,12 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	dataOut, err := process(ctx, dataIn)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to process")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if !viper.GetBool("verbose") {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := output(ctx, dataOut)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return results, nil

cmd/account/derive/output.go

@@ -15,6 +15,7 @@ package accountderive
 
 import (
 	"context"
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"os"
@@ -84,7 +85,7 @@ func outputKeystore(_ context.Context, data *dataOut) (string, error) {
 	}
 	ks := make(map[string]interface{})
 	ks["uuid"] = uuid.String()
-	ks["pubkey"] = fmt.Sprintf("%x", data.key.PublicKey().Marshal())
+	ks["pubkey"] = hex.EncodeToString(data.key.PublicKey().Marshal())
 	ks["version"] = 4
 	ks["path"] = data.path
 	ks["crypto"] = crypto

cmd/account/derive/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2020 Weald Technology Trading
+// Copyright © 2020, 2024 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
@@ -15,9 +15,9 @@ package accountderive
 
 import (
 	"context"
+	"errors"
 	"strings"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 )
 
@@ -26,7 +26,7 @@ func Run(cmd *cobra.Command) (string, error) {
 	ctx := context.Background()
 	dataIn, err := input(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain input")
+		return "", errors.Join(errors.New("failed to obtain input"), err)
 	}
 
 	// Further errors do not need a usage report.
@@ -34,7 +34,12 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	dataOut, err := process(ctx, dataIn)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to process")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if dataIn.quiet {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := output(ctx, dataOut)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return strings.TrimSuffix(results, "\n"), nil

cmd/account/import/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019 - 2024 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
@@ -15,8 +15,8 @@ package accountimport
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -26,7 +26,7 @@ func Run(cmd *cobra.Command) (string, error) {
 	ctx := context.Background()
 	dataIn, err := input(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain input")
+		return "", errors.Join(errors.New("failed to obtain input"), err)
 	}
 
 	// Further errors do not need a usage report.
@@ -34,7 +34,12 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	dataOut, err := process(ctx, dataIn)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to process")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if !viper.GetBool("verbose") {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := output(ctx, dataOut)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return results, nil

cmd/account/key/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019 - 2024 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
@@ -15,8 +15,8 @@ package accountkey
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -26,7 +26,7 @@ func Run(cmd *cobra.Command) (string, error) {
 	ctx := context.Background()
 	dataIn, err := input(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain input")
+		return "", errors.Join(errors.New("failed to set up command"), err)
 	}
 
 	// Further errors do not need a usage report.
@@ -34,7 +34,12 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	dataOut, err := process(ctx, dataIn)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to process")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if viper.GetBool("quiet") {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := output(ctx, dataOut)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return results, nil

cmd/accountcreate.go

@@ -29,7 +29,7 @@ var accountCreateCmd = &cobra.Command{
     ethdo account create --account="primary/operations" --passphrase="my secret"
 
 In quiet mode this will return 0 if the account is created successfully, otherwise 1.`,
-	RunE: func(cmd *cobra.Command, args []string) error {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := accountcreate.Run(cmd)
 		if err != nil {
 			return err

cmd/accountderive.go

@@ -29,7 +29,7 @@ var accountDeriveCmd = &cobra.Command{
     ethdo account derive --mnemonic="..." --path="m/12381/3600/0/0"
 
 In quiet mode this will return 0 if the inputs can derive an account account, otherwise 1.`,
-	RunE: func(cmd *cobra.Command, args []string) error {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := accountderive.Run(cmd)
 		if err != nil {
 			return err

cmd/accountimport.go

@@ -24,12 +24,12 @@ import (
 var accountImportCmd = &cobra.Command{
 	Use:   "import",
 	Short: "Import an account",
-	Long: `Import an account from its private key.  For example:
+	Long: `Import an account from its private key or keystore.  For example:
 
     ethdo account import --account="primary/testing" --key="0x..." --passphrase="my secret"
 
 In quiet mode this will return 0 if the account is imported successfully, otherwise 1.`,
-	RunE: func(cmd *cobra.Command, args []string) error {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := accountimport.Run(cmd)
 		if err != nil {
 			return err

cmd/accountinfo.go

@@ -33,7 +33,7 @@ var accountInfoCmd = &cobra.Command{
     ethdo account info --account="primary/my funds"
 
 In quiet mode this will return 0 if the account exists, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
+	Run: func(_ *cobra.Command, _ []string) {
 		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 		defer cancel()
 

cmd/accountkey.go

@@ -30,7 +30,7 @@ var accountKeyCmd = &cobra.Command{
     ethdo account key --account="Personal wallet/Operations" --passphrase="my account passphrase"
 
 In quiet mode this will return 0 if the key can be obtained, otherwise 1.`,
-	RunE: func(cmd *cobra.Command, args []string) error {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := accountkey.Run(cmd)
 		if err != nil {
 			return err

cmd/accountlock.go

@@ -29,7 +29,7 @@ var accountLockCmd = &cobra.Command{
     ethdo account lock --account="primary/my funds"
 
 In quiet mode this will return 0 if the account is locked, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
+	Run: func(_ *cobra.Command, _ []string) {
 		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 		defer cancel()
 

cmd/accountunlock.go

@@ -30,7 +30,7 @@ var accountUnlockCmd = &cobra.Command{
     ethdo account unlock --account="primary/my funds" --passphrase="secret"
 
 In quiet mode this will return 0 if the account is unlocked, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
+	Run: func(_ *cobra.Command, _ []string) {
 		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 		defer cancel()
 

cmd/attester/duties/input.go

@@ -61,10 +61,11 @@ func input(ctx context.Context) (*dataIn, error) {
 	// Ethereum 2 client.
 	var err error
 	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       viper.GetString("connection"),
-		Timeout:       viper.GetDuration("timeout"),
-		AllowInsecure: viper.GetBool("allow-insecure-connections"),
-		LogFallback:   !data.quiet,
+		Address:           viper.GetString("connection"),
+		Timeout:           viper.GetDuration("timeout"),
+		AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+		CustomSpecSupport: viper.GetBool("custom-spec"),
+		LogFallback:       !data.quiet,
 	})
 	if err != nil {
 		return nil, err
@@ -72,7 +73,7 @@ func input(ctx context.Context) (*dataIn, error) {
 
 	data.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(data.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(data.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to set up chaintime service")

cmd/attester/duties/process.go

@@ -17,7 +17,8 @@ import (
 	"context"
 
 	eth2client "github.com/attestantio/go-eth2-client"
-	api "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/api"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
 	spec "github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/wealdtech/ethdo/util"
@@ -49,12 +50,16 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	return results, nil
 }
 
-func duty(ctx context.Context, eth2Client eth2client.Service, validator *api.Validator, epoch spec.Epoch) (*api.AttesterDuty, error) {
+func duty(ctx context.Context, eth2Client eth2client.Service, validator *apiv1.Validator, epoch spec.Epoch) (*apiv1.AttesterDuty, error) {
 	// Find the attesting slot for the given epoch.
-	duties, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, epoch, []spec.ValidatorIndex{validator.Index})
+	dutiesResponse, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, &api.AttesterDutiesOpts{
+		Epoch:   epoch,
+		Indices: []spec.ValidatorIndex{validator.Index},
+	})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain attester duties")
 	}
+	duties := dutiesResponse.Data
 
 	if len(duties) == 0 {
 		return nil, errors.New("validator does not have duty for that epoch")

cmd/attester/duties/process_internal_test.go

@@ -37,7 +37,7 @@ func TestProcess(t *testing.T) {
 
 	chainTime, err := standardchaintime.New(context.Background(),
 		standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(eth2Client.(eth2client.GenesisProvider)),
 	)
 	require.NoError(t, err)
 

cmd/attester/duties/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2021 Weald Technology Trading
+// Copyright © 2021, 2024 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
@@ -15,8 +15,8 @@ package attesterduties
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -26,7 +26,7 @@ func Run(cmd *cobra.Command) (string, error) {
 	ctx := context.Background()
 	dataIn, err := input(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain input")
+		return "", errors.Join(errors.New("failed to set up command"), err)
 	}
 
 	// Further errors do not need a usage report.
@@ -34,7 +34,12 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	dataOut, err := process(ctx, dataIn)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to process")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if viper.GetBool("quiet") {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := output(ctx, dataOut)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return results, nil

cmd/attester/inclusion/input.go

@@ -58,10 +58,11 @@ func input(ctx context.Context) (*dataIn, error) {
 	// Ethereum 2 client.
 	var err error
 	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       viper.GetString("connection"),
-		Timeout:       viper.GetDuration("timeout"),
-		AllowInsecure: viper.GetBool("allow-insecure-connections"),
-		LogFallback:   !data.quiet,
+		Address:           viper.GetString("connection"),
+		Timeout:           viper.GetDuration("timeout"),
+		AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+		CustomSpecSupport: viper.GetBool("custom-spec"),
+		LogFallback:       !data.quiet,
 	})
 	if err != nil {
 		return nil, err
@@ -69,7 +70,7 @@ func input(ctx context.Context) (*dataIn, error) {
 
 	data.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(data.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(data.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to set up chaintime service")

cmd/attester/inclusion/output.go

@@ -16,6 +16,7 @@ package attesterinclusion
 import (
 	"context"
 	"fmt"
+	"strconv"
 	"strings"
 
 	"github.com/attestantio/go-eth2-client/spec/phase0"
@@ -49,7 +50,7 @@ func output(_ context.Context, data *dataOut) (string, error) {
 			buf.WriteString("Attestation included in block ")
 			buf.WriteString(fmt.Sprintf("%d", data.slot))
 			buf.WriteString(", index ")
-			buf.WriteString(fmt.Sprintf("%d", data.attestationIndex))
+			buf.WriteString(strconv.FormatUint(data.attestationIndex, 10))
 			if data.verbose {
 				buf.WriteString("\nInclusion delay: ")
 				buf.WriteString(fmt.Sprintf("%d", data.inclusionDelay))

cmd/attester/inclusion/process.go

@@ -17,9 +17,11 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"net/http"
 
 	eth2client "github.com/attestantio/go-eth2-client"
-	api "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/api"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
@@ -38,7 +40,7 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 
 	data.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(data.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(data.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to set up chaintime service")
@@ -61,14 +63,22 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	startSlot := duty.Slot + 1
 	endSlot := startSlot + 32
 	for slot := startSlot; slot < endSlot; slot++ {
-		signedBlock, err := data.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, fmt.Sprintf("%d", slot))
+		blockResponse, err := data.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+			Block: fmt.Sprintf("%d", slot),
+		})
 		if err != nil {
+			var apiErr *api.Error
+			if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+				// No block for this slot, that's fine.
+				continue
+			}
 			return nil, errors.Wrap(err, "failed to obtain block")
 		}
-		if signedBlock == nil {
+		block := blockResponse.Data
+		if block == nil {
 			continue
 		}
-		blockSlot, err := signedBlock.Slot()
+		blockSlot, err := block.Slot()
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to obtain block slot")
 		}
@@ -78,28 +88,38 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		if data.debug {
 			fmt.Printf("Fetched block for slot %d\n", slot)
 		}
-		attestations, err := signedBlock.Attestations()
+		attestations, err := block.Attestations()
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to obtain block attestations")
 		}
 		for i, attestation := range attestations {
-			if attestation.Data.Slot == duty.Slot &&
-				attestation.Data.Index == duty.CommitteeIndex &&
-				attestation.AggregationBits.BitAt(duty.ValidatorCommitteeIndex) {
+			attestationData, err := attestation.Data()
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to obtain attestation data")
+			}
+			aggregationBits, err := attestation.AggregationBits()
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to obtain attestation aggregation bits")
+			}
+
+			if attestationData.Slot == duty.Slot &&
+				attestationData.Index == duty.CommitteeIndex &&
+				aggregationBits.BitAt(duty.ValidatorCommitteeIndex) {
 				headCorrect := false
 				targetCorrect := false
 				if data.verbose {
-					headCorrect, err = calcHeadCorrect(ctx, data, attestation)
+					headCorrect, err = calcHeadCorrect(ctx, data, attestationData)
 					if err != nil {
 						return nil, errors.Wrap(err, "failed to obtain head correct result")
 					}
-					targetCorrect, err = calcTargetCorrect(ctx, data, attestation)
+					targetCorrect, err = calcTargetCorrect(ctx, data, attestationData)
 					if err != nil {
 						return nil, errors.Wrap(err, "failed to obtain target correct result")
 					}
 				}
 				results.found = true
-				results.attestation = attestation
+				// TODO fix.
+				// results.attestation = attestation
 				results.slot = slot
 				results.attestationIndex = uint64(i)
 				results.inclusionDelay = slot - duty.Slot
@@ -118,55 +138,67 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	return results, nil
 }
 
-func calcHeadCorrect(ctx context.Context, data *dataIn, attestation *phase0.Attestation) (bool, error) {
-	slot := attestation.Data.Slot
+func calcHeadCorrect(ctx context.Context, data *dataIn, attestationData *phase0.AttestationData) (bool, error) {
+	slot := attestationData.Slot
 	for {
-		header, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+		response, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
+			Block: fmt.Sprintf("%d", slot),
+		})
 		if err != nil {
+			var apiErr *api.Error
+			if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+				// No block.
+				slot--
+				continue
+			}
+
 			return false, err
 		}
-		if header == nil {
-			// No block.
-			slot--
-			continue
-		}
-		if !header.Canonical {
+		if !response.Data.Canonical {
 			// Not canonical.
 			slot--
 			continue
 		}
-		return bytes.Equal(header.Root[:], attestation.Data.BeaconBlockRoot[:]), nil
+		return bytes.Equal(response.Data.Root[:], attestationData.BeaconBlockRoot[:]), nil
 	}
 }
 
-func calcTargetCorrect(ctx context.Context, data *dataIn, attestation *phase0.Attestation) (bool, error) {
+func calcTargetCorrect(ctx context.Context, data *dataIn, attestationData *phase0.AttestationData) (bool, error) {
 	// Start with first slot of the target epoch.
-	slot := data.chainTime.FirstSlotOfEpoch(attestation.Data.Target.Epoch)
+	slot := data.chainTime.FirstSlotOfEpoch(attestationData.Target.Epoch)
 	for {
-		header, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+		response, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
+			Block: fmt.Sprintf("%d", slot),
+		})
 		if err != nil {
+			var apiErr *api.Error
+			if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+				// No block.
+				slot--
+				continue
+			}
+
 			return false, err
 		}
-		if header == nil {
-			// No block.
-			slot--
-			continue
-		}
-		if !header.Canonical {
+		if !response.Data.Canonical {
 			// Not canonical.
 			slot--
 			continue
 		}
-		return bytes.Equal(header.Root[:], attestation.Data.Target.Root[:]), nil
+		return bytes.Equal(response.Data.Root[:], attestationData.Target.Root[:]), nil
 	}
 }
 
-func duty(ctx context.Context, eth2Client eth2client.Service, validator *api.Validator, epoch phase0.Epoch) (*api.AttesterDuty, error) {
+func duty(ctx context.Context, eth2Client eth2client.Service, validator *apiv1.Validator, epoch phase0.Epoch) (*apiv1.AttesterDuty, error) {
 	// Find the attesting slot for the given epoch.
-	duties, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, epoch, []phase0.ValidatorIndex{validator.Index})
+	dutiesResponse, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, &api.AttesterDutiesOpts{
+		Epoch:   epoch,
+		Indices: []phase0.ValidatorIndex{validator.Index},
+	})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain attester duties")
 	}
+	duties := dutiesResponse.Data
 
 	if len(duties) == 0 {
 		return nil, errors.New("validator does not have duty for that epoch")

cmd/attester/inclusion/process_internal_test.go

@@ -37,7 +37,7 @@ func TestProcess(t *testing.T) {
 
 	chainTime, err := standardchaintime.New(context.Background(),
 		standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(eth2Client.(eth2client.GenesisProvider)),
 	)
 	require.NoError(t, err)
 

cmd/attester/inclusion/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019 - 2024 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
@@ -15,8 +15,8 @@ package attesterinclusion
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -26,7 +26,7 @@ func Run(cmd *cobra.Command) (string, error) {
 	ctx := context.Background()
 	dataIn, err := input(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain input")
+		return "", errors.Join(errors.New("failed to set up command"), err)
 	}
 
 	// Further errors do not need a usage report.
@@ -34,7 +34,12 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	dataOut, err := process(ctx, dataIn)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to process")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if viper.GetBool("quiet") {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := output(ctx, dataOut)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return results, nil

cmd/attesterduties.go

@@ -29,7 +29,7 @@ var attesterDutiesCmd = &cobra.Command{
     ethdo attester duties --validator=Validators/00001 --epoch=12345
 
 In quiet mode this will return 0 if a duty from the attester is found, otherwise 1.`,
-	RunE: func(cmd *cobra.Command, args []string) error {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := attesterduties.Run(cmd)
 		if err != nil {
 			return err

cmd/attesterinclusion.go

@@ -29,7 +29,7 @@ var attesterInclusionCmd = &cobra.Command{
     ethdo attester inclusion --validator=Validators/00001 --epoch=12345
 
 In quiet mode this will return 0 if an attestation from the attester is found on the block of the given epoch, otherwise 1.`,
-	RunE: func(cmd *cobra.Command, args []string) error {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := attesterinclusion.Run(cmd)
 		if err != nil {
 			return err

cmd/block/analyze/command.go

@@ -34,6 +34,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Operation.
 	blockID    string
@@ -124,6 +125,7 @@ func newCommand(_ context.Context) (*command, error) {
 
 	c.connection = viper.GetString("connection")
 	c.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
+	c.customSpecSupport = viper.GetBool("custom-spec")
 
 	c.blockID = viper.GetString("blockid")
 	c.stream = viper.GetBool("stream")

cmd/block/analyze/output.go

@@ -17,6 +17,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"strconv"
 	"strings"
 )
 
@@ -82,26 +83,26 @@ func (c *command) outputTxt(_ context.Context) (string, error) {
 	for i, attestation := range c.analysis.Attestations {
 		if c.verbose {
 			builder.WriteString("Attestation ")
-			builder.WriteString(fmt.Sprintf("%d", i))
+			builder.WriteString(strconv.Itoa(i))
 			builder.WriteString(": ")
 			builder.WriteString("distance ")
-			builder.WriteString(fmt.Sprintf("%d", attestation.Distance))
+			builder.WriteString(strconv.Itoa(attestation.Distance))
 			builder.WriteString(", ")
 
 			if attestation.Duplicate != nil {
 				builder.WriteString("duplicate of attestation ")
-				builder.WriteString(fmt.Sprintf("%d", attestation.Duplicate.Index))
+				builder.WriteString(strconv.Itoa(attestation.Duplicate.Index))
 				builder.WriteString(" in block ")
 				builder.WriteString(fmt.Sprintf("%d", attestation.Duplicate.Block))
 				builder.WriteString("\n")
 				continue
 			}
 
-			builder.WriteString(fmt.Sprintf("%d", attestation.NewVotes))
+			builder.WriteString(strconv.Itoa(attestation.NewVotes))
 			builder.WriteString("/")
-			builder.WriteString(fmt.Sprintf("%d", attestation.Votes))
+			builder.WriteString(strconv.Itoa(attestation.Votes))
 			builder.WriteString("/")
-			builder.WriteString(fmt.Sprintf("%d", attestation.PossibleVotes))
+			builder.WriteString(strconv.Itoa(attestation.PossibleVotes))
 			builder.WriteString(" new/total/possible votes")
 			if attestation.NewVotes == 0 {
 				builder.WriteString("\n")
@@ -137,7 +138,7 @@ func (c *command) outputTxt(_ context.Context) (string, error) {
 	if c.analysis.SyncCommitee.Contributions > 0 {
 		if c.verbose {
 			builder.WriteString("Sync committee contributions: ")
-			builder.WriteString(fmt.Sprintf("%d", c.analysis.SyncCommitee.Contributions))
+			builder.WriteString(strconv.Itoa(c.analysis.SyncCommitee.Contributions))
 			builder.WriteString(" contributions, score ")
 			builder.WriteString(fmt.Sprintf("%0.3f", c.analysis.SyncCommitee.Score))
 			builder.WriteString(", value ")

cmd/block/analyze/process.go

@@ -19,7 +19,9 @@ import (
 	"fmt"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec"
+	"github.com/attestantio/go-eth2-client/spec/electra"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
@@ -33,13 +35,17 @@ func (c *command) process(ctx context.Context) error {
 		return err
 	}
 
-	block, err := c.blocksProvider.SignedBeaconBlock(ctx, c.blockID)
+	blockResponse, err := c.blocksProvider.SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+		Block: c.blockID,
+	})
 	if err != nil {
+		var apiError *api.Error
+		if errors.As(err, &apiError) && apiError.StatusCode == 404 {
+			return errors.New("empty beacon block")
+		}
 		return errors.Wrap(err, "failed to obtain beacon block")
 	}
-	if block == nil {
-		return errors.New("empty beacon block")
-	}
+	block := blockResponse.Data
 
 	slot, err := block.Slot()
 	if err != nil {
@@ -57,8 +63,12 @@ func (c *command) process(ctx context.Context) error {
 	// Calculate how many parents we need to fetch.
 	minSlot := slot
 	for _, attestation := range attestations {
-		if attestation.Data.Slot < minSlot {
-			minSlot = attestation.Data.Slot
+		attestationData, err := attestation.Data()
+		if err != nil {
+			continue
+		}
+		if attestationData.Slot < minSlot {
+			minSlot = attestationData.Slot
 		}
 	}
 	if c.debug {
@@ -97,68 +107,27 @@ func (c *command) analyzeAttestations(ctx context.Context, block *spec.Versioned
 		if c.debug {
 			fmt.Printf("Processing attestation %d\n", i)
 		}
-		analysis := &attestationAnalysis{
-			Head:     attestation.Data.BeaconBlockRoot,
-			Target:   attestation.Data.Target.Root,
-			Distance: int(slot - attestation.Data.Slot),
-		}
 
-		root, err := attestation.HashTreeRoot()
+		var analysis *attestationAnalysis
+		switch attestation.Version {
+		case spec.DataVersionPhase0:
+			analysis, err = c.phase0Analysis(ctx, slot, attestation.Phase0, blockVotes, spec.DataVersionPhase0)
+		case spec.DataVersionAltair:
+			analysis, err = c.phase0Analysis(ctx, slot, attestation.Altair, blockVotes, spec.DataVersionAltair)
+		case spec.DataVersionBellatrix:
+			analysis, err = c.phase0Analysis(ctx, slot, attestation.Bellatrix, blockVotes, spec.DataVersionBellatrix)
+		case spec.DataVersionCapella:
+			analysis, err = c.phase0Analysis(ctx, slot, attestation.Capella, blockVotes, spec.DataVersionCapella)
+		case spec.DataVersionDeneb:
+			analysis, err = c.phase0Analysis(ctx, slot, attestation.Deneb, blockVotes, spec.DataVersionDeneb)
+		case spec.DataVersionElectra:
+			analysis, err = c.electraAnalysis(ctx, slot, attestation.Electra, blockVotes, spec.DataVersionElectra)
+		default:
+			return fmt.Errorf("unknown version %s", attestation.Version)
+		}
 		if err != nil {
 			return err
 		}
-		if info, exists := c.priorAttestations[fmt.Sprintf("%#x", root)]; exists {
-			analysis.Duplicate = info
-		} else {
-			data := attestation.Data
-			_, exists := blockVotes[data.Slot]
-			if !exists {
-				blockVotes[data.Slot] = make(map[phase0.CommitteeIndex]bitfield.Bitlist)
-			}
-			_, exists = blockVotes[data.Slot][data.Index]
-			if !exists {
-				blockVotes[data.Slot][data.Index] = bitfield.NewBitlist(attestation.AggregationBits.Len())
-			}
-
-			// Count new votes.
-			analysis.PossibleVotes = int(attestation.AggregationBits.Len())
-			for j := uint64(0); j < attestation.AggregationBits.Len(); j++ {
-				if attestation.AggregationBits.BitAt(j) {
-					analysis.Votes++
-					if blockVotes[data.Slot][data.Index].BitAt(j) {
-						// Already attested to in this block; skip.
-						continue
-					}
-					if c.votes[data.Slot][data.Index].BitAt(j) {
-						// Already attested to in a previous block; skip.
-						continue
-					}
-					analysis.NewVotes++
-					blockVotes[data.Slot][data.Index].SetBitAt(j, true)
-				}
-			}
-			// Calculate head correct.
-			var err error
-			analysis.HeadCorrect, err = c.calcHeadCorrect(ctx, attestation)
-			if err != nil {
-				return err
-			}
-
-			// Calculate head timely.
-			analysis.HeadTimely = attestation.Data.Slot == slot-1
-
-			// Calculate source timely.
-			analysis.SourceTimely = attestation.Data.Slot >= slot-5
-
-			// Calculate target correct.
-			analysis.TargetCorrect, err = c.calcTargetCorrect(ctx, attestation)
-			if err != nil {
-				return err
-			}
-
-			// Calculate target timely.
-			analysis.TargetTimely = attestation.Data.Slot >= slot-32
-		}
 
 		// Calculate score and value.
 		if analysis.TargetCorrect && analysis.TargetTimely {
@@ -179,17 +148,194 @@ func (c *command) analyzeAttestations(ctx context.Context, block *spec.Versioned
 	return nil
 }
 
+func (c *command) phase0Analysis(ctx context.Context,
+	slot phase0.Slot,
+	attestation *phase0.Attestation,
+	blockVotes map[phase0.Slot]map[phase0.CommitteeIndex]bitfield.Bitlist,
+	version spec.DataVersion,
+) (
+	*attestationAnalysis,
+	error,
+) {
+	analysis := &attestationAnalysis{
+		Head:     attestation.Data.BeaconBlockRoot,
+		Target:   attestation.Data.Target.Root,
+		Distance: int(slot - attestation.Data.Slot),
+	}
+
+	// TODO.
+	root, err := attestation.HashTreeRoot()
+	if err != nil {
+		return nil, err
+	}
+	if info, exists := c.priorAttestations[fmt.Sprintf("%#x", root)]; exists {
+		analysis.Duplicate = info
+	} else {
+		data := attestation.Data
+		_, exists := blockVotes[data.Slot]
+		if !exists {
+			blockVotes[data.Slot] = make(map[phase0.CommitteeIndex]bitfield.Bitlist)
+		}
+		_, exists = blockVotes[data.Slot][data.Index]
+		if !exists {
+			blockVotes[data.Slot][data.Index] = bitfield.NewBitlist(attestation.AggregationBits.Len())
+		}
+
+		// Count new votes.
+		analysis.PossibleVotes = int(attestation.AggregationBits.Len())
+		for j := uint64(0); j < attestation.AggregationBits.Len(); j++ {
+			if attestation.AggregationBits.BitAt(j) {
+				analysis.Votes++
+				if blockVotes[data.Slot][data.Index].BitAt(j) {
+					// Already attested to in this block; skip.
+					continue
+				}
+				if c.votes[data.Slot][data.Index].BitAt(j) {
+					// Already attested to in a previous block; skip.
+					continue
+				}
+				analysis.NewVotes++
+				blockVotes[data.Slot][data.Index].SetBitAt(j, true)
+			}
+		}
+		// Calculate head correct.
+		analysis.HeadCorrect, err = c.calcHeadCorrect(ctx, attestation)
+		if err != nil {
+			return nil, err
+		}
+
+		// Calculate head timely.
+		analysis.HeadTimely = analysis.HeadCorrect && attestation.Data.Slot == slot-1
+
+		// Calculate source timely.
+		analysis.SourceTimely = attestation.Data.Slot >= slot-5
+
+		// Calculate target correct.
+		analysis.TargetCorrect, err = c.calcTargetCorrect(ctx, attestation)
+		if err != nil {
+			return nil, err
+		}
+
+		// Calculate target timely.
+		if version < spec.DataVersionDeneb {
+			analysis.TargetTimely = attestation.Data.Slot >= slot-32
+		} else {
+			analysis.TargetTimely = true
+		}
+	}
+
+	return analysis, nil
+}
+
+func (c *command) electraAnalysis(ctx context.Context,
+	slot phase0.Slot,
+	attestation *electra.Attestation,
+	blockVotes map[phase0.Slot]map[phase0.CommitteeIndex]bitfield.Bitlist,
+	version spec.DataVersion,
+) (
+	*attestationAnalysis,
+	error,
+) {
+	analysis := &attestationAnalysis{
+		Head:     attestation.Data.BeaconBlockRoot,
+		Target:   attestation.Data.Target.Root,
+		Distance: int(slot - attestation.Data.Slot),
+	}
+
+	// TODO.
+	root, err := attestation.HashTreeRoot()
+	if err != nil {
+		return nil, err
+	}
+	if info, exists := c.priorAttestations[fmt.Sprintf("%#x", root)]; exists {
+		analysis.Duplicate = info
+	} else {
+		data := attestation.Data
+		_, exists := blockVotes[data.Slot]
+		if !exists {
+			blockVotes[data.Slot] = make(map[phase0.CommitteeIndex]bitfield.Bitlist)
+		}
+		_, exists = blockVotes[data.Slot][data.Index]
+		if !exists {
+			blockVotes[data.Slot][data.Index] = bitfield.NewBitlist(attestation.AggregationBits.Len())
+		}
+
+		// Count new votes.
+		analysis.PossibleVotes = int(attestation.AggregationBits.Len())
+		for j := uint64(0); j < attestation.AggregationBits.Len(); j++ {
+			if attestation.AggregationBits.BitAt(j) {
+				analysis.Votes++
+				if blockVotes[data.Slot][data.Index].BitAt(j) {
+					// Already attested to in this block; skip.
+					continue
+				}
+				if c.votes[data.Slot][data.Index].BitAt(j) {
+					// Already attested to in a previous block; skip.
+					continue
+				}
+				analysis.NewVotes++
+				blockVotes[data.Slot][data.Index].SetBitAt(j, true)
+			}
+		}
+		// Calculate head correct.
+		var err error
+		analysis.HeadCorrect, err = c.calcElectraHeadCorrect(ctx, attestation)
+		if err != nil {
+			return nil, err
+		}
+
+		// Calculate head timely.
+		analysis.HeadTimely = analysis.HeadCorrect && attestation.Data.Slot == slot-1
+
+		// Calculate source timely.
+		analysis.SourceTimely = attestation.Data.Slot >= slot-5
+
+		// Calculate target correct.
+		analysis.TargetCorrect, err = c.calcElectraTargetCorrect(ctx, attestation)
+		if err != nil {
+			return nil, err
+		}
+
+		// Calculate target timely.
+		if version < spec.DataVersionDeneb {
+			analysis.TargetTimely = attestation.Data.Slot >= slot-32
+		} else {
+			analysis.TargetTimely = true
+		}
+	}
+
+	return analysis, nil
+}
+
 func (c *command) fetchParents(ctx context.Context, block *spec.VersionedSignedBeaconBlock, minSlot phase0.Slot) error {
 	parentRoot, err := block.ParentRoot()
 	if err != nil {
 		return err
 	}
+	root, err := block.Deneb.HashTreeRoot()
+	if err != nil {
+		panic(err)
+	}
+	slot, err := block.Slot()
+	if err != nil {
+		panic(err)
+	}
+	if c.debug {
+		fmt.Printf("Parent root of %#x@%d is %#x\n", root, slot, parentRoot)
+	}
 
 	// Obtain the parent block.
-	parentBlock, err := c.blocksProvider.SignedBeaconBlock(ctx, fmt.Sprintf("%#x", parentRoot))
+	parentBlockResponse, err := c.blocksProvider.SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+		Block: fmt.Sprintf("%#x", parentRoot),
+	})
 	if err != nil {
+		var apiError *api.Error
+		if errors.As(err, &apiError) && apiError.StatusCode == 404 {
+			return errors.New("empty beacon block")
+		}
 		return err
 	}
+	parentBlock := parentBlockResponse.Data
 	if parentBlock == nil {
 		return fmt.Errorf("unable to obtain parent block %s", parentBlock)
 	}
@@ -210,10 +356,10 @@ func (c *command) fetchParents(ctx context.Context, block *spec.VersionedSignedB
 }
 
 func (c *command) processParentBlock(_ context.Context, block *spec.VersionedSignedBeaconBlock) error {
-	attestations, err := block.Attestations()
-	if err != nil {
-		return err
-	}
+	//	attestations, err := block.Attestations()
+	//	if err != nil {
+	//		return err
+	//	}
 	slot, err := block.Slot()
 	if err != nil {
 		return err
@@ -222,31 +368,40 @@ func (c *command) processParentBlock(_ context.Context, block *spec.VersionedSig
 		fmt.Printf("Processing block %d\n", slot)
 	}
 
-	for i, attestation := range attestations {
-		root, err := attestation.HashTreeRoot()
-		if err != nil {
-			return err
-		}
-		c.priorAttestations[fmt.Sprintf("%#x", root)] = &attestationData{
-			Block: slot,
-			Index: i,
-		}
+	// TODO reinstate.
+	// for i, attestation := range attestations {
+	//	root, err := attestation.HashTreeRoot()
+	//	if err != nil {
+	//		return err
+	//	}
+	//	c.priorAttestations[fmt.Sprintf("%#x", root)] = &attestationData{
+	//		Block: slot,
+	//		Index: i,
+	//	}
 
-		data := attestation.Data
-		_, exists := c.votes[data.Slot]
-		if !exists {
-			c.votes[data.Slot] = make(map[phase0.CommitteeIndex]bitfield.Bitlist)
-		}
-		_, exists = c.votes[data.Slot][data.Index]
-		if !exists {
-			c.votes[data.Slot][data.Index] = bitfield.NewBitlist(attestation.AggregationBits.Len())
-		}
-		for j := uint64(0); j < attestation.AggregationBits.Len(); j++ {
-			if attestation.AggregationBits.BitAt(j) {
-				c.votes[data.Slot][data.Index].SetBitAt(j, true)
-			}
-		}
-	}
+	//	data, err := attestation.Data()
+	//	if err != nil {
+	//		return err
+	//	}
+	//	aggregationBits, err := attestation.AggregationBits()
+	//	if err != nil {
+	//		return err
+	//	}
+
+	//	_, exists := c.votes[data.Slot]
+	//	if !exists {
+	//		c.votes[data.Slot] = make(map[phase0.CommitteeIndex]bitfield.Bitlist)
+	//	}
+	//	_, exists = c.votes[data.Slot][data.Index]
+	//	if !exists {
+	//		c.votes[data.Slot][data.Index] = bitfield.NewBitlist(aggregationBits.Len())
+	//	}
+	//	for j := uint64(0); j < aggregationBits.Len(); j++ {
+	//		if aggregationBits.BitAt(j) {
+	//			c.votes[data.Slot][data.Index].SetBitAt(j, true)
+	//		}
+	//	}
+	//}
 
 	return nil
 }
@@ -256,10 +411,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the client.
 	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to beacon node")
@@ -267,7 +423,7 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return errors.Wrap(err, "failed to set up chaintime service")
@@ -289,12 +445,12 @@ func (c *command) setup(ctx context.Context) error {
 		return errors.New("connection does not provide spec information")
 	}
 
-	spec, err := specProvider.Spec(ctx)
+	specResponse, err := specProvider.Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain spec")
 	}
 
-	tmp, exists := spec["TIMELY_SOURCE_WEIGHT"]
+	tmp, exists := specResponse.Data["TIMELY_SOURCE_WEIGHT"]
 	if !exists {
 		// Set a default value based on the Altair spec.
 		tmp = uint64(14)
@@ -305,7 +461,7 @@ func (c *command) setup(ctx context.Context) error {
 		return errors.New("TIMELY_SOURCE_WEIGHT of unexpected type")
 	}
 
-	tmp, exists = spec["TIMELY_TARGET_WEIGHT"]
+	tmp, exists = specResponse.Data["TIMELY_TARGET_WEIGHT"]
 	if !exists {
 		// Set a default value based on the Altair spec.
 		tmp = uint64(26)
@@ -315,7 +471,7 @@ func (c *command) setup(ctx context.Context) error {
 		return errors.New("TIMELY_TARGET_WEIGHT of unexpected type")
 	}
 
-	tmp, exists = spec["TIMELY_HEAD_WEIGHT"]
+	tmp, exists = specResponse.Data["TIMELY_HEAD_WEIGHT"]
 	if !exists {
 		// Set a default value based on the Altair spec.
 		tmp = uint64(14)
@@ -325,7 +481,7 @@ func (c *command) setup(ctx context.Context) error {
 		return errors.New("TIMELY_HEAD_WEIGHT of unexpected type")
 	}
 
-	tmp, exists = spec["SYNC_REWARD_WEIGHT"]
+	tmp, exists = specResponse.Data["SYNC_REWARD_WEIGHT"]
 	if !exists {
 		// Set a default value based on the Altair spec.
 		tmp = uint64(2)
@@ -335,7 +491,7 @@ func (c *command) setup(ctx context.Context) error {
 		return errors.New("SYNC_REWARD_WEIGHT of unexpected type")
 	}
 
-	tmp, exists = spec["PROPOSER_WEIGHT"]
+	tmp, exists = specResponse.Data["PROPOSER_WEIGHT"]
 	if !exists {
 		// Set a default value based on the Altair spec.
 		tmp = uint64(8)
@@ -345,7 +501,7 @@ func (c *command) setup(ctx context.Context) error {
 		return errors.New("PROPOSER_WEIGHT of unexpected type")
 	}
 
-	tmp, exists = spec["WEIGHT_DENOMINATOR"]
+	tmp, exists = specResponse.Data["WEIGHT_DENOMINATOR"]
 	if !exists {
 		// Set a default value based on the Altair spec.
 		tmp = uint64(64)
@@ -362,22 +518,31 @@ func (c *command) calcHeadCorrect(ctx context.Context, attestation *phase0.Attes
 	root, exists := c.headRoots[slot]
 	if !exists {
 		for {
-			header, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+			response, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
+				Block: fmt.Sprintf("%d", slot),
+			})
 			if err != nil {
+				var apiError *api.Error
+				if errors.As(err, &apiError) && apiError.StatusCode == 404 {
+					if c.debug {
+						fmt.Printf("No block available for slot %d, assuming not in canonical chain", slot)
+					}
+					return false, nil
+				}
 				return false, err
 			}
-			if header == nil {
+			if response.Data == nil {
 				// No block.
 				slot--
 				continue
 			}
-			if !header.Canonical {
+			if !response.Data.Canonical {
 				// Not canonical.
 				slot--
 				continue
 			}
-			c.headRoots[attestation.Data.Slot] = header.Root
-			root = header.Root
+			c.headRoots[attestation.Data.Slot] = response.Data.Root
+			root = response.Data.Root
 			break
 		}
 	}
@@ -391,22 +556,103 @@ func (c *command) calcTargetCorrect(ctx context.Context, attestation *phase0.Att
 		// Start with first slot of the target epoch.
 		slot := c.chainTime.FirstSlotOfEpoch(attestation.Data.Target.Epoch)
 		for {
-			header, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+			response, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
+				Block: fmt.Sprintf("%d", slot),
+			})
 			if err != nil {
-				return false, err
+				var apiError *api.Error
+				if errors.As(err, &apiError) && apiError.StatusCode == 404 {
+					if c.debug {
+						fmt.Printf("No block available for slot %d, assuming not in canonical chain", slot)
+					}
+					return false, nil
+				}
 			}
-			if header == nil {
+			if response.Data == nil {
 				// No block.
 				slot--
 				continue
 			}
-			if !header.Canonical {
+			if !response.Data.Canonical {
 				// Not canonical.
 				slot--
 				continue
 			}
-			c.targetRoots[attestation.Data.Slot] = header.Root
-			root = header.Root
+			c.targetRoots[attestation.Data.Slot] = response.Data.Root
+			root = response.Data.Root
+			break
+		}
+	}
+	return bytes.Equal(root[:], attestation.Data.Target.Root[:]), nil
+}
+
+func (c *command) calcElectraHeadCorrect(ctx context.Context, attestation *electra.Attestation) (bool, error) {
+	slot := attestation.Data.Slot
+	root, exists := c.headRoots[slot]
+	if !exists {
+		for {
+			response, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
+				Block: fmt.Sprintf("%d", slot),
+			})
+			if err != nil {
+				var apiError *api.Error
+				if errors.As(err, &apiError) && apiError.StatusCode == 404 {
+					if c.debug {
+						fmt.Printf("No block available for slot %d, assuming not in canonical chain", slot)
+					}
+					return false, nil
+				}
+				return false, err
+			}
+			if response.Data == nil {
+				// No block.
+				slot--
+				continue
+			}
+			if !response.Data.Canonical {
+				// Not canonical.
+				slot--
+				continue
+			}
+			c.headRoots[attestation.Data.Slot] = response.Data.Root
+			root = response.Data.Root
+			break
+		}
+	}
+
+	return bytes.Equal(root[:], attestation.Data.BeaconBlockRoot[:]), nil
+}
+
+func (c *command) calcElectraTargetCorrect(ctx context.Context, attestation *electra.Attestation) (bool, error) {
+	root, exists := c.targetRoots[attestation.Data.Slot]
+	if !exists {
+		// Start with first slot of the target epoch.
+		slot := c.chainTime.FirstSlotOfEpoch(attestation.Data.Target.Epoch)
+		for {
+			response, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
+				Block: fmt.Sprintf("%d", slot),
+			})
+			if err != nil {
+				var apiError *api.Error
+				if errors.As(err, &apiError) && apiError.StatusCode == 404 {
+					if c.debug {
+						fmt.Printf("No block available for slot %d, assuming not in canonical chain", slot)
+					}
+					return false, nil
+				}
+			}
+			if response.Data == nil {
+				// No block.
+				slot--
+				continue
+			}
+			if !response.Data.Canonical {
+				// Not canonical.
+				slot--
+				continue
+			}
+			c.targetRoots[attestation.Data.Slot] = response.Data.Root
+			root = response.Data.Root
 			break
 		}
 	}

cmd/block/analyze/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2022 Weald Technology Trading.
+// Copyright © 2022, 2024 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
@@ -15,8 +15,8 @@ package blockanalyze
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -27,14 +27,19 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	c, err := newCommand(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to set up command")
+		return "", errors.Join(errors.New("failed to set up command"), err)
 	}
 
 	// 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")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if viper.GetBool("quiet") {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := c.output(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return results, nil

cmd/block/info/input.go

@@ -57,10 +57,11 @@ func input(ctx context.Context) (*dataIn, error) {
 
 	var err error
 	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       viper.GetString("connection"),
-		Timeout:       viper.GetDuration("timeout"),
-		AllowInsecure: viper.GetBool("allow-insecure-connections"),
-		LogFallback:   !data.quiet,
+		Address:           viper.GetString("connection"),
+		Timeout:           viper.GetDuration("timeout"),
+		AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+		CustomSpecSupport: viper.GetBool("custom-spec"),
+		LogFallback:       !data.quiet,
 	})
 	if err != nil {
 		return nil, err

cmd/block/info/output.go

@@ -20,15 +20,18 @@ import (
 	"fmt"
 	"math/big"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
 	"unicode/utf8"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec/altair"
 	"github.com/attestantio/go-eth2-client/spec/bellatrix"
 	"github.com/attestantio/go-eth2-client/spec/capella"
 	"github.com/attestantio/go-eth2-client/spec/deneb"
+	"github.com/attestantio/go-eth2-client/spec/electra"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
@@ -116,12 +119,14 @@ func outputBlockAttestations(ctx context.Context, eth2Client eth2client.Service,
 				// Fetch committees for this epoch if not already obtained.
 				committees, exists := validatorCommittees[att.Data.Slot]
 				if !exists {
-					beaconCommittees, err := beaconCommitteesProvider.BeaconCommittees(ctx, fmt.Sprintf("%d", att.Data.Slot))
+					response, err := beaconCommitteesProvider.BeaconCommittees(ctx, &api.BeaconCommitteesOpts{
+						State: fmt.Sprintf("%d", att.Data.Slot),
+					})
 					if err != nil {
 						// Failed to get it; create an empty committee to stop us continually attempting to re-fetch.
 						validatorCommittees[att.Data.Slot] = make(map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
 					} else {
-						for _, beaconCommittee := range beaconCommittees {
+						for _, beaconCommittee := range response.Data {
 							if _, exists := validatorCommittees[beaconCommittee.Slot]; !exists {
 								validatorCommittees[beaconCommittee.Slot] = make(map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
 							}
@@ -166,11 +171,128 @@ func outputBlockAttesterSlashings(ctx context.Context, eth2Client eth2client.Ser
 
 			res.WriteString(fmt.Sprintf("  %d:\n", i))
 			res.WriteString(fmt.Sprintln("    Slashed validators:"))
-			validators, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, "head", slashedIndices)
+			response, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, &api.ValidatorsOpts{
+				State:   "head",
+				Indices: slashedIndices,
+			})
 			if err != nil {
 				return "", errors.Wrap(err, "failed to obtain beacon committees")
 			}
-			for k, v := range validators {
+			for k, v := range response.Data {
+				res.WriteString(fmt.Sprintf("      %#x (%d)\n", v.Validator.PublicKey[:], k))
+			}
+
+			// Say what caused the slashing.
+			if att1.Data.Target.Epoch == att2.Data.Target.Epoch {
+				res.WriteString(fmt.Sprintf("    Double voted for same target epoch (%d):\n", att1.Data.Target.Epoch))
+				if !bytes.Equal(att1.Data.Target.Root[:], att2.Data.Target.Root[:]) {
+					res.WriteString(fmt.Sprintf("      Attestation 1 target epoch root: %#x\n", att1.Data.Target.Root))
+					res.WriteString(fmt.Sprintf("      Attestation 2target epoch root: %#x\n", att2.Data.Target.Root))
+				}
+				if !bytes.Equal(att1.Data.BeaconBlockRoot[:], att2.Data.BeaconBlockRoot[:]) {
+					res.WriteString(fmt.Sprintf("      Attestation 1 beacon block root: %#x\n", att1.Data.BeaconBlockRoot))
+					res.WriteString(fmt.Sprintf("      Attestation 2 beacon block root: %#x\n", att2.Data.BeaconBlockRoot))
+				}
+			} else if att1.Data.Source.Epoch < att2.Data.Source.Epoch &&
+				att1.Data.Target.Epoch > att2.Data.Target.Epoch {
+				res.WriteString("    Surround voted:\n")
+				res.WriteString(fmt.Sprintf("      Attestation 1 vote: %d->%d\n", att1.Data.Source.Epoch, att1.Data.Target.Epoch))
+				res.WriteString(fmt.Sprintf("      Attestation 2 vote: %d->%d\n", att2.Data.Source.Epoch, att2.Data.Target.Epoch))
+			}
+		}
+	}
+
+	return res.String(), nil
+}
+
+func outputElectraBlockAttestations(ctx context.Context,
+	eth2Client eth2client.Service,
+	verbose bool,
+	attestations []*electra.Attestation,
+) (
+	string,
+	error,
+) {
+	res := strings.Builder{}
+
+	validatorCommittees := make(map[phase0.Slot]map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
+	res.WriteString(fmt.Sprintf("Attestations: %d\n", len(attestations)))
+	if verbose {
+		beaconCommitteesProvider, isProvider := eth2Client.(eth2client.BeaconCommitteesProvider)
+		if isProvider {
+			for i, att := range attestations {
+				res.WriteString(fmt.Sprintf("  %d:\n", i))
+
+				// Fetch committees for this epoch if not already obtained.
+				committees, exists := validatorCommittees[att.Data.Slot]
+				if !exists {
+					response, err := beaconCommitteesProvider.BeaconCommittees(ctx, &api.BeaconCommitteesOpts{
+						State: fmt.Sprintf("%d", att.Data.Slot),
+					})
+					if err != nil {
+						// Failed to get it; create an empty committee to stop us continually attempting to re-fetch.
+						validatorCommittees[att.Data.Slot] = make(map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
+					} else {
+						for _, beaconCommittee := range response.Data {
+							if _, exists := validatorCommittees[beaconCommittee.Slot]; !exists {
+								validatorCommittees[beaconCommittee.Slot] = make(map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
+							}
+							validatorCommittees[beaconCommittee.Slot][beaconCommittee.Index] = beaconCommittee.Validators
+						}
+					}
+					committees = validatorCommittees[att.Data.Slot]
+				}
+
+				res.WriteString(fmt.Sprintf("    Committee index: %d\n", att.Data.Index))
+				res.WriteString(fmt.Sprintf("    Attesters: %d/%d\n", att.AggregationBits.Count(), att.AggregationBits.Len()))
+				res.WriteString(fmt.Sprintf("    Aggregation bits: %s\n", bitlistToString(att.AggregationBits)))
+				if _, exists := committees[att.Data.Index]; exists {
+					res.WriteString(fmt.Sprintf("    Attesting indices: %s\n", attestingIndices(att.AggregationBits, committees[att.Data.Index])))
+				}
+				res.WriteString(fmt.Sprintf("    Slot: %d\n", att.Data.Slot))
+				res.WriteString(fmt.Sprintf("    Beacon block root: %#x\n", att.Data.BeaconBlockRoot))
+				res.WriteString(fmt.Sprintf("    Source epoch: %d\n", att.Data.Source.Epoch))
+				res.WriteString(fmt.Sprintf("    Source root: %#x\n", att.Data.Source.Root))
+				res.WriteString(fmt.Sprintf("    Target epoch: %d\n", att.Data.Target.Epoch))
+				res.WriteString(fmt.Sprintf("    Target root: %#x\n", att.Data.Target.Root))
+			}
+		}
+	}
+
+	return res.String(), nil
+}
+
+func outputElectraBlockAttesterSlashings(ctx context.Context,
+	eth2Client eth2client.Service,
+	verbose bool,
+	attesterSlashings []*electra.AttesterSlashing,
+) (
+	string,
+	error,
+) {
+	res := strings.Builder{}
+
+	res.WriteString(fmt.Sprintf("Attester slashings: %d\n", len(attesterSlashings)))
+	if verbose {
+		for i, slashing := range attesterSlashings {
+			// Say what was slashed.
+			att1 := slashing.Attestation1
+			att2 := slashing.Attestation2
+			slashedIndices := intersection(att1.AttestingIndices, att2.AttestingIndices)
+			if len(slashedIndices) == 0 {
+				continue
+			}
+
+			res.WriteString(fmt.Sprintf("  %d:\n", i))
+			res.WriteString(fmt.Sprintln("    Slashed validators:"))
+			response, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, &api.ValidatorsOpts{
+				State:   "head",
+				Indices: slashedIndices,
+			})
+			if err != nil {
+				return "", errors.Wrap(err, "failed to obtain beacon committees")
+			}
+			for k, v := range response.Data {
 				res.WriteString(fmt.Sprintf("      %#x (%d)\n", v.Validator.PublicKey[:], k))
 			}
 
@@ -223,11 +345,14 @@ func outputBlockVoluntaryExits(ctx context.Context, eth2Client eth2client.Servic
 	if verbose {
 		for i, voluntaryExit := range voluntaryExits {
 			res.WriteString(fmt.Sprintf("  %d:\n", i))
-			validators, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, "head", []phase0.ValidatorIndex{voluntaryExit.Message.ValidatorIndex})
+			response, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, &api.ValidatorsOpts{
+				State:   "head",
+				Indices: []phase0.ValidatorIndex{voluntaryExit.Message.ValidatorIndex},
+			})
 			if err != nil {
 				res.WriteString(fmt.Sprintf("  Error: failed to obtain validators: %v\n", err))
 			} else {
-				res.WriteString(fmt.Sprintf("    Validator: %#x (%d)\n", validators[voluntaryExit.Message.ValidatorIndex].Validator.PublicKey, voluntaryExit.Message.ValidatorIndex))
+				res.WriteString(fmt.Sprintf("    Validator: %#x (%d)\n", response.Data[voluntaryExit.Message.ValidatorIndex].Validator.PublicKey, voluntaryExit.Message.ValidatorIndex))
 				res.WriteString(fmt.Sprintf("    Epoch: %d\n", voluntaryExit.Message.Epoch))
 			}
 		}
@@ -243,11 +368,14 @@ func outputBlockBLSToExecutionChanges(ctx context.Context, eth2Client eth2client
 	if verbose {
 		for i, op := range ops {
 			res.WriteString(fmt.Sprintf("  %d:\n", i))
-			validators, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, "head", []phase0.ValidatorIndex{op.Message.ValidatorIndex})
+			response, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, &api.ValidatorsOpts{
+				State:   "head",
+				Indices: []phase0.ValidatorIndex{op.Message.ValidatorIndex},
+			})
 			if err != nil {
 				res.WriteString(fmt.Sprintf("  Error: failed to obtain validators: %v\n", err))
 			} else {
-				res.WriteString(fmt.Sprintf("    Validator: %#x (%d)\n", validators[op.Message.ValidatorIndex].Validator.PublicKey, op.Message.ValidatorIndex))
+				res.WriteString(fmt.Sprintf("    Validator: %#x (%d)\n", response.Data[op.Message.ValidatorIndex].Validator.PublicKey, op.Message.ValidatorIndex))
 				res.WriteString(fmt.Sprintf("    BLS public key: %#x\n", op.Message.FromBLSPubkey))
 				res.WriteString(fmt.Sprintf("    Execution address: %s\n", op.Message.ToExecutionAddress.String()))
 			}
@@ -265,9 +393,9 @@ func outputBlockSyncAggregate(ctx context.Context, eth2Client eth2client.Service
 	if verbose {
 		specProvider, isProvider := eth2Client.(eth2client.SpecProvider)
 		if isProvider {
-			config, err := specProvider.Spec(ctx)
+			specResponse, err := specProvider.Spec(ctx, &api.SpecOpts{})
 			if err == nil {
-				slotsPerEpoch := config["SLOTS_PER_EPOCH"].(uint64)
+				slotsPerEpoch := specResponse.Data["SLOTS_PER_EPOCH"].(uint64)
 
 				res.WriteString("  Contributions: ")
 				res.WriteString(bitvectorToString(syncAggregate.SyncCommitteeBits))
@@ -275,14 +403,16 @@ func outputBlockSyncAggregate(ctx context.Context, eth2Client eth2client.Service
 
 				syncCommitteesProvider, isProvider := eth2Client.(eth2client.SyncCommitteesProvider)
 				if isProvider {
-					syncCommittee, err := syncCommitteesProvider.SyncCommittee(ctx, fmt.Sprintf("%d", uint64(epoch)*slotsPerEpoch))
+					syncCommitteeResponse, err := syncCommitteesProvider.SyncCommittee(ctx, &api.SyncCommitteeOpts{
+						State: strconv.FormatUint(uint64(epoch)*slotsPerEpoch, 10),
+					})
 					if err != nil {
 						res.WriteString(fmt.Sprintf("  Error: failed to obtain sync committee: %v\n", err))
 					} else {
 						res.WriteString("  Contributing validators:")
 						for i := uint64(0); i < syncAggregate.SyncCommitteeBits.Len(); i++ {
 							if syncAggregate.SyncCommitteeBits.BitAt(i) {
-								res.WriteString(fmt.Sprintf(" %d", syncCommittee.Validators[i]))
+								res.WriteString(fmt.Sprintf(" %d", syncCommitteeResponse.Data.Validators[i]))
 							}
 						}
 						res.WriteString("\n")
@@ -502,6 +632,116 @@ func outputDenebBlockText(ctx context.Context,
 	return res.String(), nil
 }
 
+func outputElectraBlockText(ctx context.Context,
+	data *dataOut,
+	signedBlock *electra.SignedBeaconBlock,
+	blobs []*deneb.BlobSidecar,
+) (
+	string,
+	error,
+) {
+	if signedBlock == nil {
+		return "", errors.New("no block supplied")
+	}
+
+	body := signedBlock.Message.Body
+
+	res := strings.Builder{}
+
+	// General info.
+	blockRoot, err := signedBlock.Message.HashTreeRoot()
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain block root")
+	}
+	bodyRoot, err := signedBlock.Message.Body.HashTreeRoot()
+	if err != nil {
+		return "", errors.Wrap(err, "failed to generate body root")
+	}
+
+	tmp, err := outputBlockGeneral(ctx,
+		data.verbose,
+		signedBlock.Message.Slot,
+		signedBlock.Message.ProposerIndex,
+		blockRoot,
+		bodyRoot,
+		signedBlock.Message.ParentRoot,
+		signedBlock.Message.StateRoot,
+		signedBlock.Message.Body.Graffiti[:],
+		data.genesisTime,
+		data.slotDuration,
+		data.slotsPerEpoch)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Eth1 data.
+	if data.verbose {
+		tmp, err := outputBlockETH1Data(ctx, body.ETH1Data)
+		if err != nil {
+			return "", err
+		}
+		res.WriteString(tmp)
+	}
+
+	// Sync aggregate.
+	tmp, err = outputBlockSyncAggregate(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.SyncAggregate, phase0.Epoch(uint64(signedBlock.Message.Slot)/data.slotsPerEpoch))
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Attestations.
+	tmp, err = outputElectraBlockAttestations(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.Attestations)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Attester slashings.
+	tmp, err = outputElectraBlockAttesterSlashings(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.AttesterSlashings)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	res.WriteString(fmt.Sprintf("Proposer slashings: %d\n", len(body.ProposerSlashings)))
+	// Add verbose proposer slashings.
+
+	tmp, err = outputBlockDeposits(ctx, data.verbose, signedBlock.Message.Body.Deposits)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Voluntary exits.
+	tmp, err = outputBlockVoluntaryExits(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.VoluntaryExits)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	tmp, err = outputBlockBLSToExecutionChanges(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.BLSToExecutionChanges)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	tmp, err = outputElectraBlockExecutionPayload(ctx, data.verbose, signedBlock.Message.Body.ExecutionPayload)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	tmp, err = outputElectraBlobInfo(ctx, data.verbose, signedBlock.Message.Body, blobs)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	return res.String(), nil
+}
+
 func outputBellatrixBlockText(ctx context.Context, data *dataOut, signedBlock *bellatrix.SignedBeaconBlock) (string, error) {
 	if signedBlock == nil {
 		return "", errors.New("no block supplied")
@@ -888,6 +1128,71 @@ func outputDenebBlockExecutionPayload(_ context.Context,
 	return res.String(), nil
 }
 
+func outputElectraBlockExecutionPayload(_ context.Context,
+	verbose bool,
+	payload *electra.ExecutionPayload,
+) (
+	string,
+	error,
+) {
+	if payload == nil {
+		return "", nil
+	}
+
+	// If the block number is 0 then we're before the merge.
+	if payload.BlockNumber == 0 {
+		return "", nil
+	}
+
+	res := strings.Builder{}
+	if !verbose {
+		res.WriteString("Execution block number: ")
+		res.WriteString(fmt.Sprintf("%d\n", payload.BlockNumber))
+		res.WriteString("Transactions: ")
+		res.WriteString(fmt.Sprintf("%d\n", len(payload.Transactions)))
+	} else {
+		res.WriteString("Execution payload:\n")
+		res.WriteString("  Execution block number: ")
+		res.WriteString(fmt.Sprintf("%d\n", payload.BlockNumber))
+		res.WriteString("  Base fee per gas: ")
+		res.WriteString(string2eth.WeiToString(payload.BaseFeePerGas.ToBig(), true))
+		res.WriteString("\n  Block hash: ")
+		res.WriteString(fmt.Sprintf("%#x\n", payload.BlockHash))
+		res.WriteString("  Parent hash: ")
+		res.WriteString(fmt.Sprintf("%#x\n", payload.ParentHash))
+		res.WriteString("  Fee recipient: ")
+		res.WriteString(payload.FeeRecipient.String())
+		res.WriteString("  Gas limit: ")
+		res.WriteString(fmt.Sprintf("%d\n", payload.GasLimit))
+		res.WriteString("  Gas used: ")
+		res.WriteString(fmt.Sprintf("%d\n", payload.GasUsed))
+		res.WriteString("  Timestamp: ")
+		res.WriteString(fmt.Sprintf("%s (%d)\n", time.Unix(int64(payload.Timestamp), 0).String(), payload.Timestamp))
+		res.WriteString("  Prev RANDAO: ")
+		res.WriteString(fmt.Sprintf("%#x\n", payload.PrevRandao))
+		res.WriteString("  Receipts root: ")
+		res.WriteString(fmt.Sprintf("%#x\n", payload.ReceiptsRoot))
+		res.WriteString("  State root: ")
+		res.WriteString(fmt.Sprintf("%#x\n", payload.StateRoot))
+		res.WriteString("  Extra data: ")
+		if utf8.Valid(payload.ExtraData) {
+			res.WriteString(fmt.Sprintf("%s\n", string(payload.ExtraData)))
+		} else {
+			res.WriteString(fmt.Sprintf("%#x\n", payload.ExtraData))
+		}
+		res.WriteString("  Logs bloom: ")
+		res.WriteString(fmt.Sprintf("%#x\n", payload.LogsBloom))
+		res.WriteString("  Transactions: ")
+		res.WriteString(fmt.Sprintf("%d\n", len(payload.Transactions)))
+		res.WriteString("  Withdrawals: ")
+		res.WriteString(fmt.Sprintf("%d\n", len(payload.Withdrawals)))
+		res.WriteString("  Excess blob gas: ")
+		res.WriteString(fmt.Sprintf("%d\n", payload.ExcessBlobGas))
+	}
+
+	return res.String(), nil
+}
+
 func outputDenebBlobInfo(_ context.Context,
 	verbose bool,
 	body *deneb.BeaconBlockBody,
@@ -901,7 +1206,7 @@ func outputDenebBlobInfo(_ context.Context,
 	}
 
 	if !verbose {
-		return fmt.Sprintf("Blobs: %d\n", len(body.BlobKzgCommitments)), nil
+		return fmt.Sprintf("Blobs: %d\n", len(body.BlobKZGCommitments)), nil
 	}
 
 	res := strings.Builder{}
@@ -911,8 +1216,36 @@ func outputDenebBlobInfo(_ context.Context,
 			res.WriteString("Blobs\n")
 		}
 		res.WriteString(fmt.Sprintf("  Index: %d\n", blob.Index))
-		res.WriteString(fmt.Sprintf("  KZG commitment: %s\n", blob.KzgCommitment.String()))
-		res.WriteString(fmt.Sprintf("  KZG proof: %s\n", blob.KzgProof.String()))
+		res.WriteString(fmt.Sprintf("  KZG commitment: %s\n", body.BlobKZGCommitments[i].String()))
+	}
+
+	return res.String(), nil
+}
+
+func outputElectraBlobInfo(_ context.Context,
+	verbose bool,
+	body *electra.BeaconBlockBody,
+	blobs []*deneb.BlobSidecar,
+) (
+	string,
+	error,
+) {
+	if body == nil {
+		return "", nil
+	}
+
+	if !verbose {
+		return fmt.Sprintf("Blobs: %d\n", len(body.BlobKZGCommitments)), nil
+	}
+
+	res := strings.Builder{}
+
+	for i, blob := range blobs {
+		if i == 0 {
+			res.WriteString("Blobs\n")
+		}
+		res.WriteString(fmt.Sprintf("  Index: %d\n", blob.Index))
+		res.WriteString(fmt.Sprintf("  KZG commitment: %s\n", body.BlobKZGCommitments[i].String()))
 	}
 
 	return res.String(), nil

cmd/block/info/process.go

@@ -17,18 +17,21 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"net/http"
 	"os"
 	"strconv"
 	"strings"
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
-	api "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/api"
+	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/bellatrix"
 	"github.com/attestantio/go-eth2-client/spec/capella"
 	"github.com/attestantio/go-eth2-client/spec/deneb"
+	"github.com/attestantio/go-eth2-client/spec/electra"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
@@ -54,17 +57,18 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		eth2Client: data.eth2Client,
 	}
 
-	config, err := results.eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	specResponse, err := results.eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to connect to obtain configuration information")
 	}
-	genesis, err := results.eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
+	genesisResponse, err := results.eth2Client.(eth2client.GenesisProvider).Genesis(ctx, &api.GenesisOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to connect to obtain genesis information")
 	}
+	genesis := genesisResponse.Data
 	results.genesisTime = genesis.GenesisTime
-	results.slotDuration = config["SECONDS_PER_SLOT"].(time.Duration)
-	results.slotsPerEpoch = config["SLOTS_PER_EPOCH"].(uint64)
+	results.slotDuration = specResponse.Data["SECONDS_PER_SLOT"].(time.Duration)
+	results.slotsPerEpoch = specResponse.Data["SLOTS_PER_EPOCH"].(uint64)
 
 	if data.blockTime != "" {
 		data.blockID, err = timeToBlockID(ctx, data.eth2Client, data.blockTime)
@@ -73,43 +77,63 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		}
 	}
 
-	signedBlock, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, data.blockID)
+	blockResponse, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+		Block: data.blockID,
+	})
 	if err != nil {
+		var apiErr *api.Error
+		if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+			if data.quiet {
+				os.Exit(1)
+			}
+
+			return nil, errors.New("empty beacon block")
+		}
+
 		return nil, errors.Wrap(err, "failed to obtain beacon block")
 	}
-	if signedBlock == nil {
-		if data.quiet {
-			os.Exit(1)
-		}
-		return nil, errors.New("empty beacon block")
-	}
+	block := blockResponse.Data
 	if data.quiet {
 		os.Exit(0)
 	}
 
-	switch signedBlock.Version {
+	switch block.Version {
 	case spec.DataVersionPhase0:
-		if err := outputPhase0Block(ctx, data.jsonOutput, signedBlock.Phase0); err != nil {
+		if err := outputPhase0Block(ctx, data.jsonOutput, block.Phase0); err != nil {
 			return nil, errors.Wrap(err, "failed to output block")
 		}
 	case spec.DataVersionAltair:
-		if err := outputAltairBlock(ctx, data.jsonOutput, data.sszOutput, signedBlock.Altair); err != nil {
+		if err := outputAltairBlock(ctx, data.jsonOutput, data.sszOutput, block.Altair); err != nil {
 			return nil, errors.Wrap(err, "failed to output block")
 		}
 	case spec.DataVersionBellatrix:
-		if err := outputBellatrixBlock(ctx, data.jsonOutput, data.sszOutput, signedBlock.Bellatrix); err != nil {
+		if err := outputBellatrixBlock(ctx, data.jsonOutput, data.sszOutput, block.Bellatrix); err != nil {
 			return nil, errors.Wrap(err, "failed to output block")
 		}
 	case spec.DataVersionCapella:
-		if err := outputCapellaBlock(ctx, data.jsonOutput, data.sszOutput, signedBlock.Capella); err != nil {
+		if err := outputCapellaBlock(ctx, data.jsonOutput, data.sszOutput, block.Capella); err != nil {
 			return nil, errors.Wrap(err, "failed to output block")
 		}
 	case spec.DataVersionDeneb:
-		blobs, err := results.eth2Client.(eth2client.BeaconBlockBlobsProvider).BeaconBlockBlobs(ctx, data.blockID)
+		blobSidecarsResponse, err := results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
+			Block: data.blockID,
+		})
 		if err != nil {
-			return nil, errors.Wrap(err, "failed to obtain blobs")
+			return nil, errors.Wrap(err, "failed to obtain blob sidecars")
 		}
-		if err := outputDenebBlock(ctx, data.jsonOutput, data.sszOutput, signedBlock.Deneb, blobs); err != nil {
+		blobSidecars := blobSidecarsResponse.Data
+		if err := outputDenebBlock(ctx, data.jsonOutput, data.sszOutput, block.Deneb, blobSidecars); err != nil {
+			return nil, errors.Wrap(err, "failed to output block")
+		}
+	case spec.DataVersionElectra:
+		blobSidecarsResponse, err := results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
+			Block: data.blockID,
+		})
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to obtain blob sidecars")
+		}
+		blobSidecars := blobSidecarsResponse.Data
+		if err := outputElectraBlock(ctx, data.jsonOutput, data.sszOutput, block.Electra, blobSidecars); err != nil {
 			return nil, errors.Wrap(err, "failed to output block")
 		}
 	default:
@@ -132,7 +156,7 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	return &dataOut{}, nil
 }
 
-func headEventHandler(event *api.Event) {
+func headEventHandler(event *apiv1.Event) {
 	ctx := context.Background()
 
 	// Only interested in head events.
@@ -140,35 +164,48 @@ func headEventHandler(event *api.Event) {
 		return
 	}
 
-	blockID := fmt.Sprintf("%#x", event.Data.(*api.HeadEvent).Block[:])
-	signedBlock, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, blockID)
+	blockID := fmt.Sprintf("%#x", event.Data.(*apiv1.HeadEvent).Block[:])
+	blockResponse, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+		Block: blockID,
+	})
 	if err != nil {
 		if !jsonOutput && !sszOutput {
 			fmt.Printf("Failed to obtain block: %v\n", err)
 		}
 		return
 	}
-	if signedBlock == nil {
+	block := blockResponse.Data
+	if block == nil {
 		if !jsonOutput && !sszOutput {
 			fmt.Println("Empty beacon block")
 		}
 		return
 	}
 
-	switch signedBlock.Version {
+	switch block.Version {
 	case spec.DataVersionPhase0:
-		err = outputPhase0Block(ctx, jsonOutput, signedBlock.Phase0)
+		err = outputPhase0Block(ctx, jsonOutput, block.Phase0)
 	case spec.DataVersionAltair:
-		err = outputAltairBlock(ctx, jsonOutput, sszOutput, signedBlock.Altair)
+		err = outputAltairBlock(ctx, jsonOutput, sszOutput, block.Altair)
 	case spec.DataVersionBellatrix:
-		err = outputBellatrixBlock(ctx, jsonOutput, sszOutput, signedBlock.Bellatrix)
+		err = outputBellatrixBlock(ctx, jsonOutput, sszOutput, block.Bellatrix)
 	case spec.DataVersionCapella:
-		err = outputCapellaBlock(ctx, jsonOutput, sszOutput, signedBlock.Capella)
+		err = outputCapellaBlock(ctx, jsonOutput, sszOutput, block.Capella)
 	case spec.DataVersionDeneb:
-		var blobs []*deneb.BlobSidecar
-		blobs, err = results.eth2Client.(eth2client.BeaconBlockBlobsProvider).BeaconBlockBlobs(ctx, blockID)
+		var blobSidecarsResponse *api.Response[[]*deneb.BlobSidecar]
+		blobSidecarsResponse, err = results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
+			Block: blockID,
+		})
 		if err == nil {
-			err = outputDenebBlock(context.Background(), jsonOutput, sszOutput, signedBlock.Deneb, blobs)
+			err = outputDenebBlock(context.Background(), jsonOutput, sszOutput, block.Deneb, blobSidecarsResponse.Data)
+		}
+	case spec.DataVersionElectra:
+		var blobSidecarsResponse *api.Response[[]*deneb.BlobSidecar]
+		blobSidecarsResponse, err = results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
+			Block: blockID,
+		})
+		if err == nil {
+			err = outputElectraBlock(context.Background(), jsonOutput, sszOutput, block.Electra, blobSidecarsResponse.Data)
 		}
 	default:
 		err = errors.New("unknown block version")
@@ -302,6 +339,35 @@ func outputDenebBlock(ctx context.Context,
 	return nil
 }
 
+func outputElectraBlock(ctx context.Context,
+	jsonOutput bool,
+	sszOutput bool,
+	signedBlock *electra.SignedBeaconBlock,
+	blobs []*deneb.BlobSidecar,
+) error {
+	switch {
+	case jsonOutput:
+		data, err := json.Marshal(signedBlock)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate JSON")
+		}
+		fmt.Printf("%s\n", string(data))
+	case sszOutput:
+		data, err := signedBlock.MarshalSSZ()
+		if err != nil {
+			return errors.Wrap(err, "failed to generate SSZ")
+		}
+		fmt.Printf("%x\n", data)
+	default:
+		data, err := outputElectraBlockText(ctx, results, signedBlock, blobs)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate text")
+		}
+		fmt.Print(data)
+	}
+	return nil
+}
+
 func timeToBlockID(ctx context.Context, eth2Client eth2client.Service, input string) (string, error) {
 	var timestamp time.Time
 
@@ -331,7 +397,7 @@ func timeToBlockID(ctx context.Context, eth2Client eth2client.Service, input str
 	// Assume timestamp.
 	chainTime, err := standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return "", errors.Wrap(err, "failed to set up chaintime service")

cmd/block/info/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019 - 2024 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
@@ -15,8 +15,8 @@ package blockinfo
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -26,7 +26,7 @@ func Run(cmd *cobra.Command) (string, error) {
 	ctx := context.Background()
 	dataIn, err := input(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain input")
+		return "", errors.Join(errors.New("failed to set up command"), err)
 	}
 
 	// Further errors do not need a usage report.
@@ -34,7 +34,12 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	dataOut, err := process(ctx, dataIn)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to process")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if viper.GetBool("quiet") {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := output(ctx, dataOut)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return results, nil

cmd/blockanalyze.go

@@ -29,7 +29,7 @@ var blockAnalyzeCmd = &cobra.Command{
     ethdo block analyze --blockid=12345
 
 In quiet mode this will return 0 if the block information is present and not skipped, otherwise 1.`,
-	RunE: func(cmd *cobra.Command, args []string) error {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := blockanalyze.Run(cmd)
 		if err != nil {
 			return err

cmd/blockinfo.go

@@ -29,7 +29,7 @@ var blockInfoCmd = &cobra.Command{
     ethdo block info --blockid=12345
 
 In quiet mode this will return 0 if the block information is present and not skipped, otherwise 1.`,
-	RunE: func(cmd *cobra.Command, args []string) error {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := blockinfo.Run(cmd)
 		if err != nil {
 			return err

cmd/chain/eth1votes/command.go

@@ -34,6 +34,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Input.
 	xepoch  string
@@ -50,6 +51,8 @@ type command struct {
 	slot          phase0.Slot
 	epoch         phase0.Epoch
 	period        uint64
+	periodStart   time.Time
+	periodEnd     time.Time
 	incumbent     *phase0.ETH1Data
 	eth1DataVotes []*phase0.ETH1Data
 	votes         map[string]*vote
@@ -62,10 +65,11 @@ type vote struct {
 
 func newCommand(_ context.Context) (*command, error) {
 	c := &command{
-		quiet:   viper.GetBool("quiet"),
-		verbose: viper.GetBool("verbose"),
-		debug:   viper.GetBool("debug"),
-		json:    viper.GetBool("json"),
+		quiet:             viper.GetBool("quiet"),
+		verbose:           viper.GetBool("verbose"),
+		debug:             viper.GetBool("debug"),
+		json:              viper.GetBool("json"),
+		customSpecSupport: viper.GetBool("custom-spec"),
 	}
 
 	// Timeout.

cmd/chain/eth1votes/output.go

@@ -24,11 +24,13 @@ import (
 )
 
 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"`
+	Period      uint64           `json:"period"`
+	PeriodStart int64            `json:"period_start"`
+	PeriodEnd   int64            `json:"period_end"`
+	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) {
@@ -57,11 +59,13 @@ func (c *command) outputJSON(_ context.Context) (string, error) {
 	})
 
 	output := &jsonOutput{
-		Period:    c.period,
-		Epoch:     c.epoch,
-		Slot:      c.slot,
-		Incumbent: c.incumbent,
-		Votes:     votes,
+		Period:      c.period,
+		PeriodStart: c.periodStart.Unix(),
+		PeriodEnd:   c.periodEnd.Unix(),
+		Epoch:       c.epoch,
+		Slot:        c.slot,
+		Incumbent:   c.incumbent,
+		Votes:       votes,
 	}
 	data, err := json.Marshal(output)
 	if err != nil {
@@ -78,6 +82,11 @@ func (c *command) outputText(_ context.Context) (string, error) {
 	builder.WriteString(fmt.Sprintf("%d\n", c.period))
 
 	if c.verbose {
+		builder.WriteString("Period start: ")
+		builder.WriteString(fmt.Sprintf("%s\n", c.periodStart))
+		builder.WriteString("Period end: ")
+		builder.WriteString(fmt.Sprintf("%s\n", c.periodEnd))
+
 		builder.WriteString("Incumbent: ")
 		builder.WriteString(fmt.Sprintf("block %#x, deposit count %d\n", c.incumbent.BlockHash, c.incumbent.DepositCount))
 	}

cmd/chain/eth1votes/process.go

@@ -20,6 +20,7 @@ import (
 	"strconv"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
@@ -58,10 +59,13 @@ func (c *command) process(ctx context.Context) error {
 	if fetchSlot > c.chainTime.CurrentSlot() {
 		fetchSlot = c.chainTime.CurrentSlot()
 	}
-	state, err := c.beaconStateProvider.BeaconState(ctx, fmt.Sprintf("%d", fetchSlot))
+	stateResponse, err := c.beaconStateProvider.BeaconState(ctx, &api.BeaconStateOpts{
+		State: fmt.Sprintf("%d", fetchSlot),
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain state")
 	}
+	state := stateResponse.Data
 	if state == nil {
 		return errors.New("state not returned by beacon node")
 	}
@@ -73,32 +77,36 @@ func (c *command) process(ctx context.Context) error {
 		}
 	}
 
+	c.slot, err = state.Slot()
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain slot")
+	}
 	switch state.Version {
 	case spec.DataVersionPhase0:
-		c.slot = state.Phase0.Slot
 		c.incumbent = state.Phase0.ETH1Data
 		c.eth1DataVotes = state.Phase0.ETH1DataVotes
 	case spec.DataVersionAltair:
-		c.slot = state.Altair.Slot
 		c.incumbent = state.Altair.ETH1Data
 		c.eth1DataVotes = state.Altair.ETH1DataVotes
 	case spec.DataVersionBellatrix:
-		c.slot = state.Bellatrix.Slot
 		c.incumbent = state.Bellatrix.ETH1Data
 		c.eth1DataVotes = state.Bellatrix.ETH1DataVotes
 	case spec.DataVersionCapella:
-		c.slot = state.Capella.Slot
 		c.incumbent = state.Capella.ETH1Data
 		c.eth1DataVotes = state.Capella.ETH1DataVotes
 	case spec.DataVersionDeneb:
-		c.slot = state.Deneb.Slot
 		c.incumbent = state.Deneb.ETH1Data
 		c.eth1DataVotes = state.Deneb.ETH1DataVotes
+	case spec.DataVersionElectra:
+		c.incumbent = state.Electra.ETH1Data
+		c.eth1DataVotes = state.Electra.ETH1DataVotes
 	default:
 		return fmt.Errorf("unhandled beacon state version %v", state.Version)
 	}
 
 	c.period = uint64(c.epoch) / c.epochsPerEth1VotingPeriod
+	c.periodStart = c.chainTime.StartOfEpoch(phase0.Epoch(c.period * c.epochsPerEth1VotingPeriod))
+	c.periodEnd = c.chainTime.StartOfEpoch(phase0.Epoch((c.period + 1) * c.epochsPerEth1VotingPeriod))
 
 	c.votes = make(map[string]*vote)
 	for _, eth1Vote := range c.eth1DataVotes {
@@ -119,10 +127,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the client.
 	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to beacon node")
@@ -130,7 +139,7 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return errors.Wrap(err, "failed to set up chaintime service")
@@ -146,12 +155,12 @@ func (c *command) setup(ctx context.Context) error {
 		return errors.New("connection does not provide spec information")
 	}
 
-	spec, err := specProvider.Spec(ctx)
+	specResponse, err := specProvider.Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain spec")
 	}
 
-	tmp, exists := spec["SLOTS_PER_EPOCH"]
+	tmp, exists := specResponse.Data["SLOTS_PER_EPOCH"]
 	if !exists {
 		return errors.New("spec did not contain SLOTS_PER_EPOCH")
 	}
@@ -160,7 +169,7 @@ func (c *command) setup(ctx context.Context) error {
 	if !good {
 		return errors.New("SLOTS_PER_EPOCH value invalid")
 	}
-	tmp, exists = spec["EPOCHS_PER_ETH1_VOTING_PERIOD"]
+	tmp, exists = specResponse.Data["EPOCHS_PER_ETH1_VOTING_PERIOD"]
 	if !exists {
 		return errors.New("spec did not contain EPOCHS_PER_ETH1_VOTING_PERIOD")
 	}

cmd/chain/eth1votes/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2022 Weald Technology Trading.
+// Copyright © 2022, 2024 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
@@ -15,8 +15,8 @@ package chaineth1votes
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -27,14 +27,19 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	c, err := newCommand(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to set up command")
+		return "", errors.Join(errors.New("failed to set up command"), err)
 	}
 
 	// 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")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if viper.GetBool("quiet") {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := c.output(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return results, nil

cmd/chain/queues/command.go

@@ -33,6 +33,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Input.
 	epoch string
@@ -49,10 +50,11 @@ type command struct {
 
 func newCommand(_ context.Context) (*command, error) {
 	c := &command{
-		quiet:   viper.GetBool("quiet"),
-		verbose: viper.GetBool("verbose"),
-		debug:   viper.GetBool("debug"),
-		json:    viper.GetBool("json"),
+		quiet:             viper.GetBool("quiet"),
+		verbose:           viper.GetBool("verbose"),
+		debug:             viper.GetBool("debug"),
+		json:              viper.GetBool("json"),
+		customSpecSupport: viper.GetBool("custom-spec"),
 	}
 
 	// Timeout.

cmd/chain/queues/process.go

@@ -18,6 +18,7 @@ import (
 	"fmt"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/pkg/errors"
 	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
 	"github.com/wealdtech/ethdo/util"
@@ -34,12 +35,14 @@ func (c *command) process(ctx context.Context) error {
 		return err
 	}
 
-	validators, err := c.validatorsProvider.Validators(ctx, fmt.Sprintf("%d", c.chainTime.FirstSlotOfEpoch(epoch)), nil)
+	response, err := c.validatorsProvider.Validators(ctx, &api.ValidatorsOpts{
+		State: fmt.Sprintf("%d", c.chainTime.FirstSlotOfEpoch(epoch)),
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain validators")
 	}
 
-	for _, validator := range validators {
+	for _, validator := range response.Data {
 		if validator.Validator == nil {
 			continue
 		}
@@ -59,10 +62,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the client.
 	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to beacon node")
@@ -70,7 +74,7 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return errors.Wrap(err, "failed to set up chaintime service")

cmd/chain/queues/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2022 Weald Technology Trading.
+// Copyright © 2022, 2024 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
@@ -15,8 +15,8 @@ package chainqueues
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -27,14 +27,19 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	c, err := newCommand(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to set up command")
+		return "", errors.Join(errors.New("failed to set up command"), err)
 	}
 
 	// 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")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if viper.GetBool("quiet") {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := c.output(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return results, nil

cmd/chain/time/input.go

@@ -31,6 +31,7 @@ type dataIn struct {
 	// Input
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 	timestamp                string
 	slot                     string
 	epoch                    string
@@ -73,6 +74,7 @@ func input(_ context.Context) (*dataIn, error) {
 
 	data.connection = viper.GetString("connection")
 	data.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
+	data.customSpecSupport = viper.GetBool("custom-spec")
 
 	return data, nil
 }

cmd/chain/time/output.go

@@ -16,6 +16,7 @@ package chaintime
 import (
 	"context"
 	"fmt"
+	"strconv"
 	"strings"
 	"time"
 
@@ -59,14 +60,14 @@ func output(_ context.Context, data *dataOut) (string, error) {
 	builder.WriteString(data.epochStart.Format("2006-01-02 15:04:05"))
 	if data.verbose {
 		builder.WriteString(" (")
-		builder.WriteString(fmt.Sprintf("%d", data.epochStart.Unix()))
+		builder.WriteString(strconv.FormatInt(data.epochStart.Unix(), 10))
 		builder.WriteString(")")
 	}
 	builder.WriteString("\n  Epoch end ")
 	builder.WriteString(data.epochEnd.Format("2006-01-02 15:04:05"))
 	if data.verbose {
 		builder.WriteString(" (")
-		builder.WriteString(fmt.Sprintf("%d", data.epochEnd.Unix()))
+		builder.WriteString(strconv.FormatInt(data.epochEnd.Unix(), 10))
 		builder.WriteString(")")
 	}
 
@@ -76,27 +77,27 @@ func output(_ context.Context, data *dataOut) (string, error) {
 	builder.WriteString(data.slotStart.Format("2006-01-02 15:04:05"))
 	if data.verbose {
 		builder.WriteString(" (")
-		builder.WriteString(fmt.Sprintf("%d", data.slotStart.Unix()))
+		builder.WriteString(strconv.FormatInt(data.slotStart.Unix(), 10))
 		builder.WriteString(")")
 	}
 	builder.WriteString("\n  Slot end ")
 	builder.WriteString(data.slotEnd.Format("2006-01-02 15:04:05"))
 	if data.verbose {
 		builder.WriteString(" (")
-		builder.WriteString(fmt.Sprintf("%d", data.slotEnd.Unix()))
+		builder.WriteString(strconv.FormatInt(data.slotEnd.Unix(), 10))
 		builder.WriteString(")")
 	}
 
 	if data.hasSyncCommittees {
 		builder.WriteString("\nSync committee period ")
-		builder.WriteString(fmt.Sprintf("%d", data.syncCommitteePeriod))
+		builder.WriteString(strconv.FormatUint(data.syncCommitteePeriod, 10))
 		builder.WriteString("\n  Sync committee period start ")
 		builder.WriteString(data.syncCommitteePeriodStart.Format("2006-01-02 15:04:05"))
 		builder.WriteString(" (epoch ")
 		builder.WriteString(fmt.Sprintf("%d", data.syncCommitteePeriodEpochStart))
 		if data.verbose {
 			builder.WriteString(", ")
-			builder.WriteString(fmt.Sprintf("%d", data.syncCommitteePeriodStart.Unix()))
+			builder.WriteString(strconv.FormatInt(data.syncCommitteePeriodStart.Unix(), 10))
 		}
 		builder.WriteString(")\n  Sync committee period end ")
 		builder.WriteString(data.syncCommitteePeriodEnd.Format("2006-01-02 15:04:05"))
@@ -104,7 +105,7 @@ func output(_ context.Context, data *dataOut) (string, error) {
 		builder.WriteString(fmt.Sprintf("%d", data.syncCommitteePeriodEpochEnd))
 		if data.verbose {
 			builder.WriteString(", ")
-			builder.WriteString(fmt.Sprintf("%d", data.syncCommitteePeriodEnd.Unix()))
+			builder.WriteString(strconv.FormatInt(data.syncCommitteePeriodEnd.Unix(), 10))
 		}
 		builder.WriteString(")")
 	}

cmd/chain/time/process.go

@@ -31,10 +31,11 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	}
 
 	eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       data.connection,
-		Timeout:       data.timeout,
-		AllowInsecure: data.allowInsecureConnections,
-		LogFallback:   !data.quiet,
+		Address:           data.connection,
+		Timeout:           data.timeout,
+		AllowInsecure:     data.allowInsecureConnections,
+		CustomSpecSupport: data.customSpecSupport,
+		LogFallback:       !data.quiet,
 	})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to connect to Ethereum 2 beacon node")
@@ -42,7 +43,7 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 
 	chainTime, err := standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to set up chaintime service")

cmd/chain/time/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2021 Weald Technology Trading
+// Copyright © 2021, 2024 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
@@ -15,8 +15,8 @@ package chaintime
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -26,7 +26,7 @@ func Run(cmd *cobra.Command) (string, error) {
 	ctx := context.Background()
 	dataIn, err := input(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain input")
+		return "", errors.Join(errors.New("failed to set up command"), err)
 	}
 
 	// Further errors do not need a usage report.
@@ -34,7 +34,12 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	dataOut, err := process(ctx, dataIn)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to process")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if viper.GetBool("quiet") {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := output(ctx, dataOut)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return results, nil

cmd/chain/verify/signedcontributionandproof/command.go

@@ -33,6 +33,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Input.
 	data string
@@ -60,9 +61,10 @@ type command struct {
 
 func newCommand(_ context.Context) (*command, error) {
 	c := &command{
-		quiet:   viper.GetBool("quiet"),
-		verbose: viper.GetBool("verbose"),
-		debug:   viper.GetBool("debug"),
+		quiet:             viper.GetBool("quiet"),
+		verbose:           viper.GetBool("verbose"),
+		debug:             viper.GetBool("debug"),
+		customSpecSupport: viper.GetBool("custom-spec"),
 	}
 
 	// Timeout.

cmd/chain/verify/signedcontributionandproof/process.go

@@ -22,6 +22,7 @@ import (
 	"os"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec/altair"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
@@ -86,10 +87,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the client.
 	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to beacon node")
@@ -103,29 +105,32 @@ func (c *command) setup(ctx context.Context) error {
 	}
 
 	stateID := fmt.Sprintf("%d", c.item.Message.Contribution.Slot)
-	validators, err := c.validatorsProvider.Validators(ctx,
-		stateID,
-		[]phase0.ValidatorIndex{c.item.Message.AggregatorIndex},
-	)
+	response, err := c.validatorsProvider.Validators(ctx, &api.ValidatorsOpts{
+		State:   stateID,
+		Indices: []phase0.ValidatorIndex{c.item.Message.AggregatorIndex},
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain validator information")
 	}
 
-	if len(validators) == 0 || validators[c.item.Message.AggregatorIndex] == nil {
+	if len(response.Data) == 0 || response.Data[c.item.Message.AggregatorIndex] == nil {
 		return nil
 	}
 	c.validatorKnown = true
-	c.validator = validators[c.item.Message.AggregatorIndex]
+	c.validator = response.Data[c.item.Message.AggregatorIndex]
 
 	// Obtain the sync committee
 	syncCommitteesProvider, isProvider := c.eth2Client.(eth2client.SyncCommitteesProvider)
 	if !isProvider {
 		return errors.New("connection does not provide sync committee information")
 	}
-	c.syncCommittee, err = syncCommitteesProvider.SyncCommittee(ctx, stateID)
+	syncCommitteeResponse, err := syncCommitteesProvider.SyncCommittee(ctx, &api.SyncCommitteeOpts{
+		State: stateID,
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain sync committee information")
 	}
+	c.syncCommittee = syncCommitteeResponse.Data
 
 	return nil
 }
@@ -137,11 +142,11 @@ func (c *command) isAggregator(ctx context.Context) (bool, error) {
 	if !isProvider {
 		return false, errors.New("connection does not provide spec information")
 	}
-	var err error
-	c.spec, err = specProvider.Spec(ctx)
+	specResponse, err := specProvider.Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return false, errors.Wrap(err, "failed to obtain spec information")
 	}
+	c.spec = specResponse.Data
 
 	tmp, exists := c.spec["SYNC_COMMITTEE_SIZE"]
 	if !exists {
@@ -226,16 +231,19 @@ func (c *command) confirmContributionSignature(ctx context.Context) error {
 		fmt.Fprintf(os.Stderr, "Contribution validator indices: %v (%d)\n", includedIndices, len(includedIndices))
 	}
 
-	includedValidators, err := c.validatorsProvider.Validators(ctx, "head", includedIndices)
+	response, err := c.validatorsProvider.Validators(ctx, &api.ValidatorsOpts{
+		State:   "head",
+		Indices: includedIndices,
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain subcommittee validators")
 	}
-	if len(includedValidators) == 0 {
+	if len(response.Data) == 0 {
 		return errors.New("obtained empty subcommittee validator list")
 	}
 
 	var aggregatePubKey *e2types.BLSPublicKey
-	for _, v := range includedValidators {
+	for _, v := range response.Data {
 		pubKeyBytes := make([]byte, 48)
 		copy(pubKeyBytes, v.Validator.PublicKey[:])
 		pubKey, err := e2types.BLSPublicKeyFromBytes(pubKeyBytes)

cmd/chain/verify/signedcontributionandproof/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2021 Weald Technology Trading.
+// Copyright © 2021, 2024 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
@@ -15,8 +15,8 @@ package chainverifysignedcontributionandproof
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -27,14 +27,19 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	c, err := newCommand(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to set up command")
+		return "", errors.Join(errors.New("failed to set up command"), err)
 	}
 
 	// 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")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if viper.GetBool("quiet") {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := c.output(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return results, nil

cmd/chaineth1votes.go

@@ -31,7 +31,7 @@ var chainEth1VotesCmd = &cobra.Command{
 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 {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := chaineth1votes.Run(cmd)
 		if err != nil {
 			return err

cmd/chaininfo.go

@@ -1,4 +1,4 @@
-// Copyright © 2020, 2022 Weald Technology Trading
+// Copyright © 2020 - 2024 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
@@ -20,6 +20,8 @@ import (
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
+	"github.com/attestantio/go-eth2-client/spec/bellatrix"
 	spec "github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -34,43 +36,45 @@ var chainInfoCmd = &cobra.Command{
     ethdo chain info
 
 In quiet mode this will return 0 if the chain information can be obtained, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
+	Run: func(_ *cobra.Command, _ []string) {
 		ctx := context.Background()
 
 		eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-			Address:       viper.GetString("connection"),
-			Timeout:       viper.GetDuration("timeout"),
-			AllowInsecure: viper.GetBool("allow-insecure-connections"),
-			LogFallback:   !viper.GetBool("quiet"),
+			Address:           viper.GetString("connection"),
+			Timeout:           viper.GetDuration("timeout"),
+			AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+			CustomSpecSupport: viper.GetBool("custom-spec"),
+			LogFallback:       !viper.GetBool("quiet"),
 		})
 		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 
-		config, err := eth2Client.(eth2client.SpecProvider).Spec(ctx)
+		specResponse, err := eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
 		errCheck(err, "Failed to obtain beacon chain specification")
 
-		genesis, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
+		genesisResponse, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx, &api.GenesisOpts{})
 		errCheck(err, "Failed to obtain beacon chain genesis")
 
-		fork, err := eth2Client.(eth2client.ForkProvider).Fork(ctx, "head")
+		forkResponse, err := eth2Client.(eth2client.ForkProvider).Fork(ctx, &api.ForkOpts{State: "head"})
 		errCheck(err, "Failed to obtain current fork")
 
 		if viper.GetBool("quiet") {
 			os.Exit(_exitSuccess)
 		}
 
-		if genesis.GenesisTime.Unix() == 0 {
+		if genesisResponse.Data.GenesisTime.Unix() == 0 {
 			fmt.Println("Genesis time: undefined")
 		} else {
-			fmt.Printf("Genesis time: %s\n", genesis.GenesisTime.Format(time.UnixDate))
-			outputIf(viper.GetBool("verbose"), fmt.Sprintf("Genesis timestamp: %v", genesis.GenesisTime.Unix()))
+			fmt.Printf("Genesis time: %s\n", genesisResponse.Data.GenesisTime.Format(time.UnixDate))
+			outputIf(viper.GetBool("verbose"), fmt.Sprintf("Genesis timestamp: %v", genesisResponse.Data.GenesisTime.Unix()))
 		}
-		fmt.Printf("Genesis validators root: %#x\n", genesis.GenesisValidatorsRoot)
-		fmt.Printf("Genesis fork version: %#x\n", config["GENESIS_FORK_VERSION"].(spec.Version))
-		fmt.Printf("Current fork version: %#x\n", fork.CurrentVersion)
+
+		fmt.Printf("Genesis validators root: %#x\n", genesisResponse.Data.GenesisValidatorsRoot)
+		fmt.Printf("Genesis fork version: %#x\n", specResponse.Data["GENESIS_FORK_VERSION"].(spec.Version))
+		fmt.Printf("Current fork version: %#x\n", forkResponse.Data.CurrentVersion)
 		if viper.GetBool("verbose") {
 			forkData := &spec.ForkData{
-				CurrentVersion:        fork.CurrentVersion,
-				GenesisValidatorsRoot: genesis.GenesisValidatorsRoot,
+				CurrentVersion:        forkResponse.Data.CurrentVersion,
+				GenesisValidatorsRoot: genesisResponse.Data.GenesisValidatorsRoot,
 			}
 			forkDataRoot, err := forkData.HashTreeRoot()
 			if err == nil {
@@ -79,8 +83,12 @@ In quiet mode this will return 0 if the chain information can be obtained, other
 				fmt.Printf("Fork digest: %#x\n", forkDigest)
 			}
 		}
-		fmt.Printf("Seconds per slot: %d\n", int(config["SECONDS_PER_SLOT"].(time.Duration).Seconds()))
-		fmt.Printf("Slots per epoch: %d\n", config["SLOTS_PER_EPOCH"].(uint64))
+		fmt.Printf("Seconds per slot: %d\n", int(specResponse.Data["SECONDS_PER_SLOT"].(time.Duration).Seconds()))
+		fmt.Printf("Slots per epoch: %d\n", specResponse.Data["SLOTS_PER_EPOCH"].(uint64))
+
+		depositContractAddress := bellatrix.ExecutionAddress{}
+		copy(depositContractAddress[:], specResponse.Data["DEPOSIT_CONTRACT_ADDRESS"].([]byte))
+		fmt.Printf("Deposit contract address: %s\n", depositContractAddress.String())
 
 		os.Exit(_exitSuccess)
 	},

cmd/chainqueues.go

@@ -29,7 +29,7 @@ var chainQueuesCmd = &cobra.Command{
     ethdo chain queues
 
 In quiet mode this will return 0 if the entry and exit queues are 0, otherwise 1.`,
-	RunE: func(cmd *cobra.Command, args []string) error {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := chainqueues.Run(cmd)
 		if err != nil {
 			return err

cmd/chainspec.go

@@ -18,9 +18,11 @@ import (
 	"encoding/json"
 	"fmt"
 	"sort"
+	"strconv"
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -35,18 +37,19 @@ var chainSpecCmd = &cobra.Command{
     ethdo chain spec
 
 In quiet mode this will return 0 if the chain specification can be obtained, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
+	Run: func(_ *cobra.Command, _ []string) {
 		ctx := context.Background()
 
 		eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-			Address:       viper.GetString("connection"),
-			Timeout:       viper.GetDuration("timeout"),
-			AllowInsecure: viper.GetBool("allow-insecure-connections"),
-			LogFallback:   !viper.GetBool("quiet"),
+			Address:           viper.GetString("connection"),
+			Timeout:           viper.GetDuration("timeout"),
+			AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+			CustomSpecSupport: viper.GetBool("custom-spec"),
+			LogFallback:       !viper.GetBool("quiet"),
 		})
 		errCheck(err, "Failed to connect to Ethereum consensus node")
 
-		spec, err := eth2Client.(eth2client.SpecProvider).Spec(ctx)
+		specResponse, err := eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
 		errCheck(err, "Failed to obtain chain specification")
 
 		if viper.GetBool("quiet") {
@@ -54,35 +57,35 @@ In quiet mode this will return 0 if the chain specification can be obtained, oth
 		}
 
 		// Tweak the spec for output.
-		for k, v := range spec {
+		for k, v := range specResponse.Data {
 			switch t := v.(type) {
 			case phase0.Version:
-				spec[k] = fmt.Sprintf("%#x", t)
+				specResponse.Data[k] = fmt.Sprintf("%#x", t)
 			case phase0.DomainType:
-				spec[k] = fmt.Sprintf("%#x", t)
+				specResponse.Data[k] = fmt.Sprintf("%#x", t)
 			case time.Time:
-				spec[k] = fmt.Sprintf("%d", t.Unix())
+				specResponse.Data[k] = strconv.FormatInt(t.Unix(), 10)
 			case time.Duration:
-				spec[k] = fmt.Sprintf("%d", uint64(t.Seconds()))
+				specResponse.Data[k] = strconv.FormatUint(uint64(t.Seconds()), 10)
 			case []byte:
-				spec[k] = fmt.Sprintf("%#x", t)
+				specResponse.Data[k] = fmt.Sprintf("%#x", t)
 			case uint64:
-				spec[k] = fmt.Sprintf("%d", t)
+				specResponse.Data[k] = strconv.FormatUint(t, 10)
 			}
 		}
 
 		if viper.GetBool("json") {
-			data, err := json.Marshal(spec)
+			data, err := json.Marshal(specResponse.Data)
 			errCheck(err, "Failed to marshal JSON")
 			fmt.Printf("%s\n", string(data))
 		} else {
-			keys := make([]string, 0, len(spec))
-			for k := range spec {
+			keys := make([]string, 0, len(specResponse.Data))
+			for k := range specResponse.Data {
 				keys = append(keys, k)
 			}
 			sort.Strings(keys)
 			for _, key := range keys {
-				fmt.Printf("%s: %v\n", key, spec[key])
+				fmt.Printf("%s: %v\n", key, specResponse.Data[key])
 			}
 		}
 	},

cmd/chainstatus.go

@@ -17,10 +17,12 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"strconv"
 	"strings"
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/spf13/cobra"
@@ -38,27 +40,31 @@ var chainStatusCmd = &cobra.Command{
     ethdo chain status
 
 In quiet mode this will return 0 if the chain status can be obtained, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
+	Run: func(_ *cobra.Command, _ []string) {
 		ctx := context.Background()
 
 		eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-			Address:       viper.GetString("connection"),
-			Timeout:       viper.GetDuration("timeout"),
-			AllowInsecure: viper.GetBool("allow-insecure-connections"),
-			LogFallback:   !viper.GetBool("quiet"),
+			Address:           viper.GetString("connection"),
+			Timeout:           viper.GetDuration("timeout"),
+			AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+			CustomSpecSupport: viper.GetBool("custom-spec"),
+			LogFallback:       !viper.GetBool("quiet"),
 		})
 		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 
 		chainTime, err := standardchaintime.New(ctx,
-			standardchaintime.WithGenesisTimeProvider(eth2Client.(eth2client.GenesisTimeProvider)),
+			standardchaintime.WithGenesisProvider(eth2Client.(eth2client.GenesisProvider)),
 			standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
 		)
 		errCheck(err, "Failed to configure chaintime service")
 
 		finalityProvider, isProvider := eth2Client.(eth2client.FinalityProvider)
 		assert(isProvider, "beacon node does not provide finality; cannot report on chain status")
-		finality, err := finalityProvider.Finality(ctx, "head")
+		finalityResponse, err := finalityProvider.Finality(ctx, &api.FinalityOpts{
+			State: "head",
+		})
 		errCheck(err, "Failed to obtain finality information")
+		finality := finalityResponse.Data
 
 		slot := chainTime.CurrentSlot()
 
@@ -126,13 +132,13 @@ In quiet mode this will return 0 if the chain status can be obtained, otherwise
 		if viper.GetBool("verbose") {
 			validatorsProvider, isProvider := eth2Client.(eth2client.ValidatorsProvider)
 			if isProvider {
-				validators, err := validatorsProvider.Validators(ctx, "head", nil)
+				validatorsResponse, err := validatorsProvider.Validators(ctx, &api.ValidatorsOpts{State: "head"})
 				errCheck(err, "Failed to obtain validators information")
 				// Stats of inteest.
 				totalBalance := phase0.Gwei(0)
 				activeEffectiveBalance := phase0.Gwei(0)
 				validatorCount := make(map[apiv1.ValidatorState]int)
-				for _, validator := range validators {
+				for _, validator := range validatorsResponse.Data {
 					validatorCount[validator.Status]++
 					totalBalance += validator.Balance
 					if validator.Status.IsActive() {
@@ -162,7 +168,7 @@ In quiet mode this will return 0 if the chain status can be obtained, otherwise
 			nextPeriodTimestamp := chainTime.StartOfEpoch(nextPeriodStartEpoch)
 
 			res.WriteString("Sync committee period: ")
-			res.WriteString(fmt.Sprintf("%d", period))
+			res.WriteString(strconv.FormatUint(period, 10))
 			res.WriteString("\n")
 
 			if viper.GetBool("verbose") {

cmd/chaintime.go

@@ -27,7 +27,7 @@ var chainTimeCmd = &cobra.Command{
 	Long: `Obtain info about the chain at a given time.  For example:
 
     ethdo chain time --slot=12345`,
-	RunE: func(cmd *cobra.Command, args []string) error {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := chaintime.Run(cmd)
 		if err != nil {
 			return err

cmd/chainverifysignedcontributionandproof.go

@@ -28,7 +28,7 @@ var chainVerifySignedContributionAndProofCmd = &cobra.Command{
     ethdo chain verify signedcontributionandproof --data=... --validator=...
 
 validator can be an account, a public key or an index.`,
-	RunE: func(cmd *cobra.Command, args []string) error {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := chainverifysignedcontributionandproof.Run(cmd)
 		if err != nil {
 			return err

cmd/depositverify.go

@@ -50,7 +50,7 @@ var depositVerifyCmd = &cobra.Command{
 The deposit data is compared to the supplied withdrawal account/public key, validator public key, and value to ensure they match.
 
 In quiet mode this will return 0 if the data is verified correctly, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
+	Run: func(_ *cobra.Command, _ []string) {
 		assert(depositVerifyData != "", "--data is required")
 		var data []byte
 		var err error

cmd/epoch/summary/command.go

@@ -34,6 +34,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Operation.
 	epoch      string
@@ -108,6 +109,7 @@ func newCommand(_ context.Context) (*command, error) {
 
 	c.connection = viper.GetString("connection")
 	c.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
+	c.customSpecSupport = viper.GetBool("custom-spec")
 
 	c.epoch = viper.GetString("epoch")
 	c.stream = viper.GetBool("stream")

cmd/epoch/summary/process.go

@@ -16,12 +16,13 @@ package epochsummary
 import (
 	"context"
 	"fmt"
+	"net/http"
 	"sort"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	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"
 	"github.com/pkg/errors"
 	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
@@ -55,14 +56,14 @@ func (c *command) process(ctx context.Context) error {
 }
 
 func (c *command) processProposerDuties(ctx context.Context) error {
-	duties, err := c.proposerDutiesProvider.ProposerDuties(ctx, c.summary.Epoch, nil)
+	response, err := c.proposerDutiesProvider.ProposerDuties(ctx, &api.ProposerDutiesOpts{
+		Epoch: c.summary.Epoch,
+	})
 	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 {
+
+	for _, duty := range response.Data {
 		block, err := c.fetchBlock(ctx, fmt.Sprintf("%d", duty.Slot))
 		if err != nil {
 			return errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", duty.Slot))
@@ -79,12 +80,14 @@ func (c *command) processProposerDuties(ctx context.Context) error {
 }
 
 func (c *command) activeValidators(ctx context.Context) (map[phase0.ValidatorIndex]*apiv1.Validator, error) {
-	validators, err := c.validatorsProvider.Validators(ctx, fmt.Sprintf("%d", c.chainTime.FirstSlotOfEpoch(c.summary.Epoch)), nil)
+	response, err := c.validatorsProvider.Validators(ctx, &api.ValidatorsOpts{
+		State: fmt.Sprintf("%d", c.chainTime.FirstSlotOfEpoch(c.summary.Epoch)),
+	})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain validators for epoch")
 	}
 	activeValidators := make(map[phase0.ValidatorIndex]*apiv1.Validator)
-	for _, validator := range validators {
+	for _, validator := range response.Data {
 		if validator.Validator.ActivationEpoch <= c.summary.Epoch && validator.Validator.ExitEpoch > c.summary.Epoch {
 			activeValidators[validator.Index] = validator
 		}
@@ -181,17 +184,23 @@ func (c *command) processSlots(ctx context.Context,
 			return 0, 0, 0, 0, 0, 0, nil, nil, 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) {
+			attestationData, err := attestation.Data()
+			if err != nil {
+				return 0, 0, 0, 0, 0, 0, nil, nil, errors.Wrap(err, fmt.Sprintf("failed to obtain attestation data for slot %d", slot))
+			}
+			if attestationData.Slot < c.chainTime.FirstSlotOfEpoch(c.summary.Epoch) || attestationData.Slot >= c.chainTime.FirstSlotOfEpoch(c.summary.Epoch+1) {
 				// Outside of this epoch's range.
 				continue
 			}
-			slotCommittees, exists := allCommittees[attestation.Data.Slot]
+			slotCommittees, exists := allCommittees[attestationData.Slot]
 			if !exists {
-				beaconCommittees, err := c.beaconCommitteesProvider.BeaconCommittees(ctx, fmt.Sprintf("%d", attestation.Data.Slot))
+				response, err := c.beaconCommitteesProvider.BeaconCommittees(ctx, &api.BeaconCommitteesOpts{
+					State: fmt.Sprintf("%d", attestationData.Slot),
+				})
 				if err != nil {
-					return 0, 0, 0, 0, 0, 0, nil, nil, errors.Wrap(err, fmt.Sprintf("failed to obtain committees for slot %d", attestation.Data.Slot))
+					return 0, 0, 0, 0, 0, 0, nil, nil, errors.Wrap(err, fmt.Sprintf("failed to obtain committees for slot %d", attestationData.Slot))
 				}
-				for _, beaconCommittee := range beaconCommittees {
+				for _, beaconCommittee := range response.Data {
 					if _, exists := allCommittees[beaconCommittee.Slot]; !exists {
 						allCommittees[beaconCommittee.Slot] = make(map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
 					}
@@ -204,22 +213,26 @@ func (c *command) processSlots(ctx context.Context,
 						}
 					}
 				}
-				slotCommittees = allCommittees[attestation.Data.Slot]
+				slotCommittees = allCommittees[attestationData.Slot]
 			}
-			committee := slotCommittees[attestation.Data.Index]
+			committee := slotCommittees[attestationData.Index]
 
-			inclusionDistance := slot - attestation.Data.Slot
-			headCorrect, err := util.AttestationHeadCorrect(ctx, headersCache, attestation)
+			inclusionDistance := slot - attestationData.Slot
+			headCorrect, err := util.AttestationHeadCorrect(ctx, headersCache, attestationData)
 			if err != nil {
 				return 0, 0, 0, 0, 0, 0, nil, nil, err
 			}
-			targetCorrect, err := util.AttestationTargetCorrect(ctx, headersCache, c.chainTime, attestation)
+			targetCorrect, err := util.AttestationTargetCorrect(ctx, headersCache, c.chainTime, attestationData)
 			if err != nil {
 				return 0, 0, 0, 0, 0, 0, nil, nil, err
 			}
 
-			for i := uint64(0); i < attestation.AggregationBits.Len(); i++ {
-				if attestation.AggregationBits.BitAt(i) {
+			aggregationBits, err := attestation.AggregationBits()
+			if err != nil {
+				return 0, 0, 0, 0, 0, 0, nil, nil, err
+			}
+			for i := uint64(0); i < aggregationBits.Len(); i++ {
+				if aggregationBits.BitAt(i) {
 					votes[committee[int(i)]] = struct{}{}
 					if _, exists := headCorrects[committee[int(i)]]; !exists && headCorrect {
 						headCorrects[committee[int(i)]] = struct{}{}
@@ -240,6 +253,7 @@ func (c *command) processSlots(ctx context.Context,
 			}
 		}
 	}
+
 	return len(votes),
 		len(headCorrects),
 		len(headTimelys),
@@ -257,10 +271,13 @@ func (c *command) processSyncCommitteeDuties(ctx context.Context) error {
 		return nil
 	}
 
-	committee, err := c.syncCommitteesProvider.SyncCommittee(ctx, fmt.Sprintf("%d", c.summary.FirstSlot))
+	committeeResponse, err := c.syncCommitteesProvider.SyncCommittee(ctx, &api.SyncCommitteeOpts{
+		State: fmt.Sprintf("%d", c.summary.FirstSlot),
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain sync committee")
 	}
+	committee := committeeResponse.Data
 	if len(committee.Validators) == 0 {
 		return errors.Wrap(err, "empty sync committee")
 	}
@@ -279,21 +296,14 @@ func (c *command) processSyncCommitteeDuties(ctx context.Context) error {
 			// If the block is missed we don't count the sync aggregate miss.
 			continue
 		}
-		var aggregate *altair.SyncAggregate
-		switch block.Version {
-		case spec.DataVersionPhase0:
+		if block.Version == 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
-		case spec.DataVersionCapella:
-			aggregate = block.Capella.Message.Body.SyncAggregate
-		case spec.DataVersionDeneb:
-			aggregate = block.Deneb.Message.Body.SyncAggregate
-		default:
-			return fmt.Errorf("unhandled block version %v", block.Version)
+		}
+
+		aggregate, err := block.SyncAggregate()
+		if err != nil {
+			return errors.Wrapf(err, "failed to obtain sync aggregate for slot %d", slot)
 		}
 		for i := uint64(0); i < aggregate.SyncCommitteeBits.Len(); i++ {
 			if !aggregate.SyncCommitteeBits.BitAt(i) {
@@ -330,10 +340,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the client.
 	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to beacon node")
@@ -341,7 +352,7 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return errors.Wrap(err, "failed to set up chaintime service")
@@ -389,7 +400,9 @@ func (c *command) processBlobs(ctx context.Context) error {
 		case spec.DataVersionPhase0, spec.DataVersionAltair, spec.DataVersionBellatrix, spec.DataVersionCapella:
 			// No blobs in these forks.
 		case spec.DataVersionDeneb:
-			c.summary.Blobs += len(block.Deneb.Message.Body.BlobKzgCommitments)
+			c.summary.Blobs += len(block.Deneb.Message.Body.BlobKZGCommitments)
+		case spec.DataVersionElectra:
+			c.summary.Blobs += len(block.Electra.Message.Body.BlobKZGCommitments)
 		default:
 			return fmt.Errorf("unhandled block version %v", block.Version)
 		}
@@ -407,10 +420,19 @@ func (c *command) fetchBlock(ctx context.Context,
 	block, exists := c.blocksCache[blockID]
 	if !exists {
 		var err error
-		block, err = c.blocksProvider.SignedBeaconBlock(ctx, blockID)
+		blockResponse, err := c.blocksProvider.SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+			Block: blockID,
+		})
 		if err != nil {
+			var apiErr *api.Error
+			if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+				// No block for this slot, that's okay.
+				return nil, nil
+			}
+
 			return nil, errors.Wrap(err, "failed to fetch block")
 		}
+		block = blockResponse.Data
 		c.blocksCache[blockID] = block
 	}
 	return block, nil

cmd/epoch/summary/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2022 Weald Technology Trading.
+// Copyright © 2022, 2024 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
@@ -15,8 +15,8 @@ package epochsummary
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -27,14 +27,19 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	c, err := newCommand(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to set up command")
+		return "", errors.Join(errors.New("failed to set up command"), err)
 	}
 
 	// 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")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if viper.GetBool("quiet") {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := c.output(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return results, nil

cmd/epochsummary.go

@@ -29,7 +29,7 @@ var epochSummaryCmd = &cobra.Command{
     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 {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := epochsummary.Run(cmd)
 		if err != nil {
 			return err

cmd/exitverify.go

@@ -21,6 +21,7 @@ import (
 	"strings"
 
 	consensusclient "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	v1 "github.com/attestantio/go-eth2-client/api/v1"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
@@ -38,7 +39,7 @@ var exitVerifyCmd = &cobra.Command{
     ethdo exit verify --signed-operation=exitdata.json --validator=primary/current
 
 In quiet mode this will return 0 if the exit is verified correctly, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
+	Run: func(_ *cobra.Command, _ []string) {
 		ctx := context.Background()
 
 		assert(viper.GetString("signed-operation") != "", "signed-operation is required")
@@ -46,10 +47,11 @@ In quiet mode this will return 0 if the exit is verified correctly, otherwise 1.
 		errCheck(err, "Failed to obtain signed operation")
 
 		eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-			Address:       viper.GetString("connection"),
-			Timeout:       viper.GetDuration("timeout"),
-			AllowInsecure: viper.GetBool("allow-insecure-connections"),
-			LogFallback:   !viper.GetBool("quiet"),
+			Address:           viper.GetString("connection"),
+			Timeout:           viper.GetDuration("timeout"),
+			AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+			CustomSpecSupport: viper.GetBool("custom-spec"),
+			LogFallback:       !viper.GetBool("quiet"),
 		})
 		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 
@@ -67,10 +69,11 @@ In quiet mode this will return 0 if the exit is verified correctly, otherwise 1.
 		opRoot, err := signedOp.Message.HashTreeRoot()
 		errCheck(err, "Failed to obtain exit hash tree root")
 
-		genesis, err := eth2Client.(consensusclient.GenesisProvider).Genesis(ctx)
+		genesisResponse, err := eth2Client.(consensusclient.GenesisProvider).Genesis(ctx, &api.GenesisOpts{})
 		errCheck(err, "Failed to obtain beacon chain genesis")
+		genesis := genesisResponse.Data
 
-		fork, err := eth2Client.(consensusclient.ForkProvider).Fork(ctx, "head")
+		response, err := eth2Client.(consensusclient.ForkProvider).Fork(ctx, &api.ForkOpts{State: "head"})
 		errCheck(err, "Failed to obtain fork information")
 
 		// Check against current and prior fork versions.
@@ -83,14 +86,14 @@ In quiet mode this will return 0 if the exit is verified correctly, otherwise 1.
 
 		// Try with the current fork.
 		domain := phase0.Domain{}
-		currentExitDomain, err := e2types.ComputeDomain(e2types.DomainVoluntaryExit, fork.CurrentVersion[:], genesis.GenesisValidatorsRoot[:])
+		currentExitDomain, err := e2types.ComputeDomain(e2types.DomainVoluntaryExit, response.Data.CurrentVersion[:], genesis.GenesisValidatorsRoot[:])
 		errCheck(err, "Failed to compute domain")
 		copy(domain[:], currentExitDomain)
 		verified, err = util.VerifyRoot(account, opRoot, domain, sig)
 		errCheck(err, "Failed to verify voluntary exit")
 		if !verified {
 			// Try again with the previous fork.
-			previousExitDomain, err := e2types.ComputeDomain(e2types.DomainVoluntaryExit, fork.PreviousVersion[:], genesis.GenesisValidatorsRoot[:])
+			previousExitDomain, err := e2types.ComputeDomain(e2types.DomainVoluntaryExit, response.Data.PreviousVersion[:], genesis.GenesisValidatorsRoot[:])
 			copy(domain[:], previousExitDomain)
 			errCheck(err, "Failed to compute domain")
 			verified, err = util.VerifyRoot(account, opRoot, domain, sig)

cmd/node/events/input.go

@@ -51,10 +51,11 @@ func input(ctx context.Context) (*dataIn, error) {
 
 	var err error
 	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       viper.GetString("connection"),
-		Timeout:       viper.GetDuration("timeout"),
-		AllowInsecure: viper.GetBool("allow-insecure-connections"),
-		LogFallback:   !data.quiet,
+		Address:           viper.GetString("connection"),
+		Timeout:           viper.GetDuration("timeout"),
+		AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+		CustomSpecSupport: viper.GetBool("custom-spec"),
+		LogFallback:       !data.quiet,
 	})
 	if err != nil {
 		return nil, err

cmd/node/events/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019 - 2024 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
@@ -15,8 +15,8 @@ package nodeevents
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 )
 
@@ -25,14 +25,19 @@ func Run(cmd *cobra.Command) (string, error) {
 	ctx := context.Background()
 	dataIn, err := input(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain input")
+		return "", errors.Join(errors.New("failed to set up command"), err)
 	}
 
 	// Further errors do not need a usage report.
 	cmd.SilenceUsage = true
 
 	if err := process(ctx, dataIn); err != nil {
-		return "", errors.Wrap(err, "failed to process")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	// Process generates all output.

cmd/nodeevents.go

@@ -27,7 +27,7 @@ var nodeEventsCmd = &cobra.Command{
 	Long: `Report events from a node.  For example:
 
     ethdo node events --events=head,chain_reorg.`,
-	RunE: func(cmd *cobra.Command, args []string) error {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := nodeevents.Run(cmd)
 		if err != nil {
 			return err

cmd/nodeinfo.go

@@ -19,6 +19,7 @@ import (
 	"os"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"github.com/wealdtech/ethdo/util"
@@ -32,14 +33,15 @@ var nodeInfoCmd = &cobra.Command{
     ethdo node info
 
 In quiet mode this will return 0 if the node information can be obtained, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
+	Run: func(_ *cobra.Command, _ []string) {
 		ctx := context.Background()
 
 		eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-			Address:       viper.GetString("connection"),
-			Timeout:       viper.GetDuration("timeout"),
-			AllowInsecure: viper.GetBool("allow-insecure-connections"),
-			LogFallback:   !viper.GetBool("quiet"),
+			Address:           viper.GetString("connection"),
+			Timeout:           viper.GetDuration("timeout"),
+			AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+			CustomSpecSupport: viper.GetBool("custom-spec"),
+			LogFallback:       !viper.GetBool("quiet"),
 		})
 		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 
@@ -48,14 +50,14 @@ In quiet mode this will return 0 if the node information can be obtained, otherw
 		}
 
 		if viper.GetBool("verbose") {
-			version, err := eth2Client.(eth2client.NodeVersionProvider).NodeVersion(ctx)
+			versionResponse, err := eth2Client.(eth2client.NodeVersionProvider).NodeVersion(ctx, &api.NodeVersionOpts{})
 			errCheck(err, "Failed to obtain node version")
-			fmt.Printf("Version: %s\n", version)
+			fmt.Printf("Version: %s\n", versionResponse.Data)
 		}
 
-		syncState, err := eth2Client.(eth2client.NodeSyncingProvider).NodeSyncing(ctx)
+		syncStateResponse, err := eth2Client.(eth2client.NodeSyncingProvider).NodeSyncing(ctx, &api.NodeSyncingOpts{})
 		errCheck(err, "failed to obtain node sync state")
-		fmt.Printf("Syncing: %t\n", syncState.SyncDistance != 0)
+		fmt.Printf("Syncing: %t\n", syncStateResponse.Data.SyncDistance != 0)
 
 		os.Exit(_exitSuccess)
 	},

cmd/proposer/duties/command.go

@@ -34,6 +34,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Operation.
 	epoch      string
@@ -62,6 +63,7 @@ func newCommand(_ context.Context) (*command, error) {
 		timeout:                  viper.GetDuration("timeout"),
 		connection:               viper.GetString("connection"),
 		allowInsecureConnections: viper.GetBool("allow-insecure-connections"),
+		customSpecSupport:        viper.GetBool("custom-spec"),
 		epoch:                    viper.GetString("epoch"),
 		slot:                     viper.GetString("slot"),
 		jsonOutput:               viper.GetBool("json"),

cmd/proposer/duties/process.go

@@ -17,6 +17,7 @@ import (
 	"context"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
 	"github.com/pkg/errors"
 	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
@@ -45,14 +46,16 @@ func (c *command) processSlot(ctx context.Context) error {
 
 	c.results.Epoch = c.chainTime.SlotToEpoch(slot)
 
-	duties, err := c.proposerDutiesProvider.ProposerDuties(ctx, c.results.Epoch, nil)
+	response, err := c.proposerDutiesProvider.ProposerDuties(ctx, &api.ProposerDutiesOpts{
+		Epoch: c.results.Epoch,
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain proposer duties")
 	}
 
 	c.results.Duties = make([]*apiv1.ProposerDuty, 0, 1)
 
-	for _, duty := range duties {
+	for _, duty := range response.Data {
 		if duty.Slot == slot {
 			c.results.Duties = append(c.results.Duties, duty)
 			break
@@ -69,10 +72,13 @@ func (c *command) processEpoch(ctx context.Context) error {
 		return errors.Wrap(err, "failed to parse epoch")
 	}
 
-	c.results.Duties, err = c.proposerDutiesProvider.ProposerDuties(ctx, c.results.Epoch, nil)
+	dutiesResponse, err := c.proposerDutiesProvider.ProposerDuties(ctx, &api.ProposerDutiesOpts{
+		Epoch: c.results.Epoch,
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain proposer duties")
 	}
+	c.results.Duties = dutiesResponse.Data
 
 	return nil
 }
@@ -82,10 +88,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the client.
 	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to beacon node")
@@ -93,7 +100,7 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return errors.Wrap(err, "failed to set up chaintime service")

cmd/proposer/duties/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2022 Weald Technology Trading.
+// Copyright © 2022, 2024 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
@@ -15,8 +15,8 @@ package proposerduties
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -27,14 +27,19 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	c, err := newCommand(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to set up command")
+		return "", errors.Join(errors.New("failed to set up command"), err)
 	}
 
 	// 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")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if viper.GetBool("quiet") {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := c.output(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return results, nil

cmd/proposerduties.go

@@ -29,7 +29,7 @@ var proposerDutiesCmd = &cobra.Command{
     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 {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := proposerduties.Run(cmd)
 		if err != nil {
 			return err

cmd/root.go

@@ -136,6 +136,7 @@ func init() {
 	addPersistentFlags()
 }
 
+//nolint:gocyclo
 func addPersistentFlags() {
 	RootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.ethdo.yaml)")
 
@@ -252,6 +253,10 @@ func addPersistentFlags() {
 	if err := viper.BindPFlag("allow-insecure-connections", RootCmd.PersistentFlags().Lookup("allow-insecure-connections")); err != nil {
 		panic(err)
 	}
+	RootCmd.PersistentFlags().Bool("custom-spec", false, "allow custom (non-mainnet) beacon node specifications")
+	if err := viper.BindPFlag("custom-spec", RootCmd.PersistentFlags().Lookup("custom-spec")); err != nil {
+		panic(err)
+	}
 }
 
 // initConfig reads in config file and ENV variables if set.

cmd/signatureaggregate.go

@@ -40,7 +40,7 @@ var signatureAggregateCmd = &cobra.Command{
 Signatures are specified as "signature" for simple aggregation, and as "id:signature" for threshold aggregation.
 
 In quiet mode this will return 0 if the signatures can be aggregated, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
+	Run: func(_ *cobra.Command, _ []string) {
 		assert(len(signatureAggregateSignatures) > 1, "multiple signatures required to aggregate")
 		var signature *bls.Sign
 		var err error

cmd/signaturesign.go

@@ -36,7 +36,7 @@ var signatureSignCmd = &cobra.Command{
     ethdo signature sign --data=0x5f24e819400c6a8ee2bfc014343cd971b7eb707320025a7bcd83e621e26c35b7 --account="Personal wallet/Operations" --passphrase="my account passphrase"
 
 In quiet mode this will return 0 if the data can be signed, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
+	Run: func(_ *cobra.Command, _ []string) {
 		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 		defer cancel()
 

cmd/signatureverify.go

@@ -41,7 +41,7 @@ var signatureVerifyCmd = &cobra.Command{
     ethdo signature verify --data=0x5f24e819400c6a8ee2bfc014343cd971b7eb707320025a7bcd83e621e26c35b7 --signature=0x8888... --account="Personal wallet/Operations"
 
 In quiet mode this will return 0 if the data can be signed, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
+	Run: func(_ *cobra.Command, _ []string) {
 		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 		defer cancel()
 

cmd/slot/time/input.go

@@ -53,10 +53,11 @@ func input(ctx context.Context) (*dataIn, error) {
 	// Ethereum 2 client.
 	var err error
 	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       viper.GetString("connection"),
-		Timeout:       viper.GetDuration("timeout"),
-		AllowInsecure: viper.GetBool("allow-insecure-connections"),
-		LogFallback:   !data.quiet,
+		Address:           viper.GetString("connection"),
+		Timeout:           viper.GetDuration("timeout"),
+		AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+		CustomSpecSupport: viper.GetBool("custom-spec"),
+		LogFallback:       !data.quiet,
 	})
 	if err != nil {
 		return nil, err

cmd/slot/time/process.go

@@ -19,6 +19,7 @@ import (
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/pkg/errors"
 )
 
@@ -41,17 +42,18 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		return nil, errors.New("slot must be a positive integer")
 	}
 
-	genesis, err := data.eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
+	genesisResponse, err := data.eth2Client.(eth2client.GenesisProvider).Genesis(ctx, &api.GenesisOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain genesis information")
 	}
+	genesis := genesisResponse.Data
 
-	config, err := data.eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	specResponse, err := data.eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain chain specifications")
 	}
 
-	slotDuration := config["SECONDS_PER_SLOT"].(time.Duration)
+	slotDuration := specResponse.Data["SECONDS_PER_SLOT"].(time.Duration)
 
 	results.startTime = genesis.GenesisTime.Add((time.Duration(slot*int64(slotDuration.Seconds())) * time.Second))
 	results.endTime = results.startTime.Add(slotDuration)

cmd/slot/time/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2021 Weald Technology Trading
+// Copyright © 2021, 2024 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
@@ -15,8 +15,8 @@ package slottime
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -26,7 +26,7 @@ func Run(cmd *cobra.Command) (string, error) {
 	ctx := context.Background()
 	dataIn, err := input(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain input")
+		return "", errors.Join(errors.New("failed to set up command"), err)
 	}
 
 	// Further errors do not need a usage report.
@@ -34,7 +34,12 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	dataOut, err := process(ctx, dataIn)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to process")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if viper.GetBool("quiet") {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := output(ctx, dataOut)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return results, nil

cmd/slottime.go

@@ -29,7 +29,7 @@ var slotTimeCmd = &cobra.Command{
     ethdo slot time --slot=12345
 
 In quiet mode this will return 0.`,
-	RunE: func(cmd *cobra.Command, args []string) error {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := slottime.Run(cmd)
 		if err != nil {
 			return err

cmd/synccommittee/inclusion/command.go

@@ -33,6 +33,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Input.
 	validator string
@@ -51,9 +52,10 @@ type command struct {
 
 func newCommand(_ context.Context) (*command, error) {
 	c := &command{
-		quiet:   viper.GetBool("quiet"),
-		verbose: viper.GetBool("verbose"),
-		debug:   viper.GetBool("debug"),
+		quiet:             viper.GetBool("quiet"),
+		verbose:           viper.GetBool("verbose"),
+		debug:             viper.GetBool("debug"),
+		customSpecSupport: viper.GetBool("custom-spec"),
 	}
 
 	// Timeout.

cmd/synccommittee/inclusion/output.go

@@ -16,6 +16,7 @@ package inclusion
 import (
 	"context"
 	"fmt"
+	"strconv"
 	"strings"
 )
 
@@ -53,13 +54,13 @@ func (c *command) output(_ context.Context) (string, error) {
 			}
 		}
 		builder.WriteString("Expected: ")
-		builder.WriteString(fmt.Sprintf("%d", len(c.inclusions)))
+		builder.WriteString(strconv.Itoa(len(c.inclusions)))
 		builder.WriteString("\nIncluded: ")
-		builder.WriteString(fmt.Sprintf("%d", included))
+		builder.WriteString(strconv.Itoa(included))
 		builder.WriteString("\nMissed: ")
-		builder.WriteString(fmt.Sprintf("%d", missed))
+		builder.WriteString(strconv.Itoa(missed))
 		builder.WriteString("\nNo block: ")
-		builder.WriteString(fmt.Sprintf("%d", noBlock))
+		builder.WriteString(strconv.Itoa(noBlock))
 
 		builder.WriteString("\nPer-slot result: ")
 		for i, inclusion := range c.inclusions {

cmd/synccommittee/inclusion/process.go

@@ -16,8 +16,10 @@ package inclusion
 import (
 	"context"
 	"fmt"
+	"net/http"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/altair"
 	"github.com/pkg/errors"
@@ -41,10 +43,14 @@ func (c *command) process(ctx context.Context) error {
 		return err
 	}
 
-	syncCommittee, err := c.eth2Client.(eth2client.SyncCommitteesProvider).SyncCommitteeAtEpoch(ctx, "head", c.epoch)
+	syncCommitteeResponse, err := c.eth2Client.(eth2client.SyncCommitteesProvider).SyncCommittee(ctx, &api.SyncCommitteeOpts{
+		State: "head",
+		Epoch: &c.epoch,
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain sync committee information")
 	}
+	syncCommittee := syncCommitteeResponse.Data
 
 	if syncCommittee == nil {
 		return errors.New("no sync committee returned")
@@ -67,10 +73,19 @@ func (c *command) process(ctx context.Context) error {
 			lastSlot = c.chainTime.CurrentSlot()
 		}
 		for slot := firstSlot; slot <= lastSlot; slot++ {
-			block, err := c.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, fmt.Sprintf("%d", slot))
+			blockResponse, err := c.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+				Block: fmt.Sprintf("%d", slot),
+			})
 			if err != nil {
-				return err
+				var apiErr *api.Error
+				if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+					c.inclusions = append(c.inclusions, 0)
+					continue
+				}
+				return errors.Wrap(err, "failed to obtain beacon block")
 			}
+
+			block := blockResponse.Data
 			if block == nil {
 				c.inclusions = append(c.inclusions, 0)
 				continue
@@ -105,6 +120,13 @@ func (c *command) process(ctx context.Context) error {
 				} else {
 					c.inclusions = append(c.inclusions, 2)
 				}
+			case spec.DataVersionElectra:
+				aggregate = block.Electra.Message.Body.SyncAggregate
+				if aggregate.SyncCommitteeBits.BitAt(c.committeeIndex) {
+					c.inclusions = append(c.inclusions, 1)
+				} else {
+					c.inclusions = append(c.inclusions, 2)
+				}
 			default:
 				return fmt.Errorf("unhandled block version %v", block.Version)
 			}
@@ -119,10 +141,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the client.
 	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return err
@@ -130,7 +153,7 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return errors.Wrap(err, "failed to set up chaintime service")

cmd/synccommittee/inclusion/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2022 Weald Technology Trading.
+// Copyright © 2022, 2024 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
@@ -15,8 +15,8 @@ package inclusion
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -27,14 +27,19 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	c, err := newCommand(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to set up command")
+		return "", errors.Join(errors.New("failed to set up command"), err)
 	}
 
 	// 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")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if viper.GetBool("quiet") {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := c.output(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return results, nil

cmd/synccommittee/members/input.go

@@ -52,10 +52,11 @@ func input(ctx context.Context) (*dataIn, error) {
 	// Ethereum 2 client.
 	var err error
 	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       viper.GetString("connection"),
-		Timeout:       viper.GetDuration("timeout"),
-		AllowInsecure: viper.GetBool("allow-insecure-connections"),
-		LogFallback:   !data.quiet,
+		Address:           viper.GetString("connection"),
+		Timeout:           viper.GetDuration("timeout"),
+		AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+		CustomSpecSupport: viper.GetBool("custom-spec"),
+		LogFallback:       !data.quiet,
 	})
 	if err != nil {
 		return nil, err
@@ -63,7 +64,7 @@ func input(ctx context.Context) (*dataIn, error) {
 
 	// Chain time.
 	data.chainTime, err = standardchaintime.New(ctx,
-		standardchaintime.WithGenesisTimeProvider(data.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(data.eth2Client.(eth2client.GenesisProvider)),
 		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
 	)
 	if err != nil {

cmd/synccommittee/members/process.go

@@ -19,6 +19,7 @@ import (
 	"strings"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/wealdtech/ethdo/util"
@@ -34,10 +35,14 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		return nil, err
 	}
 
-	syncCommittee, err := data.eth2Client.(eth2client.SyncCommitteesProvider).SyncCommitteeAtEpoch(ctx, "head", epoch)
+	syncCommitteeResponse, err := data.eth2Client.(eth2client.SyncCommitteesProvider).SyncCommittee(ctx, &api.SyncCommitteeOpts{
+		State: "head",
+		Epoch: &epoch,
+	})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain sync committee information")
 	}
+	syncCommittee := syncCommitteeResponse.Data
 
 	if syncCommittee == nil {
 		return nil, errors.New("no sync committee returned")

cmd/synccommittee/members/process_internal_test.go

@@ -36,7 +36,7 @@ func TestProcess(t *testing.T) {
 	require.NoError(t, err)
 
 	chainTime, err := standardchaintime.New(context.Background(),
-		standardchaintime.WithGenesisTimeProvider(eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(eth2Client.(eth2client.GenesisProvider)),
 		standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
 	)
 	require.NoError(t, err)

cmd/synccommittee/members/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2021 Weald Technology Trading
+// Copyright © 2021, 2024 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
@@ -15,8 +15,8 @@ package members
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -26,7 +26,7 @@ func Run(cmd *cobra.Command) (string, error) {
 	ctx := context.Background()
 	dataIn, err := input(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain input")
+		return "", errors.Join(errors.New("failed to set up command"), err)
 	}
 
 	// Further errors do not need a usage report.
@@ -34,7 +34,12 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	dataOut, err := process(ctx, dataIn)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to process")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if viper.GetBool("quiet") {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := output(ctx, dataOut)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return results, nil

cmd/synccommitteeinclusion.go

@@ -31,7 +31,7 @@ var synccommitteeInclusionCmd = &cobra.Command{
 In quiet mode this will return 0 if the validator was in the sync committee, otherwise 1.
 
 epoch can be a specific epoch; If not supplied all slots for the current sync committee period will be provided`,
-	RunE: func(cmd *cobra.Command, args []string) error {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := synccommitteeinclusion.Run(cmd)
 		if err != nil {
 			return err

cmd/synccommitteemembers.go

@@ -31,7 +31,7 @@ var synccommitteeMembersCmd = &cobra.Command{
 In quiet mode this will return 0 if the synccommittee members are found, otherwise 1.
 
 epoch can be a specific epoch.  period can be 'current' for the current sync period or 'next' for the next sync period`,
-	RunE: func(cmd *cobra.Command, args []string) error {
+	RunE: func(cmd *cobra.Command, _ []string) error {
 		res, err := synccommitteemembers.Run(cmd)
 		if err != nil {
 			return err
@@ -49,7 +49,7 @@ epoch can be a specific epoch.  period can be 'current' for the current sync per
 func init() {
 	synccommitteeCmd.AddCommand(synccommitteeMembersCmd)
 	synccommitteeFlags(synccommitteeMembersCmd)
-	synccommitteeMembersCmd.Flags().Int64("epoch", -1, "the epoch for which to fetch sync committees")
+	synccommitteeMembersCmd.Flags().String("epoch", "", "the epoch for which to fetch sync committees")
 	synccommitteeMembersCmd.Flags().String("period", "", "the sync committee period for which to fetch sync committees ('current', 'next')")
 }
 

cmd/validator/credentials/get/command.go

@@ -35,6 +35,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Data access.
 	consensusClient    eth2client.Service
@@ -46,9 +47,10 @@ type command struct {
 
 func newCommand(_ context.Context) (*command, error) {
 	c := &command{
-		quiet:   viper.GetBool("quiet"),
-		verbose: viper.GetBool("verbose"),
-		debug:   viper.GetBool("debug"),
+		quiet:             viper.GetBool("quiet"),
+		verbose:           viper.GetBool("verbose"),
+		debug:             viper.GetBool("debug"),
+		customSpecSupport: viper.GetBool("custom-spec"),
 	}
 
 	// Timeout.

cmd/validator/credentials/get/output.go

@@ -15,6 +15,7 @@ package validatorcredentialsget
 
 import (
 	"context"
+	"encoding/hex"
 	"fmt"
 	"strings"
 
@@ -47,7 +48,7 @@ func (c *command) output(_ context.Context) (string, error) {
 
 // addressBytesToEIP55 converts a byte array in to an EIP-55 string format.
 func addressBytesToEIP55(address []byte) string {
-	bytes := []byte(fmt.Sprintf("%x", address))
+	bytes := []byte(hex.EncodeToString(address))
 	hash := ethutil.Keccak256(bytes)
 	for i := 0; i < len(bytes); i++ {
 		hashByte := hash[i/2]

cmd/validator/credentials/get/process.go

@@ -49,10 +49,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the consensus node.
 	c.consensusClient, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to consensus node")

cmd/validator/credentials/get/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2022 Weald Technology Trading.
+// Copyright © 2022, 2024 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
@@ -15,8 +15,8 @@ package validatorcredentialsget
 
 import (
 	"context"
+	"errors"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -27,14 +27,19 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	c, err := newCommand(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to set up command")
+		return "", errors.Join(errors.New("failed to set up command"), err)
 	}
 
 	// 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")
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
 	}
 
 	if viper.GetBool("quiet") {
@@ -43,7 +48,7 @@ func Run(cmd *cobra.Command) (string, error) {
 
 	results, err := c.output(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain output")
+		return "", errors.Join(errors.New("failed to obtain output"), err)
 	}
 
 	return results, nil

cmd/validator/credentials/set/command.go

@@ -48,11 +48,13 @@ type command struct {
 	genesisValidatorsRoot string
 	prepareOffline        bool
 	signedOperationsInput string
+	maxDistance           uint64
 
 	// Beacon node connection.
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Information required to generate the operations.
 	withdrawalAddress bellatrix.ExecutionAddress
@@ -77,6 +79,7 @@ func newCommand(_ context.Context) (*command, error) {
 		timeout:                  viper.GetDuration("timeout"),
 		connection:               viper.GetString("connection"),
 		allowInsecureConnections: viper.GetBool("allow-insecure-connections"),
+		customSpecSupport:        viper.GetBool("custom-spec"),
 		prepareOffline:           viper.GetBool("prepare-offline"),
 		account:                  viper.GetString("account"),
 		withdrawalAccount:        viper.GetString("withdrawal-account"),
@@ -90,6 +93,7 @@ func newCommand(_ context.Context) (*command, error) {
 		withdrawalAddressStr:  viper.GetString("withdrawal-address"),
 		forkVersion:           viper.GetString("fork-version"),
 		genesisValidatorsRoot: viper.GetString("genesis-validators-root"),
+		maxDistance:           viper.GetUint64("max-distance"),
 	}
 
 	// Timeout is required.