Return on error.

Add maxDistance as an input parameter

.github/workflows/docker.yml

@@ -0,0 +1,58 @@
+name: Docker
+
+on:
+  push:
+
+jobs:
+  # Set variables that will be available to all builds.
+  env_vars:
+    runs-on: ubuntu-latest
+    outputs:
+      release_version: ${{ steps.release_version.outputs.release_version }}
+      binary: ${{ steps.binary.outputs.binary }}
+    steps:
+      - id: release_version
+        run: |
+          RELEASE_VERSION=$(echo ${{ github.ref_name }} | sed -e 's/^[vt]//')
+          echo "release_version=${RELEASE_VERSION}" >> $GITHUB_OUTPUT
+      - id: binary
+        run: |
+          BINARY=$(basename ${{ github.repository }})
+          echo "binary=${BINARY}" >> $GITHUB_OUTPUT
+
+  # Build.
+  build:
+    runs-on: ubuntu-latest
+    needs: [env_vars]
+    steps:
+      - name: Check out repository into the Go module directory
+        uses: actions/checkout@v3
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64/v8
+          push: true
+          tags: wealdtech/ethdo:latest
+
+      - name: build and push on release
+        uses: docker/build-push-action@v4
+        if: ${{ github.event.release.tag_name != '' }}
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64/v8
+          push: true
+          tags: wealdtech/ethdo:${{ github.event.release.tag_name }}

.github/workflows/golangci-lint.yml

@@ -1,24 +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.19
-      - 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:
-          version: latest
-          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.19
+          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 }}
@@ -59,7 +59,11 @@ jobs:
 
       - name: Compile
         run: |
-          go build -tags osusergo,netgo -ldflags="-extldflags=-static" -v -ldflags="-X github.com/${{ github.repository }}/cmd.ReleaseVersion=${{ needs.env_vars.outputs.release_version }}"
+          # Do not attempt to upgrade grub, as it errors on github (24th Feb 2023)
+          sudo apt-mark hold grub-efi-amd64-signed grub-efi-amd64-bin
+          sudo apt-get update
+          sudo apt-get upgrade
+          go build -tags osusergo,netgo -v -ldflags="-X github.com/${{ github.repository }}/cmd.ReleaseVersion=${{ needs.env_vars.outputs.release_version }} -extldflags -static"
           tar zcf ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-linux-amd64.tar.gz ${{ needs.env_vars.outputs.binary }}
           sha256sum ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-linux-amd64.tar.gz | sed -e 's/ .*//' >${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-linux-amd64.tar.gz.sha256
       - name: Upload binary
@@ -84,8 +88,8 @@ jobs:
 
       - name: Cross compile (ARM64)
         run: |
-          apt install -y gcc-aarch64-linux-gnu libstdc++-12-pic-arm64-cross
-          CGO_ENABLED=1 CC=aarch64-linux-gnu-gcc GOOS=linux GOARCH=arm64 go build -tags osusergo,netgo -ldflags="-extldflags=-static" -v -ldflags="-X github.com/${{ github.repository }}/cmd.ReleaseVersion=${{ needs.env_vars.outputs.release_version }}"
+          sudo apt install -y gcc-aarch64-linux-gnu libstdc++-11-pic-arm64-cross
+          CGO_ENABLED=1 CC=aarch64-linux-gnu-gcc GOOS=linux GOARCH=arm64 go build -tags osusergo,netgo -v -ldflags="-X github.com/${{ github.repository }}/cmd.ReleaseVersion=${{ needs.env_vars.outputs.release_version }} -extldflags -static"
           tar zcf ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-linux-arm64.tar.gz ${{ needs.env_vars.outputs.binary }}
           sha256sum ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-linux-arm64.tar.gz | sed -e 's/ .*//' >${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-linux-arm64.tar.gz.sha256
 
@@ -115,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.19
+          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 }}
@@ -130,7 +134,7 @@ jobs:
 
       - name: Compile
         run: |
-          go build -tags osusergo,netgo -ldflags="-extldflags=-static" -v -ldflags="-X github.com/${{ github.repository }}/cmd.ReleaseVersion=${{ needs.env_vars.outputs.release_version }}"
+          go build -tags osusergo,netgo -v -ldflags="-X github.com/${{ github.repository }}/cmd.ReleaseVersion=${{ needs.env_vars.outputs.release_version }}"
           tar zcf ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-darwin-amd64.tar.gz ${{ needs.env_vars.outputs.binary }}
           brew install coreutils
           sha256sum ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-darwin-amd64.tar.gz | sed -e 's/ .*//' >${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-darwin-amd64.tar.gz.sha256
@@ -160,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.19
+          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 }}
@@ -175,7 +179,7 @@ jobs:
 
       - name: Compile
         run: |
-          go build -tags osusergo,netgo -ldflags="-extldflags=-static" -v -ldflags="-X github.com/${{ github.repository }}/cmd.ReleaseVersion=${{ needs.env_vars.outputs.release_version }}"
+          go build -v -ldflags="-X github.com/${{ github.repository }}/cmd.ReleaseVersion=${{ needs.env_vars.outputs.release_version }} -extldflags -static"
           choco install zip
           zip --junk-paths ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-windows-exe.zip ${{ needs.env_vars.outputs.binary }}.exe
           $FileHash=(certutil -hashfile ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-windows-exe.zip SHA256 | findstr /v hash | findstr /v SHA).replace(" ", "")

.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.19
-      - uses: actions/checkout@v3
+          go-version: '^1.21'
+      - uses: actions/checkout@v4
       - uses: n8maninger/action-golang-test@v1

.golangci.yml

@@ -0,0 +1,175 @@
+# This file contains all available configuration options
+# with their default values (in comments).
+#
+# 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.
+  # concurrency: 4
+
+  # Timeout for analysis, e.g. 30s, 5m.
+  # Default: 1m
+  timeout: 10m
+
+  # Exit code when at least one issue was found.
+  # Default: 1
+  # issues-exit-code: 2
+
+  # Include test files or not.
+  # Default: true
+  tests: false
+
+  # List of build tags, all linters use it.
+  # Default: [].
+  # build-tags:
+  #   - mytag
+
+  # Which dirs to skip: issues from them won't be reported.
+  # Can use regexp here: `generated.*`, regexp is applied on full path.
+  # Default value is empty list,
+  # but default dirs are skipped independently of this option's value (see skip-dirs-use-default).
+  # "/" will be replaced by current OS file path separator to properly work on Windows.
+  # skip-dirs:
+  #   - autogenerated_by_my_lib
+
+  # Enables skipping of directories:
+  # - vendor$, third_party$, testdata$, examples$, Godeps$, builtin$
+  # Default: true
+  # skip-dirs-use-default: false
+
+  # 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
+  # to go.mod are needed. This setting is most useful to check that go.mod does
+  # not need updates, such as in a continuous integration and testing system.
+  # If invoked with -mod=vendor, the go command assumes that the vendor
+  # directory holds the correct copies of dependencies and ignores
+  # the dependency descriptions in go.mod.
+  #
+  # Allowed values: readonly|vendor|mod
+  # By default, it isn't set.
+  modules-download-mode: readonly
+
+  # Allow multiple parallel golangci-lint instances running.
+  # If false (default) - golangci-lint acquires file lock on start.
+  allow-parallel-runners: true
+
+  # 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'
+
+
+# output configuration options
+output:
+  # Format: colored-line-number|line-number|json|tab|checkstyle|code-climate|junit-xml|github-actions
+  #
+  # Multiple can be specified by separating them by comma, output can be provided
+  # for each of them by separating format name and path by colon symbol.
+  # Output path can be either `stdout`, `stderr` or path to the file to write to.
+  # Example: "checkstyle:report.json,colored-line-number"
+  #
+  # Default: colored-line-number
+  # format: json
+
+  # Print lines of code with issue.
+  # Default: true
+  # print-issued-lines: false
+
+  # Print linter name in the end of issue text.
+  # Default: true
+  # print-linter-name: false
+
+  # Make issues output unique by line.
+  # Default: true
+  # uniq-by-line: false
+
+  # Add a prefix to the output file references.
+  # Default is no prefix.
+  # path-prefix: ""
+
+  # Sort results by: filepath, line and column.
+  # sort-results: true
+
+
+# All available settings of specific linters.
+linters-settings:
+  lll:
+    line-length: 132
+
+  stylecheck:
+    checks: [ "all", "-ST1000" ]
+
+  tagliatelle:
+    case:
+      # use-field-name: true
+      rules:
+        json: snake
+        yaml: snake
+
+linters:
+  # Enable all available linters.
+  # Default: false
+  enable-all: true
+  # Disable specific linter
+  # https://golangci-lint.run/usage/linters/#disabled-by-default
+  disable:
+    - contextcheck
+    - cyclop
+    - deadcode
+    - depguard
+    - dupl
+    - err113
+    - errorlint
+    - execinquery
+    - exhaustive
+    - exhaustivestruct
+    - exhaustruct
+    - forbidigo
+    - forcetypeassert
+    - funlen
+    - gci
+    - gochecknoglobals
+    - gochecknoinits
+    - gocognit
+    - goconst
+    - goheader
+    - golint
+    - gomnd
+    - ifshort
+    - interfacer
+    - ireturn
+    - lll
+    - maintidx
+    - maligned
+    - mnd
+    - musttag
+    - nestif
+    - nilnil
+    - nlreturn
+    - nolintlint
+    - nosnakecase
+    - perfsprint
+    - promlinter
+    - rowserrcheck
+    - scopelint
+    - sqlclosecheck
+    - structcheck
+    - unparam
+    - varcheck
+    - varnamelen
+    - wastedassign
+    - wrapcheck
+    - wsl

CHANGELOG.md

@@ -1,3 +1,94 @@
+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
+  - add "holesky" to the list of supported networks
+  - avoid crash when requesting validators from beacon node without debug enabled
+
+1.33.0:
+  - show all slots with 'synccommittee inclusion'
+  - add "wallet batch" command
+
+1.32.0:
+  - fix incorrect error when "deposit verify" is not given a withdrawal address
+  - allow truncated mnemonics (first four characters of each word)
+  - add deneb information to "block info"
+  - add epoch parameter to "validator yield"
+  - add proposer index to "block info"
+  - "block info" honours "--quiet" flag
+  - "block info" accepts "--block-time" option
+  - increase default operation timeout from 10s to 30s
+  - "epoch summary" JSON lists number of blobs
+
+1.31.0:
+  - initial support for deneb
+  - add "--generate-keystore" option for "account derive"
+  - update "validator exit" command to be able to generate multiple exits
+  - support for 12-word and 18-word mnemonics with single-word (no whitespace) passphrases
+  - add JSON output for "validator expectation"
+
+1.30.0:
+  - add "chain spec" command
+  - add "validator withdrawal" command
+
+1.29.2:
+  - fix regression where validator index could not be used as an account specifier
+
+1.29.0:
+  - allow use of keystores with validator credentials set
+  - tidy up various command options to provide more standard usage
+  - add mainnet fallback beacon node
+
+1.28.4:
+  - allow validator exit to use a keystore as its validator parameter
+
+1.28.2:
+  - fix bix stopping validator exit creation by direct validator specification
+
+1.28.1:
+  - generate error message if "validator credentials set" process fails to generate any credentials
+  - allow import of accounts with null name field in their keystore
+  - show text of execution payload extra data if available
+
+1.28.0:
+  - support additional mnemonic word list languages
+  - increase minimum timeout for commands that fetch all validators to 2 minutes
+  - provide better error messages when offline preparation file cannot be read
+  - allow creation of all credential change operations related to a private key (thanks to @joaocenoura)
+
+1.27.1:
+  - fix issue with voluntary exits using incorrect domain (thanks to @0xTylerHolmes)
+
+1.27.0:
+  - use new build system
+  - support S3 credentials
+  - update operation of validator exit to match validator credentials set
+
 1.26.5:
   - provide validator information in "chain status" verbose output
 

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.17-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.
 
@@ -86,6 +86,11 @@ Teku disables the REST API by default.  To enable it, the beacon node must be st
 
 The default port for the REST API is 5051, which can be changed with the `--rest-api-port` parameter.
 
+### Lodestar
+Lodestar enables the REST API by default and should just work locally. If you want to access the REST API from a remote server then you should also look to change the `--rest.address` to `0.0.0.0` as per the Lodestar documentation.
+
+The default port for the REST API is 9596, which can be changed with the `--rest.port` parameter.
+
 ## Usage
 
 `ethdo` contains a large number of features that are useful for day-to-day interactions with the different consensus clients.
@@ -166,6 +171,15 @@ If set, the `--debug` argument will output additional information about the oper
 
 Commands will have an exit status of 0 on success and 1 on failure.  The specific definition of success is specified in the help for each command.
 
+### Validator specifier
+
+Ethereum validators can be specified in a number of different ways.  The options are:
+
+- an `ethdo` account, in the format _wallet_/_account_.  It is possible to use the validator specified in this way to sign validator-related operations, if the passphrase is also supplied, with a passphrase (for local accounts) or authority (for remote accounts)
+- the validator's 48-byte public key.  It is not possible to use the a validator specified in this way to sign validator-related operations
+- a keystore, supplied either as direct JSON or as a path to a keystore on the local filesystem.  It is possible to use the validator specified in this way to sign validator-related operations, if the passphrase is also supplied
+- the validator's numeric index.  It is not possible to use a validator specified in this way to sign validator-related operations.  Note that this only works with on-chain operations, as the validator's index must be resolved to its public key
+
 ## Passphrase strength
 
 `ethdo` will by default not allow creation or export of accounts or wallets with weak passphrases.  If a weak pasphrase is used then `ethdo` will refuse to continue.

beacon/chaininfo.go

@@ -0,0 +1,335 @@
+// Copyright © 2023 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package beacon
+
+import (
+	"context"
+	"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"
+	"github.com/wealdtech/ethdo/util"
+)
+
+type ChainInfo struct {
+	Version                        uint64
+	Validators                     []*ValidatorInfo
+	GenesisValidatorsRoot          phase0.Root
+	Epoch                          phase0.Epoch
+	GenesisForkVersion             phase0.Version
+	ExitForkVersion                phase0.Version
+	CurrentForkVersion             phase0.Version
+	BLSToExecutionChangeDomainType phase0.DomainType
+	VoluntaryExitDomainType        phase0.DomainType
+}
+
+type chainInfoJSON struct {
+	Version                        string           `json:"version"`
+	Validators                     []*ValidatorInfo `json:"validators"`
+	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"`
+}
+
+type chainInfoVersionJSON struct {
+	Version string `json:"version"`
+}
+
+// MarshalJSON implements json.Marshaler.
+func (c *ChainInfo) MarshalJSON() ([]byte, error) {
+	return json.Marshal(&chainInfoJSON{
+		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),
+	})
+}
+
+// UnmarshalJSON implements json.Unmarshaler.
+func (c *ChainInfo) UnmarshalJSON(input []byte) error {
+	// See which version we are dealing with.
+	var metadata chainInfoVersionJSON
+	if err := json.Unmarshal(input, &metadata); err != nil {
+		return errors.Wrap(err, "invalid JSON")
+	}
+	if metadata.Version == "" {
+		return errors.New("version missing")
+	}
+	version, err := strconv.ParseUint(metadata.Version, 10, 64)
+	if err != nil {
+		return errors.Wrap(err, "version invalid")
+	}
+	if version < 3 {
+		return errors.New("outdated version; please regenerate your offline data")
+	}
+	c.Version = version
+
+	var data chainInfoJSON
+	if err := json.Unmarshal(input, &data); err != nil {
+		return errors.Wrap(err, "invalid JSON")
+	}
+
+	if len(data.Validators) == 0 {
+		return errors.New("validators missing")
+	}
+	c.Validators = data.Validators
+
+	if data.GenesisValidatorsRoot == "" {
+		return errors.New("genesis validators root missing")
+	}
+	genesisValidatorsRootBytes, err := hex.DecodeString(strings.TrimPrefix(data.GenesisValidatorsRoot, "0x"))
+	if err != nil {
+		return errors.Wrap(err, "genesis validators root invalid")
+	}
+	if len(genesisValidatorsRootBytes) != phase0.RootLength {
+		return errors.New("genesis validators root incorrect length")
+	}
+	copy(c.GenesisValidatorsRoot[:], genesisValidatorsRootBytes)
+
+	if data.Epoch == "" {
+		return errors.New("epoch missing")
+	}
+	epoch, err := strconv.ParseUint(data.Epoch, 10, 64)
+	if err != nil {
+		return errors.Wrap(err, "epoch invalid")
+	}
+	c.Epoch = phase0.Epoch(epoch)
+
+	if data.GenesisForkVersion == "" {
+		return errors.New("genesis fork version missing")
+	}
+	genesisForkVersionBytes, err := hex.DecodeString(strings.TrimPrefix(data.GenesisForkVersion, "0x"))
+	if err != nil {
+		return errors.Wrap(err, "genesis fork version invalid")
+	}
+	if len(genesisForkVersionBytes) != phase0.ForkVersionLength {
+		return errors.New("genesis fork version incorrect length")
+	}
+	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")
+	}
+	currentForkVersionBytes, err := hex.DecodeString(strings.TrimPrefix(data.CurrentForkVersion, "0x"))
+	if err != nil {
+		return errors.Wrap(err, "current fork version invalid")
+	}
+	if len(currentForkVersionBytes) != phase0.ForkVersionLength {
+		return errors.New("current fork version incorrect length")
+	}
+	copy(c.CurrentForkVersion[:], currentForkVersionBytes)
+
+	if data.BLSToExecutionChangeDomainType == "" {
+		return errors.New("bls to execution domain type missing")
+	}
+	blsToExecutionChangeDomainType, err := hex.DecodeString(strings.TrimPrefix(data.BLSToExecutionChangeDomainType, "0x"))
+	if err != nil {
+		return errors.Wrap(err, "bls to execution domain type invalid")
+	}
+	if len(blsToExecutionChangeDomainType) != phase0.DomainTypeLength {
+		return errors.New("bls to execution domain type incorrect length")
+	}
+	copy(c.BLSToExecutionChangeDomainType[:], blsToExecutionChangeDomainType)
+
+	if data.VoluntaryExitDomainType == "" {
+		return errors.New("voluntary exit domain type missing")
+	}
+	voluntaryExitDomainType, err := hex.DecodeString(strings.TrimPrefix(data.VoluntaryExitDomainType, "0x"))
+	if err != nil {
+		return errors.Wrap(err, "voluntary exit domain type invalid")
+	}
+	if len(voluntaryExitDomainType) != phase0.DomainTypeLength {
+		return errors.New("voluntary exit domain type incorrect length")
+	}
+	copy(c.VoluntaryExitDomainType[:], voluntaryExitDomainType)
+
+	return nil
+}
+
+// FetchValidatorInfo fetches validator info given a validator identifier.
+func (c *ChainInfo) FetchValidatorInfo(ctx context.Context, id string) (*ValidatorInfo, error) {
+	var validatorInfo *ValidatorInfo
+	switch {
+	case id == "":
+		return nil, errors.New("no validator specified")
+	case strings.HasPrefix(id, "0x"):
+		// ID is a public key.
+		// Check that the key is the correct length.
+		if len(id) != 98 {
+			return nil, errors.New("invalid public key: incorrect length")
+		}
+		for _, validator := range c.Validators {
+			if strings.EqualFold(id, fmt.Sprintf("%#x", validator.Pubkey)) {
+				validatorInfo = validator
+				break
+			}
+		}
+	case strings.Contains(id, "/"):
+		// An account.
+		_, account, err := util.WalletAndAccountFromPath(ctx, id)
+		if err != nil {
+			return nil, errors.Wrap(err, "unable to obtain account")
+		}
+		accPubKey, err := util.BestPublicKey(account)
+		if err != nil {
+			return nil, errors.Wrap(err, "unable to obtain public key for account")
+		}
+		pubkey := fmt.Sprintf("%#x", accPubKey.Marshal())
+		for _, validator := range c.Validators {
+			if strings.EqualFold(pubkey, fmt.Sprintf("%#x", validator.Pubkey)) {
+				validatorInfo = validator
+				break
+			}
+		}
+	default:
+		// An index.
+		index, err := strconv.ParseUint(id, 10, 64)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to parse validator index")
+		}
+		validatorIndex := phase0.ValidatorIndex(index)
+		for _, validator := range c.Validators {
+			if validator.Index == validatorIndex {
+				validatorInfo = validator
+				break
+			}
+		}
+	}
+
+	if validatorInfo == nil {
+		return nil, errors.New("unknown validator")
+	}
+
+	return validatorInfo, nil
+}
+
+// ObtainChainInfoFromNode obtains the chain information from a node.
+func ObtainChainInfoFromNode(ctx context.Context,
+	consensusClient consensusclient.Service,
+	chainTime chaintime.Service,
+) (
+	*ChainInfo,
+	error,
+) {
+	res := &ChainInfo{
+		Version:    3,
+		Validators: make([]*ValidatorInfo, 0),
+		Epoch:      chainTime.CurrentEpoch(),
+	}
+
+	// Obtain validators.
+	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 validatorsResponse.Data {
+		res.Validators = append(res.Validators, &ValidatorInfo{
+			Index:                 validator.Index,
+			Pubkey:                validator.Validator.PublicKey,
+			WithdrawalCredentials: validator.Validator.WithdrawalCredentials,
+			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.
+	genesisResponse, err := consensusClient.(consensusclient.GenesisProvider).Genesis(ctx, &api.GenesisOpts{})
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain genesis information")
+	}
+	res.GenesisValidatorsRoot = genesisResponse.Data.GenesisValidatorsRoot
+
+	// Fetch the genesis fork version from the specification.
+	specResponse, err := consensusClient.(consensusclient.SpecProvider).Spec(ctx, &api.SpecOpts{})
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain spec")
+	}
+	tmp, exists := specResponse.Data["GENESIS_FORK_VERSION"]
+	if !exists {
+		return nil, errors.New("genesis fork version not known by chain")
+	}
+	var isForkVersion bool
+	res.GenesisForkVersion, isForkVersion = tmp.(phase0.Version)
+	if !isForkVersion {
+		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.
+	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 forkScheduleResponse.Data {
+		if forkScheduleResponse.Data[i].Epoch <= res.Epoch {
+			res.CurrentForkVersion = forkScheduleResponse.Data[i].CurrentVersion
+		}
+	}
+
+	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 := specResponse.Data["DOMAIN_VOLUNTARY_EXIT"].(phase0.DomainType)
+	if !exists {
+		return nil, errors.New("failed to obtain DOMAIN_VOLUNTARY_EXIT")
+	}
+	copy(res.VoluntaryExitDomainType[:], voluntaryExitDomainType[:])
+
+	return res, nil
+}

beacon/validatorinfo.go

@@ -1,4 +1,4 @@
-// Copyright © 2022 Weald Technology Trading.
+// Copyright © 2023 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
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package validatorcredentialsset
+package beacon
 
 import (
 	"encoding/hex"
@@ -20,33 +20,37 @@ import (
 	"strconv"
 	"strings"
 
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 )
 
-type validatorInfo struct {
+type ValidatorInfo struct {
 	Index                 phase0.ValidatorIndex
 	Pubkey                phase0.BLSPubKey
+	State                 apiv1.ValidatorState
 	WithdrawalCredentials []byte
 }
 
 type validatorInfoJSON struct {
-	Index                 string `json:"index"`
-	Pubkey                string `json:"pubkey"`
-	WithdrawalCredentials string `json:"withdrawal_credentials"`
+	Index                 string               `json:"index"`
+	Pubkey                string               `json:"pubkey"`
+	State                 apiv1.ValidatorState `json:"state"`
+	WithdrawalCredentials string               `json:"withdrawal_credentials"`
 }
 
 // MarshalJSON implements json.Marshaler.
-func (v *validatorInfo) MarshalJSON() ([]byte, error) {
+func (v *ValidatorInfo) MarshalJSON() ([]byte, error) {
 	return json.Marshal(&validatorInfoJSON{
 		Index:                 fmt.Sprintf("%d", v.Index),
 		Pubkey:                fmt.Sprintf("%#x", v.Pubkey),
+		State:                 v.State,
 		WithdrawalCredentials: fmt.Sprintf("%#x", v.WithdrawalCredentials),
 	})
 }
 
 // UnmarshalJSON implements json.Unmarshaler.
-func (v *validatorInfo) UnmarshalJSON(input []byte) error {
+func (v *ValidatorInfo) UnmarshalJSON(input []byte) error {
 	var data validatorInfoJSON
 	if err := json.Unmarshal(input, &data); err != nil {
 		return errors.Wrap(err, "invalid JSON")
@@ -73,6 +77,11 @@ func (v *validatorInfo) UnmarshalJSON(input []byte) error {
 	}
 	copy(v.Pubkey[:], pubkey)
 
+	if data.State == apiv1.ValidatorStateUnknown {
+		return errors.New("state unknown")
+	}
+	v.State = data.State
+
 	if data.WithdrawalCredentials == "" {
 		return errors.New("withdrawal credentials missing")
 	}
@@ -88,7 +97,7 @@ func (v *validatorInfo) UnmarshalJSON(input []byte) error {
 }
 
 // String implements the Stringer interface.
-func (v *validatorInfo) String() string {
+func (v *ValidatorInfo) String() string {
 	data, err := json.Marshal(v)
 	if err != nil {
 		return fmt.Sprintf("Err: %v\n", err)

cmd/account.go

@@ -17,7 +17,7 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// accountCmd represents the account command
+// accountCmd represents the account command.
 var accountCmd = &cobra.Command{
 	Use:   "account",
 	Short: "Manage account",
@@ -28,5 +28,5 @@ func init() {
 	RootCmd.AddCommand(accountCmd)
 }
 
-func accountFlags(cmd *cobra.Command) {
+func accountFlags(_ *cobra.Command) {
 }

cmd/account/create/output.go

@@ -25,7 +25,7 @@ type dataOut struct {
 	account e2wtypes.Account
 }
 
-func output(ctx context.Context, data *dataOut) (string, error) {
+func output(_ context.Context, data *dataOut) (string, error) {
 	if data == nil {
 		return "", errors.New("no data")
 	}

cmd/account/create/process.go

@@ -86,7 +86,7 @@ func processPathed(ctx context.Context, data *dataIn) (*dataOut, error) {
 	if data.passphrase == "" {
 		return nil, errors.New("passphrase is required")
 	}
-	match, err := regexp.Match("^m/[0-9]+/[0-9]+(/[0-9+])+", []byte(data.path))
+	match, err := regexp.MatchString("^m/[0-9]+/[0-9]+(/[0-9+])+", data.path)
 	if err != nil {
 		return nil, errors.Wrap(err, "unable to match path to regular expression")
 	}

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/input.go

@@ -1,4 +1,4 @@
-// Copyright © 2020 Weald Technology Trading
+// Copyright © 2020, 2023 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
@@ -28,9 +28,10 @@ type dataIn struct {
 	// Output options.
 	showPrivateKey            bool
 	showWithdrawalCredentials bool
+	generateKeystore          bool
 }
 
-func input(ctx context.Context) (*dataIn, error) {
+func input(_ context.Context) (*dataIn, error) {
 	data := &dataIn{}
 
 	// Quiet.
@@ -54,5 +55,8 @@ func input(ctx context.Context) (*dataIn, error) {
 	// Show withdrawal credentials.
 	data.showWithdrawalCredentials = viper.GetBool("show-withdrawal-credentials")
 
+	// Generate keystore.
+	data.generateKeystore = viper.GetBool("generate-keystore")
+
 	return data, nil
 }

cmd/account/derive/output.go

@@ -1,4 +1,4 @@
-// Copyright © 2020 Weald Technology Trading
+// Copyright © 2020, 2023 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,18 +15,27 @@ package accountderive
 
 import (
 	"context"
+	"encoding/hex"
+	"encoding/json"
 	"fmt"
+	"os"
 	"strings"
+	"time"
 
+	"github.com/google/uuid"
 	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/util"
 	e2types "github.com/wealdtech/go-eth2-types/v2"
-	util "github.com/wealdtech/go-eth2-util"
+	ethutil "github.com/wealdtech/go-eth2-util"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
 )
 
 type dataOut struct {
 	showPrivateKey            bool
 	showWithdrawalCredentials bool
+	generateKeystore          bool
 	key                       *e2types.BLSPrivateKey
+	path                      string
 }
 
 func output(ctx context.Context, data *dataOut) (string, error) {
@@ -37,13 +46,17 @@ func output(ctx context.Context, data *dataOut) (string, error) {
 		return "", errors.New("no key")
 	}
 
+	if data.generateKeystore {
+		return outputKeystore(ctx, data)
+	}
+
 	builder := strings.Builder{}
 
 	if data.showPrivateKey {
 		builder.WriteString(fmt.Sprintf("Private key: %#x\n", data.key.Marshal()))
 	}
 	if data.showWithdrawalCredentials {
-		withdrawalCredentials := util.SHA256(data.key.PublicKey().Marshal())
+		withdrawalCredentials := ethutil.SHA256(data.key.PublicKey().Marshal())
 		withdrawalCredentials[0] = byte(0) // BLS_WITHDRAWAL_PREFIX
 		builder.WriteString(fmt.Sprintf("Withdrawal credentials: %#x\n", withdrawalCredentials))
 	}
@@ -53,3 +66,38 @@ func output(ctx context.Context, data *dataOut) (string, error) {
 
 	return builder.String(), nil
 }
+
+func outputKeystore(_ context.Context, data *dataOut) (string, error) {
+	passphrase, err := util.GetPassphrase()
+	if err != nil {
+		return "", errors.New("no passphrase supplied")
+	}
+
+	encryptor := keystorev4.New()
+	crypto, err := encryptor.Encrypt(data.key.Marshal(), passphrase)
+	if err != nil {
+		return "", errors.New("failed to encrypt private key")
+	}
+
+	uuid, err := uuid.NewRandom()
+	if err != nil {
+		return "", errors.New("failed to generate UUID")
+	}
+	ks := make(map[string]interface{})
+	ks["uuid"] = uuid.String()
+	ks["pubkey"] = hex.EncodeToString(data.key.PublicKey().Marshal())
+	ks["version"] = 4
+	ks["path"] = data.path
+	ks["crypto"] = crypto
+	out, err := json.Marshal(ks)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to marshal keystore JSON")
+	}
+
+	keystoreFilename := fmt.Sprintf("keystore-%s-%d.json", strings.ReplaceAll(data.path, "/", "_"), time.Now().Unix())
+
+	if err := os.WriteFile(keystoreFilename, out, 0o600); err != nil {
+		return "", errors.Wrap(err, fmt.Sprintf("failed to write %s", keystoreFilename))
+	}
+	return "", nil
+}

cmd/account/derive/process.go

@@ -1,4 +1,4 @@
-// Copyright © 2020 Weald Technology Trading
+// Copyright © 2020, 2023 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
@@ -40,7 +40,9 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	results := &dataOut{
 		showPrivateKey:            data.showPrivateKey,
 		showWithdrawalCredentials: data.showWithdrawalCredentials,
+		generateKeystore:          data.generateKeystore,
 		key:                       key.(*e2types.BLSPrivateKey),
+		path:                      data.path,
 	}
 
 	return results, nil

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/output.go

@@ -25,7 +25,7 @@ type dataOut struct {
 	account e2wtypes.Account
 }
 
-func output(ctx context.Context, data *dataOut) (string, error) {
+func output(_ context.Context, data *dataOut) (string, error) {
 	if data == nil {
 		return "", errors.New("no data")
 	}

cmd/account/import/process.go

@@ -15,6 +15,7 @@ package accountimport
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 
 	"github.com/pkg/errors"
@@ -66,7 +67,7 @@ func processFromKey(ctx context.Context, data *dataIn) (*dataOut, error) {
 	}
 	account, err := importer.ImportAccount(ctx, data.accountName, data.key, []byte(data.passphrase))
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to import account")
+		return nil, errors.Wrap(err, "failed to import wallet")
 	}
 	results.account = account
 
@@ -79,15 +80,25 @@ func processFromKeystore(ctx context.Context, data *dataIn) (*dataOut, error) {
 	encryptor := keystorev4.New()
 
 	// Need to add a couple of fields to the keystore to make it compliant.
-	keystoreData := fmt.Sprintf(`{"name":"Import","encryptor":"keystore",%s`, string(data.keystore[1:]))
-	walletData := fmt.Sprintf(`{"wallet":{"name":"ImportTest","type":"non-deterministic","uuid":"e1526407-1dc7-4f3f-9d05-ab696f40707c","version":1},"accounts":[%s]}`, keystoreData)
+	var keystore map[string]any
+	if err := json.Unmarshal(data.keystore, &keystore); err != nil {
+		return nil, errors.Wrap(err, "failed to unmarshal keystore")
+	}
+	keystore["name"] = data.accountName
+	keystore["encryptor"] = "keystore"
+	keystoreData, err := json.Marshal(keystore)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshal keystore")
+	}
+
+	walletData := fmt.Sprintf(`{"wallet":{"name":"Import","type":"non-deterministic","uuid":"e1526407-1dc7-4f3f-9d05-ab696f40707c","version":1},"accounts":[%s]}`, keystoreData)
 	encryptedData, err := ecodec.Encrypt([]byte(walletData), data.keystorePassphrase)
 	if err != nil {
 		return nil, err
 	}
 	wallet, err := nd.Import(ctx, encryptedData, data.keystorePassphrase, store, encryptor)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to import wallet")
+		return nil, errors.Wrap(err, "failed to import account")
 	}
 
 	account := <-wallet.Accounts(ctx)

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/output.go

@@ -24,7 +24,7 @@ type dataOut struct {
 	key []byte
 }
 
-func output(ctx context.Context, data *dataOut) (string, error) {
+func output(_ context.Context, data *dataOut) (string, error) {
 	if data == nil {
 		return "", errors.New("no data")
 	}

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
@@ -51,11 +51,11 @@ func init() {
 	accountCreateCmd.Flags().Uint32("signing-threshold", 1, "Signing threshold (1 for non-distributed accounts)")
 }
 
-func accountCreateBindings() {
-	if err := viper.BindPFlag("participants", accountCreateCmd.Flags().Lookup("participants")); err != nil {
+func accountCreateBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("participants", cmd.Flags().Lookup("participants")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("signing-threshold", accountCreateCmd.Flags().Lookup("signing-threshold")); err != nil {
+	if err := viper.BindPFlag("signing-threshold", cmd.Flags().Lookup("signing-threshold")); err != nil {
 		panic(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
@@ -49,13 +49,17 @@ func init() {
 	accountFlags(accountDeriveCmd)
 	accountDeriveCmd.Flags().Bool("show-private-key", false, "show private key for derived account")
 	accountDeriveCmd.Flags().Bool("show-withdrawal-credentials", false, "show withdrawal credentials for derived account")
+	accountDeriveCmd.Flags().Bool("generate-keystore", false, "generate a keystore for the derived account")
 }
 
-func accountDeriveBindings() {
-	if err := viper.BindPFlag("show-private-key", accountDeriveCmd.Flags().Lookup("show-private-key")); err != nil {
+func accountDeriveBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("show-private-key", cmd.Flags().Lookup("show-private-key")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("show-withdrawal-credentials", accountDeriveCmd.Flags().Lookup("show-withdrawal-credentials")); err != nil {
+	if err := viper.BindPFlag("show-withdrawal-credentials", cmd.Flags().Lookup("show-withdrawal-credentials")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("generate-keystore", cmd.Flags().Lookup("generate-keystore")); err != nil {
 		panic(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
@@ -52,14 +52,14 @@ func init() {
 	accountImportCmd.Flags().String("keystore-passphrase", "", "Passphrase of keystore")
 }
 
-func accountImportBindings() {
-	if err := viper.BindPFlag("key", accountImportCmd.Flags().Lookup("key")); err != nil {
+func accountImportBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("key", cmd.Flags().Lookup("key")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("keystore", accountImportCmd.Flags().Lookup("keystore")); err != nil {
+	if err := viper.BindPFlag("keystore", cmd.Flags().Lookup("keystore")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("keystore-passphrase", accountImportCmd.Flags().Lookup("keystore-passphrase")); err != nil {
+	if err := viper.BindPFlag("keystore-passphrase", cmd.Flags().Lookup("keystore-passphrase")); err != nil {
 		panic(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()
 
@@ -44,11 +44,11 @@ In quiet mode this will return 0 if the account exists, otherwise 1.`,
 		// Disallow wildcards (for now)
 		assert(fmt.Sprintf("%s/%s", wallet.Name(), account.Name()) == viper.GetString("account"), "Mismatched account name")
 
-		if quiet {
+		if viper.GetBool("quiet") {
 			os.Exit(_exitSuccess)
 		}
 
-		outputIf(verbose, fmt.Sprintf("UUID: %v", account.ID()))
+		outputIf(viper.GetBool("verbose"), fmt.Sprintf("UUID: %v", account.ID()))
 		var withdrawalPubKey e2types.PublicKey
 		if pubKeyProvider, ok := account.(e2wtypes.AccountPublicKeyProvider); ok {
 			fmt.Printf("Public key: %#x\n", pubKeyProvider.PublicKey().Marshal())
@@ -58,7 +58,7 @@ In quiet mode this will return 0 if the account exists, otherwise 1.`,
 		if distributedAccount, ok := account.(e2wtypes.DistributedAccount); ok {
 			fmt.Printf("Composite public key: %#x\n", distributedAccount.CompositePublicKey().Marshal())
 			fmt.Printf("Signing threshold: %d/%d\n", distributedAccount.SigningThreshold(), len(distributedAccount.Participants()))
-			if verbose {
+			if viper.GetBool("verbose") {
 				fmt.Printf("Participants:\n")
 				for k, v := range distributedAccount.Participants() {
 					fmt.Printf(" %d: %s\n", k, v)
@@ -67,7 +67,7 @@ In quiet mode this will return 0 if the account exists, otherwise 1.`,
 
 			withdrawalPubKey = distributedAccount.CompositePublicKey()
 		}
-		if verbose {
+		if viper.GetBool("verbose") {
 			withdrawalCredentials := util.SHA256(withdrawalPubKey.Marshal())
 			withdrawalCredentials[0] = byte(0) // BLS_WITHDRAWAL_PREFIX
 			fmt.Printf("Withdrawal credentials: %#x\n", withdrawalCredentials)

cmd/accountkey.go

@@ -21,7 +21,7 @@ import (
 	accountkey "github.com/wealdtech/ethdo/cmd/account/key"
 )
 
-// accountKeyCmd represents the account key command
+// accountKeyCmd represents the account key command.
 var accountKeyCmd = &cobra.Command{
 	Use:   "key",
 	Short: "Obtain the private key of an account.",
@@ -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/attestation.go

@@ -17,7 +17,7 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// attestationCmd represents the attestation command
+// attestationCmd represents the attestation command.
 var attestationCmd = &cobra.Command{
 	Use:   "attestation",
 	Short: "Obtain information about an Ethereum 2 attestation",

cmd/attester.go

@@ -17,7 +17,7 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// attesterCmd represents the attester command
+// attesterCmd represents the attester command.
 var attesterCmd = &cobra.Command{
 	Use:   "attester",
 	Short: "Obtain information about Ethereum 2 attesters",
@@ -28,5 +28,5 @@ func init() {
 	RootCmd.AddCommand(attesterCmd)
 }
 
-func attesterFlags(cmd *cobra.Command) {
+func attesterFlags(_ *cobra.Command) {
 }

cmd/attester/duties/input.go

@@ -18,9 +18,11 @@ import (
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/services/chaintime"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
 	"github.com/wealdtech/ethdo/util"
 )
 
@@ -31,13 +33,11 @@ type dataIn struct {
 	verbose bool
 	debug   bool
 	json    bool
-	// Chain information.
-	slotsPerEpoch uint64
 	// Operation.
-	account    string
-	pubKey     string
+	validator  string
 	eth2Client eth2client.Service
-	epoch      spec.Epoch
+	chainTime  chaintime.Service
+	epoch      phase0.Epoch
 }
 
 func input(ctx context.Context) (*dataIn, error) {
@@ -52,38 +52,38 @@ func input(ctx context.Context) (*dataIn, error) {
 	data.debug = viper.GetBool("debug")
 	data.json = viper.GetBool("json")
 
-	// Account or pubkey.
-	if viper.GetString("account") == "" && viper.GetString("pubkey") == "" {
-		return nil, errors.New("account or pubkey is required")
+	// Validator.
+	data.validator = viper.GetString("validator")
+	if data.validator == "" {
+		return nil, errors.New("validator is required")
 	}
-	data.account = viper.GetString("account")
-	data.pubKey = viper.GetString("pubkey")
 
 	// Ethereum 2 client.
 	var err error
-	data.eth2Client, err = util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
+	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+		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
 	}
 
-	// Required data.
-	config, err := data.eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	data.chainTime, err = standardchaintime.New(ctx,
+		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithGenesisProvider(data.eth2Client.(eth2client.GenesisProvider)),
+	)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to obtain beacon chain configuration")
+		return nil, errors.Wrap(err, "failed to set up chaintime service")
 	}
-	data.slotsPerEpoch = config["SLOTS_PER_EPOCH"].(uint64)
 
-	// Epoch
-	epoch := viper.GetInt64("epoch")
-	if epoch == -1 {
-		slotDuration := config["SECONDS_PER_SLOT"].(time.Duration)
-		genesis, err := data.eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to obtain genesis data")
-		}
-		epoch = int64(time.Since(genesis.GenesisTime).Seconds()) / (int64(slotDuration.Seconds()) * int64(data.slotsPerEpoch))
+	// Epoch.
+	data.epoch, err = util.ParseEpoch(ctx, data.chainTime, viper.GetString("epoch"))
+	if err != nil {
+		return nil, err
 	}
-	data.epoch = spec.Epoch(epoch)
 
 	return data, nil
 }

cmd/attester/duties/input_internal_test.go

@@ -17,6 +17,7 @@ import (
 	"context"
 	"os"
 	"testing"
+	"time"
 
 	"github.com/spf13/viper"
 	"github.com/stretchr/testify/require"
@@ -61,19 +62,21 @@ func TestInput(t *testing.T) {
 			err:  "timeout is required",
 		},
 		{
-			name: "AccountMissing",
+			name: "ValidatorMissing",
 			vars: map[string]interface{}{
 				"timeout": "5s",
 			},
-			err: "account or pubkey is required",
+			err: "validator is required",
 		},
 		{
-			name: "ConnectionMissing",
+			name: "Good",
 			vars: map[string]interface{}{
-				"timeout": "5s",
-				"pubkey":  "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
+				"timeout":   "5s",
+				"validator": "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
 			},
-			err: "failed to connect to any beacon node",
 		},
 	}
 

cmd/attester/duties/output.go

@@ -30,7 +30,7 @@ type dataOut struct {
 	duty    *api.AttesterDuty
 }
 
-func output(ctx context.Context, data *dataOut) (string, error) {
+func output(_ context.Context, data *dataOut) (string, error) {
 	if data == nil {
 		return "", errors.New("no data")
 	}

cmd/attester/duties/process.go

@@ -15,16 +15,13 @@ package attesterduties
 
 import (
 	"context"
-	"encoding/hex"
-	"fmt"
-	"strings"
 
 	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"
-	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
 func process(ctx context.Context, data *dataIn) (*dataOut, error) {
@@ -32,43 +29,9 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		return nil, errors.New("no data")
 	}
 
-	var account e2wtypes.Account
-	var err error
-	if data.account != "" {
-		ctx, cancel := context.WithTimeout(ctx, data.timeout)
-		defer cancel()
-		_, account, err = util.WalletAndAccountFromPath(ctx, data.account)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to obtain account")
-		}
-	} else {
-		pubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(data.pubKey, "0x"))
-		if err != nil {
-			return nil, errors.Wrap(err, fmt.Sprintf("failed to decode public key %s", data.pubKey))
-		}
-		account, err = util.NewScratchAccount(nil, pubKeyBytes)
-		if err != nil {
-			return nil, errors.Wrap(err, fmt.Sprintf("invalid public key %s", data.pubKey))
-		}
-	}
-
-	// Fetch validator
-	pubKeys := make([]spec.BLSPubKey, 1)
-	pubKey, err := util.BestPublicKey(account)
+	validator, err := util.ParseValidator(ctx, data.eth2Client.(eth2client.ValidatorsProvider), data.validator, "head")
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to obtain public key for account")
-	}
-	copy(pubKeys[0][:], pubKey.Marshal())
-	validators, err := data.eth2Client.(eth2client.ValidatorsProvider).ValidatorsByPubKey(ctx, fmt.Sprintf("%d", uint64(data.epoch)*data.slotsPerEpoch), pubKeys)
-	if err != nil {
-		return nil, errors.New("failed to obtain validator information")
-	}
-	if len(validators) == 0 {
-		return nil, errors.New("validator is not known")
-	}
-	var validator *api.Validator
-	for _, v := range validators {
-		validator = v
+		return nil, err
 	}
 
 	results := &dataOut{
@@ -77,7 +40,7 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		verbose: data.verbose,
 	}
 
-	duty, err := duty(ctx, data.eth2Client, validator, data.epoch, data.slotsPerEpoch)
+	duty, err := duty(ctx, data.eth2Client, validator, data.epoch)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain duty for validator")
 	}
@@ -87,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, slotsPerEpoch uint64) (*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

@@ -18,9 +18,11 @@ import (
 	"os"
 	"testing"
 
+	eth2client "github.com/attestantio/go-eth2-client"
 	"github.com/attestantio/go-eth2-client/auto"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/require"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
 )
 
 func TestProcess(t *testing.T) {
@@ -33,6 +35,12 @@ func TestProcess(t *testing.T) {
 	)
 	require.NoError(t, err)
 
+	chainTime, err := standardchaintime.New(context.Background(),
+		standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithGenesisProvider(eth2Client.(eth2client.GenesisProvider)),
+	)
+	require.NoError(t, err)
+
 	tests := []struct {
 		name   string
 		dataIn *dataIn
@@ -45,10 +53,9 @@ func TestProcess(t *testing.T) {
 		{
 			name: "Client",
 			dataIn: &dataIn{
-				eth2Client:    eth2Client,
-				slotsPerEpoch: 32,
-				pubKey:        "0x933ad9491b62059dd065b560d256d8957a8c402cc6e8d8ee7290ae11e8f7329267a8811c397529dac52ae1342ba58c95",
-				epoch:         100,
+				eth2Client: eth2Client,
+				chainTime:  chainTime,
+				validator:  "0x933ad9491b62059dd065b560d256d8957a8c402cc6e8d8ee7290ae11e8f7329267a8811c397529dac52ae1342ba58c95",
 			},
 		},
 	}

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

@@ -15,7 +15,6 @@ package attesterinclusion
 
 import (
 	"context"
-	"fmt"
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
@@ -23,6 +22,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/spf13/viper"
 	"github.com/wealdtech/ethdo/services/chaintime"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
 	"github.com/wealdtech/ethdo/util"
 )
 
@@ -32,15 +32,11 @@ type dataIn struct {
 	quiet   bool
 	verbose bool
 	debug   bool
-	// Chain information.
-	slotsPerEpoch uint64
 	// Operation.
 	eth2Client eth2client.Service
 	chainTime  chaintime.Service
 	epoch      spec.Epoch
-	account    string
-	pubKey     string
-	index      string
+	validator  string
 }
 
 func input(ctx context.Context) (*dataIn, error) {
@@ -54,48 +50,36 @@ func input(ctx context.Context) (*dataIn, error) {
 	data.verbose = viper.GetBool("verbose")
 	data.debug = viper.GetBool("debug")
 
-	// Account.
-	data.account = viper.GetString("account")
-
-	// PubKey.
-	data.pubKey = viper.GetString("pubkey")
-
-	// ID.
-	data.index = viper.GetString("index")
-
-	if viper.GetString("account") == "" && viper.GetString("index") == "" && viper.GetString("pubkey") == "" {
-		return nil, errors.New("account, index or pubkey is required")
+	data.validator = viper.GetString("validator")
+	if data.validator == "" {
+		return nil, errors.New("validator is required")
 	}
 
 	// Ethereum 2 client.
 	var err error
-	data.eth2Client, err = util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
+	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+		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
 	}
 
-	config, err := data.eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	data.chainTime, err = standardchaintime.New(ctx,
+		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithGenesisProvider(data.eth2Client.(eth2client.GenesisProvider)),
+	)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to obtain beacon chain configuration")
+		return nil, errors.Wrap(err, "failed to set up chaintime service")
 	}
-	data.slotsPerEpoch = config["SLOTS_PER_EPOCH"].(uint64)
 
 	// Epoch.
-	epoch := viper.GetInt64("epoch")
-	if epoch == -1 {
-		slotDuration := config["SECONDS_PER_SLOT"].(time.Duration)
-		genesis, err := data.eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to obtain genesis data")
-		}
-		epoch = int64(time.Since(genesis.GenesisTime).Seconds()) / (int64(slotDuration.Seconds()) * int64(data.slotsPerEpoch))
-		if epoch > 0 {
-			epoch--
-		}
-	}
-	data.epoch = spec.Epoch(epoch)
-	if data.debug {
-		fmt.Printf("Epoch is %d\n", data.epoch)
+	data.epoch, err = util.ParseEpoch(ctx, data.chainTime, viper.GetString("epoch"))
+	if err != nil {
+		return nil, err
 	}
 
 	return data, nil

cmd/attester/inclusion/input_internal_test.go

@@ -17,6 +17,7 @@ import (
 	"context"
 	"os"
 	"testing"
+	"time"
 
 	"github.com/spf13/viper"
 	"github.com/stretchr/testify/require"
@@ -61,19 +62,21 @@ func TestInput(t *testing.T) {
 			err:  "timeout is required",
 		},
 		{
-			name: "IndexMissing",
+			name: "ValidatorMissing",
 			vars: map[string]interface{}{
 				"timeout": "5s",
 			},
-			err: "account, index or pubkey is required",
+			err: "validator is required",
 		},
 		{
-			name: "ConnectionMissing",
+			name: "Good",
 			vars: map[string]interface{}{
-				"timeout": "5s",
-				"pubkey":  "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
+				"timeout":   "5s",
+				"validator": "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
 			},
-			err: "failed to connect to any beacon node",
 		},
 	}
 

cmd/attester/inclusion/output.go

@@ -16,6 +16,7 @@ package attesterinclusion
 import (
 	"context"
 	"fmt"
+	"strconv"
 	"strings"
 
 	"github.com/attestantio/go-eth2-client/spec/phase0"
@@ -38,7 +39,7 @@ type dataOut struct {
 	targetTimely     bool
 }
 
-func output(ctx context.Context, data *dataOut) (string, error) {
+func output(_ context.Context, data *dataOut) (string, error) {
 	buf := strings.Builder{}
 	if data == nil {
 		return buf.String(), errors.New("no data")
@@ -49,7 +50,7 @@ func output(ctx 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"
@@ -31,41 +33,26 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		return nil, errors.New("no data")
 	}
 
-	var err error
+	validator, err := util.ParseValidator(ctx, data.eth2Client.(eth2client.ValidatorsProvider), data.validator, "head")
+	if err != nil {
+		return nil, err
+	}
 
 	data.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithForkScheduleProvider(data.eth2Client.(eth2client.ForkScheduleProvider)),
-		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")
 	}
 
-	validatorIndex, err := util.ValidatorIndex(ctx, data.eth2Client, data.account, data.pubKey, data.index)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to obtain validator index")
-	}
-
-	validators, err := data.eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, fmt.Sprintf("%d", uint64(data.epoch)*data.slotsPerEpoch), []phase0.ValidatorIndex{validatorIndex})
-	if err != nil {
-		return nil, errors.New("failed to obtain validator information")
-	}
-	if len(validators) == 0 {
-		return nil, errors.New("validator is not known")
-	}
-	var validator *api.Validator
-	for _, v := range validators {
-		validator = v
-	}
-
 	results := &dataOut{
 		debug:   data.debug,
 		quiet:   data.quiet,
 		verbose: data.verbose,
 	}
 
-	duty, err := duty(ctx, data.eth2Client, validator, data.epoch, data.slotsPerEpoch)
+	duty, err := duty(ctx, data.eth2Client, validator, data.epoch)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain duty for validator")
 	}
@@ -76,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")
 		}
@@ -93,29 +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
@@ -134,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 {
-			return false, 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 {
-			return false, 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, slotsPerEpoch uint64) (*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

@@ -18,18 +18,26 @@ import (
 	"os"
 	"testing"
 
-	"github.com/attestantio/go-eth2-client/auto"
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/http"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/require"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
 )
 
 func TestProcess(t *testing.T) {
 	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
 		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
 	}
-	eth2Client, err := auto.New(context.Background(),
-		auto.WithLogLevel(zerolog.Disabled),
-		auto.WithAddress(os.Getenv("ETHDO_TEST_CONNECTION")),
+	eth2Client, err := http.New(context.Background(),
+		http.WithLogLevel(zerolog.Disabled),
+		http.WithAddress(os.Getenv("ETHDO_TEST_CONNECTION")),
+	)
+	require.NoError(t, err)
+
+	chainTime, err := standardchaintime.New(context.Background(),
+		standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithGenesisProvider(eth2Client.(eth2client.GenesisProvider)),
 	)
 	require.NoError(t, err)
 
@@ -45,10 +53,9 @@ func TestProcess(t *testing.T) {
 		{
 			name: "Client",
 			dataIn: &dataIn{
-				eth2Client:    eth2Client,
-				slotsPerEpoch: 32,
-				pubKey:        "0x933ad9491b62059dd065b560d256d8957a8c402cc6e8d8ee7290ae11e8f7329267a8811c397529dac52ae1342ba58c95",
-				epoch:         100,
+				eth2Client: eth2Client,
+				chainTime:  chainTime,
+				validator:  "0x933ad9491b62059dd065b560d256d8957a8c402cc6e8d8ee7290ae11e8f7329267a8811c397529dac52ae1342ba58c95",
 			},
 		},
 	}

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

@@ -26,10 +26,10 @@ var attesterDutiesCmd = &cobra.Command{
 	Short: "Obtain information about duties of an attester",
 	Long: `Obtain information about dutes of an attester.  For example:
 
-    ethdo attester duties --account=Validators/00001 --epoch=12345
+    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
@@ -47,19 +47,15 @@ In quiet mode this will return 0 if a duty from the attester is found, otherwise
 func init() {
 	attesterCmd.AddCommand(attesterDutiesCmd)
 	attesterFlags(attesterDutiesCmd)
-	attesterDutiesCmd.Flags().Int64("epoch", -1, "the last complete epoch")
-	attesterDutiesCmd.Flags().String("pubkey", "", "the public key of the attester")
-	attesterDutiesCmd.Flags().Bool("json", false, "Generate JSON data for an exit; do not broadcast to network")
+	attesterDutiesCmd.Flags().String("epoch", "head", "the epoch for which to obtain the duties")
+	attesterDutiesCmd.Flags().String("validator", "", "the index, public key, or acount of the validator")
 }
 
-func attesterDutiesBindings() {
-	if err := viper.BindPFlag("epoch", attesterDutiesCmd.Flags().Lookup("epoch")); err != nil {
+func attesterDutiesBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("epoch", cmd.Flags().Lookup("epoch")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("pubkey", attesterDutiesCmd.Flags().Lookup("pubkey")); err != nil {
-		panic(err)
-	}
-	if err := viper.BindPFlag("json", attesterDutiesCmd.Flags().Lookup("json")); err != nil {
+	if err := viper.BindPFlag("validator", cmd.Flags().Lookup("validator")); err != nil {
 		panic(err)
 	}
 }

cmd/attesterinclusion.go

@@ -26,10 +26,10 @@ var attesterInclusionCmd = &cobra.Command{
 	Short: "Obtain information about attester inclusion",
 	Long: `Obtain information about attester inclusion.  For example:
 
-    ethdo attester inclusion --account=Validators/00001 --epoch=12345
+    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
@@ -47,19 +47,19 @@ In quiet mode this will return 0 if an attestation from the attester is found on
 func init() {
 	attesterCmd.AddCommand(attesterInclusionCmd)
 	attesterFlags(attesterInclusionCmd)
-	attesterInclusionCmd.Flags().Int64("epoch", -1, "the last complete epoch")
-	attesterInclusionCmd.Flags().String("pubkey", "", "the public key of the attester")
+	attesterInclusionCmd.Flags().String("epoch", "-1", "the epoch for which to obtain the inclusion")
+	attesterInclusionCmd.Flags().String("validator", "", "the index, public key, or account of the validator")
 	attesterInclusionCmd.Flags().String("index", "", "the index of the attester")
 }
 
-func attesterInclusionBindings() {
-	if err := viper.BindPFlag("epoch", attesterInclusionCmd.Flags().Lookup("epoch")); err != nil {
+func attesterInclusionBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("epoch", cmd.Flags().Lookup("epoch")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("pubkey", attesterInclusionCmd.Flags().Lookup("pubkey")); err != nil {
+	if err := viper.BindPFlag("validator", cmd.Flags().Lookup("validator")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("index", attesterInclusionCmd.Flags().Lookup("index")); err != nil {
+	if err := viper.BindPFlag("index", cmd.Flags().Lookup("index")); err != nil {
 		panic(err)
 	}
 }

cmd/block.go

@@ -17,7 +17,7 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// blockCmd represents the block command
+// blockCmd represents the block command.
 var blockCmd = &cobra.Command{
 	Use:   "block",
 	Short: "Obtain information about an Ethereum 2 block",
@@ -28,5 +28,5 @@ func init() {
 	RootCmd.AddCommand(blockCmd)
 }
 
-func blockFlags(cmd *cobra.Command) {
+func blockFlags(_ *cobra.Command) {
 }

cmd/block/analyze/command.go

@@ -34,6 +34,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Operation.
 	blockID    string
@@ -105,7 +106,7 @@ type attestationData struct {
 	Index int         `json:"index"`
 }
 
-func newCommand(ctx context.Context) (*command, error) {
+func newCommand(_ context.Context) (*command, error) {
 	c := &command{
 		quiet:             viper.GetBool("quiet"),
 		verbose:           viper.GetBool("verbose"),
@@ -124,6 +125,7 @@ func newCommand(ctx 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,33 +83,32 @@ 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")
 				continue
-			} else {
-				builder.WriteString(", ")
 			}
+			builder.WriteString(", ")
 			switch {
 			case !attestation.HeadCorrect:
 				builder.WriteString("head vote incorrect, ")
@@ -138,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

@@ -1,4 +1,4 @@
-// Copyright © 2022 Weald Technology Trading.
+// Copyright © 2022, 2023 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
@@ -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 {
@@ -77,11 +87,7 @@ func (c *command) analyze(ctx context.Context, block *spec.VersionedSignedBeacon
 		return err
 	}
 
-	if err := c.analyzeSyncCommittees(ctx, block); err != nil {
-		return err
-	}
-
-	return nil
+	return c.analyzeSyncCommittees(ctx, block)
 }
 
 func (c *command) analyzeAttestations(ctx context.Context, block *spec.VersionedSignedBeaconBlock) error {
@@ -101,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 {
@@ -183,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)
 	}
@@ -213,11 +355,11 @@ func (c *command) fetchParents(ctx context.Context, block *spec.VersionedSignedB
 	return c.fetchParents(ctx, parentBlock, minSlot)
 }
 
-func (c *command) processParentBlock(ctx context.Context, block *spec.VersionedSignedBeaconBlock) error {
-	attestations, err := block.Attestations()
-	if err != nil {
-		return err
-	}
+func (c *command) processParentBlock(_ context.Context, block *spec.VersionedSignedBeaconBlock) error {
+	//	attestations, err := block.Attestations()
+	//	if err != nil {
+	//		return err
+	//	}
 	slot, err := block.Slot()
 	if err != nil {
 		return err
@@ -226,31 +368,40 @@ func (c *command) processParentBlock(ctx context.Context, block *spec.VersionedS
 		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
 }
@@ -259,15 +410,20 @@ func (c *command) setup(ctx context.Context) error {
 	var err error
 
 	// Connect to the client.
-	c.eth2Client, err = util.ConnectToBeaconNode(ctx, c.connection, c.timeout, c.allowInsecureConnections)
+	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+		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")
 	}
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
-		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 {
-				return false, 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,29 +556,110 @@ 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, 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 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) analyzeSyncCommittees(ctx context.Context, block *spec.VersionedSignedBeaconBlock) error {
+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
+		}
+	}
+	return bytes.Equal(root[:], attestation.Data.Target.Root[:]), nil
+}
+
+func (c *command) analyzeSyncCommittees(_ context.Context, block *spec.VersionedSignedBeaconBlock) error {
 	c.analysis.SyncCommitee = &syncCommitteeAnalysis{}
 	switch block.Version {
 	case spec.DataVersionPhase0:
@@ -439,6 +685,13 @@ func (c *command) analyzeSyncCommittees(ctx context.Context, block *spec.Version
 		c.analysis.SyncCommitee.Value = c.analysis.SyncCommitee.Score * float64(c.analysis.SyncCommitee.Contributions)
 		c.analysis.Value += c.analysis.SyncCommitee.Value
 		return nil
+	case spec.DataVersionDeneb:
+		c.analysis.SyncCommitee.Contributions = int(block.Deneb.Message.Body.SyncAggregate.SyncCommitteeBits.Count())
+		c.analysis.SyncCommitee.PossibleContributions = int(block.Deneb.Message.Body.SyncAggregate.SyncCommitteeBits.Len())
+		c.analysis.SyncCommitee.Score = float64(c.syncRewardWeight) / float64(c.weightDenominator)
+		c.analysis.SyncCommitee.Value = c.analysis.SyncCommitee.Score * float64(c.analysis.SyncCommitee.Contributions)
+		c.analysis.Value += c.analysis.SyncCommitee.Value
+		return nil
 	default:
 		return fmt.Errorf("unsupported block version %d", block.Version)
 	}

cmd/block/analyze/process_internal_test.go

@@ -39,7 +39,7 @@ func TestProcess(t *testing.T) {
 				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
 				"blockid":    "invalid",
 			},
-			err: "failed to obtain beacon block: failed to request signed beacon block: GET failed with status 400: {\"code\":400,\"message\":\"Invalid block: invalid\"}",
+			err: "failed to obtain beacon block: failed to request signed beacon block: GET failed with status 400: {\"code\":400,\"message\":\"BAD_REQUEST: Unsupported endpoint version: v2\",\"stacktraces\":[]}",
 		},
 	}
 

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

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019 - 2023 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
@@ -34,8 +34,9 @@ type dataIn struct {
 	jsonOutput bool
 	sszOutput  bool
 	// Chain information.
-	blockID string
-	stream  bool
+	blockID   string
+	blockTime string
+	stream    bool
 }
 
 func input(ctx context.Context) (*dataIn, error) {
@@ -50,21 +51,21 @@ func input(ctx context.Context) (*dataIn, error) {
 	data.debug = viper.GetBool("debug")
 	data.jsonOutput = viper.GetBool("json")
 	data.sszOutput = viper.GetBool("ssz")
-
+	data.blockID = viper.GetString("blockid")
+	data.blockTime = viper.GetString("block-time")
 	data.stream = viper.GetBool("stream")
 
 	var err error
-	data.eth2Client, err = util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
+	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+		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
 	}
 
-	if viper.GetString("blockid") == "" {
-		data.blockID = "head"
-	} else {
-		// Specific slot.
-		data.blockID = viper.GetString("blockid")
-	}
-
 	return data, nil
 }

cmd/block/info/input_internal_test.go

@@ -61,13 +61,6 @@ func TestInput(t *testing.T) {
 			vars: map[string]interface{}{},
 			err:  "timeout is required",
 		},
-		{
-			name: "ConnectionMissing",
-			vars: map[string]interface{}{
-				"timeout": "5s",
-			},
-			err: "failed to connect to any beacon node",
-		},
 		{
 			name: "ConnectionBad",
 			vars: map[string]interface{}{

cmd/block/info/output.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020, 2021 Weald Technology Trading
+// Copyright © 2019 - 2023 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,14 +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"
@@ -43,7 +47,7 @@ type dataOut struct {
 	slotsPerEpoch uint64
 }
 
-func output(ctx context.Context, data *dataOut) (string, error) {
+func output(_ context.Context, data *dataOut) (string, error) {
 	if data == nil {
 		return "", errors.New("no data")
 	}
@@ -51,9 +55,10 @@ func output(ctx context.Context, data *dataOut) (string, error) {
 	return "", nil
 }
 
-func outputBlockGeneral(ctx context.Context,
+func outputBlockGeneral(_ context.Context,
 	verbose bool,
 	slot phase0.Slot,
+	proposerIndex phase0.ValidatorIndex,
 	blockRoot phase0.Root,
 	bodyRoot phase0.Root,
 	parentRoot phase0.Root,
@@ -69,6 +74,7 @@ func outputBlockGeneral(ctx context.Context,
 	res := strings.Builder{}
 
 	res.WriteString(fmt.Sprintf("Slot: %d\n", slot))
+	res.WriteString(fmt.Sprintf("Proposing validator index: %d\n", proposerIndex))
 	res.WriteString(fmt.Sprintf("Epoch: %d\n", phase0.Epoch(uint64(slot)/slotsPerEpoch)))
 	res.WriteString(fmt.Sprintf("Timestamp: %v\n", time.Unix(genesisTime.Unix()+int64(slot)*int64(slotDuration.Seconds()), 0)))
 	res.WriteString(fmt.Sprintf("Block root: %#x\n", blockRoot))
@@ -89,7 +95,7 @@ func outputBlockGeneral(ctx context.Context,
 	return res.String(), nil
 }
 
-func outputBlockETH1Data(ctx context.Context, eth1Data *phase0.ETH1Data) (string, error) {
+func outputBlockETH1Data(_ context.Context, eth1Data *phase0.ETH1Data) (string, error) {
 	res := strings.Builder{}
 
 	res.WriteString(fmt.Sprintf("Ethereum 1 deposit count: %d\n", eth1Data.DepositCount))
@@ -113,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)
 							}
@@ -163,11 +171,14 @@ 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))
 			}
 
@@ -194,7 +205,121 @@ func outputBlockAttesterSlashings(ctx context.Context, eth2Client eth2client.Ser
 	return res.String(), nil
 }
 
-func outputBlockDeposits(ctx context.Context, verbose bool, deposits []*phase0.Deposit) (string, error) {
+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))
+			}
+
+			// 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 outputBlockDeposits(_ context.Context, verbose bool, deposits []*phase0.Deposit) (string, error) {
 	res := strings.Builder{}
 
 	// Deposits.
@@ -220,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))
 			}
 		}
@@ -240,13 +368,16 @@ 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: %#x\n", op.Message.ToExecutionAddress))
+				res.WriteString(fmt.Sprintf("    Execution address: %s\n", op.Message.ToExecutionAddress.String()))
 			}
 		}
 	}
@@ -262,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))
@@ -272,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")
@@ -314,6 +447,7 @@ func outputCapellaBlockText(ctx context.Context, data *dataOut, signedBlock *cap
 	tmp, err := outputBlockGeneral(ctx,
 		data.verbose,
 		signedBlock.Message.Slot,
+		signedBlock.Message.ProposerIndex,
 		blockRoot,
 		bodyRoot,
 		signedBlock.Message.ParentRoot,
@@ -388,6 +522,226 @@ func outputCapellaBlockText(ctx context.Context, data *dataOut, signedBlock *cap
 	return res.String(), nil
 }
 
+func outputDenebBlockText(ctx context.Context,
+	data *dataOut,
+	signedBlock *deneb.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 = outputBlockAttestations(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.Attestations)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Attester slashings.
+	tmp, err = outputBlockAttesterSlashings(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 = outputDenebBlockExecutionPayload(ctx, data.verbose, signedBlock.Message.Body.ExecutionPayload)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	tmp, err = outputDenebBlobInfo(ctx, data.verbose, signedBlock.Message.Body, blobs)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	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")
@@ -410,6 +764,7 @@ func outputBellatrixBlockText(ctx context.Context, data *dataOut, signedBlock *b
 	tmp, err := outputBlockGeneral(ctx,
 		data.verbose,
 		signedBlock.Message.Slot,
+		signedBlock.Message.ProposerIndex,
 		blockRoot,
 		bodyRoot,
 		signedBlock.Message.ParentRoot,
@@ -500,6 +855,7 @@ func outputAltairBlockText(ctx context.Context, data *dataOut, signedBlock *alta
 	tmp, err := outputBlockGeneral(ctx,
 		data.verbose,
 		signedBlock.Message.Slot,
+		signedBlock.Message.ProposerIndex,
 		blockRoot,
 		bodyRoot,
 		signedBlock.Message.ParentRoot,
@@ -583,6 +939,7 @@ func outputPhase0BlockText(ctx context.Context, data *dataOut, signedBlock *phas
 	tmp, err := outputBlockGeneral(ctx,
 		data.verbose,
 		signedBlock.Message.Slot,
+		signedBlock.Message.ProposerIndex,
 		blockRoot,
 		bodyRoot,
 		signedBlock.Message.ParentRoot,
@@ -638,7 +995,7 @@ func outputPhase0BlockText(ctx context.Context, data *dataOut, signedBlock *phas
 	return res.String(), nil
 }
 
-func outputCapellaBlockExecutionPayload(ctx context.Context,
+func outputCapellaBlockExecutionPayload(_ context.Context,
 	verbose bool,
 	payload *capella.ExecutionPayload,
 ) (
@@ -676,7 +1033,7 @@ func outputCapellaBlockExecutionPayload(ctx context.Context,
 		res.WriteString("  Parent hash: ")
 		res.WriteString(fmt.Sprintf("%#x\n", payload.ParentHash))
 		res.WriteString("  Fee recipient: ")
-		res.WriteString(fmt.Sprintf("%#x\n", payload.FeeRecipient))
+		res.WriteString(payload.FeeRecipient.String())
 		res.WriteString("  Gas limit: ")
 		res.WriteString(fmt.Sprintf("%d\n", payload.GasLimit))
 		res.WriteString("  Gas used: ")
@@ -690,7 +1047,11 @@ func outputCapellaBlockExecutionPayload(ctx context.Context,
 		res.WriteString("  State root: ")
 		res.WriteString(fmt.Sprintf("%#x\n", payload.StateRoot))
 		res.WriteString("  Extra data: ")
-		res.WriteString(fmt.Sprintf("%#x\n", payload.ExtraData))
+		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: ")
@@ -702,7 +1063,195 @@ func outputCapellaBlockExecutionPayload(ctx context.Context,
 	return res.String(), nil
 }
 
-func outputBellatrixBlockExecutionPayload(ctx context.Context,
+func outputDenebBlockExecutionPayload(_ context.Context,
+	verbose bool,
+	payload *deneb.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 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,
+	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
+}
+
+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
+}
+
+func outputBellatrixBlockExecutionPayload(_ context.Context,
 	verbose bool,
 	payload *bellatrix.ExecutionPayload,
 ) (
@@ -740,7 +1289,7 @@ func outputBellatrixBlockExecutionPayload(ctx context.Context,
 		res.WriteString("  Parent hash: ")
 		res.WriteString(fmt.Sprintf("%#x\n", payload.ParentHash))
 		res.WriteString("  Fee recipient: ")
-		res.WriteString(fmt.Sprintf("%#x\n", payload.FeeRecipient))
+		res.WriteString(payload.FeeRecipient.String())
 		res.WriteString("  Gas limit: ")
 		res.WriteString(fmt.Sprintf("%d\n", payload.GasLimit))
 		res.WriteString("  Gas used: ")

cmd/block/info/process.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019 - 2023 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
@@ -17,26 +17,39 @@ 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"
 )
 
-var jsonOutput bool
-var sszOutput bool
-var results *dataOut
+var (
+	jsonOutput bool
+	sszOutput  bool
+	results    *dataOut
+)
 
 func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	if data == nil {
 		return nil, errors.New("no data")
 	}
+	if data.blockID == "" && data.blockTime == "" {
+		return nil, errors.New("no block ID or block time")
+	}
 
 	results = &dataOut{
 		debug:      data.debug,
@@ -44,40 +57,83 @@ 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)
 
-	signedBlock, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, data.blockID)
+	if data.blockTime != "" {
+		data.blockID, err = timeToBlockID(ctx, data.eth2Client, data.blockTime)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	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 {
-		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:
+		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 := 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:
@@ -100,61 +156,65 @@ 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.
 	if event.Topic != "head" {
 		return
 	}
 
-	blockID := fmt.Sprintf("%#x", event.Data.(*api.HeadEvent).Block[:])
-	signedBlock, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(context.Background(), 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:
-		if err := outputPhase0Block(context.Background(), jsonOutput, signedBlock.Phase0); err != nil {
-			if !jsonOutput && !sszOutput {
-				fmt.Printf("Failed to output block: %v\n", err)
-			}
-			return
-		}
+		err = outputPhase0Block(ctx, jsonOutput, block.Phase0)
 	case spec.DataVersionAltair:
-		if err := outputAltairBlock(context.Background(), jsonOutput, sszOutput, signedBlock.Altair); err != nil {
-			if !jsonOutput && !sszOutput {
-				fmt.Printf("Failed to output block: %v\n", err)
-			}
-			return
-		}
+		err = outputAltairBlock(ctx, jsonOutput, sszOutput, block.Altair)
 	case spec.DataVersionBellatrix:
-		if err := outputBellatrixBlock(context.Background(), jsonOutput, sszOutput, signedBlock.Bellatrix); err != nil {
-			if !jsonOutput && !sszOutput {
-				fmt.Printf("Failed to output block: %v\n", err)
-			}
-			return
-		}
+		err = outputBellatrixBlock(ctx, jsonOutput, sszOutput, block.Bellatrix)
 	case spec.DataVersionCapella:
-		if err := outputCapellaBlock(context.Background(), jsonOutput, sszOutput, signedBlock.Capella); err != nil {
-			if !jsonOutput && !sszOutput {
-				fmt.Printf("Failed to output block: %v\n", err)
-			}
-			return
+		err = outputCapellaBlock(ctx, jsonOutput, sszOutput, block.Capella)
+	case spec.DataVersionDeneb:
+		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, 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:
-		if !jsonOutput && !sszOutput {
-			fmt.Printf("Unknown block version: %v\n", signedBlock.Version)
-		}
+		err = errors.New("unknown block version")
+	}
+	if err != nil && !jsonOutput && !sszOutput {
+		fmt.Printf("Failed to output block: %v\n", err)
 		return
 	}
+
 	if !jsonOutput && !sszOutput {
 		fmt.Println("")
 	}
@@ -249,3 +309,99 @@ func outputCapellaBlock(ctx context.Context, jsonOutput bool, sszOutput bool, si
 	}
 	return nil
 }
+
+func outputDenebBlock(ctx context.Context,
+	jsonOutput bool,
+	sszOutput bool,
+	signedBlock *deneb.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 := outputDenebBlockText(ctx, results, signedBlock, blobs)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate text")
+		}
+		fmt.Print(data)
+	}
+	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
+
+	switch {
+	case strings.HasPrefix(input, "0x"):
+		// Hex string.
+		hexTime, err := strconv.ParseInt(strings.TrimPrefix(input, "0x"), 16, 64)
+		if err != nil {
+			return "", errors.Wrap(err, "failed to parse block time as hex string")
+		}
+		timestamp = time.Unix(hexTime, 0)
+	case !strings.Contains(input, ":"):
+		// No colon, assume decimal string.
+		decTime, err := strconv.ParseInt(input, 10, 64)
+		if err != nil {
+			return "", errors.Wrap(err, "failed to parse block time as decimal string")
+		}
+		timestamp = time.Unix(decTime, 0)
+	default:
+		dateTime, err := time.Parse("2006-01-02T15:04:05", input)
+		if err != nil {
+			return "", errors.Wrap(err, "failed to parse block time as datetime")
+		}
+		timestamp = dateTime
+	}
+
+	// Assume timestamp.
+	chainTime, err := standardchaintime.New(ctx,
+		standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithGenesisProvider(eth2Client.(eth2client.GenesisProvider)),
+	)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to set up chaintime service")
+	}
+
+	return fmt.Sprintf("%d", chainTime.TimestampToSlot(timestamp)), nil
+}

cmd/block/info/process_internal_test.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019 - 2023 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
@@ -43,11 +43,11 @@ func TestProcess(t *testing.T) {
 			err:  "no data",
 		},
 		{
-			name: "Client",
+			name: "NoBlockID",
 			dataIn: &dataIn{
 				eth2Client: eth2Client,
 			},
-			err: "empty beacon block",
+			err: "no block ID",
 		},
 	}
 

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
@@ -49,17 +49,13 @@ func init() {
 	blockFlags(blockAnalyzeCmd)
 	blockAnalyzeCmd.Flags().String("blockid", "head", "the ID of the block to fetch")
 	blockAnalyzeCmd.Flags().Bool("stream", false, "continually stream blocks as they arrive")
-	blockAnalyzeCmd.Flags().Bool("json", false, "output data in JSON format")
 }
 
-func blockAnalyzeBindings() {
-	if err := viper.BindPFlag("blockid", blockAnalyzeCmd.Flags().Lookup("blockid")); err != nil {
+func blockAnalyzeBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("blockid", cmd.Flags().Lookup("blockid")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("stream", blockAnalyzeCmd.Flags().Lookup("stream")); err != nil {
-		panic(err)
-	}
-	if err := viper.BindPFlag("json", blockAnalyzeCmd.Flags().Lookup("json")); err != nil {
+	if err := viper.BindPFlag("stream", cmd.Flags().Lookup("stream")); err != nil {
 		panic(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
@@ -48,22 +48,22 @@ func init() {
 	blockCmd.AddCommand(blockInfoCmd)
 	blockFlags(blockInfoCmd)
 	blockInfoCmd.Flags().String("blockid", "head", "the ID of the block to fetch")
+	blockInfoCmd.Flags().String("block-time", "", "the time of the block to fetch (format YYYY-MM-DDTHH:MM:SS, or a hex or decimal timestamp")
 	blockInfoCmd.Flags().Bool("stream", false, "continually stream blocks as they arrive")
-	blockInfoCmd.Flags().Bool("json", false, "output data in JSON format")
 	blockInfoCmd.Flags().Bool("ssz", false, "output data in SSZ format")
 }
 
-func blockInfoBindings() {
-	if err := viper.BindPFlag("blockid", blockInfoCmd.Flags().Lookup("blockid")); err != nil {
+func blockInfoBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("blockid", cmd.Flags().Lookup("blockid")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("stream", blockInfoCmd.Flags().Lookup("stream")); err != nil {
+	if err := viper.BindPFlag("block-time", cmd.Flags().Lookup("block-time")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("json", blockInfoCmd.Flags().Lookup("json")); err != nil {
+	if err := viper.BindPFlag("stream", cmd.Flags().Lookup("stream")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("ssz", blockInfoCmd.Flags().Lookup("ssz")); err != nil {
+	if err := viper.BindPFlag("ssz", cmd.Flags().Lookup("ssz")); err != nil {
 		panic(err)
 	}
 }

cmd/chain.go

@@ -17,7 +17,7 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// chainCmd represents the chain command
+// chainCmd represents the chain command.
 var chainCmd = &cobra.Command{
 	Use:   "chain",
 	Short: "Obtain information about an Ethereum 2 chain",
@@ -28,5 +28,5 @@ func init() {
 	RootCmd.AddCommand(chainCmd)
 }
 
-func chainFlags(cmd *cobra.Command) {
+func chainFlags(_ *cobra.Command) {
 }

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
@@ -60,12 +63,13 @@ type vote struct {
 	Count int              `json:"count"`
 }
 
-func newCommand(ctx context.Context) (*command, error) {
+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) {
@@ -42,7 +44,7 @@ func (c *command) output(ctx context.Context) (string, error) {
 	return c.outputText(ctx)
 }
 
-func (c *command) outputJSON(ctx context.Context) (string, error) {
+func (c *command) outputJSON(_ context.Context) (string, error) {
 	votes := make([]*vote, 0, len(c.votes))
 	totalVotes := 0
 	for _, vote := range c.votes {
@@ -57,11 +59,13 @@ func (c *command) outputJSON(ctx 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 {
@@ -71,13 +75,18 @@ func (c *command) outputJSON(ctx context.Context) (string, error) {
 	return string(data), nil
 }
 
-func (c *command) outputText(ctx context.Context) (string, error) {
+func (c *command) outputText(_ context.Context) (string, error) {
 	builder := strings.Builder{}
 
 	builder.WriteString("Voting period: ")
 	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

@@ -1,4 +1,4 @@
-// Copyright © 2022 Weald Technology Trading.
+// Copyright © 2022, 2023 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,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,28 +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 = phase0.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.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 {
@@ -114,15 +126,20 @@ func (c *command) setup(ctx context.Context) error {
 	var err error
 
 	// Connect to the client.
-	c.eth2Client, err = util.ConnectToBeaconNode(ctx, c.connection, c.timeout, c.allowInsecureConnections)
+	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+		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")
 	}
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
-		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")
@@ -138,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")
 	}
@@ -152,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
@@ -47,12 +48,13 @@ type command struct {
 	exitQueue       int
 }
 
-func newCommand(ctx context.Context) (*command, error) {
+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/output.go

@@ -36,7 +36,7 @@ func (c *command) output(ctx context.Context) (string, error) {
 	return c.outputText(ctx)
 }
 
-func (c *command) outputJSON(ctx context.Context) (string, error) {
+func (c *command) outputJSON(_ context.Context) (string, error) {
 	output := &jsonOutput{
 		ActivationQueue: c.activationQueue,
 		ExitQueue:       c.exitQueue,
@@ -49,7 +49,7 @@ func (c *command) outputJSON(ctx context.Context) (string, error) {
 	return string(data), nil
 }
 
-func (c *command) outputText(ctx context.Context) (string, error) {
+func (c *command) outputText(_ context.Context) (string, error) {
 	builder := strings.Builder{}
 
 	if c.activationQueue > 0 {

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
 		}
@@ -58,15 +61,20 @@ func (c *command) setup(ctx context.Context) error {
 	var err error
 
 	// Connect to the client.
-	c.eth2Client, err = util.ConnectToBeaconNode(ctx, c.connection, c.timeout, c.allowInsecureConnections)
+	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+		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")
 	}
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
-		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,12 +31,13 @@ type dataIn struct {
 	// Input
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 	timestamp                string
 	slot                     string
 	epoch                    string
 }
 
-func input(ctx context.Context) (*dataIn, error) {
+func input(_ context.Context) (*dataIn, error) {
 	data := &dataIn{}
 
 	if viper.GetDuration("timeout") == 0 {
@@ -73,6 +74,7 @@ func input(ctx 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"
 
@@ -34,6 +35,7 @@ type dataOut struct {
 	slot                          spec.Slot
 	slotStart                     time.Time
 	slotEnd                       time.Time
+	hasSyncCommittees             bool
 	syncCommitteePeriod           uint64
 	syncCommitteePeriodStart      time.Time
 	syncCommitteePeriodEpochStart spec.Epoch
@@ -41,7 +43,7 @@ type dataOut struct {
 	syncCommitteePeriodEpochEnd   spec.Epoch
 }
 
-func output(ctx context.Context, data *dataOut) (string, error) {
+func output(_ context.Context, data *dataOut) (string, error) {
 	if data == nil {
 		return "", errors.New("no data")
 	}
@@ -56,27 +58,59 @@ func output(ctx context.Context, data *dataOut) (string, error) {
 	builder.WriteString(fmt.Sprintf("%d", data.epoch))
 	builder.WriteString("\n  Epoch start ")
 	builder.WriteString(data.epochStart.Format("2006-01-02 15:04:05"))
+	if data.verbose {
+		builder.WriteString(" (")
+		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(strconv.FormatInt(data.epochEnd.Unix(), 10))
+		builder.WriteString(")")
+	}
 
 	builder.WriteString("\nSlot ")
 	builder.WriteString(fmt.Sprintf("%d", data.slot))
 	builder.WriteString("\n  Slot start ")
 	builder.WriteString(data.slotStart.Format("2006-01-02 15:04:05"))
+	if data.verbose {
+		builder.WriteString(" (")
+		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(strconv.FormatInt(data.slotEnd.Unix(), 10))
+		builder.WriteString(")")
+	}
 
-	builder.WriteString("\nSync committee period ")
-	builder.WriteString(fmt.Sprintf("%d", data.syncCommitteePeriod))
-	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))
-	builder.WriteString(")\n  Sync committee period end ")
-	builder.WriteString(data.syncCommitteePeriodEnd.Format("2006-01-02 15:04:05"))
-	builder.WriteString(" (epoch ")
-	builder.WriteString(fmt.Sprintf("%d", data.syncCommitteePeriodEpochEnd))
-	builder.WriteString(")\n")
+	if data.hasSyncCommittees {
+		builder.WriteString("\nSync committee period ")
+		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(strconv.FormatInt(data.syncCommitteePeriodStart.Unix(), 10))
+		}
+		builder.WriteString(")\n  Sync committee period end ")
+		builder.WriteString(data.syncCommitteePeriodEnd.Format("2006-01-02 15:04:05"))
+		builder.WriteString(" (epoch ")
+		builder.WriteString(fmt.Sprintf("%d", data.syncCommitteePeriodEpochEnd))
+		if data.verbose {
+			builder.WriteString(", ")
+			builder.WriteString(strconv.FormatInt(data.syncCommitteePeriodEnd.Unix(), 10))
+		}
+		builder.WriteString(")")
+	}
+
+	builder.WriteString("\n")
 
 	return builder.String(), nil
 }

cmd/chain/time/process.go

@@ -21,6 +21,7 @@ import (
 	eth2client "github.com/attestantio/go-eth2-client"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
 	"github.com/wealdtech/ethdo/util"
 )
 
@@ -29,22 +30,23 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		return nil, errors.New("no data")
 	}
 
-	eth2Client, err := util.ConnectToBeaconNode(ctx, data.connection, data.timeout, data.allowInsecureConnections)
+	eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+		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")
 	}
 
-	config, err := eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	chainTime, err := standardchaintime.New(ctx,
+		standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithGenesisProvider(eth2Client.(eth2client.GenesisProvider)),
+	)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to obtain beacon chain configuration")
-	}
-
-	slotsPerEpoch := config["SLOTS_PER_EPOCH"].(uint64)
-	slotDuration := config["SECONDS_PER_SLOT"].(time.Duration)
-	epochsPerSyncCommitteePeriod := config["EPOCHS_PER_SYNC_COMMITTEE_PERIOD"].(uint64)
-	genesis, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to obtain genesis data")
+		return nil, errors.Wrap(err, "failed to set up chaintime service")
 	}
 
 	results := &dataOut{
@@ -62,34 +64,33 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		}
 		results.slot = phase0.Slot(slot)
 	case data.epoch != "":
-		epoch, err := strconv.ParseUint(data.epoch, 10, 64)
+		epoch, err := util.ParseEpoch(ctx, chainTime, data.epoch)
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to parse epoch")
 		}
-		results.slot = phase0.Slot(epoch * slotsPerEpoch)
+		results.slot = chainTime.FirstSlotOfEpoch(epoch)
 	case data.timestamp != "":
 		timestamp, err := time.Parse("2006-01-02T15:04:05-0700", data.timestamp)
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to parse timestamp")
 		}
-		secs := timestamp.Sub(genesis.GenesisTime)
-		if secs < 0 {
-			return nil, errors.New("timestamp prior to genesis")
-		}
-		results.slot = phase0.Slot(secs / slotDuration)
+		results.slot = chainTime.TimestampToSlot(timestamp)
 	}
 
 	// Fill in the info given the slot.
-	results.slotStart = genesis.GenesisTime.Add(time.Duration(results.slot) * slotDuration)
-	results.slotEnd = genesis.GenesisTime.Add(time.Duration(results.slot+1) * slotDuration)
-	results.epoch = phase0.Epoch(uint64(results.slot) / slotsPerEpoch)
-	results.epochStart = genesis.GenesisTime.Add(time.Duration(uint64(results.epoch)*slotsPerEpoch) * slotDuration)
-	results.epochEnd = genesis.GenesisTime.Add(time.Duration(uint64(results.epoch+1)*slotsPerEpoch) * slotDuration)
-	results.syncCommitteePeriod = uint64(results.epoch) / epochsPerSyncCommitteePeriod
-	results.syncCommitteePeriodEpochStart = phase0.Epoch(results.syncCommitteePeriod * epochsPerSyncCommitteePeriod)
-	results.syncCommitteePeriodEpochEnd = phase0.Epoch((results.syncCommitteePeriod+1)*epochsPerSyncCommitteePeriod) - 1
-	results.syncCommitteePeriodStart = genesis.GenesisTime.Add(time.Duration(uint64(results.syncCommitteePeriodEpochStart)*slotsPerEpoch) * slotDuration)
-	results.syncCommitteePeriodEnd = genesis.GenesisTime.Add(time.Duration(uint64(results.syncCommitteePeriodEpochEnd)*slotsPerEpoch) * slotDuration)
+	results.slotStart = chainTime.StartOfSlot(results.slot)
+	results.slotEnd = chainTime.StartOfSlot(results.slot + 1)
+	results.epoch = chainTime.SlotToEpoch(results.slot)
+	results.epochStart = chainTime.StartOfEpoch(results.epoch)
+	results.epochEnd = chainTime.StartOfEpoch(results.epoch + 1)
+	if results.epoch >= chainTime.FirstEpochOfSyncPeriod(chainTime.AltairInitialSyncCommitteePeriod()) {
+		results.hasSyncCommittees = true
+		results.syncCommitteePeriod = chainTime.SlotToSyncCommitteePeriod(results.slot)
+		results.syncCommitteePeriodEpochStart = chainTime.FirstEpochOfSyncPeriod(results.syncCommitteePeriod)
+		results.syncCommitteePeriodEpochEnd = chainTime.FirstEpochOfSyncPeriod(results.syncCommitteePeriod + 1)
+		results.syncCommitteePeriodStart = chainTime.StartOfEpoch(results.syncCommitteePeriodEpochStart)
+		results.syncCommitteePeriodEnd = chainTime.StartOfEpoch(results.syncCommitteePeriodEpochEnd)
+	}
 
 	return results, nil
 }

cmd/chain/time/process_internal_test.go

@@ -1,4 +1,4 @@
-// Copyright © 2021 Weald Technology Trading
+// Copyright © 2021 - 2023 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,7 +15,6 @@ package chaintime
 
 import (
 	"context"
-	"fmt"
 	"os"
 	"testing"
 	"time"
@@ -47,16 +46,11 @@ func TestProcess(t *testing.T) {
 				slot:                     "1",
 			},
 			expected: &dataOut{
-				epochStart:                    time.Unix(1606824023, 0),
-				epochEnd:                      time.Unix(1606824407, 0),
-				slot:                          1,
-				slotStart:                     time.Unix(1606824035, 0),
-				slotEnd:                       time.Unix(1606824047, 0),
-				syncCommitteePeriod:           0,
-				syncCommitteePeriodStart:      time.Unix(1606824023, 0),
-				syncCommitteePeriodEnd:        time.Unix(1606921943, 0),
-				syncCommitteePeriodEpochStart: 0,
-				syncCommitteePeriodEpochEnd:   255,
+				epochStart: time.Unix(1606824023, 0),
+				epochEnd:   time.Unix(1606824407, 0),
+				slot:       1,
+				slotStart:  time.Unix(1606824035, 0),
+				slotEnd:    time.Unix(1606824047, 0),
 			},
 		},
 		{
@@ -68,17 +62,12 @@ func TestProcess(t *testing.T) {
 				epoch:                    "2",
 			},
 			expected: &dataOut{
-				epoch:                         2,
-				epochStart:                    time.Unix(1606824791, 0),
-				epochEnd:                      time.Unix(1606825175, 0),
-				slot:                          64,
-				slotStart:                     time.Unix(1606824791, 0),
-				slotEnd:                       time.Unix(1606824803, 0),
-				syncCommitteePeriod:           0,
-				syncCommitteePeriodStart:      time.Unix(1606824023, 0),
-				syncCommitteePeriodEnd:        time.Unix(1606921943, 0),
-				syncCommitteePeriodEpochStart: 0,
-				syncCommitteePeriodEpochEnd:   255,
+				epoch:      2,
+				epochStart: time.Unix(1606824791, 0),
+				epochEnd:   time.Unix(1606825175, 0),
+				slot:       64,
+				slotStart:  time.Unix(1606824791, 0),
+				slotEnd:    time.Unix(1606824803, 0),
 			},
 		},
 		{
@@ -87,20 +76,21 @@ func TestProcess(t *testing.T) {
 				connection:               os.Getenv("ETHDO_TEST_CONNECTION"),
 				timeout:                  10 * time.Second,
 				allowInsecureConnections: true,
-				timestamp:                "2021-01-01T00:00:00+0000",
+				timestamp:                "2023-01-01T00:00:00+0000",
 			},
 			expected: &dataOut{
-				epoch:                         6862,
-				epochStart:                    time.Unix(1609459031, 0),
-				epochEnd:                      time.Unix(1609459415, 0),
-				slot:                          219598,
-				slotStart:                     time.Unix(1609459199, 0),
-				slotEnd:                       time.Unix(1609459211, 0),
-				syncCommitteePeriod:           26,
-				syncCommitteePeriodStart:      time.Unix(1609379927, 0),
-				syncCommitteePeriodEnd:        time.Unix(1609477847, 0),
-				syncCommitteePeriodEpochStart: 6656,
-				syncCommitteePeriodEpochEnd:   6911,
+				epoch:                         171112,
+				epochStart:                    time.Unix(1672531031, 0),
+				epochEnd:                      time.Unix(1672531415, 0),
+				slot:                          5475598,
+				slotStart:                     time.Unix(1672531199, 0),
+				slotEnd:                       time.Unix(1672531211, 0),
+				hasSyncCommittees:             true,
+				syncCommitteePeriod:           668,
+				syncCommitteePeriodStart:      time.Unix(1672491095, 0),
+				syncCommitteePeriodEnd:        time.Unix(1672589399, 0),
+				syncCommitteePeriodEpochStart: 171008,
+				syncCommitteePeriodEpochEnd:   171264,
 			},
 		},
 	}
@@ -112,7 +102,6 @@ func TestProcess(t *testing.T) {
 				require.EqualError(t, err, test.err)
 			} else {
 				require.NoError(t, err)
-				fmt.Printf("****** %d %d\n", res.syncCommitteePeriodStart.Unix(), res.syncCommitteePeriodEnd.Unix())
 				require.Equal(t, test.expected, res)
 			}
 		})

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
@@ -58,11 +59,12 @@ type command struct {
 	additionalInfo                           string
 }
 
-func newCommand(ctx context.Context) (*command, error) {
+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/output.go

@@ -18,7 +18,7 @@ import (
 	"strings"
 )
 
-func (c *command) output(ctx context.Context) (string, error) {
+func (c *command) output(_ context.Context) (string, error) {
 	if c.quiet {
 		return "", nil
 	}

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"
@@ -38,6 +39,7 @@ func (c *command) process(ctx context.Context) error {
 	err := json.Unmarshal([]byte(c.data), c.item)
 	if err != nil {
 		c.additionalInfo = err.Error()
+		//nolint:nilerr
 		return nil
 	}
 	c.itemStructureValid = true
@@ -84,7 +86,13 @@ func (c *command) setup(ctx context.Context) error {
 	var err error
 
 	// Connect to the client.
-	c.eth2Client, err = util.ConnectToBeaconNode(ctx, c.connection, c.timeout, c.allowInsecureConnections)
+	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+		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")
 	}
@@ -97,45 +105,48 @@ 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
 }
 
-// isAggregator returns true if the given
+// isAggregator returns true if the given.
 func (c *command) isAggregator(ctx context.Context) (bool, error) {
 	// Calculate the modulo.
 	specProvider, isProvider := c.eth2Client.(eth2client.SpecProvider)
 	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 {
@@ -204,6 +215,7 @@ func (c *command) confirmContributionSignature(ctx context.Context) error {
 	_, err := e2types.BLSSignatureFromBytes(sigBytes)
 	if err != nil {
 		c.additionalInfo = err.Error()
+		//nolint:nilerr
 		return nil
 	}
 	c.contributionSignatureValidFormat = true
@@ -219,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)
@@ -256,6 +271,7 @@ func (c *command) confirmContributionAndProofSignature(ctx context.Context) erro
 	sig, err := e2types.BLSSignatureFromBytes(sigBytes)
 	if err != nil {
 		c.additionalInfo = err.Error()
+		//nolint:nilerr
 		return nil
 	}
 	c.contributionAndProofSignatureValidFormat = true

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
@@ -51,17 +51,13 @@ func init() {
 	chainFlags(chainEth1VotesCmd)
 	chainEth1VotesCmd.Flags().String("epoch", "", "epoch for which to fetch the votes")
 	chainEth1VotesCmd.Flags().String("period", "", "period for which to fetch the votes")
-	chainEth1VotesCmd.Flags().Bool("json", false, "output data in JSON format")
 }
 
-func chainEth1VotesBindings() {
-	if err := viper.BindPFlag("epoch", chainEth1VotesCmd.Flags().Lookup("epoch")); err != nil {
+func chainEth1VotesBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("epoch", cmd.Flags().Lookup("epoch")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("period", chainEth1VotesCmd.Flags().Lookup("period")); err != nil {
-		panic(err)
-	}
-	if err := viper.BindPFlag("json", chainEth1VotesCmd.Flags().Lookup("json")); err != nil {
+	if err := viper.BindPFlag("period", cmd.Flags().Lookup("period")); err != nil {
 		panic(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, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
+		eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+			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 quiet {
+		if viper.GetBool("quiet") {
 			os.Exit(_exitSuccess)
 		}
 
-		if viper.GetBool("prepare-offline") {
-			fmt.Printf("Add the following to your command to run it offline:\n  --offline --genesis-validators=root=%#x --fork-version=%#x\n", genesis.GenesisValidatorsRoot, fork.CurrentVersion)
-			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(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)
-		if verbose {
+
+		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)
 	},
@@ -89,11 +97,7 @@ In quiet mode this will return 0 if the chain information can be obtained, other
 func init() {
 	chainCmd.AddCommand(chainInfoCmd)
 	chainFlags(chainInfoCmd)
-	chainInfoCmd.Flags().Bool("prepare-offline", false, "Provide information useful for offline commands")
 }
 
-func chainInfoBindings() {
-	if err := viper.BindPFlag("prepare-offline", chainInfoCmd.Flags().Lookup("prepare-offline")); err != nil {
-		panic(err)
-	}
+func chainInfoBindings(_ *cobra.Command) {
 }

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
@@ -48,14 +48,10 @@ func init() {
 	chainCmd.AddCommand(chainQueuesCmd)
 	chainFlags(chainQueuesCmd)
 	chainQueuesCmd.Flags().String("epoch", "", "epoch for which to fetch the queues")
-	chainQueuesCmd.Flags().Bool("json", false, "output data in JSON format")
 }
 
-func chainQueuesBindings() {
-	if err := viper.BindPFlag("epoch", chainQueuesCmd.Flags().Lookup("epoch")); err != nil {
-		panic(err)
-	}
-	if err := viper.BindPFlag("json", chainQueuesCmd.Flags().Lookup("json")); err != nil {
+func chainQueuesBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("epoch", cmd.Flags().Lookup("epoch")); err != nil {
 		panic(err)
 	}
 }

cmd/chainspec.go

@@ -0,0 +1,100 @@
+// Copyright © 2023 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"context"
+	"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"
+	"github.com/wealdtech/ethdo/util"
+)
+
+var chainSpecCmd = &cobra.Command{
+	Use:   "spec",
+	Short: "Obtain specification for a chain",
+	Long: `Obtain specification for a chain.  For example:
+
+    ethdo chain spec
+
+In quiet mode this will return 0 if the chain specification can be obtained, otherwise 1.`,
+	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"),
+			CustomSpecSupport: viper.GetBool("custom-spec"),
+			LogFallback:       !viper.GetBool("quiet"),
+		})
+		errCheck(err, "Failed to connect to Ethereum consensus node")
+
+		specResponse, err := eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
+		errCheck(err, "Failed to obtain chain specification")
+
+		if viper.GetBool("quiet") {
+			return
+		}
+
+		// Tweak the spec for output.
+		for k, v := range specResponse.Data {
+			switch t := v.(type) {
+			case phase0.Version:
+				specResponse.Data[k] = fmt.Sprintf("%#x", t)
+			case phase0.DomainType:
+				specResponse.Data[k] = fmt.Sprintf("%#x", t)
+			case time.Time:
+				specResponse.Data[k] = strconv.FormatInt(t.Unix(), 10)
+			case time.Duration:
+				specResponse.Data[k] = strconv.FormatUint(uint64(t.Seconds()), 10)
+			case []byte:
+				specResponse.Data[k] = fmt.Sprintf("%#x", t)
+			case uint64:
+				specResponse.Data[k] = strconv.FormatUint(t, 10)
+			}
+		}
+
+		if viper.GetBool("json") {
+			data, err := json.Marshal(specResponse.Data)
+			errCheck(err, "Failed to marshal JSON")
+			fmt.Printf("%s\n", string(data))
+		} else {
+			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, specResponse.Data[key])
+			}
+		}
+	},
+}
+
+func init() {
+	chainCmd.AddCommand(chainSpecCmd)
+	chainFlags(chainSpecCmd)
+}
+
+func chainSpecBindings(_ *cobra.Command) {
+}

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,23 +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, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
+		eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+			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.WithForkScheduleProvider(eth2Client.(eth2client.ForkScheduleProvider)),
+			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()
 
@@ -79,7 +89,7 @@ In quiet mode this will return 0 if the chain status can be obtained, otherwise
 		res.WriteString(fmt.Sprintf("%d", epoch))
 		res.WriteString("\n")
 
-		if verbose {
+		if viper.GetBool("verbose") {
 			res.WriteString("Epoch slots: ")
 			res.WriteString(fmt.Sprintf("%d", epochStartSlot))
 			res.WriteString("-")
@@ -102,7 +112,7 @@ In quiet mode this will return 0 if the chain status can be obtained, otherwise
 		res.WriteString("Justified epoch: ")
 		res.WriteString(fmt.Sprintf("%d", finality.Justified.Epoch))
 		res.WriteString("\n")
-		if verbose {
+		if viper.GetBool("verbose") {
 			distance := epoch - finality.Justified.Epoch
 			res.WriteString("Justified epoch distance: ")
 			res.WriteString(fmt.Sprintf("%d", distance))
@@ -112,23 +122,23 @@ In quiet mode this will return 0 if the chain status can be obtained, otherwise
 		res.WriteString("Finalized epoch: ")
 		res.WriteString(fmt.Sprintf("%d", finality.Finalized.Epoch))
 		res.WriteString("\n")
-		if verbose {
+		if viper.GetBool("verbose") {
 			distance := epoch - finality.Finalized.Epoch
 			res.WriteString("Finalized epoch distance: ")
 			res.WriteString(fmt.Sprintf("%d", distance))
 			res.WriteString("\n")
 		}
 
-		if verbose {
+		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() {
@@ -158,10 +168,10 @@ 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 verbose {
+			if viper.GetBool("verbose") {
 				res.WriteString("Sync committee epochs: ")
 				res.WriteString(fmt.Sprintf("%d", periodStartEpoch))
 				res.WriteString("-")

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
@@ -47,14 +47,14 @@ func init() {
 	chainTimeCmd.Flags().String("timestamp", "", "The timestamp for which to obtain information (format YYYY-MM-DDTHH:MM:SS+ZZZZ)")
 }
 
-func chainTimeBindings() {
-	if err := viper.BindPFlag("slot", chainTimeCmd.Flags().Lookup("slot")); err != nil {
+func chainTimeBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("slot", cmd.Flags().Lookup("slot")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("epoch", chainTimeCmd.Flags().Lookup("epoch")); err != nil {
+	if err := viper.BindPFlag("epoch", cmd.Flags().Lookup("epoch")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("timestamp", chainTimeCmd.Flags().Lookup("timestamp")); err != nil {
+	if err := viper.BindPFlag("timestamp", cmd.Flags().Lookup("timestamp")); err != nil {
 		panic(err)
 	}
 }

cmd/chainverify.go

@@ -18,7 +18,7 @@ import (
 	"github.com/spf13/viper"
 )
 
-// chainVerifyCmd represents the chain verify command
+// chainVerifyCmd represents the chain verify command.
 var chainVerifyCmd = &cobra.Command{
 	Use:   "verify",
 	Short: "Verify a beacon chain signature",

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/deposit.go

@@ -17,7 +17,7 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// depositCmd represents the deposit command
+// depositCmd represents the deposit command.
 var depositCmd = &cobra.Command{
 	Use:   "deposit",
 	Short: "Manage Ethereum 2 deposits",
@@ -28,5 +28,5 @@ func init() {
 	RootCmd.AddCommand(depositCmd)
 }
 
-func depositFlags(cmd *cobra.Command) {
+func depositFlags(_ *cobra.Command) {
 }

cmd/depositverify.go

@@ -16,6 +16,7 @@ package cmd
 import (
 	"bytes"
 	"encoding/hex"
+	"encoding/json"
 	"fmt"
 	"os"
 	"strings"
@@ -23,18 +24,21 @@ import (
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 	"github.com/wealdtech/ethdo/util"
 	e2types "github.com/wealdtech/go-eth2-types/v2"
 	eth2util "github.com/wealdtech/go-eth2-util"
 	string2eth "github.com/wealdtech/go-string2eth"
 )
 
-var depositVerifyData string
-var depositVerifyWithdrawalPubKey string
-var depositVerifyWithdrawalAddress string
-var depositVerifyValidatorPubKey string
-var depositVerifyDepositAmount string
-var depositVerifyForkVersion string
+var (
+	depositVerifyData              string
+	depositVerifyWithdrawalPubKey  string
+	depositVerifyWithdrawalAddress string
+	depositVerifyValidatorPubKey   string
+	depositVerifyDepositAmount     string
+	depositVerifyForkVersion       string
+)
 
 var depositVerifyCmd = &cobra.Command{
 	Use:   "verify",
@@ -45,8 +49,8 @@ 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 the data is verified correctly, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
+In quiet mode this will return 0 if the data is verified correctly, otherwise 1.`,
+	Run: func(_ *cobra.Command, _ []string) {
 		assert(depositVerifyData != "", "--data is required")
 		var data []byte
 		var err error
@@ -72,6 +76,12 @@ In quiet mode this will return 0 if the the data is verified correctly, otherwis
 
 		deposits, err := util.DepositInfoFromJSON(data)
 		errCheck(err, "Failed to fetch deposit data")
+		if viper.GetBool("debug") {
+			data, err := json.Marshal(deposits)
+			if err == nil {
+				fmt.Fprintf(os.Stderr, "Deposit data is %s\n", string(data))
+			}
+		}
 
 		var withdrawalCredentials []byte
 		if depositVerifyWithdrawalPubKey != "" {
@@ -90,7 +100,7 @@ In quiet mode this will return 0 if the the data is verified correctly, otherwis
 			withdrawalCredentials[0] = 0x01 // ETH1_ADDRESS_WITHDRAWAL_PREFIX
 			copy(withdrawalCredentials[12:], withdrawalAddressBytes)
 		}
-		outputIf(debug, fmt.Sprintf("Withdrawal credentials are %#x", withdrawalCredentials))
+		outputIf(viper.GetBool("debug"), fmt.Sprintf("Withdrawal credentials are %#x", withdrawalCredentials))
 
 		depositAmount := uint64(0)
 		if depositVerifyDepositAmount != "" {
@@ -118,9 +128,9 @@ In quiet mode this will return 0 if the the data is verified correctly, otherwis
 			}
 			if !verified {
 				failures = true
-				outputIf(!quiet, fmt.Sprintf("%s failed verification", depositName))
+				outputIf(!viper.GetBool("quiet"), fmt.Sprintf("%s failed verification", depositName))
 			} else {
-				outputIf(!quiet, fmt.Sprintf("%s verified", depositName))
+				outputIf(!viper.GetBool("quiet"), fmt.Sprintf("%s verified", depositName))
 			}
 		}
 
@@ -188,34 +198,34 @@ func validatorPubKeysFromInput(input string) (map[[48]byte]bool, error) {
 
 func verifyDeposit(deposit *util.DepositInfo, withdrawalCredentials []byte, validatorPubKeys map[[48]byte]bool, amount uint64) (bool, error) {
 	if withdrawalCredentials == nil {
-		outputIf(!quiet, "Withdrawal public key or address not supplied; withdrawal credentials NOT checked")
+		outputIf(!viper.GetBool("quiet"), "Withdrawal public key or address not supplied; withdrawal credentials NOT checked")
 	} else {
 		if !bytes.Equal(deposit.WithdrawalCredentials, withdrawalCredentials) {
-			outputIf(!quiet, "Withdrawal credentials incorrect")
+			outputIf(!viper.GetBool("quiet"), "Withdrawal credentials incorrect")
 			return false, nil
 		}
-		outputIf(!quiet, "Withdrawal credentials verified")
+		outputIf(!viper.GetBool("quiet"), "Withdrawal credentials verified")
 	}
 	if amount == 0 {
-		outputIf(!quiet, "Amount not supplied; NOT checked")
+		outputIf(!viper.GetBool("quiet"), "Amount not supplied; NOT checked")
 	} else {
 		if deposit.Amount != amount {
-			outputIf(!quiet, "Amount incorrect")
+			outputIf(!viper.GetBool("quiet"), "Amount incorrect")
 			return false, nil
 		}
-		outputIf(!quiet, "Amount verified")
+		outputIf(!viper.GetBool("quiet"), "Amount verified")
 	}
 
 	if len(validatorPubKeys) == 0 {
-		outputIf(!quiet, "Validator public key not suppled; NOT checked")
+		outputIf(!viper.GetBool("quiet"), "Validator public key not suppled; NOT checked")
 	} else {
 		var key [48]byte
 		copy(key[:], deposit.PublicKey)
 		if _, exists := validatorPubKeys[key]; !exists {
-			outputIf(!quiet, "Validator public key incorrect")
+			outputIf(!viper.GetBool("quiet"), "Validator public key incorrect")
 			return false, nil
 		}
-		outputIf(!quiet, "Validator public key verified")
+		outputIf(!viper.GetBool("quiet"), "Validator public key verified")
 	}
 
 	var pubKey phase0.BLSPubKey
@@ -235,34 +245,37 @@ func verifyDeposit(deposit *util.DepositInfo, withdrawalCredentials []byte, vali
 	}
 
 	if bytes.Equal(deposit.DepositDataRoot, depositDataRoot[:]) {
-		outputIf(!quiet, "Deposit data root verified")
+		outputIf(!viper.GetBool("quiet"), "Deposit data root verified")
 	} else {
-		outputIf(!quiet, "Deposit data root incorrect")
+		outputIf(!viper.GetBool("quiet"), "Deposit data root incorrect")
 		return false, nil
 	}
 
 	if len(deposit.ForkVersion) == 0 {
 		if depositVerifyForkVersion != "" {
-			outputIf(!quiet, "Data format does not contain fork version for verification; NOT verified")
+			outputIf(!viper.GetBool("quiet"), "Data format does not contain fork version for verification; NOT verified")
 		}
 	} else {
 		if depositVerifyForkVersion == "" {
-			outputIf(!quiet, "fork version not supplied; not checked")
+			outputIf(!viper.GetBool("quiet"), "fork version not supplied; not checked")
 		} else {
 			forkVersion, err := hex.DecodeString(strings.TrimPrefix(depositVerifyForkVersion, "0x"))
 			if err != nil {
 				return false, errors.Wrap(err, "failed to decode fork version")
 			}
 			if bytes.Equal(deposit.ForkVersion, forkVersion) {
-				outputIf(!quiet, "Fork version verified")
+				outputIf(!viper.GetBool("quiet"), "Fork version verified")
 			} else {
-				outputIf(!quiet, "Fork version incorrect")
+				outputIf(!viper.GetBool("quiet"), "Fork version incorrect")
 				return false, nil
 			}
 
-			if len(deposit.DepositMessageRoot) != 32 {
-				outputIf(!quiet, "Deposit message root not supplied; not checked")
-			} else {
+			switch {
+			case len(deposit.DepositMessageRoot) != 32:
+				outputIf(!viper.GetBool("quiet"), "Deposit message root not supplied; not checked")
+			case len(withdrawalCredentials) != 32:
+				outputIf(!viper.GetBool("quiet"), "Withdrawal credentials not available; cannot recreate deposit message")
+			default:
 				// We can also verify the deposit message signature.
 				depositMessage := &phase0.DepositMessage{
 					PublicKey:             pubKey,
@@ -275,9 +288,9 @@ func verifyDeposit(deposit *util.DepositInfo, withdrawalCredentials []byte, vali
 				}
 
 				if bytes.Equal(deposit.DepositMessageRoot, depositMessageRoot[:]) {
-					outputIf(!quiet, "Deposit message root verified")
+					outputIf(!viper.GetBool("quiet"), "Deposit message root verified")
 				} else {
-					outputIf(!quiet, "Deposit message root incorrect")
+					outputIf(!viper.GetBool("quiet"), "Deposit message root incorrect")
 					return false, nil
 				}
 
@@ -303,9 +316,9 @@ func verifyDeposit(deposit *util.DepositInfo, withdrawalCredentials []byte, vali
 				}
 				signatureVerified := blsSig.Verify(containerRoot[:], validatorPubKey)
 				if signatureVerified {
-					outputIf(!quiet, "Deposit message signature verified")
+					outputIf(!viper.GetBool("quiet"), "Deposit message signature verified")
 				} else {
-					outputIf(!quiet, "Deposit message signature NOT verified")
+					outputIf(!viper.GetBool("quiet"), "Deposit message signature NOT verified")
 					return false, nil
 				}
 			}

cmd/epoch.go

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

cmd/epoch/summary/command.go

@@ -18,6 +18,7 @@ import (
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/spf13/viper"
@@ -33,6 +34,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Operation.
 	epoch      string
@@ -49,6 +51,9 @@ type command struct {
 	beaconCommitteesProvider   eth2client.BeaconCommitteesProvider
 	beaconBlockHeadersProvider eth2client.BeaconBlockHeadersProvider
 
+	// Caches.
+	blocksCache map[string]*spec.VersionedSignedBeaconBlock
+
 	// Results.
 	summary *epochSummary
 }
@@ -67,6 +72,7 @@ type epochSummary struct {
 	TargetCorrectValidators    int                          `json:"target_correct_validators"`
 	TargetTimelyValidators     int                          `json:"target_timely_validators"`
 	NonParticipatingValidators []*nonParticipatingValidator `json:"nonparticipating_validators"`
+	Blobs                      int                          `json:"blobs"`
 }
 
 type epochProposal struct {
@@ -86,12 +92,13 @@ type nonParticipatingValidator struct {
 	Committee phase0.CommitteeIndex `json:"committee_index"`
 }
 
-func newCommand(ctx context.Context) (*command, error) {
+func newCommand(_ context.Context) (*command, error) {
 	c := &command{
-		quiet:   viper.GetBool("quiet"),
-		verbose: viper.GetBool("verbose"),
-		debug:   viper.GetBool("debug"),
-		summary: &epochSummary{},
+		quiet:       viper.GetBool("quiet"),
+		verbose:     viper.GetBool("verbose"),
+		debug:       viper.GetBool("debug"),
+		summary:     &epochSummary{},
+		blocksCache: make(map[string]*spec.VersionedSignedBeaconBlock),
 	}
 
 	// Timeout.
@@ -102,6 +109,7 @@ func newCommand(ctx 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

@@ -1,4 +1,4 @@
-// Copyright © 2022 Weald Technology Trading.
+// Copyright © 2022, 2023 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
@@ -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"
@@ -51,20 +52,19 @@ func (c *command) process(ctx context.Context) error {
 	if err := c.processSyncCommitteeDuties(ctx); err != nil {
 		return err
 	}
-
-	return nil
+	return c.processBlobs(ctx)
 }
 
 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 {
-		block, err := c.blocksProvider.SignedBeaconBlock(ctx, fmt.Sprintf("%d", duty.Slot))
+
+	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))
 		}
@@ -80,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
 		}
@@ -93,6 +95,7 @@ func (c *command) activeValidators(ctx context.Context) (map[phase0.ValidatorInd
 
 	return activeValidators, nil
 }
+
 func (c *command) processAttesterDuties(ctx context.Context) error {
 	activeValidators, err := c.activeValidators(ctx)
 	if err != nil {
@@ -164,7 +167,7 @@ func (c *command) processSlots(ctx context.Context,
 	headersCache := util.NewBeaconBlockHeaderCache(c.beaconBlockHeadersProvider)
 
 	for slot := firstSlot; slot <= lastSlot; slot++ {
-		block, err := c.blocksProvider.SignedBeaconBlock(ctx, fmt.Sprintf("%d", slot))
+		block, err := c.fetchBlock(ctx, fmt.Sprintf("%d", slot))
 		if err != nil {
 			return 0, 0, 0, 0, 0, 0, nil, nil, errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", slot))
 		}
@@ -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)
 					}
@@ -202,25 +211,28 @@ func (c *command) processSlots(ctx context.Context,
 							Slot:      beaconCommittee.Slot,
 							Committee: beaconCommittee.Index,
 						}
-
 					}
 				}
-				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{}{}
@@ -241,6 +253,7 @@ func (c *command) processSlots(ctx context.Context,
 			}
 		}
 	}
+
 	return len(votes),
 		len(headCorrects),
 		len(headTimelys),
@@ -258,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")
 	}
@@ -272,7 +288,7 @@ func (c *command) processSyncCommitteeDuties(ctx context.Context) error {
 	}
 
 	for slot := c.summary.FirstSlot; slot <= c.summary.LastSlot; slot++ {
-		block, err := c.blocksProvider.SignedBeaconBlock(ctx, fmt.Sprintf("%d", slot))
+		block, err := c.fetchBlock(ctx, fmt.Sprintf("%d", slot))
 		if err != nil {
 			return errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", slot))
 		}
@@ -280,19 +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
-		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) {
@@ -328,15 +339,20 @@ func (c *command) setup(ctx context.Context) error {
 	var err error
 
 	// Connect to the client.
-	c.eth2Client, err = util.ConnectToBeaconNode(ctx, c.connection, c.timeout, c.allowInsecureConnections)
+	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+		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")
 	}
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
-		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")
@@ -370,3 +386,54 @@ func (c *command) setup(ctx context.Context) error {
 
 	return nil
 }
+
+func (c *command) processBlobs(ctx context.Context) error {
+	for slot := c.summary.FirstSlot; slot <= c.summary.LastSlot; slot++ {
+		block, err := c.fetchBlock(ctx, fmt.Sprintf("%d", slot))
+		if err != nil {
+			return errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", slot))
+		}
+		if block == nil {
+			continue
+		}
+		switch block.Version {
+		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)
+		case spec.DataVersionElectra:
+			c.summary.Blobs += len(block.Electra.Message.Body.BlobKZGCommitments)
+		default:
+			return fmt.Errorf("unhandled block version %v", block.Version)
+		}
+	}
+
+	return nil
+}
+
+func (c *command) fetchBlock(ctx context.Context,
+	blockID string,
+) (
+	*spec.VersionedSignedBeaconBlock,
+	error,
+) {
+	block, exists := c.blocksCache[blockID]
+	if !exists {
+		var err error
+		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
@@ -47,12 +47,8 @@ In quiet mode this will return 0 if information for the epoch is found, otherwis
 func init() {
 	epochCmd.AddCommand(epochSummaryCmd)
 	epochFlags(epochSummaryCmd)
-	epochSummaryCmd.Flags().Bool("json", false, "output data in JSON format")
 }
 
-func epochSummaryBindings() {
-	epochBindings()
-	if err := viper.BindPFlag("json", epochSummaryCmd.Flags().Lookup("json")); err != nil {
-		panic(err)
-	}
+func epochSummaryBindings(cmd *cobra.Command) {
+	epochBindings(cmd)
 }

cmd/err.go

@@ -16,12 +16,14 @@ package cmd
 import (
 	"fmt"
 	"os"
+
+	"github.com/spf13/viper"
 )
 
-// errCheck checks for an error and quits if it is present
+// errCheck checks for an error and quits if it is present.
 func errCheck(err error, msg string) {
 	if err != nil {
-		if !quiet {
+		if !viper.GetBool("quiet") {
 			if msg == "" {
 				fmt.Fprintf(os.Stderr, "%s\n", err.Error())
 			} else {
@@ -48,16 +50,16 @@ func errCheck(err error, msg string) {
 // 	}
 // }
 
-// assert checks a condition and quits if it is false
+// assert checks a condition and quits if it is false.
 func assert(condition bool, msg string) {
 	if !condition {
 		die(msg)
 	}
 }
 
-// die prints an error and quits
+// die prints an error and quits.
 func die(msg string) {
-	if msg != "" && !quiet {
+	if msg != "" && !viper.GetBool("quiet") {
 		fmt.Fprintf(os.Stderr, "%s\n", msg)
 	}
 	os.Exit(_exitFailure)

cmd/exit.go

@@ -17,7 +17,7 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// exitCmd represents the exit command
+// exitCmd represents the exit command.
 var exitCmd = &cobra.Command{
 	Use:   "exit",
 	Short: "Manage Ethereum 2 voluntary exits",
@@ -28,5 +28,5 @@ func init() {
 	RootCmd.AddCommand(exitCmd)
 }
 
-func exitFlags(cmd *cobra.Command) {
+func exitFlags(_ *cobra.Command) {
 }

cmd/exitverify.go

@@ -14,80 +14,100 @@
 package cmd
 
 import (
-	"bytes"
 	"context"
-	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"os"
 	"strings"
 
-	eth2client "github.com/attestantio/go-eth2-client"
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	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"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"github.com/wealdtech/ethdo/util"
 	e2types "github.com/wealdtech/go-eth2-types/v2"
-	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
-var exitVerifyPubKey string
-
 var exitVerifyCmd = &cobra.Command{
 	Use:   "verify",
 	Short: "Verify exit data is valid",
 	Long: `Verify that exit data generated by "ethdo validator exit" is correct for a given account.  For example:
 
-    ethdo exit verify --data=exitdata.json --account=primary/current
+    ethdo exit verify --signed-operation=exitdata.json --validator=primary/current
 
-In quiet mode this will return 0 if the the exit is verified correctly, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
+In quiet mode this will return 0 if the exit is verified correctly, otherwise 1.`,
+	Run: func(_ *cobra.Command, _ []string) {
 		ctx := context.Background()
 
-		assert(viper.GetString("account") != "" || exitVerifyPubKey != "", "account or public key is required")
-		account, err := exitVerifyAccount(ctx)
-		errCheck(err, "Failed to obtain account")
+		assert(viper.GetString("signed-operation") != "", "signed-operation is required")
+		signedOp, err := obtainSignedOperation(viper.GetString("signed-operation"))
+		errCheck(err, "Failed to obtain signed operation")
 
-		assert(viper.GetString("exit") != "", "exit is required")
-		data, err := obtainExitData(viper.GetString("exit"))
-		errCheck(err, "Failed to obtain exit data")
-
-		// Confirm signature is good.
-		eth2Client, err := util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
+		eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+			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")
 
-		genesis, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
-		errCheck(err, "Failed to obtain beacon chain genesis")
+		validator, err := util.ParseValidator(ctx, eth2Client.(consensusclient.ValidatorsProvider), fmt.Sprintf("%d", signedOp.Message.ValidatorIndex), "head")
+		errCheck(err, "failed to obtain validator")
+		pubkey, err := validator.PubKey(ctx)
+		errCheck(err, "failed to obtain validator public key")
+		account, err := util.ParseAccount(ctx, pubkey.String(), nil, false)
+		errCheck(err, "failed to obtain account")
 
-		domain := e2types.Domain(e2types.DomainVoluntaryExit, data.ForkVersion[:], genesis.GenesisValidatorsRoot[:])
-		var exitDomain spec.Domain
-		copy(exitDomain[:], domain)
-		exit := &spec.VoluntaryExit{
-			Epoch:          data.Exit.Message.Epoch,
-			ValidatorIndex: data.Exit.Message.ValidatorIndex,
-		}
-		exitRoot, err := exit.HashTreeRoot()
+		// Ensure the validator is in a suitable state.
+		assert(validator.Status == v1.ValidatorStateActiveOngoing, "validator not in a suitable state to exit")
+
+		// Obtain the hash tree root of the message to check the signature.
+		opRoot, err := signedOp.Message.HashTreeRoot()
 		errCheck(err, "Failed to obtain exit hash tree root")
+
+		genesisResponse, err := eth2Client.(consensusclient.GenesisProvider).Genesis(ctx, &api.GenesisOpts{})
+		errCheck(err, "Failed to obtain beacon chain genesis")
+		genesis := genesisResponse.Data
+
+		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.
 		signatureBytes := make([]byte, 96)
-		copy(signatureBytes, data.Exit.Signature[:])
+		copy(signatureBytes, signedOp.Signature[:])
 		sig, err := e2types.BLSSignatureFromBytes(signatureBytes)
 		errCheck(err, "Invalid signature")
-		verified, err := util.VerifyRoot(account, exitRoot, exitDomain, sig)
+
+		verified := false
+
+		// Try with the current fork.
+		domain := phase0.Domain{}
+		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")
-		assert(verified, "Voluntary exit failed to verify")
+		if !verified {
+			// Try again with the previous fork.
+			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)
+			errCheck(err, "Failed to verify voluntary exit")
+		}
+		assert(verified, "Voluntary exit failed to verify against current and previous fork versions")
 
-		fork, err := eth2Client.(eth2client.ForkProvider).Fork(ctx, "head")
-		errCheck(err, "Failed to obtain current fork")
-		assert(bytes.Equal(data.ForkVersion[:], fork.CurrentVersion[:]) || bytes.Equal(data.ForkVersion[:], fork.PreviousVersion[:]), "Exit is for an old fork version and is no longer valid")
-
-		outputIf(verbose, "Verified")
+		outputIf(viper.GetBool("verbose"), "Verified")
 		os.Exit(_exitSuccess)
 	},
 }
 
-// obtainExitData obtains exit data from an input, could be JSON itself or a path to JSON.
-func obtainExitData(input string) (*util.ValidatorExitData, error) {
+// obtainSignedOperation obtains exit data from an input, could be JSON itself or a path to JSON.
+func obtainSignedOperation(input string) (*phase0.SignedVoluntaryExit, error) {
 	var err error
 	var data []byte
 	// Input could be JSON or a path to JSON
@@ -101,46 +121,23 @@ func obtainExitData(input string) (*util.ValidatorExitData, error) {
 			return nil, errors.Wrap(err, "failed to find deposit data file")
 		}
 	}
-	exitData := &util.ValidatorExitData{}
-	err = json.Unmarshal(data, exitData)
+	signedOp := &phase0.SignedVoluntaryExit{}
+	err = json.Unmarshal(data, signedOp)
 	if err != nil {
 		return nil, errors.Wrap(err, "data is not valid JSON")
 	}
 
-	return exitData, nil
-}
-
-// exitVerifyAccount obtains the account for the exitVerify command.
-func exitVerifyAccount(ctx context.Context) (e2wtypes.Account, error) {
-	var account e2wtypes.Account
-	var err error
-	if viper.GetString("account") != "" {
-		_, account, err = walletAndAccountFromPath(ctx, viper.GetString("account"))
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to obtain account")
-		}
-	} else {
-		pubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(exitVerifyPubKey, "0x"))
-		if err != nil {
-			return nil, errors.Wrap(err, fmt.Sprintf("failed to decode public key %s", exitVerifyPubKey))
-		}
-		account, err = util.NewScratchAccount(nil, pubKeyBytes)
-		if err != nil {
-			return nil, errors.Wrap(err, fmt.Sprintf("invalid public key %s", exitVerifyPubKey))
-		}
-	}
-	return account, nil
+	return signedOp, nil
 }
 
 func init() {
 	exitCmd.AddCommand(exitVerifyCmd)
 	exitFlags(exitVerifyCmd)
-	exitVerifyCmd.Flags().String("exit", "", "JSON data, or path to JSON data")
-	exitVerifyCmd.Flags().StringVar(&exitVerifyPubKey, "pubkey", "", "Public key for which to verify exit")
+	exitVerifyCmd.Flags().String("signed-operation", "", "JSON data, or path to JSON data")
 }
 
-func exitVerifyBindings() {
-	if err := viper.BindPFlag("exit", exitVerifyCmd.Flags().Lookup("exit")); err != nil {
+func exitVerifyBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("signed-operation", cmd.Flags().Lookup("signed-operation")); err != nil {
 		panic(err)
 	}
 }

cmd/node.go

@@ -17,7 +17,7 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// nodeCmd represents the node command
+// nodeCmd represents the node command.
 var nodeCmd = &cobra.Command{
 	Use:   "node",
 	Short: "Obtain information about an Ethereum 2 node",
@@ -28,5 +28,5 @@ func init() {
 	RootCmd.AddCommand(nodeCmd)
 }
 
-func nodeFlags(cmd *cobra.Command) {
+func nodeFlags(_ *cobra.Command) {
 }

cmd/node/events/input.go

@@ -50,7 +50,13 @@ func input(ctx context.Context) (*dataIn, error) {
 	data.topics = viper.GetStringSlice("topics")
 
 	var err error
-	data.eth2Client, err = util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
+	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+		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/input_internal_test.go

@@ -61,13 +61,6 @@ func TestInput(t *testing.T) {
 			vars: map[string]interface{}{},
 			err:  "timeout is required",
 		},
-		{
-			name: "ConnectionMissing",
-			vars: map[string]interface{}{
-				"timeout": "5s",
-			},
-			err: "failed to connect to any beacon node",
-		},
 		{
 			name: "ConnectionBad",
 			vars: map[string]interface{}{

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.