Update code for spec change.

Provide more help and methods to generate credentials change operations.

.github/workflows/release.yml

@@ -59,7 +59,7 @@ jobs:
 
       - name: Compile
         run: |
-          go build -tags osusergo,netgo -ldflags="-extldflags=-static" -v -ldflags="-X github.com/${{ github.repository }}/cmd.ReleaseVersion=${{ needs.env_vars.outputs.release_version }}"
+          go build -tags osusergo,netgo -v -ldflags="-X github.com/${{ github.repository }}/cmd.ReleaseVersion=${{ needs.env_vars.outputs.release_version }} -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
@@ -87,7 +87,7 @@ jobs:
           sudo apt-get update
           sudo apt-get upgrade
           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 -ldflags="-extldflags=-static" -v -ldflags="-X github.com/${{ github.repository }}/cmd.ReleaseVersion=${{ needs.env_vars.outputs.release_version }}"
+          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
 
@@ -132,7 +132,7 @@ jobs:
 
       - name: Compile
         run: |
-          go build -tags osusergo,netgo -ldflags="-extldflags=-static" -v -ldflags="-X github.com/${{ github.repository }}/cmd.ReleaseVersion=${{ needs.env_vars.outputs.release_version }}"
+          go build -tags osusergo,netgo -v -ldflags="-X github.com/${{ github.repository }}/cmd.ReleaseVersion=${{ needs.env_vars.outputs.release_version }}"
           tar zcf ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-darwin-amd64.tar.gz ${{ needs.env_vars.outputs.binary }}
           brew install coreutils
           sha256sum ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-darwin-amd64.tar.gz | sed -e 's/ .*//' >${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-darwin-amd64.tar.gz.sha256

CHANGELOG.md

@@ -1,6 +1,7 @@
-dev:
+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

beacon/chaininfo.go

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

beacon/validatorinfo.go

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

cmd/attester/inclusion/process.go

@@ -35,7 +35,6 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 
 	data.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithForkScheduleProvider(data.eth2Client.(eth2client.ForkScheduleProvider)),
 		standardchaintime.WithGenesisTimeProvider(data.eth2Client.(eth2client.GenesisTimeProvider)),
 	)
 	if err != nil {

cmd/block/analyze/process.go

@@ -266,7 +266,6 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
 		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
 	)
 	if err != nil {

cmd/chain/eth1votes/process.go

@@ -121,7 +121,6 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
 		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
 	)
 	if err != nil {

cmd/chain/queues/process.go

@@ -65,7 +65,6 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
 		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
 	)
 	if err != nil {

cmd/chainstatus.go

@@ -46,7 +46,6 @@ In quiet mode this will return 0 if the chain status can be obtained, otherwise
 
 		chainTime, err := standardchaintime.New(ctx,
 			standardchaintime.WithGenesisTimeProvider(eth2Client.(eth2client.GenesisTimeProvider)),
-			standardchaintime.WithForkScheduleProvider(eth2Client.(eth2client.ForkScheduleProvider)),
 			standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
 		)
 		errCheck(err, "Failed to configure chaintime service")

cmd/epoch/summary/process.go

@@ -335,7 +335,6 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
 		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
 	)
 	if err != nil {

cmd/proposer/duties/process.go

@@ -53,7 +53,6 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
 		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
 	)
 	if err != nil {

cmd/root.go

@@ -342,7 +342,12 @@ func walletFromPath(ctx context.Context, path string) (e2wtypes.Wallet, error) {
 			return nil, errors.Wrap(err, "failed to parse remote servers")
 		}
 
-		return dirk.OpenWallet(ctx, walletName, credentials, endpoints)
+		return dirk.Open(ctx,
+			dirk.WithName(walletName),
+			dirk.WithCredentials(credentials),
+			dirk.WithEndpoints(endpoints),
+			dirk.WithTimeout(viper.GetDuration("timeout")),
+		)
 	}
 	wallet, err := e2wallet.OpenWallet(walletName)
 	if err != nil {

cmd/signaturesign.go

@@ -1,4 +1,4 @@
-// Copyright © 2017-2020 Weald Technology Trading
+// Copyright © 2017-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
@@ -24,6 +24,7 @@ import (
 	"github.com/wealdtech/ethdo/util"
 	"github.com/wealdtech/go-bytesutil"
 	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
 // signatureSignCmd represents the signature sign command
@@ -52,14 +53,20 @@ In quiet mode this will return 0 if the data can be signed, otherwise 1.`,
 		}
 		outputIf(debug, fmt.Sprintf("Domain is %#x", domain))
 
-		assert(viper.GetString("account") != "", "--account is required")
-		_, account, err := walletAndAccountFromInput(ctx)
+		var account e2wtypes.Account
+		switch {
+		case viper.GetString("account") != "":
+			account, err = util.ParseAccount(ctx, viper.GetString("account"), util.GetPassphrases(), true)
+		case viper.GetString("private-key") != "":
+			account, err = util.ParseAccount(ctx, viper.GetString("private-key"), nil, true)
+		}
 		errCheck(err, "Failed to obtain account")
 
 		var specDomain spec.Domain
 		copy(specDomain[:], domain)
 		var fixedSizeData [32]byte
 		copy(fixedSizeData[:], data)
+		fmt.Printf("Signing %#x with domain %#x by public key %#x\n", fixedSizeData, specDomain, account.PublicKey().Marshal())
 		signature, err := util.SignRoot(account, fixedSizeData, specDomain)
 		errCheck(err, "Failed to sign")
 

cmd/signatureverify.go

@@ -1,4 +1,4 @@
-// Copyright © 2017-2020 Weald Technology Trading
+// Copyright © 2017-2023 Weald Technology Trading
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -15,13 +15,10 @@ package cmd
 
 import (
 	"context"
-	"encoding/hex"
 	"fmt"
 	"os"
-	"strings"
 
 	spec "github.com/attestantio/go-eth2-client/spec/phase0"
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"github.com/wealdtech/ethdo/util"
@@ -43,6 +40,9 @@ var signatureVerifyCmd = &cobra.Command{
 
 In quiet mode this will return 0 if the data can be signed, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
+		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+		defer cancel()
+
 		assert(viper.GetString("signature-data") != "", "--data is required")
 		data, err := bytesutil.FromHexString(viper.GetString("signature-data"))
 		errCheck(err, "Failed to parse data")
@@ -61,7 +61,15 @@ In quiet mode this will return 0 if the data can be signed, otherwise 1.`,
 			assert(len(domain) == 32, "Domain data invalid")
 		}
 
-		account, err := signatureVerifyAccount()
+		var account e2wtypes.Account
+		switch {
+		case viper.GetString("account") != "":
+			account, err = util.ParseAccount(ctx, viper.GetString("account"), nil, false)
+		case viper.GetString("private-key") != "":
+			account, err = util.ParseAccount(ctx, viper.GetString("private-key"), nil, false)
+		case viper.GetString("public-key") != "":
+			account, err = util.ParseAccount(ctx, viper.GetString("public-key"), nil, false)
+		}
 		errCheck(err, "Failed to obtain account")
 		outputIf(debug, fmt.Sprintf("Public key is %#x", account.PublicKey().Marshal()))
 
@@ -78,29 +86,6 @@ In quiet mode this will return 0 if the data can be signed, otherwise 1.`,
 	},
 }
 
-// signatureVerifyAccount obtains the account for the signature verify command.
-func signatureVerifyAccount() (e2wtypes.Account, error) {
-	var account e2wtypes.Account
-	var err error
-	if viper.GetString("account") != "" {
-		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-		defer cancel()
-		_, account, err = walletAndAccountFromPath(ctx, viper.GetString("account"))
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to obtain account")
-		}
-	} else {
-		pubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(signatureVerifySigner, "0x"))
-		if err != nil {
-			return nil, errors.Wrap(err, fmt.Sprintf("failed to decode public key %s", signatureVerifySigner))
-		}
-		account, err = util.NewScratchAccount(nil, pubKeyBytes)
-		if err != nil {
-			return nil, errors.Wrap(err, fmt.Sprintf("invalid public key %s", signatureVerifySigner))
-		}
-	}
-	return account, nil
-}
 func init() {
 	signatureCmd.AddCommand(signatureVerifyCmd)
 	signatureFlags(signatureVerifyCmd)

cmd/synccommittee/inclusion/process.go

@@ -114,7 +114,6 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
 		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
 	)
 	if err != nil {

cmd/synccommittee/members/input.go

@@ -59,7 +59,6 @@ func input(ctx context.Context) (*dataIn, error) {
 	// Chain time.
 	data.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithGenesisTimeProvider(data.eth2Client.(eth2client.GenesisTimeProvider)),
-		standardchaintime.WithForkScheduleProvider(data.eth2Client.(eth2client.ForkScheduleProvider)),
 		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
 	)
 	if err != nil {

cmd/synccommittee/members/process_internal_test.go

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

cmd/validator/credentials/set/chaininfo.go

@@ -1,4 +1,4 @@
-// Copyright © 2022 Weald Technology Trading.
+// Copyright © 2022, 2023 Weald Technology Trading.
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -14,114 +14,92 @@
 package validatorcredentialsset
 
 import (
-	"encoding/hex"
+	"context"
 	"encoding/json"
 	"fmt"
-	"strconv"
-	"strings"
+	"os"
 
-	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/beacon"
 )
 
-type chainInfo struct {
-	Version               uint64
-	Validators            []*validatorInfo
-	GenesisValidatorsRoot phase0.Root
-	Epoch                 phase0.Epoch
-	ForkVersion           phase0.Version
-	Domain                phase0.Domain
-}
-
-type chainInfoJSON struct {
-	Version               string           `json:"version"`
-	Validators            []*validatorInfo `json:"validators"`
-	GenesisValidatorsRoot string           `json:"genesis_validators_root"`
-	Epoch                 string           `json:"epoch"`
-	ForkVersion           string           `json:"fork_version"`
-	Domain                string           `json:"domain"`
-}
-
-// MarshalJSON implements json.Marshaler.
-func (v *chainInfo) MarshalJSON() ([]byte, error) {
-	return json.Marshal(&chainInfoJSON{
-		Version:               fmt.Sprintf("%d", v.Version),
-		Validators:            v.Validators,
-		GenesisValidatorsRoot: fmt.Sprintf("%#x", v.GenesisValidatorsRoot),
-		Epoch:                 fmt.Sprintf("%d", v.Epoch),
-		ForkVersion:           fmt.Sprintf("%#x", v.ForkVersion),
-		Domain:                fmt.Sprintf("%#x", v.Domain),
-	})
-}
-
-// UnmarshalJSON implements json.Unmarshaler.
-func (v *chainInfo) UnmarshalJSON(input []byte) error {
-	var data chainInfoJSON
-	if err := json.Unmarshal(input, &data); err != nil {
-		return errors.Wrap(err, "invalid JSON")
-	}
-
-	if data.Version == "" {
-		// Default to 1.
-		v.Version = 1
-	} else {
-		version, err := strconv.ParseUint(data.Version, 10, 64)
-		if err != nil {
-			return errors.Wrap(err, "version invalid")
+// obtainChainInfo obtains the chain information required to create a withdrawal credentials change operation.
+func (c *command) obtainChainInfo(ctx context.Context) error {
+	// Use the offline preparation file if present (and we haven't been asked to recreate it).
+	if !c.prepareOffline {
+		err := c.obtainChainInfoFromFile(ctx)
+		if err == nil {
+			return nil
 		}
-		v.Version = version
 	}
 
-	if len(data.Validators) == 0 {
-		return errors.New("validators missing")
-	}
-	v.Validators = data.Validators
-
-	if data.GenesisValidatorsRoot == "" {
-		return errors.New("genesis validators root missing")
+	if c.offline {
+		return fmt.Errorf("%s is unavailable or outdated; this is required to have been previously generated using --offline-preparation on an online machine and be readable in the directory in which this command is being run", offlinePreparationFilename)
 	}
 
-	genesisValidatorsRootBytes, err := hex.DecodeString(strings.TrimPrefix(data.GenesisValidatorsRoot, "0x"))
-	if err != nil {
-		return errors.Wrap(err, "genesis validators root invalid")
+	if err := c.obtainChainInfoFromNode(ctx); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// obtainChainInfoFromFile obtains chain information from a pre-generated file.
+func (c *command) obtainChainInfoFromFile(_ context.Context) error {
+	_, err := os.Stat(offlinePreparationFilename)
+	if err != nil {
+		if c.debug {
+			fmt.Fprintf(os.Stderr, "Failed to read offline preparation file: %v\n", err)
+		}
+		return errors.Wrap(err, fmt.Sprintf("cannot find %s", offlinePreparationFilename))
+	}
+
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "%s found; loading chain state\n", offlinePreparationFilename)
+	}
+	data, err := os.ReadFile(offlinePreparationFilename)
+	if err != nil {
+		if c.debug {
+			fmt.Fprintf(os.Stderr, "failed to load chain state: %v\n", err)
+		}
+		return errors.Wrap(err, "failed to read offline preparation file")
+	}
+	c.chainInfo = &beacon.ChainInfo{}
+	if err := json.Unmarshal(data, c.chainInfo); err != nil {
+		if c.debug {
+			fmt.Fprintf(os.Stderr, "chain state invalid: %v\n", err)
+		}
+		return errors.Wrap(err, "failed to parse offline preparation file")
+	}
+
+	return nil
+}
+
+// obtainChainInfoFromNode obtains chain info from a beacon node.
+func (c *command) obtainChainInfoFromNode(ctx context.Context) error {
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Populating chain info from beacon node\n")
+	}
+
+	var err error
+	c.chainInfo, err = beacon.ObtainChainInfoFromNode(ctx, c.consensusClient, c.chainTime)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// writeChainInfoToFile prepares for an offline run of this command by dumping
+// the chain information to a file.
+func (c *command) writeChainInfoToFile(_ context.Context) error {
+	data, err := json.Marshal(c.chainInfo)
+	if err != nil {
+		return err
+	}
+	if err := os.WriteFile(offlinePreparationFilename, data, 0600); err != nil {
+		return err
 	}
-	if len(genesisValidatorsRootBytes) != phase0.RootLength {
-		return errors.New("genesis validators root incorrect length")
-	}
-	copy(v.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")
-	}
-	v.Epoch = phase0.Epoch(epoch)
-
-	if data.ForkVersion == "" {
-		return errors.New("fork version missing")
-	}
-	forkVersionBytes, err := hex.DecodeString(strings.TrimPrefix(data.ForkVersion, "0x"))
-	if err != nil {
-		return errors.Wrap(err, "fork version invalid")
-	}
-	if len(forkVersionBytes) != phase0.ForkVersionLength {
-		return errors.New("fork version incorrect length")
-	}
-	copy(v.ForkVersion[:], forkVersionBytes)
-
-	if data.Domain == "" {
-		return errors.New("domain missing")
-	}
-	domainBytes, err := hex.DecodeString(strings.TrimPrefix(data.Domain, "0x"))
-	if err != nil {
-		return errors.Wrap(err, "domain invalid")
-	}
-	if len(domainBytes) != phase0.DomainLength {
-		return errors.New("domain incorrect length")
-	}
-	copy(v.Domain[:], domainBytes)
 
 	return nil
 }

cmd/validator/credentials/set/command.go

@@ -20,8 +20,10 @@ import (
 	consensusclient "github.com/attestantio/go-eth2-client"
 	"github.com/attestantio/go-eth2-client/spec/bellatrix"
 	capella "github.com/attestantio/go-eth2-client/spec/capella"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/beacon"
 	"github.com/wealdtech/ethdo/services/chaintime"
 	"github.com/wealdtech/ethdo/util"
 )
@@ -35,6 +37,7 @@ type command struct {
 
 	// Input.
 	account               string
+	withdrawalAccount     string
 	passphrases           []string
 	mnemonic              string
 	path                  string
@@ -44,6 +47,7 @@ type command struct {
 	forkVersion           string
 	genesisValidatorsRoot string
 	prepareOffline        bool
+	signedOperationsInput string
 
 	// Beacon node connection.
 	timeout                  time.Duration
@@ -52,7 +56,8 @@ type command struct {
 
 	// Information required to generate the operations.
 	withdrawalAddress bellatrix.ExecutionAddress
-	chainInfo         *chainInfo
+	chainInfo         *beacon.ChainInfo
+	domain            phase0.Domain
 
 	// Processing.
 	consensusClient consensusclient.Service
@@ -62,7 +67,7 @@ type command struct {
 	signedOperations []*capella.SignedBLSToExecutionChange
 }
 
-func newCommand(ctx context.Context) (*command, error) {
+func newCommand(_ context.Context) (*command, error) {
 	c := &command{
 		quiet:                    viper.GetBool("quiet"),
 		verbose:                  viper.GetBool("verbose"),
@@ -74,10 +79,12 @@ func newCommand(ctx context.Context) (*command, error) {
 		allowInsecureConnections: viper.GetBool("allow-insecure-connections"),
 		prepareOffline:           viper.GetBool("prepare-offline"),
 		account:                  viper.GetString("account"),
+		withdrawalAccount:        viper.GetString("withdrawal-account"),
 		passphrases:              util.GetPassphrases(),
 		mnemonic:                 viper.GetString("mnemonic"),
 		path:                     viper.GetString("path"),
 		privateKey:               viper.GetString("private-key"),
+		signedOperationsInput:    viper.GetString("signed-operations"),
 
 		validator:             viper.GetString("validator"),
 		withdrawalAddressStr:  viper.GetString("withdrawal-address"),
@@ -96,8 +103,8 @@ func newCommand(ctx context.Context) (*command, error) {
 		return c, nil
 	}
 
-	if c.account != "" && len(c.passphrases) == 0 {
-		return nil, errors.New("passphrase required with account")
+	if c.withdrawalAccount != "" && len(c.passphrases) == 0 {
+		return nil, errors.New("passphrase required with withdrawal-account")
 	}
 
 	return c, nil

cmd/validator/credentials/set/output.go

@@ -22,16 +22,24 @@ import (
 	"github.com/pkg/errors"
 )
 
-func (c *command) output(ctx context.Context) (string, error) {
+//nolint:unparam
+func (c *command) output(_ context.Context) (string, error) {
 	if c.quiet {
 		return "", nil
 	}
 
+	if c.prepareOffline {
+		return fmt.Sprintf("%s generated", offlinePreparationFilename), nil
+	}
+
 	if c.json || c.offline {
 		data, err := json.Marshal(c.signedOperations)
 		if err != nil {
 			return "", errors.Wrap(err, "failed to marshal signed operations")
 		}
+		if c.json {
+			return string(data), nil
+		}
 		if err := os.WriteFile(changeOperationsFilename, data, 0600); err != nil {
 			return "", errors.Wrap(err, fmt.Sprintf("failed to write %s", changeOperationsFilename))
 		}

cmd/validator/credentials/set/process.go

@@ -1,4 +1,4 @@
-// Copyright © 2022 Weald Technology Trading.
+// Copyright © 2022, 2023 Weald Technology Trading.
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -21,7 +21,6 @@ import (
 	"fmt"
 	"os"
 	"regexp"
-	"strconv"
 	"strings"
 
 	consensusclient "github.com/attestantio/go-eth2-client"
@@ -29,9 +28,12 @@ import (
 	capella "github.com/attestantio/go-eth2-client/spec/capella"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/go-ssz"
+	"github.com/wealdtech/ethdo/beacon"
 	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
 	"github.com/wealdtech/ethdo/signing"
 	"github.com/wealdtech/ethdo/util"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
 	ethutil "github.com/wealdtech/go-eth2-util"
 	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
@@ -43,37 +45,23 @@ var offlinePreparationFilename = "offline-preparation.json"
 var changeOperationsFilename = "change-operations.json"
 
 func (c *command) process(ctx context.Context) error {
-	// We should have exactly 1 specifier to know what we're working with.
-	validatorSpecifiers := 0
-	if c.validator != "" {
-		validatorSpecifiers++
-	}
-	if c.mnemonic != "" {
-		validatorSpecifiers++
-	}
-	if c.privateKey != "" {
-		validatorSpecifiers++
-	}
-	if validatorSpecifiers == 0 {
-		return errors.New("one of validator, mmenomic or private key should be specified")
-	}
-	if validatorSpecifiers > 1 {
-		return errors.New("only one of validator, mmenomic or private key should be specified")
-	}
-
 	if err := c.setup(ctx); err != nil {
 		return err
 	}
 
-	if err := c.obtainRequiredInformation(ctx); err != nil {
+	if err := c.obtainChainInfo(ctx); err != nil {
 		return err
 	}
 
 	if c.prepareOffline {
-		return c.dumpRequiredInformation(ctx)
+		return c.writeChainInfoToFile(ctx)
 	}
 
-	if err := c.generateOperations(ctx); err != nil {
+	if err := c.generateDomain(ctx); err != nil {
+		return err
+	}
+
+	if err := c.obtainOperations(ctx); err != nil {
 		return err
 	}
 
@@ -82,6 +70,9 @@ func (c *command) process(ctx context.Context) error {
 	}
 
 	if c.json || c.offline {
+		if c.debug {
+			fmt.Fprintf(os.Stderr, "Not broadcasting credentials change operations\n")
+		}
 		// Want JSON output, or cannot broadcast.
 		return nil
 	}
@@ -89,252 +80,130 @@ func (c *command) process(ctx context.Context) error {
 	return c.broadcastOperations(ctx)
 }
 
-// obtainRequiredInformation obtains the information required to create a
-// withdrawal credentials change operation.
-func (c *command) obtainRequiredInformation(ctx context.Context) error {
-	c.chainInfo = &chainInfo{
-		Validators: make([]*validatorInfo, 0),
-	}
-
-	// Use the offline preparation file if present (and we haven't been asked to recreate it).
-	if !c.prepareOffline {
-		err := c.loadChainInfo(ctx)
-		if err == nil {
-			return nil
-		}
-	}
-
-	if c.offline {
-		return fmt.Errorf("could not find the %s file; this is required to have been previously generated using --offline-preparation on an online machine and be readable in the directory in which this command is being run", offlinePreparationFilename)
-	}
-
-	if err := c.populateChainInfo(ctx); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// populateChainInfo populates chain info structure from a beacon node.
-func (c *command) populateChainInfo(ctx context.Context) error {
-	if c.debug {
-		fmt.Printf("Populating chain info from beacon node\n")
-	}
-
-	// Obtain validators.
-	validators, err := c.consensusClient.(consensusclient.ValidatorsProvider).Validators(ctx, "head", nil)
-	if err != nil {
-		return errors.Wrap(err, "failed to obtain validators")
-	}
-
-	for _, validator := range validators {
-		c.chainInfo.Validators = append(c.chainInfo.Validators, &validatorInfo{
-			Index:                 validator.Index,
-			Pubkey:                validator.Validator.PublicKey,
-			WithdrawalCredentials: validator.Validator.WithdrawalCredentials,
-		})
-	}
-
-	// Obtain genesis validators root.
-	if c.genesisValidatorsRoot != "" {
-		// Genesis validators root supplied manually.
-		genesisValidatorsRoot, err := hex.DecodeString(strings.TrimPrefix(c.genesisValidatorsRoot, "0x"))
-		if err != nil {
-			return errors.Wrap(err, "invalid genesis validators root supplied")
-		}
-		if len(genesisValidatorsRoot) != phase0.RootLength {
-			return errors.New("invalid length for genesis validators root")
-		}
-		copy(c.chainInfo.GenesisValidatorsRoot[:], genesisValidatorsRoot)
-	} else {
-		// Genesis validators root obtained from beacon node.
-		genesis, err := c.consensusClient.(consensusclient.GenesisProvider).Genesis(ctx)
-		if err != nil {
-			return errors.Wrap(err, "failed to obtain genesis information")
-		}
-		c.chainInfo.GenesisValidatorsRoot = genesis.GenesisValidatorsRoot
-	}
-	if c.debug {
-		fmt.Printf("Genesis validators root is %#x\n", c.chainInfo.GenesisValidatorsRoot)
-	}
-
-	// Obtain epoch.
-	c.chainInfo.Epoch = c.chainTime.CurrentEpoch()
-
-	// Obtain fork version.
-	if c.forkVersion != "" {
-		// Fork version supplied manually.
-		forkVersion, err := hex.DecodeString(strings.TrimPrefix(c.forkVersion, "0x"))
-		if err != nil {
-			return errors.Wrap(err, "invalid fork version supplied")
-		}
-		if len(forkVersion) != phase0.ForkVersionLength {
-			return errors.New("invalid length for fork version")
-		}
-		copy(c.chainInfo.ForkVersion[:], forkVersion)
-	} else {
-		// Fork version obtained from beacon node.
-		forkSchedule, err := c.consensusClient.(consensusclient.ForkScheduleProvider).ForkSchedule(ctx)
-		if err != nil {
-			return errors.Wrap(err, "failed to obtain fork schedule")
-		}
-		if len(forkSchedule) == 0 {
-			return errors.New("beacon node did not provide any fork schedule; provide manually with --fork-version")
-		}
-		if c.debug {
-			fmt.Printf("Genesis fork version is %#x\n", forkSchedule[0].CurrentVersion)
-		}
-		if len(forkSchedule) < 4 {
-			return errors.New("beacon node not providing capella fork schedule; provide manually with --fork-version")
-		}
-		for i := range forkSchedule {
-			// Need to be at least fork 3 (i.e. capella)
-			if i < 3 {
-				continue
-			}
-			if i == 3 {
-				// Force use of capella even if we aren't there yet, to allow credential
-				// change operations to be signed in advance with a signature that will be
-				// valid once capella goes live.
-				c.chainInfo.ForkVersion = forkSchedule[i].CurrentVersion
-				continue
-			}
-			if forkSchedule[i].Epoch <= c.chainInfo.Epoch {
-				c.chainInfo.ForkVersion = forkSchedule[i].CurrentVersion
-			}
-		}
-	}
-	if c.debug {
-		fmt.Printf("Fork version is %#x\n", c.chainInfo.ForkVersion)
-	}
-
-	// Calculate domain.
-	spec, err := c.consensusClient.(consensusclient.SpecProvider).Spec(ctx)
-	if err != nil {
-		return errors.Wrap(err, "failed to obtain spec")
-	}
-	domainType, exists := spec["DOMAIN_BLS_TO_EXECUTION_CHANGE"].(phase0.DomainType)
-	if !exists {
-		return errors.New("failed to obtain DOMAIN_BLS_TO_EXECUTION_CHANGE")
-	}
-	if c.debug {
-		fmt.Printf("Domain type is %#x\n", domainType)
-	}
-	copy(c.chainInfo.Domain[:], domainType[:])
-
-	root, err := (&phase0.ForkData{
-		CurrentVersion:        c.chainInfo.ForkVersion,
-		GenesisValidatorsRoot: c.chainInfo.GenesisValidatorsRoot,
-	}).HashTreeRoot()
-	if err != nil {
-		return errors.Wrap(err, "failed to calculate signature domain")
-	}
-	copy(c.chainInfo.Domain[4:], root[:])
-
-	if c.debug {
-		fmt.Printf("Domain is %#x\n", c.chainInfo.Domain)
-	}
-
-	return nil
-}
-
-// dumpRequiredInformation prepares for an offline run of this command by dumping
-// the chain information to a file.
-func (c *command) dumpRequiredInformation(ctx context.Context) error {
-	data, err := json.Marshal(c.chainInfo)
-	if err != nil {
-		return err
-	}
-	if err := os.WriteFile(offlinePreparationFilename, data, 0600); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (c *command) generateOperations(ctx context.Context) error {
-	if c.account == "" && c.mnemonic == "" && c.privateKey == "" {
+func (c *command) obtainOperations(ctx context.Context) error {
+	if c.account == "" && c.mnemonic == "" && c.privateKey == "" && c.validator == "" {
 		// No input information; fetch the operations from a file.
-		if err := c.loadOperations(ctx); err == nil {
+		err := c.obtainOperationsFromFileOrInput(ctx)
+		if err == nil {
+			// Success.
 			return nil
 		}
-		return fmt.Errorf("no account, mnemonic or private key specified and no %s file found; cannot proceed", changeOperationsFilename)
+		if c.signedOperationsInput != "" {
+			return errors.Wrap(err, "failed to obtain supplied signed operations")
+		}
+		return errors.Wrap(err, fmt.Sprintf("no account, mnemonic or private key specified, and no %s file loaded", changeOperationsFilename))
 	}
 
-	if c.mnemonic != "" && c.path == "" {
-		// Have a mnemonic and no path; scan mnemonic.
-		return c.generateOperationsFromMnemonic(ctx)
+	if c.mnemonic != "" {
+		switch {
+		case c.path != "":
+			// Have a mnemonic and path.
+			return c.generateOperationFromMnemonicAndPath(ctx)
+		case c.validator != "":
+			// Have a mnemonic and validator.
+			return c.generateOperationFromMnemonicAndValidator(ctx)
+		case c.privateKey != "":
+			// Have a mnemonic and a private key for the withdrawal address.
+			return c.generateOperationsFromMnemonicAndPrivateKey(ctx)
+		default:
+			// Have a mnemonic and nothing else; scan.
+			return c.generateOperationsFromMnemonic(ctx)
+		}
 	}
 
-	if c.mnemonic != "" && c.path != "" {
-		// Have a mnemonic and path.
-		return c.generateOperationsFromMnemonicAndPath(ctx)
+	if c.account != "" {
+		switch {
+		case c.withdrawalAccount != "":
+			// Have an account and a withdrawal account.
+			return c.generateOperationsFromAccountAndWithdrawalAccount(ctx)
+		case c.privateKey != "":
+			// Have an account and a private key for the withdrawal address.
+			return c.generateOperationsFromAccountAndPrivateKey(ctx)
+		}
 	}
 
-	// Have a validator index or public key ; fetch the validator info.
-	validatorInfo, err := c.fetchValidatorInfo(ctx)
+	if c.validator != "" && c.privateKey != "" {
+		// Have a validator and a private key for the withdrawal address.
+		return c.generateOperationsFromValidatorAndPrivateKey(ctx)
+	}
+
+	return errors.New("unsupported combination of inputs; see help for details of supported combinations")
+}
+
+func (c *command) generateOperationFromMnemonicAndPath(ctx context.Context) error {
+	seed, err := util.SeedFromMnemonic(c.mnemonic)
 	if err != nil {
 		return err
 	}
 
-	// Fetch the individual account.
-	withdrawalAccount, err := c.fetchAccount(ctx)
-	if err != nil {
-		return err
+	// Turn the validators in to a map for easy lookup.
+	validators := make(map[string]*beacon.ValidatorInfo, 0)
+	for _, validator := range c.chainInfo.Validators {
+		validators[fmt.Sprintf("%#x", validator.Pubkey)] = validator
 	}
 
-	// Generate the operation.
-	if err := c.generateOperationFromAccount(ctx, validatorInfo, withdrawalAccount); err != nil {
-		return err
+	validatorKeyPath := c.path
+	match := validatorPath.Match([]byte(c.path))
+	if !match {
+		return fmt.Errorf("path %s does not match EIP-2334 format for a validator", c.path)
+	}
+
+	if _, err := c.generateOperationFromSeedAndPath(ctx, validators, seed, validatorKeyPath); err != nil {
+		return errors.Wrap(err, "failed to generate operation from seed and path")
 	}
 
 	return nil
 }
 
-func (c *command) loadChainInfo(ctx context.Context) error {
-	_, err := os.Stat(offlinePreparationFilename)
+func (c *command) generateOperationFromMnemonicAndValidator(ctx context.Context) error {
+	seed, err := util.SeedFromMnemonic(c.mnemonic)
 	if err != nil {
-		if c.debug {
-			fmt.Printf("Failed to read offline preparation file: %v\n", err)
-		}
-		return errors.Wrap(err, fmt.Sprintf("cannot find %s", offlinePreparationFilename))
+		return err
 	}
 
-	if c.debug {
-		fmt.Printf("%s found; loading chain state\n", offlinePreparationFilename)
-	}
-	data, err := os.ReadFile(offlinePreparationFilename)
+	validatorInfo, err := c.chainInfo.FetchValidatorInfo(ctx, c.validator)
 	if err != nil {
-		return errors.Wrap(err, "failed to read offline preparation file")
+		return err
 	}
-	if err := json.Unmarshal(data, c.chainInfo); err != nil {
-		return errors.Wrap(err, "failed to parse offline preparation file")
+
+	// Scan the keys from the seed to find the path.
+	maxDistance := 1024
+	// Start scanning the validator keys.
+	var withdrawalAccount e2wtypes.Account
+	for i := 0; ; i++ {
+		if i == maxDistance {
+			if c.debug {
+				fmt.Fprintf(os.Stderr, "Gone %d indices without finding the validator, not scanning any further\n", maxDistance)
+			}
+			break
+		}
+		validatorKeyPath := fmt.Sprintf("m/12381/3600/%d/0/0", i)
+		validatorPrivkey, err := ethutil.PrivateKeyFromSeedAndPath(seed, validatorKeyPath)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate validator private key")
+		}
+		validatorPubkey := validatorPrivkey.PublicKey().Marshal()
+		if bytes.Equal(validatorPubkey, validatorInfo.Pubkey[:]) {
+			withdrawalKeyPath := strings.TrimSuffix(validatorKeyPath, "/0")
+			withdrawalAccount, err = util.ParseAccount(ctx, c.mnemonic, []string{withdrawalKeyPath}, true)
+			if err != nil {
+				return errors.Wrap(err, "failed to create withdrawal account")
+			}
+
+			err = c.generateOperationFromAccount(ctx, validatorInfo, withdrawalAccount)
+			if err != nil {
+				return err
+			}
+			break
+		}
 	}
 
 	return nil
 }
 
-func (c *command) loadOperations(ctx context.Context) error {
-	_, err := os.Stat(changeOperationsFilename)
-	if err != nil {
-		if c.debug {
-			fmt.Printf("Failed to read change operations file: %v\n", err)
-		}
-		return err
-	}
-
-	if c.debug {
-		fmt.Printf("%s found; loading operations\n", changeOperationsFilename)
-	}
-	data, err := os.ReadFile(changeOperationsFilename)
-	if err != nil {
-		return errors.Wrap(err, "failed to read change operations file")
-	}
-	if err := json.Unmarshal(data, &c.signedOperations); err != nil {
-		return errors.Wrap(err, "failed to parse change operations file")
-	}
-
-	return nil
+func (c *command) generateOperationsFromMnemonicAndPrivateKey(ctx context.Context) error {
+	// Functionally identical to a simple scan, so use that.
+	return c.generateOperationsFromMnemonic(ctx)
 }
 
 func (c *command) generateOperationsFromMnemonic(ctx context.Context) error {
@@ -344,7 +213,7 @@ func (c *command) generateOperationsFromMnemonic(ctx context.Context) error {
 	}
 
 	// Turn the validators in to a map for easy lookup.
-	validators := make(map[string]*validatorInfo, 0)
+	validators := make(map[string]*beacon.ValidatorInfo, 0)
 	for _, validator := range c.chainInfo.Validators {
 		validators[fmt.Sprintf("%#x", validator.Pubkey)] = validator
 	}
@@ -355,7 +224,7 @@ func (c *command) generateOperationsFromMnemonic(ctx context.Context) error {
 	for i := 0; ; i++ {
 		if i-lastFoundIndex > maxDistance {
 			if c.debug {
-				fmt.Printf("Gone %d indices without finding a validator, not scanning any further\n", maxDistance)
+				fmt.Fprintf(os.Stderr, "Gone %d indices without finding a validator, not scanning any further\n", maxDistance)
 			}
 			break
 		}
@@ -372,8 +241,141 @@ func (c *command) generateOperationsFromMnemonic(ctx context.Context) error {
 	return nil
 }
 
+func (c *command) generateOperationsFromAccountAndWithdrawalAccount(ctx context.Context) error {
+	validatorAccount, err := util.ParseAccount(ctx, c.account, nil, true)
+	if err != nil {
+		return err
+	}
+
+	withdrawalAccount, err := util.ParseAccount(ctx, c.withdrawalAccount, c.passphrases, true)
+	if err != nil {
+		return err
+	}
+
+	validatorPubkey, err := util.BestPublicKey(validatorAccount)
+	if err != nil {
+		return err
+	}
+	validatorInfo, err := c.chainInfo.FetchValidatorInfo(ctx, fmt.Sprintf("%#x", validatorPubkey.Marshal()))
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain validator info")
+	}
+
+	if err := c.generateOperationFromAccount(ctx, validatorInfo, withdrawalAccount); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *command) generateOperationsFromAccountAndPrivateKey(ctx context.Context) error {
+	validatorAccount, err := util.ParseAccount(ctx, c.account, nil, true)
+	if err != nil {
+		return err
+	}
+
+	withdrawalAccount, err := util.ParseAccount(ctx, c.privateKey, nil, true)
+	if err != nil {
+		return err
+	}
+
+	validatorPubkey, err := util.BestPublicKey(validatorAccount)
+	if err != nil {
+		return err
+	}
+	validatorInfo, err := c.chainInfo.FetchValidatorInfo(ctx, fmt.Sprintf("%#x", validatorPubkey.Marshal()))
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain validator info")
+	}
+
+	if err := c.generateOperationFromAccount(ctx, validatorInfo, withdrawalAccount); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *command) generateOperationsFromValidatorAndPrivateKey(ctx context.Context) error {
+	validatorInfo, err := c.chainInfo.FetchValidatorInfo(ctx, c.validator)
+	if err != nil {
+		return err
+	}
+
+	withdrawalAccount, err := util.ParseAccount(ctx, c.privateKey, nil, true)
+	if err != nil {
+		return err
+	}
+
+	if err := c.generateOperationFromAccount(ctx, validatorInfo, withdrawalAccount); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *command) obtainOperationsFromFileOrInput(ctx context.Context) error {
+	// Start off by attempting to use the provided signed operations.
+	if c.signedOperationsInput != "" {
+		return c.obtainOperationsFromInput(ctx)
+	}
+	// If not, read it from the file with the standard name.
+	return c.obtainOperationsFromFile(ctx)
+}
+
+func (c *command) obtainOperationsFromFile(ctx context.Context) error {
+	_, err := os.Stat(changeOperationsFilename)
+	if err != nil {
+		return errors.Wrap(err, "failed to read change operations file")
+	}
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "%s found; loading operations\n", changeOperationsFilename)
+	}
+	data, err := os.ReadFile(changeOperationsFilename)
+	if err != nil {
+		return errors.Wrap(err, "failed to read change operations file")
+	}
+	if err := json.Unmarshal(data, &c.signedOperations); err != nil {
+		return errors.Wrap(err, "failed to parse change operations file")
+	}
+
+	for _, op := range c.signedOperations {
+		if err := c.verifyOperation(ctx, op); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (c *command) obtainOperationsFromInput(ctx context.Context) error {
+	if strings.HasPrefix(c.signedOperationsInput, "{") {
+		// This looks like a single entry; turn it in to an array.
+		c.signedOperationsInput = fmt.Sprintf("[%s]", c.signedOperationsInput)
+	}
+
+	if !strings.HasPrefix(c.signedOperationsInput, "[") {
+		// This looks like a file; read it in.
+		data, err := os.ReadFile(c.signedOperationsInput)
+		if err != nil {
+			return errors.Wrap(err, "failed to read input file")
+		}
+		c.signedOperationsInput = string(data)
+	}
+
+	if err := json.Unmarshal([]byte(c.signedOperationsInput), &c.signedOperations); err != nil {
+		return errors.Wrap(err, "failed to parse change operations input")
+	}
+
+	for _, op := range c.signedOperations {
+		if err := c.verifyOperation(ctx, op); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func (c *command) generateOperationFromSeedAndPath(ctx context.Context,
-	validators map[string]*validatorInfo,
+	validators map[string]*beacon.ValidatorInfo,
 	seed []byte,
 	path string,
 ) (
@@ -388,45 +390,56 @@ func (c *command) generateOperationFromSeedAndPath(ctx context.Context,
 	validator, exists := validators[validatorPubkey]
 	if !exists {
 		if c.debug {
-			fmt.Printf("No validator found with public key %s at path %s\n", validatorPubkey, path)
+			fmt.Fprintf(os.Stderr, "No validator found with public key %s at path %s\n", validatorPubkey, path)
 		}
 		return false, nil
 	}
 
 	if c.verbose {
-		fmt.Printf("Validator %d found with public key %s at path %s\n", validator.Index, validatorPubkey, path)
+		fmt.Fprintf(os.Stderr, "Validator %d found with public key %s at path %s\n", validator.Index, validatorPubkey, path)
 	}
 
 	if validator.WithdrawalCredentials[0] != byte(0) {
 		if c.debug {
-			fmt.Printf("Validator %s has non-BLS withdrawal credentials %#x\n", validatorPubkey, validator.WithdrawalCredentials)
+			fmt.Fprintf(os.Stderr, "Validator %s has non-BLS withdrawal credentials %#x\n", validatorPubkey, validator.WithdrawalCredentials)
 		}
 		return false, nil
 	}
 
-	// Recreate the withdrawal credentials to ensure a match.
-	withdrawalKeyPath := strings.TrimSuffix(path, "/0")
-	withdrawalPrivkey, err := ethutil.PrivateKeyFromSeedAndPath(seed, withdrawalKeyPath)
-	if err != nil {
-		return false, errors.Wrap(err, "failed to generate withdrawal private key")
+	var withdrawalPubkey []byte
+	var withdrawalAccount e2wtypes.Account
+	if c.privateKey == "" {
+		// Recreate the withdrawal credentials to ensure a match.
+		withdrawalKeyPath := strings.TrimSuffix(path, "/0")
+		withdrawalPrivkey, err := ethutil.PrivateKeyFromSeedAndPath(seed, withdrawalKeyPath)
+		if err != nil {
+			return false, errors.Wrap(err, "failed to generate withdrawal private key")
+		}
+		withdrawalPubkey = withdrawalPrivkey.PublicKey().Marshal()
+		withdrawalAccount, err = util.ParseAccount(ctx, c.mnemonic, []string{withdrawalKeyPath}, true)
+		if err != nil {
+			return false, errors.Wrap(err, "failed to create withdrawal account")
+		}
+
+	} else {
+		// Need the withdrawal credentials from the private key.
+		withdrawalAccount, err = util.ParseAccount(ctx, c.privateKey, nil, true)
+		if err != nil {
+			return false, err
+		}
+		withdrawalPubkey = withdrawalAccount.PublicKey().Marshal()
 	}
-	withdrawalPubkey := withdrawalPrivkey.PublicKey()
-	withdrawalCredentials := ethutil.SHA256(withdrawalPubkey.Marshal())
+	withdrawalCredentials := ethutil.SHA256(withdrawalPubkey)
 	withdrawalCredentials[0] = byte(0) // BLS_WITHDRAWAL_PREFIX
 	if !bytes.Equal(withdrawalCredentials, validator.WithdrawalCredentials) {
-		if c.verbose {
-			fmt.Printf("Validator %s withdrawal credentials %#x do not match expected credentials, cannot update\n", validatorPubkey, validator.WithdrawalCredentials)
+		if c.verbose && c.privateKey == "" {
+			fmt.Fprintf(os.Stderr, "Validator %s withdrawal credentials %#x do not match expected credentials, cannot update\n", validatorPubkey, validator.WithdrawalCredentials)
 		}
 		return false, nil
 	}
 
 	if c.debug {
-		fmt.Printf("Validator %s eligible for setting credentials\n", validatorPubkey)
-	}
-
-	withdrawalAccount, err := util.ParseAccount(ctx, c.mnemonic, []string{withdrawalKeyPath}, true)
-	if err != nil {
-		return false, errors.Wrap(err, "failed to create withdrawal account")
+		fmt.Fprintf(os.Stderr, "Validator %s eligible for setting credentials\n", validatorPubkey)
 	}
 
 	err = c.generateOperationFromAccount(ctx, validator, withdrawalAccount)
@@ -438,7 +451,7 @@ func (c *command) generateOperationFromSeedAndPath(ctx context.Context,
 }
 
 func (c *command) generateOperationFromAccount(ctx context.Context,
-	validator *validatorInfo,
+	validator *beacon.ValidatorInfo,
 	withdrawalAccount e2wtypes.Account,
 ) error {
 	signedOperation, err := c.createSignedOperation(ctx, validator, withdrawalAccount)
@@ -450,7 +463,7 @@ func (c *command) generateOperationFromAccount(ctx context.Context,
 }
 
 func (c *command) createSignedOperation(ctx context.Context,
-	validator *validatorInfo,
+	validator *beacon.ValidatorInfo,
 	withdrawalAccount e2wtypes.Account,
 ) (
 	*capella.SignedBLSToExecutionChange,
@@ -460,6 +473,9 @@ func (c *command) createSignedOperation(ctx context.Context,
 	if err != nil {
 		return nil, err
 	}
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Using %#x as best public key for %s\n", pubkey.Marshal(), withdrawalAccount.Name())
+	}
 	blsPubkey := phase0.BLSPubKey{}
 	copy(blsPubkey[:], pubkey.Marshal())
 
@@ -478,7 +494,10 @@ func (c *command) createSignedOperation(ctx context.Context,
 	}
 
 	// Sign the operation.
-	signature, err := signing.SignRoot(ctx, withdrawalAccount, nil, root, c.chainInfo.Domain)
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Signing %#x with domain %#x by public key %#x\n", root, c.domain, withdrawalAccount.PublicKey().Marshal())
+	}
+	signature, err := signing.SignRoot(ctx, withdrawalAccount, nil, root, c.domain)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to sign credentials change operation")
 	}
@@ -489,7 +508,7 @@ func (c *command) createSignedOperation(ctx context.Context,
 	}, nil
 }
 
-func (c *command) parseWithdrawalAddress(ctx context.Context) error {
+func (c *command) parseWithdrawalAddress(_ context.Context) error {
 	withdrawalAddressBytes, err := hex.DecodeString(strings.TrimPrefix(c.withdrawalAddressStr, "0x"))
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain execution address")
@@ -509,7 +528,7 @@ func (c *command) parseWithdrawalAddress(ctx context.Context) error {
 
 func (c *command) validateOperations(ctx context.Context) (bool, string) {
 	// Turn the validators in to a map for easy lookup.
-	validators := make(map[phase0.ValidatorIndex]*validatorInfo, 0)
+	validators := make(map[phase0.ValidatorIndex]*beacon.ValidatorInfo, 0)
 	for _, validator := range c.chainInfo.Validators {
 		validators[validator.Index] = validator
 	}
@@ -522,8 +541,43 @@ func (c *command) validateOperations(ctx context.Context) (bool, string) {
 	return true, ""
 }
 
-func (c *command) validateOperation(ctx context.Context,
-	validators map[phase0.ValidatorIndex]*validatorInfo,
+func (c *command) verifyOperation(ctx context.Context, op *capella.SignedBLSToExecutionChange) error {
+	root, err := op.Message.HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "failed to generate message root")
+	}
+
+	sigBytes := make([]byte, len(op.Signature))
+	copy(sigBytes, op.Signature[:])
+	sig, err := e2types.BLSSignatureFromBytes(sigBytes)
+	if err != nil {
+		return errors.Wrap(err, "invalid signature")
+	}
+
+	container := &phase0.SigningData{
+		ObjectRoot: root,
+		Domain:     c.domain,
+	}
+	signingRoot, err := ssz.HashTreeRoot(container)
+	if err != nil {
+		return errors.Wrap(err, "failed to generate signing root")
+	}
+
+	pubkeyBytes := make([]byte, len(op.Message.FromBLSPubkey))
+	copy(pubkeyBytes, op.Message.FromBLSPubkey[:])
+	pubkey, err := e2types.BLSPublicKeyFromBytes(pubkeyBytes)
+	if err != nil {
+		return errors.Wrap(err, "invalid public key")
+	}
+	if !sig.Verify(signingRoot[:], pubkey) {
+		return errors.New("signature does not verify")
+	}
+
+	return nil
+}
+
+func (c *command) validateOperation(_ context.Context,
+	validators map[phase0.ValidatorIndex]*beacon.ValidatorInfo,
 	signedOperation *capella.SignedBLSToExecutionChange,
 ) (
 	bool,
@@ -534,8 +588,8 @@ func (c *command) validateOperation(ctx context.Context,
 		return false, "validator not known on chain"
 	}
 	if c.debug {
-		fmt.Printf("Credentials change operation: %v", signedOperation)
-		fmt.Printf("On-chain validator info: %v\n", validator)
+		fmt.Fprintf(os.Stderr, "Credentials change operation: %v", signedOperation)
+		fmt.Fprintf(os.Stderr, "On-chain validator info: %v\n", validator)
 	}
 
 	if validator.WithdrawalCredentials[0] != byte(0) {
@@ -546,7 +600,7 @@ func (c *command) validateOperation(ctx context.Context,
 	withdrawalCredentials[0] = byte(0) // BLS_WITHDRAWAL_PREFIX
 	if !bytes.Equal(withdrawalCredentials, validator.WithdrawalCredentials) {
 		if c.debug {
-			fmt.Printf("validator withdrawal credentials %#x do not match calculated operation withdrawal credentials %#x\n", validator.WithdrawalCredentials, withdrawalCredentials)
+			fmt.Fprintf(os.Stderr, "validator withdrawal credentials %#x do not match calculated operation withdrawal credentials %#x\n", validator.WithdrawalCredentials, withdrawalCredentials)
 		}
 		return false, "validator withdrawal credentials do not match those in the operation"
 	}
@@ -573,7 +627,6 @@ func (c *command) setup(ctx context.Context) error {
 	// Set up chaintime.
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithGenesisTimeProvider(c.consensusClient.(consensusclient.GenesisTimeProvider)),
-		standardchaintime.WithForkScheduleProvider(c.consensusClient.(consensusclient.ForkScheduleProvider)),
 		standardchaintime.WithSpecProvider(c.consensusClient.(consensusclient.SpecProvider)),
 	)
 	if err != nil {
@@ -583,74 +636,88 @@ func (c *command) setup(ctx context.Context) error {
 	return nil
 }
 
-func (c *command) fetchValidatorInfo(ctx context.Context) (*validatorInfo, error) {
-	var validatorInfo *validatorInfo
-	switch {
-	case c.validator == "":
-		return nil, errors.New("no validator specified")
-	case strings.HasPrefix(c.validator, "0x"):
-		// A public key
-		for _, validator := range c.chainInfo.Validators {
-			if strings.EqualFold(c.validator, fmt.Sprintf("%#x", validator.Pubkey)) {
-				validatorInfo = validator
-				break
-			}
-		}
-	case strings.Contains(c.validator, "/"):
-		// An account.
-		_, account, err := util.WalletAndAccountFromPath(ctx, c.validator)
-		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.chainInfo.Validators {
-			if strings.EqualFold(pubkey, fmt.Sprintf("%#x", validator.Pubkey)) {
-				validatorInfo = validator
-				break
-			}
-		}
-	default:
-		// An index.
-		index, err := strconv.ParseUint(c.validator, 10, 64)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to parse validator index")
-		}
-		validatorIndex := phase0.ValidatorIndex(index)
-		for _, validator := range c.chainInfo.Validators {
-			if validator.Index == validatorIndex {
-				validatorInfo = validator
-				break
-			}
-		}
+func (c *command) generateDomain(ctx context.Context) error {
+	genesisValidatorsRoot, err := c.obtainGenesisValidatorsRoot(ctx)
+	if err != nil {
+		return err
+	}
+	forkVersion, err := c.obtainForkVersion(ctx)
+	if err != nil {
+		return err
 	}
 
-	if validatorInfo == nil {
-		return nil, errors.New("unknown validator")
+	root, err := (&phase0.ForkData{
+		CurrentVersion:        forkVersion,
+		GenesisValidatorsRoot: genesisValidatorsRoot,
+	}).HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "failed to calculate signature domain")
 	}
 
-	return validatorInfo, nil
+	copy(c.domain[:], c.chainInfo.BLSToExecutionChangeDomainType[:])
+	copy(c.domain[4:], root[:])
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Domain is %#x\n", c.domain)
+	}
+
+	return nil
 }
 
-func (c *command) fetchAccount(ctx context.Context) (e2wtypes.Account, error) {
-	var account e2wtypes.Account
-	var err error
+func (c *command) obtainGenesisValidatorsRoot(ctx context.Context) (phase0.Root, error) {
+	genesisValidatorsRoot := phase0.Root{}
 
-	switch {
-	case c.account != "":
-		account, err = util.ParseAccount(ctx, c.account, c.passphrases, true)
-	case c.mnemonic != "":
-		account, err = util.ParseAccount(ctx, c.mnemonic, []string{c.path}, true)
-	case c.privateKey != "":
-		account, err = util.ParseAccount(ctx, c.privateKey, nil, true)
-	default:
-		err = errors.New("account, mnemonic or private key must be supplied")
+	if c.genesisValidatorsRoot != "" {
+		if c.debug {
+			fmt.Fprintf(os.Stderr, "Genesis validators root supplied on the command line\n")
+		}
+		root, err := hex.DecodeString(strings.TrimPrefix(c.genesisValidatorsRoot, "0x"))
+		if err != nil {
+			return phase0.Root{}, errors.Wrap(err, "invalid genesis validators root supplied")
+		}
+		if len(root) != phase0.RootLength {
+			return phase0.Root{}, errors.New("invalid length for genesis validators root")
+		}
+		copy(genesisValidatorsRoot[:], root)
+	} else {
+		if c.debug {
+			fmt.Fprintf(os.Stderr, "Genesis validators root obtained from chain info\n")
+		}
+		copy(genesisValidatorsRoot[:], c.chainInfo.GenesisValidatorsRoot[:])
 	}
 
-	return account, err
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Using genesis validators root %#x\n", genesisValidatorsRoot)
+	}
+	return genesisValidatorsRoot, nil
+}
+
+func (c *command) obtainForkVersion(ctx context.Context) (phase0.Version, error) {
+	forkVersion := phase0.Version{}
+
+	if c.forkVersion != "" {
+		if c.debug {
+			fmt.Fprintf(os.Stderr, "Fork version supplied on the command line\n")
+		}
+		version, err := hex.DecodeString(strings.TrimPrefix(c.forkVersion, "0x"))
+		if err != nil {
+			return phase0.Version{}, errors.Wrap(err, "invalid fork version supplied")
+		}
+		if len(version) != phase0.ForkVersionLength {
+			return phase0.Version{}, errors.New("invalid length for fork version")
+		}
+		copy(forkVersion[:], version)
+	} else {
+		if c.debug {
+			fmt.Fprintf(os.Stderr, "Fork version obtained from chain info\n")
+		}
+		// Use the genesis fork version for setting credentials as per the spec.
+		copy(forkVersion[:], c.chainInfo.GenesisForkVersion[:])
+	}
+
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Using fork version %#x\n", forkVersion)
+	}
+	return forkVersion, nil
 }
 
 // addressBytesToEIP55 converts a byte array in to an EIP-55 string format.
@@ -671,28 +738,3 @@ func addressBytesToEIP55(address []byte) string {
 
 	return fmt.Sprintf("0x%s", string(bytes))
 }
-
-func (c *command) generateOperationsFromMnemonicAndPath(ctx context.Context) error {
-	seed, err := util.SeedFromMnemonic(c.mnemonic)
-	if err != nil {
-		return err
-	}
-
-	// Turn the validators in to a map for easy lookup.
-	validators := make(map[string]*validatorInfo, 0)
-	for _, validator := range c.chainInfo.Validators {
-		validators[fmt.Sprintf("%#x", validator.Pubkey)] = validator
-	}
-
-	validatorKeyPath := c.path
-	match := validatorPath.Match([]byte(c.path))
-	if !match {
-		return fmt.Errorf("path %s does not match EIP-2334 format", c.path)
-	}
-
-	if _, err := c.generateOperationFromSeedAndPath(ctx, validators, seed, validatorKeyPath); err != nil {
-		return errors.Wrap(err, "failed to generate operation from seed and path")
-	}
-
-	return nil
-}

cmd/validator/credentials/set/process_internal_test.go

@@ -0,0 +1,372 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package validatorcredentialsset
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/attestantio/go-eth2-client/spec/bellatrix"
+	capella "github.com/attestantio/go-eth2-client/spec/capella"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/beacon"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+)
+
+func TestGenerateOperationFromMnemonicAndPath(t *testing.T) {
+	ctx := context.Background()
+
+	require.NoError(t, e2types.InitBLS())
+
+	chainInfo := &beacon.ChainInfo{
+		Version: 1,
+		Validators: []*beacon.ValidatorInfo{
+			{
+				Index:                 0,
+				Pubkey:                phase0.BLSPubKey{0xb3, 0x84, 0xf7, 0x67, 0xd9, 0x64, 0xe1, 0x00, 0xc8, 0xa9, 0xb2, 0x10, 0x18, 0xd0, 0x8c, 0x25, 0xff, 0xeb, 0xae, 0x26, 0x8b, 0x3a, 0xb6, 0xd6, 0x10, 0x35, 0x38, 0x97, 0x54, 0x19, 0x71, 0x72, 0x6d, 0xbf, 0xc3, 0xc7, 0x46, 0x38, 0x84, 0xc6, 0x8a, 0x53, 0x15, 0x15, 0xaa, 0xb9, 0x4c, 0x87},
+				WithdrawalCredentials: []byte{0x00, 0x8b, 0xa1, 0xcc, 0x4b, 0x09, 0x1b, 0x91, 0xc1, 0x20, 0x2b, 0xba, 0x3f, 0x50, 0x80, 0x75, 0xd6, 0xff, 0x56, 0x5c, 0x77, 0xe5, 0x59, 0xf0, 0x80, 0x3c, 0x07, 0x92, 0xe0, 0x30, 0x2b, 0xf1},
+			},
+			{
+				Index:                 1,
+				Pubkey:                phase0.BLSPubKey{0xb3, 0xd8, 0x9e, 0x2f, 0x29, 0xc7, 0x12, 0xc6, 0xa9, 0xf8, 0xe5, 0xa2, 0x69, 0xb9, 0x76, 0x17, 0xc4, 0xa9, 0x4d, 0xd6, 0xf6, 0x66, 0x2a, 0xb3, 0xb0, 0x7c, 0xe9, 0xe5, 0x43, 0x45, 0x73, 0xf1, 0x5b, 0x5c, 0x98, 0x8c, 0xd1, 0x4b, 0xbd, 0x58, 0x04, 0xf7, 0x71, 0x56, 0xa8, 0xaf, 0x1c, 0xfa},
+				WithdrawalCredentials: []byte{0x00, 0x78, 0x6c, 0xb0, 0x2e, 0xd2, 0x8e, 0x5f, 0xbb, 0x1f, 0x7f, 0x9e, 0x93, 0x1a, 0x2b, 0x72, 0x69, 0x29, 0x06, 0xe6, 0xb1, 0x2c, 0xe4, 0x64, 0x39, 0x75, 0xe3, 0x2b, 0x51, 0x76, 0x91, 0xf2},
+			},
+		},
+		GenesisValidatorsRoot: phase0.Root{},
+		Epoch:                 1,
+		CurrentForkVersion:    phase0.Version{},
+	}
+
+	tests := []struct {
+		name     string
+		command  *command
+		expected []*capella.SignedBLSToExecutionChange
+		err      string
+	}{
+		{
+			name: "MnemonicInvalid",
+			command: &command{
+				mnemonic:             "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon",
+				path:                 "m/12381/3600/0/0/0",
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+			err: "mnemonic is invalid",
+		},
+		{
+			name: "PathInvalid",
+			command: &command{
+				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",
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+			err: "path m/12381/3600/0/0 does not match EIP-2334 format for a validator",
+		},
+		{
+			name: "Good",
+			command: &command{
+				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/0",
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+			expected: []*capella.SignedBLSToExecutionChange{
+				{
+					Message: &capella.BLSToExecutionChange{
+						ValidatorIndex:     0,
+						FromBLSPubkey:      phase0.BLSPubKey{0x99, 0xb1, 0xf1, 0xd8, 0x4d, 0x76, 0x18, 0x54, 0x66, 0xd8, 0x6c, 0x34, 0xbd, 0xe1, 0x10, 0x13, 0x16, 0xaf, 0xdd, 0xae, 0x76, 0x21, 0x7a, 0xa8, 0x6c, 0xd0, 0x66, 0x97, 0x9b, 0x19, 0x85, 0x8c, 0x2c, 0x9d, 0x9e, 0x56, 0xee, 0xbc, 0x1e, 0x06, 0x7a, 0xc5, 0x42, 0x77, 0xa6, 0x17, 0x90, 0xdb},
+						ToExecutionAddress: bellatrix.ExecutionAddress{0x8c, 0x1f, 0xf9, 0x78, 0x03, 0x6f, 0x2e, 0x9d, 0x7c, 0xc3, 0x82, 0xef, 0xf7, 0xb4, 0xc8, 0xc5, 0x3c, 0x22, 0xac, 0x15},
+					},
+					Signature: phase0.BLSSignature{0xb7, 0x8a, 0x05, 0xba, 0xd9, 0x27, 0xfc, 0x89, 0x6f, 0x14, 0x06, 0xb3, 0x2d, 0x64, 0x4a, 0xe1, 0x69, 0xce, 0xcd, 0x89, 0x86, 0xc1, 0xef, 0x8c, 0x0d, 0x03, 0x7d, 0x70, 0x86, 0xf8, 0x5f, 0x13, 0xe1, 0xe1, 0x88, 0xb4, 0x30, 0x96, 0x43, 0xa2, 0xc1, 0x3f, 0xfe, 0xfb, 0x0a, 0xe8, 0x05, 0x11, 0x09, 0x98, 0x53, 0xa0, 0x58, 0x1f, 0x4b, 0x2b, 0xd2, 0xe1, 0x45, 0x41, 0x04, 0x79, 0x01, 0xe2, 0x2a, 0x94, 0x0a, 0x9c, 0x7e, 0x3a, 0xc0, 0xa8, 0x82, 0xd1, 0xa8, 0xaf, 0x6b, 0xfa, 0xea, 0x81, 0x3a, 0x6a, 0x6b, 0xe7, 0x21, 0xf9, 0x26, 0x22, 0x04, 0xaa, 0x9d, 0xa4, 0xe4, 0x77, 0x27, 0xd0},
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			err := test.command.generateOperationFromMnemonicAndPath(ctx)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				// fmt.Printf("%v\n", test.command.signedOperations)
+				require.Equal(t, test.expected, test.command.signedOperations)
+			}
+		})
+	}
+}
+
+func TestGenerateOperationFromMnemonicAndValidator(t *testing.T) {
+	ctx := context.Background()
+
+	require.NoError(t, e2types.InitBLS())
+
+	chainInfo := &beacon.ChainInfo{
+		Version: 1,
+		Validators: []*beacon.ValidatorInfo{
+			{
+				Index:                 0,
+				Pubkey:                phase0.BLSPubKey{0xb3, 0x84, 0xf7, 0x67, 0xd9, 0x64, 0xe1, 0x00, 0xc8, 0xa9, 0xb2, 0x10, 0x18, 0xd0, 0x8c, 0x25, 0xff, 0xeb, 0xae, 0x26, 0x8b, 0x3a, 0xb6, 0xd6, 0x10, 0x35, 0x38, 0x97, 0x54, 0x19, 0x71, 0x72, 0x6d, 0xbf, 0xc3, 0xc7, 0x46, 0x38, 0x84, 0xc6, 0x8a, 0x53, 0x15, 0x15, 0xaa, 0xb9, 0x4c, 0x87},
+				WithdrawalCredentials: []byte{0x00, 0x8b, 0xa1, 0xcc, 0x4b, 0x09, 0x1b, 0x91, 0xc1, 0x20, 0x2b, 0xba, 0x3f, 0x50, 0x80, 0x75, 0xd6, 0xff, 0x56, 0x5c, 0x77, 0xe5, 0x59, 0xf0, 0x80, 0x3c, 0x07, 0x92, 0xe0, 0x30, 0x2b, 0xf1},
+			},
+			{
+				Index:                 1,
+				Pubkey:                phase0.BLSPubKey{0xb3, 0xd8, 0x9e, 0x2f, 0x29, 0xc7, 0x12, 0xc6, 0xa9, 0xf8, 0xe5, 0xa2, 0x69, 0xb9, 0x76, 0x17, 0xc4, 0xa9, 0x4d, 0xd6, 0xf6, 0x66, 0x2a, 0xb3, 0xb0, 0x7c, 0xe9, 0xe5, 0x43, 0x45, 0x73, 0xf1, 0x5b, 0x5c, 0x98, 0x8c, 0xd1, 0x4b, 0xbd, 0x58, 0x04, 0xf7, 0x71, 0x56, 0xa8, 0xaf, 0x1c, 0xfa},
+				WithdrawalCredentials: []byte{0x00, 0x78, 0x6c, 0xb0, 0x2e, 0xd2, 0x8e, 0x5f, 0xbb, 0x1f, 0x7f, 0x9e, 0x93, 0x1a, 0x2b, 0x72, 0x69, 0x29, 0x06, 0xe6, 0xb1, 0x2c, 0xe4, 0x64, 0x39, 0x75, 0xe3, 0x2b, 0x51, 0x76, 0x91, 0xf2},
+			},
+		},
+		GenesisValidatorsRoot: phase0.Root{},
+		Epoch:                 1,
+		CurrentForkVersion:    phase0.Version{},
+	}
+
+	tests := []struct {
+		name     string
+		command  *command
+		expected []*capella.SignedBLSToExecutionChange
+		err      string
+	}{
+		{
+			name: "MnemonicInvalid",
+			command: &command{
+				mnemonic:             "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon",
+				validator:            "0",
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+			err: "mnemonic is invalid",
+		},
+		{
+			name: "ValidatorMissing",
+			command: &command{
+				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",
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+			err: "no validator specified",
+		},
+		{
+			name: "Good",
+			command: &command{
+				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",
+				validator:            "0",
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+			expected: []*capella.SignedBLSToExecutionChange{
+				{
+					Message: &capella.BLSToExecutionChange{
+						ValidatorIndex:     0,
+						FromBLSPubkey:      phase0.BLSPubKey{0x99, 0xb1, 0xf1, 0xd8, 0x4d, 0x76, 0x18, 0x54, 0x66, 0xd8, 0x6c, 0x34, 0xbd, 0xe1, 0x10, 0x13, 0x16, 0xaf, 0xdd, 0xae, 0x76, 0x21, 0x7a, 0xa8, 0x6c, 0xd0, 0x66, 0x97, 0x9b, 0x19, 0x85, 0x8c, 0x2c, 0x9d, 0x9e, 0x56, 0xee, 0xbc, 0x1e, 0x06, 0x7a, 0xc5, 0x42, 0x77, 0xa6, 0x17, 0x90, 0xdb},
+						ToExecutionAddress: bellatrix.ExecutionAddress{0x8c, 0x1f, 0xf9, 0x78, 0x03, 0x6f, 0x2e, 0x9d, 0x7c, 0xc3, 0x82, 0xef, 0xf7, 0xb4, 0xc8, 0xc5, 0x3c, 0x22, 0xac, 0x15},
+					},
+					Signature: phase0.BLSSignature{0xb7, 0x8a, 0x05, 0xba, 0xd9, 0x27, 0xfc, 0x89, 0x6f, 0x14, 0x06, 0xb3, 0x2d, 0x64, 0x4a, 0xe1, 0x69, 0xce, 0xcd, 0x89, 0x86, 0xc1, 0xef, 0x8c, 0x0d, 0x03, 0x7d, 0x70, 0x86, 0xf8, 0x5f, 0x13, 0xe1, 0xe1, 0x88, 0xb4, 0x30, 0x96, 0x43, 0xa2, 0xc1, 0x3f, 0xfe, 0xfb, 0x0a, 0xe8, 0x05, 0x11, 0x09, 0x98, 0x53, 0xa0, 0x58, 0x1f, 0x4b, 0x2b, 0xd2, 0xe1, 0x45, 0x41, 0x04, 0x79, 0x01, 0xe2, 0x2a, 0x94, 0x0a, 0x9c, 0x7e, 0x3a, 0xc0, 0xa8, 0x82, 0xd1, 0xa8, 0xaf, 0x6b, 0xfa, 0xea, 0x81, 0x3a, 0x6a, 0x6b, 0xe7, 0x21, 0xf9, 0x26, 0x22, 0x04, 0xaa, 0x9d, 0xa4, 0xe4, 0x77, 0x27, 0xd0},
+				},
+			},
+		},
+		{
+			name: "GoodPubkey",
+			command: &command{
+				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",
+				validator:            "0xb384f767d964e100c8a9b21018d08c25ffebae268b3ab6d610353897541971726dbfc3c7463884c68a531515aab94c87",
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+			expected: []*capella.SignedBLSToExecutionChange{
+				{
+					Message: &capella.BLSToExecutionChange{
+						ValidatorIndex:     0,
+						FromBLSPubkey:      phase0.BLSPubKey{0x99, 0xb1, 0xf1, 0xd8, 0x4d, 0x76, 0x18, 0x54, 0x66, 0xd8, 0x6c, 0x34, 0xbd, 0xe1, 0x10, 0x13, 0x16, 0xaf, 0xdd, 0xae, 0x76, 0x21, 0x7a, 0xa8, 0x6c, 0xd0, 0x66, 0x97, 0x9b, 0x19, 0x85, 0x8c, 0x2c, 0x9d, 0x9e, 0x56, 0xee, 0xbc, 0x1e, 0x06, 0x7a, 0xc5, 0x42, 0x77, 0xa6, 0x17, 0x90, 0xdb},
+						ToExecutionAddress: bellatrix.ExecutionAddress{0x8c, 0x1f, 0xf9, 0x78, 0x03, 0x6f, 0x2e, 0x9d, 0x7c, 0xc3, 0x82, 0xef, 0xf7, 0xb4, 0xc8, 0xc5, 0x3c, 0x22, 0xac, 0x15},
+					},
+					Signature: phase0.BLSSignature{0xb7, 0x8a, 0x05, 0xba, 0xd9, 0x27, 0xfc, 0x89, 0x6f, 0x14, 0x06, 0xb3, 0x2d, 0x64, 0x4a, 0xe1, 0x69, 0xce, 0xcd, 0x89, 0x86, 0xc1, 0xef, 0x8c, 0x0d, 0x03, 0x7d, 0x70, 0x86, 0xf8, 0x5f, 0x13, 0xe1, 0xe1, 0x88, 0xb4, 0x30, 0x96, 0x43, 0xa2, 0xc1, 0x3f, 0xfe, 0xfb, 0x0a, 0xe8, 0x05, 0x11, 0x09, 0x98, 0x53, 0xa0, 0x58, 0x1f, 0x4b, 0x2b, 0xd2, 0xe1, 0x45, 0x41, 0x04, 0x79, 0x01, 0xe2, 0x2a, 0x94, 0x0a, 0x9c, 0x7e, 0x3a, 0xc0, 0xa8, 0x82, 0xd1, 0xa8, 0xaf, 0x6b, 0xfa, 0xea, 0x81, 0x3a, 0x6a, 0x6b, 0xe7, 0x21, 0xf9, 0x26, 0x22, 0x04, 0xaa, 0x9d, 0xa4, 0xe4, 0x77, 0x27, 0xd0},
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			err := test.command.generateOperationFromMnemonicAndValidator(ctx)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.expected, test.command.signedOperations)
+			}
+		})
+	}
+}
+
+func TestGenerateOperationFromSeedAndPath(t *testing.T) {
+	ctx := context.Background()
+
+	require.NoError(t, e2types.InitBLS())
+
+	chainInfo := &beacon.ChainInfo{
+		Version: 1,
+		Validators: []*beacon.ValidatorInfo{
+			{
+				Index:                 0,
+				Pubkey:                phase0.BLSPubKey{0xb3, 0x84, 0xf7, 0x67, 0xd9, 0x64, 0xe1, 0x00, 0xc8, 0xa9, 0xb2, 0x10, 0x18, 0xd0, 0x8c, 0x25, 0xff, 0xeb, 0xae, 0x26, 0x8b, 0x3a, 0xb6, 0xd6, 0x10, 0x35, 0x38, 0x97, 0x54, 0x19, 0x71, 0x72, 0x6d, 0xbf, 0xc3, 0xc7, 0x46, 0x38, 0x84, 0xc6, 0x8a, 0x53, 0x15, 0x15, 0xaa, 0xb9, 0x4c, 0x87},
+				WithdrawalCredentials: []byte{0x00, 0x8b, 0xa1, 0xcc, 0x4b, 0x09, 0x1b, 0x91, 0xc1, 0x20, 0x2b, 0xba, 0x3f, 0x50, 0x80, 0x75, 0xd6, 0xff, 0x56, 0x5c, 0x77, 0xe5, 0x59, 0xf0, 0x80, 0x3c, 0x07, 0x92, 0xe0, 0x30, 0x2b, 0xf1},
+			},
+			{
+				Index:                 1,
+				Pubkey:                phase0.BLSPubKey{0xb3, 0xd8, 0x9e, 0x2f, 0x29, 0xc7, 0x12, 0xc6, 0xa9, 0xf8, 0xe5, 0xa2, 0x69, 0xb9, 0x76, 0x17, 0xc4, 0xa9, 0x4d, 0xd6, 0xf6, 0x66, 0x2a, 0xb3, 0xb0, 0x7c, 0xe9, 0xe5, 0x43, 0x45, 0x73, 0xf1, 0x5b, 0x5c, 0x98, 0x8c, 0xd1, 0x4b, 0xbd, 0x58, 0x04, 0xf7, 0x71, 0x56, 0xa8, 0xaf, 0x1c, 0xfa},
+				WithdrawalCredentials: []byte{0x00, 0x78, 0x6c, 0xb0, 0x2e, 0xd2, 0x8e, 0x5f, 0xbb, 0x1f, 0x7f, 0x9e, 0x93, 0x1a, 0x2b, 0x72, 0x69, 0x29, 0x06, 0xe6, 0xb1, 0x2c, 0xe4, 0x64, 0x39, 0x75, 0xe3, 0x2b, 0x51, 0x76, 0x91, 0xf2},
+			},
+			{
+				Index:                 2,
+				Pubkey:                phase0.BLSPubKey{0xaf, 0x9c, 0xe4, 0x4f, 0x50, 0x14, 0x8d, 0xb4, 0x12, 0x19, 0x4a, 0xf0, 0xba, 0xf0, 0xba, 0xb3, 0x6b, 0xd5, 0xc3, 0xe0, 0xc4, 0x93, 0x89, 0x11, 0xa4, 0xe5, 0x02, 0xe3, 0x98, 0xb5, 0x9e, 0x5c, 0xca, 0x7c, 0x78, 0xe3, 0xfe, 0x03, 0x41, 0x95, 0x47, 0x88, 0x79, 0xee, 0xb2, 0x3d, 0xb0, 0xa6},
+				WithdrawalCredentials: []byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x93, 0x1a, 0x2b, 0x72, 0x69, 0x29, 0x06, 0xe6, 0xb1, 0x2c, 0xe4, 0x64, 0x39, 0x75, 0xe3, 0x2b, 0x51, 0x76, 0x91, 0xf2},
+			},
+			{
+				Index:                 3,
+				Pubkey:                phase0.BLSPubKey{0x86, 0xd3, 0x30, 0xaf, 0x51, 0xfa, 0x59, 0x3f, 0xa9, 0xf9, 0x3e, 0xdb, 0x9d, 0x16, 0x64, 0x01, 0x86, 0xbe, 0x2e, 0x93, 0xea, 0x94, 0xd2, 0x59, 0x78, 0x1e, 0x1e, 0xb3, 0x4d, 0xeb, 0x84, 0x4c, 0x39, 0x68, 0xd7, 0x5e, 0xa9, 0x1d, 0x19, 0xf1, 0x59, 0xdb, 0xd0, 0x52, 0x3c, 0x6c, 0x5b, 0xa5},
+				WithdrawalCredentials: []byte{0x00, 0x81, 0x68, 0x45, 0x6b, 0x6d, 0x9a, 0x32, 0x83, 0x93, 0x1f, 0xea, 0x52, 0x10, 0xda, 0x12, 0x2d, 0x1e, 0x65, 0xe8, 0xed, 0x50, 0xb8, 0xe8, 0xf5, 0x91, 0x11, 0x83, 0xb0, 0x2f, 0xd1, 0x25},
+			},
+		},
+		GenesisValidatorsRoot: phase0.Root{},
+		Epoch:                 1,
+		CurrentForkVersion:    phase0.Version{},
+	}
+	validators := make(map[string]*beacon.ValidatorInfo, len(chainInfo.Validators))
+	for i := range chainInfo.Validators {
+		validators[fmt.Sprintf("%#x", chainInfo.Validators[i].Pubkey)] = chainInfo.Validators[i]
+	}
+
+	tests := []struct {
+		name      string
+		command   *command
+		seed      []byte
+		path      string
+		generated bool
+		err       string
+		expected  []*capella.SignedBLSToExecutionChange
+	}{
+		{
+			name: "PathInvalid",
+			command: &command{
+				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",
+				chainInfo:            chainInfo,
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+			seed: []byte{0x40, 0x8b, 0x28, 0x5c, 0x12, 0x38, 0x36, 0x00, 0x4f, 0x4b, 0x88, 0x42, 0xc8, 0x93, 0x24, 0xc1, 0xf0, 0x13, 0x82, 0x45, 0x0c, 0x0d, 0x43, 0x9a, 0xf3, 0x45, 0xba, 0x7f, 0xc4, 0x9a, 0xcf, 0x70, 0x54, 0x89, 0xc6, 0xfc, 0x77, 0xdb, 0xd4, 0xe3, 0xdc, 0x1d, 0xd8, 0xcc, 0x6b, 0xc9, 0xf0, 0x43, 0xdb, 0x8a, 0xda, 0x1e, 0x24, 0x3c, 0x4a, 0x0e, 0xaf, 0xb2, 0x90, 0xd3, 0x99, 0x48, 0x08, 0x40},
+			path: "invalid",
+			err:  "failed to generate validator private key: not master at path component 0",
+		},
+		{
+			name: "ValidatorUnknown",
+			command: &command{
+				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",
+				chainInfo:            chainInfo,
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+			seed: []byte{0x40, 0x8b, 0x28, 0x5c, 0x12, 0x38, 0x36, 0x00, 0x4f, 0x4b, 0x88, 0x42, 0xc8, 0x93, 0x24, 0xc1, 0xf0, 0x13, 0x82, 0x45, 0x0c, 0x0d, 0x43, 0x9a, 0xf3, 0x45, 0xba, 0x7f, 0xc4, 0x9a, 0xcf, 0x70, 0x54, 0x89, 0xc6, 0xfc, 0x77, 0xdb, 0xd4, 0xe3, 0xdc, 0x1d, 0xd8, 0xcc, 0x6b, 0xc9, 0xf0, 0x43, 0xdb, 0x8a, 0xda, 0x1e, 0x24, 0x3c, 0x4a, 0x0e, 0xaf, 0xb2, 0x90, 0xd3, 0x99, 0x48, 0x08, 0x40},
+			path: "m/12381/3600/999/0/0",
+		},
+		{
+			name: "ValidatorCredentialsAlreadySet",
+			command: &command{
+				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",
+				chainInfo:            chainInfo,
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+			seed: []byte{0x40, 0x8b, 0x28, 0x5c, 0x12, 0x38, 0x36, 0x00, 0x4f, 0x4b, 0x88, 0x42, 0xc8, 0x93, 0x24, 0xc1, 0xf0, 0x13, 0x82, 0x45, 0x0c, 0x0d, 0x43, 0x9a, 0xf3, 0x45, 0xba, 0x7f, 0xc4, 0x9a, 0xcf, 0x70, 0x54, 0x89, 0xc6, 0xfc, 0x77, 0xdb, 0xd4, 0xe3, 0xdc, 0x1d, 0xd8, 0xcc, 0x6b, 0xc9, 0xf0, 0x43, 0xdb, 0x8a, 0xda, 0x1e, 0x24, 0x3c, 0x4a, 0x0e, 0xaf, 0xb2, 0x90, 0xd3, 0x99, 0x48, 0x08, 0x40},
+			path: "m/12381/3600/2/0/0",
+		},
+		{
+			name: "PrivateKeyInvalid",
+			command: &command{
+				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",
+				chainInfo:            chainInfo,
+				privateKey:           "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+			seed: []byte{0x40, 0x8b, 0x28, 0x5c, 0x12, 0x38, 0x36, 0x00, 0x4f, 0x4b, 0x88, 0x42, 0xc8, 0x93, 0x24, 0xc1, 0xf0, 0x13, 0x82, 0x45, 0x0c, 0x0d, 0x43, 0x9a, 0xf3, 0x45, 0xba, 0x7f, 0xc4, 0x9a, 0xcf, 0x70, 0x54, 0x89, 0xc6, 0xfc, 0x77, 0xdb, 0xd4, 0xe3, 0xdc, 0x1d, 0xd8, 0xcc, 0x6b, 0xc9, 0xf0, 0x43, 0xdb, 0x8a, 0xda, 0x1e, 0x24, 0x3c, 0x4a, 0x0e, 0xaf, 0xb2, 0x90, 0xd3, 0x99, 0x48, 0x08, 0x40},
+			path: "m/12381/3600/0/0/0",
+			err:  "failed to create account from private key: invalid private key: err blsSecretKeyDeserialize ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+		},
+		{
+			name: "Good",
+			command: &command{
+				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",
+				chainInfo:            chainInfo,
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+			seed:      []byte{0x40, 0x8b, 0x28, 0x5c, 0x12, 0x38, 0x36, 0x00, 0x4f, 0x4b, 0x88, 0x42, 0xc8, 0x93, 0x24, 0xc1, 0xf0, 0x13, 0x82, 0x45, 0x0c, 0x0d, 0x43, 0x9a, 0xf3, 0x45, 0xba, 0x7f, 0xc4, 0x9a, 0xcf, 0x70, 0x54, 0x89, 0xc6, 0xfc, 0x77, 0xdb, 0xd4, 0xe3, 0xdc, 0x1d, 0xd8, 0xcc, 0x6b, 0xc9, 0xf0, 0x43, 0xdb, 0x8a, 0xda, 0x1e, 0x24, 0x3c, 0x4a, 0x0e, 0xaf, 0xb2, 0x90, 0xd3, 0x99, 0x48, 0x08, 0x40},
+			path:      "m/12381/3600/0/0/0",
+			generated: true,
+			expected: []*capella.SignedBLSToExecutionChange{
+				{
+					Message: &capella.BLSToExecutionChange{
+						ValidatorIndex:     0,
+						FromBLSPubkey:      phase0.BLSPubKey{0x99, 0xb1, 0xf1, 0xd8, 0x4d, 0x76, 0x18, 0x54, 0x66, 0xd8, 0x6c, 0x34, 0xbd, 0xe1, 0x10, 0x13, 0x16, 0xaf, 0xdd, 0xae, 0x76, 0x21, 0x7a, 0xa8, 0x6c, 0xd0, 0x66, 0x97, 0x9b, 0x19, 0x85, 0x8c, 0x2c, 0x9d, 0x9e, 0x56, 0xee, 0xbc, 0x1e, 0x06, 0x7a, 0xc5, 0x42, 0x77, 0xa6, 0x17, 0x90, 0xdb},
+						ToExecutionAddress: bellatrix.ExecutionAddress{0x8c, 0x1f, 0xf9, 0x78, 0x03, 0x6f, 0x2e, 0x9d, 0x7c, 0xc3, 0x82, 0xef, 0xf7, 0xb4, 0xc8, 0xc5, 0x3c, 0x22, 0xac, 0x15},
+					},
+					Signature: phase0.BLSSignature{0xb7, 0x8a, 0x05, 0xba, 0xd9, 0x27, 0xfc, 0x89, 0x6f, 0x14, 0x06, 0xb3, 0x2d, 0x64, 0x4a, 0xe1, 0x69, 0xce, 0xcd, 0x89, 0x86, 0xc1, 0xef, 0x8c, 0x0d, 0x03, 0x7d, 0x70, 0x86, 0xf8, 0x5f, 0x13, 0xe1, 0xe1, 0x88, 0xb4, 0x30, 0x96, 0x43, 0xa2, 0xc1, 0x3f, 0xfe, 0xfb, 0x0a, 0xe8, 0x05, 0x11, 0x09, 0x98, 0x53, 0xa0, 0x58, 0x1f, 0x4b, 0x2b, 0xd2, 0xe1, 0x45, 0x41, 0x04, 0x79, 0x01, 0xe2, 0x2a, 0x94, 0x0a, 0x9c, 0x7e, 0x3a, 0xc0, 0xa8, 0x82, 0xd1, 0xa8, 0xaf, 0x6b, 0xfa, 0xea, 0x81, 0x3a, 0x6a, 0x6b, 0xe7, 0x21, 0xf9, 0x26, 0x22, 0x04, 0xaa, 0x9d, 0xa4, 0xe4, 0x77, 0x27, 0xd0},
+				},
+			},
+		},
+		{
+			name: "GoodPrivateKey",
+			command: &command{
+				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",
+				chainInfo:            chainInfo,
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+				privateKey:           "0x67775f030068b4610d6e1bd04948f547305b2502423fcece4c1091d065b44638",
+			},
+			seed:      []byte{0x40, 0x8b, 0x28, 0x5c, 0x12, 0x38, 0x36, 0x00, 0x4f, 0x4b, 0x88, 0x42, 0xc8, 0x93, 0x24, 0xc1, 0xf0, 0x13, 0x82, 0x45, 0x0c, 0x0d, 0x43, 0x9a, 0xf3, 0x45, 0xba, 0x7f, 0xc4, 0x9a, 0xcf, 0x70, 0x54, 0x89, 0xc6, 0xfc, 0x77, 0xdb, 0xd4, 0xe3, 0xdc, 0x1d, 0xd8, 0xcc, 0x6b, 0xc9, 0xf0, 0x43, 0xdb, 0x8a, 0xda, 0x1e, 0x24, 0x3c, 0x4a, 0x0e, 0xaf, 0xb2, 0x90, 0xd3, 0x99, 0x48, 0x08, 0x40},
+			path:      "m/12381/3600/3/0/0",
+			generated: true,
+			expected: []*capella.SignedBLSToExecutionChange{
+				{
+					Message: &capella.BLSToExecutionChange{
+						ValidatorIndex:     3,
+						FromBLSPubkey:      phase0.BLSPubKey{0x86, 0x71, 0x0a, 0xbb, 0x44, 0xb6, 0xcd, 0xa6, 0x66, 0x57, 0x7b, 0xbb, 0x25, 0x5e, 0x16, 0xd9, 0x8b, 0xf2, 0x52, 0x51, 0x76, 0x22, 0x3f, 0x35, 0x35, 0xc7, 0xdf, 0xf8, 0xe7, 0x0b, 0x3b, 0xc8, 0x92, 0xbb, 0x36, 0x11, 0x33, 0x95, 0x2b, 0x03, 0xd2, 0xb0, 0x78, 0xcd, 0x07, 0x18, 0xca, 0xf3},
+						ToExecutionAddress: bellatrix.ExecutionAddress{0x8c, 0x1f, 0xf9, 0x78, 0x03, 0x6f, 0x2e, 0x9d, 0x7c, 0xc3, 0x82, 0xef, 0xf7, 0xb4, 0xc8, 0xc5, 0x3c, 0x22, 0xac, 0x15},
+					},
+					Signature: phase0.BLSSignature{0x8d, 0x92, 0xb9, 0x1c, 0x5d, 0xfd, 0x98, 0xc7, 0x98, 0xfc, 0x94, 0xe1, 0xe6, 0x69, 0xf3, 0xaa, 0xae, 0x72, 0xb2, 0x36, 0x47, 0xde, 0x88, 0x54, 0xea, 0x16, 0x74, 0x7f, 0xfe, 0xf0, 0x4d, 0x46, 0x5c, 0x07, 0x56, 0x34, 0x03, 0x30, 0x2f, 0xbc, 0x26, 0xa2, 0x6d, 0xec, 0x10, 0x20, 0xe7, 0x67, 0x10, 0xb0, 0x4a, 0x7e, 0x4e, 0x25, 0x89, 0x7e, 0x87, 0x88, 0xda, 0xaf, 0x2b, 0xb5, 0xb7, 0x73, 0x25, 0x64, 0x80, 0xc1, 0xba, 0xf3, 0x1d, 0x33, 0x8f, 0x17, 0xa5, 0x35, 0x74, 0x80, 0xf3, 0x37, 0x0e, 0xea, 0x19, 0x15, 0xd5, 0x69, 0x7e, 0xf6, 0x68, 0xaa, 0x9c, 0x3d, 0x47, 0x19, 0x75, 0xfc},
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			generated, err := test.command.generateOperationFromSeedAndPath(ctx, validators, test.seed, test.path)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.generated, generated)
+				if generated {
+					require.Equal(t, test.expected, test.command.signedOperations)
+				}
+			}
+		})
+	}
+}

cmd/validator/exit/chaininfo.go

@@ -0,0 +1,105 @@
+// 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 validatorexit
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/beacon"
+)
+
+// obtainChainInfo obtains the chain information required to create an exit operation.
+func (c *command) obtainChainInfo(ctx context.Context) error {
+	// Use the offline preparation file if present (and we haven't been asked to recreate it).
+	if !c.prepareOffline {
+		err := c.obtainChainInfoFromFile(ctx)
+		if err == nil {
+			return nil
+		}
+	}
+
+	if c.offline {
+		return fmt.Errorf("%s is unavailable or outdated; this is required to have been previously generated using --offline-preparation on an online machine and be readable in the directory in which this command is being run", offlinePreparationFilename)
+	}
+
+	if err := c.obtainChainInfoFromNode(ctx); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// obtainChainInfoFromFile obtains chain information from a pre-generated file.
+func (c *command) obtainChainInfoFromFile(_ context.Context) error {
+	_, err := os.Stat(offlinePreparationFilename)
+	if err != nil {
+		if c.debug {
+			fmt.Fprintf(os.Stderr, "Failed to read offline preparation file: %v\n", err)
+		}
+		return errors.Wrap(err, fmt.Sprintf("cannot find %s", offlinePreparationFilename))
+	}
+
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "%s found; loading chain state\n", offlinePreparationFilename)
+	}
+	data, err := os.ReadFile(offlinePreparationFilename)
+	if err != nil {
+		if c.debug {
+			fmt.Fprintf(os.Stderr, "failed to load chain state: %v\n", err)
+		}
+		return errors.Wrap(err, "failed to read offline preparation file")
+	}
+	c.chainInfo = &beacon.ChainInfo{}
+	if err := json.Unmarshal(data, c.chainInfo); err != nil {
+		if c.debug {
+			fmt.Fprintf(os.Stderr, "chain state invalid: %v\n", err)
+		}
+		return errors.Wrap(err, "failed to parse offline preparation file")
+	}
+
+	return nil
+}
+
+// obtainChainInfoFromNode obtains chain info from a beacon node.
+func (c *command) obtainChainInfoFromNode(ctx context.Context) error {
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Populating chain info from beacon node\n")
+	}
+
+	var err error
+	c.chainInfo, err = beacon.ObtainChainInfoFromNode(ctx, c.consensusClient, c.chainTime)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// writeChainInfoToFile prepares for an offline run of this command by dumping
+// the chain information to a file.
+func (c *command) writeChainInfoToFile(_ context.Context) error {
+	data, err := json.Marshal(c.chainInfo)
+	if err != nil {
+		return err
+	}
+	if err := os.WriteFile(offlinePreparationFilename, data, 0600); err != nil {
+		return err
+	}
+
+	return nil
+}

cmd/validator/exit/command.go

@@ -0,0 +1,97 @@
+// Copyright © 2023 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package validatorexit
+
+import (
+	"context"
+	"time"
+
+	consensusclient "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/beacon"
+	"github.com/wealdtech/ethdo/services/chaintime"
+	"github.com/wealdtech/ethdo/util"
+)
+
+type command struct {
+	quiet   bool
+	verbose bool
+	debug   bool
+	offline bool
+	json    bool
+
+	// Input.
+	passphrases           []string
+	mnemonic              string
+	path                  string
+	privateKey            string
+	validator             string
+	forkVersion           string
+	genesisValidatorsRoot string
+	prepareOffline        bool
+	signedOperationInput  string
+
+	// Beacon node connection.
+	timeout                  time.Duration
+	connection               string
+	allowInsecureConnections bool
+
+	// Information required to generate the operations.
+	chainInfo *beacon.ChainInfo
+	domain    phase0.Domain
+
+	// Processing.
+	consensusClient consensusclient.Service
+	chainTime       chaintime.Service
+
+	// Output.
+	signedOperation *phase0.SignedVoluntaryExit
+}
+
+func newCommand(_ context.Context) (*command, error) {
+	c := &command{
+		quiet:                    viper.GetBool("quiet"),
+		verbose:                  viper.GetBool("verbose"),
+		debug:                    viper.GetBool("debug"),
+		offline:                  viper.GetBool("offline"),
+		json:                     viper.GetBool("json"),
+		timeout:                  viper.GetDuration("timeout"),
+		connection:               viper.GetString("connection"),
+		allowInsecureConnections: viper.GetBool("allow-insecure-connections"),
+		prepareOffline:           viper.GetBool("prepare-offline"),
+		passphrases:              util.GetPassphrases(),
+		mnemonic:                 viper.GetString("mnemonic"),
+		path:                     viper.GetString("path"),
+		privateKey:               viper.GetString("private-key"),
+		signedOperationInput:     viper.GetString("signed-operation"),
+		validator:                viper.GetString("validator"),
+		forkVersion:              viper.GetString("fork-version"),
+		genesisValidatorsRoot:    viper.GetString("genesis-validators-root"),
+	}
+
+	// Timeout is required.
+	if c.timeout == 0 {
+		return nil, errors.New("timeout is required")
+	}
+
+	// We are generating information for offline use, we don't need any information
+	// related to the accounts or signing.
+	if c.prepareOffline {
+		return c, nil
+	}
+
+	return c, nil
+}

cmd/validator/exit/input.go

@@ -1,149 +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 validatorexit
-
-import (
-	"context"
-	"encoding/hex"
-	"encoding/json"
-	"strings"
-	"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/util"
-	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
-)
-
-type dataIn struct {
-	// System.
-	timeout time.Duration
-	quiet   bool
-	verbose bool
-	debug   bool
-	// Operation.
-	eth2Client eth2client.Service
-	jsonOutput bool
-	// Chain information.
-	fork         *spec.Fork
-	currentEpoch spec.Epoch
-	// Exit information.
-	account             e2wtypes.Account
-	passphrases         []string
-	epoch               spec.Epoch
-	domain              spec.Domain
-	signedVoluntaryExit *spec.SignedVoluntaryExit
-}
-
-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.passphrases = util.GetPassphrases()
-	data.jsonOutput = viper.GetBool("json")
-
-	switch {
-	case viper.GetString("exit") != "":
-		return inputJSON(ctx, data)
-	case viper.GetString("account") != "":
-		return inputAccount(ctx, data)
-	case viper.GetString("key") != "":
-		return inputKey(ctx, data)
-	default:
-		return nil, errors.New("must supply account, key, or pre-constructed JSON")
-	}
-}
-
-func inputJSON(ctx context.Context, data *dataIn) (*dataIn, error) {
-	validatorData := &util.ValidatorExitData{}
-	err := json.Unmarshal([]byte(viper.GetString("exit")), validatorData)
-	if err != nil {
-		return nil, err
-	}
-	data.signedVoluntaryExit = validatorData.Exit
-	return inputChainData(ctx, data)
-}
-
-func inputAccount(ctx context.Context, data *dataIn) (*dataIn, error) {
-	var err error
-	_, data.account, err = util.WalletAndAccountFromInput(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to obtain acount")
-	}
-	return inputChainData(ctx, data)
-}
-
-func inputKey(ctx context.Context, data *dataIn) (*dataIn, error) {
-	privKeyBytes, err := hex.DecodeString(strings.TrimPrefix(viper.GetString("key"), "0x"))
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to decode key")
-	}
-	data.account, err = util.NewScratchAccount(privKeyBytes, nil)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to create acount from key")
-	}
-	if err := data.account.(e2wtypes.AccountLocker).Unlock(ctx, nil); err != nil {
-		return nil, errors.Wrap(err, "failed to unlock account")
-	}
-	return inputChainData(ctx, data)
-}
-
-func inputChainData(ctx context.Context, data *dataIn) (*dataIn, error) {
-	var err error
-	data.eth2Client, err = util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to connect to Ethereum 2 beacon node")
-	}
-
-	// Current fork.
-	data.fork, err = data.eth2Client.(eth2client.ForkProvider).Fork(ctx, "head")
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to connect to obtain fork information")
-	}
-
-	// Calculate current epoch.
-	config, err := data.eth2Client.(eth2client.SpecProvider).Spec(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to connect to obtain configuration information")
-	}
-	genesis, err := data.eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to connect to obtain genesis information")
-	}
-	data.currentEpoch = spec.Epoch(uint64(time.Since(genesis.GenesisTime).Seconds()) / (uint64(config["SECONDS_PER_SLOT"].(time.Duration).Seconds()) * config["SLOTS_PER_EPOCH"].(uint64)))
-
-	// Epoch.
-	if viper.GetInt64("epoch") == -1 {
-		data.epoch = data.currentEpoch
-	} else {
-		data.epoch = spec.Epoch(viper.GetUint64("epoch"))
-	}
-
-	// Domain.
-	domain, err := data.eth2Client.(eth2client.DomainProvider).Domain(ctx, config["DOMAIN_VOLUNTARY_EXIT"].(spec.DomainType), data.epoch)
-	if err != nil {
-		return nil, errors.New("failed to calculate domain")
-	}
-	data.domain = domain
-
-	return data, nil
-}

cmd/validator/exit/input_internal_test.go

@@ -1,193 +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 validatorexit
-
-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{}{
-				"account":           "Test wallet",
-				"wallet-passphrase": "ce%NohGhah4ye5ra",
-				"type":              "nd",
-			},
-			err: "timeout is required",
-		},
-		{
-			name: "NoMethod",
-			vars: map[string]interface{}{
-				"timeout": "5s",
-			},
-			err: "must supply account, key, or pre-constructed JSON",
-		},
-		{
-			name: "KeyInvalid",
-			vars: map[string]interface{}{
-				"timeout": "5s",
-				"key":     "0xinvalid",
-			},
-			err: "failed to decode key: encoding/hex: invalid byte: U+0069 'i'",
-		},
-		{
-			name: "KeyBad",
-			vars: map[string]interface{}{
-				"timeout": "5s",
-				"key":     "0x00",
-			},
-			err: "failed to create acount from key: private key must be 32 bytes",
-		},
-		{
-			name: "KeyGood",
-			vars: map[string]interface{}{
-				"connection":                 os.Getenv("ETHDO_TEST_CONNECTION"),
-				"allow-insecure-connections": true,
-				"timeout":                    "5s",
-				"key":                        "0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866",
-			},
-			res: &dataIn{
-				timeout: 5 * time.Second,
-			},
-		},
-		{
-			name: "AccountUnknown",
-			vars: map[string]interface{}{
-				"connection":                 os.Getenv("ETHDO_TEST_CONNECTION"),
-				"allow-insecure-connections": true,
-				"timeout":                    "5s",
-				"account":                    "Test wallet/unknown",
-			},
-			res: &dataIn{
-				timeout: 5 * time.Second,
-			},
-			err: "failed to obtain acount: failed to obtain account: no account with name \"unknown\"",
-		},
-		{
-			name: "AccountGood",
-			vars: map[string]interface{}{
-				"connection":                 os.Getenv("ETHDO_TEST_CONNECTION"),
-				"allow-insecure-connections": true,
-				"timeout":                    "5s",
-				"account":                    "Test wallet/Interop 0",
-			},
-			res: &dataIn{
-				timeout: 5 * time.Second,
-			},
-		},
-		{
-			name: "JSONInvalid",
-			vars: map[string]interface{}{
-				"connection":                 os.Getenv("ETHDO_TEST_CONNECTION"),
-				"allow-insecure-connections": true,
-				"timeout":                    "5s",
-				"exit":                       `invalid`,
-			},
-			res: &dataIn{
-				timeout: 5 * time.Second,
-			},
-			err: "invalid character 'i' looking for beginning of value",
-		},
-		{
-			name: "JSONGood",
-			vars: map[string]interface{}{
-				"connection":                 os.Getenv("ETHDO_TEST_CONNECTION"),
-				"allow-insecure-connections": true,
-				"timeout":                    "5s",
-				"exit":                       `{"exit":{"message":{"epoch":"123","validator_index":"456"},"signature":"0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f"},"fork_version":"0x00002009"}`,
-			},
-			res: &dataIn{
-				timeout: 5 * time.Second,
-			},
-		},
-		{
-			name: "ClientBad",
-			vars: map[string]interface{}{
-				"connection":                 "localhost:1",
-				"allow-insecure-connections": true,
-				"timeout":                    "5s",
-				"key":                        "0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866",
-			},
-			err: "failed to connect to Ethereum 2 beacon node: failed to connect to beacon node: failed to confirm node connection: failed to fetch genesis: failed to request genesis: failed to call GET endpoint: Get \"http://localhost:1/eth/v1/beacon/genesis\": dial tcp 127.0.0.1:1: connect: connection refused",
-		},
-		{
-			name: "EpochProvided",
-			vars: map[string]interface{}{
-				"connection":                 os.Getenv("ETHDO_TEST_CONNECTION"),
-				"allow-insecure-connections": true,
-				"timeout":                    "5s",
-				"key":                        "0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866",
-				"epoch":                      "123",
-			},
-			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/validator/exit/output.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2023 Weald Technology Trading.
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -16,42 +16,35 @@ package validatorexit
 import (
 	"context"
 	"encoding/json"
+	"fmt"
+	"os"
 
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
-	"github.com/wealdtech/ethdo/util"
 )
 
-type dataOut struct {
-	jsonOutput          bool
-	forkVersion         spec.Version
-	signedVoluntaryExit *spec.SignedVoluntaryExit
-}
-
-func output(ctx context.Context, data *dataOut) (string, error) {
-	if data == nil {
-		return "", errors.New("no data")
+//nolint:unparam
+func (c *command) output(_ context.Context) (string, error) {
+	if c.quiet {
+		return "", nil
 	}
 
-	if data.signedVoluntaryExit == nil {
-		return "", errors.New("no signed voluntary exit")
+	if c.prepareOffline {
+		return fmt.Sprintf("%s generated", offlinePreparationFilename), nil
 	}
 
-	if data.jsonOutput {
-		return outputJSON(ctx, data)
+	if c.json || c.offline {
+		data, err := json.Marshal(c.signedOperation)
+		if err != nil {
+			return "", errors.Wrap(err, "failed to marshal signed operation")
+		}
+		if c.json {
+			return string(data), nil
+		}
+		if err := os.WriteFile(exitOperationFilename, data, 0600); err != nil {
+			return "", errors.Wrap(err, fmt.Sprintf("failed to write %s", exitOperationFilename))
+		}
+		return "", nil
 	}
 
 	return "", nil
 }
-
-func outputJSON(ctx context.Context, data *dataOut) (string, error) {
-	validatorExitData := &util.ValidatorExitData{
-		Exit:        data.signedVoluntaryExit,
-		ForkVersion: data.forkVersion,
-	}
-	bytes, err := json.Marshal(validatorExitData)
-	if err != nil {
-		return "", errors.Wrap(err, "failed to generate JSON")
-	}
-	return string(bytes), nil
-}

cmd/validator/exit/output_internal_test.go

@@ -1,97 +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 validatorexit
-
-import (
-	"context"
-	"testing"
-
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
-	"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: "SignedVoluntaryExitNil",
-			dataOut: &dataOut{
-				jsonOutput: true,
-			},
-			err: "no signed voluntary exit",
-		},
-		{
-			name: "Good",
-			dataOut: &dataOut{
-				forkVersion: spec.Version{0x01, 0x02, 0x03, 0x04},
-				signedVoluntaryExit: &spec.SignedVoluntaryExit{
-					Message: &spec.VoluntaryExit{
-						Epoch:          spec.Epoch(123),
-						ValidatorIndex: spec.ValidatorIndex(456),
-					},
-					Signature: spec.BLSSignature{
-						0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-						0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
-						0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
-						0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
-						0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
-						0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
-					},
-				},
-			},
-		},
-		{
-			name: "JSON",
-			dataOut: &dataOut{
-				jsonOutput:  true,
-				forkVersion: spec.Version{0x01, 0x02, 0x03, 0x04},
-				signedVoluntaryExit: &spec.SignedVoluntaryExit{
-					Message: &spec.VoluntaryExit{
-						Epoch:          spec.Epoch(123),
-						ValidatorIndex: spec.ValidatorIndex(456),
-					},
-					Signature: spec.BLSSignature{
-						0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-						0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
-						0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
-						0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
-						0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
-						0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
-					},
-				},
-			},
-			res: `{"exit":{"message":{"epoch":"123","validator_index":"456"},"signature":"0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f"},"fork_version":"0x01020304"}`,
-		},
-	}
-
-	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/validator/exit/process.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2023 Weald Technology Trading.
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -14,120 +14,526 @@
 package validatorexit
 
 import (
+	"bytes"
 	"context"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
 
-	eth2client "github.com/attestantio/go-eth2-client"
-	api "github.com/attestantio/go-eth2-client/api/v1"
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	consensusclient "github.com/attestantio/go-eth2-client"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/go-ssz"
+	"github.com/wealdtech/ethdo/beacon"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
 	"github.com/wealdtech/ethdo/signing"
 	"github.com/wealdtech/ethdo/util"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	ethutil "github.com/wealdtech/go-eth2-util"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
-// maxFutureEpochs is the farthest in the future for which an exit will be created.
-var maxFutureEpochs = spec.Epoch(1024)
+// validatorPath is the regular expression that matches a validator  path.
+var validatorPath = regexp.MustCompile("^m/12381/3600/[0-9]+/0/0$")
 
-func process(ctx context.Context, data *dataIn) (*dataOut, error) {
-	if data == nil {
-		return nil, errors.New("no data")
+var offlinePreparationFilename = "offline-preparation.json"
+var exitOperationFilename = "exit-operation.json"
+
+func (c *command) process(ctx context.Context) error {
+	if err := c.setup(ctx); err != nil {
+		return err
 	}
 
-	if data.epoch > data.currentEpoch {
-		if data.epoch-data.currentEpoch > maxFutureEpochs {
-			return nil, errors.New("not generating exit for an epoch in the far future")
+	if err := c.obtainChainInfo(ctx); err != nil {
+		return err
+	}
+
+	if c.prepareOffline {
+		return c.writeChainInfoToFile(ctx)
+	}
+
+	if err := c.generateDomain(ctx); err != nil {
+		return err
+	}
+
+	if err := c.obtainOperation(ctx); err != nil {
+		return err
+	}
+
+	if validated, reason := c.validateOperation(ctx); !validated {
+		return fmt.Errorf("operation failed validation: %s", reason)
+	}
+
+	if c.json || c.offline {
+		if c.debug {
+			fmt.Fprintf(os.Stderr, "Not broadcasting credentials change operations\n")
+		}
+		// Want JSON output, or cannot broadcast.
+		return nil
+	}
+
+	return c.broadcastOperation(ctx)
+}
+
+func (c *command) obtainOperation(ctx context.Context) error {
+	if (c.mnemonic == "" || c.path == "") && c.privateKey == "" && c.validator == "" {
+		// No input information; fetch the operation from a file.
+		err := c.obtainOperationFromFileOrInput(ctx)
+		if err == nil {
+			// Success.
+			return nil
+		}
+		if c.signedOperationInput != "" {
+			return errors.Wrap(err, "failed to obtain supplied signed operation")
+		}
+		return errors.Wrap(err, fmt.Sprintf("no account, mnemonic or private key specified, and no %s file loaded", exitOperationFilename))
+	}
+
+	if c.mnemonic != "" {
+		switch {
+		case c.path != "":
+			// Have a mnemonic and path.
+			return c.generateOperationFromMnemonicAndPath(ctx)
+		case c.validator != "":
+			// Have a mnemonic and validator.
+			return c.generateOperationFromMnemonicAndValidator(ctx)
+		default:
+			return errors.New("mnemonic must be supplied with either a path or validator")
 		}
 	}
-	results := &dataOut{
-		forkVersion: data.fork.CurrentVersion,
-		jsonOutput:  data.jsonOutput,
+
+	if c.privateKey != "" {
+		return c.generateOperationFromPrivateKey(ctx)
 	}
 
-	validator, err := fetchValidator(ctx, data)
+	if c.validator != "" {
+		return c.generateOperationFromValidator(ctx)
+	}
+
+	return errors.New("unsupported combination of inputs; see help for details of supported combinations")
+}
+
+func (c *command) generateOperationFromMnemonicAndPath(ctx context.Context) error {
+	seed, err := util.SeedFromMnemonic(c.mnemonic)
+	if err != nil {
+		return err
+	}
+
+	// Turn the validators in to a map for easy lookup.
+	validators := make(map[string]*beacon.ValidatorInfo, 0)
+	for _, validator := range c.chainInfo.Validators {
+		validators[fmt.Sprintf("%#x", validator.Pubkey)] = validator
+	}
+
+	validatorKeyPath := c.path
+	match := validatorPath.Match([]byte(c.path))
+	if !match {
+		return fmt.Errorf("path %s does not match EIP-2334 format for a validator", c.path)
+	}
+
+	if err := c.generateOperationFromSeedAndPath(ctx, validators, seed, validatorKeyPath); err != nil {
+		return errors.Wrap(err, "failed to generate operation from seed and path")
+	}
+
+	return nil
+}
+
+func (c *command) generateOperationFromMnemonicAndValidator(ctx context.Context) error {
+	seed, err := util.SeedFromMnemonic(c.mnemonic)
+	if err != nil {
+		return err
+	}
+
+	validatorInfo, err := c.chainInfo.FetchValidatorInfo(ctx, c.validator)
+	if err != nil {
+		return err
+	}
+
+	// Scan the keys from the seed to find the path.
+	maxDistance := 1024
+	// Start scanning the validator keys.
+	for i := 0; ; i++ {
+		if i == maxDistance {
+			if c.debug {
+				fmt.Fprintf(os.Stderr, "Gone %d indices without finding the validator, not scanning any further\n", maxDistance)
+			}
+			break
+		}
+		validatorKeyPath := fmt.Sprintf("m/12381/3600/%d/0/0", i)
+		validatorPrivkey, err := ethutil.PrivateKeyFromSeedAndPath(seed, validatorKeyPath)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate validator private key")
+		}
+		validatorPubkey := validatorPrivkey.PublicKey().Marshal()
+		if bytes.Equal(validatorPubkey, validatorInfo.Pubkey[:]) {
+			validatorAccount, err := util.ParseAccount(ctx, c.mnemonic, []string{validatorKeyPath}, true)
+			if err != nil {
+				return errors.Wrap(err, "failed to create withdrawal account")
+			}
+
+			err = c.generateOperationFromAccount(ctx, validatorInfo, validatorAccount, c.chainInfo.Epoch)
+			if err != nil {
+				return err
+			}
+			break
+		}
+	}
+
+	return nil
+}
+
+func (c *command) generateOperationFromPrivateKey(ctx context.Context) error {
+	validatorAccount, err := util.ParseAccount(ctx, c.privateKey, nil, true)
+	if err != nil {
+		return errors.Wrap(err, "failed to create validator account")
+	}
+
+	validatorPubkey, err := util.BestPublicKey(validatorAccount)
+	if err != nil {
+		return err
+	}
+
+	validatorInfo, err := c.chainInfo.FetchValidatorInfo(ctx, fmt.Sprintf("%#x", validatorPubkey.Marshal()))
+	if err != nil {
+		return err
+	}
+
+	if c.verbose {
+		fmt.Fprintf(os.Stderr, "Validator %d found with public key %s\n", validatorInfo.Index, validatorPubkey)
+	}
+
+	if err = c.generateOperationFromAccount(ctx, validatorInfo, validatorAccount, c.chainInfo.Epoch); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *command) generateOperationFromValidator(ctx context.Context) error {
+	validatorInfo, err := c.chainInfo.FetchValidatorInfo(ctx, c.validator)
+	if err != nil {
+		return err
+	}
+
+	validatorAccount, err := util.ParseAccount(ctx, c.validator, nil, true)
+	if err != nil {
+		return err
+	}
+
+	if err := c.generateOperationFromAccount(ctx, validatorInfo, validatorAccount, c.chainInfo.Epoch); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *command) obtainOperationFromFileOrInput(ctx context.Context) error {
+	// Start off by attempting to use the provided signed operation.
+	if c.signedOperationInput != "" {
+		return c.obtainOperationFromInput(ctx)
+	}
+	// If not, read it from the file with the standard name.
+	return c.obtainOperationFromFile(ctx)
+}
+
+func (c *command) obtainOperationFromFile(ctx context.Context) error {
+	_, err := os.Stat(exitOperationFilename)
+	if err != nil {
+		return errors.Wrap(err, "failed to read exit operation file")
+	}
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "%s found; loading operation\n", exitOperationFilename)
+	}
+	data, err := os.ReadFile(exitOperationFilename)
+	if err != nil {
+		return errors.Wrap(err, "failed to read exit operation file")
+	}
+	if err := json.Unmarshal(data, &c.signedOperation); err != nil {
+		return errors.Wrap(err, "failed to parse exit operation file")
+	}
+
+	if err := c.verifySignedOperation(ctx, c.signedOperation); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *command) obtainOperationFromInput(ctx context.Context) error {
+	if !strings.HasPrefix(c.signedOperationInput, "{") {
+		// This looks like a file; read it in.
+		data, err := os.ReadFile(c.signedOperationInput)
+		if err != nil {
+			return errors.Wrap(err, "failed to read input file")
+		}
+		c.signedOperationInput = string(data)
+	}
+
+	if err := json.Unmarshal([]byte(c.signedOperationInput), &c.signedOperation); err != nil {
+		return errors.Wrap(err, "failed to parse exit operation input")
+	}
+
+	if err := c.verifySignedOperation(ctx, c.signedOperation); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *command) generateOperationFromSeedAndPath(ctx context.Context,
+	validators map[string]*beacon.ValidatorInfo,
+	seed []byte,
+	path string,
+) error {
+	validatorPrivkey, err := ethutil.PrivateKeyFromSeedAndPath(seed, path)
+	if err != nil {
+		return errors.Wrap(err, "failed to generate validator private key")
+	}
+
+	c.privateKey = fmt.Sprintf("%#x", validatorPrivkey.Marshal())
+	return c.generateOperationFromPrivateKey(ctx)
+}
+
+func (c *command) generateOperationFromAccount(ctx context.Context,
+	validator *beacon.ValidatorInfo,
+	account e2wtypes.Account,
+	epoch phase0.Epoch,
+) error {
+	var err error
+	c.signedOperation, err = c.createSignedOperation(ctx, validator, account, epoch)
+	return err
+}
+
+func (c *command) createSignedOperation(ctx context.Context,
+	validator *beacon.ValidatorInfo,
+	account e2wtypes.Account,
+	epoch phase0.Epoch,
+) (
+	*phase0.SignedVoluntaryExit,
+	error,
+) {
+	pubkey, err := util.BestPublicKey(account)
 	if err != nil {
 		return nil, err
 	}
-
-	exit, err := generateExit(ctx, data, validator)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to generate voluntary exit")
-	}
-	root, err := exit.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to generate root for voluntary exit")
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Using %#x as best public key for %s\n", pubkey.Marshal(), account.Name())
 	}
+	blsPubkey := phase0.BLSPubKey{}
+	copy(blsPubkey[:], pubkey.Marshal())
 
-	if data.account != nil {
-		signature, err := signing.SignRoot(ctx, data.account, data.passphrases, root, data.domain)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to sign voluntary exit")
-		}
-
-		results.signedVoluntaryExit = &spec.SignedVoluntaryExit{
-			Message:   exit,
-			Signature: signature,
-		}
-	} else {
-		results.signedVoluntaryExit = data.signedVoluntaryExit
-	}
-
-	if !data.jsonOutput {
-		if err := broadcastExit(ctx, data, results); err != nil {
-			return nil, errors.Wrap(err, "failed to broadcast voluntary exit")
-		}
-	}
-
-	return results, nil
-}
-
-func generateExit(ctx context.Context, data *dataIn, validator *api.Validator) (*spec.VoluntaryExit, error) {
-	if data == nil {
-		return nil, errors.New("no data")
-	}
-
-	if data.signedVoluntaryExit != nil {
-		return data.signedVoluntaryExit.Message, nil
-	}
-
-	if validator == nil {
-		return nil, errors.New("no validator")
-	}
-
-	exit := &spec.VoluntaryExit{
-		Epoch:          data.epoch,
+	operation := &phase0.VoluntaryExit{
+		Epoch:          epoch,
 		ValidatorIndex: validator.Index,
 	}
-	return exit, nil
-}
-
-func broadcastExit(ctx context.Context, data *dataIn, results *dataOut) error {
-	return data.eth2Client.(eth2client.VoluntaryExitSubmitter).SubmitVoluntaryExit(ctx, results.signedVoluntaryExit)
-}
-
-func fetchValidator(ctx context.Context, data *dataIn) (*api.Validator, error) {
-	// Validator.
-	if data.account == nil {
-		return nil, nil
-	}
-
-	var validator *api.Validator
-	validatorPubKeys := make([]spec.BLSPubKey, 1)
-	pubKey, err := util.BestPublicKey(data.account)
+	root, err := operation.HashTreeRoot()
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to obtain public key for account")
+		return nil, errors.Wrap(err, "failed to generate root for exit operation")
 	}
-	copy(validatorPubKeys[0][:], pubKey.Marshal())
-	validators, err := data.eth2Client.(eth2client.ValidatorsProvider).ValidatorsByPubKey(ctx, "head", validatorPubKeys)
+
+	// Sign the operation.
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Signing %#x with domain %#x by public key %#x\n", root, c.domain, account.PublicKey().Marshal())
+	}
+	signature, err := signing.SignRoot(ctx, account, nil, root, c.domain)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to obtain validator from beacon node")
+		return nil, errors.Wrap(err, "failed to sign exit operation")
 	}
-	if len(validators) == 0 {
-		return nil, errors.New("validator not known by beacon node")
-	}
-	for _, v := range validators {
-		validator = v
-	}
-	if validator.Status != api.ValidatorStateActiveOngoing {
-		return nil, errors.New("validator is not active; cannot exit")
-	}
-	return validator, nil
+
+	return &phase0.SignedVoluntaryExit{
+		Message:   operation,
+		Signature: signature,
+	}, nil
+}
+
+func (c *command) verifySignedOperation(ctx context.Context, op *phase0.SignedVoluntaryExit) error {
+	root, err := op.Message.HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "failed to generate message root")
+	}
+
+	sigBytes := make([]byte, len(op.Signature))
+	copy(sigBytes, op.Signature[:])
+	sig, err := e2types.BLSSignatureFromBytes(sigBytes)
+	if err != nil {
+		if c.verbose {
+			fmt.Fprintf(os.Stderr, "Invalid signature: %v\n", err.Error())
+		}
+		return errors.New("invalid signature")
+	}
+
+	container := &phase0.SigningData{
+		ObjectRoot: root,
+		Domain:     c.domain,
+	}
+	signingRoot, err := ssz.HashTreeRoot(container)
+	if err != nil {
+		return errors.Wrap(err, "failed to generate signing root")
+	}
+
+	validatorInfo, err := c.chainInfo.FetchValidatorInfo(ctx, fmt.Sprintf("%d", op.Message.ValidatorIndex))
+	if err != nil {
+		return err
+	}
+
+	pubkeyBytes := make([]byte, len(validatorInfo.Pubkey[:]))
+	copy(pubkeyBytes, validatorInfo.Pubkey[:])
+	pubkey, err := e2types.BLSPublicKeyFromBytes(pubkeyBytes)
+	if err != nil {
+		return errors.Wrap(err, "invalid public key")
+	}
+
+	if !sig.Verify(signingRoot[:], pubkey) {
+		return errors.New("signature does not verify")
+	}
+
+	return nil
+}
+
+func (c *command) validateOperation(_ context.Context,
+) (
+	bool,
+	string,
+) {
+	var validatorInfo *beacon.ValidatorInfo
+	for _, chainValidatorInfo := range c.chainInfo.Validators {
+		if chainValidatorInfo.Index == c.signedOperation.Message.ValidatorIndex {
+			validatorInfo = chainValidatorInfo
+			break
+		}
+	}
+	if validatorInfo == nil {
+		return false, "validator not known on chain"
+	}
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Validator exit operation: %v", c.signedOperation)
+		fmt.Fprintf(os.Stderr, "On-chain validator info: %v\n", validatorInfo)
+	}
+
+	if validatorInfo.State == apiv1.ValidatorStateActiveExiting ||
+		validatorInfo.State == apiv1.ValidatorStateActiveSlashed ||
+		validatorInfo.State == apiv1.ValidatorStateExitedUnslashed ||
+		validatorInfo.State == apiv1.ValidatorStateExitedSlashed ||
+		validatorInfo.State == apiv1.ValidatorStateWithdrawalPossible ||
+		validatorInfo.State == apiv1.ValidatorStateWithdrawalDone {
+		return false, fmt.Sprintf("validator is in state %v, not suitable to generate an exit", validatorInfo.State)
+	}
+
+	return true, ""
+}
+
+func (c *command) broadcastOperation(ctx context.Context) error {
+	return c.consensusClient.(consensusclient.VoluntaryExitSubmitter).SubmitVoluntaryExit(ctx, c.signedOperation)
+}
+
+func (c *command) setup(ctx context.Context) error {
+	if c.offline {
+		return nil
+	}
+
+	// Connect to the consensus node.
+	var err error
+	c.consensusClient, err = util.ConnectToBeaconNode(ctx, c.connection, c.timeout, c.allowInsecureConnections)
+	if err != nil {
+		return errors.Wrap(err, "failed to connect to consensus node")
+	}
+
+	// Set up chaintime.
+	c.chainTime, err = standardchaintime.New(ctx,
+		standardchaintime.WithGenesisTimeProvider(c.consensusClient.(consensusclient.GenesisTimeProvider)),
+		standardchaintime.WithSpecProvider(c.consensusClient.(consensusclient.SpecProvider)),
+	)
+	if err != nil {
+		return errors.Wrap(err, "failed to create chaintime service")
+	}
+
+	return nil
+}
+
+func (c *command) generateDomain(ctx context.Context) error {
+	genesisValidatorsRoot, err := c.obtainGenesisValidatorsRoot(ctx)
+	if err != nil {
+		return err
+	}
+	forkVersion, err := c.obtainForkVersion(ctx)
+	if err != nil {
+		return err
+	}
+
+	root, err := (&phase0.ForkData{
+		CurrentVersion:        forkVersion,
+		GenesisValidatorsRoot: genesisValidatorsRoot,
+	}).HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "failed to calculate signature domain")
+	}
+
+	copy(c.domain[:], c.chainInfo.BLSToExecutionChangeDomainType[:])
+	copy(c.domain[4:], root[:])
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Domain is %#x\n", c.domain)
+	}
+
+	return nil
+}
+
+func (c *command) obtainGenesisValidatorsRoot(ctx context.Context) (phase0.Root, error) {
+	genesisValidatorsRoot := phase0.Root{}
+
+	if c.genesisValidatorsRoot != "" {
+		if c.debug {
+			fmt.Fprintf(os.Stderr, "Genesis validators root supplied on the command line\n")
+		}
+		root, err := hex.DecodeString(strings.TrimPrefix(c.genesisValidatorsRoot, "0x"))
+		if err != nil {
+			return phase0.Root{}, errors.Wrap(err, "invalid genesis validators root supplied")
+		}
+		if len(root) != phase0.RootLength {
+			return phase0.Root{}, errors.New("invalid length for genesis validators root")
+		}
+		copy(genesisValidatorsRoot[:], root)
+	} else {
+		if c.debug {
+			fmt.Fprintf(os.Stderr, "Genesis validators root obtained from chain info\n")
+		}
+		copy(genesisValidatorsRoot[:], c.chainInfo.GenesisValidatorsRoot[:])
+	}
+
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Using genesis validators root %#x\n", genesisValidatorsRoot)
+	}
+	return genesisValidatorsRoot, nil
+}
+
+func (c *command) obtainForkVersion(ctx context.Context) (phase0.Version, error) {
+	forkVersion := phase0.Version{}
+
+	if c.forkVersion != "" {
+		if c.debug {
+			fmt.Fprintf(os.Stderr, "Fork version supplied on the command line\n")
+		}
+		version, err := hex.DecodeString(strings.TrimPrefix(c.forkVersion, "0x"))
+		if err != nil {
+			return phase0.Version{}, errors.Wrap(err, "invalid fork version supplied")
+		}
+		if len(version) != phase0.ForkVersionLength {
+			return phase0.Version{}, errors.New("invalid length for fork version")
+		}
+		copy(forkVersion[:], version)
+	} else {
+		if c.debug {
+			fmt.Fprintf(os.Stderr, "Fork version obtained from chain info\n")
+		}
+		// Use the current fork version for generating an exit as per the spec.
+		copy(forkVersion[:], c.chainInfo.CurrentForkVersion[:])
+	}
+
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Using fork version %#x\n", forkVersion)
+	}
+	return forkVersion, nil
 }

cmd/validator/exit/process_internal_test.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2023 Weald Technology Trading.
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -15,215 +15,467 @@ package validatorexit
 
 import (
 	"context"
-	"os"
+	"fmt"
 	"testing"
-	"time"
 
-	api "github.com/attestantio/go-eth2-client/api/v1"
-	"github.com/attestantio/go-eth2-client/auto"
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
-	"github.com/spf13/viper"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/stretchr/testify/require"
-	"github.com/wealdtech/ethdo/testutil"
+	"github.com/wealdtech/ethdo/beacon"
 	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 TestProcess(t *testing.T) {
-	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
-		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
-	}
+func TestGenerateOperationFromMnemonicAndPath(t *testing.T) {
+	ctx := context.Background()
 
 	require.NoError(t, e2types.InitBLS())
 
-	eth2Client, err := auto.New(context.Background(),
-		auto.WithAddress(os.Getenv("ETHDO_TEST_CONNECTION")),
-	)
-	require.NoError(t, err)
-	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")
-	interop0, err := testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
-		"Interop 0",
-		testutil.HexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
-		[]byte("pass"),
-	)
-	require.NoError(t, err)
-
-	//		activeValidator := &api.Validator{
-	//			Index:   123,
-	//			Balance: 32123456789,
-	//			Status:  api.ValidatorStateActiveOngoing,
-	//			Validator: &spec.Validator{
-	//				PublicKey:                  testutil.HexToPubKey("0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c"),
-	//				WithdrawalCredentials:      nil,
-	//				EffectiveBalance:           32000000000,
-	//				Slashed:                    false,
-	//				ActivationEligibilityEpoch: 0,
-	//				ActivationEpoch:            0,
-	//				ExitEpoch:                  0,
-	//				WithdrawableEpoch:          0,
-	//			},
-	//		}
-
-	epochFork := &spec.Fork{
-		PreviousVersion: spec.Version{0x00, 0x00, 0x00, 0x00},
-		CurrentVersion:  spec.Version{0x00, 0x00, 0x00, 0x00},
-		Epoch:           0,
+	chainInfo := &beacon.ChainInfo{
+		Version: 1,
+		Validators: []*beacon.ValidatorInfo{
+			{
+				Index:                 0,
+				Pubkey:                phase0.BLSPubKey{0xb3, 0x84, 0xf7, 0x67, 0xd9, 0x64, 0xe1, 0x00, 0xc8, 0xa9, 0xb2, 0x10, 0x18, 0xd0, 0x8c, 0x25, 0xff, 0xeb, 0xae, 0x26, 0x8b, 0x3a, 0xb6, 0xd6, 0x10, 0x35, 0x38, 0x97, 0x54, 0x19, 0x71, 0x72, 0x6d, 0xbf, 0xc3, 0xc7, 0x46, 0x38, 0x84, 0xc6, 0x8a, 0x53, 0x15, 0x15, 0xaa, 0xb9, 0x4c, 0x87},
+				WithdrawalCredentials: []byte{0x00, 0x8b, 0xa1, 0xcc, 0x4b, 0x09, 0x1b, 0x91, 0xc1, 0x20, 0x2b, 0xba, 0x3f, 0x50, 0x80, 0x75, 0xd6, 0xff, 0x56, 0x5c, 0x77, 0xe5, 0x59, 0xf0, 0x80, 0x3c, 0x07, 0x92, 0xe0, 0x30, 0x2b, 0xf1},
+			},
+			{
+				Index:                 1,
+				Pubkey:                phase0.BLSPubKey{0xb3, 0xd8, 0x9e, 0x2f, 0x29, 0xc7, 0x12, 0xc6, 0xa9, 0xf8, 0xe5, 0xa2, 0x69, 0xb9, 0x76, 0x17, 0xc4, 0xa9, 0x4d, 0xd6, 0xf6, 0x66, 0x2a, 0xb3, 0xb0, 0x7c, 0xe9, 0xe5, 0x43, 0x45, 0x73, 0xf1, 0x5b, 0x5c, 0x98, 0x8c, 0xd1, 0x4b, 0xbd, 0x58, 0x04, 0xf7, 0x71, 0x56, 0xa8, 0xaf, 0x1c, 0xfa},
+				WithdrawalCredentials: []byte{0x00, 0x78, 0x6c, 0xb0, 0x2e, 0xd2, 0x8e, 0x5f, 0xbb, 0x1f, 0x7f, 0x9e, 0x93, 0x1a, 0x2b, 0x72, 0x69, 0x29, 0x06, 0xe6, 0xb1, 0x2c, 0xe4, 0x64, 0x39, 0x75, 0xe3, 0x2b, 0x51, 0x76, 0x91, 0xf2},
+			},
+		},
+		GenesisValidatorsRoot: phase0.Root{},
+		Epoch:                 1,
+		CurrentForkVersion:    phase0.Version{},
 	}
 
 	tests := []struct {
-		name   string
-		dataIn *dataIn
-		err    string
+		name     string
+		command  *command
+		expected *phase0.SignedVoluntaryExit
+		err      string
 	}{
 		{
-			name: "Nil",
-			err:  "no data",
-		},
-		{
-			name: "EpochTooLate",
-			dataIn: &dataIn{
-				timeout:      5 * time.Second,
-				eth2Client:   eth2Client,
-				fork:         epochFork,
-				currentEpoch: 10,
-				account:      interop0,
-				passphrases:  []string{"pass"},
-				epoch:        9999999,
-				domain:       spec.Domain{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f},
+			name: "MnemonicInvalid",
+			command: &command{
+				mnemonic:  "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon",
+				path:      "m/12381/3600/0/0/0",
+				chainInfo: chainInfo,
 			},
-			err: "not generating exit for an epoch in the far future",
+			err: "mnemonic is invalid",
 		},
 		{
-			name: "AccountUnknown",
-			dataIn: &dataIn{
-				timeout:      5 * time.Second,
-				eth2Client:   eth2Client,
-				fork:         epochFork,
-				currentEpoch: 10,
-				account:      interop0,
-				passphrases:  []string{"pass"},
-				epoch:        10,
-				domain:       spec.Domain{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f},
+			name: "PathInvalid",
+			command: &command{
+				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",
+				chainInfo: chainInfo,
 			},
-			err: "validator not known by beacon node",
-		},
-		// {
-		// 	name: "Good",
-		// 	dataIn: &dataIn{
-		// 		timeout:      5 * time.Second,
-		// 		eth2Client:   eth2Client,
-		// 		fork:         epochFork,
-		// 		currentEpoch: 10,
-		// 		account:      interop0,
-		// 		passphrases:  []string{"pass"},
-		// 		epoch:        10,
-		// 		domain:       spec.Domain{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f},
-		// 	},
-		// },
-	}
-
-	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)
-			}
-		})
-	}
-}
-
-func TestGenerateExit(t *testing.T) {
-	activeValidator := &api.Validator{
-		Index:   123,
-		Balance: 32123456789,
-		Status:  api.ValidatorStateActiveOngoing,
-		Validator: &spec.Validator{
-			PublicKey:                  testutil.HexToPubKey("0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c"),
-			WithdrawalCredentials:      nil,
-			EffectiveBalance:           32000000000,
-			Slashed:                    false,
-			ActivationEligibilityEpoch: 0,
-			ActivationEpoch:            0,
-			ExitEpoch:                  0,
-			WithdrawableEpoch:          0,
-		},
-	}
-
-	tests := []struct {
-		name      string
-		validator *api.Validator
-		dataIn    *dataIn
-		err       string
-	}{
-		{
-			name: "Nil",
-			err:  "no data",
-		},
-		{
-			name: "SignedVoluntaryExitGood",
-			dataIn: &dataIn{
-				signedVoluntaryExit: &spec.SignedVoluntaryExit{
-					Message: &spec.VoluntaryExit{
-						Epoch:          spec.Epoch(123),
-						ValidatorIndex: spec.ValidatorIndex(456),
-					},
-					Signature: spec.BLSSignature{
-						0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-						0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
-						0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
-						0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
-						0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
-						0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
-					},
-				},
-			},
-		},
-		{
-			name:   "ValidatorMissing",
-			dataIn: &dataIn{},
-			err:    "no validator",
-		},
-		{
-			name:      "ValidatorGood",
-			dataIn:    &dataIn{},
-			validator: activeValidator,
+			err: "path m/12381/3600/0/0 does not match EIP-2334 format for a validator",
 		},
 		{
 			name: "Good",
-			dataIn: &dataIn{
-				signedVoluntaryExit: &spec.SignedVoluntaryExit{
-					Message: &spec.VoluntaryExit{
-						Epoch:          spec.Epoch(123),
-						ValidatorIndex: spec.ValidatorIndex(456),
-					},
-					Signature: spec.BLSSignature{
-						0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-						0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
-						0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
-						0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
-						0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
-						0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
-					},
-				},
+			command: &command{
+				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/0",
+				chainInfo: chainInfo,
+			},
+			expected: &phase0.SignedVoluntaryExit{
+				Message: &phase0.VoluntaryExit{
+					Epoch:          1,
+					ValidatorIndex: 0,
+				},
+				Signature: phase0.BLSSignature{0x89, 0xf5, 0xc4, 0x42, 0x88, 0xf9, 0x5e, 0x19, 0xb6, 0xc1, 0x39, 0xf2, 0x62, 0x30, 0x05, 0x66, 0x5b, 0x98, 0x34, 0x62, 0xa2, 0x28, 0x12, 0x09, 0x77, 0xd8, 0x1f, 0x2e, 0xf5, 0x47, 0x56, 0x0b, 0xe2, 0x24, 0x46, 0xde, 0x21, 0xa8, 0xa9, 0x37, 0xd9, 0xdd, 0xa4, 0xe2, 0xd2, 0xec, 0x41, 0x75, 0x19, 0x64, 0x96, 0xcd, 0xd1, 0x30, 0x6d, 0xec, 0x4a, 0x12, 0x5f, 0x8c, 0x86, 0x1f, 0x80, 0x61, 0x71, 0x50, 0x4a, 0x9d, 0x6a, 0x61, 0x0e, 0xc4, 0xe1, 0x35, 0x04, 0x7e, 0x4f, 0xb6, 0x70, 0x52, 0xec, 0xc4, 0x56, 0x13, 0x60, 0xd0, 0xc3, 0xde, 0x04, 0xb6, 0xfb, 0xc4, 0x47, 0x42, 0x23, 0xff},
 			},
-			validator: activeValidator,
 		},
 	}
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			_, err := generateExit(context.Background(), test.dataIn, test.validator)
+			err := test.command.generateOperationFromMnemonicAndPath(ctx)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.expected, test.command.signedOperation)
+			}
+		})
+	}
+}
+
+func TestGenerateOperationFromMnemonicAndValidator(t *testing.T) {
+	ctx := context.Background()
+
+	require.NoError(t, e2types.InitBLS())
+
+	chainInfo := &beacon.ChainInfo{
+		Version: 1,
+		Validators: []*beacon.ValidatorInfo{
+			{
+				Index:                 0,
+				Pubkey:                phase0.BLSPubKey{0xb3, 0x84, 0xf7, 0x67, 0xd9, 0x64, 0xe1, 0x00, 0xc8, 0xa9, 0xb2, 0x10, 0x18, 0xd0, 0x8c, 0x25, 0xff, 0xeb, 0xae, 0x26, 0x8b, 0x3a, 0xb6, 0xd6, 0x10, 0x35, 0x38, 0x97, 0x54, 0x19, 0x71, 0x72, 0x6d, 0xbf, 0xc3, 0xc7, 0x46, 0x38, 0x84, 0xc6, 0x8a, 0x53, 0x15, 0x15, 0xaa, 0xb9, 0x4c, 0x87},
+				WithdrawalCredentials: []byte{0x00, 0x8b, 0xa1, 0xcc, 0x4b, 0x09, 0x1b, 0x91, 0xc1, 0x20, 0x2b, 0xba, 0x3f, 0x50, 0x80, 0x75, 0xd6, 0xff, 0x56, 0x5c, 0x77, 0xe5, 0x59, 0xf0, 0x80, 0x3c, 0x07, 0x92, 0xe0, 0x30, 0x2b, 0xf1},
+			},
+			{
+				Index:                 1,
+				Pubkey:                phase0.BLSPubKey{0xb3, 0xd8, 0x9e, 0x2f, 0x29, 0xc7, 0x12, 0xc6, 0xa9, 0xf8, 0xe5, 0xa2, 0x69, 0xb9, 0x76, 0x17, 0xc4, 0xa9, 0x4d, 0xd6, 0xf6, 0x66, 0x2a, 0xb3, 0xb0, 0x7c, 0xe9, 0xe5, 0x43, 0x45, 0x73, 0xf1, 0x5b, 0x5c, 0x98, 0x8c, 0xd1, 0x4b, 0xbd, 0x58, 0x04, 0xf7, 0x71, 0x56, 0xa8, 0xaf, 0x1c, 0xfa},
+				WithdrawalCredentials: []byte{0x00, 0x78, 0x6c, 0xb0, 0x2e, 0xd2, 0x8e, 0x5f, 0xbb, 0x1f, 0x7f, 0x9e, 0x93, 0x1a, 0x2b, 0x72, 0x69, 0x29, 0x06, 0xe6, 0xb1, 0x2c, 0xe4, 0x64, 0x39, 0x75, 0xe3, 0x2b, 0x51, 0x76, 0x91, 0xf2},
+			},
+		},
+		GenesisValidatorsRoot: phase0.Root{},
+		Epoch:                 1,
+		CurrentForkVersion:    phase0.Version{},
+	}
+
+	tests := []struct {
+		name     string
+		command  *command
+		expected *phase0.SignedVoluntaryExit
+		err      string
+	}{
+		{
+			name: "MnemonicInvalid",
+			command: &command{
+				mnemonic:  "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon",
+				validator: "0",
+				chainInfo: chainInfo,
+			},
+			err: "mnemonic is invalid",
+		},
+		{
+			name: "ValidatorMissing",
+			command: &command{
+				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",
+				chainInfo: chainInfo,
+			},
+			err: "no validator specified",
+		},
+		{
+			name: "Good",
+			command: &command{
+				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",
+				validator: "0",
+				chainInfo: chainInfo,
+			},
+			expected: &phase0.SignedVoluntaryExit{
+				Message: &phase0.VoluntaryExit{
+					Epoch:          1,
+					ValidatorIndex: 0,
+				},
+				Signature: phase0.BLSSignature{0x89, 0xf5, 0xc4, 0x42, 0x88, 0xf9, 0x5e, 0x19, 0xb6, 0xc1, 0x39, 0xf2, 0x62, 0x30, 0x05, 0x66, 0x5b, 0x98, 0x34, 0x62, 0xa2, 0x28, 0x12, 0x09, 0x77, 0xd8, 0x1f, 0x2e, 0xf5, 0x47, 0x56, 0x0b, 0xe2, 0x24, 0x46, 0xde, 0x21, 0xa8, 0xa9, 0x37, 0xd9, 0xdd, 0xa4, 0xe2, 0xd2, 0xec, 0x41, 0x75, 0x19, 0x64, 0x96, 0xcd, 0xd1, 0x30, 0x6d, 0xec, 0x4a, 0x12, 0x5f, 0x8c, 0x86, 0x1f, 0x80, 0x61, 0x71, 0x50, 0x4a, 0x9d, 0x6a, 0x61, 0x0e, 0xc4, 0xe1, 0x35, 0x04, 0x7e, 0x4f, 0xb6, 0x70, 0x52, 0xec, 0xc4, 0x56, 0x13, 0x60, 0xd0, 0xc3, 0xde, 0x04, 0xb6, 0xfb, 0xc4, 0x47, 0x42, 0x23, 0xff},
+			},
+		},
+		{
+			name: "GoodPubkey",
+			command: &command{
+				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",
+				validator: "0xb384f767d964e100c8a9b21018d08c25ffebae268b3ab6d610353897541971726dbfc3c7463884c68a531515aab94c87",
+				chainInfo: chainInfo,
+			},
+			expected: &phase0.SignedVoluntaryExit{
+				Message: &phase0.VoluntaryExit{
+					Epoch:          1,
+					ValidatorIndex: 0,
+				},
+				Signature: phase0.BLSSignature{0x89, 0xf5, 0xc4, 0x42, 0x88, 0xf9, 0x5e, 0x19, 0xb6, 0xc1, 0x39, 0xf2, 0x62, 0x30, 0x05, 0x66, 0x5b, 0x98, 0x34, 0x62, 0xa2, 0x28, 0x12, 0x09, 0x77, 0xd8, 0x1f, 0x2e, 0xf5, 0x47, 0x56, 0x0b, 0xe2, 0x24, 0x46, 0xde, 0x21, 0xa8, 0xa9, 0x37, 0xd9, 0xdd, 0xa4, 0xe2, 0xd2, 0xec, 0x41, 0x75, 0x19, 0x64, 0x96, 0xcd, 0xd1, 0x30, 0x6d, 0xec, 0x4a, 0x12, 0x5f, 0x8c, 0x86, 0x1f, 0x80, 0x61, 0x71, 0x50, 0x4a, 0x9d, 0x6a, 0x61, 0x0e, 0xc4, 0xe1, 0x35, 0x04, 0x7e, 0x4f, 0xb6, 0x70, 0x52, 0xec, 0xc4, 0x56, 0x13, 0x60, 0xd0, 0xc3, 0xde, 0x04, 0xb6, 0xfb, 0xc4, 0x47, 0x42, 0x23, 0xff},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			err := test.command.generateOperationFromMnemonicAndValidator(ctx)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.expected, test.command.signedOperation)
+			}
+		})
+	}
+}
+
+func TestGenerateOperationFromSeedAndPath(t *testing.T) {
+	ctx := context.Background()
+
+	require.NoError(t, e2types.InitBLS())
+
+	chainInfo := &beacon.ChainInfo{
+		Version: 1,
+		Validators: []*beacon.ValidatorInfo{
+			{
+				Index:                 0,
+				Pubkey:                phase0.BLSPubKey{0xb3, 0x84, 0xf7, 0x67, 0xd9, 0x64, 0xe1, 0x00, 0xc8, 0xa9, 0xb2, 0x10, 0x18, 0xd0, 0x8c, 0x25, 0xff, 0xeb, 0xae, 0x26, 0x8b, 0x3a, 0xb6, 0xd6, 0x10, 0x35, 0x38, 0x97, 0x54, 0x19, 0x71, 0x72, 0x6d, 0xbf, 0xc3, 0xc7, 0x46, 0x38, 0x84, 0xc6, 0x8a, 0x53, 0x15, 0x15, 0xaa, 0xb9, 0x4c, 0x87},
+				WithdrawalCredentials: []byte{0x00, 0x8b, 0xa1, 0xcc, 0x4b, 0x09, 0x1b, 0x91, 0xc1, 0x20, 0x2b, 0xba, 0x3f, 0x50, 0x80, 0x75, 0xd6, 0xff, 0x56, 0x5c, 0x77, 0xe5, 0x59, 0xf0, 0x80, 0x3c, 0x07, 0x92, 0xe0, 0x30, 0x2b, 0xf1},
+			},
+			{
+				Index:                 1,
+				Pubkey:                phase0.BLSPubKey{0xb3, 0xd8, 0x9e, 0x2f, 0x29, 0xc7, 0x12, 0xc6, 0xa9, 0xf8, 0xe5, 0xa2, 0x69, 0xb9, 0x76, 0x17, 0xc4, 0xa9, 0x4d, 0xd6, 0xf6, 0x66, 0x2a, 0xb3, 0xb0, 0x7c, 0xe9, 0xe5, 0x43, 0x45, 0x73, 0xf1, 0x5b, 0x5c, 0x98, 0x8c, 0xd1, 0x4b, 0xbd, 0x58, 0x04, 0xf7, 0x71, 0x56, 0xa8, 0xaf, 0x1c, 0xfa},
+				WithdrawalCredentials: []byte{0x00, 0x78, 0x6c, 0xb0, 0x2e, 0xd2, 0x8e, 0x5f, 0xbb, 0x1f, 0x7f, 0x9e, 0x93, 0x1a, 0x2b, 0x72, 0x69, 0x29, 0x06, 0xe6, 0xb1, 0x2c, 0xe4, 0x64, 0x39, 0x75, 0xe3, 0x2b, 0x51, 0x76, 0x91, 0xf2},
+			},
+			{
+				Index:                 2,
+				Pubkey:                phase0.BLSPubKey{0xaf, 0x9c, 0xe4, 0x4f, 0x50, 0x14, 0x8d, 0xb4, 0x12, 0x19, 0x4a, 0xf0, 0xba, 0xf0, 0xba, 0xb3, 0x6b, 0xd5, 0xc3, 0xe0, 0xc4, 0x93, 0x89, 0x11, 0xa4, 0xe5, 0x02, 0xe3, 0x98, 0xb5, 0x9e, 0x5c, 0xca, 0x7c, 0x78, 0xe3, 0xfe, 0x03, 0x41, 0x95, 0x47, 0x88, 0x79, 0xee, 0xb2, 0x3d, 0xb0, 0xa6},
+				WithdrawalCredentials: []byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x93, 0x1a, 0x2b, 0x72, 0x69, 0x29, 0x06, 0xe6, 0xb1, 0x2c, 0xe4, 0x64, 0x39, 0x75, 0xe3, 0x2b, 0x51, 0x76, 0x91, 0xf2},
+			},
+			{
+				Index:                 3,
+				Pubkey:                phase0.BLSPubKey{0x86, 0xd3, 0x30, 0xaf, 0x51, 0xfa, 0x59, 0x3f, 0xa9, 0xf9, 0x3e, 0xdb, 0x9d, 0x16, 0x64, 0x01, 0x86, 0xbe, 0x2e, 0x93, 0xea, 0x94, 0xd2, 0x59, 0x78, 0x1e, 0x1e, 0xb3, 0x4d, 0xeb, 0x84, 0x4c, 0x39, 0x68, 0xd7, 0x5e, 0xa9, 0x1d, 0x19, 0xf1, 0x59, 0xdb, 0xd0, 0x52, 0x3c, 0x6c, 0x5b, 0xa5},
+				WithdrawalCredentials: []byte{0x00, 0x81, 0x68, 0x45, 0x6b, 0x6d, 0x9a, 0x32, 0x83, 0x93, 0x1f, 0xea, 0x52, 0x10, 0xda, 0x12, 0x2d, 0x1e, 0x65, 0xe8, 0xed, 0x50, 0xb8, 0xe8, 0xf5, 0x91, 0x11, 0x83, 0xb0, 0x2f, 0xd1, 0x25},
+			},
+		},
+		GenesisValidatorsRoot: phase0.Root{},
+		Epoch:                 1,
+		CurrentForkVersion:    phase0.Version{},
+	}
+	validators := make(map[string]*beacon.ValidatorInfo, len(chainInfo.Validators))
+	for i := range chainInfo.Validators {
+		validators[fmt.Sprintf("%#x", chainInfo.Validators[i].Pubkey)] = chainInfo.Validators[i]
+	}
+
+	tests := []struct {
+		name     string
+		command  *command
+		seed     []byte
+		path     string
+		err      string
+		expected *phase0.SignedVoluntaryExit
+	}{
+		{
+			name: "PathInvalid",
+			command: &command{
+				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",
+				chainInfo: chainInfo,
+			},
+			seed: []byte{0x40, 0x8b, 0x28, 0x5c, 0x12, 0x38, 0x36, 0x00, 0x4f, 0x4b, 0x88, 0x42, 0xc8, 0x93, 0x24, 0xc1, 0xf0, 0x13, 0x82, 0x45, 0x0c, 0x0d, 0x43, 0x9a, 0xf3, 0x45, 0xba, 0x7f, 0xc4, 0x9a, 0xcf, 0x70, 0x54, 0x89, 0xc6, 0xfc, 0x77, 0xdb, 0xd4, 0xe3, 0xdc, 0x1d, 0xd8, 0xcc, 0x6b, 0xc9, 0xf0, 0x43, 0xdb, 0x8a, 0xda, 0x1e, 0x24, 0x3c, 0x4a, 0x0e, 0xaf, 0xb2, 0x90, 0xd3, 0x99, 0x48, 0x08, 0x40},
+			path: "invalid",
+			err:  "failed to generate validator private key: not master at path component 0",
+		},
+		{
+			name: "ValidatorUnknown",
+			command: &command{
+				chainInfo: chainInfo,
+			},
+			seed: []byte{0x40, 0x8b, 0x28, 0x5c, 0x12, 0x38, 0x36, 0x00, 0x4f, 0x4b, 0x88, 0x42, 0xc8, 0x93, 0x24, 0xc1, 0xf0, 0x13, 0x82, 0x45, 0x0c, 0x0d, 0x43, 0x9a, 0xf3, 0x45, 0xba, 0x7f, 0xc4, 0x9a, 0xcf, 0x70, 0x54, 0x89, 0xc6, 0xfc, 0x77, 0xdb, 0xd4, 0xe3, 0xdc, 0x1d, 0xd8, 0xcc, 0x6b, 0xc9, 0xf0, 0x43, 0xdb, 0x8a, 0xda, 0x1e, 0x24, 0x3c, 0x4a, 0x0e, 0xaf, 0xb2, 0x90, 0xd3, 0x99, 0x48, 0x08, 0x40},
+			path: "m/12381/3600/999/0/0",
+			err:  "unknown validator",
+		},
+		//		{
+		//			name: "ValidatorAlreadyExited",
+		//			command: &command{
+		//				chainInfo: chainInfo,
+		//			},
+		//			seed: []byte{0x40, 0x8b, 0x28, 0x5c, 0x12, 0x38, 0x36, 0x00, 0x4f, 0x4b, 0x88, 0x42, 0xc8, 0x93, 0x24, 0xc1, 0xf0, 0x13, 0x82, 0x45, 0x0c, 0x0d, 0x43, 0x9a, 0xf3, 0x45, 0xba, 0x7f, 0xc4, 0x9a, 0xcf, 0x70, 0x54, 0x89, 0xc6, 0xfc, 0x77, 0xdb, 0xd4, 0xe3, 0xdc, 0x1d, 0xd8, 0xcc, 0x6b, 0xc9, 0xf0, 0x43, 0xdb, 0x8a, 0xda, 0x1e, 0x24, 0x3c, 0x4a, 0x0e, 0xaf, 0xb2, 0x90, 0xd3, 0x99, 0x48, 0x08, 0x40},
+		//			path: "m/12381/3600/2/0/0",
+		//		},
+		{
+			name: "GoodPath0",
+			command: &command{
+				chainInfo: chainInfo,
+			},
+			seed: []byte{0x40, 0x8b, 0x28, 0x5c, 0x12, 0x38, 0x36, 0x00, 0x4f, 0x4b, 0x88, 0x42, 0xc8, 0x93, 0x24, 0xc1, 0xf0, 0x13, 0x82, 0x45, 0x0c, 0x0d, 0x43, 0x9a, 0xf3, 0x45, 0xba, 0x7f, 0xc4, 0x9a, 0xcf, 0x70, 0x54, 0x89, 0xc6, 0xfc, 0x77, 0xdb, 0xd4, 0xe3, 0xdc, 0x1d, 0xd8, 0xcc, 0x6b, 0xc9, 0xf0, 0x43, 0xdb, 0x8a, 0xda, 0x1e, 0x24, 0x3c, 0x4a, 0x0e, 0xaf, 0xb2, 0x90, 0xd3, 0x99, 0x48, 0x08, 0x40},
+			path: "m/12381/3600/0/0/0",
+			expected: &phase0.SignedVoluntaryExit{
+				Message: &phase0.VoluntaryExit{
+					Epoch:          1,
+					ValidatorIndex: 0,
+				},
+				Signature: phase0.BLSSignature{0x89, 0xf5, 0xc4, 0x42, 0x88, 0xf9, 0x5e, 0x19, 0xb6, 0xc1, 0x39, 0xf2, 0x62, 0x30, 0x05, 0x66, 0x5b, 0x98, 0x34, 0x62, 0xa2, 0x28, 0x12, 0x09, 0x77, 0xd8, 0x1f, 0x2e, 0xf5, 0x47, 0x56, 0x0b, 0xe2, 0x24, 0x46, 0xde, 0x21, 0xa8, 0xa9, 0x37, 0xd9, 0xdd, 0xa4, 0xe2, 0xd2, 0xec, 0x41, 0x75, 0x19, 0x64, 0x96, 0xcd, 0xd1, 0x30, 0x6d, 0xec, 0x4a, 0x12, 0x5f, 0x8c, 0x86, 0x1f, 0x80, 0x61, 0x71, 0x50, 0x4a, 0x9d, 0x6a, 0x61, 0x0e, 0xc4, 0xe1, 0x35, 0x04, 0x7e, 0x4f, 0xb6, 0x70, 0x52, 0xec, 0xc4, 0x56, 0x13, 0x60, 0xd0, 0xc3, 0xde, 0x04, 0xb6, 0xfb, 0xc4, 0x47, 0x42, 0x23, 0xff},
+			},
+		},
+		{
+			name: "GoodPath3",
+			command: &command{
+				chainInfo: chainInfo,
+			},
+			seed: []byte{0x40, 0x8b, 0x28, 0x5c, 0x12, 0x38, 0x36, 0x00, 0x4f, 0x4b, 0x88, 0x42, 0xc8, 0x93, 0x24, 0xc1, 0xf0, 0x13, 0x82, 0x45, 0x0c, 0x0d, 0x43, 0x9a, 0xf3, 0x45, 0xba, 0x7f, 0xc4, 0x9a, 0xcf, 0x70, 0x54, 0x89, 0xc6, 0xfc, 0x77, 0xdb, 0xd4, 0xe3, 0xdc, 0x1d, 0xd8, 0xcc, 0x6b, 0xc9, 0xf0, 0x43, 0xdb, 0x8a, 0xda, 0x1e, 0x24, 0x3c, 0x4a, 0x0e, 0xaf, 0xb2, 0x90, 0xd3, 0x99, 0x48, 0x08, 0x40},
+			path: "m/12381/3600/3/0/0",
+			expected: &phase0.SignedVoluntaryExit{
+				Message: &phase0.VoluntaryExit{
+					Epoch:          1,
+					ValidatorIndex: 3,
+				},
+				Signature: phase0.BLSSignature{0x99, 0x78, 0xb4, 0x9c, 0x21, 0x60, 0x3f, 0x04, 0xa3, 0x04, 0x4e, 0x4c, 0x49, 0x0c, 0xb4, 0x68, 0x7c, 0x6e, 0x14, 0xc2, 0xda, 0xed, 0x25, 0x92, 0xe0, 0x02, 0x2d, 0xcd, 0x63, 0xeb, 0xe7, 0x4a, 0xf1, 0x1a, 0xca, 0xba, 0xae, 0x50, 0xe1, 0x8a, 0x1d, 0xae, 0x96, 0xd9, 0xd2, 0x56, 0xbf, 0x9f, 0x02, 0x48, 0x85, 0x05, 0xc1, 0xfb, 0xb3, 0x4a, 0x0b, 0x68, 0xec, 0xc5, 0xb5, 0xf5, 0xea, 0x53, 0xdb, 0xd0, 0x09, 0x08, 0xe3, 0x1e, 0xa8, 0xca, 0x9d, 0x02, 0x08, 0x3b, 0x9e, 0xf1, 0xc7, 0xd2, 0x32, 0xf4, 0xba, 0xd9, 0xea, 0x56, 0x4b, 0xc5, 0x87, 0xd5, 0x27, 0xb7, 0x74, 0x97, 0x8a, 0xee},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			err := test.command.generateOperationFromSeedAndPath(ctx, validators, test.seed, test.path)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.expected, test.command.signedOperation)
+			}
+		})
+	}
+}
+
+func TestVerifyOperation(t *testing.T) {
+	ctx := context.Background()
+
+	require.NoError(t, e2types.InitBLS())
+
+	chainInfo := &beacon.ChainInfo{
+		Version: 1,
+		Validators: []*beacon.ValidatorInfo{
+			{
+				Index:                 0,
+				Pubkey:                phase0.BLSPubKey{0xb3, 0x84, 0xf7, 0x67, 0xd9, 0x64, 0xe1, 0x00, 0xc8, 0xa9, 0xb2, 0x10, 0x18, 0xd0, 0x8c, 0x25, 0xff, 0xeb, 0xae, 0x26, 0x8b, 0x3a, 0xb6, 0xd6, 0x10, 0x35, 0x38, 0x97, 0x54, 0x19, 0x71, 0x72, 0x6d, 0xbf, 0xc3, 0xc7, 0x46, 0x38, 0x84, 0xc6, 0x8a, 0x53, 0x15, 0x15, 0xaa, 0xb9, 0x4c, 0x87},
+				WithdrawalCredentials: []byte{0x00, 0x8b, 0xa1, 0xcc, 0x4b, 0x09, 0x1b, 0x91, 0xc1, 0x20, 0x2b, 0xba, 0x3f, 0x50, 0x80, 0x75, 0xd6, 0xff, 0x56, 0x5c, 0x77, 0xe5, 0x59, 0xf0, 0x80, 0x3c, 0x07, 0x92, 0xe0, 0x30, 0x2b, 0xf1},
+			},
+			{
+				Index:                 1,
+				Pubkey:                phase0.BLSPubKey{0xb3, 0xd8, 0x9e, 0x2f, 0x29, 0xc7, 0x12, 0xc6, 0xa9, 0xf8, 0xe5, 0xa2, 0x69, 0xb9, 0x76, 0x17, 0xc4, 0xa9, 0x4d, 0xd6, 0xf6, 0x66, 0x2a, 0xb3, 0xb0, 0x7c, 0xe9, 0xe5, 0x43, 0x45, 0x73, 0xf1, 0x5b, 0x5c, 0x98, 0x8c, 0xd1, 0x4b, 0xbd, 0x58, 0x04, 0xf7, 0x71, 0x56, 0xa8, 0xaf, 0x1c, 0xfa},
+				WithdrawalCredentials: []byte{0x00, 0x78, 0x6c, 0xb0, 0x2e, 0xd2, 0x8e, 0x5f, 0xbb, 0x1f, 0x7f, 0x9e, 0x93, 0x1a, 0x2b, 0x72, 0x69, 0x29, 0x06, 0xe6, 0xb1, 0x2c, 0xe4, 0x64, 0x39, 0x75, 0xe3, 0x2b, 0x51, 0x76, 0x91, 0xf2},
+			},
+		},
+		GenesisValidatorsRoot: phase0.Root{},
+		Epoch:                 1,
+		CurrentForkVersion:    phase0.Version{},
+	}
+
+	tests := []struct {
+		name    string
+		command *command
+		err     string
+	}{
+		{
+			name: "SignatureMissing",
+			command: &command{
+				chainInfo: chainInfo,
+				signedOperation: &phase0.SignedVoluntaryExit{
+					Message: &phase0.VoluntaryExit{
+						Epoch:          1,
+						ValidatorIndex: 0,
+					},
+				},
+			},
+			err: "invalid signature",
+		},
+		{
+			name: "SignatureShort",
+			command: &command{
+				chainInfo: chainInfo,
+				signedOperation: &phase0.SignedVoluntaryExit{
+					Message: &phase0.VoluntaryExit{
+						Epoch:          1,
+						ValidatorIndex: 0,
+					},
+					Signature: phase0.BLSSignature{0xf5, 0xc4, 0x42, 0x88, 0xf9, 0x5e, 0x19, 0xb6, 0xc1, 0x39, 0xf2, 0x62, 0x30, 0x05, 0x66, 0x5b, 0x98, 0x34, 0x62, 0xa2, 0x28, 0x12, 0x09, 0x77, 0xd8, 0x1f, 0x2e, 0xf5, 0x47, 0x56, 0x0b, 0xe2, 0x24, 0x46, 0xde, 0x21, 0xa8, 0xa9, 0x37, 0xd9, 0xdd, 0xa4, 0xe2, 0xd2, 0xec, 0x41, 0x75, 0x19, 0x64, 0x96, 0xcd, 0xd1, 0x30, 0x6d, 0xec, 0x4a, 0x12, 0x5f, 0x8c, 0x86, 0x1f, 0x80, 0x61, 0x71, 0x50, 0x4a, 0x9d, 0x6a, 0x61, 0x0e, 0xc4, 0xe1, 0x35, 0x04, 0x7e, 0x4f, 0xb6, 0x70, 0x52, 0xec, 0xc4, 0x56, 0x13, 0x60, 0xd0, 0xc3, 0xde, 0x04, 0xb6, 0xfb, 0xc4, 0x47, 0x42, 0x23, 0xff},
+				},
+			},
+			err: "invalid signature",
+		},
+		{
+			name: "SignatureIncorrect",
+			command: &command{
+				chainInfo: chainInfo,
+				signedOperation: &phase0.SignedVoluntaryExit{
+					Message: &phase0.VoluntaryExit{
+						Epoch:          1,
+						ValidatorIndex: 0,
+					},
+					Signature: phase0.BLSSignature{0x99, 0x78, 0xb4, 0x9c, 0x21, 0x60, 0x3f, 0x04, 0xa3, 0x04, 0x4e, 0x4c, 0x49, 0x0c, 0xb4, 0x68, 0x7c, 0x6e, 0x14, 0xc2, 0xda, 0xed, 0x25, 0x92, 0xe0, 0x02, 0x2d, 0xcd, 0x63, 0xeb, 0xe7, 0x4a, 0xf1, 0x1a, 0xca, 0xba, 0xae, 0x50, 0xe1, 0x8a, 0x1d, 0xae, 0x96, 0xd9, 0xd2, 0x56, 0xbf, 0x9f, 0x02, 0x48, 0x85, 0x05, 0xc1, 0xfb, 0xb3, 0x4a, 0x0b, 0x68, 0xec, 0xc5, 0xb5, 0xf5, 0xea, 0x53, 0xdb, 0xd0, 0x09, 0x08, 0xe3, 0x1e, 0xa8, 0xca, 0x9d, 0x02, 0x08, 0x3b, 0x9e, 0xf1, 0xc7, 0xd2, 0x32, 0xf4, 0xba, 0xd9, 0xea, 0x56, 0x4b, 0xc5, 0x87, 0xd5, 0x27, 0xb7, 0x74, 0x97, 0x8a, 0xee},
+				},
+			},
+			err: "signature does not verify",
+		},
+		{
+			name: "Good",
+			command: &command{
+				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",
+				validator: "0",
+				chainInfo: chainInfo,
+				signedOperation: &phase0.SignedVoluntaryExit{
+					Message: &phase0.VoluntaryExit{
+						Epoch:          1,
+						ValidatorIndex: 0,
+					},
+					Signature: phase0.BLSSignature{0x89, 0xf5, 0xc4, 0x42, 0x88, 0xf9, 0x5e, 0x19, 0xb6, 0xc1, 0x39, 0xf2, 0x62, 0x30, 0x05, 0x66, 0x5b, 0x98, 0x34, 0x62, 0xa2, 0x28, 0x12, 0x09, 0x77, 0xd8, 0x1f, 0x2e, 0xf5, 0x47, 0x56, 0x0b, 0xe2, 0x24, 0x46, 0xde, 0x21, 0xa8, 0xa9, 0x37, 0xd9, 0xdd, 0xa4, 0xe2, 0xd2, 0xec, 0x41, 0x75, 0x19, 0x64, 0x96, 0xcd, 0xd1, 0x30, 0x6d, 0xec, 0x4a, 0x12, 0x5f, 0x8c, 0x86, 0x1f, 0x80, 0x61, 0x71, 0x50, 0x4a, 0x9d, 0x6a, 0x61, 0x0e, 0xc4, 0xe1, 0x35, 0x04, 0x7e, 0x4f, 0xb6, 0x70, 0x52, 0xec, 0xc4, 0x56, 0x13, 0x60, 0xd0, 0xc3, 0xde, 0x04, 0xb6, 0xfb, 0xc4, 0x47, 0x42, 0x23, 0xff},
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			err := test.command.verifySignedOperation(ctx, test.command.signedOperation)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestObtainOperationFromInput(t *testing.T) {
+	ctx := context.Background()
+
+	require.NoError(t, e2types.InitBLS())
+
+	chainInfo := &beacon.ChainInfo{
+		Version: 1,
+		Validators: []*beacon.ValidatorInfo{
+			{
+				Index:                 0,
+				Pubkey:                phase0.BLSPubKey{0xb3, 0x84, 0xf7, 0x67, 0xd9, 0x64, 0xe1, 0x00, 0xc8, 0xa9, 0xb2, 0x10, 0x18, 0xd0, 0x8c, 0x25, 0xff, 0xeb, 0xae, 0x26, 0x8b, 0x3a, 0xb6, 0xd6, 0x10, 0x35, 0x38, 0x97, 0x54, 0x19, 0x71, 0x72, 0x6d, 0xbf, 0xc3, 0xc7, 0x46, 0x38, 0x84, 0xc6, 0x8a, 0x53, 0x15, 0x15, 0xaa, 0xb9, 0x4c, 0x87},
+				WithdrawalCredentials: []byte{0x00, 0x8b, 0xa1, 0xcc, 0x4b, 0x09, 0x1b, 0x91, 0xc1, 0x20, 0x2b, 0xba, 0x3f, 0x50, 0x80, 0x75, 0xd6, 0xff, 0x56, 0x5c, 0x77, 0xe5, 0x59, 0xf0, 0x80, 0x3c, 0x07, 0x92, 0xe0, 0x30, 0x2b, 0xf1},
+			},
+			{
+				Index:                 1,
+				Pubkey:                phase0.BLSPubKey{0xb3, 0xd8, 0x9e, 0x2f, 0x29, 0xc7, 0x12, 0xc6, 0xa9, 0xf8, 0xe5, 0xa2, 0x69, 0xb9, 0x76, 0x17, 0xc4, 0xa9, 0x4d, 0xd6, 0xf6, 0x66, 0x2a, 0xb3, 0xb0, 0x7c, 0xe9, 0xe5, 0x43, 0x45, 0x73, 0xf1, 0x5b, 0x5c, 0x98, 0x8c, 0xd1, 0x4b, 0xbd, 0x58, 0x04, 0xf7, 0x71, 0x56, 0xa8, 0xaf, 0x1c, 0xfa},
+				WithdrawalCredentials: []byte{0x00, 0x78, 0x6c, 0xb0, 0x2e, 0xd2, 0x8e, 0x5f, 0xbb, 0x1f, 0x7f, 0x9e, 0x93, 0x1a, 0x2b, 0x72, 0x69, 0x29, 0x06, 0xe6, 0xb1, 0x2c, 0xe4, 0x64, 0x39, 0x75, 0xe3, 0x2b, 0x51, 0x76, 0x91, 0xf2},
+			},
+		},
+		GenesisValidatorsRoot: phase0.Root{},
+		Epoch:                 1,
+		CurrentForkVersion:    phase0.Version{},
+	}
+
+	tests := []struct {
+		name    string
+		command *command
+		err     string
+	}{
+		{
+			name: "InvalidFilename",
+			command: &command{
+				signedOperationInput: `[]`,
+				chainInfo:            chainInfo,
+			},
+			err: "failed to read input file: open []: no such file or directory",
+		},
+		{
+			name: "InvalidJSON",
+			command: &command{
+				signedOperationInput: `{invalid}`,
+				chainInfo:            chainInfo,
+			},
+			err: "failed to parse exit operation input: invalid character 'i' looking for beginning of object key string",
+		},
+		{
+			name: "Unverifable",
+			command: &command{
+				signedOperationInput: `{"message":{"epoch":"1","validator_index":"0"},"signature":"0x9978b49c21603f04a3044e4c490cb4687c6e14c2daed2592e0022dcd63ebe74af11acabaae50e18a1dae96d9d256bf9f02488505c1fbb34a0b68ecc5b5f5ea53dbd00908e31ea8ca9d02083b9ef1c7d232f4bad9ea564bc587d527b774978aee"}`,
+				chainInfo:            chainInfo,
+			},
+			err: "signature does not verify",
+		},
+		{
+			name: "Good",
+			command: &command{
+				signedOperationInput: `{"message":{"epoch":"1","validator_index":"0"},"signature":"0x89f5c44288f95e19b6c139f2623005665b983462a228120977d81f2ef547560be22446de21a8a937d9dda4e2d2ec4175196496cdd1306dec4a125f8c861f806171504a9d6a610ec4e135047e4fb67052ecc4561360d0c3de04b6fbc4474223ff"}`,
+				chainInfo:            chainInfo,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			err := test.command.obtainOperationFromInput(ctx)
 			if test.err != "" {
 				require.EqualError(t, err, test.err)
 			} else {

cmd/validator/exit/run.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2023 Weald Technology Trading.
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -21,19 +21,19 @@ import (
 	"github.com/spf13/viper"
 )
 
-// Run runs the wallet create data command.
+// Run runs the command.
 func Run(cmd *cobra.Command) (string, error) {
 	ctx := context.Background()
-	dataIn, err := input(ctx)
+
+	c, err := newCommand(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "failed to obtain input")
+		return "", errors.Wrap(err, "failed to set up command")
 	}
 
 	// Further errors do not need a usage report.
 	cmd.SilenceUsage = true
 
-	dataOut, err := process(ctx, dataIn)
-	if err != nil {
+	if err := c.process(ctx); err != nil {
 		return "", errors.Wrap(err, "failed to process")
 	}
 
@@ -41,7 +41,7 @@ func Run(cmd *cobra.Command) (string, error) {
 		return "", nil
 	}
 
-	results, err := output(ctx, dataOut)
+	results, err := c.output(ctx)
 	if err != nil {
 		return "", errors.Wrap(err, "failed to obtain output")
 	}

cmd/validator/expectation/process.go

@@ -130,7 +130,6 @@ func (c *command) setup(ctx context.Context) error {
 
 	chainTime, err := standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
 		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
 	)
 	if err != nil {

cmd/validator/summary/process.go

@@ -384,7 +384,6 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
 		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
 	)
 	if err != nil {

cmd/validator/yield/process.go

@@ -119,7 +119,6 @@ func (c *command) setup(ctx context.Context) error {
 	if c.validators == "" {
 		chainTime, err := standardchaintime.New(ctx,
 			standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-			standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
 			standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
 		)
 		if err != nil {

cmd/validatorcredentialsset.go

@@ -28,12 +28,14 @@ var validatorCredentialsSetCmd = &cobra.Command{
 
     ethdo validator credentials set --validator=primary/validator --withdrawal-address=0x00...13 --private-key=0x00...1f
 
-The existing account can be specified in one of a number of ways:
+The validator account can be specified in one of a number of ways:
 
-  - mnemonic using --mnemonic; this will scan the mnemonic and generate all required operations
+  - mnemonic using --mnemonic; this will scan the mnemonic and generate all applicable operations
   - mnemonic and path to the validator key using --mnemonic and --path; this will generate a single operation
-  - private key using --private-key; this will generate a single operation
-  - account and passphrase using --account and --passphrase; this will generate a single operation
+  - mnemonic and validator index or public key --mnemonic and --validator; this will generate a single operation
+  - mnemonic and withdrawal private key using --mnemonic and --private-key; this will generate all applicable operations
+  - validator and withdrawal private key using --validator and --private-key; this will generate a single operation
+  - account and withdrawal account using --account and --withdrawal-account; this will generate a single operation
 
 In quiet mode this will return 0 if the credentials operation has been generated (and successfully broadcast if online), otherwise 1.`,
 	RunE: func(cmd *cobra.Command, args []string) error {
@@ -56,8 +58,9 @@ func init() {
 	validatorCredentialsFlags(validatorCredentialsSetCmd)
 	validatorCredentialsSetCmd.Flags().Bool("prepare-offline", false, "Create files for offline use")
 	validatorCredentialsSetCmd.Flags().String("validator", "", "Validator for which to set validator credentials")
+	validatorCredentialsSetCmd.Flags().String("withdrawal-account", "", "Account with which the validator's withdrawal credentials were set")
 	validatorCredentialsSetCmd.Flags().String("withdrawal-address", "", "Execution address to which to direct withdrawals")
-	validatorCredentialsSetCmd.Flags().String("signed-operation", "", "Use pre-defined JSON signed operation as created by --json to transmit the credentials change operation")
+	validatorCredentialsSetCmd.Flags().String("signed-operations", "", "Use pre-defined JSON signed operation as created by --json to transmit the credentials change operation (reads from change-operations.json if not present)")
 	validatorCredentialsSetCmd.Flags().Bool("json", false, "Generate JSON data containing a signed operation rather than broadcast it to the network (implied when offline)")
 	validatorCredentialsSetCmd.Flags().Bool("offline", false, "Do not attempt to connect to a beacon node to obtain information for the operation")
 	validatorCredentialsSetCmd.Flags().String("fork-version", "", "Fork version to use for signing (overrides fetching from beacon node)")
@@ -71,7 +74,10 @@ func validatorCredentialsSetBindings() {
 	if err := viper.BindPFlag("validator", validatorCredentialsSetCmd.Flags().Lookup("validator")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("signed-operation", validatorCredentialsSetCmd.Flags().Lookup("signed-operation")); err != nil {
+	if err := viper.BindPFlag("signed-operations", validatorCredentialsSetCmd.Flags().Lookup("signed-operations")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("withdrawal-account", validatorCredentialsSetCmd.Flags().Lookup("withdrawal-account")); err != nil {
 		panic(err)
 	}
 	if err := viper.BindPFlag("withdrawal-address", validatorCredentialsSetCmd.Flags().Lookup("withdrawal-address")); err != nil {

cmd/validatorexit.go

@@ -26,9 +26,16 @@ var validatorExitCmd = &cobra.Command{
 	Short: "Send an exit request for a validator",
 	Long: `Send an exit request for a validator.  For example:
 
-    ethdo validator exit --account=primary/validator --passphrase=secret
+    ethdo validator exit --validator=12345
 
-In quiet mode this will return 0 if the transaction has been generated, otherwise 1.`,
+The validator and key can be specified in one of a number of ways:
+
+  - mnemonic and path to the validator using --mnemonic and --path
+  - mnemonic and validator index or public key using --mnemonic and --validator
+  - validator private key using --private-key
+  - validator account using --validator
+
+In quiet mode this will return 0 if the exit operation has been generated (and successfully broadcast if online), otherwise 1.`,
 	RunE: func(cmd *cobra.Command, args []string) error {
 		res, err := validatorexit.Run(cmd)
 		if err != nil {
@@ -48,22 +55,38 @@ func init() {
 	validatorCmd.AddCommand(validatorExitCmd)
 	validatorFlags(validatorExitCmd)
 	validatorExitCmd.Flags().Int64("epoch", -1, "Epoch at which to exit (defaults to current epoch)")
-	validatorExitCmd.Flags().String("key", "", "Private key if validator not known by ethdo")
-	validatorExitCmd.Flags().String("exit", "", "Use pre-defined JSON data as created by --json to exit")
-	validatorExitCmd.Flags().Bool("json", false, "Generate JSON data for an exit; do not broadcast to network")
+	validatorExitCmd.Flags().Bool("prepare-offline", false, "Create files for offline use")
+	validatorExitCmd.Flags().String("validator", "", "Validator to exit")
+	validatorExitCmd.Flags().String("signed-operation", "", "Use pre-defined JSON signed operation as created by --json to transmit the exit operation (reads from exit-operations.json if not present)")
+	validatorExitCmd.Flags().Bool("json", false, "Generate JSON data containing a signed operation rather than broadcast it to the network (implied when offline)")
+	validatorExitCmd.Flags().Bool("offline", false, "Do not attempt to connect to a beacon node to obtain information for the operation")
+	validatorExitCmd.Flags().String("fork-version", "", "Fork version to use for signing (overrides fetching from beacon node)")
+	validatorExitCmd.Flags().String("genesis-validators-root", "", "Genesis validators root to use for signing (overrides fetching from beacon node)")
 }
 
 func validatorExitBindings() {
 	if err := viper.BindPFlag("epoch", validatorExitCmd.Flags().Lookup("epoch")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("key", validatorExitCmd.Flags().Lookup("key")); err != nil {
+	if err := viper.BindPFlag("prepare-offline", validatorExitCmd.Flags().Lookup("prepare-offline")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("exit", validatorExitCmd.Flags().Lookup("exit")); err != nil {
+	if err := viper.BindPFlag("validator", validatorExitCmd.Flags().Lookup("validator")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("signed-operation", validatorExitCmd.Flags().Lookup("signed-operation")); err != nil {
 		panic(err)
 	}
 	if err := viper.BindPFlag("json", validatorExitCmd.Flags().Lookup("json")); err != nil {
 		panic(err)
 	}
+	if err := viper.BindPFlag("offline", validatorExitCmd.Flags().Lookup("offline")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("fork-version", validatorExitCmd.Flags().Lookup("fork-version")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("genesis-validators-root", validatorExitCmd.Flags().Lookup("genesis-validators-root")); err != nil {
+		panic(err)
+	}
 }

cmd/version.go

@@ -24,7 +24,7 @@ import (
 
 // ReleaseVersion is the release version of the codebase.
 // Usually overridden by tag names when building binaries.
-var ReleaseVersion = "local build (latest release 1.26.5)"
+var ReleaseVersion = "local build (latest release 1.27.0)"
 
 // versionCmd represents the version command
 var versionCmd = &cobra.Command{

docs/changingwithdrawalcredentials.md

@@ -179,28 +179,36 @@ A mnemonic is a 24-word phrase from which withdrawal and validator keys are deri
 however this is only a standard and not a restriction, and it is possible for users to have created validators using paths of their own choice.
 
 ```
-ethdo validator credentials set --validator=123 --mnemonic="abandon abandon abandon … art" --path='m/12381/3600/0/0/0' --withdrawal-address=0x0123…cdef
+ethdo validator credentials set --mnemonic="abandon abandon abandon … art" --path='m/12381/3600/0/0/0' --withdrawal-address=0x0123…cdef
 ```
 
 replacing the path with the path to your _withdrawal_ key, and all other parameters with your own values.
 
-#### Using a private key
-If you have the private key from which the current withdrawal credentials were derived this can be used to generate and broadcast the credentials change operation with the following command:
+#### Using a mnemonic and validator.
+Similar to the previous section, however instead of specifying a path instead the index, public key or account of the validator is provided.
 
 ```
-ethdo validator credentials set --validator=123 --withdrawal-address=0x8f…9F --private-key=0x3b…9c
+ethdo validator credentials set --mnemonic="abandon abandon abandon … art" --validator=123 --withdrawal-address=0x0123…cdef
 ```
 
-replacing the parameters with your own values.
+#### Using a mnemonic and withdrawal private key.
+If the withdrawal address was created using a non-standard method then it is possible that you have the private key for the withdrawal address.  In this situation you can supply the withdrawal private key.
+
+
+```
+ethdo validator credentials set --mnemonic="abandon abandon abandon … art" --private-key=0x3b…9c
+```
+
+Note that it is possible for there to be multiple validators that use the provided private key for a withdrawal address, in which case an operation will be generated for each validator that is eligible for change.
 
 #### Using an account
-If you used `ethdo` to generate your validator deposit data you will likely have used a separate account to generate the withdrawal credentials.  You can specify the account to generate and broadcast the credentials change operation with the following command:
+If you used `ethdo` to generate your validator deposit data you will likely have used a separate account to generate the withdrawal credentials.  You can specify the accout of the validator and the accout of the withdrawal credentials to generate and broadcast the credentials change operation with the following command:
 
 ```
-ethdo validator credentials set --validator=123 --withdrawal-address=0x8f…9F --account=Wallet/Account --passphrase=secret
+ethdo validator credentials set --withdrawal-address=0x8f…9F --account=Wallet/Account --withdrawal-account=Withdrawals/Account --passphrase=secret
 ```
 
-replacing the parameters with your own values.
+replacing the parameters with your own values.  Note that the passphrase here is the passphrsae of the withdrawal account, not the validator account.
 
 ## Confirming the process has succeeded
 The final step is confirming the operation has taken place.  To do so, run the following command on an online server:

go.mod

@@ -3,7 +3,7 @@ module github.com/wealdtech/ethdo
 go 1.18
 
 require (
-	github.com/attestantio/go-eth2-client v0.15.0
+	github.com/attestantio/go-eth2-client v0.15.2
 	github.com/ferranbt/fastssz v0.1.2
 	github.com/gofrs/uuid v4.2.0+incompatible
 	github.com/google/uuid v1.3.0
@@ -19,14 +19,15 @@ require (
 	github.com/spf13/cobra v1.3.0
 	github.com/spf13/pflag v1.0.5
 	github.com/spf13/viper v1.13.0
-	github.com/stretchr/testify v1.8.0
+	github.com/stretchr/testify v1.8.1
 	github.com/tyler-smith/go-bip39 v1.1.0
+	github.com/wealdtech/chaind v0.6.17
 	github.com/wealdtech/go-bytesutil v1.2.0
 	github.com/wealdtech/go-ecodec v1.1.2
 	github.com/wealdtech/go-eth2-types/v2 v2.8.0
 	github.com/wealdtech/go-eth2-util v1.8.0
 	github.com/wealdtech/go-eth2-wallet v1.15.0
-	github.com/wealdtech/go-eth2-wallet-dirk v1.2.0
+	github.com/wealdtech/go-eth2-wallet-dirk v1.4.2
 	github.com/wealdtech/go-eth2-wallet-distributed v1.1.4
 	github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.3.0
 	github.com/wealdtech/go-eth2-wallet-hd/v2 v2.6.0
@@ -36,38 +37,44 @@ require (
 	github.com/wealdtech/go-eth2-wallet-store-scratch v1.7.0
 	github.com/wealdtech/go-eth2-wallet-types/v2 v2.10.0
 	github.com/wealdtech/go-string2eth v1.2.0
-	golang.org/x/text v0.4.0
+	golang.org/x/text v0.5.0
 )
 
 require (
 	github.com/aws/aws-sdk-go v1.44.152 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.1.2 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/dgraph-io/ristretto v0.1.0 // indirect
 	github.com/dustin/go-humanize v1.0.0 // indirect
 	github.com/fatih/color v1.13.0 // indirect
 	github.com/fsnotify/fsnotify v1.5.4 // indirect
-	github.com/goccy/go-yaml v1.9.4 // indirect
+	github.com/go-logr/logr v1.2.3 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/goccy/go-yaml v1.9.5 // indirect
 	github.com/golang/glog v1.0.0 // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/google/go-cmp v0.5.9 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/inconshreveable/mousetrap v1.0.0 // indirect
 	github.com/jackc/puddle v1.3.0 // indirect
 	github.com/jmespath/go-jmespath v0.4.0 // indirect
-	github.com/klauspost/compress v1.15.11 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.1 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.2 // indirect
 	github.com/magiconair/properties v1.8.6 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.16 // indirect
+	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
 	github.com/minio/highwayhash v1.0.2 // indirect
 	github.com/minio/sha256-simd v1.0.0 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/pelletier/go-toml v1.9.5 // indirect
 	github.com/pelletier/go-toml/v2 v2.0.5 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/prometheus/client_golang v1.14.0 // indirect
+	github.com/prometheus/client_model v0.3.0 // indirect
+	github.com/prometheus/common v0.37.0 // indirect
+	github.com/prometheus/procfs v0.8.0 // indirect
 	github.com/protolambda/zssz v0.1.5 // indirect
-	github.com/r3labs/sse/v2 v2.7.4 // indirect
+	github.com/r3labs/sse/v2 v2.8.1 // indirect
 	github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0 // indirect
 	github.com/spf13/afero v1.9.2 // indirect
 	github.com/spf13/cast v1.5.0 // indirect
@@ -75,13 +82,17 @@ require (
 	github.com/subosito/gotenv v1.4.1 // indirect
 	github.com/wealdtech/eth2-signer-api v1.7.1 // indirect
 	github.com/wealdtech/go-indexer v1.0.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.37.0 // indirect
+	go.opentelemetry.io/otel v1.11.2 // indirect
+	go.opentelemetry.io/otel/metric v0.34.0 // indirect
+	go.opentelemetry.io/otel/trace v1.11.2 // indirect
 	golang.org/x/crypto v0.3.0 // indirect
-	golang.org/x/net v0.2.0 // indirect
-	golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4 // indirect
+	golang.org/x/net v0.4.0 // indirect
+	golang.org/x/sync v0.1.0 // indirect
 	golang.org/x/sys v0.3.0 // indirect
 	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect
-	google.golang.org/genproto v0.0.0-20220930163606-c98284e70a91 // indirect
-	google.golang.org/grpc v1.49.0 // indirect
+	google.golang.org/genproto v0.0.0-20221207170731-23e4bf6bdc37 // indirect
+	google.golang.org/grpc v1.51.0 // indirect
 	google.golang.org/protobuf v1.28.1 // indirect
 	gopkg.in/cenkalti/backoff.v1 v1.1.0 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect

go.sum

@@ -29,21 +29,22 @@ cloud.google.com/go v0.94.1/go.mod h1:qAlAugsXlC+JWO+Bke5vCtc9ONxjQT3drlTTnAplMW
 cloud.google.com/go v0.97.0/go.mod h1:GF7l59pYBVlXQIBLx3a761cZ41F9bBH3JUlihCt2Udc=
 cloud.google.com/go v0.98.0/go.mod h1:ua6Ush4NALrHk5QXDWnjvZHN93OuF0HfuEPq9I1X0cM=
 cloud.google.com/go v0.99.0/go.mod h1:w0Xx2nLzqWJPuozYQX+hFfCSI8WioryfRDzkoI/Y2ZA=
+cloud.google.com/go v0.105.0 h1:DNtEKRBAAzeS4KyIory52wWHuClNaXJ5x1F7xa4q+5Y=
 cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
 cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
 cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
 cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
 cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
 cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
+cloud.google.com/go/compute v1.14.0 h1:hfm2+FfxVmnRlh6LpB7cg1ZNU+5edAHmW679JePztk0=
+cloud.google.com/go/compute/metadata v0.2.2 h1:aWKAjYaBaOSrpKl57+jnS/3fJRQnxL7TvR/u1VVbt6k=
 cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
 cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
-cloud.google.com/go/firestore v1.6.0/go.mod h1:afJwI0vaXwAG54kI7A//lP/lSPDkQORQuMkv56TxEPU=
 cloud.google.com/go/firestore v1.6.1/go.mod h1:asNXNOzBdyVQmEU+ggO8UPodTkEVFW5Qx+rwHnAz+EY=
 cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
 cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
 cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
 cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
-cloud.google.com/go/secretmanager v1.0.0/go.mod h1:+Qkm5qxIJ5mk74xxIXA+87fseaY1JLYBcFPQoc/GQxg=
 cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
 cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
 cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
@@ -54,39 +55,30 @@ dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
 github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ=
-github.com/HdrHistogram/hdrhistogram-go v1.1.1/go.mod h1:yDgFjdqOqDEKOvasDdhWNXYg9BVp4O+o5f6V/ehm6Oo=
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
-github.com/ajstarks/svgo v0.0.0-20180226025133-644b8db467af/go.mod h1:K08gAheRH3/J6wwsYMMT4xOr94bZjxIelGM0+d/wbFw=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
-github.com/antihax/optional v0.0.0-20180407024304-ca021399b1a6/go.mod h1:V8iCPQYkqmusNa815XgQio277wI47sdRh1dUOLdyC6Q=
 github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
 github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
-github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
 github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
 github.com/armon/go-metrics v0.3.10/go.mod h1:4O98XIr/9W0sxpJ8UaYkvjk10Iff7SnFrb4QAOwNTFc=
 github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
 github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
-github.com/attestantio/dirk v1.1.0 h1:hwMTYZkwj/Y0um3OD0LQxg2xSl4/5xqVWV2MRePE4ec=
-github.com/attestantio/dirk v1.1.0/go.mod h1:2jkOw/XHjvIDdhDcmj+Z3kuVPpxMcQ6zxzzjSSv71PY=
-github.com/attestantio/go-eth2-client v0.8.1/go.mod h1:kEK9iAAOBoADO5wEkd84FEOzjT1zXgVWveQsqn+uBGg=
-github.com/attestantio/go-eth2-client v0.15.0 h1:Ia8U1EPYFJ8KB/vsQ2+oEhzuPgCePlBkWXg1R3e0oWw=
-github.com/attestantio/go-eth2-client v0.15.0/go.mod h1:5kLLzdlyPGboWr8tAwnG/4Kpi43BHd/HWp++WmmP6Ws=
-github.com/aws/aws-sdk-go v1.33.17/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
+github.com/attestantio/go-eth2-client v0.15.2 h1:4EYeA5IBSBypkUMhkkFALzMddaFDdb5PvCl7ORXEl6w=
+github.com/attestantio/go-eth2-client v0.15.2/go.mod h1:/Oh6YTuHmHhgLN/ZnQRKHGc7HdIzGlDkI2vjNZvOsvA=
 github.com/aws/aws-sdk-go v1.40.41/go.mod h1:585smgzpB/KqRA+K3y/NL/oYRqQvpNJYvLm+LY1U59Q=
-github.com/aws/aws-sdk-go v1.41.19/go.mod h1:585smgzpB/KqRA+K3y/NL/oYRqQvpNJYvLm+LY1U59Q=
 github.com/aws/aws-sdk-go v1.44.152 h1:L9aaepO8wHB67gwuGD8VgIYH/cmQDxieCt7FeLa0+fI=
 github.com/aws/aws-sdk-go v1.44.152/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/census-instrumentation/opencensus-proto v0.3.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
-github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
@@ -107,28 +99,18 @@ github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWH
 github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cncf/xds/go v0.0.0-20211130200136-a8f946100490/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
-github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
-github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
 github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
-github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
 github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
-github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
 github.com/cpuguy83/go-md2man/v2 v2.0.1/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dgraph-io/badger/v2 v2.2007.4 h1:TRWBQg8UrlUhaFdco01nO2uXwzKS7zd+HVdwV/GHc4o=
-github.com/dgraph-io/badger/v2 v2.2007.4/go.mod h1:vSw/ax2qojzbN6eXHIx6KPKtCSHJN/Uz0X0VPruTIhk=
-github.com/dgraph-io/ristretto v0.0.3-0.20200630154024-f66de99634de/go.mod h1:KPxhHT9ZxKefz+PCeOGsrHpl1qZ7i70dGTu2u+Ahh6E=
 github.com/dgraph-io/ristretto v0.0.3/go.mod h1:KPxhHT9ZxKefz+PCeOGsrHpl1qZ7i70dGTu2u+Ahh6E=
 github.com/dgraph-io/ristretto v0.1.0 h1:Jv3CGQHp9OjuMBSne1485aDpUkTKEcUqF+jm/LuerPI=
 github.com/dgraph-io/ristretto v0.1.0/go.mod h1:fux0lOrBhrVCJd3lcTHsIJhq1T2rokOu6v9Vcb3Q9ug=
+github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA=
 github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
-github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 h1:fAjc9m62+UWV/WAFKLNi6ZS0675eEUC9y3AlwSbQu1Y=
-github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
 github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
@@ -139,7 +121,6 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.m
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
 github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0=
-github.com/envoyproxy/go-control-plane v0.10.0/go.mod h1:AY7fTTXNdv/aJ2O5jwpxAPOWUZ7hQAEvzN5Pf27BkQQ=
 github.com/envoyproxy/go-control-plane v0.10.1/go.mod h1:AY7fTTXNdv/aJ2O5jwpxAPOWUZ7hQAEvzN5Pf27BkQQ=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/envoyproxy/protoc-gen-validate v0.6.2/go.mod h1:2t7qjJNvHPx8IjnBOzl9E9/baC+qXE/TeeyBRzgJDws=
@@ -148,15 +129,11 @@ github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL
 github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
 github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
 github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
-github.com/ferranbt/fastssz v0.0.0-20200728110133-0b6e349af87a/go.mod h1:DyEu2iuLBnb/T51BlsiO3yLYdJC6UbGMrIkqK1KmQxM=
 github.com/ferranbt/fastssz v0.0.0-20210526181520-7df50c8568f8/go.mod h1:DyEu2iuLBnb/T51BlsiO3yLYdJC6UbGMrIkqK1KmQxM=
 github.com/ferranbt/fastssz v0.0.0-20210905181407-59cf6761a7d5/go.mod h1:S8yiDeAXy8f88W4Ul+0dBMPx49S05byYbmZD6Uv94K4=
-github.com/ferranbt/fastssz v0.0.0-20211031100431-9823ca9021f1/go.mod h1:S8yiDeAXy8f88W4Ul+0dBMPx49S05byYbmZD6Uv94K4=
 github.com/ferranbt/fastssz v0.1.2 h1:Dky6dXlngF6Qjc+EfDipAkE83N5I5DE68bY6O0VLNPk=
 github.com/ferranbt/fastssz v0.1.2/go.mod h1:X5UPrE2u1UJjxHA8X54u04SBwdAQjG2sFtWs39YxyWs=
-github.com/fogleman/gg v1.2.1-0.20190220221249-0403632d5b90/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k=
 github.com/frankban/quicktest v1.14.3 h1:FJKSZTDHjyhriyC81FLQ0LY93eSai0ZyR/ZIkd3ZUKE=
-github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/fsnotify/fsnotify v1.5.1/go.mod h1:T3375wBYaZdLLcVNkcVbzGHY7f1l/uK5T5Ai1i3InKU=
 github.com/fsnotify/fsnotify v1.5.4 h1:jRbGcIw6P2Meqdwuo0H1p6JVLbL5DHKAKlYndzMwVZI=
 github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU=
@@ -167,9 +144,16 @@ github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
+github.com/go-kit/log v0.2.0/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
 github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
+github.com/go-logfmt/logfmt v0.5.1/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.2.3 h1:2DntVwHkVopvECVRSlL5PSo9eG+cAkDCuckLubN+rq0=
+github.com/go-logr/logr v1.2.3/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
 github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
 github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
@@ -177,19 +161,15 @@ github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD87
 github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
 github.com/go-playground/validator/v10 v10.4.1 h1:pH2c5ADXtd66mxoE0Zm9SUhxE20r7aM3F26W0hOn+GE=
 github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4=
-github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/goccy/go-yaml v1.8.9/go.mod h1:U/jl18uSupI5rdI2jmuCswEA2htH9eXfferR3KfscvA=
 github.com/goccy/go-yaml v1.9.2/go.mod h1:U/jl18uSupI5rdI2jmuCswEA2htH9eXfferR3KfscvA=
-github.com/goccy/go-yaml v1.9.4 h1:S0GCYjwHKVI6IHqio7QWNKNThUl6NLzFd/g8Z65Axw8=
-github.com/goccy/go-yaml v1.9.4/go.mod h1:U/jl18uSupI5rdI2jmuCswEA2htH9eXfferR3KfscvA=
+github.com/goccy/go-yaml v1.9.5 h1:Eh/+3uk9kLxG4koCX6lRMAPS1OaMSAi+FJcya0INdB0=
+github.com/goccy/go-yaml v1.9.5/go.mod h1:U/jl18uSupI5rdI2jmuCswEA2htH9eXfferR3KfscvA=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/gofrs/uuid v4.2.0+incompatible h1:yyYWMnhkhrKwwr8gAOcOCYxOOscHgDS9yZgBrnJfGa0=
 github.com/gofrs/uuid v4.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
-github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
-github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/glog v1.0.0 h1:nfP3RFugxnNRyKgeWd4oI1nYvXpxrx8ck8ZrcizshdQ=
 github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4=
@@ -242,7 +222,6 @@ github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
-github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
 github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
@@ -274,13 +253,9 @@ github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5m
 github.com/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0=
 github.com/googleapis/gax-go/v2 v2.1.1/go.mod h1:hddJymUZASv3XPyGkUpKj8pPO47Rmb0eJc8R6ouapiM=
 github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g=
-github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 h1:+9834+KizmvFV7pXQGSXQTsaWhq2GjuNUt0aUU0YBYw=
-github.com/grpc-ecosystem/go-grpc-middleware v1.3.0/go.mod h1:z0ButlSOZa5vEBq9m2m2hlwIgKw+rp3sdCBRoJY+30Y=
-github.com/grpc-ecosystem/grpc-gateway v1.13.0/go.mod h1:8XEsbTttt/W+VvjtQhLACqCisSPWTxCZ7sBRjU6iH9c=
 github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
 github.com/hako/durafmt v0.0.0-20210608085754-5c1018a4e16b h1:wDUNC2eKiL35DbLvsDhiblTUXHxcOPwQSCzi7xpQUN4=
 github.com/hako/durafmt v0.0.0-20210608085754-5c1018a4e16b/go.mod h1:VzxiSdG6j1pi7rwGm/xYI5RbtpBgM8sARDXlvEvxlu0=
-github.com/hashicorp/consul/api v1.10.1/go.mod h1:XjsvQN+RJGWI2TWy1/kqaE16HrR2J/FWgkYjdZQsX9M=
 github.com/hashicorp/consul/api v1.11.0/go.mod h1:XjsvQN+RJGWI2TWy1/kqaE16HrR2J/FWgkYjdZQsX9M=
 github.com/hashicorp/consul/sdk v0.8.0/go.mod h1:GBvyrGALthsZObzUGsfgHZQDXjg4lOjagTIwIR1vPms=
 github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
@@ -315,7 +290,6 @@ github.com/hashicorp/serf v0.9.6/go.mod h1:TXZNMjZQijwlDvp+r0b63xZ45H7JmCmgg4gpT
 github.com/herumi/bls-eth-go-binary v0.0.0-20210520070601-31246bfa8ac4/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
 github.com/herumi/bls-eth-go-binary v0.0.0-20210902234237-7763804ee078/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
 github.com/herumi/bls-eth-go-binary v0.0.0-20210917013441-d37c07cfda4e/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
-github.com/herumi/bls-eth-go-binary v0.0.0-20211117070716-2bdbdadbf8bb/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
 github.com/herumi/bls-eth-go-binary v1.28.1 h1:fcIZ48y5EE9973k05XjE8+P3YiQgjZz4JI/YabAm8KA=
 github.com/herumi/bls-eth-go-binary v1.28.1/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
 github.com/iancoleman/strcase v0.2.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho=
@@ -323,10 +297,8 @@ github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:
 github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
-github.com/jackc/puddle v1.1.4/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
 github.com/jackc/puddle v1.3.0 h1:eHK/5clGOatcjX3oWGBO/MpxpbHzSwud5EWTSCI+MX0=
 github.com/jackc/puddle v1.3.0/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
-github.com/jmespath/go-jmespath v0.3.0/go.mod h1:9QtRXoHjLGCJ5IBSaohpXITPlowMeeYCZ7fLUTSywik=
 github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
 github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
 github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8=
@@ -341,20 +313,14 @@ github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1
 github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
 github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
-github.com/jung-kurt/gofpdf v1.0.3-0.20190309125859-24315acbbda5/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes=
-github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/klauspost/compress v1.12.3/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg=
-github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
-github.com/klauspost/compress v1.15.11 h1:Lcadnb3RKGin4FYM/orgq0qde+nc15E5Cbqg4B9Sx9c=
-github.com/klauspost/compress v1.15.11/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM=
 github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/klauspost/cpuid/v2 v2.0.6/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/klauspost/cpuid/v2 v2.1.2/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
-github.com/klauspost/cpuid/v2 v2.2.1 h1:U33DW0aiEj633gHYw3LoDNfkDiYnE5Q8M/TKJn2f2jI=
-github.com/klauspost/cpuid/v2 v2.2.1/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
+github.com/klauspost/cpuid/v2 v2.2.2 h1:xPMwiykqNK9VK0NYC3+jTMYv9I6Vl3YdjZgPZKG3zO0=
+github.com/klauspost/cpuid/v2 v2.2.2/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg=
@@ -365,11 +331,9 @@ github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
 github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
 github.com/lyft/protoc-gen-star v0.5.3/go.mod h1:V0xaHgaf5oCCqmcxYcWiDfTiKsZsRc87/1qhoTACD8w=
-github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/magiconair/properties v1.8.5/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60=
 github.com/magiconair/properties v1.8.6 h1:5ibWZ6iY0NctNGWo87LalDlEZ6R41TqbbDamhfG/Qzo=
 github.com/magiconair/properties v1.8.6/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60=
@@ -378,7 +342,6 @@ github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVc
 github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
-github.com/mattn/go-colorable v0.1.11/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
 github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
@@ -390,6 +353,7 @@ github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Ky
 github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
 github.com/mattn/go-isatty v0.0.16 h1:bq3VjFmv/sOjHtdEhmkEV4x1AJtvUvOJ2PFAZ5+peKQ=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
 github.com/miekg/dns v1.1.26/go.mod h1:bPDLeHnStXmXAq1m/Ch/hvfNHr14JKNPMBo3VZKjuso=
@@ -421,13 +385,8 @@ github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRW
 github.com/nbutton23/zxcvbn-go v0.0.0-20210217022336-fa2cb2858354 h1:4kuARK6Y6FxaNu/BnU2OAaLF86eTVhP2hjTB6iMvItA=
 github.com/nbutton23/zxcvbn-go v0.0.0-20210217022336-fa2cb2858354/go.mod h1:KSVJerMDfblTH7p5MZaTt+8zaT2iEk3AkVb9PQdZuE8=
 github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
-github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
-github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
-github.com/opentracing/opentracing-go v1.2.0 h1:uEJPy/1a5RIPAJ0Ov+OIO8OxWu77jEv+1B0VhjKrZUs=
-github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc=
 github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
 github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
-github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
 github.com/pelletier/go-toml v1.9.4/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c=
 github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8=
 github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c=
@@ -449,51 +408,50 @@ github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3O
 github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
 github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
 github.com/prometheus/client_golang v1.12.1/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
+github.com/prometheus/client_golang v1.14.0 h1:nJdhIvne2eSX/XRAFV9PcvFFRbrjbcTUj0VP62TMhnw=
+github.com/prometheus/client_golang v1.14.0/go.mod h1:8vpkKitgIVNcqrRBWh1C4TIUQgYNtG/XQE4E/Zae36Y=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.3.0 h1:UBgGFHqYdG/TPFD1B1ogZywDqEkwp3fBMvqdiQ7Xew4=
+github.com/prometheus/client_model v0.3.0/go.mod h1:LDGWKZIo7rky3hgvBe+caln+Dr3dPggB5dvjtD7w9+w=
 github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4=
 github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
 github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
 github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=
+github.com/prometheus/common v0.37.0 h1:ccBbHCgIiT9uSoFY0vX8H3zsNR5eLt17/RQLUvn8pXE=
+github.com/prometheus/common v0.37.0/go.mod h1:phzohg0JFMnBEFGxTDbfu3QyL5GI8gTQJFhYO5B3mfA=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
 github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
 github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
 github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
+github.com/prometheus/procfs v0.8.0 h1:ODq8ZFEaYeCaZOJlZZdJA2AbQR98dSHSM1KW/You5mo=
+github.com/prometheus/procfs v0.8.0/go.mod h1:z7EfXMXOkbkqb9IINtpCn86r/to3BnA0uaxHdg830/4=
 github.com/protolambda/zssz v0.1.5 h1:7fjJjissZIIaa2QcvmhS/pZISMX21zVITt49sW1ouek=
 github.com/protolambda/zssz v0.1.5/go.mod h1:a4iwOX5FE7/JkKA+J/PH0Mjo9oXftN6P8NZyL28gpag=
-github.com/prysmaticlabs/ethereumapis v0.0.0-20200812153649-a842fc47c2c3/go.mod h1:k7b2dxy6RppCG6kmOJkNOXzRpEoTdsPygc2aQhsUsZk=
-github.com/prysmaticlabs/go-bitfield v0.0.0-20200322041314-62c2aee71669/go.mod h1:hCwmef+4qXWjv0jLDbQdWnL0Ol7cS7/lCSS26WR+u6s=
-github.com/prysmaticlabs/go-bitfield v0.0.0-20210607200045-4da71aaf6c2d/go.mod h1:hCwmef+4qXWjv0jLDbQdWnL0Ol7cS7/lCSS26WR+u6s=
 github.com/prysmaticlabs/go-bitfield v0.0.0-20210809151128-385d8c5e3fb7 h1:0tVE4tdWQK9ZpYygoV7+vS6QkDvQVySboMVEIxBJmXw=
 github.com/prysmaticlabs/go-bitfield v0.0.0-20210809151128-385d8c5e3fb7/go.mod h1:wmuf/mdK4VMD+jA9ThwcUKjg3a2XWM9cVfFYjDyY4j4=
 github.com/prysmaticlabs/go-ssz v0.0.0-20210121151755-f6208871c388 h1:4bD+ujqGfY4zoDUF3q9MhdmpPXzdp03DYUIlXeQ72kk=
 github.com/prysmaticlabs/go-ssz v0.0.0-20210121151755-f6208871c388/go.mod h1:VecIJZrewdAuhVckySLFt2wAAHRME934bSDurP8ftkc=
 github.com/prysmaticlabs/gohashtree v0.0.1-alpha.0.20220714111606-acbb2962fb48 h1:cSo6/vk8YpvkLbk9v3FO97cakNmUoxwi2KMP8hd5WIw=
 github.com/prysmaticlabs/gohashtree v0.0.1-alpha.0.20220714111606-acbb2962fb48/go.mod h1:4pWaT30XoEx1j8KNJf3TV+E3mQkaufn7mf+jRNb/Fuk=
-github.com/r3labs/sse/v2 v2.3.0/go.mod h1:hUrYMKfu9WquG9MyI0r6TKiNH+6Sw/QPKm2YbNbU5g8=
-github.com/r3labs/sse/v2 v2.7.4 h1:pvCMswPDlXd/ZUFx1dry0LbXJNHXwWPulLcUGYwClc0=
 github.com/r3labs/sse/v2 v2.7.4/go.mod h1:hUrYMKfu9WquG9MyI0r6TKiNH+6Sw/QPKm2YbNbU5g8=
+github.com/r3labs/sse/v2 v2.8.1 h1:lZH+W4XOLIq88U5MIHOsLec7+R62uhz3bIi2yn0Sg8o=
+github.com/r3labs/sse/v2 v2.8.1/go.mod h1:Igau6Whc+F17QUgML1fYe1VPZzTV6EMCnYktEmkNJ7I=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/rogpeppe/go-internal v1.6.1 h1:/FiVV8dS/e+YqF2JvO3yXRFbBLTIuSDkuC7aBOAvL+k=
-github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
 github.com/rs/xid v1.3.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/xid v1.4.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
-github.com/rs/zerolog v1.19.0/go.mod h1:IzD0RJ65iWH0w97OQQebJEvTZYvsCUm9WVLWBQrJRjo=
-github.com/rs/zerolog v1.21.0/go.mod h1:ZPhntP/xmq1nnND05hhpAh2QMhSsA4UN3MGZ6O2J3hM=
-github.com/rs/zerolog v1.26.0/go.mod h1:yBiM87lvSqX8h0Ww4sdzNSkVYZ8dL2xjZJG1lAuGZEo=
 github.com/rs/zerolog v1.26.1/go.mod h1:/wSSJWX7lVrsOwlbyTRSOJvqRlc+WjWlfes+CiJ+tmc=
 github.com/rs/zerolog v1.28.0 h1:MirSo27VyNi7RJYP3078AA1+Cyzd2GB66qy3aUHvsWY=
 github.com/rs/zerolog v1.28.0/go.mod h1:NILgTygv/Uej1ra5XxGf82ZFSLk58MFGAUS2o6usyD0=
-github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
-github.com/sagikazarmark/crypt v0.1.0/go.mod h1:B/mN0msZuINBtQ1zZLEQcegFJJf9vnYIR88KRMEuODE=
 github.com/sagikazarmark/crypt v0.3.0/go.mod h1:uD/D+6UF4SrIR1uGEv7bBNkNqLGqUr43MRiaGWX1Nig=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
 github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0 h1:Xuk8ma/ibJ1fOy4Ee11vHhUFHQNpHhrBneOCNHVXS5w=
@@ -504,27 +462,19 @@ github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPx
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
 github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
-github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
-github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
 github.com/spf13/afero v1.3.3/go.mod h1:5KUK8ByomD5Ti5Artl0RtHeI5pTF7MIDuXL3yY520V4=
 github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I=
 github.com/spf13/afero v1.9.2 h1:j49Hj62F0n+DaZ1dDCvhABaPNSGNkt32oRFxI33IEMw=
 github.com/spf13/afero v1.9.2/go.mod h1:iUV7ddyEEZPO5gA3zD4fJt6iStLlL+Lg4m2cihcDf8Y=
-github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
 github.com/spf13/cast v1.4.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
 github.com/spf13/cast v1.5.0 h1:rj3WzYc11XZaIZMPKmwP96zkFEnnAmV8s6XbB2aY32w=
 github.com/spf13/cast v1.5.0/go.mod h1:SpXXQ5YoyJw6s3/6cMTQuxvgRl3PCJiyaX9p6b155UU=
-github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU=
 github.com/spf13/cobra v1.3.0 h1:R7cSvGu+Vv+qX0gW5R/85dx2kmmJT5z5NM8ifdYjdn0=
 github.com/spf13/cobra v1.3.0/go.mod h1:BrRVncBjOJa/eUcVVm9CE+oC6as8k+VYr4NY7WCi9V4=
-github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
 github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk=
 github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo=
-github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
-github.com/spf13/viper v1.9.0/go.mod h1:+i6ajR7OX2XaiBkrcZJFK21htRk7eDeLg7+O6bhUPP4=
 github.com/spf13/viper v1.10.0/go.mod h1:SoyBPwAtKDzypXNDFKN5kzH7ppppbGZtls1UpIy5AsM=
 github.com/spf13/viper v1.13.0 h1:BWSJ/M+f+3nmdz9bxB+bWX28kkALN2ok11D0rSo8EJU=
 github.com/spf13/viper v1.13.0/go.mod h1:Icm2xNL3/8uyh/wFuB1jI7TiTNKp8632Nwegu+zgdYw=
@@ -532,6 +482,7 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.3.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.1.4/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
@@ -540,17 +491,17 @@ github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
 github.com/subosito/gotenv v1.4.1 h1:jyEFiXpy21Wm81FBN71l9VoMMV8H8jG+qIK3GCpY6Qs=
 github.com/subosito/gotenv v1.4.1/go.mod h1:ayKnFf/c6rvx/2iiLrJUk1e6plDbT3edrFNGqEflhK0=
 github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
 github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8=
 github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U=
-github.com/uber/jaeger-client-go v2.29.1+incompatible/go.mod h1:WVhlPFC8FDjOFMMWRy2pZqQJSXxYSwNYOkTr/Z6d3Kk=
-github.com/uber/jaeger-lib v2.4.1+incompatible/go.mod h1:ComeNDZlWwrWnDv8aPp0Ba6+uUTzImX/AauajbLI56U=
-github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
+github.com/wealdtech/chaind v0.6.17 h1:HBlmzKj9Egy9rnZKGGIwvM6mUHJ+64163hNhSwjg/FQ=
+github.com/wealdtech/chaind v0.6.17/go.mod h1:g8XOXrrRtwjD6mlpn9TydRPJD+gy4iFZMlPkQrBxxQA=
 github.com/wealdtech/eth2-signer-api v1.7.1 h1:XdwFuv3VWCwcPPPrfa77sUXL1GSvxDtsUZxlByz//b0=
 github.com/wealdtech/eth2-signer-api v1.7.1/go.mod h1:fX8XtN9Svyjs+e7TgoOfOcwRTHeblR5SXftAVV3T1ZA=
 github.com/wealdtech/go-bytesutil v1.0.1/go.mod h1:jENeMqeTEU8FNZyDFRVc7KqBdRKSnJ9CCh26TcuNb9s=
@@ -570,8 +521,8 @@ github.com/wealdtech/go-eth2-util v1.8.0 h1:hhs3h2y3Ldty18lppFdpe46nZpdDAMbY7Qqi
 github.com/wealdtech/go-eth2-util v1.8.0/go.mod h1:rSuE0v5zX+uyZrqW/iUmXOxeDpB7lTvhcZvAVh0KlMU=
 github.com/wealdtech/go-eth2-wallet v1.15.0 h1:yff2rWCvHyr5bOU41wwilsNemFRYOFinZoIPjhzG10M=
 github.com/wealdtech/go-eth2-wallet v1.15.0/go.mod h1:BqXnen6XCa99yaUx/XIcyImaZLJMMj4wIMcUBywlMJs=
-github.com/wealdtech/go-eth2-wallet-dirk v1.2.0 h1:GNrxDo1ajDbUU8XvCHku1ImFhgtV79oNVHEZlRfu9f4=
-github.com/wealdtech/go-eth2-wallet-dirk v1.2.0/go.mod h1:1lnHDSdcRxj9CFJh+jPtdgVQCI+7jLwikjsxcqksXlg=
+github.com/wealdtech/go-eth2-wallet-dirk v1.4.2 h1:TV5rrXGtHPteV+Mk7v6KFdmSUDm38SDKBDHFIvKIL8w=
+github.com/wealdtech/go-eth2-wallet-dirk v1.4.2/go.mod h1:WGzvX3nxQnFNv4Hjx7jfBQhlVAEsRqe1tZwC8hZWM98=
 github.com/wealdtech/go-eth2-wallet-distributed v1.1.4 h1:EBk/FofiQWtbRYmwdCp0qM9TPDvlh1LN2yjlLr4W3ao=
 github.com/wealdtech/go-eth2-wallet-distributed v1.1.4/go.mod h1:Y31pDxcdyADwfQl65t8V6KhcmCes31EXkXZPDcT2SIk=
 github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.1.6/go.mod h1:hIeHsLJWVxFUUqQqaBm9nmUW3Y/eHneQclYyNayUeQg=
@@ -600,10 +551,8 @@ github.com/wealdtech/go-eth2-wallet-types/v2 v2.10.0 h1:bivQYT1TALvU+3kC9gyx2qX+
 github.com/wealdtech/go-eth2-wallet-types/v2 v2.10.0/go.mod h1:CYlvo087PNZuihF0Pdnerfs9lhXAW/wLDxySNNkgpVo=
 github.com/wealdtech/go-indexer v1.0.0 h1:/S4rfWQbSOnnYmwnvuTVatDibZ8o1s9bmTCHO16XINg=
 github.com/wealdtech/go-indexer v1.0.0/go.mod h1:u1cjsbsOXsm5jzJDyLmZY7GsrdX8KYXKBXkZcAmk3Zg=
-github.com/wealdtech/go-majordomo v1.0.1/go.mod h1:QoT4S1nUQwdQK19+CfepDwV+Yr7cc3dbF+6JFdQnIqY=
 github.com/wealdtech/go-string2eth v1.2.0 h1:C0E5p78tecZTsGccJc9r/kreFah4EfDs5uUPnS6XXMs=
 github.com/wealdtech/go-string2eth v1.2.0/go.mod h1:RUzsLjJtbZaJ/3UKn9kY19a/vCCUHtEWoUW3uiK6yGU=
-github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
 github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
@@ -611,11 +560,8 @@ github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9dec
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 github.com/yuin/goldmark v1.4.0/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-go.etcd.io/etcd/api/v3 v3.5.0/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs=
 go.etcd.io/etcd/api/v3 v3.5.1/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs=
-go.etcd.io/etcd/client/pkg/v3 v3.5.0/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g=
 go.etcd.io/etcd/client/pkg/v3 v3.5.1/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g=
-go.etcd.io/etcd/client/v2 v2.305.0/go.mod h1:h9puh54ZTgAKtEbut2oe9P4L/oqKCVB6xsXlzd7alYQ=
 go.etcd.io/etcd/client/v2 v2.305.1/go.mod h1:pMEacxZW7o8pg4CrFE7pquyCJJzZvkvdD2RibOCCCGs=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
@@ -624,17 +570,20 @@ go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
 go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.37.0 h1:+uFejS4DCfNH6d3xODVIGsdhzgzhh45p9gpbHQMbdZI=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.37.0/go.mod h1:HSmzQvagH8pS2/xrK7ScWsk0vAMtRTGbMFgInXCi8Tc=
+go.opentelemetry.io/otel v1.11.2 h1:YBZcQlsVekzFsFbjygXMOXSs6pialIZxcjfO/mBDmR0=
+go.opentelemetry.io/otel v1.11.2/go.mod h1:7p4EUV+AqgdlNV9gL97IgUZiVR3yrFXYo53f9BM3tRI=
+go.opentelemetry.io/otel/metric v0.34.0 h1:MCPoQxcg/26EuuJwpYN1mZTeCYAUGx8ABxfW07YkjP8=
+go.opentelemetry.io/otel/metric v0.34.0/go.mod h1:ZFuI4yQGNCupurTXCwkeD/zHBt+C2bR7bw5JqUm/AP8=
+go.opentelemetry.io/otel/trace v1.11.2 h1:Xf7hWSF2Glv0DE3MH7fBHvtpSBsjcBUe5MYAmZM/+y0=
+go.opentelemetry.io/otel/trace v1.11.2/go.mod h1:4N+yC7QEz7TTsG9BSRLNAa63eg5E06ObSbKPmxQ/pKA=
 go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
-go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
-go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
-go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
 go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
-go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
 go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
@@ -650,10 +599,7 @@ golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5y
 golang.org/x/crypto v0.0.0-20211215165025-cf75a172585e/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
 golang.org/x/crypto v0.3.0 h1:a06MkbcxBrEFc0w0QIZWXrH/9cCX6KJyWbBOIwAn+7A=
 golang.org/x/crypto v0.3.0/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4=
-golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20190125153040-c74c464bbbf2/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
 golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
@@ -663,7 +609,6 @@ golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u0
 golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
 golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
-golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
@@ -707,7 +652,6 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL
 golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20191002035440-2ec189313ef0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20191116160921-f9c825593386/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
@@ -740,13 +684,12 @@ golang.org/x/net v0.0.0-20210614182718-04defd469f4e/go.mod h1:9nx3DQGgdP8bBQD5qx
 golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20211020060615-d418f374d309/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20211105192438-b53810dc28af/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20211116231205-47ca1ff31462/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
+golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco=
-golang.org/x/net v0.2.0 h1:sZfSu1wtKLGlWI4ZZayP0ck9Y73K1ynO6gqzTdBVdPU=
-golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=
+golang.org/x/net v0.4.0 h1:Q5QPcMlvfxFTAPV0+07Xz/MpK9NTXu2VDUuy0FeMfaU=
+golang.org/x/net v0.4.0/go.mod h1:MBQ8lrhLObU/6UmLb4fmbmk5OcyYmqtbGd/9yIeKjEE=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -764,6 +707,8 @@ golang.org/x/oauth2 v0.0.0-20210805134026-6f1e6394065a/go.mod h1:KelEdhl1UZF7XfJ
 golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
 golang.org/x/oauth2 v0.0.0-20211005180243-6b3c2da341f1/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
 golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
+golang.org/x/oauth2 v0.2.0 h1:GtQkldQ9m7yvzCL1V+LrYow3Khe0eJH0w7RbX/VbaIU=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -775,14 +720,14 @@ golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4 h1:uVc8UZUe6tr40fFVnUP5Oj+veunVezqYl9z7DYw9xzw=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190130150945-aca44879d564/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -793,7 +738,6 @@ golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190922100055-0a153f010e69/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -854,8 +798,6 @@ golang.org/x/sys v0.0.0-20210923061019-b8560ed6a9b7/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211106132015-ebca88c72f68/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211116061358-0a5406a5449c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211205182925-97ca703d548d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -881,16 +823,14 @@ golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.4.0 h1:BrVqGRd7+k1DiOgtnFvAkoQEWQvBc25ouMJM6429SFg=
 golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.5.0 h1:OLmvp0KP+FVG99Ct/qFiL/Fhk4zp4QQnZ7b2U+5piUM=
+golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190206041539-40960b6deb8e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
@@ -902,7 +842,6 @@ golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgw
 golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
 golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
 golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20190828213141-aed303cbaa74/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20190907020128-2ca718005c18/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
@@ -953,10 +892,6 @@ golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8T
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 h1:H2TDz8ibqkAF6YGhCdN3jS9O0/s90v0rJh3X/OLHEUk=
 golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
-gonum.org/v1/gonum v0.0.0-20180816165407-929014505bf4/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo=
-gonum.org/v1/gonum v0.8.2/go.mod h1:oe/vMfY3deqTw+1EZJhuvEW2iwGF1bW9wwu7XCu0+v0=
-gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw=
-gonum.org/v1/plot v0.0.0-20190515093506-e2840ee46a6b/go.mod h1:Wt8AAjI+ypCyYX3nZBvf6cAIx93T+c/OS2HFAYskSZc=
 google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
 google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
 google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
@@ -987,7 +922,6 @@ google.golang.org/api v0.55.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqiv
 google.golang.org/api v0.56.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE=
 google.golang.org/api v0.57.0/go.mod h1:dVPlbZyBo2/OjBpmvNdpn2GRm6rPy75jyU7bmhdrMgI=
 google.golang.org/api v0.59.0/go.mod h1:sT2boj7M9YJxZzgeZqXogmhfmRWDtPzT31xkieUbuZU=
-google.golang.org/api v0.60.0/go.mod h1:d7rl65NZAkEQ90JFzqBjcRq1TVeG5ZoGV3sSpEnnVb4=
 google.golang.org/api v0.61.0/go.mod h1:xQRti5UdCmoCEqFxcz93fTl338AVqDgyaDRuOZ3hg9I=
 google.golang.org/api v0.62.0/go.mod h1:dKmwPCydfsad4qCH08MSdgWjfHOyfpd4VtDGgRFdavw=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
@@ -996,6 +930,7 @@ google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7
 google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
 google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
 google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c=
 google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
@@ -1005,7 +940,6 @@ google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRn
 google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
 google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
 google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
-google.golang.org/genproto v0.0.0-20190927181202-20e1ac93f88c/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
 google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
 google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
 google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
@@ -1019,16 +953,13 @@ google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfG
 google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
 google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
 google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200423170343-7949de9c1215/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
 google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
 google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
 google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
 google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=
 google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
-google.golang.org/genproto v0.0.0-20200528191852-705c0b31589b/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
 google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
 google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20200731012542-8145dea6a485/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
 google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
 google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
 google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
@@ -1043,7 +974,6 @@ google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6D
 google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
 google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
 google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A=
-google.golang.org/genproto v0.0.0-20210406143921-e86de6bf7a46/go.mod h1:P3QM42oQyzQSnHPnZ/vqoCdDmzH28fzWByN9asMeM8A=
 google.golang.org/genproto v0.0.0-20210513213006-bf773b8c8384/go.mod h1:P3QM42oQyzQSnHPnZ/vqoCdDmzH28fzWByN9asMeM8A=
 google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
 google.golang.org/genproto v0.0.0-20210604141403-392c879c8b08/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
@@ -1059,26 +989,21 @@ google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71/go.mod h1:eFjDcFEc
 google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
 google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
 google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
-google.golang.org/genproto v0.0.0-20210921142501-181ce0d877f6/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
 google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
 google.golang.org/genproto v0.0.0-20211008145708-270636b82663/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
-google.golang.org/genproto v0.0.0-20211021150943-2b146023228c/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
 google.golang.org/genproto v0.0.0-20211027162914-98a5263abeca/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
 google.golang.org/genproto v0.0.0-20211028162531-8db9c33dc351/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
-google.golang.org/genproto v0.0.0-20211104193956-4c6863e31247/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
-google.golang.org/genproto v0.0.0-20211116182654-e63d96a377c4/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
 google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
 google.golang.org/genproto v0.0.0-20211129164237-f09f9a12af12/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
 google.golang.org/genproto v0.0.0-20211203200212-54befc351ae9/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
 google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
 google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
-google.golang.org/genproto v0.0.0-20220930163606-c98284e70a91 h1:Ezh2cpcnP5Rq60sLensUsFnxh7P6513NLvNtCm9iyJ4=
-google.golang.org/genproto v0.0.0-20220930163606-c98284e70a91/go.mod h1:3526vdqwhZAwq4wsRUaVG555sVgsNmIjRtO7t/JH29U=
+google.golang.org/genproto v0.0.0-20221207170731-23e4bf6bdc37 h1:jmIfw8+gSvXcZSgaFAGyInDXeWzUhvYH57G/5GKMn70=
+google.golang.org/genproto v0.0.0-20221207170731-23e4bf6bdc37/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
 google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
 google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
-google.golang.org/grpc v1.24.0/go.mod h1:XDChyiUovWa60DnaeDeZmSW86xtLtjtZbwvSiRnRtcA=
 google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
 google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
 google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
@@ -1103,8 +1028,8 @@ google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9K
 google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
 google.golang.org/grpc v1.41.0/go.mod h1:U3l9uK9J0sini8mHphKoXyaqDA/8VyGnDee1zzIUK6k=
 google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU=
-google.golang.org/grpc v1.49.0 h1:WTLtQzmQori5FUH25Pq4WT22oCsv8USpQ+F6rqtsmxw=
-google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
+google.golang.org/grpc v1.51.0 h1:E1eGv1FTqoLIdnBCZufiSHgKjlqG6fKFf6pPWtMTh8U=
+google.golang.org/grpc v1.51.0/go.mod h1:wgNDFcnuBGmxLKI/qn4T+m5BtEBYXJPvibbUPsAIPww=
 google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
@@ -1128,13 +1053,10 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
-gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/ini.v1 v1.63.2/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/ini.v1 v1.66.2/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
 gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
-gopkg.in/jcmturner/gokrb5.v7 v7.5.0/go.mod h1:l8VISx+WGYp+Fp7KRbsiUuXTTOnxIc3Tuvyavf11/WM=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
@@ -1158,6 +1080,5 @@ honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt
 honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
 honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
 rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
-rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
 rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
 rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=

services/chaintime/standard/parameters.go

@@ -20,10 +20,9 @@ import (
 )
 
 type parameters struct {
-	logLevel             zerolog.Level
-	genesisTimeProvider  eth2client.GenesisTimeProvider
-	specProvider         eth2client.SpecProvider
-	forkScheduleProvider eth2client.ForkScheduleProvider
+	logLevel            zerolog.Level
+	genesisTimeProvider eth2client.GenesisTimeProvider
+	specProvider        eth2client.SpecProvider
 }
 
 // Parameter is the interface for service parameters.
@@ -58,13 +57,6 @@ func WithSpecProvider(provider eth2client.SpecProvider) Parameter {
 	})
 }
 
-// WithForkScheduleProvider sets the fork schedule provider.
-func WithForkScheduleProvider(provider eth2client.ForkScheduleProvider) Parameter {
-	return parameterFunc(func(p *parameters) {
-		p.forkScheduleProvider = provider
-	})
-}
-
 // parseAndCheckParameters parses and checks parameters to ensure that mandatory parameters are present and correct.
 func parseAndCheckParameters(params ...Parameter) (*parameters, error) {
 	parameters := parameters{
@@ -82,9 +74,6 @@ func parseAndCheckParameters(params ...Parameter) (*parameters, error) {
 	if parameters.genesisTimeProvider == nil {
 		return nil, errors.New("no genesis time provider specified")
 	}
-	if parameters.forkScheduleProvider == nil {
-		return nil, errors.New("no fork schedule provider specified")
-	}
 
 	return &parameters, nil
 }

services/chaintime/standard/service.go

@@ -14,7 +14,6 @@
 package standard
 
 import (
-	"bytes"
 	"context"
 	"time"
 
@@ -87,21 +86,21 @@ func New(ctx context.Context, params ...Parameter) (*Service, error) {
 		epochsPerSyncCommitteePeriod = tmp2
 	}
 
-	altairForkEpoch, err := fetchAltairForkEpoch(ctx, parameters.forkScheduleProvider)
+	altairForkEpoch, err := fetchAltairForkEpoch(ctx, parameters.specProvider)
 	if err != nil {
 		// Set to far future epoch.
 		altairForkEpoch = 0xffffffffffffffff
 	}
 	log.Trace().Uint64("epoch", uint64(altairForkEpoch)).Msg("Obtained Altair fork epoch")
 
-	bellatrixForkEpoch, err := fetchBellatrixForkEpoch(ctx, parameters.forkScheduleProvider)
+	bellatrixForkEpoch, err := fetchBellatrixForkEpoch(ctx, parameters.specProvider)
 	if err != nil {
 		// Set to far future epoch.
 		bellatrixForkEpoch = 0xffffffffffffffff
 	}
 	log.Trace().Uint64("epoch", uint64(bellatrixForkEpoch)).Msg("Obtained Bellatrix fork epoch")
 
-	capellaForkEpoch, err := fetchCapellaForkEpoch(ctx, parameters.forkScheduleProvider)
+	capellaForkEpoch, err := fetchCapellaForkEpoch(ctx, parameters.specProvider)
 	if err != nil {
 		// Set to far future epoch.
 		capellaForkEpoch = 0xffffffffffffffff
@@ -217,19 +216,28 @@ func (s *Service) AltairInitialSyncCommitteePeriod() uint64 {
 	return uint64(s.altairForkEpoch) / s.epochsPerSyncCommitteePeriod
 }
 
-func fetchAltairForkEpoch(ctx context.Context, provider eth2client.ForkScheduleProvider) (phase0.Epoch, error) {
-	forkSchedule, err := provider.ForkSchedule(ctx)
+func fetchAltairForkEpoch(ctx context.Context,
+	specProvider eth2client.SpecProvider,
+) (
+	phase0.Epoch,
+	error,
+) {
+	// Fetch the fork version.
+	spec, err := specProvider.Spec(ctx)
 	if err != nil {
-		return 0, err
+		return 0, errors.Wrap(err, "failed to obtain spec")
 	}
-	for i := range forkSchedule {
-		if bytes.Equal(forkSchedule[i].CurrentVersion[:], forkSchedule[i].PreviousVersion[:]) {
-			// This is the genesis fork; ignore it.
-			continue
-		}
-		return forkSchedule[i].Epoch, nil
+	tmp, exists := spec["ALTAIR_FORK_EPOCH"]
+	if !exists {
+		return 0, errors.New("altair fork version not known by chain")
 	}
-	return 0, errors.New("no altair fork obtained")
+	epoch, isEpoch := tmp.(uint64)
+	if !isEpoch {
+		//nolint:revive
+		return 0, errors.New("ALTAIR_FORK_EPOCH is not a uint64!")
+	}
+
+	return phase0.Epoch(epoch), nil
 }
 
 // BellatrixInitialEpoch provides the epoch at which the Bellatrix hard fork takes place.
@@ -237,24 +245,28 @@ func (s *Service) BellatrixInitialEpoch() phase0.Epoch {
 	return s.bellatrixForkEpoch
 }
 
-func fetchBellatrixForkEpoch(ctx context.Context, provider eth2client.ForkScheduleProvider) (phase0.Epoch, error) {
-	forkSchedule, err := provider.ForkSchedule(ctx)
+func fetchBellatrixForkEpoch(ctx context.Context,
+	specProvider eth2client.SpecProvider,
+) (
+	phase0.Epoch,
+	error,
+) {
+	// Fetch the fork version.
+	spec, err := specProvider.Spec(ctx)
 	if err != nil {
-		return 0, err
+		return 0, errors.Wrap(err, "failed to obtain spec")
 	}
-	count := 0
-	for i := range forkSchedule {
-		count++
-		if bytes.Equal(forkSchedule[i].CurrentVersion[:], forkSchedule[i].PreviousVersion[:]) {
-			// This is the genesis fork; ignore it.
-			continue
-		}
-		if count == 1 {
-			return forkSchedule[i].Epoch, nil
-		}
-		count++
+	tmp, exists := spec["BELLATRIX_FORK_EPOCH"]
+	if !exists {
+		return 0, errors.New("bellatrix fork version not known by chain")
 	}
-	return 0, errors.New("no bellatrix fork obtained")
+	epoch, isEpoch := tmp.(uint64)
+	if !isEpoch {
+		//nolint:revive
+		return 0, errors.New("BELLATRIX_FORK_EPOCH is not a uint64!")
+	}
+
+	return phase0.Epoch(epoch), nil
 }
 
 // CapellaInitialEpoch provides the epoch at which the Capella hard fork takes place.
@@ -262,22 +274,26 @@ func (s *Service) CapellaInitialEpoch() phase0.Epoch {
 	return s.capellaForkEpoch
 }
 
-func fetchCapellaForkEpoch(ctx context.Context, provider eth2client.ForkScheduleProvider) (phase0.Epoch, error) {
-	forkSchedule, err := provider.ForkSchedule(ctx)
+func fetchCapellaForkEpoch(ctx context.Context,
+	specProvider eth2client.SpecProvider,
+) (
+	phase0.Epoch,
+	error,
+) {
+	// Fetch the fork version.
+	spec, err := specProvider.Spec(ctx)
 	if err != nil {
-		return 0, err
+		return 0, errors.Wrap(err, "failed to obtain spec")
 	}
-	count := 0
-	for i := range forkSchedule {
-		count++
-		if bytes.Equal(forkSchedule[i].CurrentVersion[:], forkSchedule[i].PreviousVersion[:]) {
-			// This is the genesis fork; ignore it.
-			continue
-		}
-		if count == 2 {
-			return forkSchedule[i].Epoch, nil
-		}
-		count++
+	tmp, exists := spec["CAPELLAELLATRIX_FORK_EPOCH"]
+	if !exists {
+		return 0, errors.New("capella fork version not known by chain")
 	}
-	return 0, errors.New("no capella fork obtained")
+	epoch, isEpoch := tmp.(uint64)
+	if !isEpoch {
+		//nolint:revive
+		return 0, errors.New("CAPELLAELLATRIX_FORK_EPOCH is not a uint64!")
+	}
+
+	return phase0.Epoch(epoch), nil
 }

services/chaintime/standard/service_test.go

@@ -31,22 +31,9 @@ func TestService(t *testing.T) {
 	slotDuration := 12 * time.Second
 	slotsPerEpoch := uint64(32)
 	epochsPerSyncCommitteePeriod := uint64(256)
-	forkSchedule := []*phase0.Fork{
-		{
-			PreviousVersion: phase0.Version{0x01, 0x02, 0x03, 0x04},
-			CurrentVersion:  phase0.Version{0x01, 0x02, 0x03, 0x04},
-			Epoch:           0,
-		},
-		{
-			PreviousVersion: phase0.Version{0x01, 0x02, 0x03, 0x04},
-			CurrentVersion:  phase0.Version{0x05, 0x06, 0x07, 0x08},
-			Epoch:           10,
-		},
-	}
 
 	mockGenesisTimeProvider := mock.NewGenesisTimeProvider(genesisTime)
 	mockSpecProvider := mock.NewSpecProvider(slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod)
-	mockForkScheduleProvider := mock.NewForkScheduleProvider(forkSchedule)
 
 	tests := []struct {
 		name   string
@@ -58,7 +45,6 @@ func TestService(t *testing.T) {
 			params: []standard.Parameter{
 				standard.WithLogLevel(zerolog.Disabled),
 				standard.WithSpecProvider(mockSpecProvider),
-				standard.WithForkScheduleProvider(mockForkScheduleProvider),
 			},
 			err: "problem with parameters: no genesis time provider specified",
 		},
@@ -67,26 +53,15 @@ func TestService(t *testing.T) {
 			params: []standard.Parameter{
 				standard.WithLogLevel(zerolog.Disabled),
 				standard.WithGenesisTimeProvider(mockGenesisTimeProvider),
-				standard.WithForkScheduleProvider(mockForkScheduleProvider),
 			},
 			err: "problem with parameters: no spec provider specified",
 		},
-		{
-			name: "ForkScheduleProviderMissing",
-			params: []standard.Parameter{
-				standard.WithLogLevel(zerolog.Disabled),
-				standard.WithGenesisTimeProvider(mockGenesisTimeProvider),
-				standard.WithSpecProvider(mockSpecProvider),
-			},
-			err: "problem with parameters: no fork schedule provider specified",
-		},
 		{
 			name: "Good",
 			params: []standard.Parameter{
 				standard.WithLogLevel(zerolog.Disabled),
 				standard.WithGenesisTimeProvider(mockGenesisTimeProvider),
 				standard.WithSpecProvider(mockSpecProvider),
-				standard.WithForkScheduleProvider(mockForkScheduleProvider),
 			},
 		},
 	}
@@ -123,11 +98,9 @@ func createService(genesisTime time.Time) (chaintime.Service, time.Duration, uin
 
 	mockGenesisTimeProvider := mock.NewGenesisTimeProvider(genesisTime)
 	mockSpecProvider := mock.NewSpecProvider(slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod)
-	mockForkScheduleProvider := mock.NewForkScheduleProvider(forkSchedule)
 	s, err := standard.New(context.Background(),
 		standard.WithGenesisTimeProvider(mockGenesisTimeProvider),
 		standard.WithSpecProvider(mockSpecProvider),
-		standard.WithForkScheduleProvider(mockForkScheduleProvider),
 	)
 	return s, slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod, forkSchedule, err
 }

util/account.go

@@ -61,7 +61,7 @@ func ParseAccount(ctx context.Context,
 			// Private key.
 			account, err = newScratchAccountFromPrivKey(data)
 			if err != nil {
-				return nil, errors.Wrap(err, "failed to create account from public key")
+				return nil, errors.Wrap(err, "failed to create account from private key")
 			}
 			if unlock {
 				_, err = UnlockAccount(ctx, account, nil)

util/epoch.go

@@ -24,11 +24,15 @@ import (
 
 // ParseEpoch parses input to calculate the desired epoch.
 func ParseEpoch(ctx context.Context, chainTime chaintime.Service, epochStr string) (phase0.Epoch, error) {
+	currentEpoch := chainTime.CurrentEpoch()
 	switch epochStr {
-	case "", "current":
-		return chainTime.CurrentEpoch(), nil
+	case "", "current", "-0":
+		return currentEpoch, nil
 	case "last":
-		return chainTime.CurrentEpoch() - 1, nil
+		if currentEpoch > 0 {
+			currentEpoch--
+		}
+		return currentEpoch, nil
 	default:
 		val, err := strconv.ParseInt(epochStr, 10, 64)
 		if err != nil {
@@ -37,6 +41,9 @@ func ParseEpoch(ctx context.Context, chainTime chaintime.Service, epochStr strin
 		if val >= 0 {
 			return phase0.Epoch(val), nil
 		}
-		return chainTime.CurrentEpoch() + phase0.Epoch(val), nil
+		if phase0.Epoch(-val) > currentEpoch {
+			return 0, nil
+		}
+		return currentEpoch + phase0.Epoch(val), nil
 	}
 }

util/epoch_test.go

@@ -0,0 +1,105 @@
+// Copyright © 2032 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 util_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/rs/zerolog"
+	"github.com/stretchr/testify/require"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
+	"github.com/wealdtech/ethdo/testing/mock"
+	"github.com/wealdtech/ethdo/util"
+)
+
+func TestParseEpoch(t *testing.T) {
+	ctx := context.Background()
+
+	// genesis is 1 day ago.
+	genesisTime := time.Now().AddDate(0, 0, -1)
+	slotDuration := 12 * time.Second
+	slotsPerEpoch := uint64(32)
+	epochsPerSyncCommitteePeriod := uint64(256)
+	mockGenesisTimeProvider := mock.NewGenesisTimeProvider(genesisTime)
+	mockSpecProvider := mock.NewSpecProvider(slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod)
+	chainTime, err := standardchaintime.New(context.Background(),
+		standardchaintime.WithLogLevel(zerolog.Disabled),
+		standardchaintime.WithGenesisTimeProvider(mockGenesisTimeProvider),
+		standardchaintime.WithSpecProvider(mockSpecProvider),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name     string
+		input    string
+		err      string
+		expected phase0.Epoch
+	}{
+		{
+			name:     "Genesis",
+			input:    "0",
+			expected: 0,
+		},
+		{
+			name:  "Invalid",
+			input: "invalid",
+			err:   `failed to parse epoch: strconv.ParseInt: parsing "invalid": invalid syntax`,
+		},
+		{
+			name:     "Absolute",
+			input:    "15",
+			expected: 15,
+		},
+		{
+			name:     "Current",
+			input:    "current",
+			expected: 225,
+		},
+		{
+			name:     "Last",
+			input:    "last",
+			expected: 224,
+		},
+		{
+			name:     "RelativeZero",
+			input:    "-0",
+			expected: 225,
+		},
+		{
+			name:     "Relative",
+			input:    "-5",
+			expected: 220,
+		},
+		{
+			name:     "RelativeFar",
+			input:    "-500",
+			expected: 0,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			epoch, err := util.ParseEpoch(ctx, chainTime, test.input)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.expected, epoch)
+			}
+		})
+	}
+}

util/misc.go

@@ -1,4 +1,4 @@
-// Copyright © 2019 Weald Technology Trading
+// Copyright © 2019, 2022 Weald Technology Trading
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -114,7 +114,12 @@ func WalletFromPath(ctx context.Context, path string) (e2wtypes.Wallet, error) {
 			return nil, errors.Wrap(err, "failed to parse remote servers")
 		}
 
-		return dirk.OpenWallet(ctx, walletName, credentials, endpoints)
+		return dirk.Open(ctx,
+			dirk.WithName(walletName),
+			dirk.WithCredentials(credentials),
+			dirk.WithEndpoints(endpoints),
+			dirk.WithTimeout(viper.GetDuration("timeout")),
+		)
 	}
 	wallet, err := e2wallet.OpenWallet(walletName)
 	if err != nil {