chore: Only return commitment on PUT for OP Generic and Simple commit…

…ment modes - update tests

server/server_test.go

@@ -242,7 +242,7 @@ func TestPutHandler(t *testing.T) {
 				mockRouter.EXPECT().Put(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return([]byte(testCommitStr), nil)
 			},
 			expectedCode:           http.StatusOK,
-			expectedBody:           opKeccakPrefix + testCommitStr,
+			expectedBody:           "",
 			expectError:            false,
 			expectedCommitmentMeta: commitments.CommitmentMeta{Mode: commitments.OptimismGeneric, CertVersion: 0},
 		},
@@ -274,9 +274,13 @@ func TestPutHandler(t *testing.T) {
 				require.NoError(t, err)
 			}
 			require.Equal(t, tt.expectedCode, rec.Code)
-			if !tt.expectError {
+			if !tt.expectError && tt.expectedBody != "" {
 				require.Equal(t, []byte(tt.expectedBody), rec.Body.Bytes())
 			}
+
+			if !tt.expectError && tt.expectedBody == "" {
+				require.Equal(t, []byte(nil), rec.Body.Bytes())
+			}
 			require.Equal(t, tt.expectedCommitmentMeta, meta)
 		})
 	}

store/eigenda.go

@@ -44,7 +44,7 @@ func NewEigenDAStore(client *clients.EigenDAClient,
 
 // Get fetches a blob from DA using certificate fields.
 // VO cert: (BatchHeaderHash, BlobIndex)
-// (TODO) V1 cert 
+// (TODO) V1 cert
 func (e EigenDAStore) Get(ctx context.Context, key []byte) ([]byte, error) {
 	var cert verify.Certificate
 	err := rlp.DecodeBytes(key, &cert)

store/router.go

@@ -25,8 +25,7 @@ type IRouter interface {
 
 // Router ... storage backend routing layer
 type Router struct {
-	log     log.Logger
-
+	log log.Logger
 
 	eigenda KeyGeneratedStore
 	s3      PrecomputedKeyStore
@@ -93,22 +92,22 @@ func (r *Router) Get(ctx context.Context, key []byte, cm commitments.CommitmentM
 		// 2 - read blob from EigenDA
 		data, err := r.eigenda.Get(ctx, key)
 		if err == nil {
-			// 2.a - verify data 
+			// 2.a - verify data
 			err = r.eigenda.Verify(key, data)
 			if err != nil {
 				return nil, err
 			}
 
-			// 2.b - write fetched blob to secondary backends for lower latency reads
-			if r.cacheEnabled() || r.fallbackEnabled() {
-				err = r.handleRedundantWrites(ctx, key, data)
+			// 2.b - write fetched blob to caches for lower latency reads
+			if r.cacheEnabled() {
+				err = r.writeToCaches(ctx, key, data)
 				if err != nil {
 					log.Error("Failed to write to redundant backends", "err", err)
 				}
 
-			return data, nil
+				return data, nil
+			}
 		}
-	}
 
 		// 3 - read blob from fallbacks if enabled and data is non-retrievable from EigenDA
 		if r.fallbackEnabled() {
@@ -156,12 +155,35 @@ func (r *Router) Put(ctx context.Context, cm commitments.CommitmentMode, key, va
 	return commit, nil
 }
 
+func (r *Router) writeToCaches(ctx context.Context, commitment, value []byte) error {
+	r.cacheLock.RLock()
+	defer r.cacheLock.RUnlock()
+
+	key := crypto.Keccak256(commitment)
+	successes := 0
+
+	for _, cache := range r.caches {
+		err := cache.Put(ctx, key, value)
+		if err != nil {
+			r.log.Warn("Failed to write to cache", "backend", cache.BackendType(), "err", err)
+		} else {
+			successes++
+		}
+	}
+
+	if successes == 0 {
+		return errors.New("failed to write blob to any redundant targets")
+	}
+
+	return nil
+}
+
 // handleRedundantWrites ... writes to both sets of backends (i.e, fallback, cache)
 // and returns an error if NONE of them succeed
 // NOTE: multi-target set writes are done at once to avoid re-invocation of the same write function at the same
 // caller step for different target sets vs. reading which is done conditionally to segment between a cached read type
 // vs a fallback read type
-func (r *Router) handleRedundantWrites(ctx context.Context, commitment []byte, value []byte) error {
+func (r *Router) handleRedundantWrites(ctx context.Context, commitment, value []byte) error {
 	r.cacheLock.RLock()
 	r.fallbackLock.RLock()