From ef0a4979647a6bd4319338d33afb09799c75015e Mon Sep 17 00:00:00 2001
From: Ryan <ryanford@poluglottos.com>
Date: Thu, 1 Feb 2024 10:04:30 +0100
Subject: [PATCH 01/16] feat: separating core.ip into core.grpc.ip and
 core.rpc.ip

---
 nodebuilder/core/config.go        | 21 +++++---
 nodebuilder/core/constructors.go  |  2 +-
 nodebuilder/core/flags.go         | 86 ++++++++++++++++++++++---------
 nodebuilder/state/core.go         |  2 +-
 nodebuilder/tests/helpers_test.go |  6 +--
 nodebuilder/tests/swamp/swamp.go  |  3 +-
 state/core_access.go              | 13 +++--
 state/core_access_test.go         |  3 +-
 state/integration_test.go         |  2 +-
 9 files changed, 96 insertions(+), 42 deletions(-)

diff --git a/nodebuilder/core/config.go b/nodebuilder/core/config.go
index bb5eea5b83..f813f3a2c4 100644
--- a/nodebuilder/core/config.go
+++ b/nodebuilder/core/config.go
@@ -11,7 +11,8 @@ var MetricsEnabled bool
 
 // Config combines all configuration fields for managing the relationship with a Core node.
 type Config struct {
-	IP       string
+	RPCIP    string
+	GRPCIP   string
 	RPCPort  string
 	GRPCPort string
 }
@@ -20,7 +21,8 @@ type Config struct {
 // node's connection to a Celestia-Core endpoint.
 func DefaultConfig() Config {
 	return Config{
-		IP:       "",
+		RPCIP:    "",
+		GRPCIP:   "",
 		RPCPort:  "26657",
 		GRPCPort: "9090",
 	}
@@ -32,11 +34,18 @@ func (cfg *Config) Validate() error {
 		return nil
 	}
 
-	ip, err := utils.ValidateAddr(cfg.IP)
+	rpcIP, err := utils.ValidateAddr(cfg.RPCIP)
 	if err != nil {
-		return err
+		return fmt.Errorf("nodebuilder/core: invalid rpc ip: %s", err.Error())
 	}
-	cfg.IP = ip
+	cfg.RPCIP = rpcIP
+
+	grpcIP, err := utils.ValidateAddr(cfg.GRPCIP)
+	if err != nil {
+		return fmt.Errorf("nodebuilder/core: invalid grpc ip: %s", err.Error())
+	}
+	cfg.GRPCIP = grpcIP
+
 	_, err = strconv.Atoi(cfg.RPCPort)
 	if err != nil {
 		return fmt.Errorf("nodebuilder/core: invalid rpc port: %s", err.Error())
@@ -51,5 +60,5 @@ func (cfg *Config) Validate() error {
 // IsEndpointConfigured returns whether a core endpoint has been set
 // on the config (true if set).
 func (cfg *Config) IsEndpointConfigured() bool {
-	return cfg.IP != ""
+	return cfg.RPCIP != "" && cfg.GRPCIP != ""
 }
diff --git a/nodebuilder/core/constructors.go b/nodebuilder/core/constructors.go
index 53c914a041..189a18c3f8 100644
--- a/nodebuilder/core/constructors.go
+++ b/nodebuilder/core/constructors.go
@@ -5,5 +5,5 @@ import (
 )
 
 func remote(cfg Config) (core.Client, error) {
-	return core.NewRemote(cfg.IP, cfg.RPCPort)
+	return core.NewRemote(cfg.RPCIP, cfg.RPCPort)
 }
diff --git a/nodebuilder/core/flags.go b/nodebuilder/core/flags.go
index 9cbed9b277..41d3c8426e 100644
--- a/nodebuilder/core/flags.go
+++ b/nodebuilder/core/flags.go
@@ -8,9 +8,11 @@ import (
 )
 
 var (
-	coreFlag     = "core.ip"
-	coreRPCFlag  = "core.rpc.port"
-	coreGRPCFlag = "core.grpc.port"
+	ipFlag       = "core.ip"
+	rpcIPFlag    = "core.rpc.ip"
+	grpcIPFlag   = "core.grpc.ip"
+	rpcPortFlag  = "core.rpc.port"
+	grpcPortFlag = "core.grpc.port"
 )
 
 // Flags gives a set of hardcoded Core flags.
@@ -18,43 +20,81 @@ func Flags() *flag.FlagSet {
 	flags := &flag.FlagSet{}
 
 	flags.String(
-		coreFlag,
+		ipFlag,
 		"",
-		"Indicates node to connect to the given core node. "+
+		"Indicates node to connect to the given core node's RPC and gRPC. "+
+			"NOTE: If this flag is set, the core.rpc.ip and core.grpc.ip flags cannot be set. "+
 			"Example: <ip>, 127.0.0.1. <dns>, subdomain.domain.tld "+
 			"Assumes RPC port 26657 and gRPC port 9090 as default unless otherwise specified.",
 	)
 	flags.String(
-		coreRPCFlag,
+		rpcIPFlag,
+		"",
+		"Indicates node to connect to the given core node's RPC. "+
+			"NOTE: If this flag is set, the core.ip flag cannot be set. "+
+			"Example: <ip>, 127.0.0.1. <dns>, subdomain.domain.tld "+
+			"Assumes RPC port 26657 and gRPC port 9090 as default unless otherwise specified.",
+	)
+	flags.String(
+		grpcIPFlag,
+		"",
+		"Indicates node to connect to the given core node's gRPC. "+
+			"NOTE: If this flag is set, the core.ip flag cannot be set. "+
+			"Example: <ip>, 127.0.0.1. <dns>, subdomain.domain.tld "+
+			"Assumes RPC port 26657 and gRPC port 9090 as default unless otherwise specified.",
+	)
+	flags.String(
+		rpcPortFlag,
 		"26657",
-		"Set a custom RPC port for the core node connection. The --core.ip flag must also be provided.",
+		"Set a custom RPC port for the core node connection. The --core.rpc.ip or --core.ip flag must also be provided.",
 	)
 	flags.String(
-		coreGRPCFlag,
+		grpcPortFlag,
 		"9090",
-		"Set a custom gRPC port for the core node connection. The --core.ip flag must also be provided.",
+		"Set a custom gRPC port for the core node connection. The --core.grpc.ip or --core.ip flag must also be provided.",
 	)
 	return flags
 }
 
 // ParseFlags parses Core flags from the given cmd and saves them to the passed config.
-func ParseFlags(
-	cmd *cobra.Command,
-	cfg *Config,
-) error {
-	coreIP := cmd.Flag(coreFlag).Value.String()
-	if coreIP == "" {
-		if cmd.Flag(coreGRPCFlag).Changed || cmd.Flag(coreRPCFlag).Changed {
-			return fmt.Errorf("cannot specify RPC/gRPC ports without specifying an IP address for --core.ip")
+func ParseFlags(cmd *cobra.Command, cfg *Config) error {
+	coreIP := cmd.Flag(ipFlag).Value.String()
+	coreRPCIP, coreGRPCIP := cmd.Flag(rpcIPFlag).Value.String(), cmd.Flag(grpcIPFlag).Value.String()
+
+	// Check if core.ip is specified along with core.rpc.ip or core.grpc.ip
+	if coreIP != "" && (cmd.Flag(rpcIPFlag).Changed || cmd.Flag(grpcIPFlag).Changed) {
+		return fmt.Errorf("cannot specify core.ip and core.rpc.ip or core.grpc.ip flags together")
+	}
+
+	// Validate IP addresses and port settings
+	if coreIP == "" { // No core.ip specified
+		if coreRPCIP == "" {
+			if cmd.Flag(rpcPortFlag).Changed {
+				return fmt.Errorf("cannot specify RPC ports without specifying an IP address for --core.rpc.ip")
+			}
+			if cmd.Flag(grpcIPFlag).Changed {
+				return fmt.Errorf("setting gRPC IP requires also specifying an RPC IP. If they are identical use --core.ip instead")
+			}
+		}
+		if coreGRPCIP == "" {
+			if cmd.Flag(grpcPortFlag).Changed {
+				return fmt.Errorf("cannot specify gRPC ports without specifying an IP address for --core.grpc.ip")
+			}
+			if cmd.Flag(rpcIPFlag).Changed {
+				return fmt.Errorf("setting RPC IP requires also specifying a gRPC IP. If they are identical use --core.ip instead")
+			}
 		}
-		return nil
 	}
 
-	rpc := cmd.Flag(coreRPCFlag).Value.String()
-	grpc := cmd.Flag(coreGRPCFlag).Value.String()
+	// Assign IP addresses
+	if coreIP != "" {
+		cfg.RPCIP, cfg.GRPCIP = coreIP, coreIP
+	} else {
+		cfg.RPCIP, cfg.GRPCIP = coreRPCIP, coreGRPCIP
+	}
+
+	// Assign ports
+	cfg.RPCPort, cfg.GRPCPort = cmd.Flag(rpcPortFlag).Value.String(), cmd.Flag(grpcPortFlag).Value.String()
 
-	cfg.IP = coreIP
-	cfg.RPCPort = rpc
-	cfg.GRPCPort = grpc
 	return cfg.Validate()
 }
diff --git a/nodebuilder/state/core.go b/nodebuilder/state/core.go
index f8f8508540..06e16b8034 100644
--- a/nodebuilder/state/core.go
+++ b/nodebuilder/state/core.go
@@ -20,7 +20,7 @@ func coreAccessor(
 	sync *sync.Syncer[*header.ExtendedHeader],
 	fraudServ libfraud.Service[*header.ExtendedHeader],
 ) (*state.CoreAccessor, Module, *modfraud.ServiceBreaker[*state.CoreAccessor, *header.ExtendedHeader]) {
-	ca := state.NewCoreAccessor(signer, sync, corecfg.IP, corecfg.RPCPort, corecfg.GRPCPort)
+	ca := state.NewCoreAccessor(signer, sync, corecfg.RPCIP, corecfg.GRPCIP, corecfg.RPCPort, corecfg.GRPCPort)
 
 	return ca, ca, &modfraud.ServiceBreaker[*state.CoreAccessor, *header.ExtendedHeader]{
 		Service:   ca,
diff --git a/nodebuilder/tests/helpers_test.go b/nodebuilder/tests/helpers_test.go
index 1e7f14d823..978b66553d 100644
--- a/nodebuilder/tests/helpers_test.go
+++ b/nodebuilder/tests/helpers_test.go
@@ -6,12 +6,12 @@ import (
 	"testing"
 	"time"
 
+	"github.com/filecoin-project/go-jsonrpc/auth"
+	"github.com/stretchr/testify/require"
+
 	"github.com/celestiaorg/celestia-node/api/rpc/client"
 	"github.com/celestiaorg/celestia-node/libs/authtoken"
 	"github.com/celestiaorg/celestia-node/nodebuilder"
-
-	"github.com/filecoin-project/go-jsonrpc/auth"
-	"github.com/stretchr/testify/require"
 )
 
 func getAdminClient(ctx context.Context, nd *nodebuilder.Node, t *testing.T) *client.Client {
diff --git a/nodebuilder/tests/swamp/swamp.go b/nodebuilder/tests/swamp/swamp.go
index 9faf69744d..55bc62750f 100644
--- a/nodebuilder/tests/swamp/swamp.go
+++ b/nodebuilder/tests/swamp/swamp.go
@@ -196,7 +196,8 @@ func (s *Swamp) DefaultTestConfig(tp node.Type) *nodebuilder.Config {
 	ip, port, err := net.SplitHostPort(s.cfg.AppConfig.GRPC.Address)
 	require.NoError(s.t, err)
 
-	cfg.Core.IP = ip
+	cfg.Core.RPCIP = ip
+	cfg.Core.GRPCIP = ip
 	cfg.Core.GRPCPort = port
 	return cfg
 }
diff --git a/state/core_access.go b/state/core_access.go
index c3fbd4836a..bf662a056d 100644
--- a/state/core_access.go
+++ b/state/core_access.go
@@ -58,7 +58,8 @@ type CoreAccessor struct {
 	prt *merkle.ProofRuntime
 
 	coreConn *grpc.ClientConn
-	coreIP   string
+	rpcIP    string
+	grpcIP   string
 	rpcPort  string
 	grpcPort string
 
@@ -79,7 +80,8 @@ type CoreAccessor struct {
 func NewCoreAccessor(
 	signer *apptypes.KeyringSigner,
 	getter libhead.Head[*header.ExtendedHeader],
-	coreIP,
+	rpcIP,
+	grpcIP,
 	rpcPort string,
 	grpcPort string,
 ) *CoreAccessor {
@@ -90,7 +92,8 @@ func NewCoreAccessor(
 	return &CoreAccessor{
 		signer:   signer,
 		getter:   getter,
-		coreIP:   coreIP,
+		rpcIP:    rpcIP,
+		grpcIP:   grpcIP,
 		rpcPort:  rpcPort,
 		grpcPort: grpcPort,
 		prt:      prt,
@@ -104,7 +107,7 @@ func (ca *CoreAccessor) Start(ctx context.Context) error {
 	ca.ctx, ca.cancel = context.WithCancel(context.Background())
 
 	// dial given celestia-core endpoint
-	endpoint := fmt.Sprintf("%s:%s", ca.coreIP, ca.grpcPort)
+	endpoint := fmt.Sprintf("%s:%s", ca.grpcIP, ca.grpcPort)
 	client, err := grpc.DialContext(
 		ctx,
 		endpoint,
@@ -121,7 +124,7 @@ func (ca *CoreAccessor) Start(ctx context.Context) error {
 	stakingCli := stakingtypes.NewQueryClient(ca.coreConn)
 	ca.stakingCli = stakingCli
 	// create ABCI query client
-	cli, err := http.New(fmt.Sprintf("http://%s:%s", ca.coreIP, ca.rpcPort), "/websocket")
+	cli, err := http.New(fmt.Sprintf("http://%s:%s", ca.rpcIP, ca.rpcPort), "/websocket")
 	if err != nil {
 		return err
 	}
diff --git a/state/core_access_test.go b/state/core_access_test.go
index ad7b916ea3..829758fb55 100644
--- a/state/core_access_test.go
+++ b/state/core_access_test.go
@@ -37,7 +37,8 @@ func TestSubmitPayForBlob(t *testing.T) {
 	defer cancel()
 
 	signer := blobtypes.NewKeyringSigner(cctx.Keyring, accounts[0], cctx.ChainID)
-	ca := NewCoreAccessor(signer, nil, "127.0.0.1", extractPort(rpcAddr), extractPort(grpcAddr))
+	coreIP := "127.0.0.1"
+	ca := NewCoreAccessor(signer, nil, coreIP, coreIP, extractPort(rpcAddr), extractPort(grpcAddr))
 	// start the accessor
 	err := ca.Start(ctx)
 	require.NoError(t, err)
diff --git a/state/integration_test.go b/state/integration_test.go
index 193e7bddc7..5fd60c00f3 100644
--- a/state/integration_test.go
+++ b/state/integration_test.go
@@ -51,7 +51,7 @@ func (s *IntegrationTestSuite) SetupSuite() {
 	s.accounts = cfg.Accounts
 
 	signer := blobtypes.NewKeyringSigner(s.cctx.Keyring, s.accounts[0], s.cctx.ChainID)
-	accessor := NewCoreAccessor(signer, localHeader{s.cctx.Client}, "", "", "")
+	accessor := NewCoreAccessor(signer, localHeader{s.cctx.Client}, "", "", "", "")
 	setClients(accessor, s.cctx.GRPCClient, s.cctx.Client)
 	s.accessor = accessor
 

From ecf1ab0e45fce351e851cfa94651bb1395b2a08a Mon Sep 17 00:00:00 2001
From: ramin <raminkeene@gmail.com>
Date: Wed, 6 Mar 2024 12:12:51 +0000
Subject: [PATCH 02/16] enable setting grpc and rpc hosts separately, switch to
 using host terminology vs ip, allow setting/overriding scheme by passing in
 as part of host, allow (untested) setting of a grpc cert

---
 nodebuilder/core/config.go       | 114 ++++++++++++++++++----
 nodebuilder/core/config_test.go  | 159 +++++++++++++++++++++++++++++++
 nodebuilder/core/constructors.go |   2 +-
 nodebuilder/core/flags.go        |  85 +++++++----------
 nodebuilder/state/core.go        |  12 ++-
 nodebuilder/tests/swamp/swamp.go |   4 +-
 state/core_access.go             |  59 ++++++++----
 7 files changed, 341 insertions(+), 94 deletions(-)
 create mode 100644 nodebuilder/core/config_test.go

diff --git a/nodebuilder/core/config.go b/nodebuilder/core/config.go
index f813f3a2c4..4e0c549784 100644
--- a/nodebuilder/core/config.go
+++ b/nodebuilder/core/config.go
@@ -1,31 +1,86 @@
 package core
 
 import (
+	"errors"
 	"fmt"
+	"net/url"
+	"os"
 	"strconv"
+)
+
+var (
+	MetricsEnabled bool
 
-	"github.com/celestiaorg/celestia-node/libs/utils"
+	ErrMultipleHostsConfigured = errors.New("multiple hosts configured")
 )
 
-var MetricsEnabled bool
+const (
+	DefaultRPCScheme = "http"
+	DefaultRPCPort   = "26657"
+	DefaultGRPCPort  = "9090"
+)
 
-// Config combines all configuration fields for managing the relationship with a Core node.
+// Config combines all configuration fields for
+// managing the relationship with a Core node.
 type Config struct {
-	RPCIP    string
-	GRPCIP   string
-	RPCPort  string
-	GRPCPort string
+	IP   string
+	RPC  HostConfig
+	GRPC HostConfig
+}
+
+type HostConfig struct {
+	Scheme string
+	Host   string
+	Port   string
+	Cert   string
 }
 
 // DefaultConfig returns default configuration for managing the
 // node's connection to a Celestia-Core endpoint.
 func DefaultConfig() Config {
 	return Config{
-		RPCIP:    "",
-		GRPCIP:   "",
-		RPCPort:  "26657",
-		GRPCPort: "9090",
+		IP: "",
+		RPC: HostConfig{
+			Scheme: DefaultRPCScheme,
+			Port:   DefaultRPCPort,
+		},
+		GRPC: HostConfig{
+			Scheme: DefaultRPCScheme,
+			Port:   DefaultGRPCPort,
+		},
+	}
+}
+
+func (cfg *Config) RPCHost() string {
+	if cfg.RPC.Host != "" {
+		return cfg.RPC.Host
+	}
+	return cfg.IP
+}
+
+func (cfg *Config) GRPCHost() string {
+	if cfg.GRPC.Host != "" {
+		return cfg.GRPC.Host
 	}
+	return cfg.IP
+}
+
+func (cfg *Config) multipleHostsConfigured() error {
+	if cfg.IP != "" && cfg.RPC.Host != "" {
+		return fmt.Errorf(
+			"%w: core.ip overridden by core.rpc.host",
+			ErrMultipleHostsConfigured,
+		)
+	}
+
+	if cfg.IP != "" && cfg.GRPC.Host != "" {
+		return fmt.Errorf(
+			"%w: core.ip overridden by core.grpc.host",
+			ErrMultipleHostsConfigured,
+		)
+	}
+
+	return nil
 }
 
 // Validate performs basic validation of the config.
@@ -34,31 +89,50 @@ func (cfg *Config) Validate() error {
 		return nil
 	}
 
-	rpcIP, err := utils.ValidateAddr(cfg.RPCIP)
+	if err := cfg.multipleHostsConfigured(); err != nil {
+		return err
+	}
+
+	rpcURL, err := url.Parse(cfg.RPCHost())
 	if err != nil {
-		return fmt.Errorf("nodebuilder/core: invalid rpc ip: %s", err.Error())
+		return fmt.Errorf("nodebuilder/core: invalid rpc host: %s", err.Error())
 	}
-	cfg.RPCIP = rpcIP
+	cfg.RPC.Host = rpcURL.Host
 
-	grpcIP, err := utils.ValidateAddr(cfg.GRPCIP)
+	if rpcURL.Scheme != "" {
+		cfg.RPC.Scheme = rpcURL.Scheme
+	}
+
+	grpcURL, err := url.Parse(cfg.GRPCHost())
 	if err != nil {
-		return fmt.Errorf("nodebuilder/core: invalid grpc ip: %s", err.Error())
+		return fmt.Errorf("nodebuilder/core: invalid grpc host: %s", err.Error())
+	}
+	cfg.GRPC.Host = grpcURL.Host
+
+	if grpcURL.Scheme != "" {
+		cfg.GRPC.Scheme = rpcURL.Scheme
 	}
-	cfg.GRPCIP = grpcIP
 
-	_, err = strconv.Atoi(cfg.RPCPort)
+	_, err = strconv.Atoi(cfg.RPC.Port)
 	if err != nil {
 		return fmt.Errorf("nodebuilder/core: invalid rpc port: %s", err.Error())
 	}
-	_, err = strconv.Atoi(cfg.GRPCPort)
+	_, err = strconv.Atoi(cfg.GRPC.Port)
 	if err != nil {
 		return fmt.Errorf("nodebuilder/core: invalid grpc port: %s", err.Error())
 	}
+
+	if cfg.GRPC.Cert != "" {
+		if _, err := os.Stat(cfg.GRPC.Cert); os.IsNotExist(err) {
+			return fmt.Errorf("nodebuilder/core: grpc cert file does not exist: %s", cfg.GRPC.Cert)
+		}
+	}
+
 	return nil
 }
 
 // IsEndpointConfigured returns whether a core endpoint has been set
 // on the config (true if set).
 func (cfg *Config) IsEndpointConfigured() bool {
-	return cfg.RPCIP != "" && cfg.GRPCIP != ""
+	return cfg.RPCHost() != "" && cfg.GRPCHost() != ""
 }
diff --git a/nodebuilder/core/config_test.go b/nodebuilder/core/config_test.go
new file mode 100644
index 0000000000..d39b31a44a
--- /dev/null
+++ b/nodebuilder/core/config_test.go
@@ -0,0 +1,159 @@
+package core
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDefaultValues(t *testing.T) {
+	expectedRPCScheme := "http"
+	expectedRPCPort := "26657"
+	expectedGRPCPort := "9090"
+
+	assert.Equal(t, expectedRPCScheme, DefaultRPCScheme, "DefaultRPCScheme is incorrect")
+	assert.Equal(t, expectedRPCPort, DefaultRPCPort, "DefaultRPCPort is incorrect")
+	assert.Equal(t, expectedGRPCPort, DefaultGRPCPort, "DefaultGRPCPort is incorrect")
+}
+
+func TestGRPCHost(t *testing.T) {
+	testCases := []struct {
+		name     string
+		cfg      *Config
+		expected string
+	}{
+		{
+			name: "Fallback to IP when GRPC Host is not set",
+			cfg: &Config{
+				GRPC: HostConfig{
+					Host: "",
+				},
+				IP: "127.0.0.1",
+			},
+			expected: "127.0.0.1",
+		},
+		{
+			name: "Use GRPC Host when set",
+			cfg: &Config{
+				GRPC: HostConfig{
+					Host: "0.0.0.0",
+				},
+				IP: "127.0.0.1",
+			},
+			expected: "0.0.0.0",
+		},
+		// Add more test cases here if needed
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			actual := tc.cfg.GRPCHost()
+			assert.Equal(t, tc.expected, actual)
+		})
+	}
+}
+
+func TestRPCHost(t *testing.T) {
+	testCases := []struct {
+		name     string
+		cfg      *Config
+		expected string
+	}{
+		{
+			name: "Fallback to IP when GRPC Host is not set",
+			cfg: &Config{
+				RPC: HostConfig{
+					Host: "",
+				},
+				IP: "127.0.0.1",
+			},
+			expected: "127.0.0.1",
+		},
+		{
+			name: "Use GRPC Host when set",
+			cfg: &Config{
+				RPC: HostConfig{
+					Host: "0.0.0.0",
+				},
+				IP: "127.0.0.1",
+			},
+			expected: "0.0.0.0",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			actual := tc.cfg.RPCHost()
+			assert.Equal(t, tc.expected, actual)
+		})
+	}
+}
+
+func TestMultipleHostsConfigured(t *testing.T) {
+	testCases := []struct {
+		name     string
+		cfg      *Config
+		expected error
+	}{
+		{
+			name: "IP and RPC Host both configured",
+			cfg: &Config{
+				IP: "127.0.0.1",
+				RPC: HostConfig{
+					Host: "localhost",
+				},
+			},
+			expected: fmt.Errorf("multiple hosts configured: core.ip overridden by core.rpc.host"),
+		},
+		{
+			name: "IP and gRPC Host both configured",
+			cfg: &Config{
+				IP: "127.0.0.1",
+				GRPC: HostConfig{
+					Host: "localhost",
+				},
+			},
+			expected: fmt.Errorf("multiple hosts configured: core.ip overridden by core.grpc.host"),
+		},
+		{
+			name: "Only IP configured",
+			cfg: &Config{
+				IP: "127.0.0.1",
+			},
+			expected: nil,
+		},
+		{
+			name: "Only RPC Host configured",
+			cfg: &Config{
+				RPC: HostConfig{
+					Host: "localhost",
+				},
+			},
+			expected: nil,
+		},
+		{
+			name: "Only gRPC Host configured",
+			cfg: &Config{
+				GRPC: HostConfig{
+					Host: "localhost",
+				},
+			},
+			expected: nil,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			actual := tc.cfg.multipleHostsConfigured()
+			fmt.Println(actual)
+			fmt.Println(tc.expected)
+			if tc.expected == nil {
+				assert.Nil(t, actual)
+			} else {
+				assert.Error(t, actual)
+				assert.EqualError(t, actual, tc.expected.Error())
+			}
+		})
+	}
+}
diff --git a/nodebuilder/core/constructors.go b/nodebuilder/core/constructors.go
index 189a18c3f8..ed036466d9 100644
--- a/nodebuilder/core/constructors.go
+++ b/nodebuilder/core/constructors.go
@@ -5,5 +5,5 @@ import (
 )
 
 func remote(cfg Config) (core.Client, error) {
-	return core.NewRemote(cfg.RPCIP, cfg.RPCPort)
+	return core.NewRemote(cfg.RPCHost(), cfg.RPC.Port)
 }
diff --git a/nodebuilder/core/flags.go b/nodebuilder/core/flags.go
index 41d3c8426e..c7cd1860fe 100644
--- a/nodebuilder/core/flags.go
+++ b/nodebuilder/core/flags.go
@@ -1,21 +1,24 @@
 package core
 
 import (
-	"fmt"
-
 	"github.com/spf13/cobra"
 	flag "github.com/spf13/pflag"
 )
 
 var (
-	ipFlag       = "core.ip"
-	rpcIPFlag    = "core.rpc.ip"
-	grpcIPFlag   = "core.grpc.ip"
-	rpcPortFlag  = "core.rpc.port"
+	ipFlag = "core.ip"
+
+	rpcHostFlag = "core.rpc.host"
+	rpcPortFlag = "core.rpc.port"
+
+	grpcHostFlag = "core.grpc.host"
 	grpcPortFlag = "core.grpc.port"
+	grpcCertFlag = "core.grpc.cert"
 )
 
 // Flags gives a set of hardcoded Core flags.
+//
+//nolint:goconst
 func Flags() *flag.FlagSet {
 	flags := &flag.FlagSet{}
 
@@ -27,74 +30,52 @@ func Flags() *flag.FlagSet {
 			"Example: <ip>, 127.0.0.1. <dns>, subdomain.domain.tld "+
 			"Assumes RPC port 26657 and gRPC port 9090 as default unless otherwise specified.",
 	)
+	// RPC configuration flags
 	flags.String(
-		rpcIPFlag,
+		rpcHostFlag,
 		"",
 		"Indicates node to connect to the given core node's RPC. "+
 			"NOTE: If this flag is set, the core.ip flag cannot be set. "+
 			"Example: <ip>, 127.0.0.1. <dns>, subdomain.domain.tld "+
-			"Assumes RPC port 26657 and gRPC port 9090 as default unless otherwise specified.",
+			"Assumes RPC port 26657 as default unless otherwise specified.",
 	)
 	flags.String(
-		grpcIPFlag,
+		rpcPortFlag,
+		DefaultRPCPort,
+		"Set a custom RPC port for the core node connection.",
+	)
+	// gRPC configuration flags
+	flags.String(
+		grpcHostFlag,
 		"",
 		"Indicates node to connect to the given core node's gRPC. "+
 			"NOTE: If this flag is set, the core.ip flag cannot be set. "+
 			"Example: <ip>, 127.0.0.1. <dns>, subdomain.domain.tld "+
-			"Assumes RPC port 26657 and gRPC port 9090 as default unless otherwise specified.",
+			"Assumes RPC gRPC port 9090 as default unless otherwise specified.",
 	)
+
 	flags.String(
-		rpcPortFlag,
-		"26657",
-		"Set a custom RPC port for the core node connection. The --core.rpc.ip or --core.ip flag must also be provided.",
+		grpcPortFlag,
+		DefaultGRPCPort,
+		"Set a custom gRPC port for the core node connection.",
 	)
 	flags.String(
-		grpcPortFlag,
-		"9090",
-		"Set a custom gRPC port for the core node connection. The --core.grpc.ip or --core.ip flag must also be provided.",
+		grpcCertFlag,
+		"",
+		"Set a path to a gRPC certificate for the core node connection.",
 	)
 	return flags
 }
 
 // ParseFlags parses Core flags from the given cmd and saves them to the passed config.
 func ParseFlags(cmd *cobra.Command, cfg *Config) error {
-	coreIP := cmd.Flag(ipFlag).Value.String()
-	coreRPCIP, coreGRPCIP := cmd.Flag(rpcIPFlag).Value.String(), cmd.Flag(grpcIPFlag).Value.String()
-
-	// Check if core.ip is specified along with core.rpc.ip or core.grpc.ip
-	if coreIP != "" && (cmd.Flag(rpcIPFlag).Changed || cmd.Flag(grpcIPFlag).Changed) {
-		return fmt.Errorf("cannot specify core.ip and core.rpc.ip or core.grpc.ip flags together")
-	}
-
-	// Validate IP addresses and port settings
-	if coreIP == "" { // No core.ip specified
-		if coreRPCIP == "" {
-			if cmd.Flag(rpcPortFlag).Changed {
-				return fmt.Errorf("cannot specify RPC ports without specifying an IP address for --core.rpc.ip")
-			}
-			if cmd.Flag(grpcIPFlag).Changed {
-				return fmt.Errorf("setting gRPC IP requires also specifying an RPC IP. If they are identical use --core.ip instead")
-			}
-		}
-		if coreGRPCIP == "" {
-			if cmd.Flag(grpcPortFlag).Changed {
-				return fmt.Errorf("cannot specify gRPC ports without specifying an IP address for --core.grpc.ip")
-			}
-			if cmd.Flag(rpcIPFlag).Changed {
-				return fmt.Errorf("setting RPC IP requires also specifying a gRPC IP. If they are identical use --core.ip instead")
-			}
-		}
-	}
-
-	// Assign IP addresses
-	if coreIP != "" {
-		cfg.RPCIP, cfg.GRPCIP = coreIP, coreIP
-	} else {
-		cfg.RPCIP, cfg.GRPCIP = coreRPCIP, coreGRPCIP
-	}
+	cfg.IP = cmd.Flag(ipFlag).Value.String()
+	cfg.RPC.Host = cmd.Flag(rpcHostFlag).Value.String()
+	cfg.RPC.Port = cmd.Flag(rpcPortFlag).Value.String()
 
-	// Assign ports
-	cfg.RPCPort, cfg.GRPCPort = cmd.Flag(rpcPortFlag).Value.String(), cmd.Flag(grpcPortFlag).Value.String()
+	cfg.GRPC.Host = cmd.Flag(grpcHostFlag).Value.String()
+	cfg.GRPC.Port = cmd.Flag(grpcPortFlag).Value.String()
+	cfg.GRPC.Cert = cmd.Flag(grpcCertFlag).Value.String()
 
 	return cfg.Validate()
 }
diff --git a/nodebuilder/state/core.go b/nodebuilder/state/core.go
index 06e16b8034..145b90be4b 100644
--- a/nodebuilder/state/core.go
+++ b/nodebuilder/state/core.go
@@ -20,7 +20,17 @@ func coreAccessor(
 	sync *sync.Syncer[*header.ExtendedHeader],
 	fraudServ libfraud.Service[*header.ExtendedHeader],
 ) (*state.CoreAccessor, Module, *modfraud.ServiceBreaker[*state.CoreAccessor, *header.ExtendedHeader]) {
-	ca := state.NewCoreAccessor(signer, sync, corecfg.RPCIP, corecfg.GRPCIP, corecfg.RPCPort, corecfg.GRPCPort)
+	ca := state.NewCoreAccessor(
+		signer,
+		sync,
+		corecfg.RPC.Scheme,
+		corecfg.RPCHost(),
+		corecfg.RPC.Port,
+		corecfg.GRPC.Scheme,
+		corecfg.GRPCHost(),
+		corecfg.GRPC.Port,
+		corecfg.GRPC.Cert,
+	)
 
 	return ca, ca, &modfraud.ServiceBreaker[*state.CoreAccessor, *header.ExtendedHeader]{
 		Service:   ca,
diff --git a/nodebuilder/tests/swamp/swamp.go b/nodebuilder/tests/swamp/swamp.go
index 55bc62750f..dfbf65680b 100644
--- a/nodebuilder/tests/swamp/swamp.go
+++ b/nodebuilder/tests/swamp/swamp.go
@@ -196,8 +196,8 @@ func (s *Swamp) DefaultTestConfig(tp node.Type) *nodebuilder.Config {
 	ip, port, err := net.SplitHostPort(s.cfg.AppConfig.GRPC.Address)
 	require.NoError(s.t, err)
 
-	cfg.Core.RPCIP = ip
-	cfg.Core.GRPCIP = ip
+	cfg.Core.RPC.Host = ip
+	cfg.Core.GRPC.Host = ip
 	cfg.Core.GRPCPort = port
 	return cfg
 }
diff --git a/state/core_access.go b/state/core_access.go
index bf662a056d..e1cf2528ff 100644
--- a/state/core_access.go
+++ b/state/core_access.go
@@ -22,6 +22,7 @@ import (
 	rpcclient "github.com/tendermint/tendermint/rpc/client"
 	"github.com/tendermint/tendermint/rpc/client/http"
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/credentials/insecure"
 
 	"github.com/celestiaorg/celestia-app/app"
@@ -58,10 +59,15 @@ type CoreAccessor struct {
 	prt *merkle.ProofRuntime
 
 	coreConn *grpc.ClientConn
-	rpcIP    string
-	grpcIP   string
-	rpcPort  string
-	grpcPort string
+
+	rpcScheme string
+	rpcHost   string
+	rpcPort   string
+
+	grpcScheme string
+	grpcHost   string
+	grpcPort   string
+	grpcCert   string
 
 	// these fields are mutatable and thus need to be protected by a mutex
 	lock            sync.Mutex
@@ -80,23 +86,29 @@ type CoreAccessor struct {
 func NewCoreAccessor(
 	signer *apptypes.KeyringSigner,
 	getter libhead.Head[*header.ExtendedHeader],
-	rpcIP,
-	grpcIP,
-	rpcPort string,
-	grpcPort string,
+	rpcScheme,
+	rpcHost,
+	rpcPort,
+	grpcScheme,
+	grpcHost,
+	grpcPort,
+	grpcCert string,
 ) *CoreAccessor {
 	// create verifier
 	prt := merkle.DefaultProofRuntime()
 	prt.RegisterOpDecoder(storetypes.ProofOpIAVLCommitment, storetypes.CommitmentOpDecoder)
 	prt.RegisterOpDecoder(storetypes.ProofOpSimpleMerkleCommitment, storetypes.CommitmentOpDecoder)
 	return &CoreAccessor{
-		signer:   signer,
-		getter:   getter,
-		rpcIP:    rpcIP,
-		grpcIP:   grpcIP,
-		rpcPort:  rpcPort,
-		grpcPort: grpcPort,
-		prt:      prt,
+		signer:     signer,
+		getter:     getter,
+		rpcScheme:  rpcScheme,
+		rpcHost:    rpcHost,
+		rpcPort:    rpcPort,
+		grpcScheme: grpcScheme,
+		grpcHost:   grpcHost,
+		grpcPort:   grpcPort,
+		grpcCert:   grpcCert,
+		prt:        prt,
 	}
 }
 
@@ -106,12 +118,23 @@ func (ca *CoreAccessor) Start(ctx context.Context) error {
 	}
 	ca.ctx, ca.cancel = context.WithCancel(context.Background())
 
+	var opts []grpc.DialOption
+	if ca.grpcCert != "" {
+		creds, err := credentials.NewClientTLSFromFile(ca.grpcCert, "")
+		if err != nil {
+			return fmt.Errorf("failed to create TLS credentials: %w", err)
+		}
+		opts = append(opts, grpc.WithTransportCredentials(creds))
+	} else {
+		opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	}
+
 	// dial given celestia-core endpoint
-	endpoint := fmt.Sprintf("%s:%s", ca.grpcIP, ca.grpcPort)
+	endpoint := fmt.Sprintf("%s://%s:%s", ca.grpcScheme, ca.grpcHost, ca.grpcPort)
 	client, err := grpc.DialContext(
 		ctx,
 		endpoint,
-		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		opts...,
 	)
 	if err != nil {
 		return err
@@ -124,7 +147,7 @@ func (ca *CoreAccessor) Start(ctx context.Context) error {
 	stakingCli := stakingtypes.NewQueryClient(ca.coreConn)
 	ca.stakingCli = stakingCli
 	// create ABCI query client
-	cli, err := http.New(fmt.Sprintf("http://%s:%s", ca.rpcIP, ca.rpcPort), "/websocket")
+	cli, err := http.New(fmt.Sprintf("%s://%s:%s", ca.rpcScheme, ca.rpcHost, ca.rpcPort), "/websocket")
 	if err != nil {
 		return err
 	}

From f5ee2f0fe60ac204aae612337870a32f2f26814e Mon Sep 17 00:00:00 2001
From: ramin <raminkeene@gmail.com>
Date: Wed, 6 Mar 2024 12:26:13 +0000
Subject: [PATCH 03/16] fix tests, rename ipFLag back closer to original naming

---
 nodebuilder/core/flags.go | 4 ++--
 state/core_access_test.go | 2 +-
 state/integration_test.go | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/nodebuilder/core/flags.go b/nodebuilder/core/flags.go
index c7cd1860fe..a010adee57 100644
--- a/nodebuilder/core/flags.go
+++ b/nodebuilder/core/flags.go
@@ -6,7 +6,7 @@ import (
 )
 
 var (
-	ipFlag = "core.ip"
+	coreIpFlag = "core.ip" // TODO: @ramin - we should deprecate this
 
 	rpcHostFlag = "core.rpc.host"
 	rpcPortFlag = "core.rpc.port"
@@ -23,7 +23,7 @@ func Flags() *flag.FlagSet {
 	flags := &flag.FlagSet{}
 
 	flags.String(
-		ipFlag,
+		coreIpFlag,
 		"",
 		"Indicates node to connect to the given core node's RPC and gRPC. "+
 			"NOTE: If this flag is set, the core.rpc.ip and core.grpc.ip flags cannot be set. "+
diff --git a/state/core_access_test.go b/state/core_access_test.go
index 829758fb55..b8bc61b0c9 100644
--- a/state/core_access_test.go
+++ b/state/core_access_test.go
@@ -38,7 +38,7 @@ func TestSubmitPayForBlob(t *testing.T) {
 
 	signer := blobtypes.NewKeyringSigner(cctx.Keyring, accounts[0], cctx.ChainID)
 	coreIP := "127.0.0.1"
-	ca := NewCoreAccessor(signer, nil, coreIP, coreIP, extractPort(rpcAddr), extractPort(grpcAddr))
+	ca := NewCoreAccessor(signer, nil, "http", coreIP, extractPort(rpcAddr), "http", coreIP, extractPort(grpcAddr), "")
 	// start the accessor
 	err := ca.Start(ctx)
 	require.NoError(t, err)
diff --git a/state/integration_test.go b/state/integration_test.go
index 5fd60c00f3..a122c7c39c 100644
--- a/state/integration_test.go
+++ b/state/integration_test.go
@@ -51,7 +51,7 @@ func (s *IntegrationTestSuite) SetupSuite() {
 	s.accounts = cfg.Accounts
 
 	signer := blobtypes.NewKeyringSigner(s.cctx.Keyring, s.accounts[0], s.cctx.ChainID)
-	accessor := NewCoreAccessor(signer, localHeader{s.cctx.Client}, "", "", "", "")
+	accessor := NewCoreAccessor(signer, localHeader{s.cctx.Client}, "", "", "", "", "", "")
 	setClients(accessor, s.cctx.GRPCClient, s.cctx.Client)
 	s.accessor = accessor
 

From 9875a2feecfd519e29d42f0a899dd35f86c5984c Mon Sep 17 00:00:00 2001
From: ramin <raminkeene@gmail.com>
Date: Wed, 6 Mar 2024 12:27:03 +0000
Subject: [PATCH 04/16] organize config struct block

---
 state/core_access.go | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/state/core_access.go b/state/core_access.go
index e1cf2528ff..03e32478b3 100644
--- a/state/core_access.go
+++ b/state/core_access.go
@@ -99,16 +99,21 @@ func NewCoreAccessor(
 	prt.RegisterOpDecoder(storetypes.ProofOpIAVLCommitment, storetypes.CommitmentOpDecoder)
 	prt.RegisterOpDecoder(storetypes.ProofOpSimpleMerkleCommitment, storetypes.CommitmentOpDecoder)
 	return &CoreAccessor{
-		signer:     signer,
-		getter:     getter,
-		rpcScheme:  rpcScheme,
-		rpcHost:    rpcHost,
-		rpcPort:    rpcPort,
+		signer: signer,
+		getter: getter,
+
+		// json rpc config
+		rpcScheme: rpcScheme,
+		rpcHost:   rpcHost,
+		rpcPort:   rpcPort,
+
+		// grpc config
 		grpcScheme: grpcScheme,
 		grpcHost:   grpcHost,
 		grpcPort:   grpcPort,
 		grpcCert:   grpcCert,
-		prt:        prt,
+
+		prt: prt,
 	}
 }
 

From 3dd243a141732cd1e1c1aa2734fcccb540ac9b0e Mon Sep 17 00:00:00 2001
From: ramin <raminkeene@gmail.com>
Date: Wed, 6 Mar 2024 12:34:49 +0000
Subject: [PATCH 05/16] fix missed flag rename

---
 nodebuilder/core/flags.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nodebuilder/core/flags.go b/nodebuilder/core/flags.go
index a010adee57..77dc21ea60 100644
--- a/nodebuilder/core/flags.go
+++ b/nodebuilder/core/flags.go
@@ -69,7 +69,7 @@ func Flags() *flag.FlagSet {
 
 // ParseFlags parses Core flags from the given cmd and saves them to the passed config.
 func ParseFlags(cmd *cobra.Command, cfg *Config) error {
-	cfg.IP = cmd.Flag(ipFlag).Value.String()
+	cfg.IP = cmd.Flag(coreIpFlag).Value.String()
 	cfg.RPC.Host = cmd.Flag(rpcHostFlag).Value.String()
 	cfg.RPC.Port = cmd.Flag(rpcPortFlag).Value.String()
 

From c8d43812f80b294175596e66133dd911564b5dfc Mon Sep 17 00:00:00 2001
From: ramin <raminkeene@gmail.com>
Date: Wed, 6 Mar 2024 13:53:14 +0000
Subject: [PATCH 06/16] lint

---
 nodebuilder/core/flags.go        | 6 +++---
 nodebuilder/tests/swamp/swamp.go | 2 +-
 state/integration_test.go        | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/nodebuilder/core/flags.go b/nodebuilder/core/flags.go
index 77dc21ea60..aea0e23176 100644
--- a/nodebuilder/core/flags.go
+++ b/nodebuilder/core/flags.go
@@ -6,7 +6,7 @@ import (
 )
 
 var (
-	coreIpFlag = "core.ip" // TODO: @ramin - we should deprecate this
+	coreIPFlag = "core.ip" // TODO: @ramin - we should deprecate this
 
 	rpcHostFlag = "core.rpc.host"
 	rpcPortFlag = "core.rpc.port"
@@ -23,7 +23,7 @@ func Flags() *flag.FlagSet {
 	flags := &flag.FlagSet{}
 
 	flags.String(
-		coreIpFlag,
+		coreIPFlag,
 		"",
 		"Indicates node to connect to the given core node's RPC and gRPC. "+
 			"NOTE: If this flag is set, the core.rpc.ip and core.grpc.ip flags cannot be set. "+
@@ -69,7 +69,7 @@ func Flags() *flag.FlagSet {
 
 // ParseFlags parses Core flags from the given cmd and saves them to the passed config.
 func ParseFlags(cmd *cobra.Command, cfg *Config) error {
-	cfg.IP = cmd.Flag(coreIpFlag).Value.String()
+	cfg.IP = cmd.Flag(coreIPFlag).Value.String()
 	cfg.RPC.Host = cmd.Flag(rpcHostFlag).Value.String()
 	cfg.RPC.Port = cmd.Flag(rpcPortFlag).Value.String()
 
diff --git a/nodebuilder/tests/swamp/swamp.go b/nodebuilder/tests/swamp/swamp.go
index dfbf65680b..770220e960 100644
--- a/nodebuilder/tests/swamp/swamp.go
+++ b/nodebuilder/tests/swamp/swamp.go
@@ -198,7 +198,7 @@ func (s *Swamp) DefaultTestConfig(tp node.Type) *nodebuilder.Config {
 
 	cfg.Core.RPC.Host = ip
 	cfg.Core.GRPC.Host = ip
-	cfg.Core.GRPCPort = port
+	cfg.Core.GRPC.Port = port
 	return cfg
 }
 
diff --git a/state/integration_test.go b/state/integration_test.go
index a122c7c39c..012f6c14a7 100644
--- a/state/integration_test.go
+++ b/state/integration_test.go
@@ -51,7 +51,7 @@ func (s *IntegrationTestSuite) SetupSuite() {
 	s.accounts = cfg.Accounts
 
 	signer := blobtypes.NewKeyringSigner(s.cctx.Keyring, s.accounts[0], s.cctx.ChainID)
-	accessor := NewCoreAccessor(signer, localHeader{s.cctx.Client}, "", "", "", "", "", "")
+	accessor := NewCoreAccessor(signer, localHeader{s.cctx.Client}, "", "", "", "", "", "", "")
 	setClients(accessor, s.cctx.GRPCClient, s.cctx.Client)
 	s.accessor = accessor
 

From 48b324eac095bffba761d0f7ee02fff74a27c59f Mon Sep 17 00:00:00 2001
From: ramin <raminkeene@gmail.com>
Date: Wed, 6 Mar 2024 14:39:51 +0000
Subject: [PATCH 07/16] don't try and set https for grpc

---
 nodebuilder/core/config.go | 30 +++++++++++++++++++++++-------
 state/core_access.go       |  3 ++-
 2 files changed, 25 insertions(+), 8 deletions(-)

diff --git a/nodebuilder/core/config.go b/nodebuilder/core/config.go
index 4e0c549784..01170dd2bc 100644
--- a/nodebuilder/core/config.go
+++ b/nodebuilder/core/config.go
@@ -6,6 +6,8 @@ import (
 	"net/url"
 	"os"
 	"strconv"
+
+	"github.com/celestiaorg/celestia-node/libs/utils"
 )
 
 var (
@@ -23,9 +25,10 @@ const (
 // Config combines all configuration fields for
 // managing the relationship with a Core node.
 type Config struct {
-	IP   string
-	RPC  HostConfig
-	GRPC HostConfig
+	IP           string
+	RPC          HostConfig
+	GRPC         HostConfig
+	OtherRPCHost string
 }
 
 type HostConfig struct {
@@ -93,22 +96,22 @@ func (cfg *Config) Validate() error {
 		return err
 	}
 
-	rpcURL, err := url.Parse(cfg.RPCHost())
+	_, err := utils.ValidateAddr(cfg.RPCHost())
 	if err != nil {
 		return fmt.Errorf("nodebuilder/core: invalid rpc host: %s", err.Error())
 	}
-	cfg.RPC.Host = rpcURL.Host
 
+	rpcURL, err := url.Parse(cfg.RPCHost())
 	if rpcURL.Scheme != "" {
 		cfg.RPC.Scheme = rpcURL.Scheme
 	}
 
-	grpcURL, err := url.Parse(cfg.GRPCHost())
+	_, err = utils.ValidateAddr(cfg.GRPCHost())
 	if err != nil {
 		return fmt.Errorf("nodebuilder/core: invalid grpc host: %s", err.Error())
 	}
-	cfg.GRPC.Host = grpcURL.Host
 
+	grpcURL, err := url.Parse(cfg.GRPCHost())
 	if grpcURL.Scheme != "" {
 		cfg.GRPC.Scheme = rpcURL.Scheme
 	}
@@ -128,11 +131,24 @@ func (cfg *Config) Validate() error {
 		}
 	}
 
+	fmt.Println("config after validation")
+	fmt.Println(cfg)
+	fmt.Println("configued: ", cfg.IsEndpointConfigured())
+	fmt.Println("rpc host: ", cfg.RPCHost())
+	fmt.Println("grpc host: ", cfg.GRPCHost())
+	fmt.Println("rpc scheme: ", cfg.RPC.Scheme)
+	fmt.Println("grpc scheme: ", cfg.GRPC.Scheme)
+	fmt.Println("rpc port: ", cfg.RPC.Port)
+	fmt.Println("grpc port: ", cfg.GRPC.Port)
+
 	return nil
 }
 
 // IsEndpointConfigured returns whether a core endpoint has been set
 // on the config (true if set).
 func (cfg *Config) IsEndpointConfigured() bool {
+	fmt.Println(cfg)
+	fmt.Println(cfg.RPCHost())
+	fmt.Println(cfg.GRPCHost())
 	return cfg.RPCHost() != "" && cfg.GRPCHost() != ""
 }
diff --git a/state/core_access.go b/state/core_access.go
index 03e32478b3..6ce614fcb5 100644
--- a/state/core_access.go
+++ b/state/core_access.go
@@ -135,7 +135,8 @@ func (ca *CoreAccessor) Start(ctx context.Context) error {
 	}
 
 	// dial given celestia-core endpoint
-	endpoint := fmt.Sprintf("%s://%s:%s", ca.grpcScheme, ca.grpcHost, ca.grpcPort)
+	endpoint := fmt.Sprintf("%s:%s", ca.grpcHost, ca.grpcPort)
+
 	client, err := grpc.DialContext(
 		ctx,
 		endpoint,

From b0e0be682230b20d0bafdf7969d3716a90722ae0 Mon Sep 17 00:00:00 2001
From: ramin <raminkeene@gmail.com>
Date: Wed, 6 Mar 2024 14:59:25 +0000
Subject: [PATCH 08/16] remove lint errors and clean grpc host

---
 nodebuilder/core/config.go | 16 ++++------------
 1 file changed, 4 insertions(+), 12 deletions(-)

diff --git a/nodebuilder/core/config.go b/nodebuilder/core/config.go
index 01170dd2bc..18e21976fc 100644
--- a/nodebuilder/core/config.go
+++ b/nodebuilder/core/config.go
@@ -106,12 +106,14 @@ func (cfg *Config) Validate() error {
 		cfg.RPC.Scheme = rpcURL.Scheme
 	}
 
-	_, err = utils.ValidateAddr(cfg.GRPCHost())
+	grpcHost, _ := utils.ValidateAddr(cfg.GRPCHost())
 	if err != nil {
 		return fmt.Errorf("nodebuilder/core: invalid grpc host: %s", err.Error())
 	}
 
-	grpcURL, err := url.Parse(cfg.GRPCHost())
+	cfg.GRPC.Host = grpcHost
+
+	grpcURL, _ := url.Parse(cfg.GRPCHost())
 	if grpcURL.Scheme != "" {
 		cfg.GRPC.Scheme = rpcURL.Scheme
 	}
@@ -131,16 +133,6 @@ func (cfg *Config) Validate() error {
 		}
 	}
 
-	fmt.Println("config after validation")
-	fmt.Println(cfg)
-	fmt.Println("configued: ", cfg.IsEndpointConfigured())
-	fmt.Println("rpc host: ", cfg.RPCHost())
-	fmt.Println("grpc host: ", cfg.GRPCHost())
-	fmt.Println("rpc scheme: ", cfg.RPC.Scheme)
-	fmt.Println("grpc scheme: ", cfg.GRPC.Scheme)
-	fmt.Println("rpc port: ", cfg.RPC.Port)
-	fmt.Println("grpc port: ", cfg.GRPC.Port)
-
 	return nil
 }
 

From 2b8d549a8207688979f70e689041d61a5468ceeb Mon Sep 17 00:00:00 2001
From: ramin <raminkeene@gmail.com>
Date: Wed, 6 Mar 2024 16:00:19 +0000
Subject: [PATCH 09/16] remove debugs

---
 nodebuilder/core/config.go      | 3 ---
 nodebuilder/core/config_test.go | 2 --
 2 files changed, 5 deletions(-)

diff --git a/nodebuilder/core/config.go b/nodebuilder/core/config.go
index 18e21976fc..ea9609e681 100644
--- a/nodebuilder/core/config.go
+++ b/nodebuilder/core/config.go
@@ -139,8 +139,5 @@ func (cfg *Config) Validate() error {
 // IsEndpointConfigured returns whether a core endpoint has been set
 // on the config (true if set).
 func (cfg *Config) IsEndpointConfigured() bool {
-	fmt.Println(cfg)
-	fmt.Println(cfg.RPCHost())
-	fmt.Println(cfg.GRPCHost())
 	return cfg.RPCHost() != "" && cfg.GRPCHost() != ""
 }
diff --git a/nodebuilder/core/config_test.go b/nodebuilder/core/config_test.go
index d39b31a44a..8094d244e6 100644
--- a/nodebuilder/core/config_test.go
+++ b/nodebuilder/core/config_test.go
@@ -146,8 +146,6 @@ func TestMultipleHostsConfigured(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			actual := tc.cfg.multipleHostsConfigured()
-			fmt.Println(actual)
-			fmt.Println(tc.expected)
 			if tc.expected == nil {
 				assert.Nil(t, actual)
 			} else {

From 0797f74c6ad1853103f1b888d20072f7e9451881 Mon Sep 17 00:00:00 2001
From: ramin <raminkeene@gmail.com>
Date: Tue, 19 Mar 2024 10:28:41 +0000
Subject: [PATCH 10/16] clean up and ready for testing

---
 nodebuilder/core/config.go | 29 ++++++++---------------------
 nodebuilder/core/flags.go  | 18 ++++++++++--------
 nodebuilder/state/core.go  |  1 -
 state/core_access.go       | 19 ++-----------------
 state/core_access_test.go  |  2 +-
 state/integration_test.go  |  2 +-
 6 files changed, 22 insertions(+), 49 deletions(-)

diff --git a/nodebuilder/core/config.go b/nodebuilder/core/config.go
index ea9609e681..617131b538 100644
--- a/nodebuilder/core/config.go
+++ b/nodebuilder/core/config.go
@@ -3,8 +3,6 @@ package core
 import (
 	"errors"
 	"fmt"
-	"net/url"
-	"os"
 	"strconv"
 
 	"github.com/celestiaorg/celestia-node/libs/utils"
@@ -25,17 +23,15 @@ const (
 // Config combines all configuration fields for
 // managing the relationship with a Core node.
 type Config struct {
-	IP           string
-	RPC          HostConfig
-	GRPC         HostConfig
-	OtherRPCHost string
+	IP   string
+	RPC  HostConfig
+	GRPC HostConfig
 }
 
 type HostConfig struct {
 	Scheme string
 	Host   string
 	Port   string
-	Cert   string
 }
 
 // DefaultConfig returns default configuration for managing the
@@ -101,11 +97,13 @@ func (cfg *Config) Validate() error {
 		return fmt.Errorf("nodebuilder/core: invalid rpc host: %s", err.Error())
 	}
 
-	rpcURL, err := url.Parse(cfg.RPCHost())
-	if rpcURL.Scheme != "" {
-		cfg.RPC.Scheme = rpcURL.Scheme
+	rpcHost, _ := utils.ValidateAddr(cfg.RPCHost())
+	if err != nil {
+		return fmt.Errorf("nodebuilder/core: invalid grpc host: %s", err.Error())
 	}
 
+	cfg.RPC.Host = rpcHost
+
 	grpcHost, _ := utils.ValidateAddr(cfg.GRPCHost())
 	if err != nil {
 		return fmt.Errorf("nodebuilder/core: invalid grpc host: %s", err.Error())
@@ -113,11 +111,6 @@ func (cfg *Config) Validate() error {
 
 	cfg.GRPC.Host = grpcHost
 
-	grpcURL, _ := url.Parse(cfg.GRPCHost())
-	if grpcURL.Scheme != "" {
-		cfg.GRPC.Scheme = rpcURL.Scheme
-	}
-
 	_, err = strconv.Atoi(cfg.RPC.Port)
 	if err != nil {
 		return fmt.Errorf("nodebuilder/core: invalid rpc port: %s", err.Error())
@@ -127,12 +120,6 @@ func (cfg *Config) Validate() error {
 		return fmt.Errorf("nodebuilder/core: invalid grpc port: %s", err.Error())
 	}
 
-	if cfg.GRPC.Cert != "" {
-		if _, err := os.Stat(cfg.GRPC.Cert); os.IsNotExist(err) {
-			return fmt.Errorf("nodebuilder/core: grpc cert file does not exist: %s", cfg.GRPC.Cert)
-		}
-	}
-
 	return nil
 }
 
diff --git a/nodebuilder/core/flags.go b/nodebuilder/core/flags.go
index aea0e23176..aada83010e 100644
--- a/nodebuilder/core/flags.go
+++ b/nodebuilder/core/flags.go
@@ -10,10 +10,10 @@ var (
 
 	rpcHostFlag = "core.rpc.host"
 	rpcPortFlag = "core.rpc.port"
+	rpcUseHTTPS = "core.rpc.https"
 
 	grpcHostFlag = "core.grpc.host"
 	grpcPortFlag = "core.grpc.port"
-	grpcCertFlag = "core.grpc.cert"
 )
 
 // Flags gives a set of hardcoded Core flags.
@@ -44,6 +44,11 @@ func Flags() *flag.FlagSet {
 		DefaultRPCPort,
 		"Set a custom RPC port for the core node connection.",
 	)
+	flags.Bool(
+		rpcUseHTTPS,
+		false,
+		"Use https for RPC connection. Default is false.",
+	)
 	// gRPC configuration flags
 	flags.String(
 		grpcHostFlag,
@@ -53,17 +58,11 @@ func Flags() *flag.FlagSet {
 			"Example: <ip>, 127.0.0.1. <dns>, subdomain.domain.tld "+
 			"Assumes RPC gRPC port 9090 as default unless otherwise specified.",
 	)
-
 	flags.String(
 		grpcPortFlag,
 		DefaultGRPCPort,
 		"Set a custom gRPC port for the core node connection.",
 	)
-	flags.String(
-		grpcCertFlag,
-		"",
-		"Set a path to a gRPC certificate for the core node connection.",
-	)
 	return flags
 }
 
@@ -72,10 +71,13 @@ func ParseFlags(cmd *cobra.Command, cfg *Config) error {
 	cfg.IP = cmd.Flag(coreIPFlag).Value.String()
 	cfg.RPC.Host = cmd.Flag(rpcHostFlag).Value.String()
 	cfg.RPC.Port = cmd.Flag(rpcPortFlag).Value.String()
+	// if the flag is present, use HTTPS
+	if cmd.Flag(rpcUseHTTPS).Changed {
+		cfg.RPC.Scheme = "https"
+	}
 
 	cfg.GRPC.Host = cmd.Flag(grpcHostFlag).Value.String()
 	cfg.GRPC.Port = cmd.Flag(grpcPortFlag).Value.String()
-	cfg.GRPC.Cert = cmd.Flag(grpcCertFlag).Value.String()
 
 	return cfg.Validate()
 }
diff --git a/nodebuilder/state/core.go b/nodebuilder/state/core.go
index 145b90be4b..1cc1bc524f 100644
--- a/nodebuilder/state/core.go
+++ b/nodebuilder/state/core.go
@@ -29,7 +29,6 @@ func coreAccessor(
 		corecfg.GRPC.Scheme,
 		corecfg.GRPCHost(),
 		corecfg.GRPC.Port,
-		corecfg.GRPC.Cert,
 	)
 
 	return ca, ca, &modfraud.ServiceBreaker[*state.CoreAccessor, *header.ExtendedHeader]{
diff --git a/state/core_access.go b/state/core_access.go
index 6ce614fcb5..e47046125f 100644
--- a/state/core_access.go
+++ b/state/core_access.go
@@ -22,7 +22,6 @@ import (
 	rpcclient "github.com/tendermint/tendermint/rpc/client"
 	"github.com/tendermint/tendermint/rpc/client/http"
 	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/credentials/insecure"
 
 	"github.com/celestiaorg/celestia-app/app"
@@ -67,7 +66,6 @@ type CoreAccessor struct {
 	grpcScheme string
 	grpcHost   string
 	grpcPort   string
-	grpcCert   string
 
 	// these fields are mutatable and thus need to be protected by a mutex
 	lock            sync.Mutex
@@ -91,8 +89,7 @@ func NewCoreAccessor(
 	rpcPort,
 	grpcScheme,
 	grpcHost,
-	grpcPort,
-	grpcCert string,
+	grpcPort string,
 ) *CoreAccessor {
 	// create verifier
 	prt := merkle.DefaultProofRuntime()
@@ -111,7 +108,6 @@ func NewCoreAccessor(
 		grpcScheme: grpcScheme,
 		grpcHost:   grpcHost,
 		grpcPort:   grpcPort,
-		grpcCert:   grpcCert,
 
 		prt: prt,
 	}
@@ -123,24 +119,13 @@ func (ca *CoreAccessor) Start(ctx context.Context) error {
 	}
 	ca.ctx, ca.cancel = context.WithCancel(context.Background())
 
-	var opts []grpc.DialOption
-	if ca.grpcCert != "" {
-		creds, err := credentials.NewClientTLSFromFile(ca.grpcCert, "")
-		if err != nil {
-			return fmt.Errorf("failed to create TLS credentials: %w", err)
-		}
-		opts = append(opts, grpc.WithTransportCredentials(creds))
-	} else {
-		opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
-	}
-
 	// dial given celestia-core endpoint
 	endpoint := fmt.Sprintf("%s:%s", ca.grpcHost, ca.grpcPort)
 
 	client, err := grpc.DialContext(
 		ctx,
 		endpoint,
-		opts...,
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
 	)
 	if err != nil {
 		return err
diff --git a/state/core_access_test.go b/state/core_access_test.go
index b8bc61b0c9..da3b179f70 100644
--- a/state/core_access_test.go
+++ b/state/core_access_test.go
@@ -38,7 +38,7 @@ func TestSubmitPayForBlob(t *testing.T) {
 
 	signer := blobtypes.NewKeyringSigner(cctx.Keyring, accounts[0], cctx.ChainID)
 	coreIP := "127.0.0.1"
-	ca := NewCoreAccessor(signer, nil, "http", coreIP, extractPort(rpcAddr), "http", coreIP, extractPort(grpcAddr), "")
+	ca := NewCoreAccessor(signer, nil, "http", coreIP, extractPort(rpcAddr), "http", coreIP, extractPort(grpcAddr))
 	// start the accessor
 	err := ca.Start(ctx)
 	require.NoError(t, err)
diff --git a/state/integration_test.go b/state/integration_test.go
index 012f6c14a7..a122c7c39c 100644
--- a/state/integration_test.go
+++ b/state/integration_test.go
@@ -51,7 +51,7 @@ func (s *IntegrationTestSuite) SetupSuite() {
 	s.accounts = cfg.Accounts
 
 	signer := blobtypes.NewKeyringSigner(s.cctx.Keyring, s.accounts[0], s.cctx.ChainID)
-	accessor := NewCoreAccessor(signer, localHeader{s.cctx.Client}, "", "", "", "", "", "", "")
+	accessor := NewCoreAccessor(signer, localHeader{s.cctx.Client}, "", "", "", "", "", "")
 	setClients(accessor, s.cctx.GRPCClient, s.cctx.Client)
 	s.accessor = accessor
 

From decc39f10acfd4e8f76934ed065e32d80b4ac4b8 Mon Sep 17 00:00:00 2001
From: ramin <raminkeene@gmail.com>
Date: Tue, 19 Mar 2024 10:47:42 +0000
Subject: [PATCH 11/16] add tests for flag parsing

---
 nodebuilder/core/config.go      | 29 ++++++-----
 nodebuilder/core/config_test.go | 16 +++---
 nodebuilder/core/flags.go       |  2 +
 nodebuilder/core/flags_test.go  | 92 +++++++++++++++++++++++++++++++++
 nodebuilder/state/core.go       |  1 -
 state/core_access.go            | 17 ++----
 state/core_access_test.go       |  2 +-
 state/integration_test.go       |  2 +-
 8 files changed, 124 insertions(+), 37 deletions(-)
 create mode 100644 nodebuilder/core/flags_test.go

diff --git a/nodebuilder/core/config.go b/nodebuilder/core/config.go
index 617131b538..8fbd6c6923 100644
--- a/nodebuilder/core/config.go
+++ b/nodebuilder/core/config.go
@@ -24,28 +24,34 @@ const (
 // managing the relationship with a Core node.
 type Config struct {
 	IP   string
-	RPC  HostConfig
-	GRPC HostConfig
+	RPC  RPCConfig
+	GRPC GRPCConfig
 }
 
-type HostConfig struct {
+type RPCConfig struct {
 	Scheme string
 	Host   string
 	Port   string
 }
 
+type GRPCConfig struct {
+	Host string
+	Port string
+	// leaving separate to account for TLS
+	// and secure connections later
+}
+
 // DefaultConfig returns default configuration for managing the
 // node's connection to a Celestia-Core endpoint.
 func DefaultConfig() Config {
 	return Config{
 		IP: "",
-		RPC: HostConfig{
+		RPC: RPCConfig{
 			Scheme: DefaultRPCScheme,
 			Port:   DefaultRPCPort,
 		},
-		GRPC: HostConfig{
-			Scheme: DefaultRPCScheme,
-			Port:   DefaultGRPCPort,
+		GRPC: GRPCConfig{
+			Port: DefaultGRPCPort,
 		},
 	}
 }
@@ -92,19 +98,14 @@ func (cfg *Config) Validate() error {
 		return err
 	}
 
-	_, err := utils.ValidateAddr(cfg.RPCHost())
+	rpcHost, err := utils.ValidateAddr(cfg.RPCHost())
 	if err != nil {
 		return fmt.Errorf("nodebuilder/core: invalid rpc host: %s", err.Error())
 	}
 
-	rpcHost, _ := utils.ValidateAddr(cfg.RPCHost())
-	if err != nil {
-		return fmt.Errorf("nodebuilder/core: invalid grpc host: %s", err.Error())
-	}
-
 	cfg.RPC.Host = rpcHost
 
-	grpcHost, _ := utils.ValidateAddr(cfg.GRPCHost())
+	grpcHost, err := utils.ValidateAddr(cfg.GRPCHost())
 	if err != nil {
 		return fmt.Errorf("nodebuilder/core: invalid grpc host: %s", err.Error())
 	}
diff --git a/nodebuilder/core/config_test.go b/nodebuilder/core/config_test.go
index 8094d244e6..3c770d39b9 100644
--- a/nodebuilder/core/config_test.go
+++ b/nodebuilder/core/config_test.go
@@ -26,7 +26,7 @@ func TestGRPCHost(t *testing.T) {
 		{
 			name: "Fallback to IP when GRPC Host is not set",
 			cfg: &Config{
-				GRPC: HostConfig{
+				GRPC: GRPCConfig{
 					Host: "",
 				},
 				IP: "127.0.0.1",
@@ -36,7 +36,7 @@ func TestGRPCHost(t *testing.T) {
 		{
 			name: "Use GRPC Host when set",
 			cfg: &Config{
-				GRPC: HostConfig{
+				GRPC: GRPCConfig{
 					Host: "0.0.0.0",
 				},
 				IP: "127.0.0.1",
@@ -63,7 +63,7 @@ func TestRPCHost(t *testing.T) {
 		{
 			name: "Fallback to IP when GRPC Host is not set",
 			cfg: &Config{
-				RPC: HostConfig{
+				RPC: RPCConfig{
 					Host: "",
 				},
 				IP: "127.0.0.1",
@@ -73,7 +73,7 @@ func TestRPCHost(t *testing.T) {
 		{
 			name: "Use GRPC Host when set",
 			cfg: &Config{
-				RPC: HostConfig{
+				RPC: RPCConfig{
 					Host: "0.0.0.0",
 				},
 				IP: "127.0.0.1",
@@ -100,7 +100,7 @@ func TestMultipleHostsConfigured(t *testing.T) {
 			name: "IP and RPC Host both configured",
 			cfg: &Config{
 				IP: "127.0.0.1",
-				RPC: HostConfig{
+				RPC: RPCConfig{
 					Host: "localhost",
 				},
 			},
@@ -110,7 +110,7 @@ func TestMultipleHostsConfigured(t *testing.T) {
 			name: "IP and gRPC Host both configured",
 			cfg: &Config{
 				IP: "127.0.0.1",
-				GRPC: HostConfig{
+				GRPC: GRPCConfig{
 					Host: "localhost",
 				},
 			},
@@ -126,7 +126,7 @@ func TestMultipleHostsConfigured(t *testing.T) {
 		{
 			name: "Only RPC Host configured",
 			cfg: &Config{
-				RPC: HostConfig{
+				RPC: RPCConfig{
 					Host: "localhost",
 				},
 			},
@@ -135,7 +135,7 @@ func TestMultipleHostsConfigured(t *testing.T) {
 		{
 			name: "Only gRPC Host configured",
 			cfg: &Config{
-				GRPC: HostConfig{
+				GRPC: GRPCConfig{
 					Host: "localhost",
 				},
 			},
diff --git a/nodebuilder/core/flags.go b/nodebuilder/core/flags.go
index aada83010e..2a8a56cc84 100644
--- a/nodebuilder/core/flags.go
+++ b/nodebuilder/core/flags.go
@@ -74,6 +74,8 @@ func ParseFlags(cmd *cobra.Command, cfg *Config) error {
 	// if the flag is present, use HTTPS
 	if cmd.Flag(rpcUseHTTPS).Changed {
 		cfg.RPC.Scheme = "https"
+	} else {
+		cfg.RPC.Scheme = "http"
 	}
 
 	cfg.GRPC.Host = cmd.Flag(grpcHostFlag).Value.String()
diff --git a/nodebuilder/core/flags_test.go b/nodebuilder/core/flags_test.go
new file mode 100644
index 0000000000..a78f372b5f
--- /dev/null
+++ b/nodebuilder/core/flags_test.go
@@ -0,0 +1,92 @@
+package core
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseFlags(t *testing.T) {
+	testCases := []struct {
+		name     string
+		args     []string
+		expected Config
+	}{
+		{
+			name: "Test core.ip flag sets RPC and gRPC hosts",
+			args: []string{
+				"--core.ip=192.168.1.1",
+			},
+			expected: Config{
+				IP: "192.168.1.1",
+				RPC: RPCConfig{
+					Host:   "192.168.1.1",
+					Port:   DefaultRPCPort,
+					Scheme: DefaultRPCScheme,
+				},
+				GRPC: GRPCConfig{
+					Host: "192.168.1.1",
+					Port: DefaultGRPCPort,
+				},
+			},
+		},
+		{
+			name: "Test RPC and gRPC flags",
+			args: []string{
+				"--core.rpc.host=127.0.0.1",
+				"--core.rpc.port=26658",
+				"--core.grpc.host=127.0.0.1",
+				"--core.grpc.port=9091",
+			},
+			expected: Config{
+				RPC: RPCConfig{
+					Host:   "127.0.0.1",
+					Port:   "26658",
+					Scheme: "http",
+				},
+				GRPC: GRPCConfig{
+					Host: "127.0.0.1",
+					Port: "9091",
+				},
+			},
+		},
+		{
+			name: "Test HTTPS flag",
+			args: []string{"--core.rpc.host=127.0.0.1", "--core.rpc.https=true"},
+			expected: Config{
+				RPC: RPCConfig{
+					Host:   "127.0.0.1",
+					Port:   DefaultRPCPort, // Assuming DefaultRPCPort is defined elsewhere
+					Scheme: "https",
+				},
+				GRPC: GRPCConfig{
+					Host: "",
+					Port: DefaultGRPCPort,
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Setup Cobra command
+			cmd := &cobra.Command{
+				Use: "testCommand",
+			}
+			cmd.Flags().AddFlagSet(Flags())
+
+			// Apply flags from test case
+			err := cmd.ParseFlags(tc.args)
+			assert.NoError(t, err)
+
+			// Parse flags into config
+			var cfg Config
+			err = ParseFlags(cmd, &cfg)
+			assert.NoError(t, err)
+
+			// Assert the expected configuration
+			assert.Equal(t, tc.expected, cfg)
+		})
+	}
+}
diff --git a/nodebuilder/state/core.go b/nodebuilder/state/core.go
index 1cc1bc524f..0c3f9161fc 100644
--- a/nodebuilder/state/core.go
+++ b/nodebuilder/state/core.go
@@ -26,7 +26,6 @@ func coreAccessor(
 		corecfg.RPC.Scheme,
 		corecfg.RPCHost(),
 		corecfg.RPC.Port,
-		corecfg.GRPC.Scheme,
 		corecfg.GRPCHost(),
 		corecfg.GRPC.Port,
 	)
diff --git a/state/core_access.go b/state/core_access.go
index e47046125f..4819653af5 100644
--- a/state/core_access.go
+++ b/state/core_access.go
@@ -87,7 +87,6 @@ func NewCoreAccessor(
 	rpcScheme,
 	rpcHost,
 	rpcPort,
-	grpcScheme,
 	grpcHost,
 	grpcPort string,
 ) *CoreAccessor {
@@ -96,20 +95,14 @@ func NewCoreAccessor(
 	prt.RegisterOpDecoder(storetypes.ProofOpIAVLCommitment, storetypes.CommitmentOpDecoder)
 	prt.RegisterOpDecoder(storetypes.ProofOpSimpleMerkleCommitment, storetypes.CommitmentOpDecoder)
 	return &CoreAccessor{
-		signer: signer,
-		getter: getter,
-
-		// json rpc config
+		signer:    signer,
+		getter:    getter,
 		rpcScheme: rpcScheme,
 		rpcHost:   rpcHost,
 		rpcPort:   rpcPort,
-
-		// grpc config
-		grpcScheme: grpcScheme,
-		grpcHost:   grpcHost,
-		grpcPort:   grpcPort,
-
-		prt: prt,
+		grpcHost:  grpcHost,
+		grpcPort:  grpcPort,
+		prt:       prt,
 	}
 }
 
diff --git a/state/core_access_test.go b/state/core_access_test.go
index da3b179f70..a2effc150f 100644
--- a/state/core_access_test.go
+++ b/state/core_access_test.go
@@ -38,7 +38,7 @@ func TestSubmitPayForBlob(t *testing.T) {
 
 	signer := blobtypes.NewKeyringSigner(cctx.Keyring, accounts[0], cctx.ChainID)
 	coreIP := "127.0.0.1"
-	ca := NewCoreAccessor(signer, nil, "http", coreIP, extractPort(rpcAddr), "http", coreIP, extractPort(grpcAddr))
+	ca := NewCoreAccessor(signer, nil, "http", coreIP, extractPort(rpcAddr), coreIP, extractPort(grpcAddr))
 	// start the accessor
 	err := ca.Start(ctx)
 	require.NoError(t, err)
diff --git a/state/integration_test.go b/state/integration_test.go
index a122c7c39c..f3217814c3 100644
--- a/state/integration_test.go
+++ b/state/integration_test.go
@@ -51,7 +51,7 @@ func (s *IntegrationTestSuite) SetupSuite() {
 	s.accounts = cfg.Accounts
 
 	signer := blobtypes.NewKeyringSigner(s.cctx.Keyring, s.accounts[0], s.cctx.ChainID)
-	accessor := NewCoreAccessor(signer, localHeader{s.cctx.Client}, "", "", "", "", "", "")
+	accessor := NewCoreAccessor(signer, localHeader{s.cctx.Client}, "", "", "", "", "")
 	setClients(accessor, s.cctx.GRPCClient, s.cctx.Client)
 	s.accessor = accessor
 

From 1826c49a45da0987e910351916256d01549a0395 Mon Sep 17 00:00:00 2001
From: ramin <raminkeene@gmail.com>
Date: Tue, 19 Mar 2024 10:57:03 +0000
Subject: [PATCH 12/16] keep the scheme setting cleaner

---
 nodebuilder/core/config.go      | 5 +++++
 nodebuilder/core/config_test.go | 1 -
 nodebuilder/core/flags.go       | 3 +--
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/nodebuilder/core/config.go b/nodebuilder/core/config.go
index 8fbd6c6923..4ac8de0d34 100644
--- a/nodebuilder/core/config.go
+++ b/nodebuilder/core/config.go
@@ -98,6 +98,10 @@ func (cfg *Config) Validate() error {
 		return err
 	}
 
+	if cfg.RPC.Scheme == "" {
+		cfg.RPC.Scheme = DefaultRPCScheme
+	}
+
 	rpcHost, err := utils.ValidateAddr(cfg.RPCHost())
 	if err != nil {
 		return fmt.Errorf("nodebuilder/core: invalid rpc host: %s", err.Error())
@@ -116,6 +120,7 @@ func (cfg *Config) Validate() error {
 	if err != nil {
 		return fmt.Errorf("nodebuilder/core: invalid rpc port: %s", err.Error())
 	}
+
 	_, err = strconv.Atoi(cfg.GRPC.Port)
 	if err != nil {
 		return fmt.Errorf("nodebuilder/core: invalid grpc port: %s", err.Error())
diff --git a/nodebuilder/core/config_test.go b/nodebuilder/core/config_test.go
index 3c770d39b9..91284ccda3 100644
--- a/nodebuilder/core/config_test.go
+++ b/nodebuilder/core/config_test.go
@@ -43,7 +43,6 @@ func TestGRPCHost(t *testing.T) {
 			},
 			expected: "0.0.0.0",
 		},
-		// Add more test cases here if needed
 	}
 
 	for _, tc := range testCases {
diff --git a/nodebuilder/core/flags.go b/nodebuilder/core/flags.go
index 2a8a56cc84..7b7dc5b81c 100644
--- a/nodebuilder/core/flags.go
+++ b/nodebuilder/core/flags.go
@@ -71,11 +71,10 @@ func ParseFlags(cmd *cobra.Command, cfg *Config) error {
 	cfg.IP = cmd.Flag(coreIPFlag).Value.String()
 	cfg.RPC.Host = cmd.Flag(rpcHostFlag).Value.String()
 	cfg.RPC.Port = cmd.Flag(rpcPortFlag).Value.String()
+
 	// if the flag is present, use HTTPS
 	if cmd.Flag(rpcUseHTTPS).Changed {
 		cfg.RPC.Scheme = "https"
-	} else {
-		cfg.RPC.Scheme = "http"
 	}
 
 	cfg.GRPC.Host = cmd.Flag(grpcHostFlag).Value.String()

From bf639bd7cb49c12b9e354f1e46107bebdc0f632c Mon Sep 17 00:00:00 2001
From: ramin <raminkeene@gmail.com>
Date: Tue, 19 Mar 2024 11:00:13 +0000
Subject: [PATCH 13/16] remove unused for linter

---
 state/core_access.go | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/state/core_access.go b/state/core_access.go
index 4819653af5..2e7a8cee52 100644
--- a/state/core_access.go
+++ b/state/core_access.go
@@ -62,10 +62,8 @@ type CoreAccessor struct {
 	rpcScheme string
 	rpcHost   string
 	rpcPort   string
-
-	grpcScheme string
-	grpcHost   string
-	grpcPort   string
+	grpcHost  string
+	grpcPort  string
 
 	// these fields are mutatable and thus need to be protected by a mutex
 	lock            sync.Mutex

From b9de1357ee0a96affda5f559107054ac48fb88f5 Mon Sep 17 00:00:00 2001
From: ramin <raminkeene@gmail.com>
Date: Wed, 17 Apr 2024 23:02:42 +0100
Subject: [PATCH 14/16] fmt

---
 nodebuilder/state/core.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nodebuilder/state/core.go b/nodebuilder/state/core.go
index 2d8b7dfffc..d8b131ba74 100644
--- a/nodebuilder/state/core.go
+++ b/nodebuilder/state/core.go
@@ -29,7 +29,7 @@ func coreAccessor(
 		corecfg.RPC.Port,
 		corecfg.GRPCHost(),
 		corecfg.GRPC.Port,
-    opts...
+		opts...,
 	)
 
 	sBreaker := &modfraud.ServiceBreaker[*state.CoreAccessor, *header.ExtendedHeader]{

From 1d00494e2d00e12798832dbd171db1dc0e9cc6fc Mon Sep 17 00:00:00 2001
From: ramin <raminkeene@gmail.com>
Date: Wed, 17 Apr 2024 23:06:47 +0100
Subject: [PATCH 15/16] do not resolve to IPV4 invalidating certs

---
 libs/utils/address.go | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/libs/utils/address.go b/libs/utils/address.go
index c20d11ad06..04b1712f6f 100644
--- a/libs/utils/address.go
+++ b/libs/utils/address.go
@@ -37,9 +37,5 @@ func ValidateAddr(addr string) (string, error) {
 		return addr, nil
 	}
 
-	resolved, err := net.ResolveIPAddr("ip4", addr)
-	if err != nil {
-		return addr, err
-	}
-	return resolved.String(), nil
+	return addr, nil
 }

From 7ffb07f5a8aece865147c8db0359574bb33b8ec7 Mon Sep 17 00:00:00 2001
From: ramin <raminkeene@gmail.com>
Date: Wed, 17 Apr 2024 23:24:08 +0100
Subject: [PATCH 16/16] lookup host but not resolve to IPV4

---
 libs/utils/address.go      | 5 +++++
 libs/utils/address_test.go | 6 ------
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/libs/utils/address.go b/libs/utils/address.go
index 04b1712f6f..716c113bed 100644
--- a/libs/utils/address.go
+++ b/libs/utils/address.go
@@ -37,5 +37,10 @@ func ValidateAddr(addr string) (string, error) {
 		return addr, nil
 	}
 
+	_, err = net.LookupHost(addr)
+	if err != nil {
+		return "", err
+	}
+
 	return addr, nil
 }
diff --git a/libs/utils/address_test.go b/libs/utils/address_test.go
index 48a7747a4a..86f64792e2 100644
--- a/libs/utils/address_test.go
+++ b/libs/utils/address_test.go
@@ -1,7 +1,6 @@
 package utils
 
 import (
-	"net"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -60,11 +59,6 @@ func TestValidateAddr(t *testing.T) {
 			got, err := ValidateAddr(tt.addr)
 			require.NoError(t, err)
 
-			// validate that returned value is ip
-			if ip := net.ParseIP(got); ip == nil {
-				t.Fatalf("empty ip")
-			}
-
 			if tt.want.unresolved {
 				// unresolved addr has no addr to compare with
 				return