add node identity

Author: DiogoSantoss

api/nodeidentityopts.go

@@ -0,0 +1,6 @@
+package api
+
+// NodeIdentityOpts are the options for obtaining the node identity.
+type NodeIdentityOpts struct {
+	Common CommonOpts
+}

api/v1/identity.go

@@ -0,0 +1,62 @@
+package v1
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/pkg/errors"
+)
+
+// NodeIdentity contains the node identity information.
+type NodeIdentity struct {
+	PeerID              string            `json:"peer_id"`
+	Enr                 string            `json:"enr"`
+	P2PAddresses        []string          `json:"p2p_addresses"`
+	DiscoveryAddresses  []string          `json:"discovery_addresses"`
+	Metadata            map[string]string `json:"metadata"`
+}
+
+type nodeIdentityJSON struct {
+	PeerID              string            `json:"peer_id"`
+	Enr                 string            `json:"enr"`
+	P2PAddresses        []string          `json:"p2p_addresses"`
+	DiscoveryAddresses  []string          `json:"discovery_addresses"`
+	Metadata            map[string]string `json:"metadata"`
+}
+
+// MarshalJSON implements json.Marshaler.
+func (n *NodeIdentity) MarshalJSON() ([]byte, error) {
+	return json.Marshal(&nodeIdentityJSON{
+		PeerID:             n.PeerID,
+		Enr:                n.Enr,
+		P2PAddresses:       n.P2PAddresses,
+		DiscoveryAddresses: n.DiscoveryAddresses,
+		Metadata:           n.Metadata,
+	})
+}
+
+// UnmarshalJSON implements json.Unmarshaler.
+func (n *NodeIdentity) UnmarshalJSON(input []byte) error {
+	var nodeIdentityJSON nodeIdentityJSON
+
+	if err := json.Unmarshal(input, &nodeIdentityJSON); err != nil {
+		return errors.Wrap(err, "invalid JSON")
+	}
+
+	n.PeerID = nodeIdentityJSON.PeerID
+	n.Enr = nodeIdentityJSON.Enr
+	n.P2PAddresses = nodeIdentityJSON.P2PAddresses
+	n.DiscoveryAddresses = nodeIdentityJSON.DiscoveryAddresses
+	n.Metadata = nodeIdentityJSON.Metadata
+
+	return nil
+}
+
+func (n *NodeIdentity) String() string {
+	data, err := json.Marshal(n)
+	if err != nil {
+		return fmt.Sprintf("ERR: %v", err)
+	}
+
+	return string(data)
+}

http/nodeidentity.go

@@ -0,0 +1,46 @@
+package http
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
+)
+
+// NodeIdentity provides the identity information of the node.
+func (s *Service) NodeIdentity(ctx context.Context,
+	opts *api.NodeIdentityOpts,
+) (
+	*api.Response[*apiv1.NodeIdentity],
+	error,
+) {
+	if err := s.assertIsActive(ctx); err != nil {
+		return nil, err
+	}
+	if opts == nil {
+		return nil, client.ErrNoOptions
+	}
+
+	endpoint := "/eth/v1/node/identity"
+	httpResponse, err := s.get(ctx, endpoint, "", &opts.Common, false)
+	if err != nil {
+		return nil, err
+	}
+
+	if httpResponse.contentType != ContentTypeJSON {
+		return nil, fmt.Errorf("unexpected content type %v (expected JSON)", httpResponse.contentType)
+	}
+
+	data, metadata, err := decodeJSONResponse(bytes.NewReader(httpResponse.body), &apiv1.NodeIdentity{})
+	if err != nil {
+		return nil, err
+	}
+
+	return &api.Response[*apiv1.NodeIdentity]{
+		Data:     data,
+		Metadata: metadata,
+	}, nil
+}

mock/nodeidentity.go

@@ -0,0 +1,33 @@
+package mock
+
+import (
+	"context"
+
+	"github.com/attestantio/go-eth2-client/api"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
+)
+
+// NodeIdentity provides the identity information of the node.
+func (s *Service) NodeIdentity(ctx context.Context,
+	opts *api.NodeIdentityOpts,
+) (
+	*api.Response[*apiv1.NodeIdentity],
+	error,
+) {
+	if s.NodeIdentityFunc != nil {
+		return s.NodeIdentityFunc(ctx, opts)
+	}
+
+	return &api.Response[*apiv1.NodeIdentity]{
+		Data: &apiv1.NodeIdentity{
+			PeerID:             "16Uiu2HAmMockPeerID",
+			Enr:                "enr:-mock-enr-value",
+			P2PAddresses:       []string{"/ip4/127.0.0.1/tcp/9000"},
+			DiscoveryAddresses: []string{"/ip4/127.0.0.1/udp/9000"},
+			Metadata: map[string]string{
+				"seq_number": "1",
+				"attnets":    "0xffffffffffffffff",
+			},
+		},
+	}, nil
+}

mock/service.go

@@ -68,6 +68,7 @@ type Service struct {
 	ForkFunc                      func(context.Context, *api.ForkOpts) (*api.Response[*phase0.Fork], error)
 	ForkScheduleFunc              func(context.Context, *api.ForkScheduleOpts) (*api.Response[[]*phase0.Fork], error)
 	GenesisFunc                   func(context.Context, *api.GenesisOpts) (*api.Response[*apiv1.Genesis], error)
+	NodeIdentityFunc              func(context.Context, *api.NodeIdentityOpts) (*api.Response[*apiv1.NodeIdentity], error)
 	NodePeersFunc                 func(context.Context, *api.NodePeersOpts) (*api.Response[[]*apiv1.Peer], error)
 	NodePeerCountFunc             func(context.Context, *api.NodePeerCountOpts) (*api.Response[*apiv1.PeerCount], error)
 	NodeSyncingFunc               func(context.Context, *api.NodeSyncingOpts) (*api.Response[*apiv1.SyncState], error)

multi/nodeidentity.go

@@ -0,0 +1,31 @@
+package multi
+
+import (
+	"context"
+
+	consensusclient "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/api"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
+)
+
+// NodeIdentity provides the identity information of the node.
+func (s *Service) NodeIdentity(ctx context.Context, opts *api.NodeIdentityOpts) (*api.Response[*apiv1.NodeIdentity], error) {
+	res, err := s.doCall(ctx, func(ctx context.Context, client consensusclient.Service) (any, error) {
+		nodeIdentity, err := client.(consensusclient.NodeIdentityProvider).NodeIdentity(ctx, opts)
+		if err != nil {
+			return nil, err
+		}
+
+		return nodeIdentity, nil
+	}, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	response, isResponse := res.(*api.Response[*apiv1.NodeIdentity])
+	if !isResponse {
+		return nil, ErrIncorrectType
+	}
+
+	return response, nil
+}

service.go

@@ -526,7 +526,16 @@ type GenesisProvider interface {
 		error,
 	)
 }
-
+// NodeIdentityProvider is the interface for providing node identity information.
+type NodeIdentityProvider interface {
+	// NodeIdentity provides the identity information of the node.
+	NodeIdentity(ctx context.Context,
+		opts *api.NodeIdentityOpts,
+	) (
+		*api.Response[*apiv1.NodeIdentity],
+		error,
+	)
+}
 // NodePeersProvider is the interface for providing peer information.
 type NodePeersProvider interface {
 	// NodePeers provides the peers of the node.

testclients/erroring.go

@@ -126,6 +126,24 @@ func (s *Erroring) SlotFromStateID(ctx context.Context, stateID string) (phase0.
 	return next.SlotFromStateID(ctx, stateID)
 }
 
+// NodeIdentity provides the identity information of the node.
+func (s *Erroring) NodeIdentity(ctx context.Context,
+	opts *api.NodeIdentityOpts,
+) (
+	*api.Response[*apiv1.NodeIdentity],
+	error,
+) {
+	if err := s.maybeError(ctx); err != nil {
+		return nil, err
+	}
+	next, isNext := s.next.(consensusclient.NodeIdentityProvider)
+	if !isNext {
+		return nil, fmt.Errorf("%s@%s does not support this call", s.next.Name(), s.next.Address())
+	}
+
+	return next.NodeIdentity(ctx, opts)
+}
+
 // NodeVersion returns a free-text string with the node version.
 func (s *Erroring) NodeVersion(ctx context.Context,
 	opts *api.NodeVersionOpts,

testclients/sleepy.go

@@ -119,6 +119,22 @@ func (s *Sleepy) SlotFromStateID(ctx context.Context, stateID string) (phase0.Sl
 	return next.SlotFromStateID(ctx, stateID)
 }
 
+// NodeIdentity provides the identity information of the node.
+func (s *Sleepy) NodeIdentity(ctx context.Context,
+	opts *api.NodeIdentityOpts,
+) (
+	*api.Response[*apiv1.NodeIdentity],
+	error,
+) {
+	s.sleep(ctx)
+	next, isNext := s.next.(consensusclient.NodeIdentityProvider)
+	if !isNext {
+		return nil, errors.New("next does not support this call")
+	}
+
+	return next.NodeIdentity(ctx, opts)
+}
+
 // NodeVersion returns a free-text string with the node version.
 func (s *Sleepy) NodeVersion(ctx context.Context,
 	opts *api.NodeVersionOpts,