Update dependencies.

Provide access to public endpoint if no other connection available.

.github/workflows/golangci-lint.yml

@@ -15,12 +15,9 @@ jobs:
     steps:
       - uses: actions/setup-go@v3
         with:
-          go-version: 1.18
+          go-version: '1.20'
       - uses: actions/checkout@v3
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v3
         with:
-          # https://github.com/golangci/golangci-lint-action/issues/535
-          version: v1.47.3
-          # version: latest
           args: --timeout=60m

.github/workflows/release.yml

@@ -59,6 +59,10 @@ jobs:
 
       - name: Compile
         run: |
+          # Do not attempt to upgrade grub, as it errors on github (24th Feb 2023)
+          sudo apt-mark hold grub-efi-amd64-signed grub-efi-amd64-bin
+          sudo apt-get update
+          sudo apt-get upgrade
           go build -tags osusergo,netgo -v -ldflags="-X github.com/${{ github.repository }}/cmd.ReleaseVersion=${{ needs.env_vars.outputs.release_version }} -extldflags -static"
           tar zcf ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-linux-amd64.tar.gz ${{ needs.env_vars.outputs.binary }}
           sha256sum ${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-linux-amd64.tar.gz | sed -e 's/ .*//' >${{ needs.env_vars.outputs.binary }}-${{ needs.env_vars.outputs.release_version }}-linux-amd64.tar.gz.sha256
@@ -84,8 +88,6 @@ jobs:
 
       - name: Cross compile (ARM64)
         run: |
-          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 -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 }}

.github/workflows/test.yml

@@ -10,6 +10,6 @@ jobs:
     steps:
       - uses: actions/setup-go@v3
         with:
-          go-version: 1.19
+          go-version: '1.20'
       - uses: actions/checkout@v3
       - uses: n8maninger/action-golang-test@v1

.golangci.yml

@@ -151,6 +151,7 @@ linters:
     - lll
     - maintidx
     - maligned
+    - musttag
     - nestif
     - nilnil
     - nlreturn

CHANGELOG.md

@@ -1,3 +1,11 @@
+1.28.2:
+  - fix bix stopping validator exit creation by direct validator specification
+
+1.28.1:
+  - generate error message if "validator credentials set" process fails to generate any credentials
+  - allow import of accounts with null name field in their keystore
+  - show text of execution payload extra data if available
+
 1.28.0:
   - support additional mnemonic word list languages
   - increase minimum timeout for commands that fetch all validators to 2 minutes

beacon/chaininfo.go

@@ -176,7 +176,11 @@ func (c *ChainInfo) FetchValidatorInfo(ctx context.Context, id string) (*Validat
 	case id == "":
 		return nil, errors.New("no validator specified")
 	case strings.HasPrefix(id, "0x"):
-		// A public key.
+		// ID is a public key.
+		// Check that the key is the correct length.
+		if len(id) != 98 {
+			return nil, errors.New("invalid public key: incorrect length")
+		}
 		for _, validator := range c.Validators {
 			if strings.EqualFold(id, fmt.Sprintf("%#x", validator.Pubkey)) {
 				validatorInfo = validator

cmd/account/import/process.go

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

cmd/block/info/output.go

@@ -690,7 +690,11 @@ func outputCapellaBlockExecutionPayload(ctx context.Context,
 		res.WriteString("  State root: ")
 		res.WriteString(fmt.Sprintf("%#x\n", payload.StateRoot))
 		res.WriteString("  Extra data: ")
-		res.WriteString(fmt.Sprintf("%#x\n", payload.ExtraData))
+		if utf8.Valid(payload.ExtraData) {
+			res.WriteString(fmt.Sprintf("%s\n", string(payload.ExtraData)))
+		} else {
+			res.WriteString(fmt.Sprintf("%#x\n", payload.ExtraData))
+		}
 		res.WriteString("  Logs bloom: ")
 		res.WriteString(fmt.Sprintf("%#x\n", payload.LogsBloom))
 		res.WriteString("  Transactions: ")

cmd/chain/eth1votes/process.go

@@ -75,7 +75,7 @@ func (c *command) process(ctx context.Context) error {
 
 	switch state.Version {
 	case spec.DataVersionPhase0:
-		c.slot = phase0.Slot(state.Phase0.Slot)
+		c.slot = state.Phase0.Slot
 		c.incumbent = state.Phase0.ETH1Data
 		c.eth1DataVotes = state.Phase0.ETH1DataVotes
 	case spec.DataVersionAltair:

cmd/nodeinfo.go

@@ -24,6 +24,9 @@ import (
 	"github.com/wealdtech/ethdo/util"
 )
 
+// defaultBeaconNode is used if no other connection is supplied.
+var defaultBeaconNode = "http://mainnet-consensus.attestant.io/"
+
 var nodeInfoCmd = &cobra.Command{
 	Use:   "info",
 	Short: "Obtain information about a node",
@@ -36,7 +39,26 @@ In quiet mode this will return 0 if the node information can be obtained, otherw
 		ctx := context.Background()
 
 		eth2Client, err := util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
-		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
+		if err != nil {
+			if viper.GetString("connection") != "" {
+				// The user provided a connection, so don't second-guess them by using a different node.
+				fmt.Fprintln(os.Stderr, err.Error())
+				return
+			}
+
+			// The user did not provide a connection, so attempt to use the default node.
+			if viper.GetBool("debug") {
+				fmt.Fprintf(os.Stderr, "No node connection, attempting to use %s\n", defaultBeaconNode)
+			}
+			eth2Client, err = util.ConnectToBeaconNode(ctx, defaultBeaconNode, viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
+			if err != nil {
+				fmt.Fprintln(os.Stderr, err.Error())
+				return
+			}
+			if !viper.GetBool("quiet") {
+				fmt.Fprintf(os.Stderr, "No connection supplied; using mainnet public access endpoint\n")
+			}
+		}
 
 		if quiet {
 			os.Exit(_exitSuccess)

cmd/validator/credentials/set/process.go

@@ -44,6 +44,9 @@ import (
 // a lot of data for an unsophisticated audience so it's easier to set a higher timeout..
 var minTimeout = 2 * time.Minute
 
+// defaultBeaconNode is used if no other connection is supplied.
+var defaultBeaconNode = "http://mainnet-consensus.attestant.io/"
+
 // validatorPath is the regular expression that matches a validator  path.
 var validatorPath = regexp.MustCompile("^m/12381/3600/[0-9]+/0/0$")
 
@@ -73,6 +76,10 @@ func (c *command) process(ctx context.Context) error {
 		return err
 	}
 
+	if len(c.signedOperations) == 0 {
+		return errors.New("no suitable validators found; no operations generated")
+	}
+
 	if validated, reason := c.validateOperations(ctx); !validated {
 		return fmt.Errorf("operation failed validation: %s", reason)
 	}
@@ -161,9 +168,18 @@ func (c *command) generateOperationFromMnemonicAndPath(ctx context.Context) erro
 		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 {
+	found, err := c.generateOperationFromSeedAndPath(ctx, validators, seed, validatorKeyPath)
+	if err != nil {
 		return errors.Wrap(err, "failed to generate operation from seed and path")
 	}
+	// Function `c.generateOperationFromSeedAndPath()` will not return errors
+	// in non-serious cases since it is called in a loop when searching a
+	// mnemonic's key space without a specific path, so we need to check if a
+	// validator was not found in our case (it should be found if a path is
+	// provided) and return an error if not.
+	if !found {
+		return errors.New("no validator found with the provided path and mnemonic, please run with --debug to see more information")
+	}
 
 	return nil
 }
@@ -188,7 +204,7 @@ func (c *command) generateOperationFromMnemonicAndValidator(ctx context.Context)
 			if c.debug {
 				fmt.Fprintf(os.Stderr, "Gone %d indices without finding the validator, not scanning any further\n", maxDistance)
 			}
-			break
+			return fmt.Errorf("failed to find validator using the provided mnemonic, validator=%s, pubkey=%#x", c.validator, validatorInfo.Pubkey)
 		}
 		validatorKeyPath := fmt.Sprintf("m/12381/3600/%d/0/0", i)
 		validatorPrivkey, err := ethutil.PrivateKeyFromSeedAndPath(seed, validatorKeyPath)
@@ -234,10 +250,13 @@ func (c *command) generateOperationsFromMnemonic(ctx context.Context) error {
 	maxDistance := 1024
 	// Start scanning the validator keys.
 	lastFoundIndex := 0
+	foundValidatorCount := 0
 	for i := 0; ; i++ {
+		// If no validators have been found in the last maxDistance indices, stop scanning.
 		if i-lastFoundIndex > maxDistance {
-			if c.debug {
-				fmt.Fprintf(os.Stderr, "Gone %d indices without finding a validator, not scanning any further\n", maxDistance)
+			// If no validators were found at all, return an error.
+			if foundValidatorCount == 0 {
+				return fmt.Errorf("failed to find validators using the provided mnemonic: searched %d indices without finding a validator", maxDistance)
 			}
 			break
 		}
@@ -249,6 +268,7 @@ func (c *command) generateOperationsFromMnemonic(ctx context.Context) error {
 		}
 		if found {
 			lastFoundIndex = i
+			foundValidatorCount++
 		}
 	}
 	return nil
@@ -327,6 +347,18 @@ func (c *command) generateOperationsFromValidatorAndPrivateKey(ctx context.Conte
 }
 
 func (c *command) generateOperationsFromPrivateKey(ctx context.Context) error {
+	// Verify that the user provided a private key.
+	if strings.HasPrefix(c.privateKey, "0x") {
+		data, err := hex.DecodeString(strings.TrimPrefix(c.privateKey, "0x"))
+		if err != nil {
+			return errors.Wrap(err, "failed to parse account key")
+		}
+		if len(data) != 32 {
+			return errors.New("account key must be 32 bytes")
+		}
+	} else {
+		return errors.New("account key must be a hex string")
+	}
 	// Extract withdrawal account public key from supplied private key.
 	withdrawalAccount, err := util.ParseAccount(ctx, c.privateKey, nil, true)
 	if err != nil {
@@ -339,6 +371,7 @@ func (c *command) generateOperationsFromPrivateKey(ctx context.Context) error {
 	withdrawalCredentials := ethutil.SHA256(pubkey.Marshal())
 	withdrawalCredentials[0] = byte(0) // BLS_WITHDRAWAL_PREFIX
 
+	found := false
 	for _, validatorInfo := range c.chainInfo.Validators {
 		// Skip validators which withdrawal key don't match with supplied withdrawal account public key.
 		if !bytes.Equal(withdrawalCredentials, validatorInfo.WithdrawalCredentials) {
@@ -348,6 +381,10 @@ func (c *command) generateOperationsFromPrivateKey(ctx context.Context) error {
 		if err := c.generateOperationFromAccount(ctx, validatorInfo, withdrawalAccount); err != nil {
 			return err
 		}
+		found = true
+	}
+	if !found {
+		return fmt.Errorf("no validator found with withdrawal credentials %#x", withdrawalCredentials)
 	}
 	return nil
 }
@@ -429,7 +466,7 @@ func (c *command) generateOperationFromSeedAndPath(ctx context.Context,
 	validator, exists := validators[validatorPubkey]
 	if !exists {
 		if c.debug {
-			fmt.Fprintf(os.Stderr, "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
 	}
@@ -547,6 +584,14 @@ func (c *command) createSignedOperation(ctx context.Context,
 }
 
 func (c *command) parseWithdrawalAddress(_ context.Context) error {
+	// Check that a withdrawal address has been provided.
+	if c.withdrawalAddressStr == "" {
+		return errors.New("no withdrawal address provided")
+	}
+	// Check that the withdrawal address contains a 0x prefix.
+	if !strings.HasPrefix(c.withdrawalAddressStr, "0x") {
+		return fmt.Errorf("withdrawal address %s does not contain a 0x prefix", c.withdrawalAddressStr)
+	}
 	withdrawalAddressBytes, err := hex.DecodeString(strings.TrimPrefix(c.withdrawalAddressStr, "0x"))
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain execution address")
@@ -659,15 +704,30 @@ func (c *command) setup(ctx context.Context) error {
 	if c.timeout < minTimeout {
 		if c.debug {
 			fmt.Fprintf(os.Stderr, "Increasing timeout to %v\n", minTimeout)
-			c.timeout = minTimeout
 		}
+		c.timeout = minTimeout
 	}
 
 	// 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")
+		if c.connection != "" {
+			// The user provided a connection, so don't second-guess them by using a different node.
+			return err
+		}
+
+		// The user did not provide a connection, so attempt to use the default node.
+		if c.debug {
+			fmt.Fprintf(os.Stderr, "No node connection, attempting to use %s\n", defaultBeaconNode)
+		}
+		c.consensusClient, err = util.ConnectToBeaconNode(ctx, defaultBeaconNode, c.timeout, c.allowInsecureConnections)
+		if err != nil {
+			return err
+		}
+		if !c.quiet {
+			fmt.Fprintf(os.Stderr, "No connection supplied; using mainnet public access endpoint\n")
+		}
 	}
 
 	// Set up chaintime.

cmd/validator/credentials/set/process_internal_test.go

@@ -26,6 +26,247 @@ import (
 	e2types "github.com/wealdtech/go-eth2-types/v2"
 )
 
+func TestGenerateOperationsFromPrivateKey(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
+		expected []*capella.SignedBLSToExecutionChange
+		err      string
+	}{
+		{
+			name: "WithdrawalAddressNotHexBadChar",
+			command: &command{
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0xhc1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+				privateKey:           "0x67775f030068b4610d6e1bd04948f547305b2502423fcece4c1091d065b44638",
+			},
+			err: "invalid withdrawal address: failed to obtain execution address: encoding/hex: invalid byte: U+0068 'h'",
+		},
+		{
+			name: "WithdrawalAddressNo0xPrefix",
+			command: &command{
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+				privateKey:           "0x67775f030068b4610d6e1bd04948f547305b2502423fcece4c1091d065b44638",
+			},
+			err: "invalid withdrawal address: withdrawal address 8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15 does not contain a 0x prefix",
+		},
+		{
+			name: "ValidatorDoesNotExistInChain",
+			command: &command{
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+				privateKey:           "0x67775f030068b4610d6e1bd04948f547305b2502423fcece4c1091d065b44635",
+			},
+			err: "no validator found with withdrawal credentials 0x00afa1b7f669e09ba5a57ffdd6b140a4c30bc897202d6a8c14d694e361eeb5d3",
+		},
+		{
+			name: "InvalidKey",
+			command: &command{
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+				privateKey:           "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+			},
+			err: "failed to create account from private key: invalid private key: err blsSecretKeyDeserialize ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+		},
+		{
+			name: "PrivateKeyAddressBadChar",
+			command: &command{
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+				privateKey:           "0xh7775f030068b4610d6e1bd04948f547305b2502423fcece4c1091d065b44638",
+			},
+			err: "failed to parse account key: encoding/hex: invalid byte: U+0068 'h'",
+		},
+		{
+			name: "PrivateKeyAddressNo0xPrefix",
+			command: &command{
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+				privateKey:           "67775f030068b4610d6e1bd04948f547305b2502423fcece4c1091d065b44638",
+			},
+			err: "account key must be a hex string",
+		},
+		{
+			name: "PrivateKeyAddressWrongLength",
+			command: &command{
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+				privateKey:           "0x775f030068b4610d6e1bd04948f547305b2502423fcece4c1091d065b44638",
+			},
+			err: "account key must be 32 bytes",
+		},
+		{
+			name: "Good",
+			command: &command{
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+				privateKey:           "0x67775f030068b4610d6e1bd04948f547305b2502423fcece4c1091d065b44638",
+			},
+			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) {
+			err := test.command.generateOperationsFromPrivateKey(ctx)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.expected, test.command.signedOperations)
+			}
+		})
+	}
+}
+
+func TestGenerateOperationsFromMnemonic(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{0xb4, 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",
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+			err: "mnemonic is invalid",
+		},
+		{
+			name: "NoWithdrawalAddressProvided",
+			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),
+			},
+			err: "failed to generate operation from seed and path: invalid withdrawal address: no withdrawal address provided",
+		},
+		{
+			name: "NoValidatorFound",
+			command: &command{
+				mnemonic:             "struggle kangaroo horn sniff cradle soft ethics thunder cycle illegal flock unaware dynamic cinnamon play enforce card tennis inform parent surprise bring relax tail",
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+			err: "failed to find validators using the provided mnemonic: searched 1024 indices without finding 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",
+				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.generateOperationsFromMnemonic(ctx)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.expected, test.command.signedOperations)
+			}
+		})
+	}
+}
+
 func TestGenerateOperationFromMnemonicAndPath(t *testing.T) {
 	ctx := context.Background()
 
@@ -68,7 +309,7 @@ func TestGenerateOperationFromMnemonicAndPath(t *testing.T) {
 			err: "mnemonic is invalid",
 		},
 		{
-			name: "PathInvalid",
+			name: "PathInvalidNoIndex",
 			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",
@@ -78,6 +319,68 @@ func TestGenerateOperationFromMnemonicAndPath(t *testing.T) {
 			},
 			err: "path m/12381/3600/0/0 does not match EIP-2334 format for a validator",
 		},
+		{
+			name: "PathInvlaidIndexNot2334Format",
+			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:                 "1",
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+			err: "path 1 does not match EIP-2334 format for a validator",
+		},
+		{
+			name: "WithdrawalAddressNo0xPrefix",
+			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: "8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+			err: "failed to generate operation from seed and path: invalid withdrawal address: withdrawal address 8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15 does not contain a 0x prefix",
+		},
+		{
+			name: "WithdrawalAddressInvalidLength",
+			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: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac",
+			},
+			err: "failed to generate operation from seed and path: invalid withdrawal address: withdrawal address must be exactly 20 bytes in length",
+		},
+		{
+			name: "WithdrawalAddressMissing",
+			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),
+			},
+			err: "failed to generate operation from seed and path: invalid withdrawal address: no withdrawal address provided",
+		},
+		{
+			name: "InvalidWithdrawalAddressNotHexBarChar",
+			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: "0xrc1Ff978036F2e9d7CC382Eff7B4c8c53C22acaa",
+			},
+			err: "failed to generate operation from seed and path: invalid withdrawal address: failed to obtain execution address: encoding/hex: invalid byte: U+0072 'r'",
+		},
+		{
+			name: "NoValidatorFoundAtGivenPath",
+			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/10/0/0",
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0xrc1Ff978036F2e9d7CC382Eff7B4c8c53C22acaa",
+			},
+			err: "no validator found with the provided path and mnemonic, please run with --debug to see more information",
+		},
 		{
 			name: "Good",
 			command: &command{
@@ -165,6 +468,96 @@ func TestGenerateOperationFromMnemonicAndValidator(t *testing.T) {
 			},
 			err: "no validator specified",
 		},
+		{
+			name: "WithdrawalAddressMissing",
+			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),
+			},
+			err: "invalid withdrawal address: no withdrawal address provided",
+		},
+		{
+			name: "InvalidWithdrawalAddressLength",
+			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: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac",
+			},
+			err: "invalid withdrawal address: withdrawal address must be exactly 20 bytes in length",
+		},
+		{
+			name: "InvalidWithdrawalAddressNo0xPrefix",
+			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: "8c1Ff978036F2e9d7CC382Eff7B4c8c53C22acaa",
+			},
+			err: "invalid withdrawal address: withdrawal address 8c1Ff978036F2e9d7CC382Eff7B4c8c53C22acaa does not contain a 0x prefix",
+		},
+		{
+			name: "InvalidWithdrawalAddressNotHexBadChar",
+			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: "0xrc1Ff978036F2e9d7CC382Eff7B4c8c53C22acaa",
+			},
+			err: "invalid withdrawal address: failed to obtain execution address: encoding/hex: invalid byte: U+0072 'r'",
+		},
+		{
+			name: "ValidatorBeyondMaxDistance",
+			command: &command{
+				mnemonic:             "struggle kangaroo horn sniff cradle soft ethics thunder cycle illegal flock unaware dynamic cinnamon play enforce card tennis inform parent surprise bring relax tail",
+				validator:            "1",
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+			err: "failed to find validator using the provided mnemonic, validator=1, pubkey=0xb3d89e2f29c712c6a9f8e5a269b97617c4a94dd6f6662ab3b07ce9e5434573f15b5c988cd14bbd5804f77156a8af1cfa",
+		},
+		{
+			name: "UnknownValidatorPubKey",
+			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:            "0xb384f767d964e100c8a9b21018d08c25ffebae268b3ab6d610353897541971726dbfc3c7463884c68a531515aab94c80",
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+
+			err: "unknown validator",
+		},
+		{
+			name: "UnknownValidatorIndex",
+			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:            "10",
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+
+			err: "unknown validator",
+		},
+		{
+			name: "InvalidPubkeyLength",
+			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:            "0xb384f767d964e100c8a9b21018d08c25ffebae268b3ab6d610353897541971726dbfc3c7463884c68a531515aab94c",
+				chainInfo:            chainInfo,
+				signedOperations:     make([]*capella.SignedBLSToExecutionChange, 0),
+				withdrawalAddressStr: "0x8c1Ff978036F2e9d7CC382Eff7B4c8c53C22ac15",
+			},
+
+			err: "invalid public key: incorrect length",
+		},
 		{
 			name: "Good",
 			command: &command{
@@ -285,8 +678,9 @@ func TestGenerateOperationFromSeedAndPath(t *testing.T) {
 				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",
+			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",
+			generated: false,
 		},
 		{
 			name: "ValidatorCredentialsAlreadySet",
@@ -295,8 +689,9 @@ func TestGenerateOperationFromSeedAndPath(t *testing.T) {
 				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",
+			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",
+			generated: false,
 		},
 		{
 			name: "PrivateKeyInvalid",
@@ -310,6 +705,18 @@ func TestGenerateOperationFromSeedAndPath(t *testing.T) {
 			path: "m/12381/3600/0/0/0",
 			err:  "failed to create account from private key: invalid private key: err blsSecretKeyDeserialize ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
 		},
+		{
+			name: "PrivateKeyDoesNotMatch",
+			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:           "0x67775f030068b4610d6e1bd04948f547305b2502423fcece4c1091d065b44638",
+				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/4/0/0",
+			generated: false,
+		},
 		{
 			name: "Good",
 			command: &command{

cmd/validator/exit/command.go

@@ -82,6 +82,11 @@ func newCommand(_ context.Context) (*command, error) {
 		genesisValidatorsRoot:    viper.GetString("genesis-validators-root"),
 	}
 
+	// Account and validator are synonymous.
+	if c.validator == "" {
+		c.validator = viper.GetString("account")
+	}
+
 	// Timeout is required.
 	if c.timeout == 0 {
 		return nil, errors.New("timeout is required")

cmd/validator/exit/process.go

@@ -183,8 +183,7 @@ func (c *command) generateOperationFromMnemonicAndValidator(ctx context.Context)
 				return errors.Wrap(err, "failed to create withdrawal account")
 			}
 
-			err = c.generateOperationFromAccount(ctx, validatorInfo, validatorAccount, c.chainInfo.Epoch)
-			if err != nil {
+			if err := c.generateOperationFromAccount(ctx, validatorAccount); err != nil {
 				return err
 			}
 			break
@@ -197,24 +196,10 @@ func (c *command) generateOperationFromMnemonicAndValidator(ctx context.Context)
 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")
+		return errors.Wrap(err, "failed to parse 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 {
+	if err = c.generateOperationFromAccount(ctx, validatorAccount); err != nil {
 		return err
 	}
 
@@ -222,17 +207,12 @@ func (c *command) generateOperationFromPrivateKey(ctx context.Context) error {
 }
 
 func (c *command) generateOperationFromValidator(ctx context.Context) error {
-	validatorInfo, err := c.chainInfo.FetchValidatorInfo(ctx, c.validator)
+	validatorAccount, err := util.ParseAccount(ctx, c.validator, c.passphrases, true)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "failed to parse validator account")
 	}
 
-	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 {
+	if err := c.generateOperationFromAccount(ctx, validatorAccount); err != nil {
 		return err
 	}
 
@@ -307,12 +287,19 @@ func (c *command) generateOperationFromSeedAndPath(ctx context.Context,
 }
 
 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)
+	pubKey, err := util.BestPublicKey(account)
+	if err != nil {
+		return err
+	}
+
+	info, err := c.chainInfo.FetchValidatorInfo(ctx, fmt.Sprintf("%#x", pubKey.Marshal()))
+	if err != nil {
+		return err
+	}
+
+	c.signedOperation, err = c.createSignedOperation(ctx, info, account, c.chainInfo.Epoch)
 	return err
 }
 

cmd/validatorexit.go

@@ -57,7 +57,7 @@ func init() {
 	validatorExitCmd.Flags().Int64("epoch", -1, "Epoch at which to exit (defaults to current epoch)")
 	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().String("signed-operation", "", "Use pre-defined JSON signed operation as created by --json to transmit the exit operation (reads from exit-operation.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)")

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.28.0)"
+var ReleaseVersion = "local build (latest release 1.28.3)"
 
 // versionCmd represents the version command.
 var versionCmd = &cobra.Command{

docs/changingwithdrawalcredentials.md

@@ -59,27 +59,33 @@ Here the copy of `ethdo` with access to private keys is on an offline computer,
 ## Preparation
 Regardless of the method selected, preparation must take place on the online computer to ensure that `ethdo` can access your consensus node.  `ethdo` will attempt to find a local consensus node automatically, but if not then an explicit connection value will be required.  To find out if `ethdo` has access to the consensus node run:
 
-```
-ethdo node info --verbose
+```sh
+ethdo node info
 ```
 
 The result should be something similar to the following:
 
 ```
-Version: teku/v22.9.1/linux-x86_64/-privatebuild-openjdk64bitservervm-java-14
 Syncing: false
 ```
 
-It is important to confirm that the "Syncing" value is "false".  If this is "true" it means that the node is currently syncing, and you will need to wait for the process to finish before proceeding.
+Alternatively, the result may look like this:
 
-If this command instead returns an error you will need to add an explicit connection string.  For example, if your consensus node is serving its REST API on port 12345 then you should add `--connection=http://localhost:12345` to all `ethdo` commands in this process, for example:
+```
+No connection supplied; using mainnet public access endpoint
+Syncing: false
+```
+
+which means that a local consensus node was not accessed and instead a public endpoint specifically assigned to handle these operations was used instead.  If you do have a local consensus node but see this message it means that the local node could not be accessed, usually because it is running on a non-standard port.  If this is the case for your configuration, you need to let `ethdo` know where the consensus node's REST API is.  For example, if your consensus node is serving its REST API on port 12345 then you should add `--connection=http://localhost:12345` to all `ethdo` commands in this process, for example:
 
 ```sh
-ethdo --connection=http://localhost:12345 node info --verbose
+ethdo --connection=http://localhost:12345 node info
 ```
 
 Note that some consensus nodes may require configuration to serve their REST API.  Please refer to the documentation of your specific consensus node to enable this.
 
+Regardless of your method used above, it is important to confirm that the "Syncing" value is "false".  If this is "true" it means that the node is currently syncing, and you will need to wait for the process to finish before proceeding.
+
 Once the preparation is complete you should select either basic or advanced operation, depending on your requirements.
 
 ## Basic operation

go.mod

@@ -1,9 +1,9 @@
 module github.com/wealdtech/ethdo
 
-go 1.18
+go 1.20
 
 require (
-	github.com/attestantio/go-eth2-client v0.15.2
+	github.com/attestantio/go-eth2-client v0.15.3
 	github.com/ferranbt/fastssz v0.1.2
 	github.com/gofrs/uuid v4.2.0+incompatible
 	github.com/google/uuid v1.3.0
@@ -21,7 +21,6 @@ require (
 	github.com/spf13/viper v1.13.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
@@ -33,11 +32,11 @@ require (
 	github.com/wealdtech/go-eth2-wallet-hd/v2 v2.6.0
 	github.com/wealdtech/go-eth2-wallet-nd/v2 v2.4.0
 	github.com/wealdtech/go-eth2-wallet-store-filesystem v1.17.0
-	github.com/wealdtech/go-eth2-wallet-store-s3 v1.11.1
+	github.com/wealdtech/go-eth2-wallet-store-s3 v1.11.2
 	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.5.0
+	github.com/wealdtech/go-string2eth v1.2.1
+	golang.org/x/text v0.7.0
 )
 
 require (
@@ -87,9 +86,9 @@ require (
 	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.4.0 // indirect
+	golang.org/x/net v0.7.0 // indirect
 	golang.org/x/sync v0.1.0 // indirect
-	golang.org/x/sys v0.3.0 // indirect
+	golang.org/x/sys v0.5.0 // indirect
 	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect
 	google.golang.org/genproto v0.0.0-20221207170731-23e4bf6bdc37 // indirect
 	google.golang.org/grpc v1.51.0 // indirect

go.sum

@@ -67,8 +67,8 @@ github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmV
 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/go-eth2-client v0.15.2 h1:4EYeA5IBSBypkUMhkkFALzMddaFDdb5PvCl7ORXEl6w=
-github.com/attestantio/go-eth2-client v0.15.2/go.mod h1:/Oh6YTuHmHhgLN/ZnQRKHGc7HdIzGlDkI2vjNZvOsvA=
+github.com/attestantio/go-eth2-client v0.15.3 h1:a4uLBkTkXr5Tq3elxT6IPlDH4910+boQdDS2hTg8THk=
+github.com/attestantio/go-eth2-client v0.15.3/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.44.152 h1:L9aaepO8wHB67gwuGD8VgIYH/cmQDxieCt7FeLa0+fI=
 github.com/aws/aws-sdk-go v1.44.152/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI=
@@ -500,8 +500,6 @@ github.com/subosito/gotenv v1.4.1/go.mod h1:ayKnFf/c6rvx/2iiLrJUk1e6plDbT3edrFNG
 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/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=
@@ -539,8 +537,8 @@ github.com/wealdtech/go-eth2-wallet-store-filesystem v1.16.15/go.mod h1:v/JATYJQ
 github.com/wealdtech/go-eth2-wallet-store-filesystem v1.17.0 h1:cq7k9osiIkaYrdpetPQgk3ozl/dFvmxW364OC/uNuww=
 github.com/wealdtech/go-eth2-wallet-store-filesystem v1.17.0/go.mod h1:Fiw5If3/mgH+qYRKIH+kTpZZ3r6z2KgHUiE5Vf/QrfE=
 github.com/wealdtech/go-eth2-wallet-store-s3 v1.10.0/go.mod h1:DhAm7si8N/5qU1sZ/RLavm87LsOthnWuRyQaGWNFiyI=
-github.com/wealdtech/go-eth2-wallet-store-s3 v1.11.1 h1:q9/p/UfrT7AfR6MYZfr3nQOKdhcLCuKqldqplNHo3Ws=
-github.com/wealdtech/go-eth2-wallet-store-s3 v1.11.1/go.mod h1:azzsylTwr1hnLisDWZJbUz3HToRsrG7ADpLG8TXJgOU=
+github.com/wealdtech/go-eth2-wallet-store-s3 v1.11.2 h1:Lxxfu5YKTzfNlymI8kF04BbC8hIKPr3in06zgHDmow8=
+github.com/wealdtech/go-eth2-wallet-store-s3 v1.11.2/go.mod h1:azzsylTwr1hnLisDWZJbUz3HToRsrG7ADpLG8TXJgOU=
 github.com/wealdtech/go-eth2-wallet-store-scratch v1.6.3/go.mod h1:V4NUofSBIyzoqc5cNZaGciaDm2WFAgSQikRslOyh5Tg=
 github.com/wealdtech/go-eth2-wallet-store-scratch v1.7.0 h1:1dMKx9jtw1v9JrwOPFf2JaOQKmvpMp1GEeuMRiNfq5o=
 github.com/wealdtech/go-eth2-wallet-store-scratch v1.7.0/go.mod h1:O7BitrDeQVtBFNnvYmOYLzJCZAiCf5ur/4IRucIz+S0=
@@ -551,8 +549,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-string2eth v1.2.0 h1:C0E5p78tecZTsGccJc9r/kreFah4EfDs5uUPnS6XXMs=
-github.com/wealdtech/go-string2eth v1.2.0/go.mod h1:RUzsLjJtbZaJ/3UKn9kY19a/vCCUHtEWoUW3uiK6yGU=
+github.com/wealdtech/go-string2eth v1.2.1 h1:u9sofvGFkp+uvTg4Nvsvy5xBaiw8AibGLLngfC4F76g=
+github.com/wealdtech/go-string2eth v1.2.1/go.mod h1:9uwxm18zKZfrReXrGIbdiRYJtbE91iGcj6TezKKEx80=
 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=
@@ -679,7 +677,6 @@ golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96b
 golang.org/x/net v0.0.0-20210410081132-afb366fc7cd1/go.mod h1:9tjilg8BloeKEkVJvy7fQ90B1CfIiPueXVOjqfkSzI8=
 golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20210614182718-04defd469f4e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 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=
@@ -688,8 +685,8 @@ golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su
 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.4.0 h1:Q5QPcMlvfxFTAPV0+07Xz/MpK9NTXu2VDUuy0FeMfaU=
-golang.org/x/net v0.4.0/go.mod h1:MBQ8lrhLObU/6UmLb4fmbmk5OcyYmqtbGd/9yIeKjEE=
+golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g=
+golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 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=
@@ -809,8 +806,8 @@ golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.3.0 h1:w8ZOecv6NaNa/zC8944JTU3vz4u6Lagfk4RPQxv92NQ=
-golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
@@ -824,8 +821,8 @@ 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/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/text v0.7.0 h1:4BRB4x83lYWy72KwLD/qYDuTu7q9PjSagHvijDw7cLo=
+golang.org/x/text v0.7.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=

services/chaintime/service.go

@@ -20,6 +20,7 @@ import (
 )
 
 // Service provides a number of functions for calculating chain-related times.
+//
 //nolint:interfacebloat
 type Service interface {
 	// GenesisTime provides the time of the chain's genesis.

services/chaintime/standard/service.go

@@ -285,14 +285,14 @@ func fetchCapellaForkEpoch(ctx context.Context,
 	if err != nil {
 		return 0, errors.Wrap(err, "failed to obtain spec")
 	}
-	tmp, exists := spec["CAPELLAELLATRIX_FORK_EPOCH"]
+	tmp, exists := spec["CAPELLA_FORK_EPOCH"]
 	if !exists {
 		return 0, errors.New("capella fork version not known by chain")
 	}
 	epoch, isEpoch := tmp.(uint64)
 	if !isEpoch {
 		//nolint:revive
-		return 0, errors.New("CAPELLAELLATRIX_FORK_EPOCH is not a uint64!")
+		return 0, errors.New("CAPELLA_FORK_EPOCH is not a uint64!")
 	}
 
 	return phase0.Epoch(epoch), nil