chore: (core/da) cleanup interface (#2278)

<!--
Please read and fill out this form before submitting your PR.

Please make sure you have reviewed our contributors guide before
submitting your
first PR.

NOTE: PR titles should follow semantic commits:
https://www.conventionalcommits.org/en/v1.0.0/
-->

## Overview

This pr removes unused namespace from functions and the submit function
from the da interface


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

- **Refactor**
- Simplified the data availability (DA) interface and related APIs by
removing the namespace parameter from most methods, resulting in cleaner
and more consistent method signatures.
- Unified submission methods, consolidating options handling and
ensuring consistent blob size checks.
- Updated all internal usage, mocks, and tests to match the revised
interface, removing unnecessary placeholder arguments.
- Refactored JSON-RPC server and proxy client implementations for
clearer method dispatch and improved modularity.
- **Bug Fixes**
- Improved error handling in tests to prevent nil pointer dereferences
and better tolerate expected errors.
- **Chores**
- Removed obsolete mock generation commands and cleaned up unused code.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Co-authored-by: tac0turtle <you@example.com>
Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com>

Author: 3 people

block/da_speed_test.go

@@ -47,16 +47,16 @@ func TestDASpeed(t *testing.T) {
 			manager, mockDAClient := setupManagerForTest(t, daHeight)
 
 			var receivedBlockCount atomic.Uint64
-			ids, namespace := []coreda.ID{[]byte("dummy-id")}, []byte("placeholder")
+			ids := []coreda.ID{[]byte("dummy-id")}
 			mockDAClient.
-				On("GetIDs", mock.Anything, mock.Anything, namespace).
-				Return(func(ctx context.Context, height uint64, namespace []byte) (*coreda.GetIDsResult, error) {
+				On("GetIDs", mock.Anything, mock.Anything).
+				Return(func(ctx context.Context, height uint64) (*coreda.GetIDsResult, error) {
 					return &coreda.GetIDsResult{IDs: ids, Timestamp: time.Now()}, nil
 				})
 
 			mockDAClient.
-				On("Get", mock.Anything, ids, namespace).
-				Return(func(ctx context.Context, ids []coreda.ID, namespace []byte) ([]coreda.Blob, error) {
+				On("Get", mock.Anything, ids).
+				Return(func(ctx context.Context, ids []coreda.ID) ([]coreda.Blob, error) {
 					time.Sleep(spec.daDelay)
 					// unique headers for cache misses
 					n := receivedBlockCount.Add(1)

block/retriever_test.go

@@ -135,11 +135,11 @@ func TestProcessNextDAHeader_Success_SingleHeaderAndData(t *testing.T) {
 	blockDataBytes, err := signedData.MarshalBinary()
 	require.NoError(t, err)
 	// -----------------------------------------------------------
-	mockDAClient.On("GetIDs", mock.Anything, daHeight, []byte("placeholder")).Return(&coreda.GetIDsResult{
+	mockDAClient.On("GetIDs", mock.Anything, daHeight).Return(&coreda.GetIDsResult{
 		IDs:       []coreda.ID{[]byte("dummy-id")},
 		Timestamp: time.Now(),
 	}, nil).Once()
-	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}, []byte("placeholder")).Return(
+	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}).Return(
 		[]coreda.Blob{headerBytes, blockDataBytes}, nil,
 	).Once()
 
@@ -247,11 +247,11 @@ func TestProcessNextDAHeader_MultipleHeadersAndData(t *testing.T) {
 	// Add a few more invalid blobs at the end
 	blobs = append(blobs, invalidBlob, []byte{})
 
-	mockDAClient.On("GetIDs", mock.Anything, daHeight, []byte("placeholder")).Return(&coreda.GetIDsResult{
+	mockDAClient.On("GetIDs", mock.Anything, daHeight).Return(&coreda.GetIDsResult{
 		IDs:       []coreda.ID{[]byte("dummy-id")},
 		Timestamp: time.Now(),
 	}, nil).Once()
-	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}, []byte("placeholder")).Return(
+	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}).Return(
 		blobs, nil,
 	).Once()
 
@@ -311,11 +311,11 @@ func TestProcessNextDAHeaderAndData_NotFound(t *testing.T) {
 	defer cancel()
 
 	// Mock GetIDs to return empty IDs to simulate "not found" scenario
-	mockDAClient.On("GetIDs", mock.Anything, daHeight, []byte("placeholder")).Return(&coreda.GetIDsResult{
-		IDs:       []coreda.ID{}, // Empty IDs array
+	// Example updates needed for one instance:
+	mockDAClient.On("GetIDs", mock.Anything, daHeight).Return(&coreda.GetIDsResult{
+		IDs:       []coreda.ID{},
 		Timestamp: time.Now(),
 	}, coreda.ErrBlobNotFound).Once()
-
 	ctx := context.Background()
 	err := manager.processNextDAHeaderAndData(ctx)
 	require.NoError(t, err)
@@ -345,13 +345,13 @@ func TestProcessNextDAHeaderAndData_UnmarshalHeaderError(t *testing.T) {
 	invalidBytes := []byte("this is not a valid protobuf message")
 
 	// Mock GetIDs to return success with dummy ID
-	mockDAClient.On("GetIDs", mock.Anything, daHeight, []byte("placeholder")).Return(&coreda.GetIDsResult{
+	mockDAClient.On("GetIDs", mock.Anything, daHeight).Return(&coreda.GetIDsResult{
 		IDs:       []coreda.ID{[]byte("dummy-id")},
 		Timestamp: time.Now(),
 	}, nil).Once()
 
 	// Mock Get to return invalid bytes
-	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}, []byte("placeholder")).Return(
+	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}).Return(
 		[]coreda.Blob{invalidBytes}, nil,
 	).Once()
 
@@ -404,13 +404,13 @@ func TestProcessNextDAHeader_UnexpectedSequencer(t *testing.T) {
 	require.NoError(t, err)
 
 	// Mock GetIDs to return success with dummy ID
-	mockDAClient.On("GetIDs", mock.Anything, daHeight, []byte("placeholder")).Return(&coreda.GetIDsResult{
+	mockDAClient.On("GetIDs", mock.Anything, daHeight).Return(&coreda.GetIDsResult{
 		IDs:       []coreda.ID{[]byte("dummy-id")},
 		Timestamp: time.Now(),
 	}, nil).Once()
 
 	// Mock Get to return header bytes
-	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}, []byte("placeholder")).Return(
+	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}).Return(
 		[]coreda.Blob{headerBytes}, nil,
 	).Once()
 
@@ -448,7 +448,7 @@ func TestProcessNextDAHeader_FetchError_RetryFailure(t *testing.T) {
 	fetchErr := errors.New("persistent DA connection error")
 
 	// Mock GetIDs to return error for all retries
-	mockDAClient.On("GetIDs", mock.Anything, daHeight, []byte("placeholder")).Return(
+	mockDAClient.On("GetIDs", mock.Anything, daHeight).Return(
 		nil, fetchErr,
 	).Times(dAFetcherRetries)
 
@@ -538,7 +538,7 @@ func TestProcessNextDAHeader_HeaderAndDataAlreadySeen(t *testing.T) {
 		Timestamp: time.Now(),
 	}, nil).Once()
 
-	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}, mock.Anything).Return(
+	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}).Return(
 		[]coreda.Blob{headerBytes, blockDataBytes}, nil,
 	).Once()
 
@@ -576,12 +576,12 @@ func TestRetrieveLoop_ProcessError_HeightFromFuture(t *testing.T) {
 	futureErr := fmt.Errorf("some error wrapping: %w", ErrHeightFromFutureStr)
 
 	// Mock GetIDs to return future error for all retries
-	mockDAClient.On("GetIDs", mock.Anything, startDAHeight, []byte("placeholder")).Return(
+	mockDAClient.On("GetIDs", mock.Anything, startDAHeight).Return(
 		nil, futureErr,
 	).Once()
 
 	// Optional: Mock for the next height if needed
-	mockDAClient.On("GetIDs", mock.Anything, startDAHeight+1, []byte("placeholder")).Return(
+	mockDAClient.On("GetIDs", mock.Anything, startDAHeight+1).Return(
 		&coreda.GetIDsResult{IDs: []coreda.ID{}}, coreda.ErrBlobNotFound,
 	).Maybe()
 
@@ -624,7 +624,7 @@ func TestRetrieveLoop_ProcessError_Other(t *testing.T) {
 	otherErr := errors.New("some other DA error")
 
 	// Mock GetIDs to return error for all retries
-	mockDAClient.On("GetIDs", mock.Anything, startDAHeight, []byte("placeholder")).Return(
+	mockDAClient.On("GetIDs", mock.Anything, startDAHeight).Return(
 		nil, otherErr,
 	).Times(dAFetcherRetries)
 
@@ -708,11 +708,11 @@ func TestProcessNextDAHeader_WithNoTxs(t *testing.T) {
 	emptyDataBytes, err := emptySignedData.MarshalBinary()
 	require.NoError(t, err)
 
-	mockDAClient.On("GetIDs", mock.Anything, daHeight, []byte("placeholder")).Return(&coreda.GetIDsResult{
+	mockDAClient.On("GetIDs", mock.Anything, daHeight).Return(&coreda.GetIDsResult{
 		IDs:       []coreda.ID{[]byte("dummy-id")},
 		Timestamp: time.Now(),
 	}, nil).Once()
-	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}, []byte("placeholder")).Return(
+	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}).Return(
 		[]coreda.Blob{headerBytes, emptyDataBytes}, nil,
 	).Once()
 
@@ -761,23 +761,23 @@ func TestRetrieveLoop_DAHeightIncrementsOnlyOnSuccess(t *testing.T) {
 	require.NoError(t, err)
 
 	// 1. First call: success (header)
-	mockDAClient.On("GetIDs", mock.Anything, startDAHeight, []byte("placeholder")).Return(&coreda.GetIDsResult{
+	mockDAClient.On("GetIDs", mock.Anything, startDAHeight).Return(&coreda.GetIDsResult{
 		IDs:       []coreda.ID{[]byte("dummy-id")},
 		Timestamp: time.Now(),
 	}, nil).Once()
-	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}, []byte("placeholder")).Return(
+	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}).Return(
 		[]coreda.Blob{headerBytes}, nil,
 	).Once()
 
 	// 2. Second call: NotFound
-	mockDAClient.On("GetIDs", mock.Anything, startDAHeight+1, []byte("placeholder")).Return(&coreda.GetIDsResult{
+	mockDAClient.On("GetIDs", mock.Anything, startDAHeight+1).Return(&coreda.GetIDsResult{
 		IDs:       nil,
 		Timestamp: time.Now(),
 	}, nil).Once()
 
 	// 3. Third call: Error
 	errDA := errors.New("some DA error")
-	mockDAClient.On("GetIDs", mock.Anything, startDAHeight+2, []byte("placeholder")).Return(
+	mockDAClient.On("GetIDs", mock.Anything, startDAHeight+2).Return(
 		&coreda.GetIDsResult{
 			IDs:       nil,
 			Timestamp: time.Now(),

block/submitter_test.go

@@ -50,7 +50,7 @@ func TestSubmitDataToDA_Success(t *testing.T) {
 
 	// Simulate DA success
 	da.On("GasMultiplier", mock.Anything).Return(2.0, nil)
-	da.On("SubmitWithOptions", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+	da.On("Submit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
 		Return([]coreda.ID{[]byte("id")}, nil)
 
 	pubKey, err := m.signer.GetPublic()
@@ -102,7 +102,7 @@ func TestSubmitDataToDA_Failure(t *testing.T) {
 			var gasPriceHistory []float64
 			da.ExpectedCalls = nil
 			da.On("GasMultiplier", mock.Anything).Return(2.0, nil)
-			da.On("SubmitWithOptions", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+			da.On("Submit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
 				Run(func(args mock.Arguments) { gasPriceHistory = append(gasPriceHistory, args.Get(2).(float64)) }). //save the gas price to verify it later
 				Return(nil, tc.daError)
 
@@ -157,7 +157,7 @@ func TestSubmitHeadersToDA_Success(t *testing.T) {
 	fillWithBlockData(context.Background(), t, m.pendingHeaders, "Test Submitting Headers")
 
 	// Simulate DA layer successfully accepting the header submission
-	da.On("SubmitWithOptions", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+	da.On("Submit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
 		Return([]coreda.ID{[]byte("id")}, nil)
 
 	// Call submitHeadersToDA and expect no error
@@ -189,7 +189,7 @@ func TestSubmitHeadersToDA_Failure(t *testing.T) {
 			da.ExpectedCalls = nil
 			// Simulate DA layer returning a specific error
 			var gasPriceHistory []float64
-			da.On("SubmitWithOptions", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+			da.On("Submit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
 				Run(func(args mock.Arguments) { gasPriceHistory = append(gasPriceHistory, args.Get(2).(float64)) }). //save the gas price to verify it later
 				Return(nil, tc.daError)
 
@@ -226,7 +226,7 @@ func TestSubmitHeadersToDA_WithMetricsRecorder(t *testing.T) {
 	fillWithBlockData(context.Background(), t, m.pendingHeaders, "Test Submitting Headers")
 
 	// Simulate DA layer successfully accepting the header submission
-	da.On("SubmitWithOptions", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+	da.On("Submit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
 		Return([]coreda.ID{[]byte("id")}, nil)
 
 	// Expect RecordMetrics to be called with the correct parameters
@@ -262,7 +262,7 @@ func TestSubmitDataToDA_WithMetricsRecorder(t *testing.T) {
 
 	// Simulate DA success
 	da.On("GasMultiplier", mock.Anything).Return(2.0, nil)
-	da.On("SubmitWithOptions", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+	da.On("Submit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
 		Return([]coreda.ID{[]byte("id")}, nil)
 
 	// Expect RecordMetrics to be called with the correct parameters

core/da/da.go

@@ -13,28 +13,25 @@ type DA interface {
 	//
 	// Error should be returned if ID is not formatted properly, there is no Blob for given ID or any other client-level
 	// error occurred (dropped connection, timeout, etc).
-	Get(ctx context.Context, ids []ID, namespace []byte) ([]Blob, error)
+	Get(ctx context.Context, ids []ID) ([]Blob, error)
 
 	// GetIDs returns IDs of all Blobs located in DA at given height.
-	GetIDs(ctx context.Context, height uint64, namespace []byte) (*GetIDsResult, error)
+	GetIDs(ctx context.Context, height uint64) (*GetIDsResult, error)
 
 	// GetProofs returns inclusion Proofs for Blobs specified by their IDs.
-	GetProofs(ctx context.Context, ids []ID, namespace []byte) ([]Proof, error)
+	GetProofs(ctx context.Context, ids []ID) ([]Proof, error)
 
 	// Commit creates a Commitment for each given Blob.
-	Commit(ctx context.Context, blobs []Blob, namespace []byte) ([]Commitment, error)
+	Commit(ctx context.Context, blobs []Blob) ([]Commitment, error)
 
-	// Submit submits the Blobs to Data Availability layer.
+	// Submit submits the Blobs to Data Availability layer with additional options.
 	//
 	// This method is synchronous. Upon successful submission to Data Availability layer, it returns the IDs identifying blobs
 	// in DA.
-	Submit(ctx context.Context, blobs []Blob, gasPrice float64, namespace []byte) ([]ID, error)
-
-	// SubmitWithOptions submits the Blobs to Data Availability layer with additional options.
-	SubmitWithOptions(ctx context.Context, blobs []Blob, gasPrice float64, namespace []byte, options []byte) ([]ID, error)
+	Submit(ctx context.Context, blobs []Blob, gasPrice float64, options []byte) ([]ID, error)
 
 	// Validate validates Commitments against the corresponding Proofs. This should be possible without retrieving the Blobs.
-	Validate(ctx context.Context, ids []ID, proofs []Proof, namespace []byte) ([]bool, error)
+	Validate(ctx context.Context, ids []ID, proofs []Proof) ([]bool, error)
 
 	// GasPrice returns the gas price for the DA layer.
 	GasPrice(ctx context.Context) (float64, error)