refactor: move config back to server package + rename cli->flags

cmd/server/entrypoint.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"fmt"
 
-	proxycli "github.com/Layr-Labs/eigenda-proxy/cli"
+	"github.com/Layr-Labs/eigenda-proxy/flags"
 	"github.com/Layr-Labs/eigenda-proxy/metrics"
 	"github.com/Layr-Labs/eigenda-proxy/server"
 	"github.com/urfave/cli/v2"
@@ -18,7 +18,7 @@ func StartProxySvr(cliCtx *cli.Context) error {
 	oplog.SetGlobalLogHandler(log.Handler())
 	log.Info("Starting EigenDA Proxy Server", "version", Version, "date", Date, "commit", Commit)
 
-	cfg := proxycli.ReadCLIConfig(cliCtx)
+	cfg := server.ReadCLIConfig(cliCtx)
 	if err := cfg.Check(); err != nil {
 		return err
 	}
@@ -32,7 +32,7 @@ func StartProxySvr(cliCtx *cli.Context) error {
 		return fmt.Errorf("failed to create store: %w", err)
 	}
 	m := metrics.NewMetrics("default")
-	server := server.NewServer(cliCtx.String(proxycli.ListenAddrFlagName), cliCtx.Int(proxycli.PortFlagName), daRouter, log, m)
+	server := server.NewServer(cliCtx.String(flags.ListenAddrFlagName), cliCtx.Int(flags.PortFlagName), daRouter, log, m)
 
 	if err := server.Start(); err != nil {
 		return fmt.Errorf("failed to start the DA server: %w", err)

cmd/server/main.go

@@ -8,7 +8,7 @@ import (
 	"github.com/joho/godotenv"
 	"github.com/urfave/cli/v2"
 
-	proxycli "github.com/Layr-Labs/eigenda-proxy/cli"
+	"github.com/Layr-Labs/eigenda-proxy/flags"
 	"github.com/Layr-Labs/eigenda-proxy/metrics"
 	"github.com/ethereum-optimism/optimism/op-service/cliapp"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
@@ -26,7 +26,7 @@ func main() {
 	oplog.SetupDefaults()
 
 	app := cli.NewApp()
-	app.Flags = cliapp.ProtectFlags(proxycli.Flags)
+	app.Flags = cliapp.ProtectFlags(flags.Flags)
 	app.Version = Version
 	app.Name = "eigenda-proxy"
 	app.Usage = "EigenDA Proxy Sidecar Service"

e2e/setup.go

@@ -7,7 +7,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/Layr-Labs/eigenda-proxy/cli"
 	"github.com/Layr-Labs/eigenda-proxy/metrics"
 	"github.com/Layr-Labs/eigenda-proxy/server"
 	"github.com/Layr-Labs/eigenda-proxy/store/precomputed_key/redis"
@@ -54,20 +53,20 @@ func TestConfig(useMemory bool) *Cfg {
 	}
 }
 
-func createRedisConfig(eigendaCfg cli.Config) cli.CLIConfig {
+func createRedisConfig(eigendaCfg server.Config) server.CLIConfig {
 	eigendaCfg.RedisConfig = redis.Config{
 		Endpoint: "127.0.0.1:9001",
 		Password: "",
 		DB:       0,
 		Eviction: 10 * time.Minute,
 		Profile:  true,
 	}
-	return cli.CLIConfig{
+	return server.CLIConfig{
 		EigenDAConfig: eigendaCfg,
 	}
 }
 
-func createS3Config(eigendaCfg cli.Config) cli.CLIConfig {
+func createS3Config(eigendaCfg server.Config) server.CLIConfig {
 	// generate random string
 	bucketName := "eigenda-proxy-test-" + RandString(10)
 	createS3Bucket(bucketName)
@@ -82,12 +81,12 @@ func createS3Config(eigendaCfg cli.Config) cli.CLIConfig {
 		S3CredentialType: s3.CredentialTypeStatic,
 		Backup:           false,
 	}
-	return cli.CLIConfig{
+	return server.CLIConfig{
 		EigenDAConfig: eigendaCfg,
 	}
 }
 
-func TestSuiteConfig(t *testing.T, testCfg *Cfg) cli.CLIConfig {
+func TestSuiteConfig(t *testing.T, testCfg *Cfg) server.CLIConfig {
 	// load signer key from environment
 	pk := os.Getenv(privateKey)
 	if pk == "" && !testCfg.UseMemory {
@@ -107,7 +106,7 @@ func TestSuiteConfig(t *testing.T, testCfg *Cfg) cli.CLIConfig {
 		pollInterval = time.Minute * 1
 	}
 
-	eigendaCfg := cli.Config{
+	eigendaCfg := server.Config{
 		ClientConfig: clients.EigenDAClientConfig{
 			RPC:                      holeskyDA,
 			StatusQueryTimeout:       time.Minute * 45,
@@ -131,7 +130,7 @@ func TestSuiteConfig(t *testing.T, testCfg *Cfg) cli.CLIConfig {
 		eigendaCfg.ClientConfig.SignerPrivateKeyHex = "0000000000000000000100000000000000000000000000000000000000000000"
 	}
 
-	var cfg cli.CLIConfig
+	var cfg server.CLIConfig
 	switch {
 	case testCfg.UseKeccak256ModeS3:
 		cfg = createS3Config(eigendaCfg)
@@ -149,7 +148,7 @@ func TestSuiteConfig(t *testing.T, testCfg *Cfg) cli.CLIConfig {
 		cfg = createRedisConfig(eigendaCfg)
 
 	default:
-		cfg = cli.CLIConfig{
+		cfg = server.CLIConfig{
 			EigenDAConfig: eigendaCfg,
 			MetricsCfg:    opmetrics.CLIConfig{},
 		}
@@ -164,7 +163,7 @@ type TestSuite struct {
 	Server *server.Server
 }
 
-func CreateTestSuite(t *testing.T, testSuiteCfg cli.CLIConfig) (TestSuite, func()) {
+func CreateTestSuite(t *testing.T, testSuiteCfg server.CLIConfig) (TestSuite, func()) {
 	log := oplog.NewLogger(os.Stdout, oplog.CLIConfig{
 		Level:  log.LevelDebug,
 		Format: oplog.FormatLogFmt,

cli/flags.go → flags/flags.go

@@ -1,4 +1,4 @@
-package cli
+package flags
 
 import (
 	"time"
@@ -323,24 +323,3 @@ func init() {
 	Flags = append(Flags, oplog.CLIFlags(EnvVarPrefix)...)
 	Flags = append(Flags, opmetrics.CLIFlags(EnvVarPrefix)...)
 }
-
-type CLIConfig struct {
-	EigenDAConfig Config
-	MetricsCfg    opmetrics.CLIConfig
-}
-
-func ReadCLIConfig(ctx *cli.Context) CLIConfig {
-	config := ReadConfig(ctx)
-	return CLIConfig{
-		EigenDAConfig: config,
-		MetricsCfg:    opmetrics.ReadCLIConfig(ctx),
-	}
-}
-
-func (c CLIConfig) Check() error {
-	err := c.EigenDAConfig.Check()
-	if err != nil {
-		return err
-	}
-	return nil
-}

cli/config.go → server/config.go

@@ -1,4 +1,4 @@
-package cli
+package server
 
 import (
 	"fmt"
@@ -7,6 +7,7 @@ import (
 
 	"github.com/urfave/cli/v2"
 
+	"github.com/Layr-Labs/eigenda-proxy/flags"
 	"github.com/Layr-Labs/eigenda-proxy/store"
 	"github.com/Layr-Labs/eigenda-proxy/store/precomputed_key/redis"
 	"github.com/Layr-Labs/eigenda-proxy/store/precomputed_key/s3"
@@ -15,6 +16,8 @@ import (
 	"github.com/Layr-Labs/eigenda/api/clients"
 	"github.com/Layr-Labs/eigenda/api/clients/codecs"
 	"github.com/Layr-Labs/eigenda/encoding/kzg"
+
+	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
 )
 
 const (
@@ -114,46 +117,46 @@ func (cfg *Config) VerificationCfg() *verify.Config {
 func ReadConfig(ctx *cli.Context) Config {
 	cfg := Config{
 		RedisConfig: redis.Config{
-			Endpoint: ctx.String(RedisEndpointFlagName),
-			Password: ctx.String(RedisPasswordFlagName),
-			DB:       ctx.Int(RedisDBFlagName),
-			Eviction: ctx.Duration(RedisEvictionFlagName),
+			Endpoint: ctx.String(flags.RedisEndpointFlagName),
+			Password: ctx.String(flags.RedisPasswordFlagName),
+			DB:       ctx.Int(flags.RedisDBFlagName),
+			Eviction: ctx.Duration(flags.RedisEvictionFlagName),
 		},
 		S3Config: s3.Config{
-			S3CredentialType: s3.StringToCredentialType(ctx.String(S3CredentialTypeFlagName)),
-			Bucket:           ctx.String(S3BucketFlagName),
-			Path:             ctx.String(S3PathFlagName),
-			Endpoint:         ctx.String(S3EndpointFlagName),
-			AccessKeyID:      ctx.String(S3AccessKeyIDFlagName),
-			AccessKeySecret:  ctx.String(S3AccessKeySecretFlagName),
-			Backup:           ctx.Bool(S3BackupFlagName),
-			Timeout:          ctx.Duration(S3TimeoutFlagName),
+			S3CredentialType: s3.StringToCredentialType(ctx.String(flags.S3CredentialTypeFlagName)),
+			Bucket:           ctx.String(flags.S3BucketFlagName),
+			Path:             ctx.String(flags.S3PathFlagName),
+			Endpoint:         ctx.String(flags.S3EndpointFlagName),
+			AccessKeyID:      ctx.String(flags.S3AccessKeyIDFlagName),
+			AccessKeySecret:  ctx.String(flags.S3AccessKeySecretFlagName),
+			Backup:           ctx.Bool(flags.S3BackupFlagName),
+			Timeout:          ctx.Duration(flags.S3TimeoutFlagName),
 		},
 		ClientConfig: clients.EigenDAClientConfig{
-			RPC:                          ctx.String(EigenDADisperserRPCFlagName),
-			StatusQueryRetryInterval:     ctx.Duration(StatusQueryRetryIntervalFlagName),
-			StatusQueryTimeout:           ctx.Duration(StatusQueryTimeoutFlagName),
-			DisableTLS:                   ctx.Bool(DisableTLSFlagName),
-			ResponseTimeout:              ctx.Duration(ResponseTimeoutFlagName),
-			CustomQuorumIDs:              ctx.UintSlice(CustomQuorumIDsFlagName),
-			SignerPrivateKeyHex:          ctx.String(SignerPrivateKeyHexFlagName),
-			PutBlobEncodingVersion:       codecs.BlobEncodingVersion(ctx.Uint(PutBlobEncodingVersionFlagName)),
-			DisablePointVerificationMode: ctx.Bool(DisablePointVerificationModeFlagName),
+			RPC:                          ctx.String(flags.EigenDADisperserRPCFlagName),
+			StatusQueryRetryInterval:     ctx.Duration(flags.StatusQueryRetryIntervalFlagName),
+			StatusQueryTimeout:           ctx.Duration(flags.StatusQueryTimeoutFlagName),
+			DisableTLS:                   ctx.Bool(flags.DisableTLSFlagName),
+			ResponseTimeout:              ctx.Duration(flags.ResponseTimeoutFlagName),
+			CustomQuorumIDs:              ctx.UintSlice(flags.CustomQuorumIDsFlagName),
+			SignerPrivateKeyHex:          ctx.String(flags.SignerPrivateKeyHexFlagName),
+			PutBlobEncodingVersion:       codecs.BlobEncodingVersion(ctx.Uint(flags.PutBlobEncodingVersionFlagName)),
+			DisablePointVerificationMode: ctx.Bool(flags.DisablePointVerificationModeFlagName),
 		},
-		G1Path:                  ctx.String(G1PathFlagName),
-		G2PowerOfTauPath:        ctx.String(G2TauFlagName),
-		CacheDir:                ctx.String(CachePathFlagName),
-		MaxBlobLength:           ctx.String(MaxBlobLengthFlagName),
-		CertVerificationEnabled: ctx.Bool(CertVerificationEnabledFlagName),
-		SvcManagerAddr:          ctx.String(SvcManagerAddrFlagName),
-		EthRPC:                  ctx.String(EthRPCFlagName),
-		EthConfirmationDepth:    ctx.Int64(EthConfirmationDepthFlagName),
-		MemstoreEnabled:         ctx.Bool(MemstoreFlagName),
-		MemstoreBlobExpiration:  ctx.Duration(MemstoreExpirationFlagName),
-		MemstoreGetLatency:      ctx.Duration(MemstoreGetLatencyFlagName),
-		MemstorePutLatency:      ctx.Duration(MemstorePutLatencyFlagName),
-		FallbackTargets:         ctx.StringSlice(FallbackTargetsFlagName),
-		CacheTargets:            ctx.StringSlice(CacheTargetsFlagName),
+		G1Path:                  ctx.String(flags.G1PathFlagName),
+		G2PowerOfTauPath:        ctx.String(flags.G2TauFlagName),
+		CacheDir:                ctx.String(flags.CachePathFlagName),
+		MaxBlobLength:           ctx.String(flags.MaxBlobLengthFlagName),
+		CertVerificationEnabled: ctx.Bool(flags.CertVerificationEnabledFlagName),
+		SvcManagerAddr:          ctx.String(flags.SvcManagerAddrFlagName),
+		EthRPC:                  ctx.String(flags.EthRPCFlagName),
+		EthConfirmationDepth:    ctx.Int64(flags.EthConfirmationDepthFlagName),
+		MemstoreEnabled:         ctx.Bool(flags.MemstoreFlagName),
+		MemstoreBlobExpiration:  ctx.Duration(flags.MemstoreExpirationFlagName),
+		MemstoreGetLatency:      ctx.Duration(flags.MemstoreGetLatencyFlagName),
+		MemstorePutLatency:      ctx.Duration(flags.MemstorePutLatencyFlagName),
+		FallbackTargets:         ctx.StringSlice(flags.FallbackTargetsFlagName),
+		CacheTargets:            ctx.StringSlice(flags.CacheTargetsFlagName),
 	}
 	// the eigenda client can only wait for 0 confirmations or finality
 	// the da-proxy has a more fine-grained notion of confirmation depth
@@ -248,3 +251,24 @@ func (cfg *Config) Check() error {
 
 	return nil
 }
+
+type CLIConfig struct {
+	EigenDAConfig Config
+	MetricsCfg    opmetrics.CLIConfig
+}
+
+func ReadCLIConfig(ctx *cli.Context) CLIConfig {
+	config := ReadConfig(ctx)
+	return CLIConfig{
+		EigenDAConfig: config,
+		MetricsCfg:    opmetrics.ReadCLIConfig(ctx),
+	}
+}
+
+func (c CLIConfig) Check() error {
+	err := c.EigenDAConfig.Check()
+	if err != nil {
+		return err
+	}
+	return nil
+}

cli/config_test.go → server/config_test.go

@@ -1,4 +1,4 @@
-package cli
+package server
 
 import (
 	"testing"

server/load_store.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/Layr-Labs/eigenda-proxy/cli"
 	"github.com/Layr-Labs/eigenda-proxy/store"
 	"github.com/Layr-Labs/eigenda-proxy/store/generated_key/eigenda"
 	"github.com/Layr-Labs/eigenda-proxy/store/generated_key/memstore"
@@ -44,7 +43,7 @@ func populateTargets(targets []string, s3 store.PrecomputedKeyStore, redis *redi
 }
 
 // LoadStoreRouter ... creates storage backend clients and instruments them into a storage routing abstraction
-func LoadStoreRouter(ctx context.Context, cfg cli.CLIConfig, log log.Logger) (store.IRouter, error) {
+func LoadStoreRouter(ctx context.Context, cfg CLIConfig, log log.Logger) (store.IRouter, error) {
 	// create S3 backend store (if enabled)
 	var err error
 	var s3Store store.PrecomputedKeyStore