Update dependencies.

CHANGELOG.md

@@ -1,3 +1,6 @@
+1.34.0:
+  - update dependencies
+
 1.33.2:
   - fix windows build
 

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"
@@ -57,7 +58,7 @@ 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),
@@ -241,12 +242,12 @@ func ObtainChainInfoFromNode(ctx context.Context,
 	}
 
 	// 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 +257,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)
 	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)
 	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")
 	}
@@ -278,23 +279,23 @@ func ObtainChainInfoFromNode(ctx context.Context,
 	}
 
 	// Fetch the current fork version from the fork schedule.
-	forkSchedule, err := consensusClient.(consensusclient.ForkScheduleProvider).ForkSchedule(ctx)
+	forkScheduleResponse, err := consensusClient.(consensusclient.ForkScheduleProvider).ForkSchedule(ctx)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain fork schedule")
 	}
-	for i := range forkSchedule {
-		if forkSchedule[i].Epoch <= res.Epoch {
-			res.CurrentForkVersion = forkSchedule[i].CurrentVersion
+	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/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/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

@@ -19,7 +19,8 @@ import (
 	"fmt"
 
 	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"
@@ -61,14 +62,17 @@ 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 {
 			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 +82,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,52 +125,60 @@ 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 {
 			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
 		}
-		return bytes.Equal(header.Root[:], attestation.Data.BeaconBlockRoot[:]), nil
+		return bytes.Equal(response.Data.Root[:], attestation.Data.BeaconBlockRoot[:]), nil
 	}
 }
 
 func calcTargetCorrect(ctx context.Context, data *dataIn, attestation *phase0.Attestation) (bool, error) {
 	// Start with first slot of the target epoch.
 	slot := data.chainTime.FirstSlotOfEpoch(attestation.Data.Target.Epoch)
 	for {
-		header, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+		response, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
+			Block: fmt.Sprintf("%d", slot),
+		})
 		if err != 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
 		}
-		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/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 ")