feat: Initial V2 scaffolds - working lint and tests

.vscode/launch.json

@@ -0,0 +1,21 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch Package",
+            "type": "go",
+            "request": "launch",
+            "mode": "debug",
+            "env": {
+                "ENV_PATH": "../../.env",
+                "EIGENDA_PROXY_EIGENDA_CERT_VERIFICATION_DISABLED": "true",
+                "EIGENDA_PROXY_EIGENDA_TARGET_KZG_G1_PATH": "../../resources/g1.point",
+                "EIGENDA_PROXY_EIGENDA_TARGET_KZG_G2_POWER_OF_2_PATH": "../../resources/g2.point.powerOf2"
+            },
+            "program": "cmd/server"
+        }
+    ]
+}

flags/eigendaflags/cli.go

@@ -60,7 +60,7 @@ func withEnvPrefix(envPrefix, s string) string {
 
 // CLIFlags ... used for EigenDA client configuration
 func CLIFlags(envPrefix, category string) []cli.Flag {
-	return []cli.Flag{
+	return append([]cli.Flag{
 		&cli.StringFlag{
 			Name:     DisperserRPCFlagName,
 			Usage:    "RPC endpoint of the EigenDA disperser.",
@@ -181,6 +181,13 @@ func CLIFlags(envPrefix, category string) []cli.Flag {
 			EnvVars:  []string{withEnvPrefix(envPrefix, "PUT_RETRIES")},
 			Category: category,
 		},
+	},
+		v2Flags(envPrefix, category)...,
+	)
+}
+
+func v2Flags(envPrefix, category string) []cli.Flag {
+	return []cli.Flag{
 		// EigenDA V2 specific flags //
 		&cli.BoolFlag{
 			Name:     V2Enabled,
@@ -244,13 +251,13 @@ func ReadV2DispersalConfig(ctx *cli.Context) v2_clients.PayloadDisperserConfig {
 	payCfg := readPayloadClientConfig(ctx)
 
 	return v2_clients.PayloadDisperserConfig{
-		SignerPaymentKey: ctx.String(SignerPrivateKeyHexFlagName),
+		SignerPaymentKey:    ctx.String(SignerPrivateKeyHexFlagName),
 		PayloadClientConfig: payCfg,
 		DisperseBlobTimeout: ctx.Duration(ResponseTimeoutFlagName),
 		// TODO: Explore making these user defined
 		BlobCertifiedTimeout:   time.Second * 2,
 		BlobStatusPollInterval: time.Second * 1,
-		Quorums: []uint8{0,1},
+		Quorums:                []uint8{0, 1},
 	}
 }
 

server/config.go

@@ -108,7 +108,6 @@ func (cfg *Config) Check() error {
 		if dc.EigenDACertVerifierAddr == "" {
 			return fmt.Errorf("cert verifier contract address is required for interacting with EigenDA V2")
 		}
-
 	}
 
 	return cfg.StorageConfig.Check()

server/handlers.go

@@ -209,7 +209,7 @@ func (svr *Server) handlePostShared(w http.ResponseWriter, r *http.Request, comm
 		return err
 	}
 
-	responseCommit, err := commitments.EncodeCommitment(commitment, meta.Mode, commitments.EigenDACommit(meta.Version))
+	responseCommit, err := commitments.EncodeCommitment(commitment, meta.Mode, meta.Version)
 	if err != nil {
 		err = MetaError{
 			Err:  fmt.Errorf("failed to encode commitment %v (commitment mode %v): %w", commitment, meta.Mode, err),

server/handlers_test.go

@@ -26,6 +26,10 @@ import (
 
 var (
 	testLogger = logging.NewTextSLogger(os.Stdout, &logging.SLoggerOptions{})
+	testCfg    = Config{
+		Host: "localhost",
+		Port: 0,
+	}
 )
 
 const (
@@ -98,7 +102,7 @@ func TestHandlerGet(t *testing.T) {
 			// we need to create a router through which we can pass the request.
 			r := mux.NewRouter()
 			// enable this logger to help debug tests
-			server := NewServer("localhost", 0, mockStorageMgr, testLogger, metrics.NoopMetrics)
+			server := NewServer(&testCfg, mockStorageMgr, testLogger, metrics.NoopMetrics)
 			server.registerRoutes(r)
 			r.ServeHTTP(rec, req)
 
@@ -169,7 +173,7 @@ func TestHandlerPutSuccess(t *testing.T) {
 			// we need to create a router through which we can pass the request.
 			r := mux.NewRouter()
 			// enable this logger to help debug tests
-			server := NewServer("localhost", 0, mockStorageMgr, testLogger, metrics.NoopMetrics)
+			server := NewServer(&testCfg, mockStorageMgr, testLogger, metrics.NoopMetrics)
 			server.registerRoutes(r)
 			r.ServeHTTP(rec, req)
 
@@ -254,7 +258,7 @@ func TestHandlerPutErrors(t *testing.T) {
 				// we need to create a router through which we can pass the request.
 				r := mux.NewRouter()
 				// enable this logger to help debug tests
-				server := NewServer("localhost", 0, mockStorageMgr, testLogger, metrics.NoopMetrics)
+				server := NewServer(&testCfg, mockStorageMgr, testLogger, metrics.NoopMetrics)
 				server.registerRoutes(r)
 				r.ServeHTTP(rec, req)
 

server/load_store.go

@@ -10,7 +10,7 @@ import (
 	"github.com/Layr-Labs/eigenda-proxy/metrics"
 	"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/eigenda_v2"
+	eigendav2 "github.com/Layr-Labs/eigenda-proxy/store/generated_key/eigenda_v2"
 	"github.com/Layr-Labs/eigenda-proxy/store/generated_key/memstore"
 	"github.com/Layr-Labs/eigenda-proxy/store/precomputed_key/redis"
 	"github.com/Layr-Labs/eigenda-proxy/store/precomputed_key/s3"
@@ -50,7 +50,7 @@ func loadBackends(targets []string, s3 common.PrecomputedKeyStore, redis *redis.
 			}
 			stores[i] = s3
 
-		case common.EigenDABackendType, common.MemoryBackendType:
+		case common.EigenDABackendType, common.MemoryBackendType, common.EigenDAV2BackendType:
 			panic(fmt.Sprintf("Invalid target for fallback: %s", f))
 
 		case common.UnknownBackendType:
@@ -64,7 +64,7 @@ func loadBackends(targets []string, s3 common.PrecomputedKeyStore, redis *redis.
 	return stores
 }
 
-func loadEigenDAV2Store(ctx context.Context, cfg CLIConfig, log logging.Logger) (*eigenda_v2.Store, error) {
+func loadEigenDAV2Store(ctx context.Context, cfg CLIConfig, log logging.Logger) (*eigendav2.Store, error) {
 	// TODO: Replace with real logger once dependency PRs are merged
 
 	gethCfg := geth.EthClientConfig{
@@ -113,8 +113,8 @@ func loadEigenDAV2Store(ctx context.Context, cfg CLIConfig, log logging.Logger)
 		return nil, err
 	}
 
+	// TODO: Sanitize properly
 	splits := strings.Split(cfg.EigenDAConfig.EdaV1ClientConfig.RPC, ":")
-	println(fmt.Sprintf("%v", splits))
 
 	cfg.EigenDAConfig.V2DispersalConfig.SignerPaymentKey = cfg.EigenDAConfig.EdaV1ClientConfig.SignerPrivateKeyHex
 
@@ -139,17 +139,17 @@ func loadEigenDAV2Store(ctx context.Context, cfg CLIConfig, log logging.Logger)
 		return nil, err
 	}
 
-	verifier, err := verification.NewCertVerifier(log, ethClient, cfg.EigenDAConfig.V2DispersalConfig.EigenDACertVerifierAddr, time.Second * 1)
+	verifier, err := verification.NewCertVerifier(log, ethClient, cfg.EigenDAConfig.V2DispersalConfig.EigenDACertVerifierAddr, time.Second*1)
 	if err != nil {
 		return nil, err
 	}
 
-	return eigenda_v2.NewStore(nil, &eigenda_v2.Config{
+	return eigendav2.NewStore(nil, &eigendav2.Config{
 		ServiceManagerAddr: cfg.EigenDAConfig.EdaV1ClientConfig.SvcManagerAddr,
 		MaxBlobSizeBytes:   cfg.EigenDAConfig.MemstoreConfig.MaxBlobSizeBytes,
 		StatusQueryTimeout: cfg.EigenDAConfig.EdaV1ClientConfig.StatusQueryTimeout,
 		PutRetries:         cfg.EigenDAConfig.PutRetries,
-	}, ethClient, disperser, retriever, verifier)
+	}, disperser, retriever, verifier)
 }
 
 // LoadStoreManager ... creates storage backend clients and instruments them into a storage routing abstraction
@@ -158,7 +158,7 @@ func LoadStoreManager(ctx context.Context, cfg CLIConfig, log logging.Logger, m
 	var err error
 	var s3Store *s3.Store
 	var redisStore *redis.Store
-	var eigenDAV2Store *eigenda_v2.Store
+	var eigenDAV2Store *eigendav2.Store
 
 	// TODO: Replace with real logger once dependency PRs are merged
 

server/routing_test.go

@@ -20,7 +20,7 @@ func TestRouting(t *testing.T) {
 	mockRouter := mocks.NewMockIManager(ctrl)
 
 	m := metrics.NewMetrics("default")
-	server := NewServer("localhost", 8080, mockRouter, testLogger, m)
+	server := NewServer(&testCfg, mockRouter, testLogger, m)
 	err := server.Start()
 	require.NoError(t, err)
 

server/server.go

@@ -139,7 +139,7 @@ func parseVersionByte(w http.ResponseWriter, r *http.Request) (byte, error) {
 
 	case byte(commitments.CertV1):
 		return versionByte[0], nil
-		
+
 	default:
 		http.Error(w, fmt.Sprintf("unsupported version byte %x", versionByte), http.StatusBadRequest)
 		return 0, fmt.Errorf("unsupported version byte %x", versionByte)

store/generated_key/eigenda_v2/eigenda.go

@@ -1,4 +1,4 @@
-package eigenda_v2
+package eigendav2
 
 import (
 	"context"
@@ -12,7 +12,6 @@ import (
 
 	"github.com/Layr-Labs/eigenda/api/clients/v2"
 	"github.com/Layr-Labs/eigenda/api/clients/v2/verification"
-	eigenda_common "github.com/Layr-Labs/eigenda/common"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rlp"
 )
@@ -43,9 +42,8 @@ type Store struct {
 
 var _ common.GeneratedKeyStore = (*Store)(nil)
 
-func NewStore(log log.Logger, cfg *Config, ethClient eigenda_common.EthClient,
+func NewStore(log log.Logger, cfg *Config,
 	disperser *clients.PayloadDisperser, retriever clients.PayloadRetriever, verifier verification.ICertVerifier) (*Store, error) {
-
 	return &Store{
 		log:       log,
 		cfg:       cfg,
@@ -63,7 +61,7 @@ func (e Store) Get(ctx context.Context, key []byte) ([]byte, error) {
 	if err != nil {
 		return nil, fmt.Errorf("RLP decoding EigenDA v2 cert: %w", err)
 	}
-	
+
 	payload, err := e.retriever.GetPayload(ctx, &cert)
 	if err != nil {
 		return nil, fmt.Errorf("getting payload: %w", err)
@@ -78,7 +76,7 @@ func (e Store) Get(ctx context.Context, key []byte) ([]byte, error) {
 //	Mapping status codes to 503 failover
 func (e Store) Put(ctx context.Context, value []byte) ([]byte, error) {
 	salt := uint32(0)
-	log.Info("Put EigenDA V2 backend")
+	e.log.Debug("Dispersing payload for EigenDA V2 network")
 
 	// TODO: Verify this retry or failover code for correctness against V2
 	// protocol
@@ -135,7 +133,8 @@ func (e Store) BackendType() common.BackendType {
 
 // Key is used to recover certificate fields and that verifies blob
 // against commitment to ensure data is valid and non-tampered.
-func (e Store) Verify(ctx context.Context, key []byte, value []byte) error {
+// TODO: tap into actual verification
+func (e Store) Verify(_ context.Context, _ []byte, _ []byte) error {
 	// var cert verification.EigenDACert
 	// err := rlp.DecodeBytes(key, cert)
 	// if err != nil {

store/manager.go

@@ -74,7 +74,6 @@ func (m *Manager) Get(ctx context.Context, key []byte, cm commitments.Commitment
 			return nil, errors.New("expected EigenDA backend for DA commitment type, but none configured")
 		}
 
-
 		var err error
 		var data []byte
 
@@ -89,32 +88,14 @@ func (m *Manager) Get(ctx context.Context, key []byte, cm commitments.Commitment
 			m.log.Warn("Failed to read from cache targets", "err", err)
 		}
 
-		if version == commitments.CertV0 {
-			m.log.Debug("Reading blob from EigenDA")
-			// 2 - read blob from EigenDA v1
-			data, err := m.eigenda.Get(ctx, key)
-			if err == nil {
-				// verify v1 (payload, cert)
-				err = m.eigenda.Verify(ctx, key, data)
-				if err != nil {
-					return nil, err
-				}
-				return data, nil
-			}
-		} else if version == commitments.CertV1 {
-			m.log.Debug("Reading blob from EigenDAV2")
-			data, err := m.eigendaV2.Get(ctx, key)
-			if err == nil {
-				// verify v2 (payload, cert)
-				err = m.eigendaV2.Verify(ctx, key, data)
-				if err != nil {
-					return nil, err
-				}
-				m.log.Debug(fmt.Sprintf("%s", data))
-				return data, nil
-			}
+		// 2 - read blob from EigenDA
+		data, err = m.getEigenDAMode(ctx, version, data)
+		if err == nil {
+			return data, nil
 		}
 
+		m.log.Error(err.Error())
+
 		// 3 - read blob from fallbacks if enabled and data is non-retrievable from EigenDA
 		if m.secondary.FallbackEnabled() {
 			data, err = m.secondary.MultiSourceRead(ctx, key, true, m.eigenda.Verify)
@@ -187,6 +168,41 @@ func (m *Manager) putEigenDAMode(ctx context.Context, value []byte) ([]byte, err
 	return nil, errors.New("no DA storage backend found")
 }
 
+func (m *Manager) getEigenDAMode(ctx context.Context, v commitments.EigenDACommit, key []byte) ([]byte, error) {
+	switch v {
+	case commitments.CertV0:
+		m.log.Debug("Reading blob from EigenDAV1 backend")
+		data, err := m.eigenda.Get(ctx, key)
+		if err == nil {
+			// verify v1 (payload, cert)
+			err = m.eigenda.Verify(ctx, key, data)
+			if err != nil {
+				return nil, err
+			}
+			return data, nil
+		}
+
+		return nil, err
+
+	case commitments.CertV1:
+		m.log.Debug("Reading blob from EigenDAV2 backend")
+		data, err := m.eigendaV2.Get(ctx, key)
+		if err == nil {
+			// verify v2 (payload, cert)
+			err = m.eigendaV2.Verify(ctx, key, data)
+			if err != nil {
+				return nil, err
+			}
+			return data, nil
+		}
+
+		return nil, err
+
+	default:
+		return nil, fmt.Errorf("commitment version unknown: %b", v)
+	}
+}
+
 // putKeccak256Mode ... put blob into S3 compatible backend
 func (m *Manager) putKeccak256Mode(ctx context.Context, key []byte, value []byte) ([]byte, error) {
 	if m.s3 == nil {