Bump version.

Fixes #83

.github/workflows/golangci-lint.yml

@@ -1,23 +1,23 @@
 name: golangci-lint
-on: [ push, pull_request ]
+on:
+  push:
+    branches:
+    - master
+  pull_request:
+
+permissions:
+  contents: read
+
 jobs:
   golangci:
     name: lint
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
+    runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v2
-      - name: golangci-lint
-        uses: golangci/golangci-lint-action@v2
+      - uses: actions/setup-go@v3
         with:
-          # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
-          version: v1.29
-
-          # Optional: working directory, useful for monorepos
-          # working-directory: somedir
-
-          # Optional: golangci-lint command line arguments.
-          args: --timeout=10m
-
-          # Optional: show only new issues if it's a pull request. The default value is `false`.
-          # only-new-issues: true
+          go-version: '1.20'
+      - uses: actions/checkout@v3
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v3
+        with:
+          args: --timeout=60m

.github/workflows/release.yml

@@ -4,153 +4,203 @@ on:
   push:
     tags:
     - 'v*'
+    - 't*'
 
 jobs:
-  build:
-    name: Build
-    runs-on: ubuntu-latest
+  # Set variables that will be available to all builds.
+  env_vars:
+    runs-on: ubuntu-22.04
+    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
 
-    - name: Set up Go 1.x
-      uses: actions/setup-go@v2
-      with:
-        go-version: ^1.13
-      id: go
+  # Create a github release to hold the assets once built.
+  create_release:
+    runs-on: ubuntu-22.04
+    needs: env_vars
+    outputs:
+      upload_url: ${{ steps.release_action.outputs.upload_url }}
+    steps:
+      - name: Create Release
+        id: release_action
+        uses: ncipollo/release-action@v1
+        with:
+          name: Release ${{ needs.env_vars.outputs.release_version }}
+          draft: true
+          prerelease: false
 
-    - name: Check out code into the Go module directory
-      uses: actions/checkout@v2
+  # Build and pack the binaries for linux.
+  build_linux:
+    runs-on: ubuntu-22.04
+    needs: [create_release, env_vars]
+    steps:
+      - name: Set up Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: '^1.20'
 
-    - name: Get dependencies
-      run: |
-       go get -v -t -d ./...
-       if [ -f Gopkg.toml ]; then
-         curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
-         dep ensure
-       fi
+      - name: Check out repository into the Go module directory
+        uses: actions/checkout@v3
 
-    - name: Set env
-      run: |
-       echo "GO111MODULE=on" >> $GITHUB_ENV
-       # Release tag comes from the github reference.
-       RELEASE_TAG=$(echo ${GITHUB_REF} | sed -e 's!.*/!!')
-       echo "RELEASE_TAG=${RELEASE_TAG}" >> $GITHUB_ENV
-       echo "::set-output name=RELEASE_TAG::${RELEASE_TAG}"
-       # Ensure the release tag has expected format.
-       echo ${RELEASE_TAG} | grep -q '^v' || exit 1
-       # Release version is same as release tag without leading 'v'.
-       RELEASE_VERSION=$(echo ${GITHUB_REF} | sed -e 's!.*/v!!')
-       echo "RELEASE_VERSION=${RELEASE_VERSION}" >> $GITHUB_ENV
-       echo "::set-output name=RELEASE_VERSION::${RELEASE_VERSION}"
+      - name: Select correct tag
+        run: git checkout ${{ github.ref_name }}
 
-    - name: Build
-      run: go build -v -ldflags="-X github.com/wealdtech/ethdo/cmd.ReleaseVersion=${RELEASE_VERSION}" .
+      - name: Fetch repository dependencies
+        run: go get -v -t ./...
 
-    - name: Test
-      run: go test -v .
+      - name: Compile
+        run: |
+          # 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
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        with:
+          upload_url: ${{ needs.create_release.outputs.upload_url }}
+          asset_path: ./${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-linux-amd64.tar.gz
+          asset_name: ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-linux-amd64.tar.gz
+          asset_content_type: application/octet-stream
 
-    - name: Fetch xgo
-      run: |
-       go get github.com/suburbandad/xgo
+      - name: Upload hash
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        with:
+          upload_url: ${{ needs.create_release.outputs.upload_url }}
+          asset_path: ./${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-linux-amd64.tar.gz.sha256
+          asset_name: ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-linux-amd64.tar.gz.sha256
+          asset_content_type: text/plain
 
-    - name: Cross-compile linux
-      run: |
-        xgo -v -x -ldflags="-X github.com/wealdtech/ethdo/cmd.ReleaseVersion=${RELEASE_VERSION}" --targets="linux/amd64,linux/arm64" github.com/wealdtech/ethdo
+      - name: Cross compile (ARM64)
+        run: |
+          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
 
-    - name: Cross-compile windows
-      run: |
-        xgo -v -x -ldflags="-X github.com/wealdtech/ethdo/cmd.ReleaseVersion=${RELEASE_VERSION} -s -w -extldflags -static" --targets="windows/amd64" github.com/wealdtech/ethdo
+      - name: Upload binary (ARM64)
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        with:
+          upload_url: ${{ needs.create_release.outputs.upload_url }}
+          asset_path: ./${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-linux-arm64.tar.gz
+          asset_name: ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-linux-arm64.tar.gz
+          asset_content_type: application/octet-stream
 
-    - name: Create windows release files
-      run: |
-       mv ethdo-windows-4.0-amd64.exe ethdo.exe
-       sha256sum ethdo.exe >ethdo-${RELEASE_VERSION}-windows.sha256
-       zip --junk-paths ethdo-${RELEASE_VERSION}-windows-exe.zip ethdo.exe
+      - name: Upload hash (ARM64)
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        with:
+          upload_url: ${{ needs.create_release.outputs.upload_url }}
+          asset_path: ./${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-linux-arm64.tar.gz.sha256
+          asset_name: ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-linux-arm64.tar.gz.sha256
+          asset_content_type: text/plain
 
-    - name: Create linux AMD64 tgz file
-      run: |
-       mv ethdo-linux-amd64 ethdo
-       sha256sum ethdo >ethdo-${RELEASE_VERSION}-linux-amd64.sha256
-       tar zcf ethdo-${RELEASE_VERSION}-linux-amd64.tar.gz ethdo
+  # Build and pack the binaries for OSX.
+  build_macos:
+    runs-on: macos-latest
+    needs: [create_release, env_vars]
+    steps:
+      - name: Set up Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: '^1.20'
 
-    - name: Create linux ARM64 tgz file
-      run: |
-       mv ethdo-linux-arm64 ethdo
-       sha256sum ethdo >ethdo-${RELEASE_VERSION}-linux-arm64.sha256
-       tar zcf ethdo-${RELEASE_VERSION}-linux-arm64.tar.gz ethdo
+      - name: Check out repository into the Go module directory
+        uses: actions/checkout@v3
 
-    - name: Create release
-      id: create_release
-      uses: actions/create-release@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        tag_name: ${{ github.ref }}
-        release_name: Release ${{ env.RELEASE_VERSION }}
-        draft: true
-        prerelease: false
+      - name: Select correct tag
+        run: git checkout ${{ github.ref_name }}
 
-    - name: Upload windows checksum file
-      id: upload-release-asset-windows-checksum
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: ./ethdo-${{ env.RELEASE_VERSION }}-windows.sha256
-        asset_name: ethdo-${{ env.RELEASE_VERSION }}-windows.sha256
-        asset_content_type: text/plain
+      - name: Fetch repository dependencies
+        run: go get -v -t ./...
 
-    - name: Upload windows zip file
-      id: upload-release-asset-windows
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: ./ethdo-${{ env.RELEASE_VERSION }}-windows-exe.zip
-        asset_name: ethdo-${{ env.RELEASE_VERSION }}-windows-exe.zip
-        asset_content_type: application/zip
+      - name: Compile
+        run: |
+          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
+      - name: Upload binary
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        with:
+          upload_url: ${{ needs.create_release.outputs.upload_url }}
+          asset_path: ./${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-darwin-amd64.tar.gz
+          asset_name: ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-darwin-amd64.tar.gz
+          asset_content_type: application/octet-stream
 
-    - name: Upload linux AMD64 checksum file
-      id: upload-release-asset-linux-amd64-checksum
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: ./ethdo-${{ env.RELEASE_VERSION }}-linux-amd64.sha256
-        asset_name: ethdo-${{ env.RELEASE_VERSION }}-linux-amd64.sha256
-        asset_content_type: text/plain
+      - name: Upload hash
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        with:
+          upload_url: ${{ needs.create_release.outputs.upload_url }}
+          asset_path: ./${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-darwin-amd64.tar.gz.sha256
+          asset_name: ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-darwin-amd64.tar.gz.sha256
+          asset_content_type: text/plain
 
-    - name: Upload linux AMD64 tgz file
-      id: upload-release-asset-linux-amd64
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: ./ethdo-${{ env.RELEASE_VERSION }}-linux-amd64.tar.gz
-        asset_name: ethdo-${{ env.RELEASE_VERSION }}-linux-amd64.tar.gz
-        asset_content_type: application/gzip
+  # Build and pack the binaries for Windows.
+  build_windows:
+    runs-on: windows-latest
+    needs: [create_release, env_vars]
+    steps:
+      - name: Set up Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: '^1.20'
 
-    - name: Upload linux ARM64 checksum file
-      id: upload-release-asset-linux-arm64-checksum
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: ./ethdo-${{ env.RELEASE_VERSION }}-linux-arm64.sha256
-        asset_name: ethdo-${{ env.RELEASE_VERSION }}-linux-arm64.sha256
-        asset_content_type: text/plain
+      - name: Check out repository into the Go module directory
+        uses: actions/checkout@v3
 
-    - name: Upload linux ARM64 tgz file
-      id: upload-release-asset-linux-arm64
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: ./ethdo-${{ env.RELEASE_VERSION }}-linux-arm64.tar.gz
-        asset_name: ethdo-${{ env.RELEASE_VERSION }}-linux-arm64.tar.gz
-        asset_content_type: application/gzip
+      - name: Select correct tag
+        run: git checkout ${{ github.ref_name }}
+
+      - name: Fetch repository dependencies
+        run: go get -v -t ./...
+
+      - name: Compile
+        run: |
+          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(" ", "")
+          echo "$FileHash" > ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-windows-exe-zip.sha256
+
+      - name: Upload binary
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        with:
+          upload_url: ${{ needs.create_release.outputs.upload_url }}
+          asset_path: ./${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-windows-exe.zip
+          asset_name: ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-windows-exe.zip
+          asset_content_type: application/octet-stream
+
+      - name: Upload hash
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        with:
+          upload_url: ${{ needs.create_release.outputs.upload_url }}
+          asset_path: ./${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-windows-exe-zip.sha256
+          asset_name: ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-windows-exe-zip.sha256
+          asset_content_type: text/plain

.github/workflows/test.yml

@@ -0,0 +1,15 @@
+name: test
+on:
+  push:
+    branches:
+    - master
+  pull_request:
+jobs:
+  test:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/setup-go@v3
+        with:
+          go-version: '1.20'
+      - uses: actions/checkout@v3
+      - uses: n8maninger/action-golang-test@v1

.gitignore

@@ -18,5 +18,8 @@ coverage.html
 # Vim
 *.sw?
 
+# Local JSON files
+*.json
+
 # Local TODO
 TODO.md

.golangci.yml

@@ -0,0 +1,170 @@
+# 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.
+
+# 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
+
+  # Which files to skip: they will be analyzed, but issues from them won't be reported.
+  # Default value is empty list,
+  # but there is no need to include all autogenerated files,
+  # we confidently recognize autogenerated files.
+  # If it's not please let us know.
+  # "/" will be replaced by current OS file path separator to properly work on Windows.
+  skip-files:
+    - ".*_ssz\\.go$"
+
+  # If set we pass it to "go list -mod={option}". From "go help modules":
+  # If invoked with -mod=readonly, the go command is disallowed from the implicit
+  # automatic updating of go.mod described above. Instead, it fails when any changes
+  # 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
+    - dupl
+    - errorlint
+    - exhaustive
+    - exhaustivestruct
+    - exhaustruct
+    - forbidigo
+    - forcetypeassert
+    - funlen
+    - gci
+    - gochecknoglobals
+    - gochecknoinits
+    - gocognit
+    - goconst
+    - goerr113
+    - goheader
+    - golint
+    - gomnd
+    - ifshort
+    - interfacer
+    - ireturn
+    - lll
+    - maintidx
+    - maligned
+    - musttag
+    - nestif
+    - nilnil
+    - nlreturn
+    - nolintlint
+    - nosnakecase
+    - promlinter
+    - rowserrcheck
+    - scopelint
+    - sqlclosecheck
+    - structcheck
+    - unparam
+    - varcheck
+    - varnamelen
+    - wastedassign
+    - wrapcheck
+    - wsl

CHANGELOG.md

@@ -1,3 +1,154 @@
+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
+
+1.26.4:
+  - provide details of BLS to execution change operations with verbose block output
+
+1.26.3:
+  - provide support for additional S3 store options
+  - show error when attempting to delete non-filesystem wallets
+  - provide additional support for Capella
+
+1.26.2
+  - remove check that requires capella prior to generating validator credentials change operations
+
+1.26.1
+  - add ability to generate validator credentials change operations prior to the fork in which they become usable
+
+1.26.0
+  - add commands and documentation to set user validator credentials (not usable until capella)
+
+1.25.3
+  - add more information to "epoch summary"
+  - add "validator summary"
+
+1.25.2:
+  - no longer require connection parameter
+  - support "block analyze" on bellatrix (thanks @tcrossland)
+  - check deposit message root match for verifying deposits (thanks @aaron-alderman)
+
+1.25.0:
+  - add "proposer duties"
+  - add deposit signature verification to "deposit verify"
+
+1.24.1:
+  - fix potential crash when new validators are activated
+  - add "sepolia" to the list of supported networks
+
+1.24.0:
+  - add "validator yield"
+
+1.23.1:
+  - do not fetch future state for chain eth1votes
+
+1.23.0:
+  - do not fetch sync committee information for epoch summaries prior to Altair
+  - ensure that "attester inclusion" without validator returns appropriate error
+  - provide more information in "epoch summary" with verbose flag
+  - add "chain eth1votes"
+
+1.22.0:
+  - add "ropsten" to the list of supported networks
+
+1.21.0:
+  - add "validator credentials get"
+
+1.20.0:
+  - add "chain queues"
+
+1.19.1:
+  - add the ability to import keystores to ethdo wallets
+  - use defaults to connect to beacon nodes if no explicit connection defined
+
+1.19.0:
+  - add "epoch summary"
+
+1.18.2:
+  - tidy up output of "block info"
+
+1.18.1:
+  - do not show execution payload if empty
+
+1.18.0:
+  - add "-ssz" option to "block info"
+  - add "block analyze" command
+  - support bellatrix
+
+1.17.0:
+  - add sync committee information to "chain time"
+  - add details of vote success to "attester inclusion --verbose"
+  - add "synccommittee inclusion"
+
+1.15.1:
+  - provide sync committee slots in "chain status"
+  - clarify that --connection should be a URL
+
+1.15.0:
+  - add --period to "synccommittee members", can be "current", "next"
+  - add "validator expectation"
+
+1.14.0:
+  - add "chain verify signedcontributionandproof"
+  - show both block and body root in "block info"
+  - add exit / withdrawable epoch to "validator info"
+
+1.13.0:
+  - rework and provide additional information to "chain status" output
+
+1.12.0:
+  - add "synccommittee members"
+
+1.11.0
+  - add Altair information to "block info"
+  - add more information to "chain info"
+
+1.10.2
+  - use local shamir code (copied from github.com/hashicorp/vault)
+
+1.10.0
+  - add "wallet sharedexport" and "wallet sharedimport"
+
+1.9.1
+  - Avoid crash when required interfaces for chain status command are not supported
+  - Avoid crash with latest version of herumi/go-bls
+
 1.9.0
   - allow use of Ethereum 1 address as withdrawal credentials
 

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.14-buster as builder
+FROM golang:1.20-bullseye as builder
 
 WORKDIR /app
 
@@ -10,10 +10,12 @@ COPY . .
 
 RUN go build
 
-FROM debian:buster-slim
+FROM debian:bullseye-slim
+
+RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt install -y ca-certificates && apt-get clean && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /app
 
 COPY --from=builder /app/ethdo /app
 
-ENTRYPOINT ["/app/ethdo"]
+ENTRYPOINT ["/app/ethdo"]

README.md

@@ -11,6 +11,7 @@ A command-line tool for managing common tasks in Ethereum 2.
   - [Binaries](#binaries)
   - [Docker](#docker)
   - [Source](#source)
+- [Setting up](#setting-up)
 - [Usage](#usage)
 - [Maintainers](#maintainers)
 - [Contribute](#contribute)
@@ -34,7 +35,7 @@ docker pull wealdtech/ethdo
 `ethdo` is a standard Go program which can be installed with:
 
 ```sh
-GO111MODULE=on go get github.com/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`.
@@ -61,24 +62,53 @@ docker run --network=host ethdo chain status
 
 Alternatively, if the beacon node is running in a separate docker container a shared network can be created with `docker network create eth2` and accessed by adding `--network=eth2` added to both the beacon node and `ethdo` containers.
 
+## Setting up
+
+`ethdo` needs a connection to a beacon node for many of its features.  `ethdo` can connect to any beacon node that fully supports the [standard REST API](https://ethereum.github.io/beacon-APIs/) using the `--connection <beacon-node:port>` argument.  The following changes are required to beacon nodes to make this available.
+
+### Lighthouse
+Lighthouse disables the REST API by default.  To enable it, the beacon node must be started with the `--http` parameter.  If you want to access the REST API from a remote server then you should also look to change the `--http-address` and `--http-allow-origin` options as per the Lighthouse documentation.
+
+The default port for the REST API is 5052, which can be changed with the `--http-port` parameter.
+
+### Nimbus
+Nimbus disables the REST API by default.  To enable it, the beacon node must be started with the `--rest` parameter.  If you want to access the REST API from a remote server then you should also look to change the `--rest-address` and `--rest-allow-origin` options as per the Nimbus documentation.
+
+The default port for the REST API is 5052, which can be changed with the `--rest-port` parameter.
+
+### Prysm
+Prysm enables the REST API by default.  You will need to add the parameter `--grpc-max-msg-size 268435456` to be obtain to obtain large sets of information such as the list of current validators.  If you want to access the REST API from a remote server then you should also look to change the `--grpc-gateway-host` and `--grpc-gateway-corsdomain` options as per the Prysm documentation.
+
+The default port for the REST API is 3500, which can be changed with the `--grpc-gateway-port` parameter.
+
+### Teku
+Teku disables the REST API by default.  To enable it, the beacon node must be started with the `--rest-api-enabled` parameter.  If you want to access the REST API from a remote server then you should also look to change the `--rest-api-interface`, `--rest-api-host-allowlist` and `--rest-api-cors-origins` options as per the Teku documentation.
+
+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 Ethereum 2 blockchain.
+`ethdo` contains a large number of features that are useful for day-to-day interactions with the different consensus clients.
 
 ### Wallets and accounts
 
-ethdo uses the [go-eth2-wallet](https://github.com/wealdtech/go-eth2-wallet) system to provide unified access to different wallet types.  When on the filesystem the locations of the created wallets and accounts are:
+`ethdo` uses the [go-eth2-wallet](https://github.com/wealdtech/go-eth2-wallet) system to provide unified access to different wallet types.  When on the filesystem the locations of the created wallets and accounts are:
 
     - for Linux: $HOME/.config/ethereum2/wallets
     - for OSX: $HOME/Library/Application Support/ethereum2/wallets
     - for Windows: %APPDATA%\ethereum2\wallets
 
-If using the filesystem store, the additional parameter `basedir` can be supplied to change this location.
+If using the filesystem store, the additional parameter `base-dir` can be supplied to change this location.
 
 > If using docker as above you can make this directory accessible to docker to make wallets and accounts persistent.  For example, for linux you could use the following command to list your wallets on Linux:
 >
 > ```
-> docker run -v $HOME/.config/ethereum2/wallets:/data ethdo --basedir=/data wallet list
+> docker run -v $HOME/.config/ethereum2/wallets:/data ethdo --base-dir=/data wallet list
 > ```
 >
 > This will allow you to use `ethdo` with or without docker, with the same location for wallets and accounts.
@@ -113,6 +143,24 @@ ethdo also supports environment variables.  Environment variables are prefixed w
 export ETHDO_PASSPHRASE="my account passphrase"
 ```
 
+### S3 store options
+
+Amazon S3-compatible stores have additional options available, which can be configured under the "stores.s3" key.  An example configuration is as follows:
+
+```json
+{
+  "stores": {
+    "s3": {
+      "bucket":"mybucketname",
+      "path":"path/in/bucket",
+      "passphrase":"secret"
+    }
+  }
+}
+```
+
+Information on these and other options can be found in the S3 store repository.
+
 ### Output and exit status
 
 If set, the `--quiet` argument will suppress all output.
@@ -153,7 +201,7 @@ There is a [HOWTO](https://github.com/wealdtech/ethdo/blob/master/docs/howto.md)
 
 Jim McDonald: [@mcdee](https://github.com/mcdee).
 
-Special thanks to [@SuburbanDad](https://github.com/SuburbanDad) for updating xgo to allow for cross-compilation of `ethdo` releaes.
+Special thanks to [@SuburbanDad](https://github.com/SuburbanDad) for updating xgo to allow for cross-compilation of `ethdo` releases.
 
 ## Contribute
 

beacon/chaininfo.go

@@ -0,0 +1,304 @@
+// 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"
+	"strconv"
+	"strings"
+
+	consensusclient "github.com/attestantio/go-eth2-client"
+	"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
+	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"`
+	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:                        fmt.Sprintf("%d", c.Version),
+		Validators:                     c.Validators,
+		GenesisValidatorsRoot:          fmt.Sprintf("%#x", c.GenesisValidatorsRoot),
+		Epoch:                          fmt.Sprintf("%d", c.Epoch),
+		GenesisForkVersion:             fmt.Sprintf("%#x", c.GenesisForkVersion),
+		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 < 2 {
+		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.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:    2,
+		Validators: make([]*ValidatorInfo, 0),
+		Epoch:      chainTime.CurrentEpoch(),
+	}
+
+	// Obtain validators.
+	validators, err := consensusClient.(consensusclient.ValidatorsProvider).Validators(ctx, "head", nil)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain validators")
+	}
+
+	for _, validator := range validators {
+		res.Validators = append(res.Validators, &ValidatorInfo{
+			Index:                 validator.Index,
+			Pubkey:                validator.Validator.PublicKey,
+			WithdrawalCredentials: validator.Validator.WithdrawalCredentials,
+			State:                 validator.Status,
+		})
+	}
+
+	// Genesis validators root obtained from beacon node.
+	genesis, err := consensusClient.(consensusclient.GenesisProvider).Genesis(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain genesis information")
+	}
+	res.GenesisValidatorsRoot = genesis.GenesisValidatorsRoot
+
+	// Fetch the genesis fork version from the specification.
+	spec, err := consensusClient.(consensusclient.SpecProvider).Spec(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain spec")
+	}
+	tmp, exists := spec["GENESIS_FORK_VERSION"]
+	if !exists {
+		return nil, errors.New("capella 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 current fork version from the fork schedule.
+	forkSchedule, err := consensusClient.(consensusclient.ForkScheduleProvider).ForkSchedule(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain fork schedule")
+	}
+	for i := range forkSchedule {
+		if forkSchedule[i].Epoch <= res.Epoch {
+			res.CurrentForkVersion = forkSchedule[i].CurrentVersion
+		}
+	}
+
+	blsToExecutionChangeDomainType, exists := spec["DOMAIN_BLS_TO_EXECUTION_CHANGE"].(phase0.DomainType)
+	if !exists {
+		return nil, errors.New("failed to obtain DOMAIN_BLS_TO_EXECUTION_CHANGE")
+	}
+	copy(res.BLSToExecutionChangeDomainType[:], blsToExecutionChangeDomainType[:])
+
+	voluntaryExitDomainType, exists := spec["DOMAIN_VOLUNTARY_EXIT"].(phase0.DomainType)
+	if !exists {
+		return nil, errors.New("failed to obtain DOMAIN_VOLUNTARY_EXIT")
+	}
+	copy(res.VoluntaryExitDomainType[:], voluntaryExitDomainType[:])
+
+	return res, nil
+}

beacon/validatorinfo.go

@@ -0,0 +1,106 @@
+// 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 (
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"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 {
+	Index                 phase0.ValidatorIndex
+	Pubkey                phase0.BLSPubKey
+	State                 apiv1.ValidatorState
+	WithdrawalCredentials []byte
+}
+
+type validatorInfoJSON struct {
+	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) {
+	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 {
+	var data validatorInfoJSON
+	if err := json.Unmarshal(input, &data); err != nil {
+		return errors.Wrap(err, "invalid JSON")
+	}
+
+	if data.Index == "" {
+		return errors.New("index missing")
+	}
+	index, err := strconv.ParseUint(data.Index, 10, 64)
+	if err != nil {
+		return errors.Wrap(err, "invalid value for index")
+	}
+	v.Index = phase0.ValidatorIndex(index)
+
+	if data.Pubkey == "" {
+		return errors.New("public key missing")
+	}
+	pubkey, err := hex.DecodeString(strings.TrimPrefix(data.Pubkey, "0x"))
+	if err != nil {
+		return errors.Wrap(err, "invalid value for public key")
+	}
+	if len(pubkey) != phase0.PublicKeyLength {
+		return fmt.Errorf("incorrect length %d for public key", len(pubkey))
+	}
+	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")
+	}
+	v.WithdrawalCredentials, err = hex.DecodeString(strings.TrimPrefix(data.WithdrawalCredentials, "0x"))
+	if err != nil {
+		return errors.Wrap(err, "invalid value for withdrawal credentials")
+	}
+	if len(v.WithdrawalCredentials) != phase0.HashLength {
+		return fmt.Errorf("incorrect length %d for withdrawal credentials", len(v.WithdrawalCredentials))
+	}
+
+	return nil
+}
+
+// String implements the Stringer interface.
+func (v *ValidatorInfo) String() string {
+	data, err := json.Marshal(v)
+	if err != nil {
+		return fmt.Sprintf("Err: %v\n", err)
+	}
+	return string(data)
+}

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_internal_test.go

@@ -1,315 +0,0 @@
-// Copyright © 2019, 2020 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 accountcreate
-
-import (
-	"context"
-	"crypto/tls"
-	"crypto/x509"
-	"fmt"
-	"math/rand"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/attestantio/dirk/testing/daemon"
-	"github.com/attestantio/dirk/testing/resources"
-	"github.com/pkg/errors"
-	"github.com/stretchr/testify/require"
-	e2types "github.com/wealdtech/go-eth2-types/v2"
-	dirk "github.com/wealdtech/go-eth2-wallet-dirk"
-	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
-	hd "github.com/wealdtech/go-eth2-wallet-hd/v2"
-	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
-	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
-	"google.golang.org/grpc/credentials"
-)
-
-func TestProcess(t *testing.T) {
-	require.NoError(t, e2types.InitBLS())
-
-	testNDWallet, err := nd.CreateWallet(context.Background(),
-		"Test",
-		scratch.New(),
-		keystorev4.New(),
-	)
-	require.NoError(t, err)
-	testHDWallet, err := hd.CreateWallet(context.Background(),
-		"Test",
-		[]byte("pass"),
-		scratch.New(),
-		keystorev4.New(),
-		[]byte{
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		},
-	)
-	require.NoError(t, err)
-
-	// #nosec G404
-	port1 := uint32(12000 + rand.Intn(4000))
-	// #nosec G404
-	port2 := uint32(12000 + rand.Intn(4000))
-	// #nosec G404
-	port3 := uint32(12000 + rand.Intn(4000))
-	peers := map[uint64]string{
-		1: fmt.Sprintf("signer-test01:%d", port1),
-		2: fmt.Sprintf("signer-test02:%d", port2),
-		3: fmt.Sprintf("signer-test03:%d", port3),
-	}
-	_, path, err := daemon.New(context.Background(), "", 1, port1, peers)
-	require.NoError(t, err)
-	defer os.RemoveAll(path)
-	_, path, err = daemon.New(context.Background(), "", 2, port2, peers)
-	require.NoError(t, err)
-	defer os.RemoveAll(path)
-	_, path, err = daemon.New(context.Background(), "", 3, port3, peers)
-	require.NoError(t, err)
-	defer os.RemoveAll(path)
-	endpoints := []*dirk.Endpoint{
-		dirk.NewEndpoint("signer-test01", port1),
-		dirk.NewEndpoint("signer-test02", port2),
-		dirk.NewEndpoint("signer-test03", port3),
-	}
-	credentials, err := credentialsFromCerts(context.Background(), resources.ClientTest01Crt, resources.ClientTest01Key, resources.CACrt)
-	require.NoError(t, err)
-	testDistributedWallet, err := dirk.OpenWallet(context.Background(), "Wallet 3", credentials, endpoints)
-	require.NoError(t, err)
-
-	tests := []struct {
-		name   string
-		dataIn *dataIn
-		err    string
-	}{
-		{
-			name: "Nil",
-			err:  "no data",
-		},
-		{
-			name: "WalletPassphraseIncorrect",
-			dataIn: &dataIn{
-				timeout:          5 * time.Second,
-				wallet:           testHDWallet,
-				accountName:      "Good",
-				passphrase:       "ce%NohGhah4ye5ra",
-				walletPassphrase: "bad",
-				participants:     1,
-				signingThreshold: 1,
-			},
-			err: "failed to unlock wallet: incorrect passphrase",
-		},
-		{
-			name: "PassphraseMissing",
-			dataIn: &dataIn{
-				timeout:          5 * time.Second,
-				wallet:           testHDWallet,
-				accountName:      "Good",
-				passphrase:       "",
-				walletPassphrase: "pass",
-				participants:     1,
-				signingThreshold: 1,
-			},
-			err: "passphrase is required",
-		},
-		{
-			name: "PassphraseWeak",
-			dataIn: &dataIn{
-				timeout:          5 * time.Second,
-				wallet:           testHDWallet,
-				accountName:      "Good",
-				passphrase:       "poor",
-				walletPassphrase: "pass",
-				participants:     1,
-				signingThreshold: 1,
-			},
-			err: "supplied passphrase is weak; use a stronger one or run with the --allow-weak-passphrases flag",
-		},
-		{
-			name: "Good",
-			dataIn: &dataIn{
-				timeout:          5 * time.Second,
-				wallet:           testHDWallet,
-				accountName:      "Good",
-				passphrase:       "ce%NohGhah4ye5ra",
-				walletPassphrase: "pass",
-				participants:     1,
-				signingThreshold: 1,
-			},
-		},
-		{
-			name: "PathMalformed",
-			dataIn: &dataIn{
-				timeout:          5 * time.Second,
-				wallet:           testHDWallet,
-				accountName:      "Pathed",
-				passphrase:       "ce%NohGhah4ye5ra",
-				walletPassphrase: "pass",
-				participants:     1,
-				signingThreshold: 1,
-				path:             "n/12381/3600/1/2/3",
-			},
-			err: "path does not match expected format m/…",
-		},
-		{
-			name: "PathPassphraseMissing",
-			dataIn: &dataIn{
-				timeout:          5 * time.Second,
-				wallet:           testHDWallet,
-				accountName:      "Pathed",
-				passphrase:       "",
-				walletPassphrase: "pass",
-				participants:     1,
-				signingThreshold: 1,
-				path:             "m/12381/3600/1/2/3",
-			},
-			err: "passphrase is required",
-		},
-		{
-			name: "PathNotSupported",
-			dataIn: &dataIn{
-				timeout:          5 * time.Second,
-				wallet:           testNDWallet,
-				accountName:      "Pathed",
-				passphrase:       "ce%NohGhah4ye5ra",
-				walletPassphrase: "pass",
-				participants:     1,
-				signingThreshold: 1,
-				path:             "m/12381/3600/1/2/3",
-			},
-			err: "wallet does not support account creation with an explicit path",
-		},
-		{
-			name: "GoodWithPath",
-			dataIn: &dataIn{
-				timeout:          5 * time.Second,
-				wallet:           testHDWallet,
-				accountName:      "Pathed",
-				passphrase:       "ce%NohGhah4ye5ra",
-				walletPassphrase: "pass",
-				participants:     1,
-				signingThreshold: 1,
-				path:             "m/12381/3600/1/2/3",
-			},
-		},
-		{
-			name: "DistributedSigningThresholdZero",
-			dataIn: &dataIn{
-				timeout:          5 * time.Second,
-				wallet:           testDistributedWallet,
-				accountName:      "Remote",
-				passphrase:       "ce%NohGhah4ye5ra",
-				walletPassphrase: "pass",
-				participants:     3,
-				signingThreshold: 0,
-			},
-			err: "signing threshold required",
-		},
-		{
-			name: "DistributedSigningThresholdNotHalf",
-			dataIn: &dataIn{
-				timeout:          5 * time.Second,
-				wallet:           testDistributedWallet,
-				accountName:      "Remote",
-				passphrase:       "ce%NohGhah4ye5ra",
-				walletPassphrase: "pass",
-				participants:     3,
-				signingThreshold: 1,
-			},
-			err: "signing threshold must be more than half the number of participants",
-		},
-		{
-			name: "DistributedSigningThresholdTooHigh",
-			dataIn: &dataIn{
-				timeout:          5 * time.Second,
-				wallet:           testDistributedWallet,
-				accountName:      "Remote",
-				passphrase:       "ce%NohGhah4ye5ra",
-				walletPassphrase: "pass",
-				participants:     3,
-				signingThreshold: 4,
-			},
-			err: "signing threshold cannot be higher than the number of participants",
-		},
-		{
-			name: "DistributedNotSupported",
-			dataIn: &dataIn{
-				timeout:          5 * time.Second,
-				wallet:           testNDWallet,
-				accountName:      "Remote",
-				passphrase:       "ce%NohGhah4ye5ra",
-				walletPassphrase: "pass",
-				participants:     3,
-				signingThreshold: 2,
-			},
-			err: "wallet does not support distributed account creation",
-		},
-		{
-			name: "DistributedGood",
-			dataIn: &dataIn{
-				timeout:          5 * time.Second,
-				wallet:           testDistributedWallet,
-				accountName:      "Remote",
-				passphrase:       "ce%NohGhah4ye5ra",
-				walletPassphrase: "pass",
-				participants:     3,
-				signingThreshold: 2,
-			},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			res, err := process(context.Background(), test.dataIn)
-			if test.err != "" {
-				require.EqualError(t, err, test.err)
-			} else {
-				require.NoError(t, err)
-				require.Equal(t, test.dataIn.accountName, res.account.Name())
-			}
-		})
-	}
-}
-
-func TestNilData(t *testing.T) {
-	_, err := processStandard(context.Background(), nil)
-	require.EqualError(t, err, "no data")
-	_, err = processPathed(context.Background(), nil)
-	require.EqualError(t, err, "no data")
-	_, err = processDistributed(context.Background(), nil)
-	require.EqualError(t, err, "no data")
-}
-
-func credentialsFromCerts(ctx context.Context, clientCert []byte, clientKey []byte, caCert []byte) (credentials.TransportCredentials, error) {
-	clientPair, err := tls.X509KeyPair(clientCert, clientKey)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to load client keypair")
-	}
-
-	tlsCfg := &tls.Config{
-		Certificates: []tls.Certificate{clientPair},
-		MinVersion:   tls.VersionTLS13,
-	}
-
-	if caCert != nil {
-		cp := x509.NewCertPool()
-		if !cp.AppendCertsFromPEM(caCert) {
-			return nil, errors.New("failed to add CA certificate")
-		}
-		tlsCfg.RootCAs = cp
-	}
-
-	return credentials.NewTLS(tlsCfg), nil
-}

cmd/account/derive/input.go

@@ -30,7 +30,7 @@ type dataIn struct {
 	showWithdrawalCredentials bool
 }
 
-func input(ctx context.Context) (*dataIn, error) {
+func input(_ context.Context) (*dataIn, error) {
 	data := &dataIn{}
 
 	// Quiet.

cmd/account/derive/output.go

@@ -29,7 +29,7 @@ type dataOut struct {
 	key                       *e2types.BLSPrivateKey
 }
 
-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")
 	}
@@ -42,11 +42,13 @@ func output(ctx context.Context, data *dataOut) (string, error) {
 	if data.showPrivateKey {
 		builder.WriteString(fmt.Sprintf("Private key: %#x\n", data.key.Marshal()))
 	}
-	builder.WriteString(fmt.Sprintf("Public key: %#x", data.key.PublicKey().Marshal()))
 	if data.showWithdrawalCredentials {
 		withdrawalCredentials := util.SHA256(data.key.PublicKey().Marshal())
 		withdrawalCredentials[0] = byte(0) // BLS_WITHDRAWAL_PREFIX
-		builder.WriteString(fmt.Sprintf("\nWithdrawal credentials: %#x", withdrawalCredentials))
+		builder.WriteString(fmt.Sprintf("Withdrawal credentials: %#x\n", withdrawalCredentials))
+	}
+	if !(data.showPrivateKey || data.showWithdrawalCredentials) {
+		builder.WriteString(fmt.Sprintf("Public key: %#x\n", data.key.PublicKey().Marshal()))
 	}
 
 	return builder.String(), nil

cmd/account/derive/output_internal_test.go

@@ -64,7 +64,7 @@ func TestOutput(t *testing.T) {
 				key:            blsPrivateKey("0x068dce0c90cb428ab37a74af0191eac49648035f1aaef077734b91e05985ec55"),
 				showPrivateKey: true,
 			},
-			needs: []string{"Public key", "Private key"},
+			needs: []string{"Private key"},
 		},
 		{
 			name: "WithdrawalCredentials",
@@ -72,7 +72,7 @@ func TestOutput(t *testing.T) {
 				key:                       blsPrivateKey("0x068dce0c90cb428ab37a74af0191eac49648035f1aaef077734b91e05985ec55"),
 				showWithdrawalCredentials: true,
 			},
-			needs: []string{"Public key", "Withdrawal credentials"},
+			needs: []string{"Withdrawal credentials"},
 		},
 		{
 			name: "All",
@@ -81,7 +81,7 @@ func TestOutput(t *testing.T) {
 				showPrivateKey:            true,
 				showWithdrawalCredentials: true,
 			},
-			needs: []string{"Public key", "Private key", "Withdrawal credentials"},
+			needs: []string{"Private key", "Withdrawal credentials"},
 		},
 	}
 

cmd/account/derive/process.go

@@ -15,57 +15,32 @@ package accountderive
 
 import (
 	"context"
-	"regexp"
-	"strings"
 
 	"github.com/pkg/errors"
-	"github.com/tyler-smith/go-bip39"
-	util "github.com/wealdtech/go-eth2-util"
-	"golang.org/x/text/unicode/norm"
+	"github.com/wealdtech/ethdo/util"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
-// pathRegex is the regular expression that matches an HD path.
-var pathRegex = regexp.MustCompile("^m/[0-9]+/[0-9]+(/[0-9+])+")
-
 func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	if data == nil {
 		return nil, errors.New("no data")
 	}
 
-	// If there are more than 24 words we treat the additional characters as the passphrase.
-	mnemonicParts := strings.Split(data.mnemonic, " ")
-	mnemonicPassphrase := ""
-	if len(mnemonicParts) > 24 {
-		data.mnemonic = strings.Join(mnemonicParts[:24], " ")
-		mnemonicPassphrase = strings.Join(mnemonicParts[24:], " ")
-	}
-	// Normalise the input.
-	data.mnemonic = string(norm.NFKD.Bytes([]byte(data.mnemonic)))
-	mnemonicPassphrase = string(norm.NFKD.Bytes([]byte(mnemonicPassphrase)))
-
-	if !bip39.IsMnemonicValid(data.mnemonic) {
-		return nil, errors.New("mnemonic is invalid")
-	}
-
-	// Create seed from mnemonic and passphrase.
-	seed := bip39.NewSeed(data.mnemonic, mnemonicPassphrase)
-
-	// Ensure the path is valid.
-	match := pathRegex.Match([]byte(data.path))
-	if !match {
-		return nil, errors.New("path does not match expected format m/…")
-	}
-
-	// Derive private key from seed and path.
-	key, err := util.PrivateKeyFromSeedAndPath(seed, data.path)
+	account, err := util.ParseAccount(ctx, data.mnemonic, []string{data.path}, true)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to generate key")
+		return nil, errors.Wrap(err, "failed to derive account")
+	}
+
+	key, err := account.(e2wtypes.AccountPrivateKeyProvider).PrivateKey(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain account private key")
 	}
 
 	results := &dataOut{
-		showPrivateKey:                   data.showPrivateKey,
+		showPrivateKey:            data.showPrivateKey,
 		showWithdrawalCredentials: data.showWithdrawalCredentials,
-		key:                       key,
+		key:                       key.(*e2types.BLSPrivateKey),
 	}
 
 	return results, nil

cmd/account/derive/process_internal_test.go

@@ -40,7 +40,7 @@ func TestProcess(t *testing.T) {
 			dataIn: &dataIn{
 				path: "m/12381/3600/0/0",
 			},
-			err: "mnemonic is invalid",
+			err: "failed to derive account: no account specified",
 		},
 		{
 			name: "MnemonicInvalid",
@@ -48,14 +48,14 @@ func TestProcess(t *testing.T) {
 				mnemonic: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art",
 				path:     "m/12381/3600/0/0",
 			},
-			err: "mnemonic is invalid",
+			err: "failed to derive account: mnemonic is invalid",
 		},
 		{
 			name: "PathMissing",
 			dataIn: &dataIn{
 				mnemonic: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art",
 			},
-			err: "path does not match expected format m/…",
+			err: "failed to derive account: path does not match expected format m/…",
 		},
 		{
 			name: "PathInvalid",
@@ -63,7 +63,7 @@ func TestProcess(t *testing.T) {
 				mnemonic: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art",
 				path:     "n/12381/3600/0/0",
 			},
-			err: "path does not match expected format m/…",
+			err: "failed to derive account: path does not match expected format m/…",
 		},
 		{
 			name: "Good",

cmd/account/derive/run.go

@@ -15,6 +15,7 @@ package accountderive
 
 import (
 	"context"
+	"strings"
 
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
@@ -45,5 +46,5 @@ func Run(cmd *cobra.Command) (string, error) {
 		return "", errors.Wrap(err, "failed to obtain output")
 	}
 
-	return results, nil
+	return strings.TrimSuffix(results, "\n"), nil
 }

cmd/account/import/input.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019 - 2022 Weald Technology Trading.
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -16,6 +16,7 @@ package accountimport
 import (
 	"context"
 	"encoding/hex"
+	"os"
 	"strings"
 	"time"
 
@@ -27,12 +28,14 @@ import (
 )
 
 type dataIn struct {
-	timeout          time.Duration
-	wallet           e2wtypes.Wallet
-	key              []byte
-	accountName      string
-	passphrase       string
-	walletPassphrase string
+	timeout            time.Duration
+	wallet             e2wtypes.Wallet
+	key                []byte
+	accountName        string
+	passphrase         string
+	walletPassphrase   string
+	keystore           []byte
+	keystorePassphrase []byte
 }
 
 func input(ctx context.Context) (*dataIn, error) {
@@ -74,14 +77,55 @@ func input(ctx context.Context) (*dataIn, error) {
 	// Wallet passphrase.
 	data.walletPassphrase = util.GetWalletPassphrase()
 
-	// Key.
-	if viper.GetString("key") == "" {
-		return nil, errors.New("key is required")
+	if viper.GetString("key") == "" && viper.GetString("keystore") == "" {
+		return nil, errors.New("key or keystore is required")
 	}
-	data.key, err = hex.DecodeString(strings.TrimPrefix(viper.GetString("key"), "0x"))
-	if err != nil {
-		return nil, errors.Wrap(err, "key is malformed")
+	if viper.GetString("key") != "" && viper.GetString("keystore") != "" {
+		return nil, errors.New("only one of key and keystore is required")
+	}
+
+	if viper.GetString("key") != "" {
+		data.key, err = hex.DecodeString(strings.TrimPrefix(viper.GetString("key"), "0x"))
+		if err != nil {
+			return nil, errors.Wrap(err, "key is malformed")
+		}
+	}
+
+	if viper.GetString("keystore") != "" {
+		data.keystorePassphrase = []byte(viper.GetString("keystore-passphrase"))
+		if len(data.keystorePassphrase) == 0 {
+			return nil, errors.New("must supply keystore passphrase with keystore-passphrase when supplying keystore")
+		}
+		data.keystore, err = obtainKeystore(viper.GetString("keystore"))
+		if err != nil {
+			return nil, errors.Wrap(err, "invalid keystore")
+		}
 	}
 
 	return data, nil
 }
+
+// obtainKeystore obtains keystore from an input, could be JSON itself or a path to JSON.
+func obtainKeystore(input string) ([]byte, error) {
+	var err error
+	var data []byte
+	// Input could be JSON or a path to JSON
+	if strings.HasPrefix(input, "{") {
+		// Looks like JSON
+		data = []byte(input)
+	} else {
+		// Assume it's a path to JSON
+		data, err = os.ReadFile(input)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to find deposit data file")
+		}
+	}
+	return data, nil
+	//	exitData := &util.ValidatorExitData{}
+	//	err = json.Unmarshal(data, exitData)
+	//	if err != nil {
+	//		return nil, errors.Wrap(err, "data is not valid JSON")
+	//	}
+
+	//	return exitData, nil
+}

cmd/account/import/input_internal_test.go

@@ -102,7 +102,7 @@ func TestInput(t *testing.T) {
 				"account":    "Test wallet/Test account",
 				"passphrase": "ce%NohGhah4ye5ra",
 			},
-			err: "key is required",
+			err: "key or keystore is required",
 		},
 		{
 			name: "KeyMalformed",
@@ -114,6 +114,26 @@ func TestInput(t *testing.T) {
 			},
 			err: "key is malformed: encoding/hex: invalid byte: U+0069 'i'",
 		},
+		{
+			name: "KeyandKeystore",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "Test wallet/Test account",
+				"passphrase": "ce%NohGhah4ye5ra",
+				"key":        "0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866",
+				"keystore":   "{}",
+			},
+			err: "only one of key and keystore is required",
+		},
+		{
+			name: "KeystoreNoKeystorePassphrase",
+			vars: map[string]interface{}{
+				"timeout":  "5s",
+				"account":  "Test wallet/Test account",
+				"keystore": "{}",
+			},
+			err: "must supply keystore passphrase with keystore-passphrase when supplying keystore",
+		},
 		{
 			name: "Good",
 			vars: map[string]interface{}{

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

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019 -2022 Weald Technology Trading
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -15,9 +15,15 @@ package accountimport
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
 
 	"github.com/pkg/errors"
 	"github.com/wealdtech/ethdo/util"
+	"github.com/wealdtech/go-ecodec"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
 	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
@@ -43,13 +49,73 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		}()
 	}
 
+	if len(data.key) > 0 {
+		return processFromKey(ctx, data)
+	}
+	if len(data.keystore) > 0 {
+		return processFromKeystore(ctx, data)
+	}
+	return nil, errors.New("unsupported import mechanism")
+}
+
+func processFromKey(ctx context.Context, data *dataIn) (*dataOut, error) {
 	results := &dataOut{}
 
-	account, err := data.wallet.(e2wtypes.WalletAccountImporter).ImportAccount(ctx, data.accountName, data.key, []byte(data.passphrase))
+	importer, isImporter := data.wallet.(e2wtypes.WalletAccountImporter)
+	if !isImporter {
+		return nil, fmt.Errorf("%s wallets do not support importing accounts", data.wallet.Type())
+	}
+	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
 
 	return results, nil
 }
+
+func processFromKeystore(ctx context.Context, data *dataIn) (*dataOut, error) {
+	// Need to import the keystore in to a temporary wallet to fetch the private key.
+	store := scratch.New()
+	encryptor := keystorev4.New()
+
+	// Need to add a couple of fields to the keystore to make it compliant.
+	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 account")
+	}
+
+	account := <-wallet.Accounts(ctx)
+	privateKeyProvider, isPrivateKeyProvider := account.(e2wtypes.AccountPrivateKeyProvider)
+	if !isPrivateKeyProvider {
+		return nil, errors.New("account does not provide its private key")
+	}
+	if locker, isLocker := account.(e2wtypes.AccountLocker); isLocker {
+		if err = locker.Unlock(ctx, data.keystorePassphrase); err != nil {
+			return nil, errors.Wrap(err, "failed to unlock account")
+		}
+	}
+	key, err := privateKeyProvider.PrivateKey(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain private key")
+	}
+	data.key = key.Marshal()
+	// We have the key from the keystore; import it.
+	return processFromKey(ctx, data)
+}

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

@@ -49,17 +49,13 @@ func init() {
 	accountFlags(accountCreateCmd)
 	accountCreateCmd.Flags().Uint32("participants", 1, "Number of participants (1 for non-distributed accounts, >1 for distributed accounts)")
 	accountCreateCmd.Flags().Uint32("signing-threshold", 1, "Signing threshold (1 for non-distributed accounts)")
-	accountCreateCmd.Flags().String("path", "", "path of account (for hierarchical deterministic 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 {
-		panic(err)
-	}
-	if err := viper.BindPFlag("path", accountCreateCmd.Flags().Lookup("path")); err != nil {
+	if err := viper.BindPFlag("signing-threshold", cmd.Flags().Lookup("signing-threshold")); err != nil {
 		panic(err)
 	}
 }

cmd/accountderive.go

@@ -47,23 +47,15 @@ In quiet mode this will return 0 if the inputs can derive an account account, ot
 func init() {
 	accountCmd.AddCommand(accountDeriveCmd)
 	accountFlags(accountDeriveCmd)
-	accountDeriveCmd.Flags().String("mnemonic", "", "mnemonic from which to derive the HD seed")
-	accountDeriveCmd.Flags().String("path", "", "path from which to derive the account")
 	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")
 }
 
-func accountDeriveBindings() {
-	if err := viper.BindPFlag("mnemonic", accountDeriveCmd.Flags().Lookup("mnemonic")); 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("path", accountDeriveCmd.Flags().Lookup("path")); err != nil {
-		panic(err)
-	}
-	if err := viper.BindPFlag("show-private-key", accountDeriveCmd.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)
 	}
 }

cmd/accountimport.go

@@ -48,10 +48,18 @@ func init() {
 	accountCmd.AddCommand(accountImportCmd)
 	accountFlags(accountImportCmd)
 	accountImportCmd.Flags().String("key", "", "Private key of the account to import (0x...)")
+	accountImportCmd.Flags().String("keystore", "", "Keystore, or path to keystore ")
+	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", cmd.Flags().Lookup("keystore")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("keystore-passphrase", cmd.Flags().Lookup("keystore-passphrase")); err != nil {
 		panic(err)
 	}
 }

cmd/accountinfo.go

@@ -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.",

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,36 +52,37 @@ 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"),
+		LogFallback:   !data.quiet,
+	})
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to connect to Ethereum 2 beacon node")
+		return nil, err
 	}
 
-	// Epoch
-	epoch := viper.GetInt64("epoch")
-	if epoch == -1 {
-		config, err := data.eth2Client.(eth2client.SpecProvider).Spec(ctx)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to obtain beacon chain configuration")
-		}
-		data.slotsPerEpoch = config["SLOTS_PER_EPOCH"].(uint64)
-		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))
+	data.chainTime, err = standardchaintime.New(ctx,
+		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithGenesisTimeProvider(data.eth2Client.(eth2client.GenesisTimeProvider)),
+	)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to set up chaintime service")
+	}
+
+	// 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 Ethereum 2 beacon node: failed to connect to beacon node: problem with parameters: no address specified",
 		},
 	}
 

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,12 @@ package attesterduties
 
 import (
 	"context"
-	"encoding/hex"
-	"fmt"
-	"strings"
 
 	eth2client "github.com/attestantio/go-eth2-client"
 	api "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 +28,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 +39,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,7 +49,7 @@ 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 *api.Validator, epoch spec.Epoch) (*api.AttesterDuty, error) {
 	// Find the attesting slot for the given epoch.
 	duties, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, epoch, []spec.ValidatorIndex{validator.Index})
 	if err != nil {

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.WithGenesisTimeProvider(eth2Client.(eth2client.GenesisTimeProvider)),
+	)
+	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/inclusion/input.go

@@ -21,6 +21,8 @@ import (
 	spec "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"
 )
 
@@ -30,13 +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
+	validator  string
 }
 
 func input(ctx context.Context) (*dataIn, error) {
@@ -50,40 +50,36 @@ func input(ctx context.Context) (*dataIn, error) {
 	data.verbose = viper.GetBool("verbose")
 	data.debug = viper.GetBool("debug")
 
-	// Account or pubkey.
-	if viper.GetString("account") == "" && viper.GetString("pubkey") == "" {
-		return nil, errors.New("account or pubkey is required")
+	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"),
+		LogFallback:   !data.quiet,
+	})
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to connect to Ethereum 2 beacon node")
+		return nil, err
 	}
 
-	config, err := data.eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	data.chainTime, err = standardchaintime.New(ctx,
+		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithGenesisTimeProvider(data.eth2Client.(eth2client.GenesisTimeProvider)),
+	)
 	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, 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/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: "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 Ethereum 2 beacon node: failed to connect to beacon node: problem with parameters: no address specified",
 		},
 	}
 

cmd/attester/inclusion/output.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019 - 2022 Weald Technology Trading.
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -16,8 +16,9 @@ package attesterinclusion
 import (
 	"context"
 	"fmt"
+	"strings"
 
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 )
 
@@ -25,22 +26,67 @@ type dataOut struct {
 	debug            bool
 	quiet            bool
 	verbose          bool
-	slot             spec.Slot
+	attestation      *phase0.Attestation
+	slot             phase0.Slot
 	attestationIndex uint64
-	inclusionDelay   spec.Slot
+	inclusionDelay   phase0.Slot
 	found            bool
+	headCorrect      bool
+	headTimely       bool
+	sourceTimely     bool
+	targetCorrect    bool
+	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 "", errors.New("no data")
+		return buf.String(), errors.New("no data")
 	}
 
 	if !data.quiet {
 		if data.found {
-			return fmt.Sprintf("Attestation included in block %d, attestation %d (inclusion delay %d)", data.slot, data.attestationIndex, data.inclusionDelay), nil
+			buf.WriteString("Attestation included in block ")
+			buf.WriteString(fmt.Sprintf("%d", data.slot))
+			buf.WriteString(", index ")
+			buf.WriteString(fmt.Sprintf("%d", data.attestationIndex))
+			if data.verbose {
+				buf.WriteString("\nInclusion delay: ")
+				buf.WriteString(fmt.Sprintf("%d", data.inclusionDelay))
+				buf.WriteString("\nHead correct: ")
+				if data.headCorrect {
+					buf.WriteString("✓")
+				} else {
+					buf.WriteString("✕")
+				}
+				buf.WriteString("\nHead timely: ")
+				if data.headTimely {
+					buf.WriteString("✓")
+				} else {
+					buf.WriteString("✕")
+				}
+				buf.WriteString("\nSource timely: ")
+				if data.sourceTimely {
+					buf.WriteString("✓")
+				} else {
+					buf.WriteString("✕")
+				}
+				buf.WriteString("\nTarget correct: ")
+				if data.targetCorrect {
+					buf.WriteString("✓")
+				} else {
+					buf.WriteString("✕")
+				}
+				buf.WriteString("\nTarget timely: ")
+				if data.targetTimely {
+					buf.WriteString("✓")
+				} else {
+					buf.WriteString("✕")
+				}
+			}
+		} else {
+			buf.WriteString("Attestation not found")
 		}
-		return "Attestation not found", nil
 	}
-	return "", nil
+	return buf.String(), nil
 }

cmd/attester/inclusion/output_internal_test.go

@@ -44,7 +44,29 @@ func TestOutput(t *testing.T) {
 				attestationIndex: 456,
 				inclusionDelay:   7,
 			},
-			res: "Attestation included in block 123, attestation 456 (inclusion delay 7)",
+			res: `Attestation included in block 123, index 456`,
+		},
+		{
+			name: "Verbose",
+			dataOut: &dataOut{
+				verbose:          true,
+				found:            true,
+				slot:             123,
+				attestationIndex: 456,
+				inclusionDelay:   7,
+				headCorrect:      true,
+				headTimely:       false,
+				sourceTimely:     false,
+				targetCorrect:    true,
+				targetTimely:     true,
+			},
+			res: `Attestation included in block 123, index 456
+Inclusion delay: 7
+Head correct: ✓
+Head timely: ✕
+Source timely: ✕
+Target correct: ✓
+Target timely: ✓`,
 		},
 	}
 

cmd/attester/inclusion/process.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019 - 2022 Weald Technology Trading
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -14,17 +14,16 @@
 package attesterinclusion
 
 import (
+	"bytes"
 	"context"
-	"encoding/hex"
 	"fmt"
-	"strings"
 
 	eth2client "github.com/attestantio/go-eth2-client"
 	api "github.com/attestantio/go-eth2-client/api/v1"
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"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"
-	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
 func process(ctx context.Context, data *dataIn) (*dataOut, error) {
@@ -32,43 +31,17 @@ 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))
-		}
+	validator, err := util.ParseValidator(ctx, data.eth2Client.(eth2client.ValidatorsProvider), data.validator, "head")
+	if err != nil {
+		return nil, err
 	}
 
-	// Fetch validator
-	pubKeys := make([]spec.BLSPubKey, 1)
-	pubKey, err := util.BestPublicKey(account)
+	data.chainTime, err = standardchaintime.New(ctx,
+		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithGenesisTimeProvider(data.eth2Client.(eth2client.GenesisTimeProvider)),
+	)
 	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, errors.Wrap(err, "failed to set up chaintime service")
 	}
 
 	results := &dataOut{
@@ -77,10 +50,13 @@ 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")
 	}
+	if data.debug {
+		fmt.Printf("Duty is %s\n", duty.String())
+	}
 
 	startSlot := duty.Slot + 1
 	endSlot := startSlot + 32
@@ -92,20 +68,49 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		if signedBlock == nil {
 			continue
 		}
-		if signedBlock.Message.Slot != slot {
+		blockSlot, err := signedBlock.Slot()
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to obtain block slot")
+		}
+		if blockSlot != slot {
 			continue
 		}
 		if data.debug {
 			fmt.Printf("Fetched block for slot %d\n", slot)
 		}
-		for i, attestation := range signedBlock.Message.Body.Attestations {
+		attestations, err := signedBlock.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) {
+				headCorrect := false
+				targetCorrect := false
+				if data.verbose {
+					headCorrect, err = calcHeadCorrect(ctx, data, attestation)
+					if err != nil {
+						return nil, errors.Wrap(err, "failed to obtain head correct result")
+					}
+					targetCorrect, err = calcTargetCorrect(ctx, data, attestation)
+					if err != nil {
+						return nil, errors.Wrap(err, "failed to obtain target correct result")
+					}
+				}
+				results.found = true
+				results.attestation = attestation
 				results.slot = slot
 				results.attestationIndex = uint64(i)
 				results.inclusionDelay = slot - duty.Slot
-				results.found = true
+				results.sourceTimely = results.inclusionDelay <= 5 // sqrt(32)
+				results.targetCorrect = targetCorrect
+				results.targetTimely = targetCorrect && results.inclusionDelay <= 32
+				results.headCorrect = headCorrect
+				results.headTimely = headCorrect && results.inclusionDelay == 1
+				if data.debug {
+					fmt.Printf("Attestation is %s\n", attestation.String())
+				}
 				return results, nil
 			}
 		}
@@ -113,9 +118,52 @@ 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 calcHeadCorrect(ctx context.Context, data *dataIn, attestation *phase0.Attestation) (bool, error) {
+	slot := attestation.Data.Slot
+	for {
+		header, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+		if err != nil {
+			return false, err
+		}
+		if header == nil {
+			// No block.
+			slot--
+			continue
+		}
+		if !header.Canonical {
+			// Not canonical.
+			slot--
+			continue
+		}
+		return bytes.Equal(header.Root[:], attestation.Data.BeaconBlockRoot[:]), nil
+	}
+}
+
+func calcTargetCorrect(ctx context.Context, data *dataIn, attestation *phase0.Attestation) (bool, error) {
+	// Start with first slot of the target epoch.
+	slot := data.chainTime.FirstSlotOfEpoch(attestation.Data.Target.Epoch)
+	for {
+		header, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+		if err != nil {
+			return false, err
+		}
+		if header == nil {
+			// No block.
+			slot--
+			continue
+		}
+		if !header.Canonical {
+			// Not canonical.
+			slot--
+			continue
+		}
+		return bytes.Equal(header.Root[:], attestation.Data.Target.Root[:]), nil
+	}
+}
+
+func duty(ctx context.Context, eth2Client eth2client.Service, validator *api.Validator, epoch phase0.Epoch) (*api.AttesterDuty, error) {
 	// Find the attesting slot for the given epoch.
-	duties, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, epoch, []spec.ValidatorIndex{validator.Index})
+	duties, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, epoch, []phase0.ValidatorIndex{validator.Index})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain attester duties")
 	}

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.WithGenesisTimeProvider(eth2Client.(eth2client.GenesisTimeProvider)),
 	)
 	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/attesterduties.go

@@ -26,7 +26,7 @@ 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 {
@@ -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,7 +26,7 @@ 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 {
@@ -47,15 +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", 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

@@ -0,0 +1,133 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package blockanalyze
+
+import (
+	"context"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/go-bitfield"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/services/chaintime"
+)
+
+type command struct {
+	quiet   bool
+	verbose bool
+	debug   bool
+
+	// Beacon node connection.
+	timeout                  time.Duration
+	connection               string
+	allowInsecureConnections bool
+
+	// Operation.
+	blockID    string
+	stream     bool
+	jsonOutput bool
+
+	// Data access.
+	eth2Client           eth2client.Service
+	chainTime            chaintime.Service
+	blocksProvider       eth2client.SignedBeaconBlockProvider
+	blockHeadersProvider eth2client.BeaconBlockHeadersProvider
+
+	// Constants.
+	timelySourceWeight uint64
+	timelyTargetWeight uint64
+	timelyHeadWeight   uint64
+	syncRewardWeight   uint64
+	proposerWeight     uint64
+	weightDenominator  uint64
+
+	// Processing.
+	priorAttestations map[string]*attestationData
+	// Head roots provides the root of the head slot at given slots.
+	headRoots map[phase0.Slot]phase0.Root
+	// Target roots provides the root of the target epoch at given slots.
+	targetRoots map[phase0.Slot]phase0.Root
+
+	// Block info.
+	// Map is slot -> committee index -> validator committee index -> votes.
+	votes map[phase0.Slot]map[phase0.CommitteeIndex]bitfield.Bitlist
+
+	// Results.
+	analysis *blockAnalysis
+}
+
+type blockAnalysis struct {
+	Slot         phase0.Slot            `json:"slot"`
+	Attestations []*attestationAnalysis `json:"attestations"`
+	SyncCommitee *syncCommitteeAnalysis `json:"sync_committee"`
+	Value        float64                `json:"value"`
+}
+
+type attestationAnalysis struct {
+	Head          phase0.Root      `json:"head"`
+	Target        phase0.Root      `json:"target"`
+	Distance      int              `json:"distance"`
+	Duplicate     *attestationData `json:"duplicate,omitempty"`
+	NewVotes      int              `json:"new_votes"`
+	Votes         int              `json:"votes"`
+	PossibleVotes int              `json:"possible_votes"`
+	HeadCorrect   bool             `json:"head_correct"`
+	HeadTimely    bool             `json:"head_timely"`
+	SourceTimely  bool             `json:"source_timely"`
+	TargetCorrect bool             `json:"target_correct"`
+	TargetTimely  bool             `json:"target_timely"`
+	Score         float64          `json:"score"`
+	Value         float64          `json:"value"`
+}
+
+type syncCommitteeAnalysis struct {
+	Contributions         int     `json:"contributions"`
+	PossibleContributions int     `json:"possible_contributions"`
+	Score                 float64 `json:"score"`
+	Value                 float64 `json:"value"`
+}
+
+type attestationData struct {
+	Block phase0.Slot `json:"block"`
+	Index int         `json:"index"`
+}
+
+func newCommand(_ context.Context) (*command, error) {
+	c := &command{
+		quiet:             viper.GetBool("quiet"),
+		verbose:           viper.GetBool("verbose"),
+		debug:             viper.GetBool("debug"),
+		priorAttestations: make(map[string]*attestationData),
+		headRoots:         make(map[phase0.Slot]phase0.Root),
+		targetRoots:       make(map[phase0.Slot]phase0.Root),
+		votes:             make(map[phase0.Slot]map[phase0.CommitteeIndex]bitfield.Bitlist),
+	}
+
+	// Timeout.
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	c.timeout = viper.GetDuration("timeout")
+
+	c.connection = viper.GetString("connection")
+	c.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
+
+	c.blockID = viper.GetString("blockid")
+	c.stream = viper.GetBool("stream")
+	c.jsonOutput = viper.GetBool("json")
+
+	return c, nil
+}

cmd/block/analyze/command_internal_test.go

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

cmd/block/analyze/output.go

@@ -0,0 +1,156 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package blockanalyze
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+func (c *command) output(ctx context.Context) (string, error) {
+	if c.quiet {
+		return "", nil
+	}
+
+	if c.jsonOutput {
+		return c.outputJSON(ctx)
+	}
+
+	return c.outputTxt(ctx)
+}
+
+type attestationAnalysisJSON struct {
+	Head          string           `json:"head"`
+	Target        string           `json:"target"`
+	Distance      int              `json:"distance"`
+	Duplicate     *attestationData `json:"duplicate,omitempty"`
+	NewVotes      int              `json:"new_votes"`
+	Votes         int              `json:"votes"`
+	PossibleVotes int              `json:"possible_votes"`
+	HeadCorrect   bool             `json:"head_correct"`
+	HeadTimely    bool             `json:"head_timely"`
+	SourceTimely  bool             `json:"source_timely"`
+	TargetCorrect bool             `json:"target_correct"`
+	TargetTimely  bool             `json:"target_timely"`
+	Score         float64          `json:"score"`
+	Value         float64          `json:"value"`
+}
+
+func (a *attestationAnalysis) MarshalJSON() ([]byte, error) {
+	return json.Marshal(attestationAnalysisJSON{
+		Head:          fmt.Sprintf("%#x", a.Head),
+		Target:        fmt.Sprintf("%#x", a.Target),
+		Distance:      a.Distance,
+		Duplicate:     a.Duplicate,
+		NewVotes:      a.NewVotes,
+		Votes:         a.Votes,
+		PossibleVotes: a.PossibleVotes,
+		HeadCorrect:   a.HeadCorrect,
+		HeadTimely:    a.HeadTimely,
+		SourceTimely:  a.SourceTimely,
+		TargetCorrect: a.TargetCorrect,
+		TargetTimely:  a.TargetTimely,
+		Score:         a.Score,
+		Value:         a.Value,
+	})
+}
+
+func (c *command) outputJSON(_ context.Context) (string, error) {
+	data, err := json.Marshal(c.analysis)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+func (c *command) outputTxt(_ context.Context) (string, error) {
+	builder := strings.Builder{}
+
+	for i, attestation := range c.analysis.Attestations {
+		if c.verbose {
+			builder.WriteString("Attestation ")
+			builder.WriteString(fmt.Sprintf("%d", i))
+			builder.WriteString(": ")
+			builder.WriteString("distance ")
+			builder.WriteString(fmt.Sprintf("%d", attestation.Distance))
+			builder.WriteString(", ")
+
+			if attestation.Duplicate != nil {
+				builder.WriteString("duplicate of attestation ")
+				builder.WriteString(fmt.Sprintf("%d", 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("/")
+			builder.WriteString(fmt.Sprintf("%d", attestation.Votes))
+			builder.WriteString("/")
+			builder.WriteString(fmt.Sprintf("%d", attestation.PossibleVotes))
+			builder.WriteString(" new/total/possible votes")
+			if attestation.NewVotes == 0 {
+				builder.WriteString("\n")
+				continue
+			}
+			builder.WriteString(", ")
+			switch {
+			case !attestation.HeadCorrect:
+				builder.WriteString("head vote incorrect, ")
+			case !attestation.HeadTimely:
+				builder.WriteString("head vote correct but late, ")
+			}
+
+			if !attestation.SourceTimely {
+				builder.WriteString("source vote late, ")
+			}
+
+			switch {
+			case !attestation.TargetCorrect:
+				builder.WriteString("target vote incorrect, ")
+			case !attestation.TargetTimely:
+				builder.WriteString("target vote correct but late, ")
+			}
+
+			builder.WriteString("score ")
+			builder.WriteString(fmt.Sprintf("%0.3f", attestation.Score))
+			builder.WriteString(", value ")
+			builder.WriteString(fmt.Sprintf("%0.3f", attestation.Value))
+			builder.WriteString("\n")
+		}
+	}
+
+	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(" contributions, score ")
+			builder.WriteString(fmt.Sprintf("%0.3f", c.analysis.SyncCommitee.Score))
+			builder.WriteString(", value ")
+			builder.WriteString(fmt.Sprintf("%0.3f", c.analysis.SyncCommitee.Value))
+			builder.WriteString("\n")
+		}
+	}
+
+	builder.WriteString("Value for block ")
+	builder.WriteString(fmt.Sprintf("%d", c.analysis.Slot))
+	builder.WriteString(": ")
+	builder.WriteString(fmt.Sprintf("%0.3f", c.analysis.Value))
+	builder.WriteString("\n")
+
+	return builder.String(), nil
+}

cmd/block/analyze/process.go

@@ -0,0 +1,445 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package blockanalyze
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	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/prysmaticlabs/go-bitfield"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
+	"github.com/wealdtech/ethdo/util"
+)
+
+func (c *command) process(ctx context.Context) error {
+	// Obtain information we need to process.
+	if err := c.setup(ctx); err != nil {
+		return err
+	}
+
+	block, err := c.blocksProvider.SignedBeaconBlock(ctx, c.blockID)
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain beacon block")
+	}
+	if block == nil {
+		return errors.New("empty beacon block")
+	}
+
+	slot, err := block.Slot()
+	if err != nil {
+		return err
+	}
+	attestations, err := block.Attestations()
+	if err != nil {
+		return err
+	}
+
+	c.analysis = &blockAnalysis{
+		Slot: slot,
+	}
+
+	// Calculate how many parents we need to fetch.
+	minSlot := slot
+	for _, attestation := range attestations {
+		if attestation.Data.Slot < minSlot {
+			minSlot = attestation.Data.Slot
+		}
+	}
+	if c.debug {
+		fmt.Printf("Need to fetch blocks to slot %d\n", minSlot)
+	}
+
+	if err := c.fetchParents(ctx, block, minSlot); err != nil {
+		return err
+	}
+
+	return c.analyze(ctx, block)
+}
+
+func (c *command) analyze(ctx context.Context, block *spec.VersionedSignedBeaconBlock) error {
+	if err := c.analyzeAttestations(ctx, block); err != nil {
+		return err
+	}
+
+	return c.analyzeSyncCommittees(ctx, block)
+}
+
+func (c *command) analyzeAttestations(ctx context.Context, block *spec.VersionedSignedBeaconBlock) error {
+	attestations, err := block.Attestations()
+	if err != nil {
+		return err
+	}
+	slot, err := block.Slot()
+	if err != nil {
+		return err
+	}
+
+	c.analysis.Attestations = make([]*attestationAnalysis, len(attestations))
+
+	blockVotes := make(map[phase0.Slot]map[phase0.CommitteeIndex]bitfield.Bitlist)
+	for i, attestation := range attestations {
+		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()
+		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 {
+			analysis.Score += float64(c.timelyTargetWeight) / float64(c.weightDenominator)
+		}
+		if analysis.SourceTimely {
+			analysis.Score += float64(c.timelySourceWeight) / float64(c.weightDenominator)
+		}
+		if analysis.HeadCorrect && analysis.HeadTimely {
+			analysis.Score += float64(c.timelyHeadWeight) / float64(c.weightDenominator)
+		}
+		analysis.Value = analysis.Score * float64(analysis.NewVotes)
+		c.analysis.Value += analysis.Value
+
+		c.analysis.Attestations[i] = analysis
+	}
+
+	return nil
+}
+
+func (c *command) fetchParents(ctx context.Context, block *spec.VersionedSignedBeaconBlock, minSlot phase0.Slot) error {
+	parentRoot, err := block.ParentRoot()
+	if err != nil {
+		return err
+	}
+
+	// Obtain the parent block.
+	parentBlock, err := c.blocksProvider.SignedBeaconBlock(ctx, fmt.Sprintf("%#x", parentRoot))
+	if err != nil {
+		return err
+	}
+	if parentBlock == nil {
+		return fmt.Errorf("unable to obtain parent block %s", parentBlock)
+	}
+
+	parentSlot, err := parentBlock.Slot()
+	if err != nil {
+		return err
+	}
+	if parentSlot < minSlot {
+		return nil
+	}
+
+	if err := c.processParentBlock(ctx, parentBlock); err != nil {
+		return err
+	}
+
+	return c.fetchParents(ctx, parentBlock, minSlot)
+}
+
+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
+	}
+	if c.debug {
+		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,
+		}
+
+		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)
+			}
+		}
+	}
+
+	return nil
+}
+
+func (c *command) setup(ctx context.Context) error {
+	var err error
+
+	// Connect to the client.
+	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+		Address:       c.connection,
+		Timeout:       c.timeout,
+		AllowInsecure: c.allowInsecureConnections,
+		LogFallback:   !c.quiet,
+	})
+	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.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+	)
+	if err != nil {
+		return errors.Wrap(err, "failed to set up chaintime service")
+	}
+
+	// Obtain the number of active validators.
+	var isProvider bool
+	c.blocksProvider, isProvider = c.eth2Client.(eth2client.SignedBeaconBlockProvider)
+	if !isProvider {
+		return errors.New("connection does not provide signed beacon block information")
+	}
+	c.blockHeadersProvider, isProvider = c.eth2Client.(eth2client.BeaconBlockHeadersProvider)
+	if !isProvider {
+		return errors.New("connection does not provide beacon block header information")
+	}
+
+	specProvider, isProvider := c.eth2Client.(eth2client.SpecProvider)
+	if !isProvider {
+		return errors.New("connection does not provide spec information")
+	}
+
+	spec, err := specProvider.Spec(ctx)
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain spec")
+	}
+
+	tmp, exists := spec["TIMELY_SOURCE_WEIGHT"]
+	if !exists {
+		// Set a default value based on the Altair spec.
+		tmp = uint64(14)
+	}
+	var ok bool
+	c.timelySourceWeight, ok = tmp.(uint64)
+	if !ok {
+		return errors.New("TIMELY_SOURCE_WEIGHT of unexpected type")
+	}
+
+	tmp, exists = spec["TIMELY_TARGET_WEIGHT"]
+	if !exists {
+		// Set a default value based on the Altair spec.
+		tmp = uint64(26)
+	}
+	c.timelyTargetWeight, ok = tmp.(uint64)
+	if !ok {
+		return errors.New("TIMELY_TARGET_WEIGHT of unexpected type")
+	}
+
+	tmp, exists = spec["TIMELY_HEAD_WEIGHT"]
+	if !exists {
+		// Set a default value based on the Altair spec.
+		tmp = uint64(14)
+	}
+	c.timelyHeadWeight, ok = tmp.(uint64)
+	if !ok {
+		return errors.New("TIMELY_HEAD_WEIGHT of unexpected type")
+	}
+
+	tmp, exists = spec["SYNC_REWARD_WEIGHT"]
+	if !exists {
+		// Set a default value based on the Altair spec.
+		tmp = uint64(2)
+	}
+	c.syncRewardWeight, ok = tmp.(uint64)
+	if !ok {
+		return errors.New("SYNC_REWARD_WEIGHT of unexpected type")
+	}
+
+	tmp, exists = spec["PROPOSER_WEIGHT"]
+	if !exists {
+		// Set a default value based on the Altair spec.
+		tmp = uint64(8)
+	}
+	c.proposerWeight, ok = tmp.(uint64)
+	if !ok {
+		return errors.New("PROPOSER_WEIGHT of unexpected type")
+	}
+
+	tmp, exists = spec["WEIGHT_DENOMINATOR"]
+	if !exists {
+		// Set a default value based on the Altair spec.
+		tmp = uint64(64)
+	}
+	c.weightDenominator, ok = tmp.(uint64)
+	if !ok {
+		return errors.New("WEIGHT_DENOMINATOR of unexpected type")
+	}
+	return nil
+}
+
+func (c *command) calcHeadCorrect(ctx context.Context, attestation *phase0.Attestation) (bool, error) {
+	slot := attestation.Data.Slot
+	root, exists := c.headRoots[slot]
+	if !exists {
+		for {
+			header, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+			if err != nil {
+				return false, err
+			}
+			if header == nil {
+				// No block.
+				slot--
+				continue
+			}
+			if !header.Canonical {
+				// Not canonical.
+				slot--
+				continue
+			}
+			c.headRoots[attestation.Data.Slot] = header.Root
+			root = header.Root
+			break
+		}
+	}
+
+	return bytes.Equal(root[:], attestation.Data.BeaconBlockRoot[:]), nil
+}
+
+func (c *command) calcTargetCorrect(ctx context.Context, attestation *phase0.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 {
+			header, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+			if err != nil {
+				return false, err
+			}
+			if header == nil {
+				// No block.
+				slot--
+				continue
+			}
+			if !header.Canonical {
+				// Not canonical.
+				slot--
+				continue
+			}
+			c.targetRoots[attestation.Data.Slot] = header.Root
+			root = header.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:
+		return nil
+	case spec.DataVersionAltair:
+		c.analysis.SyncCommitee.Contributions = int(block.Altair.Message.Body.SyncAggregate.SyncCommitteeBits.Count())
+		c.analysis.SyncCommitee.PossibleContributions = int(block.Altair.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
+	case spec.DataVersionBellatrix:
+		c.analysis.SyncCommitee.Contributions = int(block.Bellatrix.Message.Body.SyncAggregate.SyncCommitteeBits.Count())
+		c.analysis.SyncCommitee.PossibleContributions = int(block.Bellatrix.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
+	case spec.DataVersionCapella:
+		c.analysis.SyncCommitee.Contributions = int(block.Capella.Message.Body.SyncAggregate.SyncCommitteeBits.Count())
+		c.analysis.SyncCommitee.PossibleContributions = int(block.Capella.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

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

cmd/block/analyze/run.go

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

cmd/block/info/input.go

@@ -32,6 +32,7 @@ type dataIn struct {
 	// Operation.
 	eth2Client eth2client.Service
 	jsonOutput bool
+	sszOutput  bool
 	// Chain information.
 	blockID string
 	stream  bool
@@ -48,13 +49,19 @@ func input(ctx context.Context) (*dataIn, error) {
 	data.verbose = viper.GetBool("verbose")
 	data.debug = viper.GetBool("debug")
 	data.jsonOutput = viper.GetBool("json")
+	data.sszOutput = viper.GetBool("ssz")
 
 	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"),
+		LogFallback:   !data.quiet,
+	})
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to connect to Ethereum 2 beacon node")
+		return nil, err
 	}
 
 	if viper.GetString("blockid") == "" {

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

cmd/block/info/output.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019, 2020, 2021 Weald Technology Trading
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -18,13 +18,17 @@ import (
 	"context"
 	"encoding/hex"
 	"fmt"
+	"math/big"
 	"sort"
 	"strings"
 	"time"
 	"unicode/utf8"
 
 	eth2client "github.com/attestantio/go-eth2-client"
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"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/phase0"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/wealdtech/go-string2eth"
@@ -39,7 +43,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")
 	}
@@ -47,34 +51,45 @@ func output(ctx context.Context, data *dataOut) (string, error) {
 	return "", nil
 }
 
-func outputBlockGeneral(ctx context.Context, verbose bool, block *spec.BeaconBlock, genesisTime time.Time, slotDuration time.Duration, slotsPerEpoch uint64) (string, error) {
-	bodyRoot, err := block.Body.HashTreeRoot()
-	if err != nil {
-		return "", errors.Wrap(err, "failed to generate block root")
-	}
-
+func outputBlockGeneral(_ context.Context,
+	verbose bool,
+	slot phase0.Slot,
+	blockRoot phase0.Root,
+	bodyRoot phase0.Root,
+	parentRoot phase0.Root,
+	stateRoot phase0.Root,
+	graffiti []byte,
+	genesisTime time.Time,
+	slotDuration time.Duration,
+	slotsPerEpoch uint64,
+) (
+	string,
+	error,
+) {
 	res := strings.Builder{}
 
-	res.WriteString(fmt.Sprintf("Slot: %d\n", block.Slot))
-	res.WriteString(fmt.Sprintf("Epoch: %d\n", spec.Epoch(uint64(block.Slot)/slotsPerEpoch)))
-	res.WriteString(fmt.Sprintf("Timestamp: %v\n", time.Unix(genesisTime.Unix()+int64(block.Slot)*int64(slotDuration.Seconds()), 0)))
-	res.WriteString(fmt.Sprintf("Block root: %#x\n", bodyRoot))
+	res.WriteString(fmt.Sprintf("Slot: %d\n", slot))
+	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))
 	if verbose {
-		res.WriteString(fmt.Sprintf("Parent root: %#x\n", block.ParentRoot))
-		res.WriteString(fmt.Sprintf("State root: %#x\n", block.StateRoot))
+		res.WriteString(fmt.Sprintf("Body root: %#x\n", bodyRoot))
+		res.WriteString(fmt.Sprintf("Parent root: %#x\n", parentRoot))
+		res.WriteString(fmt.Sprintf("State root: %#x\n", stateRoot))
 	}
-	if len(block.Body.Graffiti) > 0 && hex.EncodeToString(block.Body.Graffiti) != "0000000000000000000000000000000000000000000000000000000000000000" {
-		if utf8.Valid(block.Body.Graffiti) {
-			res.WriteString(fmt.Sprintf("Graffiti: %s\n", string(block.Body.Graffiti)))
+	if len(graffiti) > 0 && hex.EncodeToString(graffiti) != "0000000000000000000000000000000000000000000000000000000000000000" {
+		graffiti = bytes.TrimRight(graffiti, "\u0000")
+		if utf8.Valid(graffiti) {
+			res.WriteString(fmt.Sprintf("Graffiti: %s\n", string(graffiti)))
 		} else {
-			res.WriteString(fmt.Sprintf("Graffiti: %#x\n", block.Body.Graffiti))
+			res.WriteString(fmt.Sprintf("Graffiti: %#x\n", graffiti))
 		}
 	}
 
 	return res.String(), nil
 }
 
-func outputBlockETH1Data(ctx context.Context, eth1Data *spec.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))
@@ -84,10 +99,10 @@ func outputBlockETH1Data(ctx context.Context, eth1Data *spec.ETH1Data) (string,
 	return res.String(), nil
 }
 
-func outputBlockAttestations(ctx context.Context, eth2Client eth2client.Service, verbose bool, attestations []*spec.Attestation) (string, error) {
+func outputBlockAttestations(ctx context.Context, eth2Client eth2client.Service, verbose bool, attestations []*phase0.Attestation) (string, error) {
 	res := strings.Builder{}
 
-	validatorCommittees := make(map[spec.Slot]map[spec.CommitteeIndex][]spec.ValidatorIndex)
+	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)
@@ -100,21 +115,25 @@ func outputBlockAttestations(ctx context.Context, eth2Client eth2client.Service,
 				if !exists {
 					beaconCommittees, err := beaconCommitteesProvider.BeaconCommittees(ctx, fmt.Sprintf("%d", att.Data.Slot))
 					if err != nil {
-						return "", errors.Wrap(err, "failed to obtain beacon committees")
-					}
-					for _, beaconCommittee := range beaconCommittees {
-						if _, exists := validatorCommittees[beaconCommittee.Slot]; !exists {
-							validatorCommittees[beaconCommittee.Slot] = make(map[spec.CommitteeIndex][]spec.ValidatorIndex)
+						// 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 {
+							if _, exists := validatorCommittees[beaconCommittee.Slot]; !exists {
+								validatorCommittees[beaconCommittee.Slot] = make(map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
+							}
+							validatorCommittees[beaconCommittee.Slot][beaconCommittee.Index] = beaconCommittee.Validators
 						}
-						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", bitsToString(att.AggregationBits)))
-				res.WriteString(fmt.Sprintf("    Attesting indices: %s\n", attestingIndices(att.AggregationBits, committees[att.Data.Index])))
+				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))
@@ -128,7 +147,7 @@ func outputBlockAttestations(ctx context.Context, eth2Client eth2client.Service,
 	return res.String(), nil
 }
 
-func outputBlockAttesterSlashings(ctx context.Context, eth2Client eth2client.Service, verbose bool, attesterSlashings []*spec.AttesterSlashing) (string, error) {
+func outputBlockAttesterSlashings(ctx context.Context, eth2Client eth2client.Service, verbose bool, attesterSlashings []*phase0.AttesterSlashing) (string, error) {
 	res := strings.Builder{}
 
 	res.WriteString(fmt.Sprintf("Attester slashings: %d\n", len(attesterSlashings)))
@@ -175,7 +194,7 @@ func outputBlockAttesterSlashings(ctx context.Context, eth2Client eth2client.Ser
 	return res.String(), nil
 }
 
-func outputBlockDeposits(ctx context.Context, verbose bool, deposits []*spec.Deposit) (string, error) {
+func outputBlockDeposits(_ context.Context, verbose bool, deposits []*phase0.Deposit) (string, error) {
 	res := strings.Builder{}
 
 	// Deposits.
@@ -194,18 +213,18 @@ func outputBlockDeposits(ctx context.Context, verbose bool, deposits []*spec.Dep
 	return res.String(), nil
 }
 
-func outputBlockVoluntaryExits(ctx context.Context, eth2Client eth2client.Service, verbose bool, voluntaryExits []*spec.SignedVoluntaryExit) (string, error) {
+func outputBlockVoluntaryExits(ctx context.Context, eth2Client eth2client.Service, verbose bool, voluntaryExits []*phase0.SignedVoluntaryExit) (string, error) {
 	res := strings.Builder{}
 
 	res.WriteString(fmt.Sprintf("Voluntary exits: %d\n", len(voluntaryExits)))
 	if verbose {
 		for i, voluntaryExit := range voluntaryExits {
 			res.WriteString(fmt.Sprintf("  %d:\n", i))
-			validators, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, "head", []spec.ValidatorIndex{voluntaryExit.Message.ValidatorIndex})
+			validators, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, "head", []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[0].Validator.PublicKey, voluntaryExit.Message.ValidatorIndex))
+				res.WriteString(fmt.Sprintf("    Validator: %#x (%d)\n", validators[voluntaryExit.Message.ValidatorIndex].Validator.PublicKey, voluntaryExit.Message.ValidatorIndex))
 				res.WriteString(fmt.Sprintf("    Epoch: %d\n", voluntaryExit.Message.Epoch))
 			}
 		}
@@ -214,7 +233,66 @@ func outputBlockVoluntaryExits(ctx context.Context, eth2Client eth2client.Servic
 	return res.String(), nil
 }
 
-func outputBlockText(ctx context.Context, data *dataOut, signedBlock *spec.SignedBeaconBlock) (string, error) {
+func outputBlockBLSToExecutionChanges(ctx context.Context, eth2Client eth2client.Service, verbose bool, ops []*capella.SignedBLSToExecutionChange) (string, error) {
+	res := strings.Builder{}
+
+	res.WriteString(fmt.Sprintf("BLS to execution changes: %d\n", len(ops)))
+	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})
+			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("    BLS public key: %#x\n", op.Message.FromBLSPubkey))
+				res.WriteString(fmt.Sprintf("    Execution address: %#x\n", op.Message.ToExecutionAddress))
+			}
+		}
+	}
+
+	return res.String(), nil
+}
+
+func outputBlockSyncAggregate(ctx context.Context, eth2Client eth2client.Service, verbose bool, syncAggregate *altair.SyncAggregate, epoch phase0.Epoch) (string, error) {
+	res := strings.Builder{}
+
+	res.WriteString("Sync aggregate: ")
+	res.WriteString(fmt.Sprintf("%d/%d\n", syncAggregate.SyncCommitteeBits.Count(), syncAggregate.SyncCommitteeBits.Len()))
+	if verbose {
+		specProvider, isProvider := eth2Client.(eth2client.SpecProvider)
+		if isProvider {
+			config, err := specProvider.Spec(ctx)
+			if err == nil {
+				slotsPerEpoch := config["SLOTS_PER_EPOCH"].(uint64)
+
+				res.WriteString("  Contributions: ")
+				res.WriteString(bitvectorToString(syncAggregate.SyncCommitteeBits))
+				res.WriteString("\n")
+
+				syncCommitteesProvider, isProvider := eth2Client.(eth2client.SyncCommitteesProvider)
+				if isProvider {
+					syncCommittee, err := syncCommitteesProvider.SyncCommittee(ctx, fmt.Sprintf("%d", uint64(epoch)*slotsPerEpoch))
+					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("\n")
+					}
+				}
+			}
+		}
+	}
+
+	return res.String(), nil
+}
+
+func outputCapellaBlockText(ctx context.Context, data *dataOut, signedBlock *capella.SignedBeaconBlock) (string, error) {
 	if signedBlock == nil {
 		return "", errors.New("no block supplied")
 	}
@@ -224,7 +302,295 @@ func outputBlockText(ctx context.Context, data *dataOut, signedBlock *spec.Signe
 	res := strings.Builder{}
 
 	// General info.
-	tmp, err := outputBlockGeneral(ctx, data.verbose, signedBlock.Message, data.genesisTime, data.slotDuration, data.slotsPerEpoch)
+	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,
+		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 = outputCapellaBlockExecutionPayload(ctx, data.verbose, signedBlock.Message.Body.ExecutionPayload)
+	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")
+	}
+
+	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,
+		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 = outputBellatrixBlockExecutionPayload(ctx, data.verbose, signedBlock.Message.Body.ExecutionPayload)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	return res.String(), nil
+}
+
+func outputAltairBlockText(ctx context.Context, data *dataOut, signedBlock *altair.SignedBeaconBlock) (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,
+		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)
+
+	return res.String(), nil
+}
+
+func outputPhase0BlockText(ctx context.Context, data *dataOut, signedBlock *phase0.SignedBeaconBlock) (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 block root")
+	}
+	tmp, err := outputBlockGeneral(ctx,
+		data.verbose,
+		signedBlock.Message.Slot,
+		blockRoot,
+		bodyRoot,
+		signedBlock.Message.ParentRoot,
+		signedBlock.Message.StateRoot,
+		signedBlock.Message.Body.Graffiti[:],
+		data.genesisTime,
+		data.slotDuration,
+		data.slotsPerEpoch)
 	if err != nil {
 		return "", err
 	}
@@ -272,11 +638,141 @@ func outputBlockText(ctx context.Context, data *dataOut, signedBlock *spec.Signe
 	return res.String(), nil
 }
 
+func outputCapellaBlockExecutionPayload(_ context.Context,
+	verbose bool,
+	payload *capella.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))
+		baseFeePerGasBEBytes := make([]byte, len(payload.BaseFeePerGas))
+		for i := 0; i < 32; i++ {
+			baseFeePerGasBEBytes[i] = payload.BaseFeePerGas[32-1-i]
+		}
+		baseFeePerGas := new(big.Int).SetBytes(baseFeePerGasBEBytes)
+		res.WriteString("  Base fee per gas: ")
+		res.WriteString(string2eth.WeiToString(baseFeePerGas, 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(fmt.Sprintf("%#x\n", payload.FeeRecipient))
+		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)))
+	}
+
+	return res.String(), nil
+}
+
+func outputBellatrixBlockExecutionPayload(_ context.Context,
+	verbose bool,
+	payload *bellatrix.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))
+		baseFeePerGasBEBytes := make([]byte, len(payload.BaseFeePerGas))
+		for i := 0; i < 32; i++ {
+			baseFeePerGasBEBytes[i] = payload.BaseFeePerGas[32-1-i]
+		}
+		baseFeePerGas := new(big.Int).SetBytes(baseFeePerGasBEBytes)
+		res.WriteString("  Base fee per gas: ")
+		res.WriteString(string2eth.WeiToString(baseFeePerGas, 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(fmt.Sprintf("%#x\n", payload.FeeRecipient))
+		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: ")
+		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)))
+	}
+
+	return res.String(), nil
+}
+
 // intersection returns a list of items common between the two sets.
-func intersection(set1 []uint64, set2 []uint64) []spec.ValidatorIndex {
+func intersection(set1 []uint64, set2 []uint64) []phase0.ValidatorIndex {
 	sort.Slice(set1, func(i, j int) bool { return set1[i] < set1[j] })
 	sort.Slice(set2, func(i, j int) bool { return set2[i] < set2[j] })
-	res := make([]spec.ValidatorIndex, 0)
+	res := make([]phase0.ValidatorIndex, 0)
 
 	set1Pos := 0
 	set2Pos := 0
@@ -287,7 +783,7 @@ func intersection(set1 []uint64, set2 []uint64) []spec.ValidatorIndex {
 		case set2[set2Pos] < set1[set1Pos]:
 			set2Pos++
 		default:
-			res = append(res, spec.ValidatorIndex(set1[set1Pos]))
+			res = append(res, phase0.ValidatorIndex(set1[set1Pos]))
 			set1Pos++
 			set2Pos++
 		}
@@ -296,7 +792,7 @@ func intersection(set1 []uint64, set2 []uint64) []spec.ValidatorIndex {
 	return res
 }
 
-func bitsToString(input bitfield.Bitlist) string {
+func bitlistToString(input bitfield.Bitlist) string {
 	bits := int(input.Len())
 
 	res := ""
@@ -313,7 +809,24 @@ func bitsToString(input bitfield.Bitlist) string {
 	return strings.TrimSpace(res)
 }
 
-func attestingIndices(input bitfield.Bitlist, indices []spec.ValidatorIndex) string {
+func bitvectorToString(input bitfield.Bitvector512) string {
+	bits := int(input.Len())
+
+	res := strings.Builder{}
+	for i := 0; i < bits; i++ {
+		if input.BitAt(uint64(i)) {
+			res.WriteString("✓")
+		} else {
+			res.WriteString("✕")
+		}
+		if i%8 == 7 && i != bits-1 {
+			res.WriteString(" ")
+		}
+	}
+	return res.String()
+}
+
+func attestingIndices(input bitfield.Bitlist, indices []phase0.ValidatorIndex) string {
 	bits := int(input.Len())
 	res := ""
 	for i := 0; i < bits; i++ {

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
@@ -21,17 +21,27 @@ import (
 
 	eth2client "github.com/attestantio/go-eth2-client"
 	api "github.com/attestantio/go-eth2-client/api/v1"
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"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/phase0"
 	"github.com/pkg/errors"
 )
 
-var jsonOutput 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 == "" {
+		return nil, errors.New("no block ID")
+	}
 
 	results = &dataOut{
 		debug:      data.debug,
@@ -55,13 +65,36 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain beacon block")
 	}
-
-	if err := outputBlock(ctx, data.jsonOutput, signedBlock); err != nil {
-		return nil, errors.Wrap(err, "failed to output block")
+	if signedBlock == nil {
+		return nil, errors.New("empty beacon block")
+	}
+	switch signedBlock.Version {
+	case spec.DataVersionPhase0:
+		if err := outputPhase0Block(ctx, data.jsonOutput, signedBlock.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 {
+			return nil, errors.Wrap(err, "failed to output block")
+		}
+	case spec.DataVersionBellatrix:
+		if err := outputBellatrixBlock(ctx, data.jsonOutput, data.sszOutput, signedBlock.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 {
+			return nil, errors.Wrap(err, "failed to output block")
+		}
+	default:
+		return nil, errors.New("unknown block version")
 	}
 
 	if data.stream {
 		jsonOutput = data.jsonOutput
+		sszOutput = data.sszOutput
+		if !jsonOutput && !sszOutput {
+			fmt.Println("")
+		}
 		err := data.eth2Client.(eth2client.EventsProvider).Events(ctx, []string{"head"}, headEventHandler)
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to start block stream")
@@ -81,14 +114,58 @@ func headEventHandler(event *api.Event) {
 	blockID := fmt.Sprintf("%#x", event.Data.(*api.HeadEvent).Block[:])
 	signedBlock, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(context.Background(), blockID)
 	if err != nil {
-		fmt.Printf("Failed to obtain block: %v\n", err)
+		if !jsonOutput && !sszOutput {
+			fmt.Printf("Failed to obtain block: %v\n", err)
+		}
+		return
 	}
-	if err := outputBlock(context.Background(), jsonOutput, signedBlock); err != nil {
-		fmt.Printf("Failed to display block: %v\n", err)
+	if signedBlock == nil {
+		if !jsonOutput && !sszOutput {
+			fmt.Println("Empty beacon block")
+		}
+		return
+	}
+	switch signedBlock.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
+		}
+	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
+		}
+	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
+		}
+	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
+		}
+	default:
+		if !jsonOutput && !sszOutput {
+			fmt.Printf("Unknown block version: %v\n", signedBlock.Version)
+		}
+		return
+	}
+	if !jsonOutput && !sszOutput {
+		fmt.Println("")
 	}
 }
 
-func outputBlock(ctx context.Context, jsonOutput bool, signedBlock *spec.SignedBeaconBlock) error {
+func outputPhase0Block(ctx context.Context, jsonOutput bool, signedBlock *phase0.SignedBeaconBlock) error {
 	switch {
 	case jsonOutput:
 		data, err := json.Marshal(signedBlock)
@@ -97,11 +174,83 @@ func outputBlock(ctx context.Context, jsonOutput bool, signedBlock *spec.SignedB
 		}
 		fmt.Printf("%s\n", string(data))
 	default:
-		data, err := outputBlockText(ctx, results, signedBlock)
+		data, err := outputPhase0BlockText(ctx, results, signedBlock)
 		if err != nil {
 			return errors.Wrap(err, "failed to generate text")
 		}
-		fmt.Printf("%s\n", data)
+		fmt.Print(data)
+	}
+	return nil
+}
+
+func outputAltairBlock(ctx context.Context, jsonOutput bool, sszOutput bool, signedBlock *altair.SignedBeaconBlock) 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 := outputAltairBlockText(ctx, results, signedBlock)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate text")
+		}
+		fmt.Print(data)
+	}
+	return nil
+}
+
+func outputBellatrixBlock(ctx context.Context, jsonOutput bool, sszOutput bool, signedBlock *bellatrix.SignedBeaconBlock) 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 := outputBellatrixBlockText(ctx, results, signedBlock)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate text")
+		}
+		fmt.Print(data)
+	}
+	return nil
+}
+
+func outputCapellaBlock(ctx context.Context, jsonOutput bool, sszOutput bool, signedBlock *capella.SignedBeaconBlock) 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 := outputCapellaBlockText(ctx, results, signedBlock)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate text")
+		}
+		fmt.Print(data)
 	}
 	return 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: "failed to output block: failed to generate text: no block supplied",
+			err: "no block ID",
 		},
 	}
 

cmd/blockanalyze.go

@@ -0,0 +1,61 @@
+// Copyright © 2022 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	blockanalyze "github.com/wealdtech/ethdo/cmd/block/analyze"
+)
+
+var blockAnalyzeCmd = &cobra.Command{
+	Use:   "analyze",
+	Short: "Analyze a block",
+	Long: `Analyze the contents of a block.  For example:
+
+    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 {
+		res, err := blockanalyze.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Print(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	blockCmd.AddCommand(blockAnalyzeCmd)
+	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")
+}
+
+func blockAnalyzeBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("blockid", cmd.Flags().Lookup("blockid")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("stream", cmd.Flags().Lookup("stream")); err != nil {
+		panic(err)
+	}
+}

cmd/blockinfo.go

@@ -26,7 +26,7 @@ var blockInfoCmd = &cobra.Command{
 	Short: "Obtain information about a block",
 	Long: `Obtain information about a block.  For example:
 
-    ethdo block info --slot=12345
+    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 {
@@ -49,17 +49,17 @@ func init() {
 	blockFlags(blockInfoCmd)
 	blockInfoCmd.Flags().String("blockid", "head", "the ID of the block to fetch")
 	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("stream", cmd.Flags().Lookup("stream")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("json", blockInfoCmd.Flags().Lookup("json")); 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

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

cmd/chain/eth1votes/command_internal_test.go

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

cmd/chain/eth1votes/output.go

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

cmd/chain/eth1votes/process.go

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

cmd/chain/eth1votes/process_internal_test.go

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

cmd/chain/eth1votes/run.go

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

cmd/chain/queues/command.go

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

cmd/chain/queues/command_internal_test.go

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

cmd/chain/queues/output.go

@@ -0,0 +1,63 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package chainqueues
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+type jsonOutput struct {
+	ActivationQueue int `json:"activation_queue"`
+	ExitQueue       int `json:"exit_queue"`
+}
+
+func (c *command) output(ctx context.Context) (string, error) {
+	if c.quiet {
+		return "", nil
+	}
+
+	if c.json {
+		return c.outputJSON(ctx)
+	}
+	return c.outputText(ctx)
+}
+
+func (c *command) outputJSON(_ context.Context) (string, error) {
+	output := &jsonOutput{
+		ActivationQueue: c.activationQueue,
+		ExitQueue:       c.exitQueue,
+	}
+	data, err := json.Marshal(output)
+	if err != nil {
+		return "", err
+	}
+
+	return string(data), nil
+}
+
+func (c *command) outputText(_ context.Context) (string, error) {
+	builder := strings.Builder{}
+
+	if c.activationQueue > 0 {
+		builder.WriteString(fmt.Sprintf("Activation queue: %d\n", c.activationQueue))
+	}
+	if c.exitQueue > 0 {
+		builder.WriteString(fmt.Sprintf("Exit queue: %d\n", c.exitQueue))
+	}
+
+	return strings.TrimSuffix(builder.String(), "\n"), nil
+}

cmd/chain/queues/process.go

@@ -0,0 +1,86 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package chainqueues
+
+import (
+	"context"
+	"fmt"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/pkg/errors"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
+	"github.com/wealdtech/ethdo/util"
+)
+
+func (c *command) process(ctx context.Context) error {
+	// Obtain information we need to process.
+	if err := c.setup(ctx); err != nil {
+		return err
+	}
+
+	epoch, err := util.ParseEpoch(ctx, c.chainTime, c.epoch)
+	if err != nil {
+		return err
+	}
+
+	validators, err := c.validatorsProvider.Validators(ctx, fmt.Sprintf("%d", c.chainTime.FirstSlotOfEpoch(epoch)), nil)
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain validators")
+	}
+
+	for _, validator := range validators {
+		if validator.Validator == nil {
+			continue
+		}
+		if validator.Validator.ActivationEligibilityEpoch <= epoch && validator.Validator.ActivationEpoch > epoch {
+			c.activationQueue++
+		}
+		if validator.Validator.ExitEpoch != 0xffffffffffffffff && validator.Validator.ExitEpoch > epoch {
+			c.exitQueue++
+		}
+	}
+
+	return nil
+}
+
+func (c *command) setup(ctx context.Context) error {
+	var err error
+
+	// Connect to the client.
+	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+		Address:       c.connection,
+		Timeout:       c.timeout,
+		AllowInsecure: c.allowInsecureConnections,
+		LogFallback:   !c.quiet,
+	})
+	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.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+	)
+	if err != nil {
+		return errors.Wrap(err, "failed to set up chaintime service")
+	}
+
+	var isProvider bool
+	c.validatorsProvider, isProvider = c.eth2Client.(eth2client.ValidatorsProvider)
+	if !isProvider {
+		return errors.New("connection does not provide validator information")
+	}
+
+	return nil
+}

cmd/chain/queues/process_internal_test.go

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

cmd/chain/queues/run.go

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

cmd/chain/time/input.go

@@ -36,7 +36,7 @@ type dataIn struct {
 	epoch                    string
 }
 
-func input(ctx context.Context) (*dataIn, error) {
+func input(_ context.Context) (*dataIn, error) {
 	data := &dataIn{}
 
 	if viper.GetDuration("timeout") == 0 {
@@ -71,9 +71,6 @@ func input(ctx context.Context) (*dataIn, error) {
 		return nil, errors.New("one of timestamp, slot or epoch required")
 	}
 
-	if viper.GetString("connection") == "" {
-		return nil, errors.New("connection is required")
-	}
 	data.connection = viper.GetString("connection")
 	data.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
 

cmd/chain/time/input_internal_test.go

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

cmd/chain/time/output.go

@@ -28,15 +28,21 @@ type dataOut struct {
 	quiet   bool
 	verbose bool
 
-	epoch      spec.Epoch
-	epochStart time.Time
-	epochEnd   time.Time
-	slot       spec.Slot
-	slotStart  time.Time
-	slotEnd    time.Time
+	epoch                         spec.Epoch
+	epochStart                    time.Time
+	epochEnd                      time.Time
+	slot                          spec.Slot
+	slotStart                     time.Time
+	slotEnd                       time.Time
+	hasSyncCommittees             bool
+	syncCommitteePeriod           uint64
+	syncCommitteePeriodStart      time.Time
+	syncCommitteePeriodEpochStart spec.Epoch
+	syncCommitteePeriodEnd        time.Time
+	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")
 	}
@@ -51,15 +57,58 @@ 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(fmt.Sprintf("%d", data.epochStart.Unix()))
+		builder.WriteString(")")
+	}
 	builder.WriteString("\n  Epoch end ")
 	builder.WriteString(data.epochEnd.Format("2006-01-02 15:04:05"))
+	if data.verbose {
+		builder.WriteString(" (")
+		builder.WriteString(fmt.Sprintf("%d", data.epochEnd.Unix()))
+		builder.WriteString(")")
+	}
 
 	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(fmt.Sprintf("%d", data.slotStart.Unix()))
+		builder.WriteString(")")
+	}
 	builder.WriteString("\n  Slot end ")
 	builder.WriteString(data.slotEnd.Format("2006-01-02 15:04:05"))
+	if data.verbose {
+		builder.WriteString(" (")
+		builder.WriteString(fmt.Sprintf("%d", data.slotEnd.Unix()))
+		builder.WriteString(")")
+	}
+
+	if data.hasSyncCommittees {
+		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))
+		if data.verbose {
+			builder.WriteString(", ")
+			builder.WriteString(fmt.Sprintf("%d", data.syncCommitteePeriodStart.Unix()))
+		}
+		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(fmt.Sprintf("%d", data.syncCommitteePeriodEnd.Unix()))
+		}
+		builder.WriteString(")")
+	}
+
 	builder.WriteString("\n")
 
 	return builder.String(), nil

cmd/chain/time/process.go

@@ -19,8 +19,9 @@ 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"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
 	"github.com/wealdtech/ethdo/util"
 )
 
@@ -29,21 +30,22 @@ 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,
+		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.WithGenesisTimeProvider(eth2Client.(eth2client.GenesisTimeProvider)),
+	)
 	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)
-	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{
@@ -59,31 +61,35 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to parse slot")
 		}
-		results.slot = spec.Slot(slot)
+		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 = spec.Slot(epoch * slotsPerEpoch)
+		results.slot = chainTime.FirstSlotOfEpoch(epoch)
 	case data.timestamp != "":
-		timestamp, err := time.Parse("2006-01-02T15:04:05", 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 = spec.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 = spec.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.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
@@ -76,15 +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",
+				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),
+				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,
 			},
 		},
 	}

cmd/chain/verify/signedcontributionandproof/command.go

@@ -0,0 +1,83 @@
+// Copyright © 2021 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package chainverifysignedcontributionandproof
+
+import (
+	"context"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	api "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/spec/altair"
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+)
+
+type command struct {
+	quiet   bool
+	verbose bool
+	debug   bool
+
+	// Beacon node connection.
+	timeout                  time.Duration
+	connection               string
+	allowInsecureConnections bool
+
+	// Input.
+	data string
+	item *altair.SignedContributionAndProof
+
+	// Data access.
+	eth2Client         eth2client.Service
+	validatorsProvider eth2client.ValidatorsProvider
+
+	// Data.
+	spec          map[string]interface{}
+	validator     *api.Validator
+	syncCommittee *api.SyncCommittee
+
+	// Output.
+	itemStructureValid                       bool
+	validatorKnown                           bool
+	validatorInSyncCommittee                 bool
+	validatorIsAggregator                    bool
+	contributionSignatureValidFormat         bool
+	contributionAndProofSignatureValidFormat bool
+	contributionAndProofSignatureValid       bool
+	additionalInfo                           string
+}
+
+func newCommand(_ context.Context) (*command, error) {
+	c := &command{
+		quiet:   viper.GetBool("quiet"),
+		verbose: viper.GetBool("verbose"),
+		debug:   viper.GetBool("debug"),
+	}
+
+	// Timeout.
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	c.timeout = viper.GetDuration("timeout")
+
+	if viper.GetString("data") == "" {
+		return nil, errors.New("data is required")
+	}
+	c.data = viper.GetString("data")
+
+	c.connection = viper.GetString("connection")
+	c.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
+
+	return c, nil
+}

cmd/chain/verify/signedcontributionandproof/command_internal_test.go

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

cmd/chain/verify/signedcontributionandproof/output.go

@@ -0,0 +1,127 @@
+// Copyright © 2021 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package chainverifysignedcontributionandproof
+
+import (
+	"context"
+	"strings"
+)
+
+func (c *command) output(_ context.Context) (string, error) {
+	if c.quiet {
+		return "", nil
+	}
+
+	builder := strings.Builder{}
+
+	builder.WriteString("Valid data structure: ")
+	if c.itemStructureValid {
+		builder.WriteString("✓\n")
+	} else {
+		builder.WriteString("✕")
+		if c.additionalInfo != "" {
+			builder.WriteString(" (")
+			builder.WriteString(c.additionalInfo)
+			builder.WriteString(")")
+		}
+		builder.WriteString("\n")
+		return builder.String(), nil
+	}
+
+	builder.WriteString("Validator known: ")
+	if c.validatorKnown {
+		builder.WriteString("✓\n")
+	} else {
+		builder.WriteString("✕")
+		if c.additionalInfo != "" {
+			builder.WriteString(" (")
+			builder.WriteString(c.additionalInfo)
+			builder.WriteString(")")
+		}
+		builder.WriteString("\n")
+		return builder.String(), nil
+	}
+
+	builder.WriteString("Validator in sync committee: ")
+	if c.validatorInSyncCommittee {
+		builder.WriteString("✓\n")
+	} else {
+		builder.WriteString("✕")
+		if c.additionalInfo != "" {
+			builder.WriteString(" (")
+			builder.WriteString(c.additionalInfo)
+			builder.WriteString(")")
+		}
+		builder.WriteString("\n")
+		return builder.String(), nil
+	}
+
+	builder.WriteString("Validator is aggregator: ")
+	if c.validatorIsAggregator {
+		builder.WriteString("✓\n")
+	} else {
+		builder.WriteString("✕")
+		if c.additionalInfo != "" {
+			builder.WriteString(" (")
+			builder.WriteString(c.additionalInfo)
+			builder.WriteString(")")
+		}
+		builder.WriteString("\n")
+		return builder.String(), nil
+	}
+
+	builder.WriteString("Contribution signature has valid format: ")
+	if c.contributionSignatureValidFormat {
+		builder.WriteString("✓\n")
+	} else {
+		builder.WriteString("✕")
+		if c.additionalInfo != "" {
+			builder.WriteString(" (")
+			builder.WriteString(c.additionalInfo)
+			builder.WriteString(")")
+		}
+		builder.WriteString("\n")
+		return builder.String(), nil
+	}
+
+	builder.WriteString("Contribution and proof signature has valid format: ")
+	if c.contributionAndProofSignatureValidFormat {
+		builder.WriteString("✓\n")
+	} else {
+		builder.WriteString("✕")
+		if c.additionalInfo != "" {
+			builder.WriteString(" (")
+			builder.WriteString(c.additionalInfo)
+			builder.WriteString(")")
+		}
+		builder.WriteString("\n")
+		return builder.String(), nil
+	}
+
+	builder.WriteString("Contribution and proof signature is valid: ")
+	if c.contributionAndProofSignatureValid {
+		builder.WriteString("✓\n")
+	} else {
+		builder.WriteString("✕")
+		if c.additionalInfo != "" {
+			builder.WriteString(" (")
+			builder.WriteString(c.additionalInfo)
+			builder.WriteString(")")
+		}
+		builder.WriteString("\n")
+		return builder.String(), nil
+	}
+
+	return builder.String(), nil
+}

cmd/chain/verify/signedcontributionandproof/process.go

@@ -0,0 +1,311 @@
+// Copyright © 2021 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package chainverifysignedcontributionandproof
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"os"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/spec/altair"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/util"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+)
+
+func (c *command) process(ctx context.Context) error {
+	// Parse the data.
+	if c.data == "" {
+		return errors.New("no data supplied")
+	}
+	c.item = &altair.SignedContributionAndProof{}
+	err := json.Unmarshal([]byte(c.data), c.item)
+	if err != nil {
+		c.additionalInfo = err.Error()
+		//nolint:nilerr
+		return nil
+	}
+	c.itemStructureValid = true
+
+	// Obtain information we need to process.
+	if err := c.setup(ctx); err != nil {
+		return err
+	}
+
+	for _, validatorIndex := range c.syncCommittee.Validators {
+		if validatorIndex == c.item.Message.AggregatorIndex {
+			c.validatorInSyncCommittee = true
+			break
+		}
+	}
+	if !c.validatorInSyncCommittee {
+		return nil
+	}
+
+	// Ensure the validator is an aggregator.
+	isAggregator, err := c.isAggregator(ctx)
+	if err != nil {
+		return errors.Wrap(err, "failed to ascertain if sync committee member is aggregator")
+	}
+	if !isAggregator {
+		return nil
+	}
+	c.validatorIsAggregator = true
+
+	// Confirm the contribution signature.
+	if err := c.confirmContributionSignature(ctx); err != nil {
+		return errors.Wrap(err, "failed to confirm the contribution signature")
+	}
+
+	// Confirm the contribution and proof signature.
+	if err := c.confirmContributionAndProofSignature(ctx); err != nil {
+		return errors.Wrap(err, "failed to confirm the contribution and proof signature")
+	}
+
+	return nil
+}
+
+func (c *command) setup(ctx context.Context) error {
+	var err error
+
+	// Connect to the client.
+	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+		Address:       c.connection,
+		Timeout:       c.timeout,
+		AllowInsecure: c.allowInsecureConnections,
+		LogFallback:   !c.quiet,
+	})
+	if err != nil {
+		return errors.Wrap(err, "failed to connect to beacon node")
+	}
+
+	// Obtain the validator.
+	var isProvider bool
+	c.validatorsProvider, isProvider = c.eth2Client.(eth2client.ValidatorsProvider)
+	if !isProvider {
+		return errors.New("connection does not provide validator information")
+	}
+
+	stateID := fmt.Sprintf("%d", c.item.Message.Contribution.Slot)
+	validators, err := c.validatorsProvider.Validators(ctx,
+		stateID,
+		[]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 {
+		return nil
+	}
+	c.validatorKnown = true
+	c.validator = validators[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)
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain sync committee information")
+	}
+
+	return nil
+}
+
+// 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)
+	if err != nil {
+		return false, errors.Wrap(err, "failed to obtain spec information")
+	}
+
+	tmp, exists := c.spec["SYNC_COMMITTEE_SIZE"]
+	if !exists {
+		return false, errors.New("spec does not contain SYNC_COMMITTEE_SIZE")
+	}
+	if _, isUint64 := tmp.(uint64); !isUint64 {
+		return false, errors.New("spec returned non-integer value for SYNC_COMMITTEE_SIZE")
+	}
+	syncCommitteeSize := tmp.(uint64)
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "sync committee size is %d\n", syncCommitteeSize)
+	}
+
+	tmp, exists = c.spec["SYNC_COMMITTEE_SUBNET_COUNT"]
+	if !exists {
+		return false, errors.New("spec does not contain SYNC_COMMITTEE_SUBNET_COUNT")
+	}
+	if _, isUint64 := tmp.(uint64); !isUint64 {
+		return false, errors.New("spec returned non-integer value for SYNC_COMMITTEE_SUBNET_COUNT")
+	}
+	syncCommitteeSubnetCount := tmp.(uint64)
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "sync committee subnet count is %d\n", syncCommitteeSubnetCount)
+	}
+
+	tmp, exists = c.spec["TARGET_AGGREGATORS_PER_SYNC_SUBCOMMITTEE"]
+	if !exists {
+		return false, errors.New("spec does not contain TARGET_AGGREGATORS_PER_SYNC_SUBCOMMITTEE")
+	}
+	if _, isUint64 := tmp.(uint64); !isUint64 {
+		return false, errors.New("spec returned non-integer value for TARGET_AGGREGATORS_PER_SYNC_SUBCOMMITTEE")
+	}
+	targetAggregatorsPerSyncSubcommittee := tmp.(uint64)
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "target aggregators per sync subcommittee is %d\n", targetAggregatorsPerSyncSubcommittee)
+	}
+
+	modulo := syncCommitteeSize / syncCommitteeSubnetCount / targetAggregatorsPerSyncSubcommittee
+	if modulo < 1 {
+		modulo = 1
+	}
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "modulo is %d\n", modulo)
+	}
+
+	// Hash the selection proof.
+	sigHash := sha256.New()
+	n, err := sigHash.Write(c.item.Message.SelectionProof[:])
+	if err != nil {
+		return false, errors.Wrap(err, "failed to hash the selection proof")
+	}
+	if n != len(c.item.Signature[:]) {
+		return false, errors.New("failed to write all bytes of the selection proof to the hash")
+	}
+	hash := sigHash.Sum(nil)
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "hash of selection proof is %#x\n", hash)
+	}
+
+	return binary.LittleEndian.Uint64(hash[:8])%modulo == 0, nil
+}
+
+func (c *command) confirmContributionSignature(ctx context.Context) error {
+	sigBytes := make([]byte, 96)
+	copy(sigBytes, c.item.Message.Contribution.Signature[:])
+	_, err := e2types.BLSSignatureFromBytes(sigBytes)
+	if err != nil {
+		c.additionalInfo = err.Error()
+		//nolint:nilerr
+		return nil
+	}
+	c.contributionSignatureValidFormat = true
+
+	subCommittee := c.syncCommittee.ValidatorAggregates[c.item.Message.Contribution.SubcommitteeIndex]
+	includedIndices := make([]phase0.ValidatorIndex, 0, len(subCommittee))
+	for i := uint64(0); i < c.item.Message.Contribution.AggregationBits.Len(); i++ {
+		if c.item.Message.Contribution.AggregationBits.BitAt(i) {
+			includedIndices = append(includedIndices, subCommittee[int(i)])
+		}
+	}
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Contribution validator indices: %v (%d)\n", includedIndices, len(includedIndices))
+	}
+
+	includedValidators, err := c.validatorsProvider.Validators(ctx, "head", includedIndices)
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain subcommittee validators")
+	}
+	if len(includedValidators) == 0 {
+		return errors.New("obtained empty subcommittee validator list")
+	}
+
+	var aggregatePubKey *e2types.BLSPublicKey
+	for _, v := range includedValidators {
+		pubKeyBytes := make([]byte, 48)
+		copy(pubKeyBytes, v.Validator.PublicKey[:])
+		pubKey, err := e2types.BLSPublicKeyFromBytes(pubKeyBytes)
+		if err != nil {
+			return errors.Wrap(err, "failed to aggregate public key")
+		}
+		if aggregatePubKey == nil {
+			aggregatePubKey = pubKey
+		} else {
+			aggregatePubKey.Aggregate(pubKey)
+		}
+	}
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Aggregate public key is %#x\n", aggregatePubKey.Marshal())
+	}
+
+	// Don't have the ability to carry out the batch verification at current.
+
+	return nil
+}
+
+func (c *command) confirmContributionAndProofSignature(ctx context.Context) error {
+	sigBytes := make([]byte, 96)
+	copy(sigBytes, c.item.Signature[:])
+	sig, err := e2types.BLSSignatureFromBytes(sigBytes)
+	if err != nil {
+		c.additionalInfo = err.Error()
+		//nolint:nilerr
+		return nil
+	}
+	c.contributionAndProofSignatureValidFormat = true
+
+	pubKeyBytes := make([]byte, 48)
+	copy(pubKeyBytes, c.validator.Validator.PublicKey[:])
+	pubKey, err := e2types.BLSPublicKeyFromBytes(pubKeyBytes)
+	if err != nil {
+		return errors.Wrap(err, "failed to configure public key")
+	}
+
+	objectRoot, err := c.item.Message.HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain signging root")
+	}
+
+	tmp, exists := c.spec["DOMAIN_CONTRIBUTION_AND_PROOF"]
+	if !exists {
+		return errors.New("spec does not contain DOMAIN_CONTRIBUTION_AND_PROOF")
+	}
+	if _, isUint64 := tmp.(phase0.DomainType); !isUint64 {
+		return errors.New("spec returned non-domain type value for DOMAIN_CONTRIBUTION_AND_PROOF")
+	}
+	contributionAndProofDomainType := tmp.(phase0.DomainType)
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "contribution and proof domain type is %#x\n", contributionAndProofDomainType)
+	}
+	domain, err := c.eth2Client.(eth2client.DomainProvider).Domain(ctx, contributionAndProofDomainType, phase0.Epoch(c.item.Message.Contribution.Slot/32))
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain domain")
+	}
+
+	container := &phase0.SigningData{
+		ObjectRoot: objectRoot,
+		Domain:     domain,
+	}
+	signingRoot, err := container.HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain signging root")
+	}
+
+	c.contributionAndProofSignatureValid = sig.Verify(signingRoot[:], pubKey)
+
+	return nil
+}

cmd/chain/verify/signedcontributionandproof/process_internal_test.go

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

cmd/chain/verify/signedcontributionandproof/run.go

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

cmd/chaineth1votes.go

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

cmd/chaininfo.go

@@ -1,4 +1,4 @@
-// Copyright © 2020 Weald Technology Trading
+// Copyright © 2020, 2022 Weald Technology Trading
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -37,7 +37,12 @@ In quiet mode this will return 0 if the chain information can be obtained, other
 	Run: func(cmd *cobra.Command, args []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"),
+			LogFallback:   !viper.GetBool("quiet"),
+		})
 		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 
 		config, err := eth2Client.(eth2client.SpecProvider).Spec(ctx)
@@ -46,7 +51,10 @@ In quiet mode this will return 0 if the chain information can be obtained, other
 		genesis, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
 		errCheck(err, "Failed to obtain beacon chain genesis")
 
-		if quiet {
+		fork, err := eth2Client.(eth2client.ForkProvider).Fork(ctx, "head")
+		errCheck(err, "Failed to obtain current fork")
+
+		if viper.GetBool("quiet") {
 			os.Exit(_exitSuccess)
 		}
 
@@ -54,10 +62,23 @@ In quiet mode this will return 0 if the chain information can be obtained, other
 			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()))
+			outputIf(viper.GetBool("verbose"), fmt.Sprintf("Genesis timestamp: %v", genesis.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("Genesis fork version: %#x\n", config["GENESIS_FORK_VERSION"].(spec.Version))
+		fmt.Printf("Current fork version: %#x\n", fork.CurrentVersion)
+		if viper.GetBool("verbose") {
+			forkData := &spec.ForkData{
+				CurrentVersion:        fork.CurrentVersion,
+				GenesisValidatorsRoot: genesis.GenesisValidatorsRoot,
+			}
+			forkDataRoot, err := forkData.HashTreeRoot()
+			if err == nil {
+				var forkDigest spec.ForkDigest
+				copy(forkDigest[:], forkDataRoot[:])
+				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))
 
@@ -70,17 +91,5 @@ func init() {
 	chainFlags(chainInfoCmd)
 }
 
-func timestampToSlot(genesis time.Time, timestamp time.Time, secondsPerSlot time.Duration) spec.Slot {
-	if timestamp.Unix() < genesis.Unix() {
-		return 0
-	}
-	return spec.Slot(uint64(timestamp.Unix()-genesis.Unix()) / uint64(secondsPerSlot.Seconds()))
-}
-
-func slotToTimestamp(genesis time.Time, slot spec.Slot, slotDuration time.Duration) int64 {
-	return genesis.Unix() + int64(slot)*int64(slotDuration.Seconds())
-}
-
-func epochToTimestamp(genesis time.Time, slot spec.Slot, slotDuration time.Duration, slotsPerEpoch uint64) int64 {
-	return genesis.Unix() + int64(slot)*int64(slotDuration.Seconds())*int64(slotsPerEpoch)
+func chainInfoBindings(_ *cobra.Command) {
 }

cmd/chainqueues.go

@@ -0,0 +1,57 @@
+// Copyright © 2022 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	chainqueues "github.com/wealdtech/ethdo/cmd/chain/queues"
+)
+
+var chainQueuesCmd = &cobra.Command{
+	Use:   "queues",
+	Short: "Show chain queues",
+	Long: `Show beacon chain activation and exit queues.  For example:
+
+    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 {
+		res, err := chainqueues.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	chainCmd.AddCommand(chainQueuesCmd)
+	chainFlags(chainQueuesCmd)
+	chainQueuesCmd.Flags().String("epoch", "", "epoch for which to fetch the queues")
+}
+
+func chainQueuesBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("epoch", cmd.Flags().Lookup("epoch")); err != nil {
+		panic(err)
+	}
+}

cmd/chainspec.go

@@ -0,0 +1,97 @@
+// 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"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"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(cmd *cobra.Command, args []string) {
+		ctx := context.Background()
+
+		eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+			Address:       viper.GetString("connection"),
+			Timeout:       viper.GetDuration("timeout"),
+			AllowInsecure: viper.GetBool("allow-insecure-connections"),
+			LogFallback:   !viper.GetBool("quiet"),
+		})
+		errCheck(err, "Failed to connect to Ethereum consensus node")
+
+		spec, err := eth2Client.(eth2client.SpecProvider).Spec(ctx)
+		errCheck(err, "Failed to obtain chain specification")
+
+		if viper.GetBool("quiet") {
+			return
+		}
+
+		// Tweak the spec for output.
+		for k, v := range spec {
+			switch t := v.(type) {
+			case phase0.Version:
+				spec[k] = fmt.Sprintf("%#x", t)
+			case phase0.DomainType:
+				spec[k] = fmt.Sprintf("%#x", t)
+			case time.Time:
+				spec[k] = fmt.Sprintf("%d", t.Unix())
+			case time.Duration:
+				spec[k] = fmt.Sprintf("%d", uint64(t.Seconds()))
+			case []byte:
+				spec[k] = fmt.Sprintf("%#x", t)
+			case uint64:
+				spec[k] = fmt.Sprintf("%d", t)
+			}
+		}
+
+		if viper.GetBool("json") {
+			data, err := json.Marshal(spec)
+			errCheck(err, "Failed to marshal JSON")
+			fmt.Printf("%s\n", string(data))
+		} else {
+			keys := make([]string, 0, len(spec))
+			for k := range spec {
+				keys = append(keys, k)
+			}
+			sort.Strings(keys)
+			for _, key := range keys {
+				fmt.Printf("%s: %v\n", key, spec[key])
+			}
+		}
+	},
+}
+
+func init() {
+	chainCmd.AddCommand(chainSpecCmd)
+	chainFlags(chainSpecCmd)
+}
+
+func chainSpecBindings(_ *cobra.Command) {
+}

cmd/chainstatus.go

@@ -1,4 +1,4 @@
-// Copyright © 2020 Weald Technology Trading
+// Copyright © 2020, 2021 Weald Technology Trading.
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -17,13 +17,17 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"strings"
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
 	"github.com/wealdtech/ethdo/util"
+	string2eth "github.com/wealdtech/go-string2eth"
 )
 
 var chainStatusCmd = &cobra.Command{
@@ -37,49 +41,151 @@ In quiet mode this will return 0 if the chain status can be obtained, otherwise
 	Run: func(cmd *cobra.Command, args []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"),
+			LogFallback:   !viper.GetBool("quiet"),
+		})
 		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 
-		config, err := eth2Client.(eth2client.SpecProvider).Spec(ctx)
-		errCheck(err, "Failed to obtain beacon chain specification")
+		chainTime, err := standardchaintime.New(ctx,
+			standardchaintime.WithGenesisTimeProvider(eth2Client.(eth2client.GenesisTimeProvider)),
+			standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
+		)
+		errCheck(err, "Failed to configure chaintime service")
 
-		finality, err := eth2Client.(eth2client.FinalityProvider).Finality(ctx, "head")
+		finalityProvider, isProvider := eth2Client.(eth2client.FinalityProvider)
+		assert(isProvider, "beacon node does not provide finality; cannot report on chain status")
+		finality, err := finalityProvider.Finality(ctx, "head")
 		errCheck(err, "Failed to obtain finality information")
 
-		genesis, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
-		errCheck(err, "Failed to obtain genesis information")
+		slot := chainTime.CurrentSlot()
 
-		slotDuration := config["SECONDS_PER_SLOT"].(time.Duration)
-		curSlot := timestampToSlot(genesis.GenesisTime, time.Now(), slotDuration)
-		slotsPerEpoch := config["SLOTS_PER_EPOCH"].(uint64)
-		curEpoch := spec.Epoch(uint64(curSlot) / slotsPerEpoch)
-		fmt.Printf("Current epoch: %d\n", curEpoch)
-		fmt.Printf("Justified epoch: %d\n", finality.Justified.Epoch)
-		if verbose {
-			distance := curEpoch - finality.Justified.Epoch
-			fmt.Printf("Justified epoch distance: %d\n", distance)
-		}
-		fmt.Printf("Finalized epoch: %d\n", finality.Finalized.Epoch)
-		if verbose {
-			distance := curEpoch - finality.Finalized.Epoch
-			fmt.Printf("Finalized epoch distance: %d\n", distance)
-		}
-		if verbose {
-			fmt.Printf("Prior justified epoch: %d\n", finality.PreviousJustified.Epoch)
-			distance := curEpoch - finality.PreviousJustified.Epoch
-			fmt.Printf("Prior justified epoch distance: %d\n", distance)
+		nextSlot := slot + 1
+		nextSlotTimestamp := chainTime.StartOfSlot(nextSlot)
+
+		epoch := chainTime.CurrentEpoch()
+		epochStartSlot := chainTime.FirstSlotOfEpoch(epoch)
+		epochEndSlot := chainTime.FirstSlotOfEpoch(epoch+1) - 1
+
+		nextEpoch := epoch + 1
+		nextEpochStartSlot := chainTime.FirstSlotOfEpoch(nextEpoch)
+		nextEpochTimestamp := chainTime.StartOfEpoch(nextEpoch)
+
+		res := strings.Builder{}
+
+		res.WriteString("Current slot: ")
+		res.WriteString(fmt.Sprintf("%d", slot))
+		res.WriteString("\n")
+
+		res.WriteString("Current epoch: ")
+		res.WriteString(fmt.Sprintf("%d", epoch))
+		res.WriteString("\n")
+
+		if viper.GetBool("verbose") {
+			res.WriteString("Epoch slots: ")
+			res.WriteString(fmt.Sprintf("%d", epochStartSlot))
+			res.WriteString("-")
+			res.WriteString(fmt.Sprintf("%d", epochEndSlot))
+			res.WriteString("\n")
 		}
 
-		if verbose {
-			epochStartSlot := (uint64(curSlot) / slotsPerEpoch) * slotsPerEpoch
-			fmt.Printf("Epoch slots: %d-%d\n", epochStartSlot, epochStartSlot+slotsPerEpoch-1)
-			nextSlotTimestamp := slotToTimestamp(genesis.GenesisTime, curSlot+1, slotDuration)
-			fmt.Printf("Time until next slot: %2.1fs\n", float64(time.Until(time.Unix(nextSlotTimestamp, 0)).Milliseconds())/1000)
-			nextEpoch := epochToTimestamp(genesis.GenesisTime, spec.Slot(uint64(curSlot)/slotsPerEpoch+1), slotDuration, slotsPerEpoch)
-			fmt.Printf("Slots until next epoch: %d\n", (uint64(curSlot)/slotsPerEpoch+1)*slotsPerEpoch-uint64(curSlot))
-			fmt.Printf("Time until next epoch: %2.1fs\n", float64(time.Until(time.Unix(nextEpoch, 0)).Milliseconds())/1000)
+		res.WriteString("Time until next slot: ")
+		res.WriteString(time.Until(nextSlotTimestamp).Round(time.Second).String())
+		res.WriteString("\n")
+
+		res.WriteString("Time until next epoch: ")
+		res.WriteString(time.Until(nextEpochTimestamp).Round(time.Second).String())
+		res.WriteString("\n")
+
+		res.WriteString("Slots until next epoch: ")
+		res.WriteString(fmt.Sprintf("%d", nextEpochStartSlot-slot))
+		res.WriteString("\n")
+
+		res.WriteString("Justified epoch: ")
+		res.WriteString(fmt.Sprintf("%d", finality.Justified.Epoch))
+		res.WriteString("\n")
+		if viper.GetBool("verbose") {
+			distance := epoch - finality.Justified.Epoch
+			res.WriteString("Justified epoch distance: ")
+			res.WriteString(fmt.Sprintf("%d", distance))
+			res.WriteString("\n")
 		}
 
+		res.WriteString("Finalized epoch: ")
+		res.WriteString(fmt.Sprintf("%d", finality.Finalized.Epoch))
+		res.WriteString("\n")
+		if viper.GetBool("verbose") {
+			distance := epoch - finality.Finalized.Epoch
+			res.WriteString("Finalized epoch distance: ")
+			res.WriteString(fmt.Sprintf("%d", distance))
+			res.WriteString("\n")
+		}
+
+		if viper.GetBool("verbose") {
+			validatorsProvider, isProvider := eth2Client.(eth2client.ValidatorsProvider)
+			if isProvider {
+				validators, err := validatorsProvider.Validators(ctx, "head", nil)
+				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 {
+					validatorCount[validator.Status]++
+					totalBalance += validator.Balance
+					if validator.Status.IsActive() {
+						activeEffectiveBalance += validator.Validator.EffectiveBalance
+					}
+				}
+				res.WriteString(fmt.Sprintf("Total balance: %s\n", string2eth.GWeiToString(uint64(totalBalance), true)))
+				res.WriteString(fmt.Sprintf("Active effective balance: %s\n", string2eth.GWeiToString(uint64(activeEffectiveBalance), true)))
+				res.WriteString("Validator states:\n")
+				res.WriteString(fmt.Sprintf("  Pending: %d\n", validatorCount[apiv1.ValidatorStatePendingInitialized]))
+				res.WriteString(fmt.Sprintf("  Activating: %d\n", validatorCount[apiv1.ValidatorStatePendingQueued]))
+				res.WriteString(fmt.Sprintf("  Active: %d\n", validatorCount[apiv1.ValidatorStateActiveOngoing]+validatorCount[apiv1.ValidatorStateActiveSlashed]))
+				res.WriteString(fmt.Sprintf("  Exiting: %d\n", validatorCount[apiv1.ValidatorStateActiveExiting]))
+				res.WriteString(fmt.Sprintf("  Exited: %d\n", validatorCount[apiv1.ValidatorStateExitedUnslashed]+validatorCount[apiv1.ValidatorStateExitedSlashed]+validatorCount[apiv1.ValidatorStateWithdrawalPossible]+validatorCount[apiv1.ValidatorStateWithdrawalDone]))
+				res.WriteString(fmt.Sprintf("  Unknown: %d\n", validatorCount[apiv1.ValidatorStateUnknown]))
+			}
+		}
+
+		if epoch >= chainTime.AltairInitialEpoch() {
+			period := chainTime.SlotToSyncCommitteePeriod(slot)
+			periodStartEpoch := chainTime.FirstEpochOfSyncPeriod(period)
+			periodStartSlot := chainTime.FirstSlotOfEpoch(periodStartEpoch)
+			nextPeriod := period + 1
+			nextPeriodStartEpoch := chainTime.FirstEpochOfSyncPeriod(nextPeriod)
+			periodEndEpoch := nextPeriodStartEpoch - 1
+			periodEndSlot := chainTime.FirstSlotOfEpoch(periodEndEpoch+1) - 1
+			nextPeriodTimestamp := chainTime.StartOfEpoch(nextPeriodStartEpoch)
+
+			res.WriteString("Sync committee period: ")
+			res.WriteString(fmt.Sprintf("%d", period))
+			res.WriteString("\n")
+
+			if viper.GetBool("verbose") {
+				res.WriteString("Sync committee epochs: ")
+				res.WriteString(fmt.Sprintf("%d", periodStartEpoch))
+				res.WriteString("-")
+				res.WriteString(fmt.Sprintf("%d", periodEndEpoch))
+				res.WriteString("\n")
+
+				res.WriteString("Sync committee slots: ")
+				res.WriteString(fmt.Sprintf("%d", periodStartSlot))
+				res.WriteString("-")
+				res.WriteString(fmt.Sprintf("%d", periodEndSlot))
+				res.WriteString("\n")
+
+				res.WriteString("Time until next sync committee period: ")
+				res.WriteString(time.Until(nextPeriodTimestamp).Round(time.Second).String())
+				res.WriteString("\n")
+			}
+		}
+
+		fmt.Print(res.String())
+
 		os.Exit(_exitSuccess)
 	},
 }

cmd/chaintime.go

@@ -44,17 +44,17 @@ func init() {
 	chainFlags(chainTimeCmd)
 	chainTimeCmd.Flags().String("slot", "", "The slot for which to obtain information")
 	chainTimeCmd.Flags().String("epoch", "", "The epoch for which to obtain information")
-	chainTimeCmd.Flags().String("timestamp", "", "The timestamp for which to obtain information (format YYYY-MM-DDTHH:MM:SS)")
+	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

@@ -0,0 +1,45 @@
+// Copyright © 2021 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// chainVerifyCmd represents the chain verify command.
+var chainVerifyCmd = &cobra.Command{
+	Use:   "verify",
+	Short: "Verify a beacon chain signature",
+	Long:  "Verify the signature for a given beacon chain structure is correct",
+}
+
+func init() {
+	chainCmd.AddCommand(chainVerifyCmd)
+}
+
+func chainVerifyFlags(cmd *cobra.Command) {
+	chainFlags(cmd)
+	cmd.Flags().String("validator", "", "The account, public key or index of the validator")
+	cmd.Flags().String("data", "", "The data to verify, as a JSON structure")
+}
+
+func chainVerifyBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("validator", cmd.Flags().Lookup("validator")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("data", cmd.Flags().Lookup("data")); err != nil {
+		panic(err)
+	}
+}

cmd/chainverifysignedcontributionandproof.go

@@ -0,0 +1,50 @@
+// Copyright © 2021 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	chainverifysignedcontributionandproof "github.com/wealdtech/ethdo/cmd/chain/verify/signedcontributionandproof"
+)
+
+var chainVerifySignedContributionAndProofCmd = &cobra.Command{
+	Use:   "signedcontributionandproof",
+	Short: "Verify a signed contribution and proof",
+	Long: `Verify a signed contribution and proof.  For example:
+
+    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 {
+		res, err := chainverifysignedcontributionandproof.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if res != "" {
+			fmt.Print(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	chainVerifyCmd.AddCommand(chainVerifySignedContributionAndProofCmd)
+	chainVerifyFlags(chainVerifySignedContributionAndProofCmd)
+}
+
+func chainVerifySignedContributionAndProofBindings(cmd *cobra.Command) {
+	chainVerifyBindings(cmd)
+}

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

@@ -1,4 +1,4 @@
-// Copyright © 2019-2021 Weald Technology Limited.
+// Copyright © 2019-2022 Weald Technology Limited.
 // 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,25 +17,27 @@ import (
 	"bytes"
 	"encoding/hex"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"strings"
 
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/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",
@@ -46,7 +48,7 @@ var depositVerifyCmd = &cobra.Command{
 
 The deposit data is compared to the supplied withdrawal account/public key, validator public key, and value to ensure they match.
 
-In quiet mode this will return 0 if the the data is verified correctly, otherwise 1.`,
+In quiet mode this will return 0 if the data is verified correctly, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
 		assert(depositVerifyData != "", "--data is required")
 		var data []byte
@@ -64,7 +66,7 @@ In quiet mode this will return 0 if the the data is verified correctly, otherwis
 			data = []byte(depositVerifyData)
 		default:
 			// Assume it's a path to JSON.
-			data, err = ioutil.ReadFile(depositVerifyData)
+			data, err = os.ReadFile(depositVerifyData)
 			errCheck(err, "Failed to read deposit data file")
 			if data[0] == '{' {
 				data = []byte("[" + string(data) + "]")
@@ -91,7 +93,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 != "" {
@@ -119,9 +121,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))
 			}
 		}
 
@@ -155,7 +157,7 @@ func validatorPubKeysFromInput(input string) (map[[48]byte]bool, error) {
 		pubKeys[key] = true
 	} else {
 		// Assume it's a path to a file of public keys.
-		data, err = ioutil.ReadFile(input)
+		data, err = os.ReadFile(input)
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to find public key file")
 		}
@@ -189,45 +191,45 @@ 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 spec.BLSPubKey
+	var pubKey phase0.BLSPubKey
 	copy(pubKey[:], deposit.PublicKey)
-	var signature spec.BLSSignature
+	var signature phase0.BLSSignature
 	copy(signature[:], deposit.Signature)
 
-	depositData := &spec.DepositData{
+	depositData := &phase0.DepositData{
 		PublicKey:             pubKey,
 		WithdrawalCredentials: deposit.WithdrawalCredentials,
-		Amount:                spec.Gwei(deposit.Amount),
+		Amount:                phase0.Gwei(deposit.Amount),
 		Signature:             signature,
 	}
 	depositDataRoot, err := depositData.HashTreeRoot()
@@ -236,30 +238,80 @@ 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(!viper.GetBool("quiet"), "Deposit message root not supplied; not checked")
+			} else {
+				// We can also verify the deposit message signature.
+				depositMessage := &phase0.DepositMessage{
+					PublicKey:             pubKey,
+					WithdrawalCredentials: withdrawalCredentials,
+					Amount:                phase0.Gwei(deposit.Amount),
+				}
+				depositMessageRoot, err := depositMessage.HashTreeRoot()
+				if err != nil {
+					return false, errors.Wrap(err, "failed to generate deposit message root")
+				}
+
+				if bytes.Equal(deposit.DepositMessageRoot, depositMessageRoot[:]) {
+					outputIf(!viper.GetBool("quiet"), "Deposit message root verified")
+				} else {
+					outputIf(!viper.GetBool("quiet"), "Deposit message root incorrect")
+					return false, nil
+				}
+
+				domainBytes := e2types.Domain(e2types.DomainDeposit, forkVersion, e2types.ZeroGenesisValidatorsRoot)
+				var domain phase0.Domain
+				copy(domain[:], domainBytes)
+				container := &phase0.SigningData{
+					ObjectRoot: depositMessageRoot,
+					Domain:     domain,
+				}
+				containerRoot, err := container.HashTreeRoot()
+				if err != nil {
+					return false, errors.New("failed to generate root for container")
+				}
+
+				validatorPubKey, err := e2types.BLSPublicKeyFromBytes(pubKey[:])
+				if err != nil {
+					return false, errors.Wrap(err, "failed to generate validator public key")
+				}
+				blsSig, err := e2types.BLSSignatureFromBytes(signature[:])
+				if err != nil {
+					return false, errors.New("failed to verify BLS signature")
+				}
+				signatureVerified := blsSig.Verify(containerRoot[:], validatorPubKey)
+				if signatureVerified {
+					outputIf(!viper.GetBool("quiet"), "Deposit message signature verified")
+				} else {
+					outputIf(!viper.GetBool("quiet"), "Deposit message signature NOT verified")
+					return false, nil
+				}
+			}
 		}
 	}
 

cmd/epoch.go

@@ -0,0 +1,40 @@
+// Copyright © 2022 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// epochCmd represents the epoch command.
+var epochCmd = &cobra.Command{
+	Use:   "epoch",
+	Short: "Obtain information about Ethereum 2 epochs",
+	Long:  "Obtain information about Ethereum 2 epochs",
+}
+
+func init() {
+	RootCmd.AddCommand(epochCmd)
+}
+
+func epochFlags(_ *cobra.Command) {
+	epochSummaryCmd.Flags().String("epoch", "", "the epoch for which to obtain information (default current, can be 'current', 'last' or a number)")
+}
+
+func epochBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("epoch", cmd.Flags().Lookup("epoch")); err != nil {
+		panic(err)
+	}
+}

cmd/epoch/summary/command.go

@@ -0,0 +1,111 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package epochsummary
+
+import (
+	"context"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/services/chaintime"
+)
+
+type command struct {
+	quiet   bool
+	verbose bool
+	debug   bool
+
+	// Beacon node connection.
+	timeout                  time.Duration
+	connection               string
+	allowInsecureConnections bool
+
+	// Operation.
+	epoch      string
+	stream     bool
+	jsonOutput bool
+
+	// Data access.
+	eth2Client                 eth2client.Service
+	chainTime                  chaintime.Service
+	proposerDutiesProvider     eth2client.ProposerDutiesProvider
+	blocksProvider             eth2client.SignedBeaconBlockProvider
+	syncCommitteesProvider     eth2client.SyncCommitteesProvider
+	validatorsProvider         eth2client.ValidatorsProvider
+	beaconCommitteesProvider   eth2client.BeaconCommitteesProvider
+	beaconBlockHeadersProvider eth2client.BeaconBlockHeadersProvider
+
+	// Results.
+	summary *epochSummary
+}
+
+type epochSummary struct {
+	Epoch                      phase0.Epoch                 `json:"epoch"`
+	FirstSlot                  phase0.Slot                  `json:"first_slot"`
+	LastSlot                   phase0.Slot                  `json:"last_slot"`
+	Proposals                  []*epochProposal             `json:"proposals"`
+	SyncCommittee              []*epochSyncCommittee        `json:"sync_committees"`
+	ActiveValidators           int                          `json:"active_validators"`
+	ParticipatingValidators    int                          `json:"participating_validators"`
+	HeadCorrectValidators      int                          `json:"head_correct_validators"`
+	HeadTimelyValidators       int                          `json:"head_timely_validators"`
+	SourceTimelyValidators     int                          `json:"source_timely_validators"`
+	TargetCorrectValidators    int                          `json:"target_correct_validators"`
+	TargetTimelyValidators     int                          `json:"target_timely_validators"`
+	NonParticipatingValidators []*nonParticipatingValidator `json:"nonparticipating_validators"`
+}
+
+type epochProposal struct {
+	Slot     phase0.Slot           `json:"slot"`
+	Proposer phase0.ValidatorIndex `json:"proposer"`
+	Block    bool                  `json:"block"`
+}
+
+type epochSyncCommittee struct {
+	Index  phase0.ValidatorIndex `json:"index"`
+	Missed int                   `json:"missed"`
+}
+
+type nonParticipatingValidator struct {
+	Validator phase0.ValidatorIndex `json:"validator_index"`
+	Slot      phase0.Slot           `json:"slot"`
+	Committee phase0.CommitteeIndex `json:"committee_index"`
+}
+
+func newCommand(_ context.Context) (*command, error) {
+	c := &command{
+		quiet:   viper.GetBool("quiet"),
+		verbose: viper.GetBool("verbose"),
+		debug:   viper.GetBool("debug"),
+		summary: &epochSummary{},
+	}
+
+	// Timeout.
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	c.timeout = viper.GetDuration("timeout")
+
+	c.connection = viper.GetString("connection")
+	c.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
+
+	c.epoch = viper.GetString("epoch")
+	c.stream = viper.GetBool("stream")
+	c.jsonOutput = viper.GetBool("json")
+
+	return c, nil
+}

cmd/epoch/summary/command_internal_test.go

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

cmd/epoch/summary/output.go

@@ -0,0 +1,110 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package epochsummary
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+func (c *command) output(ctx context.Context) (string, error) {
+	if c.quiet {
+		return "", nil
+	}
+
+	if c.jsonOutput {
+		return c.outputJSON(ctx)
+	}
+
+	return c.outputTxt(ctx)
+}
+
+func (c *command) outputJSON(_ context.Context) (string, error) {
+	data, err := json.Marshal(c.summary)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+func (c *command) outputTxt(_ context.Context) (string, error) {
+	builder := strings.Builder{}
+
+	builder.WriteString("Epoch ")
+	builder.WriteString(fmt.Sprintf("%d:\n", c.summary.Epoch))
+
+	proposedBlocks := 0
+	missedProposals := make([]string, 0, len(c.summary.Proposals))
+	for _, proposal := range c.summary.Proposals {
+		if !proposal.Block {
+			missedProposals = append(missedProposals, fmt.Sprintf("\n    Slot %d (validator %d)", proposal.Slot, proposal.Proposer))
+		} else {
+			proposedBlocks++
+		}
+	}
+	builder.WriteString(fmt.Sprintf("  Proposals: %d/%d (%0.2f%%)", proposedBlocks, len(missedProposals)+proposedBlocks, 100.0*float64(proposedBlocks)/float64(len(missedProposals)+proposedBlocks)))
+	if c.verbose {
+		for _, proposal := range c.summary.Proposals {
+			if proposal.Block {
+				continue
+			}
+			builder.WriteString("\n    Slot ")
+			builder.WriteString(fmt.Sprintf("%d (%d/%d)", proposal.Slot, uint64(proposal.Slot)%uint64(len(c.summary.Proposals)), len(c.summary.Proposals)))
+			builder.WriteString(" validator ")
+			builder.WriteString(fmt.Sprintf("%d", proposal.Proposer))
+			builder.WriteString(" not proposed or not included")
+		}
+	}
+
+	builder.WriteString(fmt.Sprintf("\n  Attestations: %d/%d (%0.2f%%)", c.summary.ParticipatingValidators, c.summary.ActiveValidators, 100.0*float64(c.summary.ParticipatingValidators)/float64(c.summary.ActiveValidators)))
+	builder.WriteString(fmt.Sprintf("\n    Source timely: %d/%d (%0.2f%%)", c.summary.SourceTimelyValidators, c.summary.ActiveValidators, 100.0*float64(c.summary.SourceTimelyValidators)/float64(c.summary.ActiveValidators)))
+	builder.WriteString(fmt.Sprintf("\n    Target correct: %d/%d (%0.2f%%)", c.summary.TargetCorrectValidators, c.summary.ActiveValidators, 100.0*float64(c.summary.TargetCorrectValidators)/float64(c.summary.ActiveValidators)))
+	builder.WriteString(fmt.Sprintf("\n    Target timely: %d/%d (%0.2f%%)", c.summary.TargetTimelyValidators, c.summary.ActiveValidators, 100.0*float64(c.summary.TargetTimelyValidators)/float64(c.summary.ActiveValidators)))
+	builder.WriteString(fmt.Sprintf("\n    Head correct: %d/%d (%0.2f%%)", c.summary.HeadCorrectValidators, c.summary.ActiveValidators, 100.0*float64(c.summary.HeadCorrectValidators)/float64(c.summary.ActiveValidators)))
+	builder.WriteString(fmt.Sprintf("\n    Head timely: %d/%d (%0.2f%%)", c.summary.HeadTimelyValidators, c.summary.ActiveValidators, 100.0*float64(c.summary.HeadTimelyValidators)/float64(c.summary.ActiveValidators)))
+	if c.verbose {
+		// Sort list by validator index.
+		for _, validator := range c.summary.NonParticipatingValidators {
+			builder.WriteString("\n    Slot ")
+			builder.WriteString(fmt.Sprintf("%d", validator.Slot))
+			builder.WriteString(" committee ")
+			builder.WriteString(fmt.Sprintf("%d", validator.Committee))
+			builder.WriteString(" validator ")
+			builder.WriteString(fmt.Sprintf("%d", validator.Validator))
+			builder.WriteString(" failed to participate")
+		}
+	}
+
+	if c.summary.Epoch >= c.chainTime.AltairInitialEpoch() {
+		contributions := proposedBlocks * 512 // SYNC_COMMITTEE_SIZE
+		totalMissed := 0
+		for _, contribution := range c.summary.SyncCommittee {
+			totalMissed += contribution.Missed
+		}
+		builder.WriteString(fmt.Sprintf("\n  Sync committees: %d/%d (%0.2f%%)", contributions-totalMissed, contributions, 100.0*float64(contributions-totalMissed)/float64(contributions)))
+		if c.verbose {
+			for _, syncCommittee := range c.summary.SyncCommittee {
+				builder.WriteString("\n    Validator ")
+				builder.WriteString(fmt.Sprintf("%d", syncCommittee.Index))
+				builder.WriteString(" included ")
+				builder.WriteString(fmt.Sprintf("%d/%d", proposedBlocks-syncCommittee.Missed, proposedBlocks))
+				builder.WriteString(fmt.Sprintf(" (%0.2f%%)", 100.0*float64(proposedBlocks-syncCommittee.Missed)/float64(proposedBlocks)))
+			}
+		}
+	}
+
+	return builder.String(), nil
+}

cmd/epoch/summary/process.go

@@ -0,0 +1,372 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package epochsummary
+
+import (
+	"context"
+	"fmt"
+	"sort"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/spec"
+	"github.com/attestantio/go-eth2-client/spec/altair"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
+	"github.com/wealdtech/ethdo/util"
+)
+
+func (c *command) process(ctx context.Context) error {
+	// Obtain information we need to process.
+	err := c.setup(ctx)
+	if err != nil {
+		return err
+	}
+
+	c.summary.Epoch, err = util.ParseEpoch(ctx, c.chainTime, c.epoch)
+	if err != nil {
+		return errors.Wrap(err, "failed to parse epoch")
+	}
+	c.summary.FirstSlot = c.chainTime.FirstSlotOfEpoch(c.summary.Epoch)
+	c.summary.LastSlot = c.chainTime.FirstSlotOfEpoch(c.summary.Epoch+1) - 1
+
+	if err := c.processProposerDuties(ctx); err != nil {
+		return err
+	}
+	if err := c.processAttesterDuties(ctx); err != nil {
+		return err
+	}
+	return c.processSyncCommitteeDuties(ctx)
+}
+
+func (c *command) processProposerDuties(ctx context.Context) error {
+	duties, err := c.proposerDutiesProvider.ProposerDuties(ctx, c.summary.Epoch, nil)
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain proposer duties")
+	}
+	if duties == nil {
+		return errors.New("empty proposer duties")
+	}
+	for _, duty := range duties {
+		block, err := c.blocksProvider.SignedBeaconBlock(ctx, fmt.Sprintf("%d", duty.Slot))
+		if err != nil {
+			return errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", duty.Slot))
+		}
+		present := block != nil
+		c.summary.Proposals = append(c.summary.Proposals, &epochProposal{
+			Slot:     duty.Slot,
+			Proposer: duty.ValidatorIndex,
+			Block:    present,
+		})
+	}
+
+	return nil
+}
+
+func (c *command) 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)
+	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 {
+		if validator.Validator.ActivationEpoch <= c.summary.Epoch && validator.Validator.ExitEpoch > c.summary.Epoch {
+			activeValidators[validator.Index] = validator
+		}
+	}
+
+	return activeValidators, nil
+}
+
+func (c *command) processAttesterDuties(ctx context.Context) error {
+	activeValidators, err := c.activeValidators(ctx)
+	if err != nil {
+		return err
+	}
+	c.summary.ActiveValidators = len(activeValidators)
+
+	// Obtain number of validators that voted for blocks in the epoch.
+	// These votes can be included anywhere from the second slot of
+	// the epoch to the first slot of the next-but-one epoch.
+	firstSlot := c.chainTime.FirstSlotOfEpoch(c.summary.Epoch) + 1
+	lastSlot := c.chainTime.FirstSlotOfEpoch(c.summary.Epoch + 2)
+	if lastSlot > c.chainTime.CurrentSlot() {
+		lastSlot = c.chainTime.CurrentSlot()
+	}
+
+	var votes map[phase0.ValidatorIndex]struct{}
+	var participations map[phase0.ValidatorIndex]*nonParticipatingValidator
+	c.summary.ParticipatingValidators, c.summary.HeadCorrectValidators, c.summary.HeadTimelyValidators, c.summary.SourceTimelyValidators, c.summary.TargetCorrectValidators, c.summary.TargetTimelyValidators, votes, participations, err = c.processSlots(ctx, firstSlot, lastSlot)
+	if err != nil {
+		return err
+	}
+
+	c.summary.NonParticipatingValidators = make([]*nonParticipatingValidator, 0, len(activeValidators)-len(votes))
+	for activeValidatorIndex := range activeValidators {
+		if _, exists := votes[activeValidatorIndex]; !exists {
+			if _, exists := participations[activeValidatorIndex]; exists {
+				c.summary.NonParticipatingValidators = append(c.summary.NonParticipatingValidators, participations[activeValidatorIndex])
+			}
+		}
+	}
+	sort.Slice(c.summary.NonParticipatingValidators, func(i int, j int) bool {
+		if c.summary.NonParticipatingValidators[i].Slot != c.summary.NonParticipatingValidators[j].Slot {
+			return c.summary.NonParticipatingValidators[i].Slot < c.summary.NonParticipatingValidators[j].Slot
+		}
+		if c.summary.NonParticipatingValidators[i].Committee != c.summary.NonParticipatingValidators[j].Committee {
+			return c.summary.NonParticipatingValidators[i].Committee < c.summary.NonParticipatingValidators[j].Committee
+		}
+		return c.summary.NonParticipatingValidators[i].Validator < c.summary.NonParticipatingValidators[j].Validator
+	})
+
+	return nil
+}
+
+func (c *command) processSlots(ctx context.Context,
+	firstSlot phase0.Slot,
+	lastSlot phase0.Slot,
+) (
+	int,
+	int,
+	int,
+	int,
+	int,
+	int,
+	map[phase0.ValidatorIndex]struct{},
+	map[phase0.ValidatorIndex]*nonParticipatingValidator,
+	error,
+) {
+	votes := make(map[phase0.ValidatorIndex]struct{})
+	headCorrects := make(map[phase0.ValidatorIndex]struct{})
+	headTimelys := make(map[phase0.ValidatorIndex]struct{})
+	sourceTimelys := make(map[phase0.ValidatorIndex]struct{})
+	targetCorrects := make(map[phase0.ValidatorIndex]struct{})
+	targetTimelys := make(map[phase0.ValidatorIndex]struct{})
+	allCommittees := make(map[phase0.Slot]map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
+	participations := make(map[phase0.ValidatorIndex]*nonParticipatingValidator)
+
+	// Need a cache of beacon block headers to reduce lookup times.
+	headersCache := util.NewBeaconBlockHeaderCache(c.beaconBlockHeadersProvider)
+
+	for slot := firstSlot; slot <= lastSlot; slot++ {
+		block, err := c.blocksProvider.SignedBeaconBlock(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))
+		}
+		if block == nil {
+			// No block at this slot; that's fine.
+			continue
+		}
+		slot, err := block.Slot()
+		if err != nil {
+			return 0, 0, 0, 0, 0, 0, nil, nil, err
+		}
+		attestations, err := block.Attestations()
+		if err != nil {
+			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) {
+				// Outside of this epoch's range.
+				continue
+			}
+			slotCommittees, exists := allCommittees[attestation.Data.Slot]
+			if !exists {
+				beaconCommittees, err := c.beaconCommitteesProvider.BeaconCommittees(ctx, fmt.Sprintf("%d", attestation.Data.Slot))
+				if err != nil {
+					return 0, 0, 0, 0, 0, 0, nil, nil, errors.Wrap(err, fmt.Sprintf("failed to obtain committees for slot %d", attestation.Data.Slot))
+				}
+				for _, beaconCommittee := range beaconCommittees {
+					if _, exists := allCommittees[beaconCommittee.Slot]; !exists {
+						allCommittees[beaconCommittee.Slot] = make(map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
+					}
+					allCommittees[beaconCommittee.Slot][beaconCommittee.Index] = beaconCommittee.Validators
+					for _, index := range beaconCommittee.Validators {
+						participations[index] = &nonParticipatingValidator{
+							Validator: index,
+							Slot:      beaconCommittee.Slot,
+							Committee: beaconCommittee.Index,
+						}
+					}
+				}
+				slotCommittees = allCommittees[attestation.Data.Slot]
+			}
+			committee := slotCommittees[attestation.Data.Index]
+
+			inclusionDistance := slot - attestation.Data.Slot
+			headCorrect, err := util.AttestationHeadCorrect(ctx, headersCache, attestation)
+			if err != nil {
+				return 0, 0, 0, 0, 0, 0, nil, nil, err
+			}
+			targetCorrect, err := util.AttestationTargetCorrect(ctx, headersCache, c.chainTime, attestation)
+			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) {
+					votes[committee[int(i)]] = struct{}{}
+					if _, exists := headCorrects[committee[int(i)]]; !exists && headCorrect {
+						headCorrects[committee[int(i)]] = struct{}{}
+					}
+					if _, exists := headTimelys[committee[int(i)]]; !exists && headCorrect && inclusionDistance == 1 {
+						headTimelys[committee[int(i)]] = struct{}{}
+					}
+					if _, exists := sourceTimelys[committee[int(i)]]; !exists && inclusionDistance <= 5 {
+						sourceTimelys[committee[int(i)]] = struct{}{}
+					}
+					if _, exists := targetCorrects[committee[int(i)]]; !exists && targetCorrect {
+						targetCorrects[committee[int(i)]] = struct{}{}
+					}
+					if _, exists := targetTimelys[committee[int(i)]]; !exists && targetCorrect && inclusionDistance <= 32 {
+						targetTimelys[committee[int(i)]] = struct{}{}
+					}
+				}
+			}
+		}
+	}
+	return len(votes),
+		len(headCorrects),
+		len(headTimelys),
+		len(sourceTimelys),
+		len(targetCorrects),
+		len(targetTimelys),
+		votes,
+		participations,
+		nil
+}
+
+func (c *command) processSyncCommitteeDuties(ctx context.Context) error {
+	if c.summary.Epoch < c.chainTime.AltairInitialEpoch() {
+		// The epoch is pre-Altair.  No info but no error.
+		return nil
+	}
+
+	committee, err := c.syncCommitteesProvider.SyncCommittee(ctx, fmt.Sprintf("%d", c.summary.FirstSlot))
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain sync committee")
+	}
+	if len(committee.Validators) == 0 {
+		return errors.Wrap(err, "empty sync committee")
+	}
+
+	missed := make(map[phase0.ValidatorIndex]int)
+	for _, index := range committee.Validators {
+		missed[index] = 0
+	}
+
+	for slot := c.summary.FirstSlot; slot <= c.summary.LastSlot; slot++ {
+		block, err := c.blocksProvider.SignedBeaconBlock(ctx, fmt.Sprintf("%d", slot))
+		if err != nil {
+			return errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", slot))
+		}
+		if block == nil {
+			// If the block is missed we don't count the sync aggregate miss.
+			continue
+		}
+		var aggregate *altair.SyncAggregate
+		switch block.Version {
+		case spec.DataVersionPhase0:
+			// No sync committees in this fork.
+			return nil
+		case spec.DataVersionAltair:
+			aggregate = block.Altair.Message.Body.SyncAggregate
+		case spec.DataVersionBellatrix:
+			aggregate = block.Bellatrix.Message.Body.SyncAggregate
+		case spec.DataVersionCapella:
+			aggregate = block.Capella.Message.Body.SyncAggregate
+		default:
+			return fmt.Errorf("unhandled block version %v", block.Version)
+		}
+		for i := uint64(0); i < aggregate.SyncCommitteeBits.Len(); i++ {
+			if !aggregate.SyncCommitteeBits.BitAt(i) {
+				missed[committee.Validators[int(i)]]++
+			}
+		}
+	}
+
+	c.summary.SyncCommittee = make([]*epochSyncCommittee, 0, len(missed))
+	for index, count := range missed {
+		if count > 0 {
+			c.summary.SyncCommittee = append(c.summary.SyncCommittee, &epochSyncCommittee{
+				Index:  index,
+				Missed: count,
+			})
+		}
+	}
+
+	sort.Slice(c.summary.SyncCommittee, func(i int, j int) bool {
+		missedDiff := c.summary.SyncCommittee[i].Missed - c.summary.SyncCommittee[j].Missed
+		if missedDiff != 0 {
+			// Actually want to order by missed descending, so invert the expected condition.
+			return missedDiff > 0
+		}
+		// Then order by validator index.
+		return c.summary.SyncCommittee[i].Index < c.summary.SyncCommittee[j].Index
+	})
+
+	return nil
+}
+
+func (c *command) setup(ctx context.Context) error {
+	var err error
+
+	// Connect to the client.
+	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+		Address:       c.connection,
+		Timeout:       c.timeout,
+		AllowInsecure: c.allowInsecureConnections,
+		LogFallback:   !c.quiet,
+	})
+	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.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+	)
+	if err != nil {
+		return errors.Wrap(err, "failed to set up chaintime service")
+	}
+
+	var isProvider bool
+	c.proposerDutiesProvider, isProvider = c.eth2Client.(eth2client.ProposerDutiesProvider)
+	if !isProvider {
+		return errors.New("connection does not provide proposer duties")
+	}
+	c.blocksProvider, isProvider = c.eth2Client.(eth2client.SignedBeaconBlockProvider)
+	if !isProvider {
+		return errors.New("connection does not provide signed beacon blocks")
+	}
+	c.syncCommitteesProvider, isProvider = c.eth2Client.(eth2client.SyncCommitteesProvider)
+	if !isProvider {
+		return errors.New("connection does not provide sync committee duties")
+	}
+	c.validatorsProvider, isProvider = c.eth2Client.(eth2client.ValidatorsProvider)
+	if !isProvider {
+		return errors.New("connection does not provide validators")
+	}
+	c.beaconCommitteesProvider, isProvider = c.eth2Client.(eth2client.BeaconCommitteesProvider)
+	if !isProvider {
+		return errors.New("connection does not provide beacon committees")
+	}
+	c.beaconBlockHeadersProvider, isProvider = c.eth2Client.(eth2client.BeaconBlockHeadersProvider)
+	if !isProvider {
+		return errors.New("connection does not provide beacon block headers")
+	}
+
+	return nil
+}

cmd/epoch/summary/process_internal_test.go

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

cmd/epoch/summary/run.go

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

cmd/epochsummary.go

@@ -0,0 +1,54 @@
+// Copyright © 2022 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	epochsummary "github.com/wealdtech/ethdo/cmd/epoch/summary"
+)
+
+var epochSummaryCmd = &cobra.Command{
+	Use:   "summary",
+	Short: "Obtain summary information about an epoch",
+	Long: `Obtain summary information about an epoch.  For example:
+
+    ethdo epoch summary --epoch=12345
+
+In quiet mode this will return 0 if information for the epoch is found, otherwise 1.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := epochsummary.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	epochCmd.AddCommand(epochSummaryCmd)
+	epochFlags(epochSummaryCmd)
+}
+
+func epochSummaryBindings(cmd *cobra.Command) {
+	epochBindings(cmd)
+}