Merge pull request #174 from wealdtech/update-docker-workflow

Update docker build and push workflow

.github/workflows/docker.yml

@@ -0,0 +1,45 @@
+name: Docker
+
+# This workflow is triggered on a push to a tag that follows semantic versioning
+# e.g., v1.2.3, v2.0.0-rc1
+on:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+**'
+
+jobs:
+  # Build and push the Docker image
+  build-and-push:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      # This step extracts the version number from the tag
+      # e.g., if the tag is 'v1.2.3', this will output '1.2.3'
+      - name: Extract release version
+        id: release_version
+        run: |
+          echo "version=$(echo ${{ github.ref_name }} | sed -e 's/^v//')" >> $GITHUB_OUTPUT
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64/v8
+          push: true
+          tags: |
+            wealdtech/ethdo:${{ steps.release_version.outputs.version }}
+            wealdtech/ethdo:latest

.github/workflows/golangci-lint.yml

@@ -0,0 +1,29 @@
+name: 'golangci-lint'
+on:
+  pull_request:
+  push:
+    branches:
+      - 'master'
+  workflow_dispatch:
+
+permissions:
+  contents: 'read'
+  pull-requests: 'read'
+  checks: 'write'
+
+jobs:
+  golangci:
+    name: 'lint'
+    runs-on: 'ubuntu-24.04'
+    steps:
+      - uses: 'actions/setup-go@v5'
+        with:
+          cache: false
+          go-version: '^1.22'
+      - uses: 'actions/checkout@v4'
+      - uses: 'golangci/golangci-lint-action@v6'
+        with:
+          version: 'latest'
+          args: '--timeout=60m'
+          only-new-issues: true
+          skip-cache: true

.github/workflows/release.yml

@@ -3,113 +3,208 @@ name: Release
 on:
   push:
     tags:
-    - 'v*'
+      - 'v*'
+      - 't*'
+  workflow_dispatch:
 
 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@v5
+        with:
+          cache: false
+          go-version: '^1.22'
 
-    - 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@v4
 
-    - name: Set env
-      run: |
-       echo '::set-env name=GO111MODULE::on'
-       # Release tag comes from the github reference.
-       RELEASE_TAG=$(echo ${GITHUB_REF} | sed -e 's!.*/!!')
-       echo "::set-env name=RELEASE_TAG::${RELEASE_TAG}"
-       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 "::set-env name=RELEASE_VERSION::${RELEASE_VERSION}"
-       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
-      run: xgo -v -x -ldflags="-X github.com/wealdtech/ethdo/cmd.ReleaseVersion=${RELEASE_VERSION}" --targets="linux/amd64,linux/arm64,windows/amd64" 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: Create windows zip file
-      run: |
-       mv ethdo-windows-4.0-amd64.exe ethdo.exe
-       zip --junk-paths ethdo-${RELEASE_VERSION}-windows-exe.zip ethdo.exe
+      - 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 linux AMD64 tgz file
-      run: |
-       mv ethdo-linux-amd64 ethdo
-       tar zcf ethdo-${RELEASE_VERSION}-linux-amd64.tar.gz ethdo
+      - 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 ARM64 tgz file
-      run: |
-       mv ethdo-linux-arm64 ethdo
-       tar zcf ethdo-${RELEASE_VERSION}-linux-arm64.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@v5
+        with:
+          cache: false
+          go-version: '^1.22'
 
-    - name: Create draft 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: 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: 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
-       
-    - 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: Check out repository into the Go module directory
+        uses: actions/checkout@v4
+
+      - name: Select correct tag
+        run: git checkout ${{ github.ref_name }}
+
+      - name: Fetch repository dependencies
+        run: go get -v -t ./...
+
+      - 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 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
+
+  # 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@v5
+        with:
+          cache: false
+          go-version: '^1.22'
+
+      - name: Check out repository into the Go module directory
+        uses: actions/checkout@v4
+
+      - 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,18 @@
+name: test
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-go@v5
+        with:
+          cache: false
+          go-version: '^1.22'
+      - uses: actions/checkout@v4
+      - uses: n8maninger/action-golang-test@v2

.gitignore

@@ -15,8 +15,17 @@ coverage.html
 # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
 .glide/
 
+# Intellij
+.idea/
+
+# Makefile
+Makefile
+
 # Vim
 *.sw?
 
+# Local JSON files
+*.json
+
 # Local TODO
 TODO.md

.golangci.yml

@@ -0,0 +1,143 @@
+# This file contains all available configuration options
+# with their default values (in comments).
+#
+# This file is not a configuration example,
+# it contains the exhaustive configuration with explanations of the options.
+
+issues:
+  # Which files to exclude: they will be analyzed, but issues from them won't be reported.
+  # There is no need to include all autogenerated files,
+  # we confidently recognize autogenerated files.
+  # If it's not, please let us know.
+  # "/" will be replaced by current OS file path separator to properly work on Windows.
+  # Default: []
+  exclude-files:
+    - ".*_ssz\\.go$"
+
+# Options for analysis running.
+run:
+  # The default concurrency value is the number of available CPU.
+  # concurrency: 4
+
+  # Timeout for analysis, e.g. 30s, 5m.
+  # Default: 1m
+  timeout: 10m
+
+  # Exit code when at least one issue was found.
+  # Default: 1
+  # issues-exit-code: 2
+
+  # Include test files or not.
+  # Default: true
+  tests: false
+
+  # List of build tags, all linters use it.
+  # Default: [].
+  # build-tags:
+  #   - mytag
+
+  # Which dirs to skip: issues from them won't be reported.
+  # Can use regexp here: `generated.*`, regexp is applied on full path.
+  # Default value is empty list,
+  # but default dirs are skipped independently of this option's value (see skip-dirs-use-default).
+  # "/" will be replaced by current OS file path separator to properly work on Windows.
+  # skip-dirs:
+  #   - autogenerated_by_my_lib
+
+  # Enables skipping of directories:
+  # - vendor$, third_party$, testdata$, examples$, Godeps$, builtin$
+  # Default: true
+  # skip-dirs-use-default: false
+
+  # If set we pass it to "go list -mod={option}". From "go help modules":
+  # If invoked with -mod=readonly, the go command is disallowed from the implicit
+  # automatic updating of go.mod described above. Instead, it fails when any changes
+  # to go.mod are needed. This setting is most useful to check that go.mod does
+  # not need updates, such as in a continuous integration and testing system.
+  # If invoked with -mod=vendor, the go command assumes that the vendor
+  # directory holds the correct copies of dependencies and ignores
+  # the dependency descriptions in go.mod.
+  #
+  # Allowed values: readonly|vendor|mod
+  # By default, it isn't set.
+  modules-download-mode: readonly
+
+  # Allow multiple parallel golangci-lint instances running.
+  # If false (default) - golangci-lint acquires file lock on start.
+  allow-parallel-runners: true
+
+  # Define the Go version limit.
+  # Mainly related to generics support since go1.18.
+  # Default: use Go version from the go.mod file, fallback on the env var `GOVERSION`, fallback on 1.18
+  # go: '1.19'
+
+
+# output configuration options
+output:
+  formats:
+    - format: colored-line-number
+      path: stderr
+
+# All available settings of specific linters.
+linters-settings:
+  gosec:
+    excludes:
+      # Flags for potentially-unsafe casting of ints, but generates a lot of false positives.
+      - 'G115'
+
+  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
+    - depguard
+    - dupl
+    - err113
+    - errorlint
+    - exhaustive
+    - exhaustruct
+    - forbidigo
+    - forcetypeassert
+    - funlen
+    - gci
+    - gochecknoglobals
+    - gochecknoinits
+    - gocognit
+    - goconst
+    - goheader
+    - ireturn
+    - lll
+    - maintidx
+    - mnd
+    - musttag
+    - nestif
+    - nilnil
+    - nlreturn
+    - nolintlint
+    - perfsprint
+    - promlinter
+    - rowserrcheck
+    - sqlclosecheck
+    - tenv
+    - unparam
+    - varnamelen
+    - wastedassign
+    - wrapcheck
+    - wsl

CHANGELOG.md

@@ -0,0 +1,316 @@
+dev:
+ 
+1.39.0:
+ - support Fulu 
+
+1.38.0:
+ - update latest version of go-eth2-client to support complex Spec types
+ - adapt event handling to use new event handler structures in go-eth2-client  
+
+1.37.4:
+ - add support for eip-7044 in exit verify command
+ - provide ETH values as well as validator numbers in "epoch summary"
+
+1.37.3:
+ - add "hoodi" to the list of supported networks
+
+1.37.2:
+ - add "block trail"
+
+1.37.1:
+ - handle missing blobs for block info
+ - fix `--epoch` flag for epoch summary
+
+1.37.0:
+ - support Electra
+ - add `--compounding` flag when creating validator deposit data
+
+1.36.6:
+  - allow specification of blockid for validator info
+  - validator depositdata orders deposits from an HD wallet by path
+
+1.36.5:
+  - avoid corner case mnemonic derivation with 25th word
+
+1.36.2:
+  - avoid crash when signing and verifing signatures using keys rather than accounts
+
+1.36.1:
+  - more JSON data for epoch summary
+  - fix crash when block ifno had no blobs
+
+1.36.0:
+  - support keystore wallets
+
+1.35.6:
+  - provide more JSON data in "epoch summary"
+
+1.35.5:
+  - allow keystore to be output to the console
+
+1.35.4:
+  - provide consensus and execution client info in block info output 
+
+1.35.3:
+  - provide better error message on context deadlline exceeded
+  - update launchpad output to match latest version
+  - add deposit contract address to "chain info"
+
+1.35.2:
+  - update dependencies
+
+1.35.1:
+  - fix output for various commands that may encounter an empty slot
+
+1.35.0:
+  - support Deneb
+  - add start and end dates for eth1votes period
+
+1.34.1:
+  - fix period parsing for "synccommittee members" command
+
+1.34.0:
+  - update dependencies
+  - use Capella fork for all exits
+  - support Deneb beta 5
+
+1.33.2:
+  - fix windows build
+
+1.33.1:
+  - add "slot" to "proposer duties" command
+  - add activation epoch and time to "validator info" command where applicable
+  - add "holesky" to the list of supported networks
+  - avoid crash when requesting validators from beacon node without debug enabled
+
+1.33.0:
+  - show all slots with 'synccommittee inclusion'
+  - add "wallet batch" command
+
+1.32.0:
+  - fix incorrect error when "deposit verify" is not given a withdrawal address
+  - allow truncated mnemonics (first four characters of each word)
+  - add deneb information to "block info"
+  - add epoch parameter to "validator yield"
+  - add proposer index to "block info"
+  - "block info" honours "--quiet" flag
+  - "block info" accepts "--block-time" option
+  - increase default operation timeout from 10s to 30s
+  - "epoch summary" JSON lists number of blobs
+
+1.31.0:
+  - initial support for deneb
+  - add "--generate-keystore" option for "account derive"
+  - update "validator exit" command to be able to generate multiple exits
+  - support for 12-word and 18-word mnemonics with single-word (no whitespace) passphrases
+  - add JSON output for "validator expectation"
+
+1.30.0:
+  - add "chain spec" command
+  - add "validator withdrawal" command
+
+1.29.2:
+  - fix regression where validator index could not be used as an account specifier
+
+1.29.0:
+  - allow use of keystores with validator credentials set
+  - tidy up various command options to provide more standard usage
+  - add mainnet fallback beacon node
+
+1.28.4:
+  - allow validator exit to use a keystore as its validator parameter
+
+1.28.2:
+  - fix bix stopping validator exit creation by direct validator specification
+
+1.28.1:
+  - generate error message if "validator credentials set" process fails to generate any credentials
+  - allow import of accounts with null name field in their keystore
+  - show text of execution payload extra data if available
+
+1.28.0:
+  - support additional mnemonic word list languages
+  - increase minimum timeout for commands that fetch all validators to 2 minutes
+  - provide better error messages when offline preparation file cannot be read
+  - allow creation of all credential change operations related to a private key (thanks to @joaocenoura)
+
+1.27.1:
+  - fix issue with voluntary exits using incorrect domain (thanks to @0xTylerHolmes)
+
+1.27.0:
+  - use new build system
+  - support S3 credentials
+  - update operation of validator exit to match validator credentials set
+
+1.26.5:
+  - provide validator information in "chain status" verbose output
+
+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
+
+1.8.1
+  - fix issue where 'attester duties' and 'attester inclusion' could crash
+
+1.8.0
+  - add "chain time"
+  - add "validator keycheck"
+
+1.7.5:
+  - add "slot time"
+  - add "attester duties"
+  - add "node events"
+  - add activation epoch to "validator info"
+
+1.7.3:
+  - fix issue where base directory was ignored for wallet creation
+  - new "validator duties" command to display known duties for a given validator
+  - update go-eth2-client to display correct validator status from prysm
+
+1.7.2:
+  - new "account derive" command to derive keys directly from a mnemonic and derivation path
+  - add more output to "deposit verify" to explain operation
+
+1.7.1:
+  - fix "store not set" issue
+
+1.7.0:
+  - "validator depositdata" now defaults to mainnet, does not silently fetch fork version from chain
+  - update deposit data output to version 3, to allow for better deposit checking
+  - use go-eth2-client for beacon node communications
+  - deprecated "--basedir" in favor of "--base-dir"
+  - deprecated "--storepassphrase" in favor of "--store-passphrase"
+  - deprecated "--walletpassphrsae" in favor of "--wallet-passphrsae"
+  - renamed "--exportpassphrase" and "--importpassphrase" flags to "--passphrase"
+  - reworked internal structure of account-related commands
+  - reject weak passphrases by default
+
+1.6.1:
+  - "attester inclusion" defaults to previous epoch
+  - output array for launchpad deposit data JSON in all situations
+
+1.6.0:
+  - update BLS HKDF function to match spec 04
+  - add --launchpad option to "validator depositdata" to output data in launchpad format
+
+1.5.9:
+  - fix issue where wallet mnemonics were not normalised to NFKD
+  - "block info" supports fetching the gensis block (--slot=0)
+  - "attester inclusion" command finds the inclusion slot for a validator's attestation
+  - "account info" with verbose option now displays participants for distributed accounts
+  - fix issue where distributed account generation without a passphrase was not allowed
+
+1.5.8:
+  - allow raw deposit transactions to be supplied to "deposit verify"
+  - move functionality of "account withdrawalcredentials" to be part of "account info"
+  - add genesis validators root to "chain info"

Dockerfile

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

README.md

@@ -5,12 +5,13 @@
 
 A command-line tool for managing common tasks in Ethereum 2.
 
-**Please note that this tool and its underlying libraries have not yet undergone a security audit; use at your own risk.**
-
 ## Table of Contents
 
 - [Install](#install)
+  - [Binaries](#binaries)
   - [Docker](#docker)
+  - [Source](#source)
+- [Setting up](#setting-up)
 - [Usage](#usage)
 - [Maintainers](#maintainers)
 - [Contribute](#contribute)
@@ -18,15 +19,9 @@ A command-line tool for managing common tasks in Ethereum 2.
 
 ## Install
 
-`ethdo` is a standard Go program which can be installed with:
+### Binaries
 
-```sh
-GO111MODULE=on go get github.com/wealdtech/ethdo
-```
-
-Note that `ethdo` requires at least version 1.13 of go to operate.  The version of go can be found with `go version`.
-
-If this does not work please see the [troubleshooting](https://github.com/wealdtech/ethdo/blob/master/docs/troubleshooting.md) page.
+Binaries for the latest version of `ethdo` can be obtained from [the releases page](https://github.com/wealdtech/ethdo/releases).
 
 ### Docker
 
@@ -36,7 +31,18 @@ You can obtain the latest version of `ethdo` using docker with:
 docker pull wealdtech/ethdo
 ```
 
-Or build `ethdo` using docker:
+### Source
+`ethdo` is a standard Go program which can be installed with:
+
+```sh
+go install github.com/wealdtech/ethdo@latest
+```
+
+Note that `ethdo` requires at least version 1.20 of go to operate.  The version of go can be found with `go version`.
+
+If this does not work please see the [troubleshooting](https://github.com/wealdtech/ethdo/blob/master/docs/troubleshooting.md) page.
+
+The docker image can be build locally with:
 
 ```sh
 docker build -t ethdo .
@@ -56,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.
@@ -83,7 +118,7 @@ All ethdo comands take the following parameters:
   - `store`: the name of the storage system for wallets.  This can be one of "filesystem" (for local storage of the wallet) or "s3" (for remote storage of the wallet on [Amazon's S3](https://aws.amazon.com/s3/) storage system), and defaults to "filesystem"
   - `storepassphrase`: the passphrase for the store.  If this is empty the store is unencrypted
   - `walletpassphrase`: the passphrase for the wallet.  This is required for some wallet-centric operations such as creating new accounts
-  - `accountpassphrase`: the passphrase for the account.  This is required for some account-centric operations such as signing data
+  - `passphrase`: the passphrase for the account.  This is required for some account-centric operations such as signing data
 
 Accounts are specified in the standard "<wallet>/<account>" format, for example the account "savings" in the wallet "primary" would be referenced as "primary/savings".
 
@@ -108,6 +143,28 @@ 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": {
+      "region": "us-west-1",
+      "bucket": "my-s3-store",
+      "path": "/wallets",
+      "credentials": {
+        "id": "ABCDEF123",
+        "secret": "XXXXXXXXX"
+      }
+    }
+  }
+}
+```
+
+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.
@@ -118,6 +175,21 @@ If set, the `--debug` argument will output additional information about the oper
 
 Commands will have an exit status of 0 on success and 1 on failure.  The specific definition of success is specified in the help for each command.
 
+### Validator specifier
+
+Ethereum validators can be specified in a number of different ways.  The options are:
+
+- an `ethdo` account, in the format _wallet_/_account_.  It is possible to use the validator specified in this way to sign validator-related operations, if the passphrase is also supplied, with a passphrase (for local accounts) or authority (for remote accounts)
+- the validator's 48-byte public key.  It is not possible to use the a validator specified in this way to sign validator-related operations
+- a keystore, supplied either as direct JSON or as a path to a keystore on the local filesystem.  It is possible to use the validator specified in this way to sign validator-related operations, if the passphrase is also supplied
+- the validator's numeric index.  It is not possible to use a validator specified in this way to sign validator-related operations.  Note that this only works with on-chain operations, as the validator's index must be resolved to its public key
+
+## Passphrase strength
+
+`ethdo` will by default not allow creation or export of accounts or wallets with weak passphrases.  If a weak pasphrase is used then `ethdo` will refuse to continue.
+
+If a weak passphrase is required, `ethdo` can be supplied with the `--allow-weak-passphrases` option which will force it to accept any passphrase, even if it is considered weak.
+
 ## Rules for account passphrases
 
 Account passphrases are used in various places in `ethdo`.  Where they are used, the following rules apply:
@@ -136,12 +208,14 @@ Command information, along with sample outputs and optional arguments, is availa
 
 # HOWTO
 
-There is a [HOWTO](https://github.com/wealdtech/ethdo/blob/master/docs/howto.md) that covers details about how to carry out various common tasks.
+There is a [HOWTO](https://github.com/wealdtech/ethdo/blob/master/docs/howto.md) that covers details about how to carry out various common tasks.  There is also a specific document that provides details of how to carry out [common conversions](docs/conversions.md) from mnemonic, to account, to deposit data, for launchpad-related configurations.
 
 ## Maintainers
 
 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` releases.
+
 ## Contribute
 
 Contributions welcome. Please check out [the issues](https://github.com/wealdtech/ethdo/issues).

beacon/chaininfo.go

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

beacon/validatorinfo.go

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

@@ -0,0 +1,96 @@
+// 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"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/util"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+type dataIn struct {
+	timeout time.Duration
+	// For all accounts.
+	wallet           e2wtypes.Wallet
+	accountName      string
+	passphrase       string
+	walletPassphrase string
+	// For distributed accounts.
+	participants     uint32
+	signingThreshold uint32
+	// For pathed accounts.
+	path string
+}
+
+func input(ctx context.Context) (*dataIn, error) {
+	var err error
+	data := &dataIn{}
+
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	data.timeout = viper.GetDuration("timeout")
+
+	// Account name.
+	if viper.GetString("account") == "" {
+		return nil, errors.New("account is required")
+	}
+	_, data.accountName, err = e2wallet.WalletAndAccountNames(viper.GetString("account"))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain account name")
+	}
+	if data.accountName == "" {
+		return nil, errors.New("account name is required")
+	}
+
+	// Wallet.
+	ctx, cancel := context.WithTimeout(ctx, data.timeout)
+	defer cancel()
+	data.wallet, err = util.WalletFromInput(ctx)
+	cancel()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain wallet")
+	}
+
+	// Passphrase.
+	data.passphrase, err = util.GetOptionalPassphrase()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain passphrase")
+	}
+
+	// Wallet passphrase.
+	data.walletPassphrase = util.GetWalletPassphrase()
+
+	// Participants.
+	if viper.GetInt32("participants") == 0 {
+		return nil, errors.New("participants must be at least one")
+	}
+	data.participants = viper.GetUint32("participants")
+
+	// Signing threshold.
+	if viper.GetInt32("signing-threshold") == 0 {
+		return nil, errors.New("signing threshold must be at least one")
+	}
+	data.signingThreshold = viper.GetUint32("signing-threshold")
+
+	// Path.
+	data.path = viper.GetString("path")
+
+	return data, nil
+}

cmd/account/create/input_internal_test.go

@@ -0,0 +1,161 @@
+// 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"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	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"
+)
+
+func TestInput(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	store := scratch.New()
+	require.NoError(t, e2wallet.UseStore(store))
+	testWallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, testWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{
+				"account":    "Test wallet/Test account",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "timeout is required",
+		},
+		{
+			name: "WalletUnknown",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "Unknown/Test account",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "failed to obtain wallet: wallet not found",
+		},
+		{
+			name: "AccountMissing",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "account is required",
+		},
+		{
+			name: "AccountWalletOnly",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"passphrase": "ce%NohGhah4ye5ra",
+				"account":    "Test wallet/",
+			},
+			err: "account name is required",
+		},
+		{
+			name: "AccountMalformed",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "//",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "failed to obtain account name: invalid account format",
+		},
+		{
+			name: "MultiplePassphrases",
+			vars: map[string]interface{}{
+				"timeout":           "5s",
+				"account":           "Test wallet/Test account",
+				"passphrase":        []string{"ce%NohGhah4ye5ra", "other"},
+				"participants":      3,
+				"signing-threshold": 2,
+			},
+			err: "failed to obtain passphrase: multiple passphrases supplied",
+		},
+		{
+			name: "ParticipantsZero",
+			vars: map[string]interface{}{
+				"timeout":           "5s",
+				"account":           "Test wallet/Test account",
+				"passphrase":        "ce%NohGhah4ye5ra",
+				"participants":      0,
+				"signing-threshold": 2,
+			},
+			err: "participants must be at least one",
+		},
+		{
+			name: "SigningThresholdZero",
+			vars: map[string]interface{}{
+				"timeout":           "5s",
+				"account":           "Test wallet/Test account",
+				"passphrase":        "ce%NohGhah4ye5ra",
+				"participants":      3,
+				"signing-threshold": 0,
+			},
+			err: "signing threshold must be at least one",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"timeout":           "5s",
+				"account":           "Test wallet/Test account",
+				"passphrase":        "ce%NohGhah4ye5ra",
+				"participants":      3,
+				"signing-threshold": 2,
+			},
+			res: &dataIn{
+				timeout:          5 * time.Second,
+				accountName:      "Test account",
+				passphrase:       "ce%NohGhah4ye5ra",
+				participants:     3,
+				signingThreshold: 2,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				// Cannot compare accounts directly, so need to check each element individually.
+				require.Equal(t, test.res.timeout, res.timeout)
+				require.Equal(t, test.res.accountName, res.accountName)
+				require.Equal(t, test.res.passphrase, res.passphrase)
+				require.Equal(t, test.res.participants, res.participants)
+				require.Equal(t, test.res.signingThreshold, res.signingThreshold)
+			}
+		})
+	}
+}

cmd/account/create/output.go

@@ -0,0 +1,45 @@
+// 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"
+	"fmt"
+
+	"github.com/pkg/errors"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+type dataOut struct {
+	account e2wtypes.Account
+}
+
+func output(_ context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+	if data.account == nil {
+		return "", errors.New("no account")
+	}
+
+	if pubKeyProvider, ok := data.account.(e2wtypes.AccountCompositePublicKeyProvider); ok {
+		return fmt.Sprintf("%#x", pubKeyProvider.CompositePublicKey().Marshal()), nil
+	}
+
+	if pubKeyProvider, ok := data.account.(e2wtypes.AccountPublicKeyProvider); ok {
+		return fmt.Sprintf("%#x", pubKeyProvider.PublicKey().Marshal()), nil
+	}
+
+	return "", errors.New("no public key available")
+}

cmd/account/create/output_internal_test.go

@@ -0,0 +1,113 @@
+// 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"
+	"encoding/hex"
+	"strings"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	distributed "github.com/wealdtech/go-eth2-wallet-distributed"
+	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"
+)
+
+func hexToBytes(input string) []byte {
+	res, err := hex.DecodeString(strings.TrimPrefix(input, "0x"))
+	if err != nil {
+		panic(err)
+	}
+	return res
+}
+
+func TestOutput(t *testing.T) {
+	testWallet, err := nd.CreateWallet(context.Background(), "Test", scratch.New(), keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, testWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+	viper.Set("passphrase", "pass")
+	interop0, err := testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 0",
+		hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	distributedWallet, err := distributed.CreateWallet(context.Background(), "Test distributed", scratch.New(), keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, distributedWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+	distributed0, err := distributedWallet.(e2wtypes.WalletDistributedAccountImporter).ImportDistributedAccount(context.Background(),
+		"Distributed 0",
+		hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		2,
+		[][]byte{
+			hexToBytes("0x876dd4705157eb66dc71bc2e07fb151ea53e1a62a0bb980a7ce72d15f58944a8a3752d754f52f4a60dbfc7b18169f268"),
+			hexToBytes("0xaec922bd7a9b7b1dc21993133b586b0c3041c1e2e04b513e862227b9d7aecaf9444222f7e78282a449622ffc6278915d"),
+		},
+		map[uint64]string{
+			1: "localhost-1:12345",
+			2: "localhost-2:12345",
+			3: "localhost-3:12345",
+		},
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		res     string
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name:    "AccountNil",
+			dataOut: &dataOut{},
+			err:     "no account",
+		},
+		{
+			name: "Account",
+			dataOut: &dataOut{
+				account: interop0,
+			},
+			res: "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
+		},
+		{
+			name: "DistributedAccount",
+			dataOut: &dataOut{
+				account: distributed0,
+			},
+			res: "0x876dd4705157eb66dc71bc2e07fb151ea53e1a62a0bb980a7ce72d15f58944a8a3752d754f52f4a60dbfc7b18169f268",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(context.Background(), test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}

cmd/account/create/process.go

@@ -0,0 +1,147 @@
+// 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"
+	"regexp"
+
+	"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) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if data.passphrase != "" && !util.AcceptablePassphrase(data.passphrase) {
+		return nil, errors.New("supplied passphrase is weak; use a stronger one or run with the --allow-weak-passphrases flag")
+	}
+	locker, isLocker := data.wallet.(e2wtypes.WalletLocker)
+	if isLocker {
+		if err := locker.Unlock(ctx, []byte(data.walletPassphrase)); err != nil {
+			return nil, errors.Wrap(err, "failed to unlock wallet")
+		}
+		defer func() {
+			if err := locker.Lock(ctx); err != nil {
+				util.Log.Trace().Err(err).Msg("Failed to lock wallet")
+			}
+		}()
+	}
+	if data.participants == 0 {
+		return nil, errors.New("participants is required")
+	}
+
+	// Create style of account based on input.
+	switch {
+	case data.participants > 1:
+		return processDistributed(ctx, data)
+	case data.path != "":
+		return processPathed(ctx, data)
+	default:
+		return processStandard(ctx, data)
+	}
+}
+
+func processStandard(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if data.passphrase == "" {
+		return nil, errors.New("passphrase is required")
+	}
+
+	results := &dataOut{}
+
+	creator, isCreator := data.wallet.(e2wtypes.WalletAccountCreator)
+	if !isCreator {
+		return nil, errors.New("wallet does not support account creation")
+	}
+	ctx, cancel := context.WithTimeout(ctx, data.timeout)
+	defer cancel()
+	account, err := creator.CreateAccount(ctx, data.accountName, []byte(data.passphrase))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to create account")
+	}
+	results.account = account
+	return results, nil
+}
+
+func processPathed(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if data.passphrase == "" {
+		return nil, errors.New("passphrase is required")
+	}
+	match, err := regexp.MatchString("^m/[0-9]+/[0-9]+(/[0-9+])+", data.path)
+	if err != nil {
+		return nil, errors.Wrap(err, "unable to match path to regular expression")
+	}
+	if !match {
+		return nil, errors.New("path does not match expected format m/…")
+	}
+
+	results := &dataOut{}
+
+	creator, isCreator := data.wallet.(e2wtypes.WalletPathedAccountCreator)
+	if !isCreator {
+		return nil, errors.New("wallet does not support account creation with an explicit path")
+	}
+
+	ctx, cancel := context.WithTimeout(ctx, data.timeout)
+	defer cancel()
+	account, err := creator.CreatePathedAccount(ctx, data.path, data.accountName, []byte(data.passphrase))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to create account")
+	}
+	results.account = account
+	return results, nil
+}
+
+func processDistributed(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if data.signingThreshold == 0 {
+		return nil, errors.New("signing threshold required")
+	}
+	if data.signingThreshold <= data.participants/2 {
+		return nil, errors.New("signing threshold must be more than half the number of participants")
+	}
+	if data.signingThreshold > data.participants {
+		return nil, errors.New("signing threshold cannot be higher than the number of participants")
+	}
+
+	results := &dataOut{}
+
+	creator, isCreator := data.wallet.(e2wtypes.WalletDistributedAccountCreator)
+	if !isCreator {
+		return nil, errors.New("wallet does not support distributed account creation")
+	}
+
+	ctx, cancel := context.WithTimeout(ctx, data.timeout)
+	defer cancel()
+	account, err := creator.CreateDistributedAccount(ctx,
+		data.accountName,
+		data.participants,
+		data.signingThreshold,
+		[]byte(data.passphrase))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to create account")
+	}
+	results.account = account
+	return results, nil
+}

cmd/account/create/run.go

@@ -0,0 +1,55 @@
+// Copyright © 2019 - 2024 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     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"
+	"errors"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the account create data command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+	dataIn, err := input(ctx)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to set up command"), err)
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	dataOut, err := process(ctx, dataIn)
+	if err != nil {
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
+	}
+
+	if !viper.GetBool("verbose") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to obtain output"), err)
+	}
+
+	return results, nil
+}

cmd/account/derive/input.go

@@ -0,0 +1,66 @@
+// Copyright © 2020, 2023 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     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 accountderive
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+)
+
+type dataIn struct {
+	quiet bool
+	json  bool
+	// Derivation information.
+	mnemonic string
+	path     string
+	// Output options.
+	showPrivateKey            bool
+	showWithdrawalCredentials bool
+	generateKeystore          bool
+}
+
+func input(_ context.Context) (*dataIn, error) {
+	data := &dataIn{}
+
+	// Quiet.
+	data.quiet = viper.GetBool("quiet")
+
+	// JSON.
+	data.json = viper.GetBool("json")
+
+	// Mnemonic.
+	if viper.GetString("mnemonic") == "" {
+		return nil, errors.New("mnemonic is required")
+	}
+	data.mnemonic = viper.GetString("mnemonic")
+
+	// Path.
+	if viper.GetString("path") == "" {
+		return nil, errors.New("path is required")
+	}
+	data.path = viper.GetString("path")
+
+	// Show private key.
+	data.showPrivateKey = viper.GetBool("show-private-key")
+
+	// Show withdrawal credentials.
+	data.showWithdrawalCredentials = viper.GetBool("show-withdrawal-credentials")
+
+	// Generate keystore.
+	data.generateKeystore = viper.GetBool("generate-keystore")
+
+	return data, nil
+}

cmd/account/derive/input_internal_test.go

@@ -0,0 +1,78 @@
+// Copyright © 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 accountderive
+
+import (
+	"context"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+)
+
+func TestInput(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "MnemonicMissing",
+			vars: map[string]interface{}{
+				"path": "m/12381/3600/0/0",
+			},
+			err: "mnemonic is required",
+		},
+		{
+			name: "PathMissing",
+			vars: map[string]interface{}{
+				"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 is required",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"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":     "m/12381/3600/0/0",
+			},
+			res: &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",
+				path:     "m/12381/3600/0/0",
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				// Cannot compare accounts directly, so need to check each element individually.
+				require.Equal(t, test.res.mnemonic, res.mnemonic)
+				require.Equal(t, test.res.path, res.path)
+			}
+		})
+	}
+}

cmd/account/derive/output.go

@@ -0,0 +1,108 @@
+// Copyright © 2020, 2023 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     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 accountderive
+
+import (
+	"context"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/util"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	ethutil "github.com/wealdtech/go-eth2-util"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+)
+
+type dataOut struct {
+	json                      bool
+	showPrivateKey            bool
+	showWithdrawalCredentials bool
+	generateKeystore          bool
+	key                       *e2types.BLSPrivateKey
+	path                      string
+}
+
+func output(ctx context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+	if data.key == nil {
+		return "", errors.New("no key")
+	}
+
+	if data.generateKeystore {
+		return outputKeystore(ctx, data)
+	}
+
+	builder := strings.Builder{}
+
+	if data.showPrivateKey {
+		builder.WriteString(fmt.Sprintf("Private key: %#x\n", data.key.Marshal()))
+	}
+	if data.showWithdrawalCredentials {
+		withdrawalCredentials := ethutil.SHA256(data.key.PublicKey().Marshal())
+		withdrawalCredentials[0] = byte(0) // BLS_WITHDRAWAL_PREFIX
+		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
+}
+
+func outputKeystore(_ context.Context, data *dataOut) (string, error) {
+	passphrase, err := util.GetPassphrase()
+	if err != nil {
+		return "", errors.New("no passphrase supplied")
+	}
+
+	encryptor := keystorev4.New()
+	crypto, err := encryptor.Encrypt(data.key.Marshal(), passphrase)
+	if err != nil {
+		return "", errors.New("failed to encrypt private key")
+	}
+
+	uuid, err := uuid.NewRandom()
+	if err != nil {
+		return "", errors.New("failed to generate UUID")
+	}
+	ks := make(map[string]interface{})
+	ks["uuid"] = uuid.String()
+	ks["pubkey"] = hex.EncodeToString(data.key.PublicKey().Marshal())
+	ks["version"] = 4
+	ks["path"] = data.path
+	ks["crypto"] = crypto
+	out, err := json.Marshal(ks)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to marshal keystore JSON")
+	}
+
+	if data.json {
+		fmt.Fprintf(os.Stdout, "%s\n", string(out))
+	} else {
+		keystoreFilename := fmt.Sprintf("keystore-%s-%d.json", strings.ReplaceAll(data.path, "/", "_"), time.Now().Unix())
+
+		if err := os.WriteFile(keystoreFilename, out, 0o600); err != nil {
+			return "", errors.Wrap(err, fmt.Sprintf("failed to write %s", keystoreFilename))
+		}
+	}
+	return "", nil
+}

cmd/account/derive/output_internal_test.go

@@ -0,0 +1,101 @@
+// Copyright © 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 accountderive
+
+import (
+	"context"
+	"encoding/hex"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+)
+
+func blsPrivateKey(input string) *e2types.BLSPrivateKey {
+	data, err := hex.DecodeString(strings.TrimPrefix(input, "0x"))
+	if err != nil {
+		panic(err)
+	}
+	key, err := e2types.BLSPrivateKeyFromBytes(data)
+	if err != nil {
+		panic(err)
+	}
+	return key
+}
+
+func TestOutput(t *testing.T) {
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		needs   []string
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name:    "KeyMissing",
+			dataOut: &dataOut{},
+			err:     "no key",
+		},
+		{
+			name: "Good",
+			dataOut: &dataOut{
+				key: blsPrivateKey("0x068dce0c90cb428ab37a74af0191eac49648035f1aaef077734b91e05985ec55"),
+			},
+			needs: []string{"Public key"},
+		},
+		{
+			name: "PrivatKey",
+			dataOut: &dataOut{
+				key:            blsPrivateKey("0x068dce0c90cb428ab37a74af0191eac49648035f1aaef077734b91e05985ec55"),
+				showPrivateKey: true,
+			},
+			needs: []string{"Private key"},
+		},
+		{
+			name: "WithdrawalCredentials",
+			dataOut: &dataOut{
+				key:                       blsPrivateKey("0x068dce0c90cb428ab37a74af0191eac49648035f1aaef077734b91e05985ec55"),
+				showWithdrawalCredentials: true,
+			},
+			needs: []string{"Withdrawal credentials"},
+		},
+		{
+			name: "All",
+			dataOut: &dataOut{
+				key:                       blsPrivateKey("0x068dce0c90cb428ab37a74af0191eac49648035f1aaef077734b91e05985ec55"),
+				showPrivateKey:            true,
+				showWithdrawalCredentials: true,
+			},
+			needs: []string{"Private key", "Withdrawal credentials"},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(context.Background(), test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				for _, need := range test.needs {
+					require.Contains(t, res, need)
+				}
+			}
+		})
+	}
+}

cmd/account/derive/process.go

@@ -0,0 +1,50 @@
+// Copyright © 2020, 2023 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     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 accountderive
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/util"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+
+	account, err := util.ParseAccount(ctx, data.mnemonic, []string{data.path}, true)
+	if err != nil {
+		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{
+		json:                      data.json,
+		showPrivateKey:            data.showPrivateKey,
+		showWithdrawalCredentials: data.showWithdrawalCredentials,
+		generateKeystore:          data.generateKeystore,
+		key:                       key.(*e2types.BLSPrivateKey),
+		path:                      data.path,
+	}
+
+	return results, nil
+}

cmd/account/derive/process_internal_test.go

@@ -0,0 +1,97 @@
+// Copyright © 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 accountderive
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+)
+
+func TestProcess(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	tests := []struct {
+		name    string
+		dataIn  *dataIn
+		privKey []byte
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "MnemonicMissing",
+			dataIn: &dataIn{
+				path: "m/12381/3600/0/0",
+			},
+			err: "failed to derive account: no account specified",
+		},
+		{
+			name: "MnemonicInvalid",
+			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 art",
+				path:     "m/12381/3600/0/0",
+			},
+			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: "failed to derive account: path does not match expected format m/…",
+		},
+		{
+			name: "PathInvalid",
+			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",
+				path:     "n/12381/3600/0/0",
+			},
+			err: "failed to derive account: path does not match expected format m/…",
+		},
+		{
+			name: "Good",
+			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",
+				path:     "m/12381/3600/0/0",
+			},
+			privKey: testutil.HexToBytes("0x068dce0c90cb428ab37a74af0191eac49648035f1aaef077734b91e05985ec55"),
+		},
+		{
+			name: "Extended",
+			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 extended",
+				path:     "m/12381/3600/0/0",
+			},
+			privKey: testutil.HexToBytes("0x58c8b280ae035de0452797b52fb62555f27f78541ea2f04b23e7bb0fcd0fc2d6"),
+		},
+	}
+
+	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.privKey, res.key.Marshal())
+			}
+		})
+	}
+}

cmd/account/derive/run.go

@@ -0,0 +1,55 @@
+// Copyright © 2020, 2024 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     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 accountderive
+
+import (
+	"context"
+	"errors"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+// Run runs the account create data command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+	dataIn, err := input(ctx)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to obtain input"), err)
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	dataOut, err := process(ctx, dataIn)
+	if err != nil {
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
+	}
+
+	if dataIn.quiet {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to obtain output"), err)
+	}
+
+	return strings.TrimSuffix(results, "\n"), nil
+}

cmd/account/import/input.go

@@ -0,0 +1,131 @@
+// 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
+//
+//     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 accountimport
+
+import (
+	"context"
+	"encoding/hex"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/util"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+type dataIn struct {
+	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) {
+	var err error
+	data := &dataIn{}
+
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	data.timeout = viper.GetDuration("timeout")
+
+	// Account name.
+	if viper.GetString("account") == "" {
+		return nil, errors.New("account is required")
+	}
+	_, data.accountName, err = e2wallet.WalletAndAccountNames(viper.GetString("account"))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain account name")
+	}
+	if data.accountName == "" {
+		return nil, errors.New("account name is required")
+	}
+
+	// Wallet.
+	ctx, cancel := context.WithTimeout(ctx, data.timeout)
+	defer cancel()
+	data.wallet, err = util.WalletFromInput(ctx)
+	cancel()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain wallet")
+	}
+
+	// Passphrase.
+	data.passphrase, err = util.GetOptionalPassphrase()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain passphrase")
+	}
+
+	// Wallet passphrase.
+	data.walletPassphrase = util.GetWalletPassphrase()
+
+	if viper.GetString("key") == "" && viper.GetString("keystore") == "" {
+		return nil, errors.New("key or keystore is required")
+	}
+	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

@@ -0,0 +1,172 @@
+// 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 accountimport
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	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"
+)
+
+func TestInput(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	store := scratch.New()
+	require.NoError(t, e2wallet.UseStore(store))
+	testWallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, testWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{
+				"account":    "Test wallet/Test account",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "timeout is required",
+		},
+		{
+			name: "WalletUnknown",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "Unknown/Test account",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "failed to obtain wallet: wallet not found",
+		},
+		{
+			name: "AccountMissing",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "account is required",
+		},
+		{
+			name: "AccountWalletOnly",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"passphrase": "ce%NohGhah4ye5ra",
+				"account":    "Test wallet/",
+			},
+			err: "account name is required",
+		},
+		{
+			name: "AccountMalformed",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "//",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "failed to obtain account name: invalid account format",
+		},
+		{
+			name: "MultiplePassphrases",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "Test wallet/Test account",
+				"passphrase": []string{"ce%NohGhah4ye5ra", "other"},
+			},
+			err: "failed to obtain passphrase: multiple passphrases supplied",
+		},
+		{
+			name: "KeyMissing",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "Test wallet/Test account",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "key or keystore is required",
+		},
+		{
+			name: "KeyMalformed",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "Test wallet/Test account",
+				"passphrase": "ce%NohGhah4ye5ra",
+				"key":        "invalid",
+			},
+			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{}{
+				"timeout":    "5s",
+				"account":    "Test wallet/Test account",
+				"passphrase": "ce%NohGhah4ye5ra",
+				"key":        "0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866",
+			},
+			res: &dataIn{
+				timeout:     5 * time.Second,
+				accountName: "Test account",
+				passphrase:  "ce%NohGhah4ye5ra",
+				key:         hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				// Cannot compare accounts directly, so need to check each element individually.
+				require.Equal(t, test.res.timeout, res.timeout)
+				require.Equal(t, test.res.accountName, res.accountName)
+				require.Equal(t, test.res.passphrase, res.passphrase)
+			}
+		})
+	}
+}

cmd/account/import/output.go

@@ -0,0 +1,45 @@
+// 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 accountimport
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+type dataOut struct {
+	account e2wtypes.Account
+}
+
+func output(_ context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+	if data.account == nil {
+		return "", errors.New("no account")
+	}
+
+	if pubKeyProvider, ok := data.account.(e2wtypes.AccountCompositePublicKeyProvider); ok {
+		return fmt.Sprintf("%#x", pubKeyProvider.CompositePublicKey().Marshal()), nil
+	}
+
+	if pubKeyProvider, ok := data.account.(e2wtypes.AccountPublicKeyProvider); ok {
+		return fmt.Sprintf("%#x", pubKeyProvider.PublicKey().Marshal()), nil
+	}
+
+	return "", errors.New("no public key available")
+}

cmd/account/import/output_internal_test.go

@@ -0,0 +1,113 @@
+// 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 accountimport
+
+import (
+	"context"
+	"encoding/hex"
+	"strings"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	distributed "github.com/wealdtech/go-eth2-wallet-distributed"
+	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"
+)
+
+func hexToBytes(input string) []byte {
+	res, err := hex.DecodeString(strings.TrimPrefix(input, "0x"))
+	if err != nil {
+		panic(err)
+	}
+	return res
+}
+
+func TestOutput(t *testing.T) {
+	testWallet, err := nd.CreateWallet(context.Background(), "Test", scratch.New(), keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, testWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+	viper.Set("passphrase", "pass")
+	interop0, err := testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 0",
+		hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	distributedWallet, err := distributed.CreateWallet(context.Background(), "Test distributed", scratch.New(), keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, distributedWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+	distributed0, err := distributedWallet.(e2wtypes.WalletDistributedAccountImporter).ImportDistributedAccount(context.Background(),
+		"Distributed 0",
+		hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		2,
+		[][]byte{
+			hexToBytes("0x876dd4705157eb66dc71bc2e07fb151ea53e1a62a0bb980a7ce72d15f58944a8a3752d754f52f4a60dbfc7b18169f268"),
+			hexToBytes("0xaec922bd7a9b7b1dc21993133b586b0c3041c1e2e04b513e862227b9d7aecaf9444222f7e78282a449622ffc6278915d"),
+		},
+		map[uint64]string{
+			1: "localhost-1:12345",
+			2: "localhost-2:12345",
+			3: "localhost-3:12345",
+		},
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		res     string
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name:    "AccountNil",
+			dataOut: &dataOut{},
+			err:     "no account",
+		},
+		{
+			name: "Account",
+			dataOut: &dataOut{
+				account: interop0,
+			},
+			res: "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
+		},
+		{
+			name: "DistributedAccount",
+			dataOut: &dataOut{
+				account: distributed0,
+			},
+			res: "0x876dd4705157eb66dc71bc2e07fb151ea53e1a62a0bb980a7ce72d15f58944a8a3752d754f52f4a60dbfc7b18169f268",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(context.Background(), test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}

cmd/account/import/process.go

@@ -0,0 +1,121 @@
+// 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
+//
+//     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 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"
+)
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if data.passphrase == "" {
+		return nil, errors.New("passphrase is required")
+	}
+	if !util.AcceptablePassphrase(data.passphrase) {
+		return nil, errors.New("supplied passphrase is weak; use a stronger one or run with the --allow-weak-passphrases flag")
+	}
+	locker, isLocker := data.wallet.(e2wtypes.WalletLocker)
+	if isLocker {
+		if err := locker.Unlock(ctx, []byte(data.walletPassphrase)); err != nil {
+			return nil, errors.Wrap(err, "failed to unlock wallet")
+		}
+		defer func() {
+			if err := locker.Lock(ctx); err != nil {
+				util.Log.Trace().Err(err).Msg("Failed to lock wallet")
+			}
+		}()
+	}
+
+	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{}
+
+	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 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/import/process_internal_test.go

@@ -0,0 +1,95 @@
+// 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 accountimport
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	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"
+)
+
+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)
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "PassphraseMissing",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testNDWallet,
+				accountName:      "Good",
+				passphrase:       "",
+				walletPassphrase: "pass",
+				key:              hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+			},
+			err: "passphrase is required",
+		},
+		{
+			name: "PassphraseWeak",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testNDWallet,
+				accountName:      "Good",
+				passphrase:       "poor",
+				walletPassphrase: "pass",
+				key:              hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+			},
+			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:           testNDWallet,
+				accountName:      "Good",
+				passphrase:       "ce%NohGhah4ye5ra",
+				walletPassphrase: "pass",
+				key:              hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+			},
+		},
+	}
+
+	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())
+			}
+		})
+	}
+}

cmd/account/import/run.go

@@ -0,0 +1,55 @@
+// Copyright © 2019 - 2024 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     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 accountimport
+
+import (
+	"context"
+	"errors"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the account import data command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+	dataIn, err := input(ctx)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to obtain input"), err)
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	dataOut, err := process(ctx, dataIn)
+	if err != nil {
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
+	}
+
+	if !viper.GetBool("verbose") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to obtain output"), err)
+	}
+
+	return results, nil
+}

cmd/account/key/input.go

@@ -0,0 +1,51 @@
+// 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 accountkey
+
+import (
+	"context"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/util"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+type dataIn struct {
+	timeout     time.Duration
+	account     e2wtypes.Account
+	passphrases []string
+}
+
+func input(ctx context.Context) (*dataIn, error) {
+	var err error
+	data := &dataIn{}
+
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	data.timeout = viper.GetDuration("timeout")
+
+	// Account.
+	_, data.account, err = util.WalletAndAccountFromInput(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain acount")
+	}
+
+	// Passphrases.
+	data.passphrases = util.GetPassphrases()
+
+	return data, nil
+}

cmd/account/key/input_internal_test.go

@@ -0,0 +1,128 @@
+// 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 accountkey
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	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"
+)
+
+func TestInput(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	store := scratch.New()
+	require.NoError(t, e2wallet.UseStore(store))
+	testWallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, testWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+	viper.Set("passphrase", "pass")
+	_, err = testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 0",
+		hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{
+				"account":    "Test wallet/Interop 0",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "timeout is required",
+		},
+		{
+			name: "WalletUnknown",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "Unknown/Interop 0",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "failed to obtain acount: failed to open wallet for account: wallet not found",
+		},
+		{
+			name: "AccountMissing",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "failed to obtain acount: failed to open wallet for account: invalid account format",
+		},
+		{
+			name: "AccountWalletOnly",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"passphrase": "ce%NohGhah4ye5ra",
+				"account":    "Test wallet/",
+			},
+			err: "failed to obtain acount: no account name",
+		},
+		{
+			name: "AccountMalformed",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "//",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "failed to obtain acount: failed to open wallet for account: invalid account format",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "Test wallet/Interop 0",
+				"passphrase": []string{"ce%NohGhah4ye5ra", "pass"},
+				"key":        "0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866",
+			},
+			res: &dataIn{
+				timeout:     5 * time.Second,
+				passphrases: []string{"ce%NohGhah4ye5ra", "pass"},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				// Cannot compare accounts directly, so need to check each element individually.
+				require.Equal(t, test.res.timeout, res.timeout)
+				require.Equal(t, test.res.passphrases, res.passphrases)
+			}
+		})
+	}
+}

cmd/account/key/output.go

@@ -0,0 +1,36 @@
+// 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 accountkey
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+)
+
+type dataOut struct {
+	key []byte
+}
+
+func output(_ context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+	if len(data.key) == 0 {
+		return "", errors.New("no account")
+	}
+
+	return fmt.Sprintf("%#x", data.key), nil
+}

cmd/account/key/output_internal_test.go

@@ -0,0 +1,69 @@
+// 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 accountkey
+
+import (
+	"context"
+	"encoding/hex"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func hexToBytes(input string) []byte {
+	res, err := hex.DecodeString(strings.TrimPrefix(input, "0x"))
+	if err != nil {
+		panic(err)
+	}
+	return res
+}
+
+func TestOutput(t *testing.T) {
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		res     string
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name:    "AccountNil",
+			dataOut: &dataOut{},
+			err:     "no account",
+		},
+		{
+			name: "Good",
+			dataOut: &dataOut{
+				key: hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+			},
+			res: "0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(context.Background(), test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}

cmd/account/key/process.go

@@ -0,0 +1,70 @@
+// 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 accountkey
+
+import (
+	"context"
+
+	"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) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if len(data.passphrases) == 0 {
+		return nil, errors.New("passphrase is required")
+	}
+
+	results := &dataOut{}
+
+	privateKeyProvider, isPrivateKeyProvider := data.account.(e2wtypes.AccountPrivateKeyProvider)
+	if !isPrivateKeyProvider {
+		return nil, errors.New("account does not provide its private key")
+	}
+
+	if locker, isLocker := data.account.(e2wtypes.AccountLocker); isLocker {
+		unlocked, err := locker.IsUnlocked(ctx)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to find out if account is locked")
+		}
+		if !unlocked {
+			for _, passphrase := range data.passphrases {
+				err = locker.Unlock(ctx, []byte(passphrase))
+				if err == nil {
+					unlocked = true
+					break
+				}
+			}
+			if !unlocked {
+				return nil, errors.New("failed to unlock account")
+			}
+			// Because we unlocked the accout we should re-lock it when we're done.
+			defer func() {
+				if err := locker.Lock(ctx); err != nil {
+					util.Log.Trace().Err(err).Msg("Failed to lock account")
+				}
+			}()
+		}
+	}
+	key, err := privateKeyProvider.PrivateKey(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain private key")
+	}
+	results.key = key.Marshal()
+
+	return results, nil
+}

cmd/account/key/process_internal_test.go

@@ -0,0 +1,87 @@
+// 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 accountkey
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	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"
+)
+
+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)
+	require.NoError(t, testNDWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+	viper.Set("passphrase", "pass")
+	interop0, err := testNDWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 0",
+		hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "PassphrasesMissing",
+			dataIn: &dataIn{
+				timeout: 5 * time.Second,
+				account: interop0,
+			},
+			err: "passphrase is required",
+		},
+		{
+			name: "Good",
+			dataIn: &dataIn{
+				timeout:     5 * time.Second,
+				account:     interop0,
+				passphrases: []string{"ce%NohGhah4ye5ra", "pass"},
+			},
+		},
+	}
+
+	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.NotNil(t, res)
+				require.NotNil(t, res.key)
+			}
+		})
+	}
+}

cmd/account/key/run.go

@@ -0,0 +1,55 @@
+// Copyright © 2019 - 2024 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     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 accountkey
+
+import (
+	"context"
+	"errors"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the account import data command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+	dataIn, err := input(ctx)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to set up command"), err)
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	dataOut, err := process(ctx, dataIn)
+	if err != nil {
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to obtain output"), err)
+	}
+
+	return results, nil
+}

cmd/accountcreate.go

@@ -14,14 +14,11 @@
 package cmd
 
 import (
-	"context"
 	"fmt"
-	"os"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
-	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+	accountcreate "github.com/wealdtech/ethdo/cmd/account/create"
 )
 
 var accountCreateCmd = &cobra.Command{
@@ -32,62 +29,33 @@ var accountCreateCmd = &cobra.Command{
     ethdo account create --account="primary/operations" --passphrase="my secret"
 
 In quiet mode this will return 0 if the account is created successfully, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		assert(viper.GetString("account") != "", "--account is required")
-
-		wallet, err := openWallet()
-		errCheck(err, "Failed to access wallet")
-		outputIf(debug, fmt.Sprintf("Opened wallet %q of type %s", wallet.Name(), wallet.Type()))
-		if wallet.Type() == "hierarchical deterministic" {
-			assert(getWalletPassphrase() != "", "walletpassphrase is required to create new accounts with hierarchical deterministic wallets")
+	RunE: func(cmd *cobra.Command, _ []string) error {
+		res, err := accountcreate.Run(cmd)
+		if err != nil {
+			return err
 		}
-		locker, isLocker := wallet.(e2wtypes.WalletLocker)
-		if isLocker {
-			ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-			defer cancel()
-			errCheck(locker.Unlock(ctx, []byte(getWalletPassphrase())), "Failed to unlock wallet")
+		if viper.GetBool("quiet") {
+			return nil
 		}
-
-		_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
-		errCheck(err, "Failed to obtain account name")
-
-		var account e2wtypes.Account
-		if viper.GetUint("participants") > 0 {
-			// Want a distributed account.
-			distributedCreator, isDistributedCreator := wallet.(e2wtypes.WalletDistributedAccountCreator)
-			assert(isDistributedCreator, "Wallet does not support distributed account creation")
-			outputIf(debug, fmt.Sprintf("Distributed account has %d/%d threshold", viper.GetUint32("signing-threshold"), viper.GetUint32("participants")))
-			ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-			defer cancel()
-			account, err = distributedCreator.CreateDistributedAccount(ctx, accountName, viper.GetUint32("participants"), viper.GetUint32("signing-threshold"), []byte(getPassphrase()))
-		} else {
-			creator, isCreator := wallet.(e2wtypes.WalletAccountCreator)
-			assert(isCreator, "Wallet does not support account creation")
-			ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-			defer cancel()
-			account, err = creator.CreateAccount(ctx, accountName, []byte(getPassphrase()))
+		if res != "" {
+			fmt.Println(res)
 		}
-		errCheck(err, "Failed to create account")
-
-		if pubKeyProvider, ok := account.(e2wtypes.AccountCompositePublicKeyProvider); ok {
-			outputIf(verbose, fmt.Sprintf("%#x", pubKeyProvider.CompositePublicKey().Marshal()))
-		} else if pubKeyProvider, ok := account.(e2wtypes.AccountPublicKeyProvider); ok {
-			outputIf(verbose, fmt.Sprintf("%#x", pubKeyProvider.PublicKey().Marshal()))
-		}
-
-		os.Exit(_exitSuccess)
+		return nil
 	},
 }
 
 func init() {
 	accountCmd.AddCommand(accountCreateCmd)
 	accountFlags(accountCreateCmd)
-	accountCreateCmd.Flags().Uint32("participants", 0, "Number of participants (for distributed accounts)")
-	if err := viper.BindPFlag("participants", accountCreateCmd.Flags().Lookup("participants")); err != nil {
+	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)")
+}
+
+func accountCreateBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("participants", cmd.Flags().Lookup("participants")); err != nil {
 		panic(err)
 	}
-	accountCreateCmd.Flags().Uint32("signing-threshold", 0, "Signing threshold (for distributed accounts)")
-	if err := viper.BindPFlag("signing-threshold", accountCreateCmd.Flags().Lookup("signing-threshold")); err != nil {
+	if err := viper.BindPFlag("signing-threshold", cmd.Flags().Lookup("signing-threshold")); err != nil {
 		panic(err)
 	}
 }

cmd/accountderive.go

@@ -0,0 +1,69 @@
+// 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 cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	accountderive "github.com/wealdtech/ethdo/cmd/account/derive"
+)
+
+var accountDeriveCmd = &cobra.Command{
+	Use:   "derive",
+	Short: "Derive an account",
+	Long: `Derive an account from a mnemonic and path.  For example:
+
+    ethdo account derive --mnemonic="..." --path="m/12381/3600/0/0"
+
+In quiet mode this will return 0 if the inputs can derive an account account, otherwise 1.`,
+	RunE: func(cmd *cobra.Command, _ []string) error {
+		res, err := accountderive.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	accountCmd.AddCommand(accountDeriveCmd)
+	accountFlags(accountDeriveCmd)
+	accountDeriveCmd.Flags().Bool("show-private-key", false, "show private key for derived account")
+	accountDeriveCmd.Flags().Bool("show-withdrawal-credentials", false, "show withdrawal credentials for derived account")
+	accountDeriveCmd.Flags().Bool("generate-keystore", false, "generate a keystore for the derived account")
+	accountDeriveCmd.Flags().Bool("json", false, "display the JSON keystore for the derived account on stdout")
+}
+
+func accountDeriveBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("show-private-key", cmd.Flags().Lookup("show-private-key")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("show-withdrawal-credentials", cmd.Flags().Lookup("show-withdrawal-credentials")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("generate-keystore", cmd.Flags().Lookup("generate-keystore")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("json", cmd.Flags().Lookup("json")); err != nil {
+		panic(err)
+	}
+}

cmd/accountimport.go

@@ -14,19 +14,13 @@
 package cmd
 
 import (
-	"context"
 	"fmt"
-	"os"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	"github.com/wealdtech/go-bytesutil"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
-	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+	accountimport "github.com/wealdtech/ethdo/cmd/account/import"
 )
 
-var accountImportKey string
-
 var accountImportCmd = &cobra.Command{
 	Use:   "import",
 	Short: "Import an account",
@@ -35,49 +29,37 @@ var accountImportCmd = &cobra.Command{
     ethdo account import --account="primary/testing" --key="0x..." --passphrase="my secret"
 
 In quiet mode this will return 0 if the account is imported successfully, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		assert(!remote, "account import not available with remote wallets")
-		assert(viper.GetString("account") != "", "--account is required")
-		passphrase := getPassphrase()
-		assert(accountImportKey != "", "--key is required")
-
-		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-		defer cancel()
-
-		key, err := bytesutil.FromHexString(accountImportKey)
-		errCheck(err, "Invalid key")
-
-		w, err := walletFromPath(viper.GetString("account"))
-		errCheck(err, "Failed to access wallet")
-
-		_, ok := w.(e2wtypes.WalletAccountImporter)
-		assert(ok, fmt.Sprintf("wallets of type %q do not allow importing accounts", w.Type()))
-
-		_, err = accountFromPath(ctx, viper.GetString("account"))
-		assert(err != nil, "Account already exists")
-
-		locker, isLocker := w.(e2wtypes.WalletLocker)
-		if isLocker {
-			errCheck(locker.Unlock(ctx, []byte(getWalletPassphrase())), "Failed to unlock wallet")
+	RunE: func(cmd *cobra.Command, _ []string) error {
+		res, err := accountimport.Run(cmd)
+		if err != nil {
+			return err
 		}
-
-		_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
-		errCheck(err, "Failed to obtain account name")
-
-		account, err := w.(e2wtypes.WalletAccountImporter).ImportAccount(ctx, accountName, key, []byte(passphrase))
-		errCheck(err, "Failed to create account")
-
-		pubKey, err := bestPublicKey(account)
-		if err == nil {
-			outputIf(verbose, fmt.Sprintf("%#x", pubKey.Marshal()))
+		if viper.GetBool("quiet") {
+			return nil
 		}
-
-		os.Exit(_exitSuccess)
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
 	},
 }
 
 func init() {
 	accountCmd.AddCommand(accountImportCmd)
 	accountFlags(accountImportCmd)
-	accountImportCmd.Flags().StringVar(&accountImportKey, "key", "", "Private key of the account to import (0x...)")
+	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(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

@@ -22,7 +22,6 @@ import (
 	"github.com/spf13/viper"
 	e2types "github.com/wealdtech/go-eth2-types/v2"
 	util "github.com/wealdtech/go-eth2-util"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
 	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
@@ -34,30 +33,22 @@ var accountInfoCmd = &cobra.Command{
     ethdo account info --account="primary/my funds"
 
 In quiet mode this will return 0 if the account exists, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		assert(viper.GetString("account") != "", "--account is required")
-
-		wallet, err := openWallet()
-		errCheck(err, "Failed to access wallet")
-
-		_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
-		errCheck(err, "Failed to obtain account name")
-
-		accountByNameProvider, isAccountByNameProvider := wallet.(e2wtypes.WalletAccountByNameProvider)
-		assert(isAccountByNameProvider, "wallet cannot obtain accounts by name")
+	Run: func(_ *cobra.Command, _ []string) {
 		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 		defer cancel()
-		account, err := accountByNameProvider.AccountByName(ctx, accountName)
+
+		assert(viper.GetString("account") != "", "--account is required")
+		wallet, account, err := walletAndAccountFromInput(ctx)
 		errCheck(err, "Failed to obtain account")
 
 		// 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())
@@ -67,9 +58,16 @@ 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 viper.GetBool("verbose") {
+				fmt.Printf("Participants:\n")
+				for k, v := range distributedAccount.Participants() {
+					fmt.Printf(" %d: %s\n", k, v)
+				}
+			}
+
 			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

@@ -14,16 +14,14 @@
 package cmd
 
 import (
-	"context"
 	"fmt"
-	"os"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+	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.",
@@ -32,36 +30,18 @@ var accountKeyCmd = &cobra.Command{
     ethdo account key --account="Personal wallet/Operations" --passphrase="my account passphrase"
 
 In quiet mode this will return 0 if the key can be obtained, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		assert(!remote, "account keys not available with remote wallets")
-		assert(viper.GetString("account") != "", "--account is required")
-
-		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-		defer cancel()
-
-		account, err := accountFromPath(ctx, viper.GetString("account"))
-		errCheck(err, "Failed to access account")
-
-		privateKeyProvider, isPrivateKeyProvider := account.(e2wtypes.AccountPrivateKeyProvider)
-		assert(isPrivateKeyProvider, fmt.Sprintf("account %q does not provide its private key", viper.GetString("account")))
-
-		if locker, isLocker := account.(e2wtypes.AccountLocker); isLocker {
-			unlocked := false
-			for _, passphrase := range getPassphrases() {
-				err = locker.Unlock(ctx, []byte(passphrase))
-				if err == nil {
-					unlocked = true
-					break
-				}
-			}
-			assert(unlocked, "Failed to unlock account to obtain private key")
-			defer errCheck(locker.Lock(context.Background()), "failed to re-lock account")
+	RunE: func(cmd *cobra.Command, _ []string) error {
+		res, err := accountkey.Run(cmd)
+		if err != nil {
+			return err
 		}
-		privateKey, err := privateKeyProvider.PrivateKey(ctx)
-		errCheck(err, "Failed to obtain private key")
-
-		outputIf(!quiet, fmt.Sprintf("%#x", privateKey.Marshal()))
-		os.Exit(_exitSuccess)
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
 	},
 }
 

cmd/accountlock.go

@@ -18,7 +18,6 @@ import (
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
 	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
@@ -30,28 +29,19 @@ var accountLockCmd = &cobra.Command{
     ethdo account lock --account="primary/my funds"
 
 In quiet mode this will return 0 if the account is locked, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		assert(viper.GetString("account") != "", "--account is required")
-
-		wallet, err := openWallet()
-		errCheck(err, "Failed to access wallet")
-
-		_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
-		errCheck(err, "Failed to obtain account name")
-
-		accountByNameProvider, isAccountByNameProvider := wallet.(e2wtypes.WalletAccountByNameProvider)
-		assert(isAccountByNameProvider, "wallet cannot obtain accounts by name")
+	Run: func(_ *cobra.Command, _ []string) {
 		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 		defer cancel()
-		account, err := accountByNameProvider.AccountByName(ctx, accountName)
+
+		assert(viper.GetString("account") != "", "--account is required")
+
+		_, account, err := walletAndAccountFromInput(ctx)
 		errCheck(err, "Failed to obtain account")
 
 		locker, isLocker := account.(e2wtypes.AccountLocker)
 		assert(isLocker, "Account does not support locking")
 
-		ctx, cancel = context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 		err = locker.Lock(ctx)
-		cancel()
 		errCheck(err, "Failed to lock account")
 	},
 }

cmd/accountunlock.go

@@ -19,7 +19,6 @@ import (
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
 	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
@@ -31,20 +30,13 @@ var accountUnlockCmd = &cobra.Command{
     ethdo account unlock --account="primary/my funds" --passphrase="secret"
 
 In quiet mode this will return 0 if the account is unlocked, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		assert(viper.GetString("account") != "", "--account is required")
-
-		wallet, err := openWallet()
-		errCheck(err, "Failed to access wallet")
-
-		_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
-		errCheck(err, "Failed to obtain account name")
-
-		accountByNameProvider, isAccountByNameProvider := wallet.(e2wtypes.WalletAccountByNameProvider)
-		assert(isAccountByNameProvider, "wallet cannot obtain accounts by name")
+	Run: func(_ *cobra.Command, _ []string) {
 		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 		defer cancel()
-		account, err := accountByNameProvider.AccountByName(ctx, accountName)
+
+		assert(viper.GetString("account") != "", "--account is required")
+
+		_, account, err := walletAndAccountFromInput(ctx)
 		errCheck(err, "Failed to obtain account")
 
 		locker, isLocker := account.(e2wtypes.AccountLocker)

cmd/accountwithdrawalcredentials.go

@@ -1,83 +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 cmd
-
-import (
-	"context"
-	"encoding/hex"
-	"fmt"
-	"os"
-	"strings"
-
-	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
-	util "github.com/wealdtech/go-eth2-util"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
-	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
-)
-
-var accountWithdrawalCredentialsCmd = &cobra.Command{
-	Use:   "withdrawalcredentials",
-	Short: "Provide withdrawal credentials for an account",
-	Long: `Provide withdrawal credentials for an account.  For example:
-
-    ethdo account withdrawalcredentials --account="Validators/1"
-
-In quiet mode this will return 0 if the account exists, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-		defer cancel()
-
-		assert(viper.GetString("account") != "" || viper.GetString("pubkey") != "", "account or pubkey is required")
-
-		var pubKey []byte
-		if viper.GetString("pubkey") != "" {
-			var err error
-			pubKey, err = hex.DecodeString(strings.TrimPrefix(viper.GetString("pubkey"), "0x"))
-			errCheck(err, "Failed to decode supplied public key")
-		} else {
-			wallet, err := openWallet()
-			errCheck(err, "Failed to access wallet")
-
-			_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
-			errCheck(err, "Failed to obtain account name")
-
-			accountByNameProvider, isAccountByNameProvider := wallet.(e2wtypes.WalletAccountByNameProvider)
-			assert(isAccountByNameProvider, "wallet cannot obtain accounts by name")
-			account, err := accountByNameProvider.AccountByName(ctx, accountName)
-			errCheck(err, "Failed to obtain account")
-
-			key, err := bestPublicKey(account)
-			errCheck(err, "Account does not provide a public key")
-			pubKey = key.Marshal()
-		}
-
-		if quiet {
-			os.Exit(_exitSuccess)
-		}
-
-		withdrawalCredentials := util.SHA256(pubKey)
-		withdrawalCredentials[0] = byte(0) // BLS_WITHDRAWAL_PREFIX
-		fmt.Printf("%#x\n", withdrawalCredentials)
-	},
-}
-
-func init() {
-	accountCmd.AddCommand(accountWithdrawalCredentialsCmd)
-	accountFlags(accountWithdrawalCredentialsCmd)
-	accountWithdrawalCredentialsCmd.Flags().String("pubkey", "", "Public key (overrides account)")
-	if err := viper.BindPFlag("pubkey", accountCreateCmd.Flags().Lookup("pubkey")); err != nil {
-		panic(err)
-	}
-}

cmd/attestation.go

@@ -0,0 +1,29 @@
+// Copyright © 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 cmd
+
+import (
+	"github.com/spf13/cobra"
+)
+
+// attestationCmd represents the attestation command.
+var attestationCmd = &cobra.Command{
+	Use:   "attestation",
+	Short: "Obtain information about an Ethereum 2 attestation",
+	Long:  "Obtain information about an Ethereum 2 attestation",
+}
+
+func init() {
+	RootCmd.AddCommand(attestationCmd)
+}

cmd/attester.go

@@ -0,0 +1,32 @@
+// Copyright © 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 cmd
+
+import (
+	"github.com/spf13/cobra"
+)
+
+// attesterCmd represents the attester command.
+var attesterCmd = &cobra.Command{
+	Use:   "attester",
+	Short: "Obtain information about Ethereum 2 attesters",
+	Long:  "Obtain information about Ethereum 2 attesters",
+}
+
+func init() {
+	RootCmd.AddCommand(attesterCmd)
+}
+
+func attesterFlags(_ *cobra.Command) {
+}

cmd/attester/duties/input.go

@@ -0,0 +1,88 @@
+// 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 attesterduties
+
+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"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
+	"github.com/wealdtech/ethdo/util"
+)
+
+type dataIn struct {
+	// System.
+	timeout time.Duration
+	quiet   bool
+	verbose bool
+	debug   bool
+	json    bool
+	// Operation.
+	validator  string
+	eth2Client eth2client.Service
+	chainTime  chaintime.Service
+	epoch      phase0.Epoch
+}
+
+func input(ctx context.Context) (*dataIn, error) {
+	data := &dataIn{}
+
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	data.timeout = viper.GetDuration("timeout")
+	data.quiet = viper.GetBool("quiet")
+	data.verbose = viper.GetBool("verbose")
+	data.debug = viper.GetBool("debug")
+	data.json = viper.GetBool("json")
+
+	// Validator.
+	data.validator = viper.GetString("validator")
+	if data.validator == "" {
+		return nil, errors.New("validator is required")
+	}
+
+	// Ethereum 2 client.
+	var err error
+	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+		Address:       viper.GetString("connection"),
+		Timeout:       viper.GetDuration("timeout"),
+		AllowInsecure: viper.GetBool("allow-insecure-connections"),
+		LogFallback:   !data.quiet,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	data.chainTime, err = standardchaintime.New(ctx,
+		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithGenesisProvider(data.eth2Client.(eth2client.GenesisProvider)),
+	)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to set up chaintime service")
+	}
+
+	// Epoch.
+	data.epoch, err = util.ParseEpoch(ctx, data.chainTime, viper.GetString("epoch"))
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}

cmd/attester/duties/input_internal_test.go

@@ -0,0 +1,99 @@
+// 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 attesterduties
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	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"
+)
+
+func TestInput(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	require.NoError(t, e2types.InitBLS())
+
+	store := scratch.New()
+	require.NoError(t, e2wallet.UseStore(store))
+	testWallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, testWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+	viper.Set("passphrase", "pass")
+	_, err = testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 0",
+		testutil.HexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{},
+			err:  "timeout is required",
+		},
+		{
+			name: "ValidatorMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+			},
+			err: "validator is required",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"timeout":   "5s",
+				"validator": "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res.timeout, res.timeout)
+			}
+		})
+	}
+}

cmd/attester/duties/output.go

@@ -0,0 +1,55 @@
+// 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 attesterduties
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	api "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/pkg/errors"
+)
+
+type dataOut struct {
+	debug   bool
+	quiet   bool
+	verbose bool
+	json    bool
+	duty    *api.AttesterDuty
+}
+
+func output(_ context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+
+	if data.quiet {
+		return "", nil
+	}
+
+	if data.duty == nil {
+		return "No duties found", nil
+	}
+
+	if data.json {
+		bytes, err := json.Marshal(data.duty)
+		if err != nil {
+			return "", errors.Wrap(err, "failed to marshalJSON")
+		}
+		return string(bytes), nil
+	}
+
+	return fmt.Sprintf("Validator attesting in slot %d committee %d", data.duty.Slot, data.duty.CommitteeIndex), nil
+}

cmd/attester/duties/output_internal_test.go

@@ -0,0 +1,85 @@
+// 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 attesterduties
+
+import (
+	"context"
+	"testing"
+
+	api "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+)
+
+func TestOutput(t *testing.T) {
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		res     string
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name:    "Empty",
+			dataOut: &dataOut{},
+			res:     "No duties found",
+		},
+		{
+			name: "Present",
+			dataOut: &dataOut{
+				duty: &api.AttesterDuty{
+					PubKey:                  testutil.HexToPubKey("0x933ad9491b62059dd065b560d256d8957a8c402cc6e8d8ee7290ae11e8f7329267a8811c397529dac52ae1342ba58c95"),
+					Slot:                    1,
+					ValidatorIndex:          2,
+					CommitteeIndex:          3,
+					CommitteeLength:         4,
+					CommitteesAtSlot:        5,
+					ValidatorCommitteeIndex: 6,
+				},
+			},
+			res: "Validator attesting in slot 1 committee 3",
+		},
+		{
+			name: "JSON",
+			dataOut: &dataOut{
+				json: true,
+				duty: &api.AttesterDuty{
+					PubKey:                  testutil.HexToPubKey("0x933ad9491b62059dd065b560d256d8957a8c402cc6e8d8ee7290ae11e8f7329267a8811c397529dac52ae1342ba58c95"),
+					Slot:                    1,
+					ValidatorIndex:          2,
+					CommitteeIndex:          3,
+					CommitteeLength:         4,
+					CommitteesAtSlot:        5,
+					ValidatorCommitteeIndex: 6,
+				},
+			},
+			res: `{"pubkey":"0x933ad9491b62059dd065b560d256d8957a8c402cc6e8d8ee7290ae11e8f7329267a8811c397529dac52ae1342ba58c95","slot":"1","validator_index":"2","committee_index":"3","committee_length":"4","committees_at_slot":"5","validator_committee_index":"6"}`,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(context.Background(), test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}

cmd/attester/duties/process.go

@@ -0,0 +1,69 @@
+// 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 attesterduties
+
+import (
+	"context"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/util"
+)
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+
+	validator, err := util.ParseValidator(ctx, data.eth2Client.(eth2client.ValidatorsProvider), data.validator, "head")
+	if err != nil {
+		return nil, err
+	}
+
+	results := &dataOut{
+		debug:   data.debug,
+		quiet:   data.quiet,
+		verbose: data.verbose,
+	}
+
+	duty, err := duty(ctx, data.eth2Client, validator, data.epoch)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain duty for validator")
+	}
+
+	results.duty = duty
+
+	return results, nil
+}
+
+func duty(ctx context.Context, eth2Client eth2client.Service, validator *apiv1.Validator, epoch spec.Epoch) (*apiv1.AttesterDuty, error) {
+	// Find the attesting slot for the given epoch.
+	dutiesResponse, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, &api.AttesterDutiesOpts{
+		Epoch:   epoch,
+		Indices: []spec.ValidatorIndex{validator.Index},
+	})
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain attester duties")
+	}
+	duties := dutiesResponse.Data
+
+	if len(duties) == 0 {
+		return nil, errors.New("validator does not have duty for that epoch")
+	}
+
+	return duties[0], nil
+}

cmd/attester/duties/process_internal_test.go

@@ -0,0 +1,73 @@
+// 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 attesterduties
+
+import (
+	"context"
+	"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) {
+	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")),
+	)
+	require.NoError(t, err)
+
+	chainTime, err := standardchaintime.New(context.Background(),
+		standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithGenesisProvider(eth2Client.(eth2client.GenesisProvider)),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "Client",
+			dataIn: &dataIn{
+				eth2Client: eth2Client,
+				chainTime:  chainTime,
+				validator:  "0x933ad9491b62059dd065b560d256d8957a8c402cc6e8d8ee7290ae11e8f7329267a8811c397529dac52ae1342ba58c95",
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, err := process(context.Background(), test.dataIn)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/attester/duties/run.go

@@ -0,0 +1,55 @@
+// Copyright © 2021, 2024 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     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 attesterduties
+
+import (
+	"context"
+	"errors"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the wallet create data command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+	dataIn, err := input(ctx)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to set up command"), err)
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	dataOut, err := process(ctx, dataIn)
+	if err != nil {
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to obtain output"), err)
+	}
+
+	return results, nil
+}

cmd/attester/inclusion/input.go

@@ -0,0 +1,85 @@
+// 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 attesterinclusion
+
+import (
+	"context"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	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"
+)
+
+type dataIn struct {
+	// System.
+	timeout time.Duration
+	quiet   bool
+	verbose bool
+	debug   bool
+	// Operation.
+	eth2Client eth2client.Service
+	chainTime  chaintime.Service
+	epoch      spec.Epoch
+	validator  string
+}
+
+func input(ctx context.Context) (*dataIn, error) {
+	data := &dataIn{}
+
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	data.timeout = viper.GetDuration("timeout")
+	data.quiet = viper.GetBool("quiet")
+	data.verbose = viper.GetBool("verbose")
+	data.debug = viper.GetBool("debug")
+
+	data.validator = viper.GetString("validator")
+	if data.validator == "" {
+		return nil, errors.New("validator is required")
+	}
+
+	// Ethereum 2 client.
+	var err error
+	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+		Address:       viper.GetString("connection"),
+		Timeout:       viper.GetDuration("timeout"),
+		AllowInsecure: viper.GetBool("allow-insecure-connections"),
+		LogFallback:   !data.quiet,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	data.chainTime, err = standardchaintime.New(ctx,
+		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithGenesisProvider(data.eth2Client.(eth2client.GenesisProvider)),
+	)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to set up chaintime service")
+	}
+
+	// Epoch.
+	data.epoch, err = util.ParseEpoch(ctx, data.chainTime, viper.GetString("epoch"))
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}

cmd/attester/inclusion/input_internal_test.go

@@ -0,0 +1,99 @@
+// 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 attesterinclusion
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	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"
+)
+
+func TestInput(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	require.NoError(t, e2types.InitBLS())
+
+	store := scratch.New()
+	require.NoError(t, e2wallet.UseStore(store))
+	testWallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, testWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+	viper.Set("passphrase", "pass")
+	_, err = testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 0",
+		testutil.HexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{},
+			err:  "timeout is required",
+		},
+		{
+			name: "ValidatorMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+			},
+			err: "validator is required",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"timeout":   "5s",
+				"validator": "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res.timeout, res.timeout)
+			}
+		})
+	}
+}

cmd/attester/inclusion/output.go

@@ -0,0 +1,94 @@
+// 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
+//
+//     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 attesterinclusion
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/attestantio/go-eth2-client/spec"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+)
+
+type dataOut struct {
+	debug            bool
+	quiet            bool
+	verbose          bool
+	attestation      *spec.VersionedAttestation
+	slot             phase0.Slot
+	attestationIndex uint64
+	inclusionDelay   phase0.Slot
+	found            bool
+	headCorrect      bool
+	headTimely       bool
+	sourceTimely     bool
+	targetCorrect    bool
+	targetTimely     bool
+}
+
+func output(_ context.Context, data *dataOut) (string, error) {
+	buf := strings.Builder{}
+	if data == nil {
+		return buf.String(), errors.New("no data")
+	}
+
+	if !data.quiet {
+		if data.found {
+			buf.WriteString("Attestation included in block ")
+			buf.WriteString(fmt.Sprintf("%d", data.slot))
+			buf.WriteString(", index ")
+			buf.WriteString(strconv.FormatUint(data.attestationIndex, 10))
+			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 buf.String(), nil
+}

cmd/attester/inclusion/output_internal_test.go

@@ -0,0 +1,84 @@
+// 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 attesterinclusion
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestOutput(t *testing.T) {
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		res     string
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name:    "Empty",
+			dataOut: &dataOut{},
+			res:     "Attestation not found",
+		},
+		{
+			name: "Found",
+			dataOut: &dataOut{
+				found:            true,
+				slot:             123,
+				attestationIndex: 456,
+				inclusionDelay:   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: ✓`,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(context.Background(), test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}

cmd/attester/inclusion/process.go

@@ -0,0 +1,220 @@
+// 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
+//
+//     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 attesterinclusion
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"net/http"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/spec"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
+	"github.com/wealdtech/ethdo/util"
+)
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+
+	validator, err := util.ParseValidator(ctx, data.eth2Client.(eth2client.ValidatorsProvider), data.validator, "head")
+	if err != nil {
+		return nil, err
+	}
+
+	data.chainTime, err = standardchaintime.New(ctx,
+		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithGenesisProvider(data.eth2Client.(eth2client.GenesisProvider)),
+	)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to set up chaintime service")
+	}
+
+	results := &dataOut{
+		debug:   data.debug,
+		quiet:   data.quiet,
+		verbose: data.verbose,
+	}
+
+	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
+	for slot := startSlot; slot < endSlot; slot++ {
+		blockResponse, err := data.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+			Block: fmt.Sprintf("%d", slot),
+		})
+		if err != nil {
+			var apiErr *api.Error
+			if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+				// No block for this slot, that's fine.
+				continue
+			}
+			return nil, errors.Wrap(err, "failed to obtain block")
+		}
+		block := blockResponse.Data
+		if block == nil {
+			continue
+		}
+		blockSlot, err := block.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)
+		}
+		attestations, err := block.Attestations()
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to obtain block attestations")
+		}
+		for i, attestation := range attestations {
+			attestationData, err := attestation.Data()
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to obtain attestation data")
+			}
+			aggregationBits, err := attestation.AggregationBits()
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to obtain attestation aggregation bits")
+			}
+
+			if attestationData.Slot == duty.Slot &&
+				attestationData.Index == duty.CommitteeIndex &&
+				aggregationBits.BitAt(duty.ValidatorCommitteeIndex) {
+				headCorrect := false
+				targetCorrect := false
+				if data.verbose {
+					headCorrect, err = calcHeadCorrect(ctx, data, attestation)
+					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.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
+			}
+		}
+	}
+	return results, nil
+}
+
+func calcHeadCorrect(ctx context.Context, data *dataIn, attestation *spec.VersionedAttestation) (bool, error) {
+	attestationData, err := attestation.Data()
+	if err != nil {
+		return false, errors.Wrap(err, "failed to obtain attestation data")
+	}
+
+	slot := attestationData.Slot
+	for {
+		response, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
+			Block: fmt.Sprintf("%d", slot),
+		})
+		if err != nil {
+			var apiErr *api.Error
+			if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+				// No block.
+				slot--
+				continue
+			}
+
+			return false, err
+		}
+		if !response.Data.Canonical {
+			// Not canonical.
+			slot--
+			continue
+		}
+
+		return bytes.Equal(response.Data.Root[:], attestationData.BeaconBlockRoot[:]), nil
+	}
+}
+
+func calcTargetCorrect(ctx context.Context, data *dataIn, attestation *spec.VersionedAttestation) (bool, error) {
+	attestationData, err := attestation.Data()
+	if err != nil {
+		return false, errors.Wrap(err, "failed to obtain attestation data")
+	}
+
+	// Start with first slot of the target epoch.
+	slot := data.chainTime.FirstSlotOfEpoch(attestationData.Target.Epoch)
+	for {
+		response, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
+			Block: fmt.Sprintf("%d", slot),
+		})
+		if err != nil {
+			var apiErr *api.Error
+			if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+				// No block.
+				slot--
+				continue
+			}
+
+			return false, err
+		}
+		if !response.Data.Canonical {
+			// Not canonical.
+			slot--
+			continue
+		}
+
+		return bytes.Equal(response.Data.Root[:], attestationData.Target.Root[:]), nil
+	}
+}
+
+func duty(ctx context.Context, eth2Client eth2client.Service, validator *apiv1.Validator, epoch phase0.Epoch) (*apiv1.AttesterDuty, error) {
+	// Find the attesting slot for the given epoch.
+	dutiesResponse, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, &api.AttesterDutiesOpts{
+		Epoch:   epoch,
+		Indices: []phase0.ValidatorIndex{validator.Index},
+	})
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain attester duties")
+	}
+	duties := dutiesResponse.Data
+
+	if len(duties) == 0 {
+		return nil, errors.New("validator does not have duty for that epoch")
+	}
+
+	return duties[0], nil
+}

cmd/attester/inclusion/process_internal_test.go

@@ -0,0 +1,73 @@
+// 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 attesterinclusion
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	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 := http.New(context.Background(),
+		http.WithLogLevel(zerolog.Disabled),
+		http.WithAddress(os.Getenv("ETHDO_TEST_CONNECTION")),
+	)
+	require.NoError(t, err)
+
+	chainTime, err := standardchaintime.New(context.Background(),
+		standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithGenesisProvider(eth2Client.(eth2client.GenesisProvider)),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "Client",
+			dataIn: &dataIn{
+				eth2Client: eth2Client,
+				chainTime:  chainTime,
+				validator:  "0x933ad9491b62059dd065b560d256d8957a8c402cc6e8d8ee7290ae11e8f7329267a8811c397529dac52ae1342ba58c95",
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, err := process(context.Background(), test.dataIn)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/attester/inclusion/run.go

@@ -0,0 +1,55 @@
+// Copyright © 2019 - 2024 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     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 attesterinclusion
+
+import (
+	"context"
+	"errors"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the wallet create data command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+	dataIn, err := input(ctx)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to set up command"), err)
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	dataOut, err := process(ctx, dataIn)
+	if err != nil {
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to obtain output"), err)
+	}
+
+	return results, nil
+}

cmd/attesterduties.go

@@ -0,0 +1,61 @@
+// Copyright © 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 cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	attesterduties "github.com/wealdtech/ethdo/cmd/attester/duties"
+)
+
+var attesterDutiesCmd = &cobra.Command{
+	Use:   "duties",
+	Short: "Obtain information about duties of an attester",
+	Long: `Obtain information about dutes of an attester.  For example:
+
+    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, _ []string) error {
+		res, err := attesterduties.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	attesterCmd.AddCommand(attesterDutiesCmd)
+	attesterFlags(attesterDutiesCmd)
+	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(cmd *cobra.Command) {
+	if err := viper.BindPFlag("epoch", cmd.Flags().Lookup("epoch")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("validator", cmd.Flags().Lookup("validator")); err != nil {
+		panic(err)
+	}
+}

cmd/attesterinclusion.go

@@ -0,0 +1,65 @@
+// Copyright © 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 cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	attesterinclusion "github.com/wealdtech/ethdo/cmd/attester/inclusion"
+)
+
+var attesterInclusionCmd = &cobra.Command{
+	Use:   "inclusion",
+	Short: "Obtain information about attester inclusion",
+	Long: `Obtain information about attester inclusion.  For example:
+
+    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, _ []string) error {
+		res, err := attesterinclusion.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	attesterCmd.AddCommand(attesterInclusionCmd)
+	attesterFlags(attesterInclusionCmd)
+	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(cmd *cobra.Command) {
+	if err := viper.BindPFlag("epoch", cmd.Flags().Lookup("epoch")); err != nil {
+		panic(err)
+	}
+	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]*attestationDataInfo
+	// 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     *attestationDataInfo `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 attestationDataInfo 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]*attestationDataInfo),
+		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,157 @@
+// 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"
+	"strconv"
+	"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     *attestationDataInfo `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(strconv.Itoa(i))
+			builder.WriteString(": ")
+			builder.WriteString("distance ")
+			builder.WriteString(strconv.Itoa(attestation.Distance))
+			builder.WriteString(", ")
+
+			if attestation.Duplicate != nil {
+				builder.WriteString("duplicate of attestation ")
+				builder.WriteString(strconv.Itoa(attestation.Duplicate.Index))
+				builder.WriteString(" in block ")
+				builder.WriteString(fmt.Sprintf("%d", attestation.Duplicate.Block))
+				builder.WriteString("\n")
+				continue
+			}
+
+			builder.WriteString(strconv.Itoa(attestation.NewVotes))
+			builder.WriteString("/")
+			builder.WriteString(strconv.Itoa(attestation.Votes))
+			builder.WriteString("/")
+			builder.WriteString(strconv.Itoa(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(strconv.Itoa(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,541 @@
+// Copyright © 2022, 2023 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     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"
+	"net/http"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
+	"github.com/attestantio/go-eth2-client/spec"
+	"github.com/attestantio/go-eth2-client/spec/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
+	}
+
+	blockResponse, err := c.blocksProvider.SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+		Block: c.blockID,
+	})
+	if err != nil {
+		var apiError *api.Error
+		if errors.As(err, &apiError) && apiError.StatusCode == http.StatusNotFound {
+			return errors.New("empty beacon block")
+		}
+		return errors.Wrap(err, "failed to obtain beacon block")
+	}
+	block := blockResponse.Data
+
+	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 {
+		attestationData, err := attestation.Data()
+		if err != nil {
+			return errors.Wrap(err, "failed to obtain attestation data")
+		}
+		if attestationData.Slot < minSlot {
+			minSlot = attestationData.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)
+		}
+
+		attestationData, err := attestation.Data()
+		if err != nil {
+			return errors.Wrap(err, "failed to obtain attestation data")
+		}
+
+		analysis := &attestationAnalysis{
+			Head:     attestationData.BeaconBlockRoot,
+			Target:   attestationData.Target.Root,
+			Distance: int(slot - attestationData.Slot),
+		}
+
+		root, err := attestation.HashTreeRoot()
+		if err != nil {
+			return err
+		}
+		if info, exists := c.priorAttestations[fmt.Sprintf("%#x", root)]; exists {
+			analysis.Duplicate = info
+		} else {
+			aggregationBits, err := attestation.AggregationBits()
+			if err != nil {
+				return err
+			}
+			_, exists := blockVotes[attestationData.Slot]
+			if !exists {
+				blockVotes[attestationData.Slot] = make(map[phase0.CommitteeIndex]bitfield.Bitlist)
+			}
+			_, exists = blockVotes[attestationData.Slot][attestationData.Index]
+			if !exists {
+				blockVotes[attestationData.Slot][attestationData.Index] = bitfield.NewBitlist(aggregationBits.Len())
+			}
+
+			// Count new votes.
+			analysis.PossibleVotes = int(aggregationBits.Len())
+			for j := range aggregationBits.Len() {
+				if aggregationBits.BitAt(j) {
+					analysis.Votes++
+					if blockVotes[attestationData.Slot][attestationData.Index].BitAt(j) {
+						// Already attested to in this block; skip.
+						continue
+					}
+					if c.votes[attestationData.Slot][attestationData.Index].BitAt(j) {
+						// Already attested to in a previous block; skip.
+						continue
+					}
+					analysis.NewVotes++
+					blockVotes[attestationData.Slot][attestationData.Index].SetBitAt(j, true)
+				}
+			}
+			// Calculate head correct.
+			analysis.HeadCorrect, err = c.calcHeadCorrect(ctx, attestation)
+			if err != nil {
+				return err
+			}
+
+			// Calculate head timely.
+			analysis.HeadTimely = analysis.HeadCorrect && attestationData.Slot == slot-1
+
+			// Calculate source timely.
+			analysis.SourceTimely = attestationData.Slot >= slot-5
+
+			// Calculate target correct.
+			analysis.TargetCorrect, err = c.calcTargetCorrect(ctx, attestation)
+			if err != nil {
+				return err
+			}
+
+			// Calculate target timely.
+			if block.Version < spec.DataVersionDeneb {
+				analysis.TargetTimely = attestationData.Slot >= slot-32
+			} else {
+				analysis.TargetTimely = true
+			}
+		}
+
+		// 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
+	}
+	root, err := block.Root()
+	if err != nil {
+		panic(err)
+	}
+	slot, err := block.Slot()
+	if err != nil {
+		panic(err)
+	}
+	if c.debug {
+		fmt.Printf("Parent root of %#x@%d is %#x\n", root, slot, parentRoot)
+	}
+
+	// Obtain the parent block.
+	parentBlockResponse, err := c.blocksProvider.SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+		Block: fmt.Sprintf("%#x", parentRoot),
+	})
+	if err != nil {
+		var apiError *api.Error
+		if errors.As(err, &apiError) && apiError.StatusCode == http.StatusNotFound {
+			return errors.New("empty beacon block")
+		}
+		return err
+	}
+	parentBlock := parentBlockResponse.Data
+	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)] = &attestationDataInfo{
+			Block: slot,
+			Index: i,
+		}
+
+		attestationData, err := attestation.Data()
+		if err != nil {
+			return errors.Wrap(err, "failed to obtain attestation data")
+		}
+		aggregationBits, err := attestation.AggregationBits()
+		if err != nil {
+			return errors.Wrap(err, "failed to obtain attestation aggregation bits")
+		}
+
+		_, exists := c.votes[attestationData.Slot]
+		if !exists {
+			c.votes[attestationData.Slot] = make(map[phase0.CommitteeIndex]bitfield.Bitlist)
+		}
+		_, exists = c.votes[attestationData.Slot][attestationData.Index]
+		if !exists {
+			c.votes[attestationData.Slot][attestationData.Index] = bitfield.NewBitlist(aggregationBits.Len())
+		}
+		for j := range aggregationBits.Len() {
+			if aggregationBits.BitAt(j) {
+				c.votes[attestationData.Slot][attestationData.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.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
+	)
+	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")
+	}
+
+	specResponse, err := specProvider.Spec(ctx, &api.SpecOpts{})
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain spec")
+	}
+
+	tmp, exists := specResponse.Data["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 = specResponse.Data["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 = specResponse.Data["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 = specResponse.Data["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 = specResponse.Data["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 = specResponse.Data["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 *spec.VersionedAttestation) (bool, error) {
+	attestationData, err := attestation.Data()
+	if err != nil {
+		return false, errors.Wrap(err, "failed to obtain attestation data")
+	}
+
+	slot := attestationData.Slot
+	root, exists := c.headRoots[slot]
+	if !exists {
+		for {
+			response, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
+				Block: fmt.Sprintf("%d", slot),
+			})
+			if err != nil {
+				var apiError *api.Error
+				if errors.As(err, &apiError) && apiError.StatusCode == http.StatusNotFound {
+					if c.debug {
+						fmt.Printf("No block available for slot %d, assuming not in canonical chain", slot)
+					}
+					return false, nil
+				}
+				return false, err
+			}
+			if response.Data == nil {
+				// No block.
+				slot--
+				continue
+			}
+			if !response.Data.Canonical {
+				// Not canonical.
+				slot--
+				continue
+			}
+			c.headRoots[slot] = response.Data.Root
+			root = response.Data.Root
+			break
+		}
+	}
+
+	return bytes.Equal(root[:], attestationData.BeaconBlockRoot[:]), nil
+}
+
+func (c *command) calcTargetCorrect(ctx context.Context, attestation *spec.VersionedAttestation) (bool, error) {
+	attestationData, err := attestation.Data()
+	if err != nil {
+		return false, errors.Wrap(err, "failed to obtain attestation data")
+	}
+
+	root, exists := c.targetRoots[attestationData.Slot]
+	if !exists {
+		// Start with first slot of the target epoch.
+		slot := c.chainTime.FirstSlotOfEpoch(attestationData.Target.Epoch)
+		for {
+			response, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
+				Block: fmt.Sprintf("%d", slot),
+			})
+			if err != nil {
+				var apiError *api.Error
+				if errors.As(err, &apiError) && apiError.StatusCode == http.StatusNotFound {
+					if c.debug {
+						fmt.Printf("No block available for slot %d, assuming not in canonical chain", slot)
+					}
+					return false, nil
+				}
+			}
+			if response.Data == nil {
+				// No block.
+				slot--
+				continue
+			}
+			if !response.Data.Canonical {
+				// Not canonical.
+				slot--
+				continue
+			}
+			c.targetRoots[attestationData.Slot] = response.Data.Root
+			root = response.Data.Root
+			break
+		}
+	}
+	return bytes.Equal(root[:], attestationData.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
+	case spec.DataVersionDeneb:
+		c.analysis.SyncCommitee.Contributions = int(block.Deneb.Message.Body.SyncAggregate.SyncCommitteeBits.Count())
+		c.analysis.SyncCommitee.PossibleContributions = int(block.Deneb.Message.Body.SyncAggregate.SyncCommitteeBits.Len())
+		c.analysis.SyncCommitee.Score = float64(c.syncRewardWeight) / float64(c.weightDenominator)
+		c.analysis.SyncCommitee.Value = c.analysis.SyncCommitee.Score * float64(c.analysis.SyncCommitee.Contributions)
+		c.analysis.Value += c.analysis.SyncCommitee.Value
+		return nil
+	case spec.DataVersionElectra:
+		c.analysis.SyncCommitee.Contributions = int(block.Electra.Message.Body.SyncAggregate.SyncCommitteeBits.Count())
+		c.analysis.SyncCommitee.PossibleContributions = int(block.Electra.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.DataVersionFulu:
+		c.analysis.SyncCommitee.Contributions = int(block.Fulu.Message.Body.SyncAggregate.SyncCommitteeBits.Count())
+		c.analysis.SyncCommitee.PossibleContributions = int(block.Fulu.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,55 @@
+// Copyright © 2022, 2024 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     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"
+	"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.Join(errors.New("failed to set up command"), err)
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	if err := c.process(ctx); err != nil {
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := c.output(ctx)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to obtain output"), err)
+	}
+
+	return results, nil
+}

cmd/block/info/input.go

@@ -0,0 +1,70 @@
+// 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
+//
+//     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 blockinfo
+
+import (
+	"context"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/util"
+)
+
+type dataIn struct {
+	// System.
+	timeout time.Duration
+	quiet   bool
+	verbose bool
+	debug   bool
+	// Operation.
+	eth2Client eth2client.Service
+	jsonOutput bool
+	sszOutput  bool
+	// Chain information.
+	blockID   string
+	blockTime string
+	stream    bool
+}
+
+func input(ctx context.Context) (*dataIn, error) {
+	data := &dataIn{}
+
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	data.timeout = viper.GetDuration("timeout")
+	data.quiet = viper.GetBool("quiet")
+	data.verbose = viper.GetBool("verbose")
+	data.debug = viper.GetBool("debug")
+	data.jsonOutput = viper.GetBool("json")
+	data.sszOutput = viper.GetBool("ssz")
+	data.blockID = viper.GetString("blockid")
+	data.blockTime = viper.GetString("block-time")
+	data.stream = viper.GetBool("stream")
+
+	var err error
+	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
+		Address:       viper.GetString("connection"),
+		Timeout:       viper.GetDuration("timeout"),
+		AllowInsecure: viper.GetBool("allow-insecure-connections"),
+		LogFallback:   !data.quiet,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}

cmd/block/info/input_internal_test.go

@@ -0,0 +1,119 @@
+// 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 blockinfo
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	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"
+)
+
+func TestInput(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	require.NoError(t, e2types.InitBLS())
+
+	store := scratch.New()
+	require.NoError(t, e2wallet.UseStore(store))
+	testWallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, testWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+	viper.Set("passphrase", "pass")
+	_, err = testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 0",
+		testutil.HexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{},
+			err:  "timeout is required",
+		},
+		{
+			name: "ConnectionBad",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"connection": "localhost:1",
+				"blockid":    "justified",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+				blockID: "justified",
+			},
+			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",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+				blockID: "head",
+			},
+		},
+		{
+			name: "BlockIDSpecific",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+				"blockid":    "justified",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+				blockID: "justified",
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res.timeout, res.timeout)
+				require.Equal(t, test.res.blockID, res.blockID)
+			}
+		})
+	}
+}

cmd/block/info/output_internal_test.go

@@ -0,0 +1,232 @@
+// 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 blockinfo
+
+import (
+	"context"
+	"testing"
+
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+)
+
+func TestOutput(t *testing.T) {
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		res     string
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name:    "Good",
+			dataOut: &dataOut{},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(context.Background(), test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}
+
+// func TestOutputBlockText(t *testing.T) {
+// 	tests := []struct {
+// 		name              string
+// 		dataOut           *dataOut
+// 		signedBeaconBlock *spec.SignedBeaconBlock
+// 		err               string
+// 	}{
+// 		{
+// 			name: "Nil",
+// 			err:  "no data",
+// 		},
+// 		{
+// 			name:    "Good",
+// 			dataOut: &dataOut{},
+// 		},
+// 	}
+//
+// 	for _, test := range tests {
+// 		t.Run(test.name, func(t *testing.T) {
+// 			res := outputBlockText(context.Background(), test.dataOut, test.signedBeaconBlock)
+// 			if test.err != "" {
+// 				require.EqualError(t, err, test.err)
+// 			} else {
+// 				require.NoError(t, err)
+// 				require.Equal(t, test.res, res)
+// 			}
+// 		})
+// 	}
+// }
+
+func TestOutputBlockDeposits(t *testing.T) {
+	tests := []struct {
+		name     string
+		dataOut  *dataOut
+		verbose  bool
+		deposits []*spec.Deposit
+		res      string
+		err      string
+	}{
+		{
+			name: "Nil",
+			res:  "Deposits: 0\n",
+		},
+		{
+			name: "Empty",
+			res:  "Deposits: 0\n",
+		},
+		{
+			name: "Single",
+			deposits: []*spec.Deposit{
+				{
+					Data: &spec.DepositData{
+						PublicKey:             testutil.HexToPubKey("0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c"),
+						WithdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+						Amount:                spec.Gwei(32000000000),
+						Signature:             testutil.HexToSignature("0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2"),
+					},
+				},
+			},
+			res: "Deposits: 1\n",
+		},
+		{
+			name: "SingleVerbose",
+			deposits: []*spec.Deposit{
+				{
+					Data: &spec.DepositData{
+						PublicKey:             testutil.HexToPubKey("0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c"),
+						WithdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+						Amount:                spec.Gwei(32000000000),
+						Signature:             testutil.HexToSignature("0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2"),
+					},
+				},
+			},
+			verbose: true,
+			res:     "Deposits: 1\n  0:\n    Public key: 0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c\n    Amount: 32 Ether\n    Withdrawal credentials: 0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b\n    Signature: 0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2\n",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := outputBlockDeposits(context.Background(), test.verbose, test.deposits)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}
+
+func TestOutputBlockETH1Data(t *testing.T) {
+	tests := []struct {
+		name     string
+		dataOut  *dataOut
+		verbose  bool
+		eth1Data *spec.ETH1Data
+		res      string
+		err      string
+	}{
+		{
+			name: "Good",
+			eth1Data: &spec.ETH1Data{
+				DepositRoot:  testutil.HexToRoot("0x92407b66d7daf4f30beb84820caae2cbba51add1c4648584101ff3c32151eb83"),
+				DepositCount: 109936,
+				BlockHash:    testutil.HexToBytes("0x77b03ebaf0f2835b491cbd99a7f4649a03a6e7999678603030a014a3c48b32a4"),
+			},
+			res: "Ethereum 1 deposit count: 109936\nEthereum 1 deposit root: 0x92407b66d7daf4f30beb84820caae2cbba51add1c4648584101ff3c32151eb83\nEthereum 1 block hash: 0x77b03ebaf0f2835b491cbd99a7f4649a03a6e7999678603030a014a3c48b32a4\n",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := outputBlockETH1Data(context.Background(), test.eth1Data)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}
+
+func TestBlockGraffiti(t *testing.T) {
+	tests := []struct {
+		name     string
+		graffiti []byte
+		res      string
+	}{
+		{
+			name:     "Empty",
+			graffiti: []byte(""),
+		},
+		{
+			name:     "NoID",
+			graffiti: []byte("No identifier"),
+			res:      "Graffiti: No identifier\n",
+		},
+		{
+			name:     "SingleClient",
+			graffiti: []byte("Graffiti TK"),
+			res:      "Graffiti: Graffiti\nConsensus client: teku\n",
+		},
+		{
+			name:     "SingleClientImmediate",
+			graffiti: []byte("TK"),
+			res:      "Consensus client: teku\n",
+		},
+		{
+			name:     "SingleClientAndHashImmediate",
+			graffiti: []byte("TKa9f98260"),
+			res:      "Consensus client: teku (version hash a9f98260)\n",
+		},
+		{
+			name:     "DualClients",
+			graffiti: []byte("LHGE"),
+			res:      "Consensus client: lighthouse\nExecution client: go-ethereum\n",
+		},
+		{
+			name:     "DualClientsReverseOrder",
+			graffiti: []byte("GELH"),
+			res:      "Consensus client: lighthouse\nExecution client: go-ethereum\n",
+		},
+		{
+			name:     "DualClientsTruncatedHash",
+			graffiti: []byte("Freedom To Transact TKa9f9NM220b"),
+			res:      "Graffiti: Freedom To Transact\nConsensus client: teku (version hash a9f9)\nExecution client: nethermind (version hash 220b)\n",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res := blockGraffiti(context.Background(), test.graffiti)
+			require.Equal(t, test.res, res)
+		})
+	}
+}

cmd/block/info/process.go

@@ -0,0 +1,563 @@
+// 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
+//
+//     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 blockinfo
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/spec"
+	"github.com/attestantio/go-eth2-client/spec/altair"
+	"github.com/attestantio/go-eth2-client/spec/bellatrix"
+	"github.com/attestantio/go-eth2-client/spec/capella"
+	"github.com/attestantio/go-eth2-client/spec/deneb"
+	"github.com/attestantio/go-eth2-client/spec/electra"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
+)
+
+var (
+	jsonOutput bool
+	sszOutput  bool
+	results    *dataOut
+)
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if data.blockID == "" && data.blockTime == "" {
+		return nil, errors.New("no block ID or block time")
+	}
+
+	results = &dataOut{
+		debug:      data.debug,
+		verbose:    data.verbose,
+		eth2Client: data.eth2Client,
+	}
+
+	err := populateResults(ctx, results)
+	if err != nil {
+		return nil, err
+	}
+
+	if data.blockTime != "" {
+		data.blockID, err = timeToBlockID(ctx, data.eth2Client, data.blockTime)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	block, err := obtainBlock(ctx, data, results)
+	if err != nil {
+		return nil, err
+	}
+	if data.quiet {
+		os.Exit(0)
+	}
+
+	switch block.Version {
+	case spec.DataVersionPhase0:
+		err = outputPhase0Block(ctx, data.jsonOutput, block.Phase0)
+	case spec.DataVersionAltair:
+		err = outputAltairBlock(ctx, data.jsonOutput, data.sszOutput, block.Altair)
+	case spec.DataVersionBellatrix:
+		err = outputBellatrixBlock(ctx, data.jsonOutput, data.sszOutput, block.Bellatrix)
+	case spec.DataVersionCapella:
+		err = outputCapellaBlock(ctx, data.jsonOutput, data.sszOutput, block.Capella)
+	case spec.DataVersionDeneb:
+		err = processDenebBlock(ctx, data, block)
+	case spec.DataVersionElectra:
+		err = processElectraBlock(ctx, data, block)
+	case spec.DataVersionFulu:
+		err = processFuluBlock(ctx, data, block)
+	default:
+		return nil, errors.New("unknown block version")
+	}
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to process block")
+	}
+
+	if data.stream {
+		jsonOutput = data.jsonOutput
+		sszOutput = data.sszOutput
+		if !jsonOutput && !sszOutput {
+			fmt.Println("")
+		}
+		err := data.eth2Client.(eth2client.EventsProvider).Events(ctx, &api.EventsOpts{
+			Topics:      []string{"head"},
+			HeadHandler: headEventHandler,
+		})
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to start block stream")
+		}
+		<-ctx.Done()
+	}
+
+	return &dataOut{}, nil
+}
+
+func populateResults(ctx context.Context, results *dataOut) error {
+	specResponse, err := results.eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
+	if err != nil {
+		return errors.Wrap(err, "failed to connect to obtain configuration information")
+	}
+	genesisResponse, err := results.eth2Client.(eth2client.GenesisProvider).Genesis(ctx, &api.GenesisOpts{})
+	if err != nil {
+		return errors.Wrap(err, "failed to connect to obtain genesis information")
+	}
+	genesis := genesisResponse.Data
+	results.genesisTime = genesis.GenesisTime
+	results.slotDuration = specResponse.Data["SECONDS_PER_SLOT"].(time.Duration)
+	results.slotsPerEpoch = specResponse.Data["SLOTS_PER_EPOCH"].(uint64)
+
+	return nil
+}
+
+func obtainBlock(ctx context.Context, data *dataIn, results *dataOut,
+) (
+	*spec.VersionedSignedBeaconBlock,
+	error,
+) {
+	blockResponse, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+		Block: data.blockID,
+	})
+	if err != nil {
+		var apiErr *api.Error
+		if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+			if data.quiet {
+				os.Exit(1)
+			}
+
+			return nil, errors.New("empty beacon block")
+		}
+
+		return nil, errors.Wrap(err, "failed to obtain beacon block")
+	}
+
+	return blockResponse.Data, nil
+}
+
+func processDenebBlock(ctx context.Context,
+	data *dataIn,
+	block *spec.VersionedSignedBeaconBlock,
+) error {
+	var blobSidecars []*deneb.BlobSidecar
+	kzgCommitments, err := block.BlobKZGCommitments()
+	if err != nil {
+		return err
+	}
+	if len(kzgCommitments) > 0 {
+		blobSidecarsResponse, err := results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
+			Block: data.blockID,
+		})
+		if err != nil {
+			var apiErr *api.Error
+			if errors.As(err, &apiErr) && apiErr.StatusCode != http.StatusNotFound {
+				return errors.Wrap(err, "failed to obtain blob sidecars")
+			}
+		} else {
+			blobSidecars = blobSidecarsResponse.Data
+		}
+	}
+	if err := outputDenebBlock(ctx, data.jsonOutput, data.sszOutput, block.Deneb, blobSidecars); err != nil {
+		return errors.Wrap(err, "failed to output block")
+	}
+
+	return nil
+}
+
+func processElectraBlock(ctx context.Context,
+	data *dataIn,
+	block *spec.VersionedSignedBeaconBlock,
+) error {
+	var blobSidecars []*deneb.BlobSidecar
+	kzgCommitments, err := block.BlobKZGCommitments()
+	if err != nil {
+		return err
+	}
+	if len(kzgCommitments) > 0 {
+		blobSidecarsResponse, err := results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
+			Block: data.blockID,
+		})
+		if err != nil {
+			var apiErr *api.Error
+			if errors.As(err, &apiErr) && apiErr.StatusCode != http.StatusNotFound {
+				return errors.Wrap(err, "failed to obtain blob sidecars")
+			}
+		} else {
+			blobSidecars = blobSidecarsResponse.Data
+		}
+	}
+	if err := outputElectraBlock(ctx, data.jsonOutput, data.sszOutput, block.Electra, blobSidecars); err != nil {
+		return errors.Wrap(err, "failed to output block")
+	}
+
+	return nil
+}
+
+func processFuluBlock(ctx context.Context,
+	data *dataIn,
+	block *spec.VersionedSignedBeaconBlock,
+) error {
+	var blobSidecars []*deneb.BlobSidecar
+	kzgCommitments, err := block.BlobKZGCommitments()
+	if err != nil {
+		return err
+	}
+	if len(kzgCommitments) > 0 {
+		blobSidecarsResponse, err := results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
+			Block: data.blockID,
+		})
+		if err != nil {
+			var apiErr *api.Error
+			if errors.As(err, &apiErr) && apiErr.StatusCode != http.StatusNotFound {
+				return errors.Wrap(err, "failed to obtain blob sidecars")
+			}
+		} else {
+			blobSidecars = blobSidecarsResponse.Data
+		}
+	}
+	if err := outputFuluBlock(ctx, data.jsonOutput, data.sszOutput, block.Fulu, blobSidecars); err != nil {
+		return errors.Wrap(err, "failed to output block")
+	}
+
+	return nil
+}
+
+func headEventHandler(ctx context.Context, headEvent *apiv1.HeadEvent) {
+	blockID := fmt.Sprintf("%#x", headEvent.Block[:])
+	blockResponse, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+		Block: blockID,
+	})
+	if err != nil {
+		if !jsonOutput && !sszOutput {
+			fmt.Printf("Failed to obtain block: %v\n", err)
+		}
+		return
+	}
+	block := blockResponse.Data
+	if block == nil {
+		if !jsonOutput && !sszOutput {
+			fmt.Println("Empty beacon block")
+		}
+		return
+	}
+
+	switch block.Version {
+	case spec.DataVersionPhase0:
+		err = outputPhase0Block(ctx, jsonOutput, block.Phase0)
+	case spec.DataVersionAltair:
+		err = outputAltairBlock(ctx, jsonOutput, sszOutput, block.Altair)
+	case spec.DataVersionBellatrix:
+		err = outputBellatrixBlock(ctx, jsonOutput, sszOutput, block.Bellatrix)
+	case spec.DataVersionCapella:
+		err = outputCapellaBlock(ctx, jsonOutput, sszOutput, block.Capella)
+	case spec.DataVersionDeneb:
+		var blobSidecars []*deneb.BlobSidecar
+		var kzgCommitments []deneb.KZGCommitment
+		kzgCommitments, err = block.BlobKZGCommitments()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Failed to obtain KZG commitments: %v\n", err)
+			return
+		}
+		if len(kzgCommitments) > 0 {
+			var blobSidecarsResponse *api.Response[[]*deneb.BlobSidecar]
+			blobSidecarsResponse, err = results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
+				Block: blockID,
+			})
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Failed to obtain blob sidecars: %v\n", err)
+				return
+			}
+			blobSidecars = blobSidecarsResponse.Data
+		}
+		err = outputDenebBlock(context.Background(), jsonOutput, sszOutput, block.Deneb, blobSidecars)
+	case spec.DataVersionElectra:
+		var blobSidecars []*deneb.BlobSidecar
+		var kzgCommitments []deneb.KZGCommitment
+		kzgCommitments, err = block.BlobKZGCommitments()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Failed to obtain KZG commitments: %v\n", err)
+			return
+		}
+		if len(kzgCommitments) > 0 {
+			var blobSidecarsResponse *api.Response[[]*deneb.BlobSidecar]
+			blobSidecarsResponse, err = results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
+				Block: blockID,
+			})
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Failed to obtain blob sidecars: %v\n", err)
+				return
+			}
+			blobSidecars = blobSidecarsResponse.Data
+		}
+		err = outputElectraBlock(context.Background(), jsonOutput, sszOutput, block.Electra, blobSidecars)
+	case spec.DataVersionFulu:
+		var blobSidecars []*deneb.BlobSidecar
+		var kzgCommitments []deneb.KZGCommitment
+		kzgCommitments, err = block.BlobKZGCommitments()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Failed to obtain KZG commitments: %v\n", err)
+			return
+		}
+		if len(kzgCommitments) > 0 {
+			var blobSidecarsResponse *api.Response[[]*deneb.BlobSidecar]
+			blobSidecarsResponse, err = results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
+				Block: blockID,
+			})
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Failed to obtain blob sidecars: %v\n", err)
+				return
+			}
+			blobSidecars = blobSidecarsResponse.Data
+		}
+		err = outputFuluBlock(context.Background(), jsonOutput, sszOutput, block.Fulu, blobSidecars)
+	default:
+		err = errors.New("unknown block version")
+	}
+	if err != nil && !jsonOutput && !sszOutput {
+		fmt.Printf("Failed to output block: %v\n", err)
+		return
+	}
+
+	if !jsonOutput && !sszOutput {
+		fmt.Println("")
+	}
+}
+
+func outputPhase0Block(ctx context.Context, jsonOutput bool, signedBlock *phase0.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))
+	default:
+		data, err := outputPhase0BlockText(ctx, results, signedBlock)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate text")
+		}
+		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
+}
+
+func outputDenebBlock(ctx context.Context,
+	jsonOutput bool,
+	sszOutput bool,
+	signedBlock *deneb.SignedBeaconBlock,
+	blobs []*deneb.BlobSidecar,
+) error {
+	switch {
+	case jsonOutput:
+		data, err := json.Marshal(signedBlock)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate JSON")
+		}
+		fmt.Printf("%s\n", string(data))
+	case sszOutput:
+		data, err := signedBlock.MarshalSSZ()
+		if err != nil {
+			return errors.Wrap(err, "failed to generate SSZ")
+		}
+		fmt.Printf("%x\n", data)
+	default:
+		data, err := outputDenebBlockText(ctx, results, signedBlock, blobs)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate text")
+		}
+		fmt.Print(data)
+	}
+	return nil
+}
+
+func outputElectraBlock(ctx context.Context,
+	jsonOutput bool,
+	sszOutput bool,
+	signedBlock *electra.SignedBeaconBlock,
+	blobs []*deneb.BlobSidecar,
+) error {
+	switch {
+	case jsonOutput:
+		data, err := json.Marshal(signedBlock)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate JSON")
+		}
+		fmt.Printf("%s\n", string(data))
+	case sszOutput:
+		data, err := signedBlock.MarshalSSZ()
+		if err != nil {
+			return errors.Wrap(err, "failed to generate SSZ")
+		}
+		fmt.Printf("%x\n", data)
+	default:
+		data, err := outputElectraBlockText(ctx, results, signedBlock, blobs)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate text")
+		}
+		fmt.Print(data)
+	}
+	return nil
+}
+
+func outputFuluBlock(ctx context.Context,
+	jsonOutput bool,
+	sszOutput bool,
+	signedBlock *electra.SignedBeaconBlock,
+	blobs []*deneb.BlobSidecar,
+) error {
+	switch {
+	case jsonOutput:
+		data, err := json.Marshal(signedBlock)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate JSON")
+		}
+		fmt.Printf("%s\n", string(data))
+	case sszOutput:
+		data, err := signedBlock.MarshalSSZ()
+		if err != nil {
+			return errors.Wrap(err, "failed to generate SSZ")
+		}
+		fmt.Printf("%x\n", data)
+	default:
+		data, err := outputElectraBlockText(ctx, results, signedBlock, blobs)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate text")
+		}
+		fmt.Print(data)
+	}
+	return nil
+}
+
+func timeToBlockID(ctx context.Context, eth2Client eth2client.Service, input string) (string, error) {
+	var timestamp time.Time
+
+	switch {
+	case strings.HasPrefix(input, "0x"):
+		// Hex string.
+		hexTime, err := strconv.ParseInt(strings.TrimPrefix(input, "0x"), 16, 64)
+		if err != nil {
+			return "", errors.Wrap(err, "failed to parse block time as hex string")
+		}
+		timestamp = time.Unix(hexTime, 0)
+	case !strings.Contains(input, ":"):
+		// No colon, assume decimal string.
+		decTime, err := strconv.ParseInt(input, 10, 64)
+		if err != nil {
+			return "", errors.Wrap(err, "failed to parse block time as decimal string")
+		}
+		timestamp = time.Unix(decTime, 0)
+	default:
+		dateTime, err := time.Parse("2006-01-02T15:04:05", input)
+		if err != nil {
+			return "", errors.Wrap(err, "failed to parse block time as datetime")
+		}
+		timestamp = dateTime
+	}
+
+	// Assume timestamp.
+	chainTime, err := standardchaintime.New(ctx,
+		standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithGenesisProvider(eth2Client.(eth2client.GenesisProvider)),
+	)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to set up chaintime service")
+	}
+
+	return fmt.Sprintf("%d", chainTime.TimestampToSlot(timestamp)), nil
+}

cmd/block/info/process_internal_test.go

@@ -0,0 +1,64 @@
+// 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
+//
+//     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 blockinfo
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/attestantio/go-eth2-client/auto"
+	"github.com/rs/zerolog"
+	"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")
+	}
+	eth2Client, err := auto.New(context.Background(),
+		auto.WithLogLevel(zerolog.Disabled),
+		auto.WithAddress(os.Getenv("ETHDO_TEST_CONNECTION")),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "NoBlockID",
+			dataIn: &dataIn{
+				eth2Client: eth2Client,
+			},
+			err: "no block ID",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, err := process(context.Background(), test.dataIn)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/block/info/run.go

@@ -0,0 +1,55 @@
+// Copyright © 2019 - 2024 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     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 blockinfo
+
+import (
+	"context"
+	"errors"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the wallet create data command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+	dataIn, err := input(ctx)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to set up command"), err)
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	dataOut, err := process(ctx, dataIn)
+	if err != nil {
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to obtain output"), err)
+	}
+
+	return results, nil
+}

cmd/block/trail/command.go

@@ -0,0 +1,89 @@
+// Copyright © 2025 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 blocktrail
+
+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.
+	blockID    string
+	jsonOutput bool
+	target     string
+	maxBlocks  int
+
+	// Data access.
+	consensusClient      eth2client.Service
+	chainTime            chaintime.Service
+	blocksProvider       eth2client.SignedBeaconBlockProvider
+	blockHeadersProvider eth2client.BeaconBlockHeadersProvider
+
+	// Processing.
+	justifiedCheckpoint *phase0.Checkpoint
+	finalizedCheckpoint *phase0.Checkpoint
+
+	// Results.
+	steps []*step
+	found bool
+}
+
+type step struct {
+	Slot       phase0.Slot `json:"slot"`
+	Root       phase0.Root `json:"root"`
+	ParentRoot phase0.Root `json:"parent_root"`
+	State      string      `json:"state,omitempty"`
+	// Not a slot, but we're using it to steal the JSON processing.
+	ExecutionBlock phase0.Slot   `json:"execution_block"`
+	ExecutionHash  phase0.Hash32 `json:"execution_hash"`
+}
+
+func newCommand(_ context.Context) (*command, error) {
+	c := &command{
+		timeout:                  viper.GetDuration("timeout"),
+		quiet:                    viper.GetBool("quiet"),
+		verbose:                  viper.GetBool("verbose"),
+		debug:                    viper.GetBool("debug"),
+		jsonOutput:               viper.GetBool("json"),
+		connection:               viper.GetString("connection"),
+		allowInsecureConnections: viper.GetBool("allow-insecure-connections"),
+		blockID:                  viper.GetString("blockid"),
+		target:                   viper.GetString("target"),
+		maxBlocks:                viper.GetInt("max-blocks"),
+		steps:                    make([]*step, 0),
+	}
+
+	// Timeout.
+	if c.timeout == 0 {
+		return nil, errors.New("timeout is required")
+	}
+
+	return c, nil
+}

cmd/block/trail/output.go

@@ -0,0 +1,74 @@
+// Copyright © 2025 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 blocktrail
+
+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 simpleOut struct {
+	Start *step `json:"start"`
+	End   *step `json:"end"`
+	Steps int   `json:"distance"`
+}
+
+func (c *command) outputJSON(_ context.Context) (string, error) {
+	var err error
+	var data []byte
+	if c.verbose {
+		data, err = json.Marshal(c.steps)
+	} else {
+		basic := &simpleOut{
+			Start: c.steps[0],
+			End:   c.steps[len(c.steps)-1],
+			Steps: len(c.steps) - 1,
+		}
+		data, err = json.Marshal(basic)
+	}
+
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+func (c *command) outputTxt(_ context.Context) (string, error) {
+	if !c.found {
+		return "Target not found", nil
+	}
+
+	builder := strings.Builder{}
+	builder.WriteString("Target '")
+	builder.WriteString(c.target)
+	builder.WriteString("' found at a distance of ")
+	builder.WriteString(fmt.Sprintf("%d", len(c.steps)-1))
+	builder.WriteString(" block(s)")
+
+	return builder.String(), nil
+}

cmd/block/trail/process.go

@@ -0,0 +1,182 @@
+// Copyright © 2025 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 blocktrail
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	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
+	}
+
+	untilRoot := phase0.Root{}
+	var untilBlock phase0.Slot
+	switch {
+	case strings.ToLower(c.target) == "justified", strings.ToLower(c.target) == "finalized":
+		// Nothing to do.
+	case strings.HasPrefix(c.target, "0x"):
+		// Assume a root.
+		if err := json.Unmarshal([]byte(fmt.Sprintf("%q", c.target)), &untilRoot); err != nil {
+			return err
+		}
+	default:
+		// Assume a block number.
+		tmp, err := strconv.ParseUint(c.target, 10, 64)
+		if err != nil {
+			return err
+		}
+		untilBlock = phase0.Slot(tmp)
+	}
+
+	blockID := c.blockID
+	for range c.maxBlocks {
+		step := &step{}
+
+		blockResponse, err := c.blocksProvider.SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+			Block: blockID,
+		})
+		if err != nil {
+			var apiError *api.Error
+			if errors.As(err, &apiError) && apiError.StatusCode == http.StatusNotFound {
+				return errors.New("empty beacon block")
+			}
+			return errors.Wrap(err, "failed to obtain beacon block")
+		}
+		block := blockResponse.Data
+
+		step.Slot, err = block.Slot()
+		if err != nil {
+			return err
+		}
+		step.Root, err = block.Root()
+		if err != nil {
+			return err
+		}
+		step.ParentRoot, err = block.ParentRoot()
+		if err != nil {
+			return err
+		}
+		executionBlock, err := block.ExecutionBlockNumber()
+		if err != nil {
+			return err
+		}
+		step.ExecutionBlock = phase0.Slot(executionBlock)
+		step.ExecutionHash, err = block.ExecutionBlockHash()
+		if err != nil {
+			return err
+		}
+
+		if c.debug {
+			data, err := json.Marshal(step)
+			if err == nil {
+				fmt.Fprintf(os.Stderr, "Step is %s\n", string(data))
+			}
+		}
+
+		c.steps = append(c.steps, step)
+
+		blockID = step.ParentRoot.String()
+
+		if c.target == "justified" && bytes.Equal(step.Root[:], c.justifiedCheckpoint.Root[:]) {
+			c.found = true
+			break
+		}
+		if c.target == "finalized" && bytes.Equal(step.Root[:], c.finalizedCheckpoint.Root[:]) {
+			c.found = true
+			break
+		}
+		if untilBlock > 0 && step.Slot == untilBlock {
+			c.found = true
+			break
+		}
+		if (!untilRoot.IsZero()) && bytes.Equal(step.Root[:], untilRoot[:]) {
+			c.found = true
+			break
+		}
+	}
+
+	return nil
+}
+
+func (c *command) setup(ctx context.Context) error {
+	var err error
+
+	// Connect to the client.
+	c.consensusClient, 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.consensusClient.(eth2client.SpecProvider)),
+		standardchaintime.WithGenesisProvider(c.consensusClient.(eth2client.GenesisProvider)),
+	)
+	if err != nil {
+		return errors.Wrap(err, "failed to set up chaintime service")
+	}
+
+	var isProvider bool
+	c.blocksProvider, isProvider = c.consensusClient.(eth2client.SignedBeaconBlockProvider)
+	if !isProvider {
+		return errors.New("connection does not provide signed beacon block information")
+	}
+	c.blockHeadersProvider, isProvider = c.consensusClient.(eth2client.BeaconBlockHeadersProvider)
+	if !isProvider {
+		return errors.New("connection does not provide beacon block header information")
+	}
+
+	finalityProvider, isProvider := c.consensusClient.(eth2client.FinalityProvider)
+	if !isProvider {
+		return errors.New("connection does not provide finality information")
+	}
+	finalityResponse, err := finalityProvider.Finality(ctx, &api.FinalityOpts{
+		State: "head",
+	})
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain finality")
+	}
+	finality := finalityResponse.Data
+	c.justifiedCheckpoint = finality.Justified
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Justified checkpoint is %d / %#x\n", c.justifiedCheckpoint.Epoch, c.justifiedCheckpoint.Root)
+	}
+	c.finalizedCheckpoint = finality.Finalized
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Finalized checkpoint is %d / %#x\n", c.finalizedCheckpoint.Epoch, c.finalizedCheckpoint.Root)
+	}
+
+	return nil
+}

cmd/block/trail/process_internal_test.go

@@ -0,0 +1,63 @@
+// Copyright © 2025 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 blocktrail
+
+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/trail/run.go

@@ -0,0 +1,59 @@
+// Copyright © 2025 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 blocktrail
+
+import (
+	"context"
+	"errors"
+	"os"
+
+	"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.Join(errors.New("failed to set up command"), err)
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	if err := c.process(ctx); err != nil {
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
+	}
+
+	if viper.GetBool("quiet") {
+		if c.found {
+			return "", nil
+		}
+		os.Exit(1)
+	}
+
+	results, err := c.output(ctx)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to obtain output"), err)
+	}
+
+	return results, nil
+}

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, _ []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

@@ -14,270 +14,56 @@
 package cmd
 
 import (
-	"bytes"
-	"encoding/hex"
 	"fmt"
-	"os"
-	"sort"
-	"strings"
-	"time"
-	"unicode/utf8"
 
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/go-ssz"
 	"github.com/spf13/cobra"
-	"github.com/wealdtech/ethdo/grpc"
-	string2eth "github.com/wealdtech/go-string2eth"
+	"github.com/spf13/viper"
+	blockinfo "github.com/wealdtech/ethdo/cmd/block/info"
 )
 
-var blockInfoSlot int64
-var blockInfoStream bool
-
 var blockInfoCmd = &cobra.Command{
 	Use:   "info",
 	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.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		err := connect()
-		errCheck(err, "Failed to obtain connection to Ethereum 2 beacon chain block")
-
-		config, err := grpc.FetchChainConfig(eth2GRPCConn)
-		errCheck(err, "Failed to obtain beacon chain configuration")
-		slotsPerEpoch := config["SlotsPerEpoch"].(uint64)
-		secondsPerSlot := config["SecondsPerSlot"].(uint64)
-
-		genesisTime, err := grpc.FetchGenesisTime(eth2GRPCConn)
-		errCheck(err, "Failed to obtain beacon chain genesis")
-
-		assert(blockInfoStream || blockInfoSlot != 0, "--slot or --stream is required")
-		assert(!blockInfoStream || blockInfoSlot == -1, "--slot and --stream are not supported together")
-
-		var slot uint64
-		if blockInfoSlot < 0 {
-			slot, err = grpc.FetchLatestFilledSlot(eth2GRPCConn)
-			errCheck(err, "Failed to obtain slot of latest block")
-		} else {
-			slot = uint64(blockInfoSlot)
+	RunE: func(cmd *cobra.Command, _ []string) error {
+		res, err := blockinfo.Run(cmd)
+		if err != nil {
+			return err
 		}
-		assert(slot > 0, "slot must be greater than 0")
-
-		signedBlock, err := grpc.FetchBlock(eth2GRPCConn, slot)
-		errCheck(err, "Failed to obtain block")
-		if signedBlock == nil {
-			outputIf(!quiet, "No block at that slot")
-			os.Exit(_exitFailure)
+		if viper.GetBool("quiet") {
+			return nil
 		}
-		outputBlock(signedBlock, genesisTime, secondsPerSlot, slotsPerEpoch)
-
-		if blockInfoStream {
-			stream, err := grpc.StreamBlocks(eth2GRPCConn)
-			errCheck(err, "Failed to obtain block stream")
-			for {
-				fmt.Println()
-				signedBlock, err := stream.Recv()
-				errCheck(err, "Failed to obtain block")
-				if signedBlock != nil {
-					outputBlock(signedBlock, genesisTime, secondsPerSlot, slotsPerEpoch)
-				}
-			}
+		if res != "" {
+			fmt.Println(res)
 		}
-
-		os.Exit(_exitSuccess)
+		return nil
 	},
 }
 
-func outputBlock(signedBlock *ethpb.SignedBeaconBlock, genesisTime time.Time, secondsPerSlot uint64, slotsPerEpoch uint64) {
-	block := signedBlock.Block
-	body := block.Body
-
-	// General info.
-	bodyRoot, err := ssz.HashTreeRoot(block)
-	errCheck(err, "Failed to calculate block body root")
-	fmt.Printf("Slot: %d\n", block.Slot)
-	fmt.Printf("Epoch: %d\n", block.Slot/slotsPerEpoch)
-	fmt.Printf("Timestamp: %v\n", time.Unix(genesisTime.Unix()+int64(block.Slot*secondsPerSlot), 0))
-	fmt.Printf("Block root: %#x\n", bodyRoot)
-	outputIf(verbose, fmt.Sprintf("Parent root: %#x", block.ParentRoot))
-	outputIf(verbose, fmt.Sprintf("State root: %#x", block.StateRoot))
-	if len(body.Graffiti) > 0 && hex.EncodeToString(body.Graffiti) != "0000000000000000000000000000000000000000000000000000000000000000" {
-		if utf8.Valid(body.Graffiti) {
-			fmt.Printf("Graffiti: %s\n", string(body.Graffiti))
-		} else {
-			fmt.Printf("Graffiti: %#x\n", body.Graffiti)
-		}
-	}
-
-	// Eth1 data.
-	eth1Data := body.Eth1Data
-	outputIf(verbose, fmt.Sprintf("Ethereum 1 deposit count: %d", eth1Data.DepositCount))
-	outputIf(verbose, fmt.Sprintf("Ethereum 1 deposit root: %#x", eth1Data.DepositRoot))
-	outputIf(verbose, fmt.Sprintf("Ethereum 1 block hash: %#x", eth1Data.BlockHash))
-
-	validatorCommittees := make(map[uint64][][]uint64)
-
-	// Attestations.
-	fmt.Printf("Attestations: %d\n", len(body.Attestations))
-	if verbose {
-		for i, att := range body.Attestations {
-			fmt.Printf("\t%d:\n", i)
-
-			// Fetch committees for this epoch if not already obtained.
-			committees, exists := validatorCommittees[att.Data.Slot]
-			if !exists {
-				attestationEpoch := att.Data.Slot / slotsPerEpoch
-				epochCommittees, err := grpc.FetchValidatorCommittees(eth2GRPCConn, attestationEpoch)
-				errCheck(err, "Failed to obtain committees")
-				for k, v := range epochCommittees {
-					validatorCommittees[k] = v
-				}
-				committees = validatorCommittees[att.Data.Slot]
-			}
-
-			fmt.Printf("\t\tCommittee index: %d\n", att.Data.CommitteeIndex)
-			fmt.Printf("\t\tAttesters: %d/%d\n", att.AggregationBits.Count(), att.AggregationBits.Len())
-			fmt.Printf("\t\tAggregation bits: %s\n", bitsToString(att.AggregationBits))
-			fmt.Printf("\t\tAttesting indices: %s\n", attestingIndices(att.AggregationBits, committees[att.Data.CommitteeIndex]))
-			fmt.Printf("\t\tSlot: %d\n", att.Data.Slot)
-			fmt.Printf("\t\tBeacon block root: %#x\n", att.Data.BeaconBlockRoot)
-			fmt.Printf("\t\tSource epoch: %d\n", att.Data.Source.Epoch)
-			fmt.Printf("\t\tSource root: %#x\n", att.Data.Source.Root)
-			fmt.Printf("\t\tTarget epoch: %d\n", att.Data.Target.Epoch)
-			fmt.Printf("\t\tTarget root: %#x\n", att.Data.Target.Root)
-		}
-	}
-
-	// Attester slashings.
-	fmt.Printf("Attester slashings: %d\n", len(body.AttesterSlashings))
-	if verbose {
-		for i, slashing := range body.AttesterSlashings {
-			// Say what was slashed.
-			att1 := slashing.Attestation_1
-			outputIf(debug, fmt.Sprintf("Attestation 1 attesting indices are %v", att1.AttestingIndices))
-			att2 := slashing.Attestation_2
-			outputIf(debug, fmt.Sprintf("Attestation 2 attesting indices are %v", att2.AttestingIndices))
-			slashedIndices := intersection(att1.AttestingIndices, att2.AttestingIndices)
-			if len(slashedIndices) == 0 {
-				continue
-			}
-
-			fmt.Printf("\t%d:\n", i)
-
-			fmt.Println("\t\tSlashed validators:")
-			for _, slashedIndex := range slashedIndices {
-				validator, err := grpc.FetchValidatorByIndex(eth2GRPCConn, slashedIndex)
-				errCheck(err, "Failed to obtain validator information")
-				fmt.Printf("\t\t\t%#x (%d)\n", validator.PublicKey, slashedIndex)
-			}
-
-			// Say what caused the slashing.
-			if att1.Data.Target.Epoch == att2.Data.Target.Epoch {
-				fmt.Printf("\t\tDouble voted for same target epoch (%d):\n", att1.Data.Target.Epoch)
-				if !bytes.Equal(att1.Data.Target.Root, att2.Data.Target.Root) {
-					fmt.Printf("\t\t\tAttestation 1 target epoch root: %#x\n", att1.Data.Target.Root)
-					fmt.Printf("\t\t\tAttestation 2target epoch root: %#x\n", att2.Data.Target.Root)
-				}
-				if !bytes.Equal(att1.Data.BeaconBlockRoot, att2.Data.BeaconBlockRoot) {
-					fmt.Printf("\t\t\tAttestation 1 beacon block root: %#x\n", att1.Data.BeaconBlockRoot)
-					fmt.Printf("\t\t\tAttestation 2 beacon block root: %#x\n", att2.Data.BeaconBlockRoot)
-				}
-			} else if att1.Data.Source.Epoch < att2.Data.Source.Epoch &&
-				att1.Data.Target.Epoch > att2.Data.Target.Epoch {
-				fmt.Printf("\t\tSurround voted:\n")
-				fmt.Printf("\t\t\tAttestation 1 vote: %d->%d\n", att1.Data.Source.Epoch, att1.Data.Target.Epoch)
-				fmt.Printf("\t\t\tAttestation 2 vote: %d->%d\n", att2.Data.Source.Epoch, att2.Data.Target.Epoch)
-			}
-		}
-	}
-
-	fmt.Printf("Proposer slashings: %d\n", len(body.ProposerSlashings))
-	// TODO verbose proposer slashings.
-
-	// Deposits.
-	fmt.Printf("Deposits: %d\n", len(body.Deposits))
-	if verbose {
-		for i, deposit := range body.Deposits {
-			data := deposit.Data
-			fmt.Printf("\t%d:\n", i)
-			fmt.Printf("\t\tPublic key: %#x\n", data.PublicKey)
-			fmt.Printf("\t\tAmount: %s\n", string2eth.GWeiToString(data.Amount, true))
-			fmt.Printf("\t\tWithdrawal credentials: %#x\n", data.WithdrawalCredentials)
-			fmt.Printf("\t\tSignature: %#x\n", data.Signature)
-		}
-	}
-
-	// Voluntary exits.
-	fmt.Printf("Voluntary exits: %d\n", len(body.VoluntaryExits))
-	if verbose {
-		for i, voluntaryExit := range body.VoluntaryExits {
-			fmt.Printf("\t%d:\n", i)
-			validator, err := grpc.FetchValidatorByIndex(eth2GRPCConn, voluntaryExit.Exit.ValidatorIndex)
-			errCheck(err, "Failed to obtain validator information")
-			fmt.Printf("\t\tValidator: %#x (%d)\n", validator.PublicKey, voluntaryExit.Exit.ValidatorIndex)
-			fmt.Printf("\t\tEpoch: %d\n", voluntaryExit.Exit.Epoch)
-		}
-	}
-}
-
-// intersection returns a list of items common between the two sets.
-func intersection(set1 []uint64, set2 []uint64) []uint64 {
-	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([]uint64, 0)
-
-	set1Pos := 0
-	set2Pos := 0
-	for set1Pos < len(set1) && set2Pos < len(set2) {
-		switch {
-		case set1[set1Pos] < set2[set2Pos]:
-			set1Pos++
-		case set2[set2Pos] < set1[set1Pos]:
-			set2Pos++
-		default:
-			res = append(res, set1[set1Pos])
-			set1Pos++
-			set2Pos++
-		}
-	}
-
-	return res
-}
-
-func bitsToString(input bitfield.Bitlist) string {
-	bits := int(input.Len())
-
-	res := ""
-	for i := 0; i < bits; i++ {
-		if input.BitAt(uint64(i)) {
-			res = fmt.Sprintf("%s✓", res)
-		} else {
-			res = fmt.Sprintf("%s✕", res)
-		}
-		if i%8 == 7 {
-			res = fmt.Sprintf("%s ", res)
-		}
-	}
-	return strings.TrimSpace(res)
-}
-
-func attestingIndices(input bitfield.Bitlist, indices []uint64) string {
-	bits := int(input.Len())
-	res := ""
-	for i := 0; i < bits; i++ {
-		if input.BitAt(uint64(i)) {
-			res = fmt.Sprintf("%s%d ", res, indices[i])
-		}
-	}
-	return strings.TrimSpace(res)
-}
-
 func init() {
 	blockCmd.AddCommand(blockInfoCmd)
 	blockFlags(blockInfoCmd)
-	blockInfoCmd.Flags().Int64Var(&blockInfoSlot, "slot", -1, "the latest slot with a block")
-	blockInfoCmd.Flags().BoolVar(&blockInfoStream, "stream", false, "continually stream blocks as they arrive")
+	blockInfoCmd.Flags().String("blockid", "head", "the ID of the block to fetch")
+	blockInfoCmd.Flags().String("block-time", "", "the time of the block to fetch (format YYYY-MM-DDTHH:MM:SS, or a hex or decimal timestamp")
+	blockInfoCmd.Flags().Bool("stream", false, "continually stream blocks as they arrive")
+	blockInfoCmd.Flags().Bool("ssz", false, "output data in SSZ format")
+}
+
+func blockInfoBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("blockid", cmd.Flags().Lookup("blockid")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("block-time", cmd.Flags().Lookup("block-time")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("stream", cmd.Flags().Lookup("stream")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("ssz", cmd.Flags().Lookup("ssz")); err != nil {
+		panic(err)
+	}
 }

cmd/blocktrail.go

@@ -0,0 +1,65 @@
+// Copyright © 2025 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"
+	blocktrail "github.com/wealdtech/ethdo/cmd/block/trail"
+)
+
+var blockTrailCmd = &cobra.Command{
+	Use:   "trail",
+	Short: "Trail back in the chain from a given block.",
+	Long: `Trail back in the chain for a given block.  For example:
+
+    ethdo block trail --blockid=12345 --target=finalized
+
+In quiet mode this will return 0 if the block trail ends up at the finalized state, otherwise 1.`,
+	RunE: func(cmd *cobra.Command, _ []string) error {
+		res, err := blocktrail.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	blockCmd.AddCommand(blockTrailCmd)
+	blockFlags(blockTrailCmd)
+	blockTrailCmd.Flags().String("blockid", "head", "the ID of the block to fetch")
+	blockTrailCmd.Flags().String("target", "justified", "the target block (block number, hash, justified or finalized)")
+	blockTrailCmd.Flags().Int("max-blocks", 16384, "the maximum number of blocks to look at before halting")
+}
+
+func blockTrailBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("blockid", cmd.Flags().Lookup("blockid")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("target", cmd.Flags().Lookup("target")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("max-blocks", cmd.Flags().Lookup("max-blocks")); 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,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 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
+	periodStart   time.Time
+	periodEnd     time.Time
+	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,134 @@
+// 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"`
+	PeriodStart int64            `json:"period_start"`
+	PeriodEnd   int64            `json:"period_end"`
+	Epoch       phase0.Epoch     `json:"epoch"`
+	Slot        phase0.Slot      `json:"slot"`
+	Incumbent   *phase0.ETH1Data `json:"incumbent"`
+	Votes       []*vote          `json:"votes"`
+}
+
+func (c *command) output(ctx context.Context) (string, error) {
+	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,
+		PeriodStart: c.periodStart.Unix(),
+		PeriodEnd:   c.periodEnd.Unix(),
+		Epoch:       c.epoch,
+		Slot:        c.slot,
+		Incumbent:   c.incumbent,
+		Votes:       votes,
+	}
+	data, err := json.Marshal(output)
+	if err != nil {
+		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("Period start: ")
+		builder.WriteString(fmt.Sprintf("%s\n", c.periodStart))
+		builder.WriteString("Period end: ")
+		builder.WriteString(fmt.Sprintf("%s\n", c.periodEnd))
+
+		builder.WriteString("Incumbent: ")
+		builder.WriteString(fmt.Sprintf("block %#x, deposit count %d\n", c.incumbent.BlockHash, c.incumbent.DepositCount))
+	}
+
+	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,184 @@
+// Copyright © 2022, 2023 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     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/api"
+	"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()
+	}
+	stateResponse, err := c.beaconStateProvider.BeaconState(ctx, &api.BeaconStateOpts{
+		State: fmt.Sprintf("%d", fetchSlot),
+	})
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain state")
+	}
+	state := stateResponse.Data
+	if state == nil {
+		return errors.New("state not returned by beacon node")
+	}
+
+	if c.debug {
+		data, err := json.Marshal(state)
+		if err == nil {
+			fmt.Printf("%s\n", string(data))
+		}
+	}
+
+	c.slot, err = state.Slot()
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain slot")
+	}
+	switch state.Version {
+	case spec.DataVersionPhase0:
+		c.incumbent = state.Phase0.ETH1Data
+		c.eth1DataVotes = state.Phase0.ETH1DataVotes
+	case spec.DataVersionAltair:
+		c.incumbent = state.Altair.ETH1Data
+		c.eth1DataVotes = state.Altair.ETH1DataVotes
+	case spec.DataVersionBellatrix:
+		c.incumbent = state.Bellatrix.ETH1Data
+		c.eth1DataVotes = state.Bellatrix.ETH1DataVotes
+	case spec.DataVersionCapella:
+		c.incumbent = state.Capella.ETH1Data
+		c.eth1DataVotes = state.Capella.ETH1DataVotes
+	case spec.DataVersionDeneb:
+		c.incumbent = state.Deneb.ETH1Data
+		c.eth1DataVotes = state.Deneb.ETH1DataVotes
+	case spec.DataVersionElectra:
+		c.incumbent = state.Electra.ETH1Data
+		c.eth1DataVotes = state.Electra.ETH1DataVotes
+	case spec.DataVersionFulu:
+		c.incumbent = state.Fulu.ETH1Data
+		c.eth1DataVotes = state.Fulu.ETH1DataVotes
+	default:
+		return fmt.Errorf("unhandled beacon state version %v", state.Version)
+	}
+
+	c.period = uint64(c.epoch) / c.epochsPerEth1VotingPeriod
+	c.periodStart = c.chainTime.StartOfEpoch(phase0.Epoch(c.period * c.epochsPerEth1VotingPeriod))
+	c.periodEnd = c.chainTime.StartOfEpoch(phase0.Epoch((c.period + 1) * c.epochsPerEth1VotingPeriod))
+
+	c.votes = make(map[string]*vote)
+	for _, eth1Vote := range c.eth1DataVotes {
+		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.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
+	)
+	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")
+	}
+
+	specResponse, err := specProvider.Spec(ctx, &api.SpecOpts{})
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain spec")
+	}
+
+	tmp, exists := specResponse.Data["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 = specResponse.Data["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,55 @@
+// Copyright © 2022, 2024 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     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"
+	"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.Join(errors.New("failed to set up command"), err)
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	if err := c.process(ctx); err != nil {
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := c.output(ctx)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to obtain output"), err)
+	}
+
+	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,89 @@
+// 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/attestantio/go-eth2-client/api"
+	"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
+	}
+
+	response, err := c.validatorsProvider.Validators(ctx, &api.ValidatorsOpts{
+		State: fmt.Sprintf("%d", c.chainTime.FirstSlotOfEpoch(epoch)),
+	})
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain validators")
+	}
+
+	for _, validator := range response.Data {
+		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.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
+	)
+	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,55 @@
+// Copyright © 2022, 2024 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     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"
+	"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.Join(errors.New("failed to set up command"), err)
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	if err := c.process(ctx); err != nil {
+		switch {
+		case errors.Is(err, context.DeadlineExceeded):
+			return "", errors.New("operation timed out; try increasing with --timeout option")
+		default:
+			return "", errors.Join(errors.New("failed to process"), err)
+		}
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := c.output(ctx)
+	if err != nil {
+		return "", errors.Join(errors.New("failed to obtain output"), err)
+	}
+
+	return results, nil
+}