Auto correct the IP if the operator set their IP to localhost when opt-in

core/state.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"math/big"
+	"strings"
 )
 
 // Operators
@@ -18,6 +19,26 @@ func MakeOperatorSocket(nodeIP, dispersalPort, retrievalPort string) OperatorSoc
 	return OperatorSocket(fmt.Sprintf("%s:%s;%s", nodeIP, dispersalPort, retrievalPort))
 }
 
+func ParseOperatorSocket(operatorSocket string) (socket string, dispersalPort string, retrievalPort string, err error) {
+	s := strings.Split(operatorSocket, ":")
+	if len(s) != 2 {
+		err = fmt.Errorf("invalid socket address format: %s", operatorSocket)
+		return
+	}
+	hostname := s[0]
+	dispersalPort = s[1]
+
+	s = strings.Split(operatorSocket, ";")
+	if len(s) != 2 {
+		err = fmt.Errorf("invalid socket address format, missing retrieval port: %s", operatorSocket)
+		return
+	}
+	retrievalPort = s[1]
+
+	socket = string(MakeOperatorSocket(hostname, dispersalPort, retrievalPort))
+	return
+}
+
 type StakeAmount *big.Int
 
 // OperatorInfo contains information about an operator which is stored on the blockchain state,

node/node.go

@@ -375,7 +375,7 @@ func (n *Node) checkCurrentNodeIp(ctx context.Context) {
 		case <-ctx.Done():
 			return
 		case <-t.C:
-			newSocketAddr, err := n.socketAddress(ctx)
+			newSocketAddr, err := SocketAddress(ctx, n.PubIPProvider, n.Config.DispersalPort, n.Config.RetrievalPort)
 			if err != nil {
 				n.Logger.Error("failed to get socket address", "err", err)
 				continue
@@ -385,15 +385,6 @@ func (n *Node) checkCurrentNodeIp(ctx context.Context) {
 	}
 }
 
-func (n *Node) socketAddress(ctx context.Context) (string, error) {
-	ip, err := n.PubIPProvider.PublicIPAddress(ctx)
-	if err != nil {
-		return "", fmt.Errorf("failed to get public ip address from IP provider: %w", err)
-	}
-	socket := core.MakeOperatorSocket(ip, n.Config.DispersalPort, n.Config.RetrievalPort)
-	return socket.String(), nil
-}
-
 // we only need to build the sdk clients for eigenmetrics right now,
 // but we might eventually want to move as much as possible to the sdk
 func buildSdkClients(config *Config, logger common.Logger) (*constructor.Clients, error) {

node/plugin/cmd/main.go

@@ -5,10 +5,12 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"strings"
 	"time"
 
 	"github.com/Layr-Labs/eigenda/common/geth"
 	"github.com/Layr-Labs/eigenda/common/logging"
+	"github.com/Layr-Labs/eigenda/common/pubip"
 	"github.com/Layr-Labs/eigenda/core"
 	"github.com/Layr-Labs/eigenda/core/eth"
 	"github.com/Layr-Labs/eigenda/node"
@@ -114,8 +116,23 @@ func pluginOps(ctx *cli.Context) {
 		return
 	}
 
+	socket, dispersalPort, retrievalPort, err := core.ParseOperatorSocket(config.Socket)
+	if err != nil {
+		log.Printf("Error: failed to parse operator socket: %v", err)
+		return
+	}
+
+	if isLocalhost(socket) {
+		pubIPProvider := pubip.ProviderOrDefault(config.PubIPProvider)
+		socket, err = node.SocketAddress(context.Background(), pubIPProvider, dispersalPort, retrievalPort)
+		if err != nil {
+			log.Printf("Error: failed to get socket address from ip provider: %v", err)
+			return
+		}
+	}
+
 	operator := &node.Operator{
-		Socket:     config.Socket,
+		Socket:     socket,
 		Timeout:    10 * time.Second,
 		KeyPair:    keyPair,
 		OperatorId: keyPair.GetPubKeyG1().GetOperatorID(),
@@ -141,3 +158,7 @@ func pluginOps(ctx *cli.Context) {
 		log.Fatalf("Fatal: unsupported operation: %s", config.Operation)
 	}
 }
+
+func isLocalhost(socket string) bool {
+	return strings.Contains(socket, "localhost") || strings.Contains(socket, "127.0.0.1") || strings.Contains(socket, "0.0.0.0")
+}

node/plugin/config.go

@@ -14,6 +14,13 @@ import (
 var (
 	/* Required Flags */
 
+	PubIPProviderFlag = cli.StringFlag{
+		Name:     "public-ip-provider",
+		Usage:    "The ip provider service used to obtain a operator's public IP [seeip (default), ipify)",
+		Required: true,
+		EnvVar:   common.PrefixEnvVar(flags.EnvVarPrefix, "PUBLIC_IP_PROVIDER"),
+	}
+
 	// The operation to run.
 	OperationFlag = cli.StringFlag{
 		Name:     "operation",
@@ -99,6 +106,7 @@ var (
 )
 
 type Config struct {
+	PubIPProvider                 string
 	Operation                     string
 	EcdsaKeyFile                  string
 	BlsKeyFile                    string
@@ -130,6 +138,7 @@ func NewConfig(ctx *cli.Context) (*Config, error) {
 	}
 
 	return &Config{
+		PubIPProvider:                 ctx.GlobalString(PubIPProviderFlag.Name),
 		Operation:                     op,
 		EcdsaKeyPassword:              ctx.GlobalString(EcdsaKeyPasswordFlag.Name),
 		BlsKeyPassword:                ctx.GlobalString(BlsKeyPasswordFlag.Name),

node/utils.go

@@ -2,9 +2,12 @@ package node
 
 import (
 	"bytes"
+	"context"
 	"encoding/binary"
 	"errors"
+	"fmt"
 
+	"github.com/Layr-Labs/eigenda/common/pubip"
 	"github.com/Layr-Labs/eigenda/core"
 )
 
@@ -80,3 +83,12 @@ func DecodeBatchExpirationKey(key []byte) (int64, error) {
 	ts := int64(binary.BigEndian.Uint64(key[len(key)-8:]))
 	return ts, nil
 }
+
+func SocketAddress(ctx context.Context, provider pubip.Provider, dispersalPort string, retrievalPort string) (string, error) {
+	ip, err := provider.PublicIPAddress(ctx)
+	if err != nil {
+		return "", fmt.Errorf("failed to get public ip address from IP provider: %w", err)
+	}
+	socket := core.MakeOperatorSocket(ip, dispersalPort, retrievalPort)
+	return socket.String(), nil
+}