Get blob fulu (#15610)

* wip * wip * adding ssz marshalling * updating function for readability * adding unit tests and fixing ssz * gaz * linting * fixing test * wip * fixing mock blocker * fixing test * fixing tests and handler * updating unit test for more coverage * adding some comments * self review * gofmt * updating and consolidating tests * moving functional options so it can be used properly * gofmt * more missed gofmt * Update beacon-chain/rpc/endpoints.go Co-authored-by: Radosław Kapka <rkapka@wp.pl> * Update beacon-chain/rpc/lookup/blocker.go Co-authored-by: Radosław Kapka <rkapka@wp.pl> * Update beacon-chain/rpc/eth/beacon/handlers.go Co-authored-by: Radosław Kapka <rkapka@wp.pl> * radek feedback * fixing tests * fixing test * moving endpoint in test * removed unneeded comment * fixing linting from latest develop merge * fixing linting from latest develop merge * Update beacon-chain/rpc/eth/blob/handlers.go Co-authored-by: Radosław Kapka <rkapka@wp.pl> * Update beacon-chain/rpc/eth/blob/handlers.go Co-authored-by: Radosław Kapka <rkapka@wp.pl> * reverting change * reverting change * adding in better error for which hashes are missing * Update beacon-chain/rpc/lookup/blocker.go Co-authored-by: Radosław Kapka <rkapka@wp.pl> * fixing unit test * gofmt --------- Co-authored-by: Radosław Kapka <rkapka@wp.pl>
2026-01-08 23:18:15 -05:00 · 2025-09-17 10:42:25 -05:00
parent a1be3d68cd
commit 7e32bbc199
14 changed files with 958 additions and 29 deletions
--- a/api/server/structs/endpoints_beacon.go
+++ b/api/server/structs/endpoints_beacon.go
@@ -290,3 +290,9 @@ type GetProposerLookaheadResponse struct {
 	Finalized           bool     `json:"finalized"`
 	Data                []string `json:"data"` // validator indexes
 }
+
+type GetBlobsResponse struct {
+	ExecutionOptimistic bool     `json:"execution_optimistic"`
+	Finalized           bool     `json:"finalized"`
+	Data                []string `json:"data"` //blobs
+}
--- a/beacon-chain/rpc/endpoints.go
+++ b/beacon-chain/rpc/endpoints.go
@@ -194,6 +194,8 @@ func (s *Service) blobEndpoints(blocker lookup.Blocker) []endpoint {
 	const namespace = "blob"
 	return []endpoint{
 		{
+			// Deprecated: /eth/v1/beacon/blob_sidecars/{block_id} in favor of /eth/v1/beacon/blobs/{block_id}
+			// the endpoint will continue to work post fulu for some time however
 			template: "/eth/v1/beacon/blob_sidecars/{block_id}",
 			name:     namespace + ".Blobs",
 			middleware: []middleware.Middleware{
@@ -203,6 +205,16 @@ func (s *Service) blobEndpoints(blocker lookup.Blocker) []endpoint {
 			handler: server.Blobs,
 			methods: []string{http.MethodGet},
 		},
+		{
+			template: "/eth/v1/beacon/blobs/{block_id}",
+			name:     namespace + ".GetBlobs",
+			middleware: []middleware.Middleware{
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
+				middleware.AcceptEncodingHeaderHandler(),
+			},
+			handler: server.GetBlobs,
+			methods: []string{http.MethodGet},
+		},
 	}
 }

--- a/beacon-chain/rpc/endpoints_test.go
+++ b/beacon-chain/rpc/endpoints_test.go
@@ -70,6 +70,7 @@ func Test_endpoints(t *testing.T) {

 	blobRoutes := map[string][]string{
 		"/eth/v1/beacon/blob_sidecars/{block_id}": {http.MethodGet},
+		"/eth/v1/beacon/blobs/{block_id}":         {http.MethodGet},
 	}

 	configRoutes := map[string][]string{
--- a/beacon-chain/rpc/eth/blob/BUILD.bazel
+++ b/beacon-chain/rpc/eth/blob/BUILD.bazel
@@ -13,7 +13,9 @@ go_library(
        "//api/server/structs:go_default_library",
        "//beacon-chain/blockchain:go_default_library",
        "//beacon-chain/rpc/core:go_default_library",
+        "//beacon-chain/rpc/eth/shared:go_default_library",
        "//beacon-chain/rpc/lookup:go_default_library",
+        "//beacon-chain/rpc/options:go_default_library",
        "//config/fieldparams:go_default_library",
        "//config/params:go_default_library",
        "//consensus-types/blocks:go_default_library",
@@ -33,6 +35,7 @@ go_test(
    deps = [
        "//api:go_default_library",
        "//api/server/structs:go_default_library",
+        "//beacon-chain/blockchain/kzg:go_default_library",
        "//beacon-chain/blockchain/testing:go_default_library",
        "//beacon-chain/db/filesystem:go_default_library",
        "//beacon-chain/db/testing:go_default_library",
@@ -41,6 +44,7 @@ go_test(
        "//beacon-chain/verification:go_default_library",
        "//config/fieldparams:go_default_library",
        "//config/params:go_default_library",
+        "//consensus-types/primitives:go_default_library",
        "//network/httputil:go_default_library",
        "//proto/prysm/v1alpha1:go_default_library",
        "//runtime/version:go_default_library",
--- a/beacon-chain/rpc/eth/blob/handlers.go
+++ b/beacon-chain/rpc/eth/blob/handlers.go
@@ -10,7 +10,9 @@ import (
 	"github.com/OffchainLabs/prysm/v6/api"
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/core"
-	field_params "github.com/OffchainLabs/prysm/v6/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/eth/shared"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/options"
+	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
@@ -22,6 +24,8 @@ import (
 )

 // Blobs is an HTTP handler for Beacon API getBlobs.
+// Deprecated: /eth/v1/beacon/blob_sidecars/{block_id} in favor of /eth/v1/beacon/blobs/{block_id}
+// the endpoint will continue to work post fulu for some time however
 func (s *Server) Blobs(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.Blobs")
 	defer span.End()
@@ -34,7 +38,7 @@ func (s *Server) Blobs(w http.ResponseWriter, r *http.Request) {
 	segments := strings.Split(r.URL.Path, "/")
 	blockId := segments[len(segments)-1]

-	verifiedBlobs, rpcErr := s.Blocker.Blobs(ctx, blockId, indices)
+	verifiedBlobs, rpcErr := s.Blocker.Blobs(ctx, blockId, options.WithIndices(indices))
 	if rpcErr != nil {
 		code := core.ErrorReasonToHTTP(rpcErr.Reason)
 		switch code {
@@ -127,6 +131,94 @@ loop:
 	return indices, nil
 }

+// GetBlobs retrieves blobs for a given block id. ( this is the new handler that replaces func (s *Server) Blobs )
+func (s *Server) GetBlobs(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "beacon.GetBlobs")
+	defer span.End()
+
+	segments := strings.Split(r.URL.Path, "/")
+	blockId := segments[len(segments)-1]
+
+	var verifiedBlobs []*blocks.VerifiedROBlob
+	var rpcErr *core.RpcError
+
+	// Check if versioned_hashes parameter is provided
+	versionedHashesStr := r.URL.Query()["versioned_hashes"]
+	versionedHashes := make([][]byte, len(versionedHashesStr))
+	if len(versionedHashesStr) > 0 {
+		for i, hashStr := range versionedHashesStr {
+			hash, ok := shared.ValidateHex(w, fmt.Sprintf("versioned_hashes[%d]", i), hashStr, 32)
+			if !ok {
+				return
+			}
+			versionedHashes[i] = hash
+		}
+	}
+	verifiedBlobs, rpcErr = s.Blocker.Blobs(ctx, blockId, options.WithVersionedHashes(versionedHashes))
+	if rpcErr != nil {
+		code := core.ErrorReasonToHTTP(rpcErr.Reason)
+		switch code {
+		case http.StatusBadRequest:
+			httputil.HandleError(w, "Bad Request: "+rpcErr.Err.Error(), code)
+			return
+		case http.StatusNotFound:
+			httputil.HandleError(w, "Not found: "+rpcErr.Err.Error(), code)
+			return
+		case http.StatusInternalServerError:
+			httputil.HandleError(w, "Internal server error: "+rpcErr.Err.Error(), code)
+			return
+		default:
+			httputil.HandleError(w, rpcErr.Err.Error(), code)
+			return
+		}
+	}
+
+	blk, err := s.Blocker.Block(ctx, []byte(blockId))
+	if err != nil {
+		httputil.HandleError(w, "Could not fetch block: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if blk == nil {
+		httputil.HandleError(w, "Block not found", http.StatusNotFound)
+		return
+	}
+
+	if httputil.RespondWithSsz(r) {
+		sszLen := fieldparams.BlobSize
+		sszData := make([]byte, len(verifiedBlobs)*sszLen)
+		for i := range verifiedBlobs {
+			copy(sszData[i*sszLen:(i+1)*sszLen], verifiedBlobs[i].Blob)
+		}
+
+		w.Header().Set(api.VersionHeader, version.String(blk.Version()))
+		httputil.WriteSsz(w, sszData)
+		return
+	}
+
+	blkRoot, err := blk.Block().HashTreeRoot()
+	if err != nil {
+		httputil.HandleError(w, "Could not hash block: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	isOptimistic, err := s.OptimisticModeFetcher.IsOptimisticForRoot(ctx, blkRoot)
+	if err != nil {
+		httputil.HandleError(w, "Could not check if block is optimistic: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	data := make([]string, len(verifiedBlobs))
+	for i, v := range verifiedBlobs {
+		data[i] = hexutil.Encode(v.Blob)
+	}
+	resp := &structs.GetBlobsResponse{
+		Data:                data,
+		ExecutionOptimistic: isOptimistic,
+		Finalized:           s.FinalizationFetcher.IsFinalized(ctx, blkRoot),
+	}
+	w.Header().Set(api.VersionHeader, version.String(blk.Version()))
+	httputil.WriteJson(w, resp)
+}
+
 func buildSidecarsJsonResponse(verifiedBlobs []*blocks.VerifiedROBlob) []*structs.Sidecar {
 	sidecars := make([]*structs.Sidecar, len(verifiedBlobs))
 	for i, sc := range verifiedBlobs {
@@ -147,13 +239,13 @@ func buildSidecarsJsonResponse(verifiedBlobs []*blocks.VerifiedROBlob) []*struct
 }

 func buildSidecarsSSZResponse(verifiedBlobs []*blocks.VerifiedROBlob) ([]byte, error) {
-	ssz := make([]byte, field_params.BlobSidecarSize*len(verifiedBlobs))
+	ssz := make([]byte, fieldparams.BlobSidecarSize*len(verifiedBlobs))
 	for i, sidecar := range verifiedBlobs {
 		sszrep, err := sidecar.MarshalSSZ()
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to marshal sidecar ssz")
 		}
-		copy(ssz[i*field_params.BlobSidecarSize:(i+1)*field_params.BlobSidecarSize], sszrep)
+		copy(ssz[i*fieldparams.BlobSidecarSize:(i+1)*fieldparams.BlobSidecarSize], sszrep)
 	}
 	return ssz, nil
 }
--- a/beacon-chain/rpc/eth/blob/handlers_test.go
+++ b/beacon-chain/rpc/eth/blob/handlers_test.go
@@ -14,6 +14,7 @@ import (

 	"github.com/OffchainLabs/prysm/v6/api"
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	mockChain "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
@@ -22,6 +23,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/network/httputil"
 	eth "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
@@ -278,7 +280,7 @@ func TestBlobs(t *testing.T) {
 		assert.Equal(t, http.StatusBadRequest, e.Code)
 		assert.Equal(t, true, strings.Contains(e.Message, fmt.Sprintf("requested blob indices [%d] are invalid", overLimit)))
 	})
-	t.Run("outside retention period returns 200 w/ empty list ", func(t *testing.T) {
+	t.Run("outside retention period returns 200 with what we have", func(t *testing.T) {
 		u := "http://foo.example/123"
 		request := httptest.NewRequest("GET", u, nil)
 		writer := httptest.NewRecorder()
@@ -296,7 +298,7 @@ func TestBlobs(t *testing.T) {
 		assert.Equal(t, http.StatusOK, writer.Code)
 		resp := &structs.SidecarsResponse{}
 		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		require.Equal(t, 0, len(resp.Data))
+		require.Equal(t, 4, len(resp.Data))

 		require.Equal(t, "deneb", resp.Version)
 		require.Equal(t, false, resp.ExecutionOptimistic)
@@ -558,7 +560,573 @@ func Test_parseIndices(t *testing.T) {
 	}
 }

+func TestGetBlobs(t *testing.T) {
+	// Start the trusted setup for KZG operations (needed for data columns)
+	require.NoError(t, kzg.Start())
+
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.DenebForkEpoch = 1
+	cfg.ElectraForkEpoch = 10
+	cfg.FuluForkEpoch = 20
+	cfg.BlobSchedule = []params.BlobScheduleEntry{
+		{Epoch: 0, MaxBlobsPerBlock: 0},
+		{Epoch: 1, MaxBlobsPerBlock: 6},   // Deneb
+		{Epoch: 10, MaxBlobsPerBlock: 9},  // Electra
+		{Epoch: 20, MaxBlobsPerBlock: 12}, // Fulu
+	}
+	params.OverrideBeaconConfig(cfg)
+
+	db := testDB.SetupDB(t)
+	denebBlock, blobs := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 123, 4)
+	require.NoError(t, db.SaveBlock(t.Context(), denebBlock))
+	bs := filesystem.NewEphemeralBlobStorage(t)
+	testSidecars := verification.FakeVerifySliceForTest(t, blobs)
+	for i := range testSidecars {
+		require.NoError(t, bs.Save(testSidecars[i]))
+	}
+	blockRoot := blobs[0].BlockRoot()
+
+	mockChainService := &mockChain.ChainService{
+		FinalizedRoots: map[[32]byte]bool{},
+		Genesis:        time.Now().Add(-time.Duration(uint64(params.BeaconConfig().SlotsPerEpoch)*uint64(params.BeaconConfig().DenebForkEpoch)*params.BeaconConfig().SecondsPerSlot) * time.Second),
+	}
+	s := &Server{
+		OptimisticModeFetcher: mockChainService,
+		FinalizationFetcher:   mockChainService,
+		TimeFetcher:           mockChainService,
+	}
+
+	t.Run("genesis", func(t *testing.T) {
+		u := "http://foo.example/genesis"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusBadRequest, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusBadRequest, e.Code)
+		assert.StringContains(t, "blobs are not supported for Phase 0 fork", e.Message)
+	})
+	t.Run("head", func(t *testing.T) {
+		u := "http://foo.example/head"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{Root: blockRoot[:], Block: denebBlock},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 4, len(resp.Data))
+		blob := resp.Data[0]
+		require.NotNil(t, blob)
+		assert.Equal(t, hexutil.Encode(blobs[0].Blob), blob)
+		blob = resp.Data[1]
+		require.NotNil(t, blob)
+		assert.Equal(t, hexutil.Encode(blobs[1].Blob), blob)
+		blob = resp.Data[2]
+		require.NotNil(t, blob)
+		assert.Equal(t, hexutil.Encode(blobs[2].Blob), blob)
+		blob = resp.Data[3]
+		require.NotNil(t, blob)
+		assert.Equal(t, hexutil.Encode(blobs[3].Blob), blob)
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
+	})
+	t.Run("finalized", func(t *testing.T) {
+		u := "http://foo.example/finalized"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}, Block: denebBlock},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 4, len(resp.Data))
+
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
+	})
+	t.Run("root", func(t *testing.T) {
+		u := "http://foo.example/" + hexutil.Encode(blockRoot[:])
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{Block: denebBlock},
+			BeaconDB:         db,
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 4, len(resp.Data))
+
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
+	})
+	t.Run("slot", func(t *testing.T) {
+		u := "http://foo.example/123"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{Block: denebBlock},
+			BeaconDB:         db,
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 4, len(resp.Data))
+
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
+	})
+	t.Run("slot not found", func(t *testing.T) {
+		u := "http://foo.example/122"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{Block: denebBlock},
+			BeaconDB:         db,
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusNotFound, writer.Code)
+	})
+	t.Run("no blobs returns an empty array", func(t *testing.T) {
+		u := "http://foo.example/123"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}, Block: denebBlock},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: filesystem.NewEphemeralBlobStorage(t), // new ephemeral storage
+		}
+
+		s.GetBlobs(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, len(resp.Data), 0)
+
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
+	})
+	t.Run("outside retention period still returns 200 what we have in db ", func(t *testing.T) {
+		u := "http://foo.example/123"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		moc := &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}, Block: denebBlock}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher:   moc,
+			GenesisTimeFetcher: moc, // genesis time is set to 0 here, so it results in current epoch being extremely large
+			BeaconDB:           db,
+			BlobStorage:        bs,
+		}
+
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 4, len(resp.Data))
+
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
+	})
+	t.Run("block without commitments returns 200 w/empty list ", func(t *testing.T) {
+		denebBlock, _ := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 333, 0)
+		commitments, err := denebBlock.Block().Body().BlobKzgCommitments()
+		require.NoError(t, err)
+		require.Equal(t, len(commitments), 0)
+		require.NoError(t, db.SaveBlock(t.Context(), denebBlock))
+
+		u := "http://foo.example/333"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}, Block: denebBlock},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 0, len(resp.Data))
+
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
+	})
+	t.Run("slot before Deneb fork", func(t *testing.T) {
+		u := "http://foo.example/31"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{}
+
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusBadRequest, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusBadRequest, e.Code)
+		assert.StringContains(t, "blobs are not supported before Deneb fork", e.Message)
+	})
+	t.Run("malformed block ID", func(t *testing.T) {
+		u := "http://foo.example/foo"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusBadRequest, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusBadRequest, e.Code)
+		assert.Equal(t, true, strings.Contains(e.Message, "could not parse block ID"))
+	})
+	t.Run("ssz", func(t *testing.T) {
+		u := "http://foo.example/finalized"
+		request := httptest.NewRequest("GET", u, nil)
+		request.Header.Add("Accept", "application/octet-stream")
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+		assert.Equal(t, version.String(version.Deneb), writer.Header().Get(api.VersionHeader))
+		assert.Equal(t, http.StatusOK, writer.Code)
+		require.Equal(t, fieldparams.BlobSize*4, len(writer.Body.Bytes())) // size of 4 sidecars
+		// unmarshal all 4 blobs
+		blbs := unmarshalBlobs(t, writer.Body.Bytes())
+		require.Equal(t, 4, len(blbs))
+	})
+	t.Run("ssz multiple blobs", func(t *testing.T) {
+		u := "http://foo.example/finalized"
+		request := httptest.NewRequest("GET", u, nil)
+		request.Header.Add("Accept", "application/octet-stream")
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		blbs := unmarshalBlobs(t, writer.Body.Bytes())
+		require.Equal(t, 4, len(blbs))
+	})
+
+	t.Run("versioned_hashes invalid hex", func(t *testing.T) {
+		u := "http://foo.example/finalized?versioned_hashes=invalidhex,invalid2hex"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusBadRequest, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusBadRequest, e.Code)
+		assert.StringContains(t, "versioned_hashes[0] is invalid", e.Message)
+		assert.StringContains(t, "hex string without 0x prefix", e.Message)
+	})
+
+	t.Run("versioned_hashes invalid length", func(t *testing.T) {
+		// Using 16 bytes instead of 32
+		shortHash := "0x1234567890abcdef1234567890abcdef"
+		u := fmt.Sprintf("http://foo.example/finalized?versioned_hashes=%s", shortHash)
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusBadRequest, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusBadRequest, e.Code)
+		assert.StringContains(t, "Invalid versioned_hashes[0]:", e.Message)
+		assert.StringContains(t, "is not length 32", e.Message)
+	})
+
+	t.Run("versioned_hashes valid single hash", func(t *testing.T) {
+		// Get the first blob's commitment and convert to versioned hash
+		versionedHash := primitives.ConvertKzgCommitmentToVersionedHash(blobs[0].KzgCommitment)
+
+		u := fmt.Sprintf("http://foo.example/finalized?versioned_hashes=%s", hexutil.Encode(versionedHash[:]))
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 1, len(resp.Data)) // Should return only the requested blob
+		blob := resp.Data[0]
+		require.NotNil(t, blob)
+		assert.Equal(t, hexutil.Encode(blobs[0].Blob), blob)
+	})
+
+	t.Run("versioned_hashes multiple hashes", func(t *testing.T) {
+		// Get commitments for blobs 1 and 3 and convert to versioned hashes
+		versionedHash1 := primitives.ConvertKzgCommitmentToVersionedHash(blobs[1].KzgCommitment)
+		versionedHash3 := primitives.ConvertKzgCommitmentToVersionedHash(blobs[3].KzgCommitment)
+
+		u := fmt.Sprintf("http://foo.example/finalized?versioned_hashes=%s&versioned_hashes=%s",
+			hexutil.Encode(versionedHash1[:]), hexutil.Encode(versionedHash3[:]))
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: bs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 2, len(resp.Data)) // Should return 2 requested blobs
+		// Verify blobs are returned in KZG commitment order from the block (1, 3)
+		// not in the requested order
+		assert.Equal(t, hexutil.Encode(blobs[1].Blob), resp.Data[0])
+		assert.Equal(t, hexutil.Encode(blobs[3].Blob), resp.Data[1])
+	})
+
+	// Test for Electra fork
+	t.Run("electra max blobs", func(t *testing.T) {
+		electraBlock, electraBlobs := util.GenerateTestElectraBlockWithSidecar(t, [32]byte{}, 323, maxBlobsPerBlockByVersion(version.Electra))
+		require.NoError(t, db.SaveBlock(t.Context(), electraBlock))
+		electraBs := filesystem.NewEphemeralBlobStorage(t)
+		electraSidecars := verification.FakeVerifySliceForTest(t, electraBlobs)
+		for i := range electraSidecars {
+			require.NoError(t, electraBs.Save(electraSidecars[i]))
+		}
+		electraBlockRoot := electraBlobs[0].BlockRoot()
+
+		u := "http://foo.example/323"
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: electraBlockRoot[:]}, Block: electraBlock},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:    db,
+			BlobStorage: electraBs,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, version.String(version.Electra), writer.Header().Get(api.VersionHeader))
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, maxBlobsPerBlockByVersion(version.Electra), len(resp.Data))
+		blob := resp.Data[0]
+		require.NotNil(t, blob)
+		assert.Equal(t, hexutil.Encode(electraBlobs[0].Blob), blob)
+	})
+
+	// Test for Fulu fork with data columns
+	t.Run("fulu with data columns", func(t *testing.T) {
+		// Generate a Fulu block with data columns
+		fuluForkSlot := primitives.Slot(20 * params.BeaconConfig().SlotsPerEpoch) // Fulu is at epoch 20
+		fuluBlock, _, verifiedRoDataColumnSidecars := util.GenerateTestFuluBlockWithSidecars(t, 3, util.WithSlot(fuluForkSlot))
+		require.NoError(t, db.SaveBlock(t.Context(), fuluBlock.ReadOnlySignedBeaconBlock))
+		fuluBlockRoot := fuluBlock.Root()
+
+		// Store data columns
+		_, dataColumnStorage := filesystem.NewEphemeralDataColumnStorageAndFs(t)
+		require.NoError(t, dataColumnStorage.Save(verifiedRoDataColumnSidecars))
+
+		u := fmt.Sprintf("http://foo.example/%d", fuluForkSlot)
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		// Create an empty blob storage (won't be used but needs to be non-nil)
+		_, emptyBlobStorage := filesystem.NewEphemeralBlobStorageAndFs(t)
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: fuluBlockRoot[:]}, Block: fuluBlock.ReadOnlySignedBeaconBlock},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:          db,
+			BlobStorage:       emptyBlobStorage,
+			DataColumnStorage: dataColumnStorage,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, version.String(version.Fulu), writer.Header().Get(api.VersionHeader))
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 3, len(resp.Data))
+
+		// Verify that we got blobs back (they were reconstructed from data columns)
+		for i := range resp.Data {
+			require.NotNil(t, resp.Data[i])
+		}
+	})
+
+	// Test for Fulu with versioned hashes and data columns
+	t.Run("fulu versioned_hashes with data columns", func(t *testing.T) {
+		// Generate a Fulu block with data columns
+		fuluForkSlot2 := primitives.Slot(20*params.BeaconConfig().SlotsPerEpoch + 10) // Fulu is at epoch 20
+		fuluBlock2, _, verifiedRoDataColumnSidecars2 := util.GenerateTestFuluBlockWithSidecars(t, 4, util.WithSlot(fuluForkSlot2))
+		require.NoError(t, db.SaveBlock(t.Context(), fuluBlock2.ReadOnlySignedBeaconBlock))
+		fuluBlockRoot2 := fuluBlock2.Root()
+
+		// Store data columns
+		_, dataColumnStorage := filesystem.NewEphemeralDataColumnStorageAndFs(t)
+		require.NoError(t, dataColumnStorage.Save(verifiedRoDataColumnSidecars2))
+
+		// Get the commitments from the block to derive versioned hashes
+		commitments, err := fuluBlock2.Block().Body().BlobKzgCommitments()
+		require.NoError(t, err)
+		require.Equal(t, true, len(commitments) >= 3)
+
+		// Request specific blobs by versioned hashes in reverse order
+		// We request commitments[2] and commitments[0], but they should be returned
+		// in commitment order from the block (0, 2), not in the requested order
+		versionedHash1 := primitives.ConvertKzgCommitmentToVersionedHash(commitments[2])
+		versionedHash2 := primitives.ConvertKzgCommitmentToVersionedHash(commitments[0])
+
+		u := fmt.Sprintf("http://foo.example/%d?versioned_hashes=%s&versioned_hashes=%s", fuluForkSlot2,
+			hexutil.Encode(versionedHash1[:]),
+			hexutil.Encode(versionedHash2[:]))
+		request := httptest.NewRequest("GET", u, nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		// Create an empty blob storage (won't be used but needs to be non-nil)
+		_, emptyBlobStorage := filesystem.NewEphemeralBlobStorageAndFs(t)
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: fuluBlockRoot2[:]}, Block: fuluBlock2.ReadOnlySignedBeaconBlock},
+			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
+				Genesis: time.Now(),
+			},
+			BeaconDB:          db,
+			BlobStorage:       emptyBlobStorage,
+			DataColumnStorage: dataColumnStorage,
+		}
+		s.GetBlobs(writer, request)
+
+		assert.Equal(t, version.String(version.Fulu), writer.Header().Get(api.VersionHeader))
+		assert.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlobsResponse{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		require.Equal(t, 2, len(resp.Data))
+		// Blobs are returned in commitment order, regardless of request order
+	})
+}
+
+func unmarshalBlobs(t *testing.T, response []byte) [][]byte {
+	require.Equal(t, 0, len(response)%fieldparams.BlobSize)
+	if len(response) == fieldparams.BlobSize {
+		return [][]byte{response}
+	}
+	blobs := make([][]byte, len(response)/fieldparams.BlobSize)
+	for i := range blobs {
+		blobs[i] = response[i*fieldparams.BlobSize : (i+1)*fieldparams.BlobSize]
+	}
+	return blobs
+}
+
 func maxBlobsPerBlockByVersion(v int) int {
+	if v >= version.Fulu {
+		return params.BeaconConfig().DeprecatedMaxBlobsPerBlockFulu
+	}
 	if v >= version.Electra {
 		return params.BeaconConfig().DeprecatedMaxBlobsPerBlockElectra
 	}
--- a/beacon-chain/rpc/lookup/BUILD.bazel
+++ b/beacon-chain/rpc/lookup/BUILD.bazel
@@ -14,6 +14,7 @@ go_library(
        "//beacon-chain/db:go_default_library",
        "//beacon-chain/db/filesystem:go_default_library",
        "//beacon-chain/rpc/core:go_default_library",
+        "//beacon-chain/rpc/options:go_default_library",
        "//beacon-chain/state:go_default_library",
        "//beacon-chain/state/stategen:go_default_library",
        "//cmd/beacon-chain/flags:go_default_library",
@@ -44,6 +45,7 @@ go_test(
        "//beacon-chain/db/filesystem:go_default_library",
        "//beacon-chain/db/testing:go_default_library",
        "//beacon-chain/rpc/core:go_default_library",
+        "//beacon-chain/rpc/options:go_default_library",
        "//beacon-chain/rpc/testutil:go_default_library",
        "//beacon-chain/state/state-native:go_default_library",
        "//beacon-chain/state/stategen:go_default_library",
--- a/beacon-chain/rpc/lookup/blocker.go
+++ b/beacon-chain/rpc/lookup/blocker.go
@@ -11,6 +11,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/core"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/options"
 	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
@@ -57,7 +58,7 @@ func (e BlockIdParseError) Error() string {
 // Blocker is responsible for retrieving blocks.
 type Blocker interface {
 	Block(ctx context.Context, id []byte) (interfaces.ReadOnlySignedBeaconBlock, error)
-	Blobs(ctx context.Context, id string, indices []int) ([]*blocks.VerifiedROBlob, *core.RpcError)
+	Blobs(ctx context.Context, id string, opts ...options.BlobsOption) ([]*blocks.VerifiedROBlob, *core.RpcError)
 }

 // BeaconDbBlocker is an implementation of Blocker. It retrieves blocks from the beacon chain database.
@@ -147,7 +148,9 @@ func (p *BeaconDbBlocker) Block(ctx context.Context, id []byte) (interfaces.Read
 	return blk, nil
 }

-// Blobs returns the blobs for a given block id identifier and blob indices. The identifier can be one of:
+// Blobs returns the fetched blobs for a given block ID with configurable options.
+// Options can specify either blob indices or versioned hashes for retrieval.
+// The identifier can be one of:
 //   - "head" (canonical head in node's view)
 //   - "genesis"
 //   - "finalized"
@@ -158,11 +161,17 @@ func (p *BeaconDbBlocker) Block(ctx context.Context, id []byte) (interfaces.Read
 //
 // cases:
 //   - no block, 404
-//   - block exists, no commitment, 200 w/ empty list
 //   - block exists, has commitments, inside retention period (greater of protocol- or user-specified) serve then w/ 200 unless we hit an error reading them.
 //     we are technically not supposed to import a block to forkchoice unless we have the blobs, so the nuance here is if we can't find the file and we are inside the protocol-defined retention period, then it's actually a 500.
 //   - block exists, has commitments, outside retention period (greater of protocol- or user-specified) - ie just like block exists, no commitment
-func (p *BeaconDbBlocker) Blobs(ctx context.Context, id string, indices []int) ([]*blocks.VerifiedROBlob, *core.RpcError) {
+func (p *BeaconDbBlocker) Blobs(ctx context.Context, id string, opts ...options.BlobsOption) ([]*blocks.VerifiedROBlob, *core.RpcError) {
+	// Apply options
+	cfg := &options.BlobsConfig{}
+	for _, opt := range opts {
+		opt(cfg)
+	}
+
+	// Resolve block ID to root
 	var rootSlice []byte
 	switch id {
 	case "genesis":
@@ -239,11 +248,6 @@ func (p *BeaconDbBlocker) Blobs(ctx context.Context, id string, indices []int) (
 		return nil, &core.RpcError{Err: fmt.Errorf("block %#x not found in db", rootSlice), Reason: core.NotFound}
 	}

-	// If block is not in the retention window, return 200 w/ empty list
-	if !p.BlobStorage.WithinRetentionPeriod(slots.ToEpoch(roSignedBlock.Block().Slot()), slots.ToEpoch(p.GenesisTimeFetcher.CurrentSlot())) {
-		return make([]*blocks.VerifiedROBlob, 0), nil
-	}
-
 	roBlock := roSignedBlock.Block()

 	commitments, err := roBlock.Body().BlobKzgCommitments()
@@ -266,6 +270,46 @@ func (p *BeaconDbBlocker) Blobs(ctx context.Context, id string, indices []int) (
 		}
 	}

+	// Convert versioned hashes to indices if provided
+	indices := cfg.Indices
+	if len(cfg.VersionedHashes) > 0 {
+		// Build a map of requested versioned hashes for fast lookup and tracking
+		requestedHashes := make(map[string]bool)
+		for _, versionedHash := range cfg.VersionedHashes {
+			requestedHashes[string(versionedHash)] = true
+		}
+
+		// Create indices array and track which hashes we found
+		indices = make([]int, 0, len(cfg.VersionedHashes))
+		foundHashes := make(map[string]bool)
+
+		for i, commitment := range commitments {
+			versionedHash := primitives.ConvertKzgCommitmentToVersionedHash(commitment)
+			hashStr := string(versionedHash[:])
+			if requestedHashes[hashStr] {
+				indices = append(indices, i)
+				foundHashes[hashStr] = true
+			}
+		}
+
+		// Check if all requested hashes were found
+		if len(indices) != len(cfg.VersionedHashes) {
+			// Collect missing hashes
+			missingHashes := make([]string, 0, len(cfg.VersionedHashes)-len(indices))
+			for _, requestedHash := range cfg.VersionedHashes {
+				if !foundHashes[string(requestedHash)] {
+					missingHashes = append(missingHashes, hexutil.Encode(requestedHash))
+				}
+			}
+
+			// Create detailed error message
+			errMsg := fmt.Sprintf("versioned hash(es) not found in block (requested %d hashes, found %d, missing: %v)",
+				len(cfg.VersionedHashes), len(indices), missingHashes)
+
+			return nil, &core.RpcError{Err: errors.New(errMsg), Reason: core.NotFound}
+		}
+	}
+
 	if roBlock.Slot() >= fuluForkSlot {
 		roBlock, err := blocks.NewROBlockWithRoot(roSignedBlock, root)
 		if err != nil {
--- a/beacon-chain/rpc/lookup/blocker_test.go
+++ b/beacon-chain/rpc/lookup/blocker_test.go
@@ -14,11 +14,13 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/core"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/options"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/testutil"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
@@ -236,7 +238,7 @@ func TestGetBlob(t *testing.T) {
 		setupDeneb(t)

 		blocker := &BeaconDbBlocker{}
-		_, rpcErr := blocker.Blobs(ctx, "genesis", nil)
+		_, rpcErr := blocker.Blobs(ctx, "genesis")
 		require.Equal(t, http.StatusBadRequest, core.ErrorReasonToHTTP(rpcErr.Reason))
 		require.StringContains(t, "blobs are not supported for Phase 0 fork", rpcErr.Err.Error())
 	})
@@ -253,7 +255,7 @@ func TestGetBlob(t *testing.T) {
 			BlobStorage: blobStorage,
 		}

-		retrievedVerifiedSidecars, rpcErr := blocker.Blobs(ctx, "head", nil)
+		retrievedVerifiedSidecars, rpcErr := blocker.Blobs(ctx, "head")
 		require.IsNil(t, rpcErr)
 		require.Equal(t, blobCount, len(retrievedVerifiedSidecars))

@@ -282,7 +284,7 @@ func TestGetBlob(t *testing.T) {
 			BlobStorage: blobStorage,
 		}

-		verifiedSidecars, rpcErr := blocker.Blobs(ctx, "finalized", nil)
+		verifiedSidecars, rpcErr := blocker.Blobs(ctx, "finalized")
 		require.IsNil(t, rpcErr)
 		require.Equal(t, blobCount, len(verifiedSidecars))
 	})
@@ -299,7 +301,7 @@ func TestGetBlob(t *testing.T) {
 			BlobStorage: blobStorage,
 		}

-		verifiedSidecars, rpcErr := blocker.Blobs(ctx, "justified", nil)
+		verifiedSidecars, rpcErr := blocker.Blobs(ctx, "justified")
 		require.IsNil(t, rpcErr)
 		require.Equal(t, blobCount, len(verifiedSidecars))
 	})
@@ -315,7 +317,7 @@ func TestGetBlob(t *testing.T) {
 			BlobStorage: blobStorage,
 		}

-		verifiedBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(denebBlockRoot[:]), nil)
+		verifiedBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(denebBlockRoot[:]))
 		require.IsNil(t, rpcErr)
 		require.Equal(t, blobCount, len(verifiedBlobs))
 	})
@@ -331,7 +333,7 @@ func TestGetBlob(t *testing.T) {
 			BlobStorage: blobStorage,
 		}

-		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "123", nil)
+		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "123")
 		require.IsNil(t, rpcErr)
 		require.Equal(t, blobCount, len(verifiedBlobs))
 	})
@@ -350,7 +352,7 @@ func TestGetBlob(t *testing.T) {
 			BlobStorage: blobStorage,
 		}

-		retrievedVerifiedSidecars, rpcErr := blocker.Blobs(ctx, "123", []int{index})
+		retrievedVerifiedSidecars, rpcErr := blocker.Blobs(ctx, "123", options.WithIndices([]int{index}))
 		require.IsNil(t, rpcErr)
 		require.Equal(t, 1, len(retrievedVerifiedSidecars))

@@ -376,7 +378,7 @@ func TestGetBlob(t *testing.T) {
 			BlobStorage: filesystem.NewEphemeralBlobStorage(t),
 		}

-		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "123", nil)
+		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "123")
 		require.IsNil(t, rpcErr)
 		require.Equal(t, 0, len(verifiedBlobs))
 	})
@@ -394,7 +396,7 @@ func TestGetBlob(t *testing.T) {
 		}

 		noBlobIndex := len(storedBlobSidecars) + 1
-		_, rpcErr := blocker.Blobs(ctx, "123", []int{0, noBlobIndex})
+		_, rpcErr := blocker.Blobs(ctx, "123", options.WithIndices([]int{0, noBlobIndex}))
 		require.NotNil(t, rpcErr)
 		require.Equal(t, core.ErrorReason(core.NotFound), rpcErr.Reason)
 	})
@@ -410,7 +412,7 @@ func TestGetBlob(t *testing.T) {
 			BeaconDB:    db,
 			BlobStorage: blobStorage,
 		}
-		_, rpcErr := blocker.Blobs(ctx, "123", []int{0, math.MaxInt})
+		_, rpcErr := blocker.Blobs(ctx, "123", options.WithIndices([]int{0, math.MaxInt}))
 		require.NotNil(t, rpcErr)
 		require.Equal(t, core.ErrorReason(core.BadRequest), rpcErr.Reason)
 	})
@@ -431,7 +433,7 @@ func TestGetBlob(t *testing.T) {
 			DataColumnStorage: dataColumnStorage,
 		}

-		_, rpcErr := blocker.Blobs(ctx, hexutil.Encode(fuluBlockRoot[:]), nil)
+		_, rpcErr := blocker.Blobs(ctx, hexutil.Encode(fuluBlockRoot[:]))
 		require.NotNil(t, rpcErr)
 		require.Equal(t, core.ErrorReason(core.NotFound), rpcErr.Reason)
 	})
@@ -452,7 +454,7 @@ func TestGetBlob(t *testing.T) {
 			DataColumnStorage: dataColumnStorage,
 		}

-		retrievedVerifiedRoBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(fuluBlockRoot[:]), nil)
+		retrievedVerifiedRoBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(fuluBlockRoot[:]))
 		require.IsNil(t, rpcErr)
 		require.Equal(t, len(fuluBlobSidecars), len(retrievedVerifiedRoBlobs))

@@ -479,7 +481,7 @@ func TestGetBlob(t *testing.T) {
 			DataColumnStorage: dataColumnStorage,
 		}

-		retrievedVerifiedRoBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(fuluBlockRoot[:]), nil)
+		retrievedVerifiedRoBlobs, rpcErr := blocker.Blobs(ctx, hexutil.Encode(fuluBlockRoot[:]))
 		require.IsNil(t, rpcErr)
 		require.Equal(t, len(fuluBlobSidecars), len(retrievedVerifiedRoBlobs))

@@ -490,3 +492,164 @@ func TestGetBlob(t *testing.T) {
 		}
 	})
 }
+
+func TestBlobs_CommitmentOrdering(t *testing.T) {
+	// Set up Fulu fork configuration
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.DenebForkEpoch = 1
+	cfg.FuluForkEpoch = 2
+	params.OverrideBeaconConfig(cfg)
+
+	beaconDB := testDB.SetupDB(t)
+	ctx := t.Context()
+
+	// Start the trusted setup for KZG
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	// Create Fulu/Electra block with multiple blob commitments
+	fuluForkSlot := primitives.Slot(cfg.FuluForkEpoch) * params.BeaconConfig().SlotsPerEpoch
+	parent := [32]byte{}
+	fuluBlock, fuluBlobs := util.GenerateTestElectraBlockWithSidecar(t, parent, fuluForkSlot, 3)
+
+	// Save the block
+	err = beaconDB.SaveBlock(ctx, fuluBlock)
+	require.NoError(t, err)
+	fuluBlockRoot := fuluBlock.Root()
+
+	// Get the commitments from the generated block
+	commitments, err := fuluBlock.Block().Body().BlobKzgCommitments()
+	require.NoError(t, err)
+	require.Equal(t, 3, len(commitments))
+
+	// Convert blob sidecars to data column sidecars for Fulu
+	cellsAndProofsList := make([]kzg.CellsAndProofs, 0, len(fuluBlobs))
+	for _, blob := range fuluBlobs {
+		var kzgBlob kzg.Blob
+		copy(kzgBlob[:], blob.Blob)
+		cellsAndProofs, err := kzg.ComputeCellsAndKZGProofs(&kzgBlob)
+		require.NoError(t, err)
+		cellsAndProofsList = append(cellsAndProofsList, cellsAndProofs)
+	}
+
+	dataColumnSidecarPb, err := peerdas.DataColumnSidecars(cellsAndProofsList, peerdas.PopulateFromBlock(fuluBlock))
+	require.NoError(t, err)
+
+	verifiedRoDataColumnSidecars := make([]blocks.VerifiedRODataColumn, 0, len(dataColumnSidecarPb))
+	for _, roDataColumn := range dataColumnSidecarPb {
+		verifiedRoDataColumn := blocks.NewVerifiedRODataColumn(roDataColumn)
+		verifiedRoDataColumnSidecars = append(verifiedRoDataColumnSidecars, verifiedRoDataColumn)
+	}
+
+	// Set up data column storage and save data columns
+	_, dataColumnStorage := filesystem.NewEphemeralDataColumnStorageAndFs(t)
+	err = dataColumnStorage.Save(verifiedRoDataColumnSidecars)
+	require.NoError(t, err)
+
+	// Set up the blocker
+	chainService := &mockChain.ChainService{
+		Genesis: time.Now(),
+		FinalizedCheckPoint: &ethpb.Checkpoint{
+			Epoch: 0,
+			Root:  fuluBlockRoot[:],
+		},
+	}
+	blocker := &BeaconDbBlocker{
+		BeaconDB:           beaconDB,
+		ChainInfoFetcher:   chainService,
+		GenesisTimeFetcher: chainService,
+		BlobStorage:        filesystem.NewEphemeralBlobStorage(t),
+		DataColumnStorage:  dataColumnStorage,
+	}
+
+	// Compute versioned hashes for commitments in their block order
+	hash0 := primitives.ConvertKzgCommitmentToVersionedHash(commitments[0])
+	hash1 := primitives.ConvertKzgCommitmentToVersionedHash(commitments[1])
+	hash2 := primitives.ConvertKzgCommitmentToVersionedHash(commitments[2])
+
+	t.Run("blobs returned in commitment order regardless of request order", func(t *testing.T) {
+		// Request versioned hashes in reverse order: 2, 1, 0
+		requestedHashes := [][]byte{hash2[:], hash1[:], hash0[:]}
+
+		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "finalized", options.WithVersionedHashes(requestedHashes))
+		if rpcErr != nil {
+			t.Errorf("RPC Error: %v (reason: %v)", rpcErr.Err, rpcErr.Reason)
+			return
+		}
+		require.Equal(t, 3, len(verifiedBlobs))
+
+		// Verify blobs are returned in commitment order from the block (0, 1, 2)
+		// In Fulu, blobs are reconstructed from data columns
+		assert.Equal(t, uint64(0), verifiedBlobs[0].Index) // First commitment in block
+		assert.Equal(t, uint64(1), verifiedBlobs[1].Index) // Second commitment in block
+		assert.Equal(t, uint64(2), verifiedBlobs[2].Index) // Third commitment in block
+
+		// Verify the blob content matches what we expect
+		for i, verifiedBlob := range verifiedBlobs {
+			require.NotNil(t, verifiedBlob.BlobSidecar)
+			require.DeepEqual(t, fuluBlobs[i].Blob, verifiedBlob.Blob)
+			require.DeepEqual(t, fuluBlobs[i].KzgCommitment, verifiedBlob.KzgCommitment)
+		}
+	})
+
+	t.Run("subset of blobs maintains commitment order", func(t *testing.T) {
+		// Request hashes for indices 1 and 0 (out of order)
+		requestedHashes := [][]byte{hash1[:], hash0[:]}
+
+		verifiedBlobs, rpcErr := blocker.Blobs(ctx, "finalized", options.WithVersionedHashes(requestedHashes))
+		if rpcErr != nil {
+			t.Errorf("RPC Error: %v (reason: %v)", rpcErr.Err, rpcErr.Reason)
+			return
+		}
+		require.Equal(t, 2, len(verifiedBlobs))
+
+		// Verify blobs are returned in commitment order from the block
+		assert.Equal(t, uint64(0), verifiedBlobs[0].Index) // First commitment in block
+		assert.Equal(t, uint64(1), verifiedBlobs[1].Index) // Second commitment in block
+
+		// Verify the blob content matches what we expect
+		require.DeepEqual(t, fuluBlobs[0].Blob, verifiedBlobs[0].Blob)
+		require.DeepEqual(t, fuluBlobs[1].Blob, verifiedBlobs[1].Blob)
+	})
+
+	t.Run("request non-existent hash", func(t *testing.T) {
+		// Create a fake versioned hash
+		fakeHash := make([]byte, 32)
+		for i := 0; i < 32; i++ {
+			fakeHash[i] = 0xFF
+		}
+
+		// Request only the fake hash
+		requestedHashes := [][]byte{fakeHash}
+
+		_, rpcErr := blocker.Blobs(ctx, "finalized", options.WithVersionedHashes(requestedHashes))
+		require.NotNil(t, rpcErr)
+		require.Equal(t, core.ErrorReason(core.NotFound), rpcErr.Reason)
+		require.StringContains(t, "versioned hash(es) not found in block", rpcErr.Err.Error())
+		require.StringContains(t, "requested 1 hashes, found 0", rpcErr.Err.Error())
+		require.StringContains(t, "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", rpcErr.Err.Error())
+	})
+
+	t.Run("request multiple non-existent hashes", func(t *testing.T) {
+		// Create two fake versioned hashes
+		fakeHash1 := make([]byte, 32)
+		fakeHash2 := make([]byte, 32)
+		for i := 0; i < 32; i++ {
+			fakeHash1[i] = 0xAA
+			fakeHash2[i] = 0xBB
+		}
+
+		// Request valid hash with two fake hashes
+		requestedHashes := [][]byte{fakeHash1, hash0[:], fakeHash2}
+
+		_, rpcErr := blocker.Blobs(ctx, "finalized", options.WithVersionedHashes(requestedHashes))
+		require.NotNil(t, rpcErr)
+		require.Equal(t, core.ErrorReason(core.NotFound), rpcErr.Reason)
+		require.StringContains(t, "versioned hash(es) not found in block", rpcErr.Err.Error())
+		require.StringContains(t, "requested 3 hashes, found 1", rpcErr.Err.Error())
+		// Check that both missing hashes are reported
+		require.StringContains(t, "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", rpcErr.Err.Error())
+		require.StringContains(t, "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", rpcErr.Err.Error())
+	})
+}
--- a/beacon-chain/rpc/options/BUILD.bazel
+++ b/beacon-chain/rpc/options/BUILD.bazel
@@ -0,0 +1,8 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["options.go"],
+    importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/options",
+    visibility = ["//visibility:public"],
+)
--- a/beacon-chain/rpc/options/options.go
+++ b/beacon-chain/rpc/options/options.go
@@ -0,0 +1,24 @@
+package options
+
+// BlobsOption is a functional option for configuring blob retrieval
+type BlobsOption func(*BlobsConfig)
+
+// BlobsConfig holds configuration for blob retrieval
+type BlobsConfig struct {
+	Indices         []int
+	VersionedHashes [][]byte
+}
+
+// WithIndices specifies blob indices to retrieve
+func WithIndices(indices []int) BlobsOption {
+	return func(c *BlobsConfig) {
+		c.Indices = indices
+	}
+}
+
+// WithVersionedHashes specifies versioned hashes to retrieve blobs by
+func WithVersionedHashes(hashes [][]byte) BlobsOption {
+	return func(c *BlobsConfig) {
+		c.VersionedHashes = hashes
+	}
+}
--- a/beacon-chain/rpc/testutil/BUILD.bazel
+++ b/beacon-chain/rpc/testutil/BUILD.bazel
@@ -16,6 +16,7 @@ go_library(
    deps = [
        "//beacon-chain/db:go_default_library",
        "//beacon-chain/rpc/core:go_default_library",
+        "//beacon-chain/rpc/options:go_default_library",
        "//beacon-chain/state:go_default_library",
        "//config/params:go_default_library",
        "//consensus-types/blocks:go_default_library",
--- a/beacon-chain/rpc/testutil/mock_blocker.go
+++ b/beacon-chain/rpc/testutil/mock_blocker.go
@@ -5,6 +5,7 @@ import (
 	"strconv"

 	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/core"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/options"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
@@ -36,6 +37,6 @@ func (m *MockBlocker) Block(_ context.Context, b []byte) (interfaces.ReadOnlySig
 }

 // Blobs --
-func (*MockBlocker) Blobs(_ context.Context, _ string, _ []int) ([]*blocks.VerifiedROBlob, *core.RpcError) {
+func (*MockBlocker) Blobs(_ context.Context, _ string, _ ...options.BlobsOption) ([]*blocks.VerifiedROBlob, *core.RpcError) {
 	return nil, &core.RpcError{}
 }
--- a/changelog/james-prysm_get-blob-fulu.md
+++ b/changelog/james-prysm_get-blob-fulu.md
@@ -0,0 +1,3 @@
+### Added
+
+- Added new post fulu /eth/v1/beacon/blobs/{block_id} endpoint