Update dependencies.

Bump go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc from 0.45.0 to 0.46.0

CHANGELOG.md

@@ -1,3 +1,34 @@
+1.35.2:
+  - update dependencies
+
+1.35.1:
+  - fix output for various commands that may encounter an empty slot
+
+1.35.0:
+  - support Deneb
+  - add start and end dates for eth1votes period
+
+1.34.1:
+  - fix period parsing for "synccommittee members" command
+
+1.34.0:
+  - update dependencies
+  - use Capella fork for all exits
+  - support Deneb beta 5
+
+1.33.2:
+  - fix windows build
+
+1.33.1:
+  - add "slot" to "proposer duties" command
+  - add activation epoch and time to "validator info" command where applicable
+  - add "holesky" to the list of supported networks
+  - avoid crash when requesting validators from beacon node without debug enabled
+
+1.33.0:
+  - show all slots with 'synccommittee inclusion'
+  - add "wallet batch" command
+
 1.32.0:
   - fix incorrect error when "deposit verify" is not given a withdrawal address
   - allow truncated mnemonics (first four characters of each word)

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.20-bullseye as builder
+FROM golang:1.20-bookworm as builder
 
 WORKDIR /app
 
@@ -10,7 +10,7 @@ COPY . .
 
 RUN go build
 
-FROM debian:bullseye-slim
+FROM debian:bookworm-slim
 
 RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt install -y ca-certificates && apt-get clean && rm -rf /var/lib/apt/lists/*
 

README.md

@@ -38,7 +38,7 @@ docker pull wealdtech/ethdo
 go install github.com/wealdtech/ethdo@latest
 ```
 
-Note that `ethdo` requires at least version 1.13 of go to operate.  The version of go can be found with `go version`.
+Note that `ethdo` requires at least version 1.20 of go to operate.  The version of go can be found with `go version`.
 
 If this does not work please see the [troubleshooting](https://github.com/wealdtech/ethdo/blob/master/docs/troubleshooting.md) page.
 

beacon/chaininfo.go

@@ -22,6 +22,7 @@ import (
 	"strings"
 
 	consensusclient "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/wealdtech/ethdo/services/chaintime"
@@ -34,6 +35,7 @@ type ChainInfo struct {
 	GenesisValidatorsRoot          phase0.Root
 	Epoch                          phase0.Epoch
 	GenesisForkVersion             phase0.Version
+	ExitForkVersion                phase0.Version
 	CurrentForkVersion             phase0.Version
 	BLSToExecutionChangeDomainType phase0.DomainType
 	VoluntaryExitDomainType        phase0.DomainType
@@ -45,6 +47,7 @@ type chainInfoJSON struct {
 	GenesisValidatorsRoot          string           `json:"genesis_validators_root"`
 	Epoch                          string           `json:"epoch"`
 	GenesisForkVersion             string           `json:"genesis_fork_version"`
+	ExitForkVersion                string           `json:"exit_fork_version"`
 	CurrentForkVersion             string           `json:"current_fork_version"`
 	BLSToExecutionChangeDomainType string           `json:"bls_to_execution_change_domain_type"`
 	VoluntaryExitDomainType        string           `json:"voluntary_exit_domain_type"`
@@ -57,11 +60,12 @@ type chainInfoVersionJSON struct {
 // MarshalJSON implements json.Marshaler.
 func (c *ChainInfo) MarshalJSON() ([]byte, error) {
 	return json.Marshal(&chainInfoJSON{
-		Version:                        fmt.Sprintf("%d", c.Version),
+		Version:                        strconv.FormatUint(c.Version, 10),
 		Validators:                     c.Validators,
 		GenesisValidatorsRoot:          fmt.Sprintf("%#x", c.GenesisValidatorsRoot),
 		Epoch:                          fmt.Sprintf("%d", c.Epoch),
 		GenesisForkVersion:             fmt.Sprintf("%#x", c.GenesisForkVersion),
+		ExitForkVersion:                fmt.Sprintf("%#x", c.ExitForkVersion),
 		CurrentForkVersion:             fmt.Sprintf("%#x", c.CurrentForkVersion),
 		BLSToExecutionChangeDomainType: fmt.Sprintf("%#x", c.BLSToExecutionChangeDomainType),
 		VoluntaryExitDomainType:        fmt.Sprintf("%#x", c.VoluntaryExitDomainType),
@@ -82,7 +86,7 @@ func (c *ChainInfo) UnmarshalJSON(input []byte) error {
 	if err != nil {
 		return errors.Wrap(err, "version invalid")
 	}
-	if version < 2 {
+	if version < 3 {
 		return errors.New("outdated version; please regenerate your offline data")
 	}
 	c.Version = version
@@ -130,6 +134,18 @@ func (c *ChainInfo) UnmarshalJSON(input []byte) error {
 	}
 	copy(c.GenesisForkVersion[:], genesisForkVersionBytes)
 
+	if data.ExitForkVersion == "" {
+		return errors.New("exit fork version missing")
+	}
+	exitForkVersionBytes, err := hex.DecodeString(strings.TrimPrefix(data.ExitForkVersion, "0x"))
+	if err != nil {
+		return errors.Wrap(err, "exit fork version invalid")
+	}
+	if len(exitForkVersionBytes) != phase0.ForkVersionLength {
+		return errors.New("exit fork version incorrect length")
+	}
+	copy(c.ExitForkVersion[:], exitForkVersionBytes)
+
 	if data.CurrentForkVersion == "" {
 		return errors.New("current fork version missing")
 	}
@@ -235,18 +251,18 @@ func ObtainChainInfoFromNode(ctx context.Context,
 	error,
 ) {
 	res := &ChainInfo{
-		Version:    2,
+		Version:    3,
 		Validators: make([]*ValidatorInfo, 0),
 		Epoch:      chainTime.CurrentEpoch(),
 	}
 
 	// Obtain validators.
-	validators, err := consensusClient.(consensusclient.ValidatorsProvider).Validators(ctx, "head", nil)
+	validatorsResponse, err := consensusClient.(consensusclient.ValidatorsProvider).Validators(ctx, &api.ValidatorsOpts{State: "head"})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain validators")
 	}
 
-	for _, validator := range validators {
+	for _, validator := range validatorsResponse.Data {
 		res.Validators = append(res.Validators, &ValidatorInfo{
 			Index:                 validator.Index,
 			Pubkey:                validator.Validator.PublicKey,
@@ -256,18 +272,18 @@ func ObtainChainInfoFromNode(ctx context.Context,
 	}
 
 	// Genesis validators root obtained from beacon node.
-	genesis, err := consensusClient.(consensusclient.GenesisProvider).Genesis(ctx)
+	genesisResponse, err := consensusClient.(consensusclient.GenesisProvider).Genesis(ctx, &api.GenesisOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain genesis information")
 	}
-	res.GenesisValidatorsRoot = genesis.GenesisValidatorsRoot
+	res.GenesisValidatorsRoot = genesisResponse.Data.GenesisValidatorsRoot
 
 	// Fetch the genesis fork version from the specification.
-	spec, err := consensusClient.(consensusclient.SpecProvider).Spec(ctx)
+	specResponse, err := consensusClient.(consensusclient.SpecProvider).Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain spec")
 	}
-	tmp, exists := spec["GENESIS_FORK_VERSION"]
+	tmp, exists := specResponse.Data["GENESIS_FORK_VERSION"]
 	if !exists {
 		return nil, errors.New("genesis fork version not known by chain")
 	}
@@ -277,24 +293,34 @@ func ObtainChainInfoFromNode(ctx context.Context,
 		return nil, errors.New("could not obtain GENESIS_FORK_VERSION")
 	}
 
+	// Fetch the exit fork version (Capella) from the specification.
+	tmp, exists = specResponse.Data["CAPELLA_FORK_VERSION"]
+	if !exists {
+		return nil, errors.New("capella fork version not known by chain")
+	}
+	res.ExitForkVersion, isForkVersion = tmp.(phase0.Version)
+	if !isForkVersion {
+		return nil, errors.New("could not obtain CAPELLA_FORK_VERSION")
+	}
+
 	// Fetch the current fork version from the fork schedule.
-	forkSchedule, err := consensusClient.(consensusclient.ForkScheduleProvider).ForkSchedule(ctx)
+	forkScheduleResponse, err := consensusClient.(consensusclient.ForkScheduleProvider).ForkSchedule(ctx, &api.ForkScheduleOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain fork schedule")
 	}
-	for i := range forkSchedule {
-		if forkSchedule[i].Epoch <= res.Epoch {
-			res.CurrentForkVersion = forkSchedule[i].CurrentVersion
+	for i := range forkScheduleResponse.Data {
+		if forkScheduleResponse.Data[i].Epoch <= res.Epoch {
+			res.CurrentForkVersion = forkScheduleResponse.Data[i].CurrentVersion
 		}
 	}
 
-	blsToExecutionChangeDomainType, exists := spec["DOMAIN_BLS_TO_EXECUTION_CHANGE"].(phase0.DomainType)
+	blsToExecutionChangeDomainType, exists := specResponse.Data["DOMAIN_BLS_TO_EXECUTION_CHANGE"].(phase0.DomainType)
 	if !exists {
 		return nil, errors.New("failed to obtain DOMAIN_BLS_TO_EXECUTION_CHANGE")
 	}
 	copy(res.BLSToExecutionChangeDomainType[:], blsToExecutionChangeDomainType[:])
 
-	voluntaryExitDomainType, exists := spec["DOMAIN_VOLUNTARY_EXIT"].(phase0.DomainType)
+	voluntaryExitDomainType, exists := specResponse.Data["DOMAIN_VOLUNTARY_EXIT"].(phase0.DomainType)
 	if !exists {
 		return nil, errors.New("failed to obtain DOMAIN_VOLUNTARY_EXIT")
 	}

cmd/account/derive/output.go

@@ -15,6 +15,7 @@ package accountderive
 
 import (
 	"context"
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"os"
@@ -84,7 +85,7 @@ func outputKeystore(_ context.Context, data *dataOut) (string, error) {
 	}
 	ks := make(map[string]interface{})
 	ks["uuid"] = uuid.String()
-	ks["pubkey"] = fmt.Sprintf("%x", data.key.PublicKey().Marshal())
+	ks["pubkey"] = hex.EncodeToString(data.key.PublicKey().Marshal())
 	ks["version"] = 4
 	ks["path"] = data.path
 	ks["crypto"] = crypto

cmd/attester/duties/input.go

@@ -72,7 +72,7 @@ func input(ctx context.Context) (*dataIn, error) {
 
 	data.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(data.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(data.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to set up chaintime service")

cmd/attester/duties/process.go

@@ -17,7 +17,8 @@ import (
 	"context"
 
 	eth2client "github.com/attestantio/go-eth2-client"
-	api "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/api"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
 	spec "github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/wealdtech/ethdo/util"
@@ -49,12 +50,16 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	return results, nil
 }
 
-func duty(ctx context.Context, eth2Client eth2client.Service, validator *api.Validator, epoch spec.Epoch) (*api.AttesterDuty, error) {
+func duty(ctx context.Context, eth2Client eth2client.Service, validator *apiv1.Validator, epoch spec.Epoch) (*apiv1.AttesterDuty, error) {
 	// Find the attesting slot for the given epoch.
-	duties, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, epoch, []spec.ValidatorIndex{validator.Index})
+	dutiesResponse, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, &api.AttesterDutiesOpts{
+		Epoch:   epoch,
+		Indices: []spec.ValidatorIndex{validator.Index},
+	})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain attester duties")
 	}
+	duties := dutiesResponse.Data
 
 	if len(duties) == 0 {
 		return nil, errors.New("validator does not have duty for that epoch")

cmd/attester/duties/process_internal_test.go

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

cmd/attester/inclusion/input.go

@@ -69,7 +69,7 @@ func input(ctx context.Context) (*dataIn, error) {
 
 	data.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(data.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(data.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to set up chaintime service")

cmd/attester/inclusion/output.go

@@ -16,6 +16,7 @@ package attesterinclusion
 import (
 	"context"
 	"fmt"
+	"strconv"
 	"strings"
 
 	"github.com/attestantio/go-eth2-client/spec/phase0"
@@ -49,7 +50,7 @@ func output(_ context.Context, data *dataOut) (string, error) {
 			buf.WriteString("Attestation included in block ")
 			buf.WriteString(fmt.Sprintf("%d", data.slot))
 			buf.WriteString(", index ")
-			buf.WriteString(fmt.Sprintf("%d", data.attestationIndex))
+			buf.WriteString(strconv.FormatUint(data.attestationIndex, 10))
 			if data.verbose {
 				buf.WriteString("\nInclusion delay: ")
 				buf.WriteString(fmt.Sprintf("%d", data.inclusionDelay))

cmd/attester/inclusion/process.go

@@ -17,9 +17,11 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"net/http"
 
 	eth2client "github.com/attestantio/go-eth2-client"
-	api "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/api"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
@@ -38,7 +40,7 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 
 	data.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(data.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(data.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to set up chaintime service")
@@ -61,14 +63,22 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	startSlot := duty.Slot + 1
 	endSlot := startSlot + 32
 	for slot := startSlot; slot < endSlot; slot++ {
-		signedBlock, err := data.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, fmt.Sprintf("%d", slot))
+		blockResponse, err := data.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+			Block: fmt.Sprintf("%d", slot),
+		})
 		if err != nil {
+			var apiErr *api.Error
+			if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+				// No block for this slot, that's fine.
+				continue
+			}
 			return nil, errors.Wrap(err, "failed to obtain block")
 		}
-		if signedBlock == nil {
+		block := blockResponse.Data
+		if block == nil {
 			continue
 		}
-		blockSlot, err := signedBlock.Slot()
+		blockSlot, err := block.Slot()
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to obtain block slot")
 		}
@@ -78,7 +88,7 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		if data.debug {
 			fmt.Printf("Fetched block for slot %d\n", slot)
 		}
-		attestations, err := signedBlock.Attestations()
+		attestations, err := block.Attestations()
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to obtain block attestations")
 		}
@@ -121,21 +131,25 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 func calcHeadCorrect(ctx context.Context, data *dataIn, attestation *phase0.Attestation) (bool, error) {
 	slot := attestation.Data.Slot
 	for {
-		header, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+		response, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
+			Block: fmt.Sprintf("%d", slot),
+		})
 		if err != nil {
+			var apiErr *api.Error
+			if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+				// No block.
+				slot--
+				continue
+			}
+
 			return false, err
 		}
-		if header == nil {
-			// No block.
-			slot--
-			continue
-		}
-		if !header.Canonical {
+		if !response.Data.Canonical {
 			// Not canonical.
 			slot--
 			continue
 		}
-		return bytes.Equal(header.Root[:], attestation.Data.BeaconBlockRoot[:]), nil
+		return bytes.Equal(response.Data.Root[:], attestation.Data.BeaconBlockRoot[:]), nil
 	}
 }
 
@@ -143,30 +157,38 @@ func calcTargetCorrect(ctx context.Context, data *dataIn, attestation *phase0.At
 	// Start with first slot of the target epoch.
 	slot := data.chainTime.FirstSlotOfEpoch(attestation.Data.Target.Epoch)
 	for {
-		header, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+		response, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
+			Block: fmt.Sprintf("%d", slot),
+		})
 		if err != nil {
+			var apiErr *api.Error
+			if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+				// No block.
+				slot--
+				continue
+			}
+
 			return false, err
 		}
-		if header == nil {
-			// No block.
-			slot--
-			continue
-		}
-		if !header.Canonical {
+		if !response.Data.Canonical {
 			// Not canonical.
 			slot--
 			continue
 		}
-		return bytes.Equal(header.Root[:], attestation.Data.Target.Root[:]), nil
+		return bytes.Equal(response.Data.Root[:], attestation.Data.Target.Root[:]), nil
 	}
 }
 
-func duty(ctx context.Context, eth2Client eth2client.Service, validator *api.Validator, epoch phase0.Epoch) (*api.AttesterDuty, error) {
+func duty(ctx context.Context, eth2Client eth2client.Service, validator *apiv1.Validator, epoch phase0.Epoch) (*apiv1.AttesterDuty, error) {
 	// Find the attesting slot for the given epoch.
-	duties, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, epoch, []phase0.ValidatorIndex{validator.Index})
+	dutiesResponse, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, &api.AttesterDutiesOpts{
+		Epoch:   epoch,
+		Indices: []phase0.ValidatorIndex{validator.Index},
+	})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain attester duties")
 	}
+	duties := dutiesResponse.Data
 
 	if len(duties) == 0 {
 		return nil, errors.New("validator does not have duty for that epoch")

cmd/attester/inclusion/process_internal_test.go

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

cmd/block/analyze/output.go

@@ -17,6 +17,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"strconv"
 	"strings"
 )
 
@@ -82,26 +83,26 @@ func (c *command) outputTxt(_ context.Context) (string, error) {
 	for i, attestation := range c.analysis.Attestations {
 		if c.verbose {
 			builder.WriteString("Attestation ")
-			builder.WriteString(fmt.Sprintf("%d", i))
+			builder.WriteString(strconv.Itoa(i))
 			builder.WriteString(": ")
 			builder.WriteString("distance ")
-			builder.WriteString(fmt.Sprintf("%d", attestation.Distance))
+			builder.WriteString(strconv.Itoa(attestation.Distance))
 			builder.WriteString(", ")
 
 			if attestation.Duplicate != nil {
 				builder.WriteString("duplicate of attestation ")
-				builder.WriteString(fmt.Sprintf("%d", attestation.Duplicate.Index))
+				builder.WriteString(strconv.Itoa(attestation.Duplicate.Index))
 				builder.WriteString(" in block ")
 				builder.WriteString(fmt.Sprintf("%d", attestation.Duplicate.Block))
 				builder.WriteString("\n")
 				continue
 			}
 
-			builder.WriteString(fmt.Sprintf("%d", attestation.NewVotes))
+			builder.WriteString(strconv.Itoa(attestation.NewVotes))
 			builder.WriteString("/")
-			builder.WriteString(fmt.Sprintf("%d", attestation.Votes))
+			builder.WriteString(strconv.Itoa(attestation.Votes))
 			builder.WriteString("/")
-			builder.WriteString(fmt.Sprintf("%d", attestation.PossibleVotes))
+			builder.WriteString(strconv.Itoa(attestation.PossibleVotes))
 			builder.WriteString(" new/total/possible votes")
 			if attestation.NewVotes == 0 {
 				builder.WriteString("\n")
@@ -137,7 +138,7 @@ func (c *command) outputTxt(_ context.Context) (string, error) {
 	if c.analysis.SyncCommitee.Contributions > 0 {
 		if c.verbose {
 			builder.WriteString("Sync committee contributions: ")
-			builder.WriteString(fmt.Sprintf("%d", c.analysis.SyncCommitee.Contributions))
+			builder.WriteString(strconv.Itoa(c.analysis.SyncCommitee.Contributions))
 			builder.WriteString(" contributions, score ")
 			builder.WriteString(fmt.Sprintf("%0.3f", c.analysis.SyncCommitee.Score))
 			builder.WriteString(", value ")

cmd/block/analyze/process.go

@@ -19,6 +19,7 @@ import (
 	"fmt"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
@@ -33,13 +34,17 @@ func (c *command) process(ctx context.Context) error {
 		return err
 	}
 
-	block, err := c.blocksProvider.SignedBeaconBlock(ctx, c.blockID)
+	blockResponse, err := c.blocksProvider.SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+		Block: c.blockID,
+	})
 	if err != nil {
+		var apiError *api.Error
+		if errors.As(err, &apiError) && apiError.StatusCode == 404 {
+			return errors.New("empty beacon block")
+		}
 		return errors.Wrap(err, "failed to obtain beacon block")
 	}
-	if block == nil {
-		return errors.New("empty beacon block")
-	}
+	block := blockResponse.Data
 
 	slot, err := block.Slot()
 	if err != nil {
@@ -145,7 +150,7 @@ func (c *command) analyzeAttestations(ctx context.Context, block *spec.Versioned
 			}
 
 			// Calculate head timely.
-			analysis.HeadTimely = attestation.Data.Slot == slot-1
+			analysis.HeadTimely = analysis.HeadCorrect && attestation.Data.Slot == slot-1
 
 			// Calculate source timely.
 			analysis.SourceTimely = attestation.Data.Slot >= slot-5
@@ -157,7 +162,11 @@ func (c *command) analyzeAttestations(ctx context.Context, block *spec.Versioned
 			}
 
 			// Calculate target timely.
-			analysis.TargetTimely = attestation.Data.Slot >= slot-32
+			if block.Version < spec.DataVersionDeneb {
+				analysis.TargetTimely = attestation.Data.Slot >= slot-32
+			} else {
+				analysis.TargetTimely = true
+			}
 		}
 
 		// Calculate score and value.
@@ -184,12 +193,30 @@ func (c *command) fetchParents(ctx context.Context, block *spec.VersionedSignedB
 	if err != nil {
 		return err
 	}
+	root, err := block.Deneb.HashTreeRoot()
+	if err != nil {
+		panic(err)
+	}
+	slot, err := block.Slot()
+	if err != nil {
+		panic(err)
+	}
+	if c.debug {
+		fmt.Printf("Parent root of %#x@%d is %#x\n", root, slot, parentRoot)
+	}
 
 	// Obtain the parent block.
-	parentBlock, err := c.blocksProvider.SignedBeaconBlock(ctx, fmt.Sprintf("%#x", parentRoot))
+	parentBlockResponse, err := c.blocksProvider.SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+		Block: fmt.Sprintf("%#x", parentRoot),
+	})
 	if err != nil {
+		var apiError *api.Error
+		if errors.As(err, &apiError) && apiError.StatusCode == 404 {
+			return errors.New("empty beacon block")
+		}
 		return err
 	}
+	parentBlock := parentBlockResponse.Data
 	if parentBlock == nil {
 		return fmt.Errorf("unable to obtain parent block %s", parentBlock)
 	}
@@ -267,7 +294,7 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return errors.Wrap(err, "failed to set up chaintime service")
@@ -289,12 +316,12 @@ func (c *command) setup(ctx context.Context) error {
 		return errors.New("connection does not provide spec information")
 	}
 
-	spec, err := specProvider.Spec(ctx)
+	specResponse, err := specProvider.Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain spec")
 	}
 
-	tmp, exists := spec["TIMELY_SOURCE_WEIGHT"]
+	tmp, exists := specResponse.Data["TIMELY_SOURCE_WEIGHT"]
 	if !exists {
 		// Set a default value based on the Altair spec.
 		tmp = uint64(14)
@@ -305,7 +332,7 @@ func (c *command) setup(ctx context.Context) error {
 		return errors.New("TIMELY_SOURCE_WEIGHT of unexpected type")
 	}
 
-	tmp, exists = spec["TIMELY_TARGET_WEIGHT"]
+	tmp, exists = specResponse.Data["TIMELY_TARGET_WEIGHT"]
 	if !exists {
 		// Set a default value based on the Altair spec.
 		tmp = uint64(26)
@@ -315,7 +342,7 @@ func (c *command) setup(ctx context.Context) error {
 		return errors.New("TIMELY_TARGET_WEIGHT of unexpected type")
 	}
 
-	tmp, exists = spec["TIMELY_HEAD_WEIGHT"]
+	tmp, exists = specResponse.Data["TIMELY_HEAD_WEIGHT"]
 	if !exists {
 		// Set a default value based on the Altair spec.
 		tmp = uint64(14)
@@ -325,7 +352,7 @@ func (c *command) setup(ctx context.Context) error {
 		return errors.New("TIMELY_HEAD_WEIGHT of unexpected type")
 	}
 
-	tmp, exists = spec["SYNC_REWARD_WEIGHT"]
+	tmp, exists = specResponse.Data["SYNC_REWARD_WEIGHT"]
 	if !exists {
 		// Set a default value based on the Altair spec.
 		tmp = uint64(2)
@@ -335,7 +362,7 @@ func (c *command) setup(ctx context.Context) error {
 		return errors.New("SYNC_REWARD_WEIGHT of unexpected type")
 	}
 
-	tmp, exists = spec["PROPOSER_WEIGHT"]
+	tmp, exists = specResponse.Data["PROPOSER_WEIGHT"]
 	if !exists {
 		// Set a default value based on the Altair spec.
 		tmp = uint64(8)
@@ -345,7 +372,7 @@ func (c *command) setup(ctx context.Context) error {
 		return errors.New("PROPOSER_WEIGHT of unexpected type")
 	}
 
-	tmp, exists = spec["WEIGHT_DENOMINATOR"]
+	tmp, exists = specResponse.Data["WEIGHT_DENOMINATOR"]
 	if !exists {
 		// Set a default value based on the Altair spec.
 		tmp = uint64(64)
@@ -362,22 +389,31 @@ func (c *command) calcHeadCorrect(ctx context.Context, attestation *phase0.Attes
 	root, exists := c.headRoots[slot]
 	if !exists {
 		for {
-			header, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+			response, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
+				Block: fmt.Sprintf("%d", slot),
+			})
 			if err != nil {
+				var apiError *api.Error
+				if errors.As(err, &apiError) && apiError.StatusCode == 404 {
+					if c.debug {
+						fmt.Printf("No block available for slot %d, assuming not in canonical chain", slot)
+					}
+					return false, nil
+				}
 				return false, err
 			}
-			if header == nil {
+			if response.Data == nil {
 				// No block.
 				slot--
 				continue
 			}
-			if !header.Canonical {
+			if !response.Data.Canonical {
 				// Not canonical.
 				slot--
 				continue
 			}
-			c.headRoots[attestation.Data.Slot] = header.Root
-			root = header.Root
+			c.headRoots[attestation.Data.Slot] = response.Data.Root
+			root = response.Data.Root
 			break
 		}
 	}
@@ -391,22 +427,30 @@ func (c *command) calcTargetCorrect(ctx context.Context, attestation *phase0.Att
 		// Start with first slot of the target epoch.
 		slot := c.chainTime.FirstSlotOfEpoch(attestation.Data.Target.Epoch)
 		for {
-			header, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+			response, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
+				Block: fmt.Sprintf("%d", slot),
+			})
 			if err != nil {
-				return false, err
+				var apiError *api.Error
+				if errors.As(err, &apiError) && apiError.StatusCode == 404 {
+					if c.debug {
+						fmt.Printf("No block available for slot %d, assuming not in canonical chain", slot)
+					}
+					return false, nil
+				}
 			}
-			if header == nil {
+			if response.Data == nil {
 				// No block.
 				slot--
 				continue
 			}
-			if !header.Canonical {
+			if !response.Data.Canonical {
 				// Not canonical.
 				slot--
 				continue
 			}
-			c.targetRoots[attestation.Data.Slot] = header.Root
-			root = header.Root
+			c.targetRoots[attestation.Data.Slot] = response.Data.Root
+			root = response.Data.Root
 			break
 		}
 	}

cmd/block/info/output.go

@@ -20,11 +20,13 @@ import (
 	"fmt"
 	"math/big"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
 	"unicode/utf8"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec/altair"
 	"github.com/attestantio/go-eth2-client/spec/bellatrix"
 	"github.com/attestantio/go-eth2-client/spec/capella"
@@ -116,12 +118,14 @@ func outputBlockAttestations(ctx context.Context, eth2Client eth2client.Service,
 				// Fetch committees for this epoch if not already obtained.
 				committees, exists := validatorCommittees[att.Data.Slot]
 				if !exists {
-					beaconCommittees, err := beaconCommitteesProvider.BeaconCommittees(ctx, fmt.Sprintf("%d", att.Data.Slot))
+					response, err := beaconCommitteesProvider.BeaconCommittees(ctx, &api.BeaconCommitteesOpts{
+						State: fmt.Sprintf("%d", att.Data.Slot),
+					})
 					if err != nil {
 						// Failed to get it; create an empty committee to stop us continually attempting to re-fetch.
 						validatorCommittees[att.Data.Slot] = make(map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
 					} else {
-						for _, beaconCommittee := range beaconCommittees {
+						for _, beaconCommittee := range response.Data {
 							if _, exists := validatorCommittees[beaconCommittee.Slot]; !exists {
 								validatorCommittees[beaconCommittee.Slot] = make(map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
 							}
@@ -166,11 +170,14 @@ func outputBlockAttesterSlashings(ctx context.Context, eth2Client eth2client.Ser
 
 			res.WriteString(fmt.Sprintf("  %d:\n", i))
 			res.WriteString(fmt.Sprintln("    Slashed validators:"))
-			validators, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, "head", slashedIndices)
+			response, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, &api.ValidatorsOpts{
+				State:   "head",
+				Indices: slashedIndices,
+			})
 			if err != nil {
 				return "", errors.Wrap(err, "failed to obtain beacon committees")
 			}
-			for k, v := range validators {
+			for k, v := range response.Data {
 				res.WriteString(fmt.Sprintf("      %#x (%d)\n", v.Validator.PublicKey[:], k))
 			}
 
@@ -223,11 +230,14 @@ func outputBlockVoluntaryExits(ctx context.Context, eth2Client eth2client.Servic
 	if verbose {
 		for i, voluntaryExit := range voluntaryExits {
 			res.WriteString(fmt.Sprintf("  %d:\n", i))
-			validators, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, "head", []phase0.ValidatorIndex{voluntaryExit.Message.ValidatorIndex})
+			response, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, &api.ValidatorsOpts{
+				State:   "head",
+				Indices: []phase0.ValidatorIndex{voluntaryExit.Message.ValidatorIndex},
+			})
 			if err != nil {
 				res.WriteString(fmt.Sprintf("  Error: failed to obtain validators: %v\n", err))
 			} else {
-				res.WriteString(fmt.Sprintf("    Validator: %#x (%d)\n", validators[voluntaryExit.Message.ValidatorIndex].Validator.PublicKey, voluntaryExit.Message.ValidatorIndex))
+				res.WriteString(fmt.Sprintf("    Validator: %#x (%d)\n", response.Data[voluntaryExit.Message.ValidatorIndex].Validator.PublicKey, voluntaryExit.Message.ValidatorIndex))
 				res.WriteString(fmt.Sprintf("    Epoch: %d\n", voluntaryExit.Message.Epoch))
 			}
 		}
@@ -243,11 +253,14 @@ func outputBlockBLSToExecutionChanges(ctx context.Context, eth2Client eth2client
 	if verbose {
 		for i, op := range ops {
 			res.WriteString(fmt.Sprintf("  %d:\n", i))
-			validators, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, "head", []phase0.ValidatorIndex{op.Message.ValidatorIndex})
+			response, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, &api.ValidatorsOpts{
+				State:   "head",
+				Indices: []phase0.ValidatorIndex{op.Message.ValidatorIndex},
+			})
 			if err != nil {
 				res.WriteString(fmt.Sprintf("  Error: failed to obtain validators: %v\n", err))
 			} else {
-				res.WriteString(fmt.Sprintf("    Validator: %#x (%d)\n", validators[op.Message.ValidatorIndex].Validator.PublicKey, op.Message.ValidatorIndex))
+				res.WriteString(fmt.Sprintf("    Validator: %#x (%d)\n", response.Data[op.Message.ValidatorIndex].Validator.PublicKey, op.Message.ValidatorIndex))
 				res.WriteString(fmt.Sprintf("    BLS public key: %#x\n", op.Message.FromBLSPubkey))
 				res.WriteString(fmt.Sprintf("    Execution address: %s\n", op.Message.ToExecutionAddress.String()))
 			}
@@ -265,9 +278,9 @@ func outputBlockSyncAggregate(ctx context.Context, eth2Client eth2client.Service
 	if verbose {
 		specProvider, isProvider := eth2Client.(eth2client.SpecProvider)
 		if isProvider {
-			config, err := specProvider.Spec(ctx)
+			specResponse, err := specProvider.Spec(ctx, &api.SpecOpts{})
 			if err == nil {
-				slotsPerEpoch := config["SLOTS_PER_EPOCH"].(uint64)
+				slotsPerEpoch := specResponse.Data["SLOTS_PER_EPOCH"].(uint64)
 
 				res.WriteString("  Contributions: ")
 				res.WriteString(bitvectorToString(syncAggregate.SyncCommitteeBits))
@@ -275,14 +288,16 @@ func outputBlockSyncAggregate(ctx context.Context, eth2Client eth2client.Service
 
 				syncCommitteesProvider, isProvider := eth2Client.(eth2client.SyncCommitteesProvider)
 				if isProvider {
-					syncCommittee, err := syncCommitteesProvider.SyncCommittee(ctx, fmt.Sprintf("%d", uint64(epoch)*slotsPerEpoch))
+					syncCommitteeResponse, err := syncCommitteesProvider.SyncCommittee(ctx, &api.SyncCommitteeOpts{
+						State: strconv.FormatUint(uint64(epoch)*slotsPerEpoch, 10),
+					})
 					if err != nil {
 						res.WriteString(fmt.Sprintf("  Error: failed to obtain sync committee: %v\n", err))
 					} else {
 						res.WriteString("  Contributing validators:")
 						for i := uint64(0); i < syncAggregate.SyncCommitteeBits.Len(); i++ {
 							if syncAggregate.SyncCommitteeBits.BitAt(i) {
-								res.WriteString(fmt.Sprintf(" %d", syncCommittee.Validators[i]))
+								res.WriteString(fmt.Sprintf(" %d", syncCommitteeResponse.Data.Validators[i]))
 							}
 						}
 						res.WriteString("\n")
@@ -881,8 +896,8 @@ func outputDenebBlockExecutionPayload(_ context.Context,
 		res.WriteString(fmt.Sprintf("%d\n", len(payload.Transactions)))
 		res.WriteString("  Withdrawals: ")
 		res.WriteString(fmt.Sprintf("%d\n", len(payload.Withdrawals)))
-		res.WriteString("  Excess data gas: ")
-		res.WriteString(fmt.Sprintf("%d\n", payload.ExcessDataGas))
+		res.WriteString("  Excess blob gas: ")
+		res.WriteString(fmt.Sprintf("%d\n", payload.ExcessBlobGas))
 	}
 
 	return res.String(), nil
@@ -901,7 +916,7 @@ func outputDenebBlobInfo(_ context.Context,
 	}
 
 	if !verbose {
-		return fmt.Sprintf("Blobs: %d\n", len(body.BlobKzgCommitments)), nil
+		return fmt.Sprintf("Blobs: %d\n", len(body.BlobKZGCommitments)), nil
 	}
 
 	res := strings.Builder{}
@@ -911,8 +926,7 @@ func outputDenebBlobInfo(_ context.Context,
 			res.WriteString("Blobs\n")
 		}
 		res.WriteString(fmt.Sprintf("  Index: %d\n", blob.Index))
-		res.WriteString(fmt.Sprintf("  KZG commitment: %s\n", blob.KzgCommitment.String()))
-		res.WriteString(fmt.Sprintf("  KZG proof: %s\n", blob.KzgProof.String()))
+		res.WriteString(fmt.Sprintf("  KZG commitment: %s\n", body.BlobKZGCommitments[i].String()))
 	}
 
 	return res.String(), nil

cmd/block/info/process.go

@@ -17,13 +17,15 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"net/http"
 	"os"
 	"strconv"
 	"strings"
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
-	api "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/api"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
 	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/altair"
 	"github.com/attestantio/go-eth2-client/spec/bellatrix"
@@ -54,17 +56,18 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		eth2Client: data.eth2Client,
 	}
 
-	config, err := results.eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	specResponse, err := results.eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to connect to obtain configuration information")
 	}
-	genesis, err := results.eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
+	genesisResponse, err := results.eth2Client.(eth2client.GenesisProvider).Genesis(ctx, &api.GenesisOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to connect to obtain genesis information")
 	}
+	genesis := genesisResponse.Data
 	results.genesisTime = genesis.GenesisTime
-	results.slotDuration = config["SECONDS_PER_SLOT"].(time.Duration)
-	results.slotsPerEpoch = config["SLOTS_PER_EPOCH"].(uint64)
+	results.slotDuration = specResponse.Data["SECONDS_PER_SLOT"].(time.Duration)
+	results.slotsPerEpoch = specResponse.Data["SLOTS_PER_EPOCH"].(uint64)
 
 	if data.blockTime != "" {
 		data.blockID, err = timeToBlockID(ctx, data.eth2Client, data.blockTime)
@@ -73,43 +76,52 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		}
 	}
 
-	signedBlock, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, data.blockID)
+	blockResponse, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+		Block: data.blockID,
+	})
 	if err != nil {
+		var apiErr *api.Error
+		if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+			if data.quiet {
+				os.Exit(1)
+			}
+
+			return nil, errors.New("empty beacon block")
+		}
+
 		return nil, errors.Wrap(err, "failed to obtain beacon block")
 	}
-	if signedBlock == nil {
-		if data.quiet {
-			os.Exit(1)
-		}
-		return nil, errors.New("empty beacon block")
-	}
+	block := blockResponse.Data
 	if data.quiet {
 		os.Exit(0)
 	}
 
-	switch signedBlock.Version {
+	switch block.Version {
 	case spec.DataVersionPhase0:
-		if err := outputPhase0Block(ctx, data.jsonOutput, signedBlock.Phase0); err != nil {
+		if err := outputPhase0Block(ctx, data.jsonOutput, block.Phase0); err != nil {
 			return nil, errors.Wrap(err, "failed to output block")
 		}
 	case spec.DataVersionAltair:
-		if err := outputAltairBlock(ctx, data.jsonOutput, data.sszOutput, signedBlock.Altair); err != nil {
+		if err := outputAltairBlock(ctx, data.jsonOutput, data.sszOutput, block.Altair); err != nil {
 			return nil, errors.Wrap(err, "failed to output block")
 		}
 	case spec.DataVersionBellatrix:
-		if err := outputBellatrixBlock(ctx, data.jsonOutput, data.sszOutput, signedBlock.Bellatrix); err != nil {
+		if err := outputBellatrixBlock(ctx, data.jsonOutput, data.sszOutput, block.Bellatrix); err != nil {
 			return nil, errors.Wrap(err, "failed to output block")
 		}
 	case spec.DataVersionCapella:
-		if err := outputCapellaBlock(ctx, data.jsonOutput, data.sszOutput, signedBlock.Capella); err != nil {
+		if err := outputCapellaBlock(ctx, data.jsonOutput, data.sszOutput, block.Capella); err != nil {
 			return nil, errors.Wrap(err, "failed to output block")
 		}
 	case spec.DataVersionDeneb:
-		blobs, err := results.eth2Client.(eth2client.BeaconBlockBlobsProvider).BeaconBlockBlobs(ctx, data.blockID)
+		blobSidecarsResponse, err := results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
+			Block: data.blockID,
+		})
 		if err != nil {
-			return nil, errors.Wrap(err, "failed to obtain blobs")
+			return nil, errors.Wrap(err, "failed to obtain blob sidecars")
 		}
-		if err := outputDenebBlock(ctx, data.jsonOutput, data.sszOutput, signedBlock.Deneb, blobs); err != nil {
+		blobSidecars := blobSidecarsResponse.Data
+		if err := outputDenebBlock(ctx, data.jsonOutput, data.sszOutput, block.Deneb, blobSidecars); err != nil {
 			return nil, errors.Wrap(err, "failed to output block")
 		}
 	default:
@@ -132,7 +144,7 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	return &dataOut{}, nil
 }
 
-func headEventHandler(event *api.Event) {
+func headEventHandler(event *apiv1.Event) {
 	ctx := context.Background()
 
 	// Only interested in head events.
@@ -140,35 +152,40 @@ func headEventHandler(event *api.Event) {
 		return
 	}
 
-	blockID := fmt.Sprintf("%#x", event.Data.(*api.HeadEvent).Block[:])
-	signedBlock, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, blockID)
+	blockID := fmt.Sprintf("%#x", event.Data.(*apiv1.HeadEvent).Block[:])
+	blockResponse, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+		Block: blockID,
+	})
 	if err != nil {
 		if !jsonOutput && !sszOutput {
 			fmt.Printf("Failed to obtain block: %v\n", err)
 		}
 		return
 	}
-	if signedBlock == nil {
+	block := blockResponse.Data
+	if block == nil {
 		if !jsonOutput && !sszOutput {
 			fmt.Println("Empty beacon block")
 		}
 		return
 	}
 
-	switch signedBlock.Version {
+	switch block.Version {
 	case spec.DataVersionPhase0:
-		err = outputPhase0Block(ctx, jsonOutput, signedBlock.Phase0)
+		err = outputPhase0Block(ctx, jsonOutput, block.Phase0)
 	case spec.DataVersionAltair:
-		err = outputAltairBlock(ctx, jsonOutput, sszOutput, signedBlock.Altair)
+		err = outputAltairBlock(ctx, jsonOutput, sszOutput, block.Altair)
 	case spec.DataVersionBellatrix:
-		err = outputBellatrixBlock(ctx, jsonOutput, sszOutput, signedBlock.Bellatrix)
+		err = outputBellatrixBlock(ctx, jsonOutput, sszOutput, block.Bellatrix)
 	case spec.DataVersionCapella:
-		err = outputCapellaBlock(ctx, jsonOutput, sszOutput, signedBlock.Capella)
+		err = outputCapellaBlock(ctx, jsonOutput, sszOutput, block.Capella)
 	case spec.DataVersionDeneb:
-		var blobs []*deneb.BlobSidecar
-		blobs, err = results.eth2Client.(eth2client.BeaconBlockBlobsProvider).BeaconBlockBlobs(ctx, blockID)
+		var blobSidecarsResponse *api.Response[[]*deneb.BlobSidecar]
+		blobSidecarsResponse, err = results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
+			Block: blockID,
+		})
 		if err == nil {
-			err = outputDenebBlock(context.Background(), jsonOutput, sszOutput, signedBlock.Deneb, blobs)
+			err = outputDenebBlock(context.Background(), jsonOutput, sszOutput, block.Deneb, blobSidecarsResponse.Data)
 		}
 	default:
 		err = errors.New("unknown block version")
@@ -331,7 +348,7 @@ func timeToBlockID(ctx context.Context, eth2Client eth2client.Service, input str
 	// Assume timestamp.
 	chainTime, err := standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return "", errors.Wrap(err, "failed to set up chaintime service")

cmd/chain/eth1votes/command.go

@@ -50,6 +50,8 @@ type command struct {
 	slot          phase0.Slot
 	epoch         phase0.Epoch
 	period        uint64
+	periodStart   time.Time
+	periodEnd     time.Time
 	incumbent     *phase0.ETH1Data
 	eth1DataVotes []*phase0.ETH1Data
 	votes         map[string]*vote

cmd/chain/eth1votes/output.go

@@ -24,11 +24,13 @@ import (
 )
 
 type jsonOutput struct {
-	Period    uint64           `json:"period"`
-	Epoch     phase0.Epoch     `json:"epoch"`
-	Slot      phase0.Slot      `json:"slot"`
-	Incumbent *phase0.ETH1Data `json:"incumbent"`
-	Votes     []*vote          `json:"votes"`
+	Period      uint64           `json:"period"`
+	PeriodStart int64            `json:"period_start"`
+	PeriodEnd   int64            `json:"period_end"`
+	Epoch       phase0.Epoch     `json:"epoch"`
+	Slot        phase0.Slot      `json:"slot"`
+	Incumbent   *phase0.ETH1Data `json:"incumbent"`
+	Votes       []*vote          `json:"votes"`
 }
 
 func (c *command) output(ctx context.Context) (string, error) {
@@ -57,11 +59,13 @@ func (c *command) outputJSON(_ context.Context) (string, error) {
 	})
 
 	output := &jsonOutput{
-		Period:    c.period,
-		Epoch:     c.epoch,
-		Slot:      c.slot,
-		Incumbent: c.incumbent,
-		Votes:     votes,
+		Period:      c.period,
+		PeriodStart: c.periodStart.Unix(),
+		PeriodEnd:   c.periodEnd.Unix(),
+		Epoch:       c.epoch,
+		Slot:        c.slot,
+		Incumbent:   c.incumbent,
+		Votes:       votes,
 	}
 	data, err := json.Marshal(output)
 	if err != nil {
@@ -78,6 +82,11 @@ func (c *command) outputText(_ context.Context) (string, error) {
 	builder.WriteString(fmt.Sprintf("%d\n", c.period))
 
 	if c.verbose {
+		builder.WriteString("Period start: ")
+		builder.WriteString(fmt.Sprintf("%s\n", c.periodStart))
+		builder.WriteString("Period end: ")
+		builder.WriteString(fmt.Sprintf("%s\n", c.periodEnd))
+
 		builder.WriteString("Incumbent: ")
 		builder.WriteString(fmt.Sprintf("block %#x, deposit count %d\n", c.incumbent.BlockHash, c.incumbent.DepositCount))
 	}

cmd/chain/eth1votes/process.go

@@ -20,6 +20,7 @@ import (
 	"strconv"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
@@ -58,10 +59,13 @@ func (c *command) process(ctx context.Context) error {
 	if fetchSlot > c.chainTime.CurrentSlot() {
 		fetchSlot = c.chainTime.CurrentSlot()
 	}
-	state, err := c.beaconStateProvider.BeaconState(ctx, fmt.Sprintf("%d", fetchSlot))
+	stateResponse, err := c.beaconStateProvider.BeaconState(ctx, &api.BeaconStateOpts{
+		State: fmt.Sprintf("%d", fetchSlot),
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain state")
 	}
+	state := stateResponse.Data
 	if state == nil {
 		return errors.New("state not returned by beacon node")
 	}
@@ -73,25 +77,24 @@ func (c *command) process(ctx context.Context) error {
 		}
 	}
 
+	c.slot, err = state.Slot()
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain slot")
+	}
 	switch state.Version {
 	case spec.DataVersionPhase0:
-		c.slot = state.Phase0.Slot
 		c.incumbent = state.Phase0.ETH1Data
 		c.eth1DataVotes = state.Phase0.ETH1DataVotes
 	case spec.DataVersionAltair:
-		c.slot = state.Altair.Slot
 		c.incumbent = state.Altair.ETH1Data
 		c.eth1DataVotes = state.Altair.ETH1DataVotes
 	case spec.DataVersionBellatrix:
-		c.slot = state.Bellatrix.Slot
 		c.incumbent = state.Bellatrix.ETH1Data
 		c.eth1DataVotes = state.Bellatrix.ETH1DataVotes
 	case spec.DataVersionCapella:
-		c.slot = state.Capella.Slot
 		c.incumbent = state.Capella.ETH1Data
 		c.eth1DataVotes = state.Capella.ETH1DataVotes
 	case spec.DataVersionDeneb:
-		c.slot = state.Deneb.Slot
 		c.incumbent = state.Deneb.ETH1Data
 		c.eth1DataVotes = state.Deneb.ETH1DataVotes
 	default:
@@ -99,6 +102,8 @@ func (c *command) process(ctx context.Context) error {
 	}
 
 	c.period = uint64(c.epoch) / c.epochsPerEth1VotingPeriod
+	c.periodStart = c.chainTime.StartOfEpoch(phase0.Epoch(c.period * c.epochsPerEth1VotingPeriod))
+	c.periodEnd = c.chainTime.StartOfEpoch(phase0.Epoch((c.period + 1) * c.epochsPerEth1VotingPeriod))
 
 	c.votes = make(map[string]*vote)
 	for _, eth1Vote := range c.eth1DataVotes {
@@ -130,7 +135,7 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return errors.Wrap(err, "failed to set up chaintime service")
@@ -146,12 +151,12 @@ func (c *command) setup(ctx context.Context) error {
 		return errors.New("connection does not provide spec information")
 	}
 
-	spec, err := specProvider.Spec(ctx)
+	specResponse, err := specProvider.Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain spec")
 	}
 
-	tmp, exists := spec["SLOTS_PER_EPOCH"]
+	tmp, exists := specResponse.Data["SLOTS_PER_EPOCH"]
 	if !exists {
 		return errors.New("spec did not contain SLOTS_PER_EPOCH")
 	}
@@ -160,7 +165,7 @@ func (c *command) setup(ctx context.Context) error {
 	if !good {
 		return errors.New("SLOTS_PER_EPOCH value invalid")
 	}
-	tmp, exists = spec["EPOCHS_PER_ETH1_VOTING_PERIOD"]
+	tmp, exists = specResponse.Data["EPOCHS_PER_ETH1_VOTING_PERIOD"]
 	if !exists {
 		return errors.New("spec did not contain EPOCHS_PER_ETH1_VOTING_PERIOD")
 	}

cmd/chain/queues/process.go

@@ -18,6 +18,7 @@ import (
 	"fmt"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/pkg/errors"
 	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
 	"github.com/wealdtech/ethdo/util"
@@ -34,12 +35,14 @@ func (c *command) process(ctx context.Context) error {
 		return err
 	}
 
-	validators, err := c.validatorsProvider.Validators(ctx, fmt.Sprintf("%d", c.chainTime.FirstSlotOfEpoch(epoch)), nil)
+	response, err := c.validatorsProvider.Validators(ctx, &api.ValidatorsOpts{
+		State: fmt.Sprintf("%d", c.chainTime.FirstSlotOfEpoch(epoch)),
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain validators")
 	}
 
-	for _, validator := range validators {
+	for _, validator := range response.Data {
 		if validator.Validator == nil {
 			continue
 		}
@@ -70,7 +73,7 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return errors.Wrap(err, "failed to set up chaintime service")

cmd/chain/time/output.go

@@ -16,6 +16,7 @@ package chaintime
 import (
 	"context"
 	"fmt"
+	"strconv"
 	"strings"
 	"time"
 
@@ -59,14 +60,14 @@ func output(_ context.Context, data *dataOut) (string, error) {
 	builder.WriteString(data.epochStart.Format("2006-01-02 15:04:05"))
 	if data.verbose {
 		builder.WriteString(" (")
-		builder.WriteString(fmt.Sprintf("%d", data.epochStart.Unix()))
+		builder.WriteString(strconv.FormatInt(data.epochStart.Unix(), 10))
 		builder.WriteString(")")
 	}
 	builder.WriteString("\n  Epoch end ")
 	builder.WriteString(data.epochEnd.Format("2006-01-02 15:04:05"))
 	if data.verbose {
 		builder.WriteString(" (")
-		builder.WriteString(fmt.Sprintf("%d", data.epochEnd.Unix()))
+		builder.WriteString(strconv.FormatInt(data.epochEnd.Unix(), 10))
 		builder.WriteString(")")
 	}
 
@@ -76,27 +77,27 @@ func output(_ context.Context, data *dataOut) (string, error) {
 	builder.WriteString(data.slotStart.Format("2006-01-02 15:04:05"))
 	if data.verbose {
 		builder.WriteString(" (")
-		builder.WriteString(fmt.Sprintf("%d", data.slotStart.Unix()))
+		builder.WriteString(strconv.FormatInt(data.slotStart.Unix(), 10))
 		builder.WriteString(")")
 	}
 	builder.WriteString("\n  Slot end ")
 	builder.WriteString(data.slotEnd.Format("2006-01-02 15:04:05"))
 	if data.verbose {
 		builder.WriteString(" (")
-		builder.WriteString(fmt.Sprintf("%d", data.slotEnd.Unix()))
+		builder.WriteString(strconv.FormatInt(data.slotEnd.Unix(), 10))
 		builder.WriteString(")")
 	}
 
 	if data.hasSyncCommittees {
 		builder.WriteString("\nSync committee period ")
-		builder.WriteString(fmt.Sprintf("%d", data.syncCommitteePeriod))
+		builder.WriteString(strconv.FormatUint(data.syncCommitteePeriod, 10))
 		builder.WriteString("\n  Sync committee period start ")
 		builder.WriteString(data.syncCommitteePeriodStart.Format("2006-01-02 15:04:05"))
 		builder.WriteString(" (epoch ")
 		builder.WriteString(fmt.Sprintf("%d", data.syncCommitteePeriodEpochStart))
 		if data.verbose {
 			builder.WriteString(", ")
-			builder.WriteString(fmt.Sprintf("%d", data.syncCommitteePeriodStart.Unix()))
+			builder.WriteString(strconv.FormatInt(data.syncCommitteePeriodStart.Unix(), 10))
 		}
 		builder.WriteString(")\n  Sync committee period end ")
 		builder.WriteString(data.syncCommitteePeriodEnd.Format("2006-01-02 15:04:05"))
@@ -104,7 +105,7 @@ func output(_ context.Context, data *dataOut) (string, error) {
 		builder.WriteString(fmt.Sprintf("%d", data.syncCommitteePeriodEpochEnd))
 		if data.verbose {
 			builder.WriteString(", ")
-			builder.WriteString(fmt.Sprintf("%d", data.syncCommitteePeriodEnd.Unix()))
+			builder.WriteString(strconv.FormatInt(data.syncCommitteePeriodEnd.Unix(), 10))
 		}
 		builder.WriteString(")")
 	}

cmd/chain/time/process.go

@@ -42,7 +42,7 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 
 	chainTime, err := standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to set up chaintime service")

cmd/chain/verify/signedcontributionandproof/process.go

@@ -22,6 +22,7 @@ import (
 	"os"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec/altair"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
@@ -103,29 +104,32 @@ func (c *command) setup(ctx context.Context) error {
 	}
 
 	stateID := fmt.Sprintf("%d", c.item.Message.Contribution.Slot)
-	validators, err := c.validatorsProvider.Validators(ctx,
-		stateID,
-		[]phase0.ValidatorIndex{c.item.Message.AggregatorIndex},
-	)
+	response, err := c.validatorsProvider.Validators(ctx, &api.ValidatorsOpts{
+		State:   stateID,
+		Indices: []phase0.ValidatorIndex{c.item.Message.AggregatorIndex},
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain validator information")
 	}
 
-	if len(validators) == 0 || validators[c.item.Message.AggregatorIndex] == nil {
+	if len(response.Data) == 0 || response.Data[c.item.Message.AggregatorIndex] == nil {
 		return nil
 	}
 	c.validatorKnown = true
-	c.validator = validators[c.item.Message.AggregatorIndex]
+	c.validator = response.Data[c.item.Message.AggregatorIndex]
 
 	// Obtain the sync committee
 	syncCommitteesProvider, isProvider := c.eth2Client.(eth2client.SyncCommitteesProvider)
 	if !isProvider {
 		return errors.New("connection does not provide sync committee information")
 	}
-	c.syncCommittee, err = syncCommitteesProvider.SyncCommittee(ctx, stateID)
+	syncCommitteeResponse, err := syncCommitteesProvider.SyncCommittee(ctx, &api.SyncCommitteeOpts{
+		State: stateID,
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain sync committee information")
 	}
+	c.syncCommittee = syncCommitteeResponse.Data
 
 	return nil
 }
@@ -137,11 +141,11 @@ func (c *command) isAggregator(ctx context.Context) (bool, error) {
 	if !isProvider {
 		return false, errors.New("connection does not provide spec information")
 	}
-	var err error
-	c.spec, err = specProvider.Spec(ctx)
+	specResponse, err := specProvider.Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return false, errors.Wrap(err, "failed to obtain spec information")
 	}
+	c.spec = specResponse.Data
 
 	tmp, exists := c.spec["SYNC_COMMITTEE_SIZE"]
 	if !exists {
@@ -226,16 +230,19 @@ func (c *command) confirmContributionSignature(ctx context.Context) error {
 		fmt.Fprintf(os.Stderr, "Contribution validator indices: %v (%d)\n", includedIndices, len(includedIndices))
 	}
 
-	includedValidators, err := c.validatorsProvider.Validators(ctx, "head", includedIndices)
+	response, err := c.validatorsProvider.Validators(ctx, &api.ValidatorsOpts{
+		State:   "head",
+		Indices: includedIndices,
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain subcommittee validators")
 	}
-	if len(includedValidators) == 0 {
+	if len(response.Data) == 0 {
 		return errors.New("obtained empty subcommittee validator list")
 	}
 
 	var aggregatePubKey *e2types.BLSPublicKey
-	for _, v := range includedValidators {
+	for _, v := range response.Data {
 		pubKeyBytes := make([]byte, 48)
 		copy(pubKeyBytes, v.Validator.PublicKey[:])
 		pubKey, err := e2types.BLSPublicKeyFromBytes(pubKeyBytes)

cmd/chaininfo.go

@@ -20,6 +20,7 @@ import (
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	spec "github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -45,32 +46,32 @@ In quiet mode this will return 0 if the chain information can be obtained, other
 		})
 		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 
-		config, err := eth2Client.(eth2client.SpecProvider).Spec(ctx)
+		specResponse, err := eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
 		errCheck(err, "Failed to obtain beacon chain specification")
 
-		genesis, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
+		genesisResponse, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx, &api.GenesisOpts{})
 		errCheck(err, "Failed to obtain beacon chain genesis")
 
-		fork, err := eth2Client.(eth2client.ForkProvider).Fork(ctx, "head")
+		forkResponse, err := eth2Client.(eth2client.ForkProvider).Fork(ctx, &api.ForkOpts{State: "head"})
 		errCheck(err, "Failed to obtain current fork")
 
 		if viper.GetBool("quiet") {
 			os.Exit(_exitSuccess)
 		}
 
-		if genesis.GenesisTime.Unix() == 0 {
+		if genesisResponse.Data.GenesisTime.Unix() == 0 {
 			fmt.Println("Genesis time: undefined")
 		} else {
-			fmt.Printf("Genesis time: %s\n", genesis.GenesisTime.Format(time.UnixDate))
-			outputIf(viper.GetBool("verbose"), fmt.Sprintf("Genesis timestamp: %v", genesis.GenesisTime.Unix()))
+			fmt.Printf("Genesis time: %s\n", genesisResponse.Data.GenesisTime.Format(time.UnixDate))
+			outputIf(viper.GetBool("verbose"), fmt.Sprintf("Genesis timestamp: %v", genesisResponse.Data.GenesisTime.Unix()))
 		}
-		fmt.Printf("Genesis validators root: %#x\n", genesis.GenesisValidatorsRoot)
-		fmt.Printf("Genesis fork version: %#x\n", config["GENESIS_FORK_VERSION"].(spec.Version))
-		fmt.Printf("Current fork version: %#x\n", fork.CurrentVersion)
+		fmt.Printf("Genesis validators root: %#x\n", genesisResponse.Data.GenesisValidatorsRoot)
+		fmt.Printf("Genesis fork version: %#x\n", specResponse.Data["GENESIS_FORK_VERSION"].(spec.Version))
+		fmt.Printf("Current fork version: %#x\n", forkResponse.Data.CurrentVersion)
 		if viper.GetBool("verbose") {
 			forkData := &spec.ForkData{
-				CurrentVersion:        fork.CurrentVersion,
-				GenesisValidatorsRoot: genesis.GenesisValidatorsRoot,
+				CurrentVersion:        forkResponse.Data.CurrentVersion,
+				GenesisValidatorsRoot: genesisResponse.Data.GenesisValidatorsRoot,
 			}
 			forkDataRoot, err := forkData.HashTreeRoot()
 			if err == nil {
@@ -79,8 +80,8 @@ In quiet mode this will return 0 if the chain information can be obtained, other
 				fmt.Printf("Fork digest: %#x\n", forkDigest)
 			}
 		}
-		fmt.Printf("Seconds per slot: %d\n", int(config["SECONDS_PER_SLOT"].(time.Duration).Seconds()))
-		fmt.Printf("Slots per epoch: %d\n", config["SLOTS_PER_EPOCH"].(uint64))
+		fmt.Printf("Seconds per slot: %d\n", int(specResponse.Data["SECONDS_PER_SLOT"].(time.Duration).Seconds()))
+		fmt.Printf("Slots per epoch: %d\n", specResponse.Data["SLOTS_PER_EPOCH"].(uint64))
 
 		os.Exit(_exitSuccess)
 	},

cmd/chainspec.go

@@ -18,9 +18,11 @@ import (
 	"encoding/json"
 	"fmt"
 	"sort"
+	"strconv"
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -46,7 +48,7 @@ In quiet mode this will return 0 if the chain specification can be obtained, oth
 		})
 		errCheck(err, "Failed to connect to Ethereum consensus node")
 
-		spec, err := eth2Client.(eth2client.SpecProvider).Spec(ctx)
+		specResponse, err := eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
 		errCheck(err, "Failed to obtain chain specification")
 
 		if viper.GetBool("quiet") {
@@ -54,35 +56,35 @@ In quiet mode this will return 0 if the chain specification can be obtained, oth
 		}
 
 		// Tweak the spec for output.
-		for k, v := range spec {
+		for k, v := range specResponse.Data {
 			switch t := v.(type) {
 			case phase0.Version:
-				spec[k] = fmt.Sprintf("%#x", t)
+				specResponse.Data[k] = fmt.Sprintf("%#x", t)
 			case phase0.DomainType:
-				spec[k] = fmt.Sprintf("%#x", t)
+				specResponse.Data[k] = fmt.Sprintf("%#x", t)
 			case time.Time:
-				spec[k] = fmt.Sprintf("%d", t.Unix())
+				specResponse.Data[k] = strconv.FormatInt(t.Unix(), 10)
 			case time.Duration:
-				spec[k] = fmt.Sprintf("%d", uint64(t.Seconds()))
+				specResponse.Data[k] = strconv.FormatUint(uint64(t.Seconds()), 10)
 			case []byte:
-				spec[k] = fmt.Sprintf("%#x", t)
+				specResponse.Data[k] = fmt.Sprintf("%#x", t)
 			case uint64:
-				spec[k] = fmt.Sprintf("%d", t)
+				specResponse.Data[k] = strconv.FormatUint(t, 10)
 			}
 		}
 
 		if viper.GetBool("json") {
-			data, err := json.Marshal(spec)
+			data, err := json.Marshal(specResponse.Data)
 			errCheck(err, "Failed to marshal JSON")
 			fmt.Printf("%s\n", string(data))
 		} else {
-			keys := make([]string, 0, len(spec))
-			for k := range spec {
+			keys := make([]string, 0, len(specResponse.Data))
+			for k := range specResponse.Data {
 				keys = append(keys, k)
 			}
 			sort.Strings(keys)
 			for _, key := range keys {
-				fmt.Printf("%s: %v\n", key, spec[key])
+				fmt.Printf("%s: %v\n", key, specResponse.Data[key])
 			}
 		}
 	},

cmd/chainstatus.go

@@ -17,10 +17,12 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"strconv"
 	"strings"
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/spf13/cobra"
@@ -50,15 +52,18 @@ In quiet mode this will return 0 if the chain status can be obtained, otherwise
 		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 
 		chainTime, err := standardchaintime.New(ctx,
-			standardchaintime.WithGenesisTimeProvider(eth2Client.(eth2client.GenesisTimeProvider)),
+			standardchaintime.WithGenesisProvider(eth2Client.(eth2client.GenesisProvider)),
 			standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
 		)
 		errCheck(err, "Failed to configure chaintime service")
 
 		finalityProvider, isProvider := eth2Client.(eth2client.FinalityProvider)
 		assert(isProvider, "beacon node does not provide finality; cannot report on chain status")
-		finality, err := finalityProvider.Finality(ctx, "head")
+		finalityResponse, err := finalityProvider.Finality(ctx, &api.FinalityOpts{
+			State: "head",
+		})
 		errCheck(err, "Failed to obtain finality information")
+		finality := finalityResponse.Data
 
 		slot := chainTime.CurrentSlot()
 
@@ -126,13 +131,13 @@ In quiet mode this will return 0 if the chain status can be obtained, otherwise
 		if viper.GetBool("verbose") {
 			validatorsProvider, isProvider := eth2Client.(eth2client.ValidatorsProvider)
 			if isProvider {
-				validators, err := validatorsProvider.Validators(ctx, "head", nil)
+				validatorsResponse, err := validatorsProvider.Validators(ctx, &api.ValidatorsOpts{State: "head"})
 				errCheck(err, "Failed to obtain validators information")
 				// Stats of inteest.
 				totalBalance := phase0.Gwei(0)
 				activeEffectiveBalance := phase0.Gwei(0)
 				validatorCount := make(map[apiv1.ValidatorState]int)
-				for _, validator := range validators {
+				for _, validator := range validatorsResponse.Data {
 					validatorCount[validator.Status]++
 					totalBalance += validator.Balance
 					if validator.Status.IsActive() {
@@ -162,7 +167,7 @@ In quiet mode this will return 0 if the chain status can be obtained, otherwise
 			nextPeriodTimestamp := chainTime.StartOfEpoch(nextPeriodStartEpoch)
 
 			res.WriteString("Sync committee period: ")
-			res.WriteString(fmt.Sprintf("%d", period))
+			res.WriteString(strconv.FormatUint(period, 10))
 			res.WriteString("\n")
 
 			if viper.GetBool("verbose") {

cmd/epoch/summary/process.go

@@ -16,12 +16,13 @@ package epochsummary
 import (
 	"context"
 	"fmt"
+	"net/http"
 	"sort"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
 	"github.com/attestantio/go-eth2-client/spec"
-	"github.com/attestantio/go-eth2-client/spec/altair"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
@@ -55,14 +56,14 @@ func (c *command) process(ctx context.Context) error {
 }
 
 func (c *command) processProposerDuties(ctx context.Context) error {
-	duties, err := c.proposerDutiesProvider.ProposerDuties(ctx, c.summary.Epoch, nil)
+	response, err := c.proposerDutiesProvider.ProposerDuties(ctx, &api.ProposerDutiesOpts{
+		Epoch: c.summary.Epoch,
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain proposer duties")
 	}
-	if duties == nil {
-		return errors.New("empty proposer duties")
-	}
-	for _, duty := range duties {
+
+	for _, duty := range response.Data {
 		block, err := c.fetchBlock(ctx, fmt.Sprintf("%d", duty.Slot))
 		if err != nil {
 			return errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", duty.Slot))
@@ -79,12 +80,14 @@ func (c *command) processProposerDuties(ctx context.Context) error {
 }
 
 func (c *command) activeValidators(ctx context.Context) (map[phase0.ValidatorIndex]*apiv1.Validator, error) {
-	validators, err := c.validatorsProvider.Validators(ctx, fmt.Sprintf("%d", c.chainTime.FirstSlotOfEpoch(c.summary.Epoch)), nil)
+	response, err := c.validatorsProvider.Validators(ctx, &api.ValidatorsOpts{
+		State: fmt.Sprintf("%d", c.chainTime.FirstSlotOfEpoch(c.summary.Epoch)),
+	})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain validators for epoch")
 	}
 	activeValidators := make(map[phase0.ValidatorIndex]*apiv1.Validator)
-	for _, validator := range validators {
+	for _, validator := range response.Data {
 		if validator.Validator.ActivationEpoch <= c.summary.Epoch && validator.Validator.ExitEpoch > c.summary.Epoch {
 			activeValidators[validator.Index] = validator
 		}
@@ -187,11 +190,13 @@ func (c *command) processSlots(ctx context.Context,
 			}
 			slotCommittees, exists := allCommittees[attestation.Data.Slot]
 			if !exists {
-				beaconCommittees, err := c.beaconCommitteesProvider.BeaconCommittees(ctx, fmt.Sprintf("%d", attestation.Data.Slot))
+				response, err := c.beaconCommitteesProvider.BeaconCommittees(ctx, &api.BeaconCommitteesOpts{
+					State: fmt.Sprintf("%d", attestation.Data.Slot),
+				})
 				if err != nil {
 					return 0, 0, 0, 0, 0, 0, nil, nil, errors.Wrap(err, fmt.Sprintf("failed to obtain committees for slot %d", attestation.Data.Slot))
 				}
-				for _, beaconCommittee := range beaconCommittees {
+				for _, beaconCommittee := range response.Data {
 					if _, exists := allCommittees[beaconCommittee.Slot]; !exists {
 						allCommittees[beaconCommittee.Slot] = make(map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
 					}
@@ -257,10 +262,13 @@ func (c *command) processSyncCommitteeDuties(ctx context.Context) error {
 		return nil
 	}
 
-	committee, err := c.syncCommitteesProvider.SyncCommittee(ctx, fmt.Sprintf("%d", c.summary.FirstSlot))
+	committeeResponse, err := c.syncCommitteesProvider.SyncCommittee(ctx, &api.SyncCommitteeOpts{
+		State: fmt.Sprintf("%d", c.summary.FirstSlot),
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain sync committee")
 	}
+	committee := committeeResponse.Data
 	if len(committee.Validators) == 0 {
 		return errors.Wrap(err, "empty sync committee")
 	}
@@ -279,21 +287,14 @@ func (c *command) processSyncCommitteeDuties(ctx context.Context) error {
 			// If the block is missed we don't count the sync aggregate miss.
 			continue
 		}
-		var aggregate *altair.SyncAggregate
-		switch block.Version {
-		case spec.DataVersionPhase0:
+		if block.Version == spec.DataVersionPhase0 {
 			// No sync committees in this fork.
 			return nil
-		case spec.DataVersionAltair:
-			aggregate = block.Altair.Message.Body.SyncAggregate
-		case spec.DataVersionBellatrix:
-			aggregate = block.Bellatrix.Message.Body.SyncAggregate
-		case spec.DataVersionCapella:
-			aggregate = block.Capella.Message.Body.SyncAggregate
-		case spec.DataVersionDeneb:
-			aggregate = block.Deneb.Message.Body.SyncAggregate
-		default:
-			return fmt.Errorf("unhandled block version %v", block.Version)
+		}
+
+		aggregate, err := block.SyncAggregate()
+		if err != nil {
+			return errors.Wrapf(err, "failed to obtain sync aggregate for slot %d", slot)
 		}
 		for i := uint64(0); i < aggregate.SyncCommitteeBits.Len(); i++ {
 			if !aggregate.SyncCommitteeBits.BitAt(i) {
@@ -341,7 +342,7 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return errors.Wrap(err, "failed to set up chaintime service")
@@ -389,7 +390,7 @@ func (c *command) processBlobs(ctx context.Context) error {
 		case spec.DataVersionPhase0, spec.DataVersionAltair, spec.DataVersionBellatrix, spec.DataVersionCapella:
 			// No blobs in these forks.
 		case spec.DataVersionDeneb:
-			c.summary.Blobs += len(block.Deneb.Message.Body.BlobKzgCommitments)
+			c.summary.Blobs += len(block.Deneb.Message.Body.BlobKZGCommitments)
 		default:
 			return fmt.Errorf("unhandled block version %v", block.Version)
 		}
@@ -407,10 +408,19 @@ func (c *command) fetchBlock(ctx context.Context,
 	block, exists := c.blocksCache[blockID]
 	if !exists {
 		var err error
-		block, err = c.blocksProvider.SignedBeaconBlock(ctx, blockID)
+		blockResponse, err := c.blocksProvider.SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+			Block: blockID,
+		})
 		if err != nil {
+			var apiErr *api.Error
+			if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+				// No block for this slot, that's okay.
+				return nil, nil
+			}
+
 			return nil, errors.Wrap(err, "failed to fetch block")
 		}
+		block = blockResponse.Data
 		c.blocksCache[blockID] = block
 	}
 	return block, nil

cmd/exitverify.go

@@ -21,6 +21,7 @@ import (
 	"strings"
 
 	consensusclient "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	v1 "github.com/attestantio/go-eth2-client/api/v1"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
@@ -67,10 +68,11 @@ In quiet mode this will return 0 if the exit is verified correctly, otherwise 1.
 		opRoot, err := signedOp.Message.HashTreeRoot()
 		errCheck(err, "Failed to obtain exit hash tree root")
 
-		genesis, err := eth2Client.(consensusclient.GenesisProvider).Genesis(ctx)
+		genesisResponse, err := eth2Client.(consensusclient.GenesisProvider).Genesis(ctx, &api.GenesisOpts{})
 		errCheck(err, "Failed to obtain beacon chain genesis")
+		genesis := genesisResponse.Data
 
-		fork, err := eth2Client.(consensusclient.ForkProvider).Fork(ctx, "head")
+		response, err := eth2Client.(consensusclient.ForkProvider).Fork(ctx, &api.ForkOpts{State: "head"})
 		errCheck(err, "Failed to obtain fork information")
 
 		// Check against current and prior fork versions.
@@ -83,14 +85,14 @@ In quiet mode this will return 0 if the exit is verified correctly, otherwise 1.
 
 		// Try with the current fork.
 		domain := phase0.Domain{}
-		currentExitDomain, err := e2types.ComputeDomain(e2types.DomainVoluntaryExit, fork.CurrentVersion[:], genesis.GenesisValidatorsRoot[:])
+		currentExitDomain, err := e2types.ComputeDomain(e2types.DomainVoluntaryExit, response.Data.CurrentVersion[:], genesis.GenesisValidatorsRoot[:])
 		errCheck(err, "Failed to compute domain")
 		copy(domain[:], currentExitDomain)
 		verified, err = util.VerifyRoot(account, opRoot, domain, sig)
 		errCheck(err, "Failed to verify voluntary exit")
 		if !verified {
 			// Try again with the previous fork.
-			previousExitDomain, err := e2types.ComputeDomain(e2types.DomainVoluntaryExit, fork.PreviousVersion[:], genesis.GenesisValidatorsRoot[:])
+			previousExitDomain, err := e2types.ComputeDomain(e2types.DomainVoluntaryExit, response.Data.PreviousVersion[:], genesis.GenesisValidatorsRoot[:])
 			copy(domain[:], previousExitDomain)
 			errCheck(err, "Failed to compute domain")
 			verified, err = util.VerifyRoot(account, opRoot, domain, sig)

cmd/nodeinfo.go

@@ -19,6 +19,7 @@ import (
 	"os"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"github.com/wealdtech/ethdo/util"
@@ -48,14 +49,14 @@ In quiet mode this will return 0 if the node information can be obtained, otherw
 		}
 
 		if viper.GetBool("verbose") {
-			version, err := eth2Client.(eth2client.NodeVersionProvider).NodeVersion(ctx)
+			versionResponse, err := eth2Client.(eth2client.NodeVersionProvider).NodeVersion(ctx, &api.NodeVersionOpts{})
 			errCheck(err, "Failed to obtain node version")
-			fmt.Printf("Version: %s\n", version)
+			fmt.Printf("Version: %s\n", versionResponse.Data)
 		}
 
-		syncState, err := eth2Client.(eth2client.NodeSyncingProvider).NodeSyncing(ctx)
+		syncStateResponse, err := eth2Client.(eth2client.NodeSyncingProvider).NodeSyncing(ctx, &api.NodeSyncingOpts{})
 		errCheck(err, "failed to obtain node sync state")
-		fmt.Printf("Syncing: %t\n", syncState.SyncDistance != 0)
+		fmt.Printf("Syncing: %t\n", syncStateResponse.Data.SyncDistance != 0)
 
 		os.Exit(_exitSuccess)
 	},

cmd/proposer/duties/command.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
@@ -37,6 +37,7 @@ type command struct {
 
 	// Operation.
 	epoch      string
+	slot       string
 	jsonOutput bool
 
 	// Data access.
@@ -55,23 +56,22 @@ type results struct {
 
 func newCommand(_ context.Context) (*command, error) {
 	c := &command{
-		quiet:   viper.GetBool("quiet"),
-		verbose: viper.GetBool("verbose"),
-		debug:   viper.GetBool("debug"),
-		results: &results{},
+		quiet:                    viper.GetBool("quiet"),
+		verbose:                  viper.GetBool("verbose"),
+		debug:                    viper.GetBool("debug"),
+		timeout:                  viper.GetDuration("timeout"),
+		connection:               viper.GetString("connection"),
+		allowInsecureConnections: viper.GetBool("allow-insecure-connections"),
+		epoch:                    viper.GetString("epoch"),
+		slot:                     viper.GetString("slot"),
+		jsonOutput:               viper.GetBool("json"),
+		results:                  &results{},
 	}
 
 	// Timeout.
-	if viper.GetDuration("timeout") == 0 {
+	if c.timeout == 0 {
 		return nil, errors.New("timeout is required")
 	}
-	c.timeout = viper.GetDuration("timeout")
-
-	c.connection = viper.GetString("connection")
-	c.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
-
-	c.epoch = viper.GetString("epoch")
-	c.jsonOutput = viper.GetBool("json")
 
 	return c, nil
 }

cmd/proposer/duties/output.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
@@ -43,19 +43,32 @@ func (c *command) outputJSON(_ context.Context) (string, error) {
 func (c *command) outputTxt(_ context.Context) (string, error) {
 	builder := strings.Builder{}
 
-	builder.WriteString("Epoch ")
-	builder.WriteString(fmt.Sprintf("%d:\n", c.results.Epoch))
-
-	for _, duty := range c.results.Duties {
-		builder.WriteString("  Slot ")
-		builder.WriteString(fmt.Sprintf("%d: ", duty.Slot))
-		builder.WriteString("validator ")
+	if len(c.results.Duties) == 1 {
+		// Only have a single slot, just print the validator.
+		duty := c.results.Duties[0]
+		builder.WriteString("Validator ")
 		builder.WriteString(fmt.Sprintf("%d", duty.ValidatorIndex))
 		if c.verbose {
 			builder.WriteString(" (pubkey ")
 			builder.WriteString(fmt.Sprintf("%#x)", duty.PubKey))
 		}
 		builder.WriteString("\n")
+	} else {
+		// Have multiple slots, print per-slot information.
+		builder.WriteString("Epoch ")
+		builder.WriteString(fmt.Sprintf("%d:\n", c.results.Epoch))
+
+		for _, duty := range c.results.Duties {
+			builder.WriteString("  Slot ")
+			builder.WriteString(fmt.Sprintf("%d: ", duty.Slot))
+			builder.WriteString("validator ")
+			builder.WriteString(fmt.Sprintf("%d", duty.ValidatorIndex))
+			if c.verbose {
+				builder.WriteString(" (pubkey ")
+				builder.WriteString(fmt.Sprintf("%#x)", duty.PubKey))
+			}
+			builder.WriteString("\n")
+		}
 	}
 
 	return strings.TrimSuffix(builder.String(), "\n"), nil

cmd/proposer/duties/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
@@ -17,6 +17,8 @@ import (
 	"context"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
 	"github.com/pkg/errors"
 	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
 	"github.com/wealdtech/ethdo/util"
@@ -24,20 +26,59 @@ import (
 
 func (c *command) process(ctx context.Context) error {
 	// Obtain information we need to process.
-	err := c.setup(ctx)
-	if err != nil {
+	if err := c.setup(ctx); err != nil {
 		return err
 	}
 
+	if c.slot != "" {
+		return c.processSlot(ctx)
+	}
+
+	return c.processEpoch(ctx)
+}
+
+func (c *command) processSlot(ctx context.Context) error {
+	var err error
+	slot, err := util.ParseSlot(ctx, c.chainTime, c.slot)
+	if err != nil {
+		return errors.Wrap(err, "failed to parse slot")
+	}
+
+	c.results.Epoch = c.chainTime.SlotToEpoch(slot)
+
+	response, err := c.proposerDutiesProvider.ProposerDuties(ctx, &api.ProposerDutiesOpts{
+		Epoch: c.results.Epoch,
+	})
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain proposer duties")
+	}
+
+	c.results.Duties = make([]*apiv1.ProposerDuty, 0, 1)
+
+	for _, duty := range response.Data {
+		if duty.Slot == slot {
+			c.results.Duties = append(c.results.Duties, duty)
+			break
+		}
+	}
+
+	return nil
+}
+
+func (c *command) processEpoch(ctx context.Context) error {
+	var err error
 	c.results.Epoch, err = util.ParseEpoch(ctx, c.chainTime, c.epoch)
 	if err != nil {
 		return errors.Wrap(err, "failed to parse epoch")
 	}
 
-	c.results.Duties, err = c.proposerDutiesProvider.ProposerDuties(ctx, c.results.Epoch, nil)
+	dutiesResponse, err := c.proposerDutiesProvider.ProposerDuties(ctx, &api.ProposerDutiesOpts{
+		Epoch: c.results.Epoch,
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain proposer duties")
 	}
+	c.results.Duties = dutiesResponse.Data
 
 	return nil
 }
@@ -58,7 +99,7 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return errors.Wrap(err, "failed to set up chaintime service")

cmd/proposerduties.go

@@ -48,10 +48,14 @@ func init() {
 	proposerCmd.AddCommand(proposerDutiesCmd)
 	proposerFlags(proposerDutiesCmd)
 	proposerDutiesCmd.Flags().String("epoch", "", "the epoch for which to fetch duties")
+	proposerDutiesCmd.Flags().String("slot", "", "the slot for which to fetch duties")
 }
 
 func proposerDutiesBindings(cmd *cobra.Command) {
 	if err := viper.BindPFlag("epoch", cmd.Flags().Lookup("epoch")); err != nil {
 		panic(err)
 	}
+	if err := viper.BindPFlag("slot", cmd.Flags().Lookup("slot")); err != nil {
+		panic(err)
+	}
 }

cmd/root.go

@@ -76,6 +76,7 @@ var bindings = map[string]func(cmd *cobra.Command){
 	"validator/yield":           validatorYieldBindings,
 	"validator/expectation":     validatorExpectationBindings,
 	"validator/withdrawal":      validatorWithdrawalBindings,
+	"wallet/batch":              walletBatchBindings,
 	"wallet/create":             walletCreateBindings,
 	"wallet/import":             walletImportBindings,
 	"wallet/sharedexport":       walletSharedExportBindings,

cmd/signaturesign.go

@@ -66,7 +66,7 @@ In quiet mode this will return 0 if the data can be signed, otherwise 1.`,
 		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())
+		outputIf(viper.GetBool("debug"), fmt.Sprintf("Signing %#x with domain %#x by public key %#x", fixedSizeData, specDomain, account.PublicKey().Marshal()))
 		signature, err := util.SignRoot(account, fixedSizeData, specDomain)
 		errCheck(err, "Failed to sign")
 

cmd/slot/time/process.go

@@ -19,6 +19,7 @@ import (
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/pkg/errors"
 )
 
@@ -41,17 +42,18 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		return nil, errors.New("slot must be a positive integer")
 	}
 
-	genesis, err := data.eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
+	genesisResponse, err := data.eth2Client.(eth2client.GenesisProvider).Genesis(ctx, &api.GenesisOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain genesis information")
 	}
+	genesis := genesisResponse.Data
 
-	config, err := data.eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	specResponse, err := data.eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain chain specifications")
 	}
 
-	slotDuration := config["SECONDS_PER_SLOT"].(time.Duration)
+	slotDuration := specResponse.Data["SECONDS_PER_SLOT"].(time.Duration)
 
 	results.startTime = genesis.GenesisTime.Add((time.Duration(slot*int64(slotDuration.Seconds())) * time.Second))
 	results.endTime = results.startTime.Add(slotDuration)

cmd/synccommittee/inclusion/output.go

@@ -16,6 +16,7 @@ package inclusion
 import (
 	"context"
 	"fmt"
+	"strconv"
 	"strings"
 )
 
@@ -53,13 +54,13 @@ func (c *command) output(_ context.Context) (string, error) {
 			}
 		}
 		builder.WriteString("Expected: ")
-		builder.WriteString(fmt.Sprintf("%d", len(c.inclusions)))
+		builder.WriteString(strconv.Itoa(len(c.inclusions)))
 		builder.WriteString("\nIncluded: ")
-		builder.WriteString(fmt.Sprintf("%d", included))
+		builder.WriteString(strconv.Itoa(included))
 		builder.WriteString("\nMissed: ")
-		builder.WriteString(fmt.Sprintf("%d", missed))
+		builder.WriteString(strconv.Itoa(missed))
 		builder.WriteString("\nNo block: ")
-		builder.WriteString(fmt.Sprintf("%d", noBlock))
+		builder.WriteString(strconv.Itoa(noBlock))
 
 		builder.WriteString("\nPer-slot result: ")
 		for i, inclusion := range c.inclusions {

cmd/synccommittee/inclusion/process.go

@@ -16,8 +16,10 @@ package inclusion
 import (
 	"context"
 	"fmt"
+	"net/http"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/altair"
 	"github.com/pkg/errors"
@@ -41,10 +43,14 @@ func (c *command) process(ctx context.Context) error {
 		return err
 	}
 
-	syncCommittee, err := c.eth2Client.(eth2client.SyncCommitteesProvider).SyncCommitteeAtEpoch(ctx, "head", c.epoch)
+	syncCommitteeResponse, err := c.eth2Client.(eth2client.SyncCommitteesProvider).SyncCommittee(ctx, &api.SyncCommitteeOpts{
+		State: "head",
+		Epoch: &c.epoch,
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain sync committee information")
 	}
+	syncCommittee := syncCommitteeResponse.Data
 
 	if syncCommittee == nil {
 		return errors.New("no sync committee returned")
@@ -66,11 +72,20 @@ func (c *command) process(ctx context.Context) error {
 		if lastSlot > c.chainTime.CurrentSlot() {
 			lastSlot = c.chainTime.CurrentSlot()
 		}
-		for slot := firstSlot; slot < lastSlot; slot++ {
-			block, err := c.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, fmt.Sprintf("%d", slot))
+		for slot := firstSlot; slot <= lastSlot; slot++ {
+			blockResponse, err := c.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+				Block: fmt.Sprintf("%d", slot),
+			})
 			if err != nil {
-				return err
+				var apiErr *api.Error
+				if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+					c.inclusions = append(c.inclusions, 0)
+					continue
+				}
+				return errors.Wrap(err, "failed to obtain beacon block")
 			}
+
+			block := blockResponse.Data
 			if block == nil {
 				c.inclusions = append(c.inclusions, 0)
 				continue
@@ -130,7 +145,7 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return errors.Wrap(err, "failed to set up chaintime service")

cmd/synccommittee/members/input.go

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

cmd/synccommittee/members/process.go

@@ -19,6 +19,7 @@ import (
 	"strings"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/wealdtech/ethdo/util"
@@ -34,10 +35,14 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		return nil, err
 	}
 
-	syncCommittee, err := data.eth2Client.(eth2client.SyncCommitteesProvider).SyncCommitteeAtEpoch(ctx, "head", epoch)
+	syncCommitteeResponse, err := data.eth2Client.(eth2client.SyncCommitteesProvider).SyncCommittee(ctx, &api.SyncCommitteeOpts{
+		State: "head",
+		Epoch: &epoch,
+	})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain sync committee information")
 	}
+	syncCommittee := syncCommitteeResponse.Data
 
 	if syncCommittee == nil {
 		return nil, errors.New("no sync committee returned")

cmd/synccommittee/members/process_internal_test.go

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

cmd/synccommitteemembers.go

@@ -49,7 +49,7 @@ epoch can be a specific epoch.  period can be 'current' for the current sync per
 func init() {
 	synccommitteeCmd.AddCommand(synccommitteeMembersCmd)
 	synccommitteeFlags(synccommitteeMembersCmd)
-	synccommitteeMembersCmd.Flags().Int64("epoch", -1, "the epoch for which to fetch sync committees")
+	synccommitteeMembersCmd.Flags().String("epoch", "", "the epoch for which to fetch sync committees")
 	synccommitteeMembersCmd.Flags().String("period", "", "the sync committee period for which to fetch sync committees ('current', 'next')")
 }
 

cmd/validator/credentials/get/output.go

@@ -15,6 +15,7 @@ package validatorcredentialsget
 
 import (
 	"context"
+	"encoding/hex"
 	"fmt"
 	"strings"
 
@@ -47,7 +48,7 @@ func (c *command) output(_ context.Context) (string, error) {
 
 // addressBytesToEIP55 converts a byte array in to an EIP-55 string format.
 func addressBytesToEIP55(address []byte) string {
-	bytes := []byte(fmt.Sprintf("%x", address))
+	bytes := []byte(hex.EncodeToString(address))
 	hash := ethutil.Keccak256(bytes)
 	for i := 0; i < len(bytes); i++ {
 		hashByte := hash[i/2]

cmd/validator/credentials/set/process.go

@@ -732,7 +732,7 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Set up chaintime.
 	c.chainTime, err = standardchaintime.New(ctx,
-		standardchaintime.WithGenesisTimeProvider(c.consensusClient.(consensusclient.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(c.consensusClient.(consensusclient.GenesisProvider)),
 		standardchaintime.WithSpecProvider(c.consensusClient.(consensusclient.SpecProvider)),
 	)
 	if err != nil {
@@ -828,7 +828,7 @@ func (c *command) obtainForkVersion(_ context.Context) (phase0.Version, error) {
 
 // addressBytesToEIP55 converts a byte array in to an EIP-55 string format.
 func addressBytesToEIP55(address []byte) string {
-	bytes := []byte(fmt.Sprintf("%x", address))
+	bytes := []byte(hex.EncodeToString(address))
 	hash := ethutil.Keccak256(bytes)
 	for i := 0; i < len(bytes); i++ {
 		hashByte := hash[i/2]

cmd/validator/depositdata/output.go

@@ -112,6 +112,7 @@ func validatorDepositDataOutputLaunchpad(datum *dataOut) (string, error) {
 		[4]byte{0x00, 0x00, 0x10, 0x20}: "goerli",
 		[4]byte{0x80, 0x00, 0x00, 0x69}: "ropsten",
 		[4]byte{0x90, 0x00, 0x00, 0x69}: "sepolia",
+		[4]byte{0x00, 0x01, 0x70, 0x00}: "holesky",
 	}
 
 	if datum.validatorPubKey == nil {

cmd/validator/depositdata/process.go

@@ -155,7 +155,7 @@ func createWithdrawalCredentials(data *dataIn) ([]byte, error) {
 
 // addressBytesToEIP55 converts a byte array in to an EIP-55 string format.
 func addressBytesToEIP55(address []byte) string {
-	bytes := []byte(fmt.Sprintf("%x", address))
+	bytes := []byte(hex.EncodeToString(address))
 	hash := util.Keccak256(bytes)
 	for i := 0; i < len(bytes); i++ {
 		hashByte := hash[i/2]

cmd/validator/duties/process.go

@@ -18,7 +18,8 @@ import (
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
-	api "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/api"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
 	spec "github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/wealdtech/ethdo/util"
@@ -75,28 +76,32 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	}
 	results.nextEpochAttesterDuty = nextEpochAttesterDuty
 
-	genesis, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
+	genesisResponse, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx, &api.GenesisOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain genesis data")
 	}
-	results.genesisTime = genesis.GenesisTime
+	results.genesisTime = genesisResponse.Data.GenesisTime
 
-	config, err := eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	specResponse, err := eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain beacon chain configuration")
 	}
-	results.slotsPerEpoch = config["SLOTS_PER_EPOCH"].(uint64)
-	results.slotDuration = config["SECONDS_PER_SLOT"].(time.Duration)
+	results.slotsPerEpoch = specResponse.Data["SLOTS_PER_EPOCH"].(uint64)
+	results.slotDuration = specResponse.Data["SECONDS_PER_SLOT"].(time.Duration)
 
 	return results, nil
 }
 
-func attesterDuty(ctx context.Context, eth2Client eth2client.Service, validatorIndex spec.ValidatorIndex, epoch spec.Epoch) (*api.AttesterDuty, error) {
+func attesterDuty(ctx context.Context, eth2Client eth2client.Service, validatorIndex spec.ValidatorIndex, epoch spec.Epoch) (*apiv1.AttesterDuty, error) {
 	// Find the attesting slot for the given epoch.
-	duties, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, epoch, []spec.ValidatorIndex{validatorIndex})
+	dutiesResponse, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, &api.AttesterDutiesOpts{
+		Epoch:   epoch,
+		Indices: []spec.ValidatorIndex{validatorIndex},
+	})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain attester duties")
 	}
+	duties := dutiesResponse.Data
 
 	if len(duties) == 0 {
 		return nil, errors.New("validator does not have duty for that epoch")
@@ -105,30 +110,33 @@ func attesterDuty(ctx context.Context, eth2Client eth2client.Service, validatorI
 	return duties[0], nil
 }
 
-func proposerDuties(ctx context.Context, eth2Client eth2client.Service, validatorIndex spec.ValidatorIndex, epoch spec.Epoch) ([]*api.ProposerDuty, error) {
+func proposerDuties(ctx context.Context, eth2Client eth2client.Service, validatorIndex spec.ValidatorIndex, epoch spec.Epoch) ([]*apiv1.ProposerDuty, error) {
 	// Fetch the proposer duties for this epoch.
-	proposerDuties, err := eth2Client.(eth2client.ProposerDutiesProvider).ProposerDuties(ctx, epoch, []spec.ValidatorIndex{validatorIndex})
+	proposerDuties, err := eth2Client.(eth2client.ProposerDutiesProvider).ProposerDuties(ctx, &api.ProposerDutiesOpts{
+		Epoch:   epoch,
+		Indices: []spec.ValidatorIndex{validatorIndex},
+	})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain proposer duties")
 	}
 
-	return proposerDuties, nil
+	return proposerDuties.Data, nil
 }
 
 func currentEpoch(ctx context.Context, eth2Client eth2client.Service) (spec.Epoch, error) {
-	config, err := eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	specResponse, err := eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return 0, errors.Wrap(err, "failed to obtain beacon chain configuration")
 	}
-	slotsPerEpoch := config["SLOTS_PER_EPOCH"].(uint64)
-	slotDuration := config["SECONDS_PER_SLOT"].(time.Duration)
-	genesis, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
+	slotsPerEpoch := specResponse.Data["SLOTS_PER_EPOCH"].(uint64)
+	slotDuration := specResponse.Data["SECONDS_PER_SLOT"].(time.Duration)
+
+	genesisResponse, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx, &api.GenesisOpts{})
 	if err != nil {
 		return 0, errors.Wrap(err, "failed to obtain genesis data")
 	}
-
-	if genesis.GenesisTime.After(time.Now()) {
+	if genesisResponse.Data.GenesisTime.After(time.Now()) {
 		return spec.Epoch(0), nil
 	}
-	return spec.Epoch(uint64(time.Since(genesis.GenesisTime).Seconds()) / (uint64(slotDuration.Seconds()) * slotsPerEpoch)), nil
+	return spec.Epoch(uint64(time.Since(genesisResponse.Data.GenesisTime).Seconds()) / (uint64(slotDuration.Seconds()) * slotsPerEpoch)), nil
 }

cmd/validator/exit/process.go

@@ -599,7 +599,7 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Set up chaintime.
 	c.chainTime, err = standardchaintime.New(ctx,
-		standardchaintime.WithGenesisTimeProvider(c.consensusClient.(consensusclient.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(c.consensusClient.(consensusclient.GenesisProvider)),
 		standardchaintime.WithSpecProvider(c.consensusClient.(consensusclient.SpecProvider)),
 	)
 	if err != nil {
@@ -614,7 +614,7 @@ func (c *command) generateDomain(ctx context.Context) error {
 	if err != nil {
 		return err
 	}
-	forkVersion, err := c.obtainForkVersion(ctx)
+	forkVersion, err := c.obtainExitForkVersion(ctx)
 	if err != nil {
 		return err
 	}
@@ -661,10 +661,11 @@ func (c *command) obtainGenesisValidatorsRoot(_ context.Context) (phase0.Root, e
 	if c.debug {
 		fmt.Fprintf(os.Stderr, "Using genesis validators root %#x\n", genesisValidatorsRoot)
 	}
+
 	return genesisValidatorsRoot, nil
 }
 
-func (c *command) obtainForkVersion(_ context.Context) (phase0.Version, error) {
+func (c *command) obtainExitForkVersion(_ context.Context) (phase0.Version, error) {
 	forkVersion := phase0.Version{}
 
 	if c.forkVersion != "" {
@@ -683,12 +684,13 @@ func (c *command) obtainForkVersion(_ context.Context) (phase0.Version, error) {
 		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[:])
+		// Use the Capella fork version for generating an exit as per the spec.
+		copy(forkVersion[:], c.chainInfo.ExitForkVersion[:])
 	}
 
 	if c.debug {
 		fmt.Fprintf(os.Stderr, "Using fork version %#x\n", forkVersion)
 	}
+
 	return forkVersion, nil
 }

cmd/validator/expectation/command.go

@@ -16,7 +16,7 @@ package validatorexpectation
 import (
 	"context"
 	"encoding/json"
-	"fmt"
+	"strconv"
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
@@ -63,11 +63,11 @@ type resultsJSON struct {
 
 func (r *results) MarshalJSON() ([]byte, error) {
 	data := &resultsJSON{
-		ActiveValidators:          fmt.Sprintf("%d", r.activeValidators),
+		ActiveValidators:          strconv.FormatUint(r.activeValidators, 10),
 		TimeBetweenProposals:      durafmt.Parse(r.timeBetweenProposals).LimitFirstN(2).String(),
-		SecsBetweenProposals:      fmt.Sprintf("%d", int64(r.timeBetweenProposals.Seconds())),
+		SecsBetweenProposals:      strconv.FormatInt(int64(r.timeBetweenProposals.Seconds()), 10),
 		TimeBetweenSyncCommittees: durafmt.Parse(r.timeBetweenSyncCommittees).LimitFirstN(2).String(),
-		SecsBetweenSyncCommittees: fmt.Sprintf("%d", int64(r.timeBetweenSyncCommittees.Seconds())),
+		SecsBetweenSyncCommittees: strconv.FormatInt(int64(r.timeBetweenSyncCommittees.Seconds()), 10),
 	}
 	return json.Marshal(data)
 }

cmd/validator/expectation/process.go

@@ -19,6 +19,7 @@ import (
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/pkg/errors"
 	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
 	"github.com/wealdtech/ethdo/util"
@@ -45,12 +46,12 @@ func (c *command) calculateProposalChance(ctx context.Context) error {
 	// Chance of proposing a block is 1/activeValidators.
 	// Expectation of number of slots before proposing a block is 1/p, == activeValidators slots.
 
-	spec, err := c.eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	specResponse, err := c.eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return err
 	}
 
-	tmp, exists := spec["SECONDS_PER_SLOT"]
+	tmp, exists := specResponse.Data["SECONDS_PER_SLOT"]
 	if !exists {
 		return errors.New("spec missing SECONDS_PER_SLOT")
 	}
@@ -68,12 +69,12 @@ func (c *command) calculateSyncCommitteeChance(ctx context.Context) error {
 	// Chance of being in a sync committee is SYNC_COMMITTEE_SIZE/activeValidators.
 	// Expectation of number of periods before being in a sync committee is 1/p, activeValidators/SYNC_COMMITTEE_SIZE periods.
 
-	spec, err := c.eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	specResponse, err := c.eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return err
 	}
 
-	tmp, exists := spec["SECONDS_PER_SLOT"]
+	tmp, exists := specResponse.Data["SECONDS_PER_SLOT"]
 	if !exists {
 		return errors.New("spec missing SECONDS_PER_SLOT")
 	}
@@ -82,7 +83,7 @@ func (c *command) calculateSyncCommitteeChance(ctx context.Context) error {
 		return errors.New("SECONDS_PER_SLOT of incorrect type")
 	}
 
-	tmp, exists = spec["SYNC_COMMITTEE_SIZE"]
+	tmp, exists = specResponse.Data["SYNC_COMMITTEE_SIZE"]
 	if !exists {
 		return errors.New("spec missing SYNC_COMMITTEE_SIZE")
 	}
@@ -91,7 +92,7 @@ func (c *command) calculateSyncCommitteeChance(ctx context.Context) error {
 		return errors.New("SYNC_COMMITTEE_SIZE of incorrect type")
 	}
 
-	tmp, exists = spec["SLOTS_PER_EPOCH"]
+	tmp, exists = specResponse.Data["SLOTS_PER_EPOCH"]
 	if !exists {
 		return errors.New("spec missing SLOTS_PER_EPOCH")
 	}
@@ -100,7 +101,7 @@ func (c *command) calculateSyncCommitteeChance(ctx context.Context) error {
 		return errors.New("SLOTS_PER_EPOCH of incorrect type")
 	}
 
-	tmp, exists = spec["EPOCHS_PER_SYNC_COMMITTEE_PERIOD"]
+	tmp, exists = specResponse.Data["EPOCHS_PER_SYNC_COMMITTEE_PERIOD"]
 	if !exists {
 		return errors.New("spec missing EPOCHS_PER_SYNC_COMMITTEE_PERIOD")
 	}
@@ -135,7 +136,7 @@ func (c *command) setup(ctx context.Context) error {
 
 	chainTime, err := standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return errors.Wrap(err, "failed to set up chaintime service")
@@ -148,13 +149,15 @@ func (c *command) setup(ctx context.Context) error {
 		return errors.New("connection does not provide validator information")
 	}
 
-	validators, err := c.validatorsProvider.Validators(ctx, "head", nil)
+	response, err := c.validatorsProvider.Validators(ctx, &api.ValidatorsOpts{
+		State: "head",
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain validators")
 	}
 
 	currentEpoch := chainTime.CurrentEpoch()
-	for _, validator := range validators {
+	for _, validator := range response.Data {
 		if validator.Validator.ActivationEpoch <= currentEpoch &&
 			validator.Validator.ExitEpoch > currentEpoch {
 			c.res.activeValidators++

cmd/validator/summary/process.go

@@ -16,9 +16,11 @@ package validatorsummary
 import (
 	"context"
 	"fmt"
+	"net/http"
 	"sort"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
@@ -81,21 +83,28 @@ func (c *command) process(ctx context.Context) error {
 }
 
 func (c *command) processProposerDuties(ctx context.Context) error {
-	duties, err := c.proposerDutiesProvider.ProposerDuties(ctx, c.summary.Epoch, nil)
+	response, err := c.proposerDutiesProvider.ProposerDuties(ctx, &api.ProposerDutiesOpts{
+		Epoch: c.summary.Epoch,
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain proposer duties")
 	}
-	if duties == nil {
-		return errors.New("empty proposer duties")
-	}
-	for _, duty := range duties {
+	for _, duty := range response.Data {
 		if _, exists := c.validatorsByIndex[duty.ValidatorIndex]; !exists {
 			continue
 		}
-		block, err := c.blocksProvider.SignedBeaconBlock(ctx, fmt.Sprintf("%d", duty.Slot))
+		blockResponse, err := c.blocksProvider.SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+			Block: fmt.Sprintf("%d", duty.Slot),
+		})
 		if err != nil {
+			var apiErr *api.Error
+			if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+				return nil
+			}
+
 			return errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", duty.Slot))
 		}
+		block := blockResponse.Data
 		present := block != nil
 		c.summary.Proposals = append(c.summary.Proposals, &epochProposal{
 			Slot:     duty.Slot,
@@ -133,10 +142,14 @@ func (c *command) processAttesterDuties(ctx context.Context) error {
 	}
 
 	// Obtain the duties for the validators to know where they should be attesting.
-	duties, err := c.attesterDutiesProvider.AttesterDuties(ctx, c.summary.Epoch, activeValidatorIndices)
+	dutiesResponse, err := c.attesterDutiesProvider.AttesterDuties(ctx, &api.AttesterDutiesOpts{
+		Epoch:   c.summary.Epoch,
+		Indices: activeValidatorIndices,
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain attester duties")
 	}
+	duties := dutiesResponse.Data
 	for slot := c.chainTime.FirstSlotOfEpoch(c.summary.Epoch); slot < c.chainTime.FirstSlotOfEpoch(c.summary.Epoch+1); slot++ {
 		index := int(slot - c.chainTime.FirstSlotOfEpoch(c.summary.Epoch))
 		c.summary.Slots[index].Attestations = &slotAttestations{}
@@ -213,14 +226,18 @@ func (c *command) processAttesterDutiesSlot(ctx context.Context,
 	headersCache *util.BeaconBlockHeaderCache,
 	activeValidatorIndices []phase0.ValidatorIndex,
 ) error {
-	block, err := c.blocksProvider.SignedBeaconBlock(ctx, fmt.Sprintf("%d", slot))
+	blockResponse, err := c.blocksProvider.SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+		Block: fmt.Sprintf("%d", slot),
+	})
 	if err != nil {
-		return errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", slot))
-	}
-	if block == nil {
-		// No block at this slot; that's fine.
-		return nil
+		var apiErr *api.Error
+		if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+			return nil
+		}
+
+		return errors.Wrap(err, "failed to obtain beacon block")
 	}
+	block := blockResponse.Data
 	attestations, err := block.Attestations()
 	if err != nil {
 		return err
@@ -393,7 +410,7 @@ func (c *command) setup(ctx context.Context) error {
 
 	c.chainTime, err = standardchaintime.New(ctx,
 		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
 	)
 	if err != nil {
 		return errors.Wrap(err, "failed to set up chaintime service")

cmd/validator/withdrawal/process.go

@@ -20,8 +20,8 @@ import (
 	"time"
 
 	consensusclient "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
-	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
@@ -49,10 +49,13 @@ func (c *command) process(ctx context.Context) error {
 		return errors.New("validator has nothing to withdraw")
 	}
 
-	block, err := c.consensusClient.(consensusclient.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, "head")
+	blockResponse, err := c.consensusClient.(consensusclient.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+		Block: "head",
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain block")
 	}
+	block := blockResponse.Data
 	slot, err := block.Slot()
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain block slot")
@@ -61,32 +64,25 @@ func (c *command) process(ctx context.Context) error {
 		fmt.Fprintf(os.Stderr, "Slot is %d\n", slot)
 	}
 
-	validatorsMap, err := c.consensusClient.(consensusclient.ValidatorsProvider).Validators(ctx, fmt.Sprintf("%d", slot), nil)
+	response, err := c.consensusClient.(consensusclient.ValidatorsProvider).Validators(ctx, &api.ValidatorsOpts{
+		State: fmt.Sprintf("%d", slot),
+	})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain validators")
 	}
-	validators := make([]*apiv1.Validator, len(validatorsMap))
-	for _, validator := range validatorsMap {
+	validators := make([]*apiv1.Validator, len(response.Data))
+	for _, validator := range response.Data {
 		validators[validator.Index] = validator
 	}
 
-	var nextWithdrawalValidatorIndex phase0.ValidatorIndex
-	switch block.Version {
-	case spec.DataVersionCapella:
-		withdrawals := block.Capella.Message.Body.ExecutionPayload.Withdrawals
-		if len(withdrawals) == 0 {
-			return errors.New("block without withdrawals; cannot obtain next withdrawal validator index")
-		}
-		nextWithdrawalValidatorIndex = phase0.ValidatorIndex((int(withdrawals[len(withdrawals)-1].ValidatorIndex) + 1) % len(validators))
-	case spec.DataVersionDeneb:
-		withdrawals := block.Deneb.Message.Body.ExecutionPayload.Withdrawals
-		if len(withdrawals) == 0 {
-			return errors.New("block without withdrawals; cannot obtain next withdrawal validator index")
-		}
-		nextWithdrawalValidatorIndex = phase0.ValidatorIndex((int(withdrawals[len(withdrawals)-1].ValidatorIndex) + 1) % len(validators))
-	default:
-		return fmt.Errorf("unhandled block version %v", block.Version)
+	withdrawals, err := block.Withdrawals()
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain withdrawals from block")
 	}
+	if len(withdrawals) == 0 {
+		return errors.New("block without withdrawals; cannot obtain next withdrawal validator index")
+	}
+	nextWithdrawalValidatorIndex := phase0.ValidatorIndex((int(withdrawals[len(withdrawals)-1].ValidatorIndex) + 1) % len(validators))
 
 	if c.debug {
 		fmt.Fprintf(os.Stderr, "Next withdrawal validator index is %d\n", nextWithdrawalValidatorIndex)
@@ -133,25 +129,25 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Set up chaintime.
 	c.chainTime, err = standardchaintime.New(ctx,
-		standardchaintime.WithGenesisTimeProvider(c.consensusClient.(consensusclient.GenesisTimeProvider)),
+		standardchaintime.WithGenesisProvider(c.consensusClient.(consensusclient.GenesisProvider)),
 		standardchaintime.WithSpecProvider(c.consensusClient.(consensusclient.SpecProvider)),
 	)
 	if err != nil {
 		return errors.Wrap(err, "failed to create chaintime service")
 	}
 
-	spec, err := c.consensusClient.(consensusclient.SpecProvider).Spec(ctx)
+	specResponse, err := c.consensusClient.(consensusclient.SpecProvider).Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return errors.Wrap(err, "failed to obtain spec")
 	}
 
-	if val, exists := spec["MAX_WITHDRAWALS_PER_PAYLOAD"]; !exists {
+	if val, exists := specResponse.Data["MAX_WITHDRAWALS_PER_PAYLOAD"]; !exists {
 		c.maxWithdrawalsPerPayload = 16
 	} else {
 		c.maxWithdrawalsPerPayload = val.(uint64)
 	}
 
-	if val, exists := spec["MAX_EFFECTIVE_BALANCE"]; !exists {
+	if val, exists := specResponse.Data["MAX_EFFECTIVE_BALANCE"]; !exists {
 		c.maxEffectiveBalance = 32000000000
 	} else {
 		c.maxEffectiveBalance = phase0.Gwei(val.(uint64))

cmd/validator/yield/process.go

@@ -20,6 +20,7 @@ import (
 	"strconv"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/pkg/errors"
 	"github.com/shopspring/decimal"
 	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
@@ -48,12 +49,12 @@ var (
 
 // calculateYield calculates yield from the number of active validators.
 func (c *command) calculateYield(ctx context.Context) error {
-	spec, err := c.eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	specResponse, err := c.eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return err
 	}
 
-	tmp, exists := spec["BASE_REWARD_FACTOR"]
+	tmp, exists := specResponse.Data["BASE_REWARD_FACTOR"]
 	if !exists {
 		return errors.New("spec missing BASE_REWARD_FACTOR")
 	}
@@ -125,7 +126,7 @@ func (c *command) setup(ctx context.Context) error {
 	if c.validators == "" {
 		chainTime, err := standardchaintime.New(ctx,
 			standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
-			standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+			standardchaintime.WithGenesisProvider(c.eth2Client.(eth2client.GenesisProvider)),
 		)
 		if err != nil {
 			return errors.Wrap(err, "failed to set up chaintime service")
@@ -143,14 +144,16 @@ func (c *command) setup(ctx context.Context) error {
 			return errors.Wrap(err, "failed to parse epoch")
 		}
 
-		validators, err := validatorsProvider.Validators(ctx, fmt.Sprintf("%d", chainTime.FirstSlotOfEpoch(epoch)), nil)
+		response, err := validatorsProvider.Validators(ctx, &api.ValidatorsOpts{
+			State: fmt.Sprintf("%d", chainTime.FirstSlotOfEpoch(epoch)),
+		})
 		if err != nil {
 			return err
 		}
 
 		activeValidators := decimal.Zero
 		activeValidatorBalance := decimal.Zero
-		for _, validator := range validators {
+		for _, validator := range response.Data {
 			if validator.Validator.ActivationEpoch <= epoch &&
 				validator.Validator.ExitEpoch > epoch {
 				activeValidators = activeValidators.Add(one)

cmd/validatorinfo.go

@@ -30,6 +30,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
 	"github.com/wealdtech/ethdo/util"
 	string2eth "github.com/wealdtech/go-string2eth"
 )
@@ -53,6 +54,14 @@ In quiet mode this will return 0 if the validator information can be obtained, o
 		})
 		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 
+		chainTime, err := standardchaintime.New(ctx,
+			standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
+			standardchaintime.WithGenesisProvider(eth2Client.(eth2client.GenesisProvider)),
+		)
+		if err != nil {
+			errCheck(err, "failed to set up chaintime service")
+		}
+
 		if viper.GetString("validator") == "" {
 			fmt.Println("validator is required")
 			os.Exit(_exitFailure)
@@ -84,7 +93,13 @@ In quiet mode this will return 0 if the validator information can be obtained, o
 		}
 		if viper.GetBool("verbose") {
 			if validator.Status.IsPending() {
-				fmt.Printf("Activation eligibility epoch: %d\n", validator.Validator.ActivationEligibilityEpoch)
+				if validator.Validator.ActivationEpoch == 0xffffffffffffffff {
+					fmt.Printf("Activation eligibility epoch: %d\n", validator.Validator.ActivationEligibilityEpoch)
+					fmt.Printf("Activation eligibility timestamp: %v\n", chainTime.StartOfEpoch(validator.Validator.ActivationEligibilityEpoch))
+				} else {
+					fmt.Printf("Activation epoch: %d\n", validator.Validator.ActivationEpoch)
+					fmt.Printf("Activation timestamp: %v\n", chainTime.StartOfEpoch(validator.Validator.ActivationEpoch))
+				}
 			}
 			if validator.Status.HasActivated() {
 				fmt.Printf("Activation epoch: %d\n", validator.Validator.ActivationEpoch)

cmd/version.go

@@ -1,4 +1,4 @@
-// Copyright © 2019 - 2023 Weald Technology Trading.
+// Copyright © 2019 - 2024 Weald Technology Trading.
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -16,7 +16,7 @@ package cmd
 import (
 	"fmt"
 	"os"
-	dbg "runtime/debug"
+	"runtime/debug"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -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.32.0)"
+var ReleaseVersion = "local build (latest release 1.35.2)"
 
 // versionCmd represents the version command.
 var versionCmd = &cobra.Command{
@@ -36,7 +36,16 @@ var versionCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		fmt.Println(ReleaseVersion)
 		if viper.GetBool("verbose") {
-			buildInfo, ok := dbg.ReadBuildInfo()
+			if info, ok := debug.ReadBuildInfo(); ok {
+				for _, setting := range info.Settings {
+					if setting.Key == "vcs.revision" {
+						fmt.Printf("Commit hash: %s\n", setting.Value)
+						break
+					}
+				}
+			}
+
+			buildInfo, ok := debug.ReadBuildInfo()
 			if ok {
 				fmt.Printf("Package: %s\n", buildInfo.Path)
 				fmt.Println("Dependencies:")

cmd/wallet/batch/command.go

@@ -0,0 +1,62 @@
+// 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 walletbatch
+
+import (
+	"context"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/util"
+)
+
+type command struct {
+	quiet   bool
+	verbose bool
+	debug   bool
+
+	timeout time.Duration
+
+	// Operation.
+	walletName      string
+	passphrases     []string
+	batchPassphrase string
+}
+
+func newCommand(_ context.Context) (*command, error) {
+	c := &command{
+		quiet:           viper.GetBool("quiet"),
+		verbose:         viper.GetBool("verbose"),
+		debug:           viper.GetBool("debug"),
+		timeout:         viper.GetDuration("timeout"),
+		walletName:      viper.GetString("wallet"),
+		passphrases:     util.GetPassphrases(),
+		batchPassphrase: viper.GetString("batch-passphrase"),
+	}
+
+	if c.timeout == 0 {
+		return nil, errors.New("timeout is required")
+	}
+
+	if c.walletName == "" {
+		return nil, errors.New("wallet is required")
+	}
+
+	if c.batchPassphrase == "" {
+		return nil, errors.New("batch passphrase is required")
+	}
+
+	return c, nil
+}

cmd/wallet/batch/output.go

@@ -0,0 +1,22 @@
+// 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 walletbatch
+
+import (
+	"context"
+)
+
+func (c *command) output(_ context.Context) (string, error) {
+	return "", nil
+}

cmd/wallet/batch/process.go

@@ -0,0 +1,43 @@
+// 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 walletbatch
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/util"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func (c *command) process(ctx context.Context) error {
+	// Obtain the wallet.
+	opCtx, cancel := context.WithTimeout(ctx, c.timeout)
+	wallet, err := util.WalletFromInput(opCtx)
+	cancel()
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain wallet")
+	}
+	batchCreator, isBatchCreator := wallet.(e2wtypes.WalletBatchCreator)
+	if !isBatchCreator {
+		return errors.New("wallet does not support batching")
+	}
+
+	// Create the batch.
+	if err := batchCreator.BatchWallet(ctx, util.GetPassphrases(), c.batchPassphrase); err != nil {
+		return errors.Wrap(err, "failed to batch wallet")
+	}
+
+	return nil
+}

cmd/wallet/batch/process_internal_test.go

@@ -0,0 +1,63 @@
+// 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 walletbatch
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestProcess(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		err  string
+	}{
+		{
+			name: "NoBlock",
+			vars: map[string]interface{}{
+				"timeout":    "60s",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+				"blockid":    "invalid",
+			},
+			err: "failed to obtain beacon block: failed to request signed beacon block: GET failed with status 400: {\"code\":400,\"message\":\"Invalid block: invalid\"}",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			cmd, err := newCommand(context.Background())
+			require.NoError(t, err)
+			err = cmd.process(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/wallet/batch/run.go

@@ -0,0 +1,50 @@
+// 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 walletbatch
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+
+	c, err := newCommand(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to set up command")
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	if err := c.process(ctx); err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := c.output(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/wallet/import/process_internal_test.go

@@ -62,7 +62,7 @@ func TestProcess(t *testing.T) {
 				data:       append([]byte{0x00}, data...),
 				passphrase: "ce%NohGhah4ye5ra",
 			},
-			err: "failed to import wallet: unhandled version 0x00",
+			err: "failed to import wallet: failed to decrypt wallet: unhandled version 0x00",
 		},
 		{
 			name: "PassphraseMissing",
@@ -70,7 +70,7 @@ func TestProcess(t *testing.T) {
 				timeout: 5 * time.Second,
 				data:    data,
 			},
-			err: "failed to import wallet: invalid key",
+			err: "failed to import wallet: failed to decrypt wallet: invalid key",
 		},
 		{
 			name: "PassphraseIncorrect",
@@ -79,7 +79,7 @@ func TestProcess(t *testing.T) {
 				data:       data,
 				passphrase: "weak",
 			},
-			err: "failed to import wallet: invalid key",
+			err: "failed to import wallet: failed to decrypt wallet: invalid key",
 		},
 		{
 			name: "Good",

cmd/wallet/sharedexport/output.go

@@ -15,7 +15,7 @@ package walletsharedexport
 
 import (
 	"context"
-	"fmt"
+	"encoding/hex"
 	"strings"
 
 	"github.com/pkg/errors"
@@ -32,7 +32,7 @@ func output(_ context.Context, data *dataOut) (string, error) {
 
 	builder := strings.Builder{}
 	for i := range data.shares {
-		builder.WriteString(fmt.Sprintf("%x", data.shares[i]))
+		builder.WriteString(hex.EncodeToString(data.shares[i]))
 		if i != len(data.shares)-1 {
 			builder.WriteString("\n")
 		}

cmd/walletbatch.go

@@ -0,0 +1,54 @@
+// Copyright © 2023 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	walletbatch "github.com/wealdtech/ethdo/cmd/wallet/batch"
+)
+
+var walletBatchCmd = &cobra.Command{
+	Use:   "batch",
+	Short: "Batch a wallet",
+	Long: `Batch a wallet.  For example:
+
+    ethdo wallet batch --wallet="Primary wallet" --passphrase=accounts-secret --batch-passphrase=batch-secret
+
+In quiet mode this will return 0 if the wallet is batched successfully, otherwise 1.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := walletbatch.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	walletCmd.AddCommand(walletBatchCmd)
+	walletFlags(walletBatchCmd)
+	walletBatchCmd.Flags().String("batch-passphrase", "", "The passphrase to use for the batch")
+}
+
+func walletBatchBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("batch-passphrase", cmd.Flags().Lookup("batch-passphrase")); err != nil {
+		panic(err)
+	}
+}

docs/usage.md

@@ -29,12 +29,25 @@ Auctions: 0x812f340269c315c1d882ae7c13cdaddf862dbdbd482b1836798b2070160dd1e19408
 Operations: 0x8e2f9e8cc29658ff37ecc30e95a0807579b224586c185d128cb7a7490784c1ad9b0ab93dbe604ab075b40079931e6670
 Spending: 0x85dfc6dcee4c9da36f6473ec02fda283d6c920c641fc8e3a76113c5c227d4aeeb100efcfec977b12d20d571907d05650
 ```
+
+#### `batch`
+
+`ethdo wallet batch` batches the accounts in a wallet into a single file to allow faster decryption. Options for batching a wallet include:
+
+- `wallet`: the name of the wallet to batch
+- `passphrase`: the passphrase for of the accounts in the wallet
+- `batch-passphrase`: the passphrase for the batch.   Note that this can be the same as the passphrase for the accounts
+
+```sh
+$ ethdo wallet batch --wallet="Validators" ---passphrase="my account secret" --batch-passphrase="my batch secret"
+```
+
 #### `create`
 
 `ethdo wallet create` creates a new wallet with the given parameters.  Options for creating a wallet include:
 
 - `wallet`: the name of the wallet to create
-- `type`: the type of wallet to create.  This can be either "nd" for a non-deterministic wallet, where private keys are generated randomly, or "hd" for a hierarchical deterministic wallet, where private keys are generated from a seed and path as per [ERC-2333](https://github.com/CarlBeek/EIPs/blob/bls_path/EIPS/eip-2334.md) (defaults to "nd")
+- `type`: the type of wallet to create.  This can be either "nd" for a non-deterministic wallet, where private keys are generated randomly, or "hd" for a hierarchical deterministic wallet, where private keys are generated from a seed and path as per [EIP-2333](https://eips.ethereum.org/EIPS/eip-2333) (defaults to "nd")
 - `wallet-passphrase`: the passphrase for of the wallet.  This is required for hierarchical deterministic wallets, to protect the seed
 - `mnemonic`: for hierarchical deterministic wallets only, use a pre-defined 24-word [BIP-39 seed phrase](https://en.bitcoin.it/wiki/Seed_phrase) to create the wallet, along with an additional "seed extension" phrase if required.  **Warning** The same mnemonic can be used to create multiple wallets, in which case they will generate the same keys.
 
@@ -782,6 +795,7 @@ Proposer commands focus on Ethereum consensus validators' actions as proposers.
 `ethdo proposer duties` provides information on the proposal duties for a given epoch.  Options include:
 
 - `epoch` the epoch in which to obtain the duties (defaults to current epoch)
+- `slot` the slot in which to obtain the duties (overrides epoch if present)
 - `json` obtain detailed information in JSON format
 
 ```sh

go.mod

@@ -3,96 +3,102 @@ module github.com/wealdtech/ethdo
 go 1.20
 
 require (
-	github.com/attestantio/go-eth2-client v0.17.0
+	github.com/attestantio/go-eth2-client v0.19.10
 	github.com/ferranbt/fastssz v0.1.3
 	github.com/gofrs/uuid v4.4.0+incompatible
-	github.com/google/uuid v1.3.0
+	github.com/google/uuid v1.5.0
 	github.com/hako/durafmt v0.0.0-20210608085754-5c1018a4e16b
-	github.com/herumi/bls-eth-go-binary v1.29.1
+	github.com/herumi/bls-eth-go-binary v1.33.0
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/nbutton23/zxcvbn-go v0.0.0-20210217022336-fa2cb2858354
 	github.com/pkg/errors v0.9.1
 	github.com/prysmaticlabs/go-bitfield v0.0.0-20210809151128-385d8c5e3fb7
 	github.com/prysmaticlabs/go-ssz v0.0.0-20210121151755-f6208871c388
-	github.com/rs/zerolog v1.29.0
+	github.com/rs/zerolog v1.31.0
 	github.com/shopspring/decimal v1.3.1
-	github.com/spf13/cobra v1.7.0
+	github.com/spf13/cobra v1.8.0
 	github.com/spf13/pflag v1.0.5
-	github.com/spf13/viper v1.15.0
-	github.com/stretchr/testify v1.8.2
+	github.com/spf13/viper v1.18.2
+	github.com/stretchr/testify v1.8.4
 	github.com/tyler-smith/go-bip39 v1.1.0
 	github.com/wealdtech/go-bytesutil v1.2.1
-	github.com/wealdtech/go-ecodec v1.1.3
-	github.com/wealdtech/go-eth2-types/v2 v2.8.1
-	github.com/wealdtech/go-eth2-util v1.8.1
-	github.com/wealdtech/go-eth2-wallet v1.15.1
-	github.com/wealdtech/go-eth2-wallet-dirk v1.4.2
-	github.com/wealdtech/go-eth2-wallet-distributed v1.1.5
-	github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.3.1
-	github.com/wealdtech/go-eth2-wallet-hd/v2 v2.6.1
-	github.com/wealdtech/go-eth2-wallet-nd/v2 v2.4.1
-	github.com/wealdtech/go-eth2-wallet-store-filesystem v1.17.1
-	github.com/wealdtech/go-eth2-wallet-store-s3 v1.11.3
-	github.com/wealdtech/go-eth2-wallet-store-scratch v1.7.1
-	github.com/wealdtech/go-eth2-wallet-types/v2 v2.10.1
+	github.com/wealdtech/go-ecodec v1.1.4
+	github.com/wealdtech/go-eth2-types/v2 v2.8.2
+	github.com/wealdtech/go-eth2-util v1.8.2
+	github.com/wealdtech/go-eth2-wallet v1.16.0
+	github.com/wealdtech/go-eth2-wallet-dirk v1.4.7
+	github.com/wealdtech/go-eth2-wallet-distributed v1.2.1
+	github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.4.1
+	github.com/wealdtech/go-eth2-wallet-hd/v2 v2.7.0
+	github.com/wealdtech/go-eth2-wallet-nd/v2 v2.5.0
+	github.com/wealdtech/go-eth2-wallet-store-filesystem v1.18.1
+	github.com/wealdtech/go-eth2-wallet-store-s3 v1.12.0
+	github.com/wealdtech/go-eth2-wallet-store-scratch v1.7.2
+	github.com/wealdtech/go-eth2-wallet-types/v2 v2.11.0
 	github.com/wealdtech/go-string2eth v1.2.1
-	golang.org/x/text v0.9.0
+	golang.org/x/text v0.14.0
 )
 
 require (
-	github.com/aws/aws-sdk-go v1.44.213 // indirect
+	github.com/aws/aws-sdk-go v1.50.0 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/dgraph-io/ristretto v0.1.1 // indirect
-	github.com/dustin/go-humanize v1.0.0 // indirect
-	github.com/fatih/color v1.13.0 // indirect
-	github.com/fsnotify/fsnotify v1.6.0 // indirect
-	github.com/go-logr/logr v1.2.3 // indirect
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/fatih/color v1.16.0 // indirect
+	github.com/fsnotify/fsnotify v1.7.0 // indirect
+	github.com/go-logr/logr v1.4.1 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/goccy/go-yaml v1.9.2 // indirect
-	github.com/golang/glog v1.0.0 // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/goccy/go-yaml v1.11.2 // indirect
+	github.com/golang/glog v1.2.0 // indirect
+	github.com/golang/protobuf v1.5.3 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
-	github.com/holiman/uint256 v1.2.2 // indirect
+	github.com/holiman/uint256 v1.2.4 // indirect
+	github.com/huandu/go-clone v1.7.2 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/jackc/puddle v1.3.0 // indirect
+	github.com/jackc/puddle/v2 v2.2.1 // indirect
 	github.com/jmespath/go-jmespath v0.4.0 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.6 // indirect
 	github.com/magiconair/properties v1.8.7 // 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/mattn/go-isatty v0.0.20 // indirect
 	github.com/minio/highwayhash v1.0.2 // indirect
-	github.com/minio/sha256-simd v1.0.0 // indirect
+	github.com/minio/sha256-simd v1.0.1 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
-	github.com/pelletier/go-toml/v2 v2.0.6 // 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/pelletier/go-toml/v2 v2.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
+	github.com/prometheus/client_golang v1.18.0 // indirect
+	github.com/prometheus/client_model v0.5.0 // indirect
+	github.com/prometheus/common v0.46.0 // indirect
+	github.com/prometheus/procfs v0.12.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.10.0 // indirect
+	github.com/sagikazarmark/locafero v0.4.0 // indirect
+	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
 	github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0 // indirect
-	github.com/spf13/afero v1.9.3 // indirect
-	github.com/spf13/cast v1.5.0 // indirect
-	github.com/spf13/jwalterweatherman v1.1.0 // indirect
-	github.com/subosito/gotenv v1.4.2 // indirect
-	github.com/wealdtech/eth2-signer-api v1.7.1 // indirect
-	github.com/wealdtech/go-indexer v1.0.1 // 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.6.0 // indirect
-	golang.org/x/net v0.6.0 // indirect
-	golang.org/x/sync v0.1.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-20230110181048-76db0878b65f // indirect
-	google.golang.org/grpc v1.53.0 // indirect
-	google.golang.org/protobuf v1.28.1 // indirect
+	github.com/sourcegraph/conc v0.3.0 // indirect
+	github.com/spf13/afero v1.11.0 // indirect
+	github.com/spf13/cast v1.6.0 // indirect
+	github.com/subosito/gotenv v1.6.0 // indirect
+	github.com/wealdtech/eth2-signer-api v1.7.2 // indirect
+	github.com/wealdtech/go-indexer v1.1.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.47.0 // indirect
+	go.opentelemetry.io/otel v1.22.0 // indirect
+	go.opentelemetry.io/otel/metric v1.22.0 // indirect
+	go.opentelemetry.io/otel/trace v1.22.0 // indirect
+	go.uber.org/multierr v1.11.0 // indirect
+	golang.org/x/crypto v0.18.0 // indirect
+	golang.org/x/exp v0.0.0-20240119083558-1b970713d09a // indirect
+	golang.org/x/net v0.20.0 // indirect
+	golang.org/x/sync v0.6.0 // indirect
+	golang.org/x/sys v0.16.0 // indirect
+	golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect
+	google.golang.org/genproto v0.0.0-20240116215550-a9fa1716bcac // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20240116215550-a9fa1716bcac // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240116215550-a9fa1716bcac // indirect
+	google.golang.org/grpc v1.60.1 // indirect
+	google.golang.org/protobuf v1.32.0 // indirect
 	gopkg.in/cenkalti/backoff.v1 v1.1.0 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect

go.sum

@@ -1,802 +1,266 @@
-cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
-cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
-cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
-cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
-cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
-cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
-cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
-cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
-cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
-cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
-cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=
-cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
-cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=
-cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=
-cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI=
-cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk=
-cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY=
-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.15.1 h1:7UGq3QknM33pw5xATlpzeoomNxsacIVvTqTTvbfajmE=
+cloud.google.com/go v0.111.0 h1:YHLKNupSD1KqjDbQ3+LVdQ81h/UJbJyZG203cEfnQgM=
+cloud.google.com/go/compute v1.23.3 h1:6sVlXXBmbd7jNX0Ipq0trII3e4n1/MsADLK6a+aiVlk=
 cloud.google.com/go/compute/metadata v0.2.3 h1:mg4jlk7mCAj6xXp9UJ4fjI9VUI5rubuGBW5aJ7UnBMY=
-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/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/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=
-cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
-cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
-cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo=
-dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
-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/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
-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 v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
-github.com/attestantio/go-eth2-client v0.17.0 h1:Rvn/tmLHRRztoS2c/6AmsslGucyytWMvnQlAUz4EvYY=
-github.com/attestantio/go-eth2-client v0.17.0/go.mod h1:N+BNIxaHmul44d0tTjwFrUJU/g6MIblFP67oagm1Lwo=
-github.com/aws/aws-sdk-go v1.44.213 h1:WahquyWs7cQdz0vpDVWyWETEemgSoORx0PbWL9oz2WA=
-github.com/aws/aws-sdk-go v1.44.213/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/attestantio/go-eth2-client v0.19.10 h1:NLs9mcBvZpBTZ3du7Ey2NHQoj8d3UePY7pFBXX6C6qs=
+github.com/attestantio/go-eth2-client v0.19.10/go.mod h1:TTz7YF6w4z6ahvxKiHuGPn6DbQn7gH6HPuWm/DEQeGE=
+github.com/aws/aws-sdk-go v1.50.0 h1:HBtrLeO+QyDKnc3t1+5DR1RxodOHCGr8ZcrHudpv7jI=
+github.com/aws/aws-sdk-go v1.50.0/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk=
 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/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
-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/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
 github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
-github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
-github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
-github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
-github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
-github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
-github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
-github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
-github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/cncf/xds/go v0.0.0-20230607035331-e9ce68804cb4 h1:/inchEIKaYC1Akx+H+gqO04wryn5h75LSazbRlnya1k=
+github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
+github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 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/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgraph-io/ristretto v0.1.1 h1:6CWw5tJNgpegArSHpNHJKldNeq03FQCwYvfMVWajOK8=
 github.com/dgraph-io/ristretto v0.1.1/go.mod h1:S1GPSBCYCIhmVNfcth17y2zZtQT6wzkzgwUve0VDWWA=
 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/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=
-github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
-github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
-github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/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/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-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/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/envoyproxy/protoc-gen-validate v1.0.2 h1:QkIBuU5k+x7/QXPvPPnWXWlCdaBFApVqftFV6k087DA=
+github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
+github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
 github.com/ferranbt/fastssz v0.1.3 h1:ZI+z3JH05h4kgmFXdHuR1aWYsgrg7o+Fw7/NCzM16Mo=
 github.com/ferranbt/fastssz v0.1.3/go.mod h1:0Y9TEd/9XuFlh7mskMPfXiI2Dkw4Ddg9EyXt1W7MRvE=
-github.com/frankban/quicktest v1.14.3 h1:FJKSZTDHjyhriyC81FLQ0LY93eSai0ZyR/ZIkd3ZUKE=
-github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY=
-github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
-github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
-github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-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/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
+github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
+github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
 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/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ=
+github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 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=
 github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
-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-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/goccy/go-yaml v1.9.2 h1:2Njwzw+0+pjU2gb805ZC1B/uBuAs2VcZ3K+ZgHwDs7w=
-github.com/goccy/go-yaml v1.9.2/go.mod h1:U/jl18uSupI5rdI2jmuCswEA2htH9eXfferR3KfscvA=
+github.com/goccy/go-yaml v1.11.2 h1:joq77SxuyIs9zzxEjgyLBugMQ9NEgTWxXfz2wVqwAaQ=
+github.com/goccy/go-yaml v1.11.2/go.mod h1:wKnAMd44+9JAAnGQpWVEgBzGt3YuTaQ4uXoHvE4m7WU=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/gofrs/uuid v4.4.0+incompatible h1:3qXRTX8/NbyulANqlc0lchS1gqAVxRgsuW1YrTJupqA=
 github.com/gofrs/uuid v4.4.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
-github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 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=
-github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
-github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
-github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
-github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
-github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/glog v1.2.0 h1:uCdmnmatrKCgMBlM4rMuJZWOkPDqdbZPnrMXDY4gI68=
+github.com/golang/glog v1.2.0/go.mod h1:6AhwSGph0fcJtXVM/PEHPqZlFeoLxhs7/t5UDAwmO+w=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
-github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
+github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
-github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
-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=
-github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
-github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
-github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
-github.com/google/pprof v0.0.0-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
-github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
-github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
-github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
-github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
-github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g=
-github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=
+github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 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/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
-github.com/herumi/bls-eth-go-binary v1.29.1 h1:XcNSHYTyNjEUVfWDCE2gtG5r95biTwd7MJUJF09LtSE=
-github.com/herumi/bls-eth-go-binary v1.29.1/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
-github.com/holiman/uint256 v1.2.2 h1:TXKcSGc2WaxPD2+bmzAsVthL4+pEN0YwXcL5qED83vk=
-github.com/holiman/uint256 v1.2.2/go.mod h1:SC8Ryt4n+UBbPbIBKaG9zbbDlp4jOru9xFZmPzLUTxw=
-github.com/huandu/go-clone v1.6.0 h1:HMo5uvg4wgfiy5FoGOqlFLQED/VGRm2D9Pi8g1FXPGc=
+github.com/herumi/bls-eth-go-binary v1.33.0 h1:fHoysK+WbL/FQIJoVGECGd2lBLa2De7YjAGZljI2vzQ=
+github.com/herumi/bls-eth-go-binary v1.33.0/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
+github.com/holiman/uint256 v1.2.4 h1:jUc4Nk8fm9jZabQuqr2JzednajVmBpC+oiTiXZJEApU=
+github.com/holiman/uint256 v1.2.4/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E=
+github.com/huandu/go-assert v1.1.5 h1:fjemmA7sSfYHJD7CUqs9qTwwfdNAx7/j2/ZlHXzNB3c=
+github.com/huandu/go-assert v1.1.5/go.mod h1:yOLvuqZwmcHIC5rIzrBhT7D3Q9c3GFnd0JrPVhn/06U=
+github.com/huandu/go-clone v1.7.2 h1:3+Aq0Ed8XK+zKkLjE2dfHg0XrpIfcohBE1K+c8Usxoo=
+github.com/huandu/go-clone v1.7.2/go.mod h1:ReGivhG6op3GYr+UY3lS6mxjKp7MIGTknuU5TbTVaXE=
 github.com/huandu/go-clone/generic v1.6.0 h1:Wgmt/fUZ28r16F2Y3APotFD59sHk1p78K0XLdbUYN5U=
-github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
-github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-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/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
+github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 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=
 github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
-github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
-github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
-github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
-github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
-github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
-github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
-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/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
-github.com/klauspost/cpuid/v2 v2.2.4 h1:acbojRNwl3o09bUq+yDCtZFc1aiwaAAxtcn8YkZXnvk=
-github.com/klauspost/cpuid/v2 v2.2.4/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=
-github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-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/klauspost/cpuid/v2 v2.2.6 h1:ndNyv040zDGIDh8thGkXYjnFtiN02M1PVVF+JE/48xc=
+github.com/klauspost/cpuid/v2 v2.2.6/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 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/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY=
 github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-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.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=
-github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-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/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/minio/highwayhash v1.0.2 h1:Aak5U0nElisjDCfPSG79Tgzkn2gl66NxOMspRrKnA/g=
 github.com/minio/highwayhash v1.0.2/go.mod h1:BQskDq+xkJ12lmlUUi7U0M5Swg3EWR+dLTk+kldvVxY=
-github.com/minio/sha256-simd v1.0.0 h1:v1ta+49hkWZyvaKwrQB8elexRqm6Y0aMLjCNsrYxo6g=
-github.com/minio/sha256-simd v1.0.0/go.mod h1:OuYzVNI5vcoYIAmbIvHPl3N3jUzVedXbKy5RFepssQM=
+github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM=
+github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
 github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
-github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
-github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
-github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 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/pelletier/go-toml/v2 v2.0.6 h1:nrzqCb7j9cDFj2coyLNLaZuJTLjWjlaz6nvTvIwycIU=
-github.com/pelletier/go-toml/v2 v2.0.6/go.mod h1:eumQOmlWiOPt5WriQQqoM5y18pDHwha2N+QD+EUNTek=
-github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pelletier/go-toml/v2 v2.1.1 h1:LWAJwfNvjQZCFIDKWYQaM62NcYeYViCmWIwmOStowAI=
+github.com/pelletier/go-toml/v2 v2.1.1/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
-github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
-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.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.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/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prometheus/client_golang v1.18.0 h1:HzFfmkOzH5Q8L8G+kSJKUx5dtG87sewO+FoDDqP5Tbk=
+github.com/prometheus/client_golang v1.18.0/go.mod h1:T+GXkCk5wSJyOqMIzVgvvjFDlkOQntgjkJWKrN5txjA=
+github.com/prometheus/client_model v0.5.0 h1:VQw1hfvPvk3Uv6Qf29VrPF32JB6rtbgI6cYPYQjL0Qw=
+github.com/prometheus/client_model v0.5.0/go.mod h1:dTiFglRmd66nLR9Pv9f0mZi7B7fk5Pm3gvsjB5tr+kI=
+github.com/prometheus/common v0.46.0 h1:doXzt5ybi1HBKpsZOL0sSkaNHJJqkyfEWZGGqqScV0Y=
+github.com/prometheus/common v0.46.0/go.mod h1:Tp0qkxpb9Jsg54QMe+EAmqXkSV7Evdy1BTn+g2pa/hQ=
+github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo=
+github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo=
 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/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/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/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.4.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
-github.com/rs/zerolog v1.29.0 h1:Zes4hju04hjbvkVkOhdl2HpZa+0PmVwigmo8XoORE5w=
-github.com/rs/zerolog v1.29.0/go.mod h1:NILgTygv/Uej1ra5XxGf82ZFSLk58MFGAUS2o6usyD0=
+github.com/r3labs/sse/v2 v2.10.0 h1:hFEkLLFY4LDifoHdiCN/LlGBAdVJYsANaLqNYa1l/v0=
+github.com/r3labs/sse/v2 v2.10.0/go.mod h1:Igau6Whc+F17QUgML1fYe1VPZzTV6EMCnYktEmkNJ7I=
+github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
+github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
+github.com/rs/zerolog v1.31.0 h1:FcTR3NnLWW+NnTwwhFWiJSZr4ECLpqCm6QsEnyvbV4A=
+github.com/rs/zerolog v1.31.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ=
+github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4=
+github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE=
+github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ=
 github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0 h1:Xuk8ma/ibJ1fOy4Ee11vHhUFHQNpHhrBneOCNHVXS5w=
 github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0/go.mod h1:7AwjWCpdPhkSmNAgUv5C7EJ4AbmjEB3r047r3DXWu3Y=
 github.com/shopspring/decimal v1.3.1 h1:2Usl1nmF/WZucqkFZhnfFYxxxu8LG21F6nPQBE5gKV8=
 github.com/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o=
-github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
-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/spf13/afero v1.9.3 h1:41FoI0fD7OR7mGcKE/aOiLkGreyf8ifIOQmJANWogMk=
-github.com/spf13/afero v1.9.3/go.mod h1:iUV7ddyEEZPO5gA3zD4fJt6iStLlL+Lg4m2cihcDf8Y=
-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 v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
-github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
-github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk=
-github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo=
+github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=
+github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=
+github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8=
+github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY=
+github.com/spf13/cast v1.6.0 h1:GEiTHELF+vaR5dhz3VqZfFSzZjYbgeKDpBxQVS4GYJ0=
+github.com/spf13/cast v1.6.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
+github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
+github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
 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.15.0 h1:js3yy885G8xwJa6iOISGFwd+qlUo5AvyXb7CiihdtiU=
-github.com/spf13/viper v1.15.0/go.mod h1:fFcTBJxvhhzSJiZy8n+PeW6t8l+KeT/uTARa0jHOQLA=
+github.com/spf13/viper v1.18.2 h1:LUXCnvUvSM6FXAsj6nnfc8Q2tp1dIgUfY9Kc8GsSOiQ=
+github.com/spf13/viper v1.18.2/go.mod h1:EKmWIqdnk5lOcmR72yw6hS+8OPYcwD0jteitLMVB+yk=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 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=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 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/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
-github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/subosito/gotenv v1.4.2 h1:X1TuBLAMDFbaTAChgCBLu3DU3UPyELpnF2jjJ2cz/S8=
-github.com/subosito/gotenv v1.4.2/go.mod h1:ayKnFf/c6rvx/2iiLrJUk1e6plDbT3edrFNGqEflhK0=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
+github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
 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/umbracle/gohashtree v0.0.2-alpha.0.20230207094856-5b775a815c10 h1:CQh33pStIp/E30b7TxDlXfM0145bn2e8boI30IxAhTg=
-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/eth2-signer-api v1.7.2 h1:9wmwWEstUwukyZmh0OhQfSHm9KrqFHF7oLSlrk0l2Uk=
+github.com/wealdtech/eth2-signer-api v1.7.2/go.mod h1:HOdnGSKi9z6OkV/UgpKpbsF3HcOAJkIjjjSWTXisnWI=
 github.com/wealdtech/go-bytesutil v1.2.1 h1:TjuRzcG5KaPwaR5JB7L/OgJqMQWvlrblA1n0GfcXFSY=
 github.com/wealdtech/go-bytesutil v1.2.1/go.mod h1:RhUDUGT1F4UP4ydqbYp2MWJbAel3M+mKd057Pad7oag=
-github.com/wealdtech/go-ecodec v1.1.3 h1:ldQFJqzvega2IMsbjB6Yp4uZMsQTxvYnuM521ZGiglo=
-github.com/wealdtech/go-ecodec v1.1.3/go.mod h1:+sSrfAZvFf1bqEBfPGB42VtHijcT27cUkw6J1gueJKg=
-github.com/wealdtech/go-eth2-types/v2 v2.8.1 h1:y2N3xSIZ3tVqsnvj4AgPkh48U5sM612vhZwlK3k+3lM=
-github.com/wealdtech/go-eth2-types/v2 v2.8.1/go.mod h1:3TJShI4oBzG8pCZsfe3NZAq8QAmXrC2rd45q7Vn/XB8=
-github.com/wealdtech/go-eth2-util v1.8.1 h1:nb50hygsNoql94akg7GN6im/weg8ZZgJWHgiyrj8qiU=
-github.com/wealdtech/go-eth2-util v1.8.1/go.mod h1:vv+8jVgYRXEGty/VLPNn1RYlbQNYmTht3VR6nfh0z4E=
-github.com/wealdtech/go-eth2-wallet v1.15.1 h1:gtjl5EE5XgJBEs7s6s4XenIyGsn2d4TQCmXj9anP7Gc=
-github.com/wealdtech/go-eth2-wallet v1.15.1/go.mod h1:FoUxyJQ1xNNdUJkb9KfNTM79MmItX682EujqbcnVLdc=
-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.5 h1:kUpESVq2dVGeI4GXUy/LfoP5fycl3LGYTUcta7VTIjE=
-github.com/wealdtech/go-eth2-wallet-distributed v1.1.5/go.mod h1:zaATC9jRC3bn7jAmB2+MaCiyyJcavHGzSq5OCd7h/tM=
-github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.3.1 h1:NlWiq9cUd69xFvhAdCRpz7CwfDjMuz8cEvPQ9yponT4=
-github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.3.1/go.mod h1:luy/Y/I3gC3JxT0mQBKqysvzRN1DiFnwqUij8Yc2SP4=
-github.com/wealdtech/go-eth2-wallet-encryptor-unencrypted v1.0.1 h1:x6bq8cVgRgfhwtSQSYo/9AqJ8qEeaS6af28cW0cVj5U=
-github.com/wealdtech/go-eth2-wallet-hd/v2 v2.6.1 h1:pEVfJCHB5T02oVtOumpcwU9H4zC2vWsJEQl09moh+n0=
-github.com/wealdtech/go-eth2-wallet-hd/v2 v2.6.1/go.mod h1:11BHG8gt2FqQC02MrT4KN2+EV1ZTsn9SmSVme1HWp7E=
-github.com/wealdtech/go-eth2-wallet-nd/v2 v2.4.1 h1:LvgLIYaP+WqZ8xcrN4e0CAIGDtjKhzpBqAhjExQzqb4=
-github.com/wealdtech/go-eth2-wallet-nd/v2 v2.4.1/go.mod h1:279Gj7DqpQBar9eoo82RcC6SgD0fiZs1Dc6SffsDZM0=
-github.com/wealdtech/go-eth2-wallet-store-filesystem v1.17.1 h1:fe3wd7fKCy4d3TsdKGWsy5/uKoyKiz4GsYyck/BDO88=
-github.com/wealdtech/go-eth2-wallet-store-filesystem v1.17.1/go.mod h1:mlB4RA5n1/3CnktH2iphuYoky7xn3DEugKvXrFqkBW4=
-github.com/wealdtech/go-eth2-wallet-store-s3 v1.11.3 h1:HAUyuCcoxpmm5c1DVJ3P7vI9v12aI3u23O2qrw7vugE=
-github.com/wealdtech/go-eth2-wallet-store-s3 v1.11.3/go.mod h1:OQyhned9FiLSC/5misLeAvc/BGhBDlksZGOe0PFq17o=
-github.com/wealdtech/go-eth2-wallet-store-scratch v1.7.1 h1:0JRUCM6UgpsgTGGpd8Q6BDQXAyhRd359mumBf6pAdlc=
-github.com/wealdtech/go-eth2-wallet-store-scratch v1.7.1/go.mod h1:NaGxeFPNnLqDAUtbs1smC5m60QSX4kQqPRh5myEvNiA=
-github.com/wealdtech/go-eth2-wallet-types/v2 v2.10.1 h1:RRJhZ9M3S2Vh5k1SLwQmyA4NZ7E1HM4QnnHhiUySFdk=
-github.com/wealdtech/go-eth2-wallet-types/v2 v2.10.1/go.mod h1:ErJ+f0bEVFn218QcwhY+Sy9UUa8XgfEjVeNauUJqOgE=
-github.com/wealdtech/go-indexer v1.0.1 h1:kInFsg0ZYHXE5EPY0dhgyBu1nSfS126h4m2iKgvuBFQ=
-github.com/wealdtech/go-indexer v1.0.1/go.mod h1:kqGWOcsn/5rFSIJF4hjwQnIUM/Aqa91RNrdWVNBhqCg=
+github.com/wealdtech/go-ecodec v1.1.4 h1:iHx9/X3Szn1Q5RbZmk5l8A1TdUDXtAFb21gJH1JcO5A=
+github.com/wealdtech/go-ecodec v1.1.4/go.mod h1:zEblpCFdl9xZlcNYoDL9o6U7YtzY+eWzOao13UVe4j0=
+github.com/wealdtech/go-eth2-types/v2 v2.8.2 h1:b5aXlNBLKgjAg/Fft9VvGlqAUCQMP5LzYhlHRrr4yPg=
+github.com/wealdtech/go-eth2-types/v2 v2.8.2/go.mod h1:IAz9Lz1NVTaHabQa+4zjk2QDKMv8LVYo0n46M9o/TXw=
+github.com/wealdtech/go-eth2-util v1.8.2 h1:gq+JMrnadifyKadUr75wmfP7+usiqMu9t3VVoob5Dvo=
+github.com/wealdtech/go-eth2-util v1.8.2/go.mod h1:/80GAK0K/3+PqUBZHvaOPd3b1sjHeimxQh1nrJzgaPk=
+github.com/wealdtech/go-eth2-wallet v1.16.0 h1:syD1xDYB7emk4x+6bTYm5VZp9nx5FLab5Fgm09Eq1Kg=
+github.com/wealdtech/go-eth2-wallet v1.16.0/go.mod h1:JFA2P7PpPR8quQ/T6Gsr/4VLj5sQVnyzKgfPA+eqmYE=
+github.com/wealdtech/go-eth2-wallet-dirk v1.4.7 h1:P9xgaoBB9h1r0OUEE6LHffZ+IbiGE4uniMaNjvP1+D8=
+github.com/wealdtech/go-eth2-wallet-dirk v1.4.7/go.mod h1:fP/g7OQQTYCFRg+ZIv6eoTvDdjkZlHnLcf41UgCvrM8=
+github.com/wealdtech/go-eth2-wallet-distributed v1.2.1 h1:+pbG9i9b5TrWd7GDRX8yq4FKA+D7k7aI6uySEvAZ+Kk=
+github.com/wealdtech/go-eth2-wallet-distributed v1.2.1/go.mod h1:jYkDax2VhUNKIct6TVlgxAagvR56/eg7y7J+JFq+gDo=
+github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.4.1 h1:9j7bpwjT9wmwBb54ZkBhTm1uNIlFFcCJXefd/YskZPw=
+github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.4.1/go.mod h1:+tI1VD76E1WINI+Nstg7RVGpUolL5ql10nu2YztMO/4=
+github.com/wealdtech/go-eth2-wallet-encryptor-unencrypted v1.0.2 h1:IMIyl70hbJlxOkgTcCK//3vKe5ylhGIk6oUlIlK9xp0=
+github.com/wealdtech/go-eth2-wallet-hd/v2 v2.7.0 h1:5g4emFacTf+sX6zx6SbZIZGR7Jx5Xr/Xdb7sXnEXlWk=
+github.com/wealdtech/go-eth2-wallet-hd/v2 v2.7.0/go.mod h1:aWgnEi07w1L9wMBRB69sYvoEONppAUly6FDQRWQGqH8=
+github.com/wealdtech/go-eth2-wallet-nd/v2 v2.5.0 h1:vphAFklkYMRJVo9f5rVWly7PECHrLS4yarjemBa7fRM=
+github.com/wealdtech/go-eth2-wallet-nd/v2 v2.5.0/go.mod h1:kBZUZogqwvvxulEvXi5l6OjZyd7EBmCKxce5Q+lW7fs=
+github.com/wealdtech/go-eth2-wallet-store-filesystem v1.18.1 h1:Ceq74WL57jdBQnrZJFJyGRBKOOFI5wwq9VoxeAbjoEk=
+github.com/wealdtech/go-eth2-wallet-store-filesystem v1.18.1/go.mod h1:woTpldN8qThnmya/0yeD+a3u/3Zj42u6/ijgF9CGaz8=
+github.com/wealdtech/go-eth2-wallet-store-s3 v1.12.0 h1:noknYCbHw2soPhwke1LvC99Kk/2CLN787KcgxdZ7OGo=
+github.com/wealdtech/go-eth2-wallet-store-s3 v1.12.0/go.mod h1:1lSVxfQynUAd5u46rCeAI8wCl8S44lZsNYYXlxVAvwU=
+github.com/wealdtech/go-eth2-wallet-store-scratch v1.7.2 h1:TwOt7bEHsVe6dKJb7XuUG7m06gaBGPCQlBk24Ql8Mws=
+github.com/wealdtech/go-eth2-wallet-store-scratch v1.7.2/go.mod h1:rtIoB34tqL3kUOK+LsLTAHfynxLR8pGScy0lmQmpbKc=
+github.com/wealdtech/go-eth2-wallet-types/v2 v2.11.0 h1:yX9+FfUXvPDvZ8Q5bhF+64AWrQwh4a3/HpfTx99DnZc=
+github.com/wealdtech/go-eth2-wallet-types/v2 v2.11.0/go.mod h1:UVP9YFcnPiIzHqbmCMW3qrQ3TK5FOqr1fmKqNT9JGr8=
+github.com/wealdtech/go-indexer v1.1.0 h1:vn4gY7nSYSLe0sXVauJgyHvK4NXiDrLKBYYYKWypahk=
+github.com/wealdtech/go-indexer v1.1.0/go.mod h1:lEFTda1rul1EwWIX3QqXq/KW0tnEEhC41Lup06V7Tlo=
 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=
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
-go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
-go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-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.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=
-golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.47.0 h1:UNQQKPfTDe1J81ViolILjTKPr9WetKW6uei2hFgJmFs=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.47.0/go.mod h1:r9vWsPS/3AQItv3OSlEJ/E4mbrhUbbw18meOjArPtKQ=
+go.opentelemetry.io/otel v1.22.0 h1:xS7Ku+7yTFvDfDraDIJVpw7XPyuHlB9MCiqqX5mcJ6Y=
+go.opentelemetry.io/otel v1.22.0/go.mod h1:eoV4iAi3Ea8LkAEI9+GFT44O6T/D0GWAVFyZVCC6pMI=
+go.opentelemetry.io/otel/metric v1.22.0 h1:lypMQnGyJYeuYPhOM/bgjbFM6WE44W1/T45er4d8Hhg=
+go.opentelemetry.io/otel/metric v1.22.0/go.mod h1:evJGjVpZv0mQ5QBRJoBF64yMuOf4xCWdXjK8pzFvliY=
+go.opentelemetry.io/otel/trace v1.22.0 h1:Hg6pPujv0XG9QaVbGOBVHunyuLcCC3jN7WEhPx83XD0=
+go.opentelemetry.io/otel/trace v1.22.0/go.mod h1:RbbHXVqKES9QhzZq/fE5UnOSILqRt40a21sPw2He1xo=
+go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
+go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
 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=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
-golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.6.0 h1:qfktjS5LUO+fFKeJXZ+ikTRijMmljikvG68fpMMruSc=
-golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=
-golang.org/x/exp v0.0.0-20190121172915-509febef88a4/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=
-golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
-golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-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-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=
-golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
-golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
-golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
-golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
-golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
-golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
-golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/crypto v0.18.0 h1:PGVlW0xEltQnzFZ55hkuX5+KLyrMYhHld1YHO4AKcdc=
+golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
+golang.org/x/exp v0.0.0-20240119083558-1b970713d09a h1:Q8/wZp0KX97QFTc2ywcOE0YRjZPVIx+MXInMzdvQqcA=
+golang.org/x/exp v0.0.0-20240119083558-1b970713d09a/go.mod h1:idGWGoKP1toJGkd5/ig9ZLuPcZBC3ewk7SzmH0uou08=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-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-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=
-golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20211020060615-d418f374d309/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.6.0 h1:L4ZwwTvKW9gr0ZMS1yrHD9GZhIuVjOBBnaKH+SPQK0Q=
-golang.org/x/net v0.6.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=
-golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/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.4.0 h1:NF0gk8LVPg1Ml7SSbGyySuoxdsXitj7TvgvuRxIMc/M=
-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=
-golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-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-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-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-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo=
+golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
+golang.org/x/oauth2 v0.16.0 h1:aDkGMBSYxElaoP81NpoUoz2oo2R2wHdZpGToUxfyQrQ=
+golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
+golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 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-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-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-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/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-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20221010170243-090e33056c14/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.1.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=
-golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
+golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-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/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-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-20180917221912-90fa682c2a6e/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-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=
-golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-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-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
-golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
-golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
-golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
-golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
-golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
-golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE=
-golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
-golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-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=
-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=
-google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
-google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
-google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
-google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM=
-google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc=
-google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg=
-google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE=
-google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8=
-google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
-google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-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=
-google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-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-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=
-google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
-google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-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-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-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-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=
-google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20211027162914-98a5263abeca/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
-google.golang.org/genproto v0.0.0-20230110181048-76db0878b65f h1:BWUVssLB0HVOSY78gIdvk1dTVYtT1y8SBWtPYuTJ/6w=
-google.golang.org/genproto v0.0.0-20230110181048-76db0878b65f/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.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=
-google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
-google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
-google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
-google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
-google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
-google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0=
-google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
-google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8=
-google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
-google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
-google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
-google.golang.org/grpc v1.41.0/go.mod h1:U3l9uK9J0sini8mHphKoXyaqDA/8VyGnDee1zzIUK6k=
-google.golang.org/grpc v1.53.0 h1:LAv2ds7cmFV/XTS3XG1NneeENYrXGmorPxsBbptIjNc=
-google.golang.org/grpc v1.53.0/go.mod h1:OnIrk0ipVdj4N5d9IUoFUx72/VlD7+jUsHwZgwSMQpw=
-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=
-google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
-google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
-google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
-google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
+golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU=
+golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90=
+google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM=
+google.golang.org/genproto v0.0.0-20240116215550-a9fa1716bcac h1:ZL/Teoy/ZGnzyrqK/Optxxp2pmVh+fmJ97slxSRyzUg=
+google.golang.org/genproto v0.0.0-20240116215550-a9fa1716bcac/go.mod h1:+Rvu7ElI+aLzyDQhpHMFMMltsD6m7nqpuWDd2CwJw3k=
+google.golang.org/genproto/googleapis/api v0.0.0-20240116215550-a9fa1716bcac h1:OZkkudMUu9LVQMCoRUbI/1p5VCo9BOrlvkqMvWtqa6s=
+google.golang.org/genproto/googleapis/api v0.0.0-20240116215550-a9fa1716bcac/go.mod h1:B5xPO//w8qmBDjGReYLpR6UJPnkldGkCSMoH/2vxJeg=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240116215550-a9fa1716bcac h1:nUQEQmH/csSvFECKYRv6HWEyypysidKl2I6Qpsglq/0=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240116215550-a9fa1716bcac/go.mod h1:daQN87bsDqDoe316QbbvX60nMoJQa4r6Ds0ZuoAe5yA=
+google.golang.org/grpc v1.60.1 h1:26+wFr+cNqSGFcOXcabYC0lUVJVRa2Sb2ortSK7VrEU=
+google.golang.org/grpc v1.60.1/go.mod h1:OlCHIeLYqSSsLi6i49B5QGdzaMZK9+M7LXN2FKz4eGM=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
-google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
-gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I=
+google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/cenkalti/backoff.v1 v1.1.0 h1:Arh75ttbsvlpVA7WtVpH4u9h6Zl46xuptxqLxPiSo4Y=
 gopkg.in/cenkalti/backoff.v1 v1.1.0/go.mod h1:J6Vskwqd+OMVJl8C33mmtxTBs2gyzfv7UDAkHu8BrjI=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-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/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 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/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=
-gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo=
-honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
-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/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,14 +20,14 @@ import (
 )
 
 type parameters struct {
-	logLevel            zerolog.Level
-	genesisTimeProvider eth2client.GenesisTimeProvider
-	specProvider        eth2client.SpecProvider
+	logLevel        zerolog.Level
+	genesisProvider eth2client.GenesisProvider
+	specProvider    eth2client.SpecProvider
 }
 
 // Parameter is the interface for service parameters.
 type Parameter interface {
-	apply(*parameters)
+	apply(p *parameters)
 }
 
 type parameterFunc func(*parameters)
@@ -43,10 +43,10 @@ func WithLogLevel(logLevel zerolog.Level) Parameter {
 	})
 }
 
-// WithGenesisTimeProvider sets the genesis time provider.
-func WithGenesisTimeProvider(provider eth2client.GenesisTimeProvider) Parameter {
+// WithGenesisProvider sets the genesis time provider.
+func WithGenesisProvider(provider eth2client.GenesisProvider) Parameter {
 	return parameterFunc(func(p *parameters) {
-		p.genesisTimeProvider = provider
+		p.genesisProvider = provider
 	})
 }
 
@@ -71,8 +71,8 @@ func parseAndCheckParameters(params ...Parameter) (*parameters, error) {
 	if parameters.specProvider == nil {
 		return nil, errors.New("no spec provider specified")
 	}
-	if parameters.genesisTimeProvider == nil {
-		return nil, errors.New("no genesis time provider specified")
+	if parameters.genesisProvider == nil {
+		return nil, errors.New("no genesis provider specified")
 	}
 
 	return &parameters, nil

services/chaintime/standard/service.go

@@ -18,6 +18,7 @@ import (
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog"
@@ -49,18 +50,18 @@ func New(ctx context.Context, params ...Parameter) (*Service, error) {
 	// Set logging.
 	log = zerologger.With().Str("service", "chaintime").Str("impl", "standard").Logger().Level(parameters.logLevel)
 
-	genesisTime, err := parameters.genesisTimeProvider.GenesisTime(ctx)
+	genesisResponse, err := parameters.genesisProvider.Genesis(ctx, &api.GenesisOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain genesis time")
 	}
-	log.Trace().Time("genesis_time", genesisTime).Msg("Obtained genesis time")
+	log.Trace().Time("genesis_time", genesisResponse.Data.GenesisTime).Msg("Obtained genesis time")
 
-	spec, err := parameters.specProvider.Spec(ctx)
+	specResponse, err := parameters.specProvider.Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain spec")
 	}
 
-	tmp, exists := spec["SECONDS_PER_SLOT"]
+	tmp, exists := specResponse.Data["SECONDS_PER_SLOT"]
 	if !exists {
 		return nil, errors.New("SECONDS_PER_SLOT not found in spec")
 	}
@@ -69,7 +70,7 @@ func New(ctx context.Context, params ...Parameter) (*Service, error) {
 		return nil, errors.New("SECONDS_PER_SLOT of unexpected type")
 	}
 
-	tmp, exists = spec["SLOTS_PER_EPOCH"]
+	tmp, exists = specResponse.Data["SLOTS_PER_EPOCH"]
 	if !exists {
 		return nil, errors.New("SLOTS_PER_EPOCH not found in spec")
 	}
@@ -79,7 +80,7 @@ func New(ctx context.Context, params ...Parameter) (*Service, error) {
 	}
 
 	var epochsPerSyncCommitteePeriod uint64
-	if tmp, exists := spec["EPOCHS_PER_SYNC_COMMITTEE_PERIOD"]; exists {
+	if tmp, exists := specResponse.Data["EPOCHS_PER_SYNC_COMMITTEE_PERIOD"]; exists {
 		tmp2, ok := tmp.(uint64)
 		if !ok {
 			return nil, errors.New("EPOCHS_PER_SYNC_COMMITTEE_PERIOD of unexpected type")
@@ -116,7 +117,7 @@ func New(ctx context.Context, params ...Parameter) (*Service, error) {
 	log.Trace().Uint64("epoch", uint64(denebForkEpoch)).Msg("Obtained Deneb fork epoch")
 
 	s := &Service{
-		genesisTime:                  genesisTime,
+		genesisTime:                  genesisResponse.Data.GenesisTime,
 		slotDuration:                 slotDuration,
 		slotsPerEpoch:                slotsPerEpoch,
 		epochsPerSyncCommitteePeriod: epochsPerSyncCommitteePeriod,
@@ -237,11 +238,11 @@ func fetchAltairForkEpoch(ctx context.Context,
 	error,
 ) {
 	// Fetch the fork version.
-	spec, err := specProvider.Spec(ctx)
+	specResponse, err := specProvider.Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return 0, errors.Wrap(err, "failed to obtain spec")
 	}
-	tmp, exists := spec["ALTAIR_FORK_EPOCH"]
+	tmp, exists := specResponse.Data["ALTAIR_FORK_EPOCH"]
 	if !exists {
 		return 0, errors.New("altair fork version not known by chain")
 	}
@@ -266,11 +267,11 @@ func fetchBellatrixForkEpoch(ctx context.Context,
 	error,
 ) {
 	// Fetch the fork version.
-	spec, err := specProvider.Spec(ctx)
+	specResponse, err := specProvider.Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return 0, errors.Wrap(err, "failed to obtain spec")
 	}
-	tmp, exists := spec["BELLATRIX_FORK_EPOCH"]
+	tmp, exists := specResponse.Data["BELLATRIX_FORK_EPOCH"]
 	if !exists {
 		return 0, errors.New("bellatrix fork version not known by chain")
 	}
@@ -295,11 +296,11 @@ func fetchCapellaForkEpoch(ctx context.Context,
 	error,
 ) {
 	// Fetch the fork version.
-	spec, err := specProvider.Spec(ctx)
+	specResponse, err := specProvider.Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return 0, errors.Wrap(err, "failed to obtain spec")
 	}
-	tmp, exists := spec["CAPELLA_FORK_EPOCH"]
+	tmp, exists := specResponse.Data["CAPELLA_FORK_EPOCH"]
 	if !exists {
 		return 0, errors.New("capella fork version not known by chain")
 	}
@@ -324,11 +325,11 @@ func fetchDenebForkEpoch(ctx context.Context,
 	error,
 ) {
 	// Fetch the fork version.
-	spec, err := specProvider.Spec(ctx)
+	specResponse, err := specProvider.Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return 0, errors.Wrap(err, "failed to obtain spec")
 	}
-	tmp, exists := spec["DENEB_FORK_EPOCH"]
+	tmp, exists := specResponse.Data["DENEB_FORK_EPOCH"]
 	if !exists {
 		return 0, errors.New("deneb fork version not known by chain")
 	}

services/chaintime/standard/service_test.go

@@ -32,7 +32,7 @@ func TestService(t *testing.T) {
 	slotsPerEpoch := uint64(32)
 	epochsPerSyncCommitteePeriod := uint64(256)
 
-	mockGenesisTimeProvider := mock.NewGenesisTimeProvider(genesisTime)
+	mockGenesisProvider := mock.NewGenesisProvider(genesisTime)
 	mockSpecProvider := mock.NewSpecProvider(slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod)
 
 	tests := []struct {
@@ -41,18 +41,18 @@ func TestService(t *testing.T) {
 		err    string
 	}{
 		{
-			name: "GenesisTimeProviderMissing",
+			name: "GenesisProviderMissing",
 			params: []standard.Parameter{
 				standard.WithLogLevel(zerolog.Disabled),
 				standard.WithSpecProvider(mockSpecProvider),
 			},
-			err: "problem with parameters: no genesis time provider specified",
+			err: "problem with parameters: no genesis provider specified",
 		},
 		{
 			name: "SpecProviderMissing",
 			params: []standard.Parameter{
 				standard.WithLogLevel(zerolog.Disabled),
-				standard.WithGenesisTimeProvider(mockGenesisTimeProvider),
+				standard.WithGenesisProvider(mockGenesisProvider),
 			},
 			err: "problem with parameters: no spec provider specified",
 		},
@@ -60,7 +60,7 @@ func TestService(t *testing.T) {
 			name: "Good",
 			params: []standard.Parameter{
 				standard.WithLogLevel(zerolog.Disabled),
-				standard.WithGenesisTimeProvider(mockGenesisTimeProvider),
+				standard.WithGenesisProvider(mockGenesisProvider),
 				standard.WithSpecProvider(mockSpecProvider),
 			},
 		},
@@ -96,10 +96,10 @@ func createService(genesisTime time.Time) (chaintime.Service, time.Duration, uin
 		},
 	}
 
-	mockGenesisTimeProvider := mock.NewGenesisTimeProvider(genesisTime)
+	mockGenesisProvider := mock.NewGenesisProvider(genesisTime)
 	mockSpecProvider := mock.NewSpecProvider(slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod)
 	s, err := standard.New(context.Background(),
-		standard.WithGenesisTimeProvider(mockGenesisTimeProvider),
+		standard.WithGenesisProvider(mockGenesisProvider),
 		standard.WithSpecProvider(mockSpecProvider),
 	)
 	return s, slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod, forkSchedule, err

testing/mock/eth2client.go

@@ -18,31 +18,37 @@ import (
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
-	api "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/api"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
 	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 )
 
-// GenesisTimeProvider is a mock for eth2client.GenesisTimeProvider.
-type GenesisTimeProvider struct {
+// GenesisProvider is a mock for eth2client.GenesisProvider.
+type GenesisProvider struct {
 	genesisTime time.Time
 }
 
-// NewGenesisTimeProvider returns a mock genesis time provider with the provided value.
-func NewGenesisTimeProvider(genesisTime time.Time) eth2client.GenesisTimeProvider {
-	return &GenesisTimeProvider{
+// NewGenesisProvider returns a mock genesis provider with the provided value.
+func NewGenesisProvider(genesisTime time.Time) eth2client.GenesisProvider {
+	return &GenesisProvider{
 		genesisTime: genesisTime,
 	}
 }
 
-// GenesisTime is a mock.
-func (m *GenesisTimeProvider) GenesisTime(_ context.Context) (time.Time, error) {
-	return m.genesisTime, nil
+// Genesisis a mock.
+func (m *GenesisProvider) Genesis(_ context.Context, _ *api.GenesisOpts) (*api.Response[*apiv1.Genesis], error) {
+	return &api.Response[*apiv1.Genesis]{
+		Data: &apiv1.Genesis{
+			GenesisTime: m.genesisTime,
+		},
+		Metadata: make(map[string]any),
+	}, nil
 }
 
 // SpecProvider is a mock for eth2client.SpecProvider.
 type SpecProvider struct {
-	spec map[string]interface{}
+	spec map[string]any
 }
 
 // NewSpecProvider returns a mock spec provider with the provided values.
@@ -51,7 +57,7 @@ func NewSpecProvider(slotDuration time.Duration,
 	epochsPerSyncCommitteePeriod uint64,
 ) eth2client.SpecProvider {
 	return &SpecProvider{
-		spec: map[string]interface{}{
+		spec: map[string]any{
 			"SECONDS_PER_SLOT":                 slotDuration,
 			"SLOTS_PER_EPOCH":                  slotsPerEpoch,
 			"EPOCHS_PER_SYNC_COMMITTEE_PERIOD": epochsPerSyncCommitteePeriod,
@@ -60,8 +66,11 @@ func NewSpecProvider(slotDuration time.Duration,
 }
 
 // Spec is a mock.
-func (m *SpecProvider) Spec(_ context.Context) (map[string]interface{}, error) {
-	return m.spec, nil
+func (m *SpecProvider) Spec(_ context.Context, _ *api.SpecOpts) (*api.Response[map[string]any], error) {
+	return &api.Response[map[string]any]{
+		Data:     m.spec,
+		Metadata: make(map[string]any),
+	}, nil
 }
 
 // ForkScheduleProvider is a mock for eth2client.ForkScheduleProvider.
@@ -77,8 +86,11 @@ func NewForkScheduleProvider(schedule []*phase0.Fork) eth2client.ForkSchedulePro
 }
 
 // ForkSchedule is a mock.
-func (m *ForkScheduleProvider) ForkSchedule(_ context.Context) ([]*phase0.Fork, error) {
-	return m.schedule, nil
+func (m *ForkScheduleProvider) ForkSchedule(_ context.Context, _ *api.ForkScheduleOpts) (*api.Response[[]*phase0.Fork], error) {
+	return &api.Response[[]*phase0.Fork]{
+		Data:     m.schedule,
+		Metadata: make(map[string]any),
+	}, nil
 }
 
 // SlotsPerEpochProvider is a mock for eth2client.SlotsPerEpochProvider.
@@ -146,6 +158,6 @@ func NewBeaconCommitteeSubscriptionsSubmitter() eth2client.BeaconCommitteeSubscr
 }
 
 // SubmitBeaconCommitteeSubscriptions is a mock.
-func (m *BeaconCommitteeSubscriptionsSubmitter) SubmitBeaconCommitteeSubscriptions(_ context.Context, _ []*api.BeaconCommitteeSubscription) error {
+func (m *BeaconCommitteeSubscriptionsSubmitter) SubmitBeaconCommitteeSubscriptions(_ context.Context, _ []*apiv1.BeaconCommitteeSubscription) error {
 	return nil
 }

util/beaconheadercache.go

@@ -15,9 +15,12 @@ package util
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"net/http"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 )
@@ -50,20 +53,23 @@ func (b *BeaconBlockHeaderCache) Fetch(ctx context.Context,
 ) {
 	entry, exists := b.entries[slot]
 	if !exists {
-		header, err := b.beaconBlockHeadersProvider.BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+		response, err := b.beaconBlockHeadersProvider.BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{Block: fmt.Sprintf("%d", slot)})
 		if err != nil {
-			return nil, err
-		}
-		if header == nil {
-			entry = &beaconBlockHeaderEntry{
-				present: false,
+			var apiErr *api.Error
+			if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+				entry = &beaconBlockHeaderEntry{
+					present: false,
+				}
+			} else {
+				return nil, err
 			}
 		} else {
 			entry = &beaconBlockHeaderEntry{
 				present: true,
-				value:   header,
+				value:   response.Data,
 			}
 		}
+
 		b.entries[slot] = entry
 	}
 	return entry.value, nil

util/epoch_test.go

@@ -34,11 +34,11 @@ func TestParseEpoch(t *testing.T) {
 	slotDuration := 12 * time.Second
 	slotsPerEpoch := uint64(32)
 	epochsPerSyncCommitteePeriod := uint64(256)
-	mockGenesisTimeProvider := mock.NewGenesisTimeProvider(genesisTime)
+	mockGenesisProvider := mock.NewGenesisProvider(genesisTime)
 	mockSpecProvider := mock.NewSpecProvider(slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod)
 	chainTime, err := standardchaintime.New(context.Background(),
 		standardchaintime.WithLogLevel(zerolog.Disabled),
-		standardchaintime.WithGenesisTimeProvider(mockGenesisTimeProvider),
+		standardchaintime.WithGenesisProvider(mockGenesisProvider),
 		standardchaintime.WithSpecProvider(mockSpecProvider),
 	)
 	require.NoError(t, err)

util/networks.go

@@ -1,4 +1,4 @@
-// Copyright © 2020 Weald Technology Trading
+// Copyright © 2020 - 2023 Weald Technology Trading.
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -15,9 +15,10 @@ package util
 
 import (
 	"context"
-	"fmt"
+	"encoding/hex"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/pkg/errors"
 )
 
@@ -28,6 +29,8 @@ var networks = map[string]string{
 	"8c5fecdc472e27bc447696f431e425d02dd46a8c": "Pyrmont",
 	"ff50ed3d0ec03ac01d4c79aad74928bff48a7b2b": "Prater",
 	"6f22ffbc56eff051aecf839396dd1ed9ad6bba9d": "Ropsten",
+	"7f02c3e3c98b133055b8b348b2ac625669ed295d": "Sepolia",
+	"4242424242424242424242424242424242424242": "Holesky",
 }
 
 // Network returns the name of the network., calculated from the deposit contract information.
@@ -43,14 +46,11 @@ func Network(ctx context.Context, eth2Client eth2client.Service) (string, error)
 	if !isProvider {
 		return "", errors.New("client does not provide deposit contract address")
 	}
-	config, err := provider.Spec(ctx)
+	specResponse, err := provider.Spec(ctx, &api.SpecOpts{})
 	if err != nil {
 		return "", errors.Wrap(err, "failed to obtain chain specification")
 	}
-	if config == nil {
-		return "", errors.New("failed to return chain specification")
-	}
-	depositContractAddress, exists := config["DEPOSIT_CONTRACT_ADDRESS"]
+	depositContractAddress, exists := specResponse.Data["DEPOSIT_CONTRACT_ADDRESS"]
 	if exists {
 		address = depositContractAddress.([]byte)
 	}
@@ -60,7 +60,7 @@ func Network(ctx context.Context, eth2Client eth2client.Service) (string, error)
 
 // network returns a network given an Ethereum 1 contract address.
 func network(address []byte) string {
-	if network, exists := networks[fmt.Sprintf("%x", address)]; exists {
+	if network, exists := networks[hex.EncodeToString(address)]; exists {
 		return network
 	}
 	return "Unknown"

util/networks_test.go

@@ -18,6 +18,7 @@ import (
 	"testing"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/stretchr/testify/require"
 	"github.com/wealdtech/ethdo/testutil"
 	"github.com/wealdtech/ethdo/util"
@@ -39,9 +40,12 @@ func (c *specETH2Client) Address() string {
 }
 
 // Spec provides the spec information of the chain.
-func (c *specETH2Client) Spec(ctx context.Context) (map[string]interface{}, error) {
-	return map[string]interface{}{
-		"DEPOSIT_CONTRACT_ADDRESS": c.address,
+func (c *specETH2Client) Spec(ctx context.Context, _ *api.SpecOpts) (*api.Response[map[string]any], error) {
+	return &api.Response[map[string]any]{
+		Data: map[string]any{
+			"DEPOSIT_CONTRACT_ADDRESS": c.address,
+		},
+		Metadata: make(map[string]any),
 	}, nil
 }
 

util/slot.go

@@ -0,0 +1,49 @@
+// 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 util
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/services/chaintime"
+)
+
+// ParseSlot parses input to calculate the desired slot.
+func ParseSlot(_ context.Context, chainTime chaintime.Service, slotStr string) (phase0.Slot, error) {
+	currentSlot := chainTime.CurrentSlot()
+	switch slotStr {
+	case "", "current", "head", "-0":
+		return currentSlot, nil
+	case "last":
+		if currentSlot > 0 {
+			currentSlot--
+		}
+		return currentSlot, nil
+	default:
+		val, err := strconv.ParseInt(slotStr, 10, 64)
+		if err != nil {
+			return 0, errors.Wrap(err, "failed to parse slot")
+		}
+		if val >= 0 {
+			return phase0.Slot(val), nil
+		}
+		if phase0.Slot(-val) > currentSlot {
+			return 0, nil
+		}
+		return currentSlot + phase0.Slot(val), nil
+	}
+}

util/slot_test.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 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 TestParseSlot(t *testing.T) {
+	ctx := context.Background()
+
+	// genesis is 1 day ago.
+	genesisTime := time.Now().AddDate(0, 0, -1)
+	slotDuration := 12 * time.Second
+	slotsPerSlot := uint64(32)
+	epochsPerSyncCommitteePeriod := uint64(256)
+	mockGenesisProvider := mock.NewGenesisProvider(genesisTime)
+	mockSpecProvider := mock.NewSpecProvider(slotDuration, slotsPerSlot, epochsPerSyncCommitteePeriod)
+	chainTime, err := standardchaintime.New(context.Background(),
+		standardchaintime.WithLogLevel(zerolog.Disabled),
+		standardchaintime.WithGenesisProvider(mockGenesisProvider),
+		standardchaintime.WithSpecProvider(mockSpecProvider),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name     string
+		input    string
+		err      string
+		expected phase0.Slot
+	}{
+		{
+			name:     "Genesis",
+			input:    "0",
+			expected: 0,
+		},
+		{
+			name:  "Invalid",
+			input: "invalid",
+			err:   `failed to parse slot: strconv.ParseInt: parsing "invalid": invalid syntax`,
+		},
+		{
+			name:     "Absolute",
+			input:    "15",
+			expected: 15,
+		},
+		{
+			name:     "Current",
+			input:    "current",
+			expected: 7200,
+		},
+		{
+			name:     "Last",
+			input:    "last",
+			expected: 7199,
+		},
+		{
+			name:     "RelativeZero",
+			input:    "-0",
+			expected: 7200,
+		},
+		{
+			name:     "Relative",
+			input:    "-5",
+			expected: 7195,
+		},
+		{
+			name:     "RelativeFar",
+			input:    "-50000",
+			expected: 0,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			slot, err := util.ParseSlot(ctx, chainTime, test.input)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.expected, slot)
+			}
+		})
+	}
+}

util/validator.go

@@ -22,6 +22,7 @@ import (
 	"time"
 
 	consensusclient "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
@@ -67,12 +68,15 @@ func accountToIndex(ctx context.Context, account e2wtypes.Account, client consen
 
 	pubKeys := make([]phase0.BLSPubKey, 1)
 	copy(pubKeys[0][:], pubKey.Marshal())
-	validators, err := client.(consensusclient.ValidatorsProvider).ValidatorsByPubKey(ctx, "head", pubKeys)
+	validatorsResponse, err := client.(consensusclient.ValidatorsProvider).Validators(ctx, &api.ValidatorsOpts{
+		State:   "head",
+		PubKeys: pubKeys,
+	})
 	if err != nil {
 		return 0, err
 	}
 
-	for index := range validators {
+	for index := range validatorsResponse.Data {
 		return index, nil
 	}
 	return 0, errors.New("validator not found")

util/validators.go

@@ -20,6 +20,7 @@ import (
 	"strings"
 
 	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
 	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
@@ -28,6 +29,7 @@ import (
 // ParseValidators parses input to obtain the list of validators.
 func ParseValidators(ctx context.Context, validatorsProvider eth2client.ValidatorsProvider, validatorsStr []string, stateID string) ([]*apiv1.Validator, error) {
 	validators := make([]*apiv1.Validator, 0, len(validatorsStr))
+	indices := make([]phase0.ValidatorIndex, 0)
 	for i := range validatorsStr {
 		if strings.Contains(validatorsStr[i], "-") {
 			// Range.
@@ -43,25 +45,25 @@ func ParseValidators(ctx context.Context, validatorsProvider eth2client.Validato
 			if err != nil {
 				return nil, errors.Wrap(err, "invalid range end")
 			}
-			indices := make([]phase0.ValidatorIndex, 0)
 			for index := low; index <= high; index++ {
 				indices = append(indices, phase0.ValidatorIndex(index))
 			}
-			rangeValidators, err := validatorsProvider.Validators(ctx, stateID, indices)
-			if err != nil {
-				return nil, errors.Wrap(err, fmt.Sprintf("failed to obtain validators %s", validatorsStr[i]))
-			}
-			for _, validator := range rangeValidators {
-				validators = append(validators, validator)
-			}
 		} else {
-			validator, err := ParseValidator(ctx, validatorsProvider, validatorsStr[i], stateID)
+			index, err := strconv.ParseUint(validatorsStr[i], 10, 64)
 			if err != nil {
-				return nil, errors.Wrap(err, fmt.Sprintf("unknown validator %s", validatorsStr[i]))
+				return nil, errors.Wrapf(err, "failed to parse validator %s", validatorsStr[i])
 			}
-			validators = append(validators, validator)
+			indices = append(indices, phase0.ValidatorIndex(index))
 		}
 	}
+
+	response, err := validatorsProvider.Validators(ctx, &api.ValidatorsOpts{State: stateID, Indices: indices})
+	if err != nil {
+		return nil, errors.Wrap(err, fmt.Sprintf("failed to obtain validators %v", indices))
+	}
+	for _, validator := range response.Data {
+		validators = append(validators, validator)
+	}
 	return validators, nil
 }
 
@@ -79,10 +81,14 @@ func ParseValidator(ctx context.Context,
 	// Could be a simple index.
 	index, err := strconv.ParseUint(validatorStr, 10, 64)
 	if err == nil {
-		validators, err = validatorsProvider.Validators(ctx, stateID, []phase0.ValidatorIndex{phase0.ValidatorIndex(index)})
+		response, err := validatorsProvider.Validators(ctx, &api.ValidatorsOpts{
+			State:   stateID,
+			Indices: []phase0.ValidatorIndex{phase0.ValidatorIndex(index)},
+		})
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to obtain validator information")
 		}
+		validators = response.Data
 	} else {
 		// Some sort of specifier.
 		account, err := ParseAccount(ctx, validatorStr, nil, false)
@@ -96,13 +102,14 @@ func ParseValidator(ctx context.Context,
 		}
 		pubKey := phase0.BLSPubKey{}
 		copy(pubKey[:], accPubKey.Marshal())
-		validators, err = validatorsProvider.ValidatorsByPubKey(ctx,
-			stateID,
-			[]phase0.BLSPubKey{pubKey},
-		)
+		validatorsResponse, err := validatorsProvider.Validators(ctx, &api.ValidatorsOpts{
+			State:   stateID,
+			PubKeys: []phase0.BLSPubKey{pubKey},
+		})
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to obtain validator information")
 		}
+		validators = validatorsResponse.Data
 	}
 
 	// Validator is first and only entry in the map.