chore: revert da cleanup (#2399)

<!--
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

<!-- 
Please provide an explanation of the PR, including the appropriate
context,
background, goal, and rationale. If there is an issue with this
information,
please provide a tl;dr and link the issue. 

Ex: Closes #<issue number>
-->


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

## Summary by CodeRabbit

* **New Features**
* Added support for specifying namespaces in data availability
operations, enabling more granular data scoping and retrieval.
* Introduced the ability to submit blobs with additional options for
enhanced flexibility.

* **Bug Fixes**
* Improved handling of multiple submissions and height simulation in
dummy data availability implementations.

* **Tests**
* Updated and extended test suites to cover namespace-aware operations
and new submission methods.
  * Added new end-to-end tests for transaction submission and retrieval.

* **Chores**
  * Enhanced test output verbosity for better debugging.
  * Updated dependencies for improved compatibility and stability.

* **Documentation**
* Clarified method behaviors and updated comments to reflect new
parameters and logic.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Co-authored-by: tac0turtle <you@example.com>
Co-authored-by: chatton <github.qpeyb@simplelogin.fr>

Author: 3 people

block/da_speed_test.go

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

block/retriever.go

@@ -212,7 +212,7 @@ func (m *Manager) fetchBlobs(ctx context.Context, daHeight uint64) (coreda.Resul
 	ctx, cancel := context.WithTimeout(ctx, dAefetcherTimeout)
 	defer cancel()
 	// TODO: we should maintain the original error instead of creating a new one as we lose context by creating a new error.
-	blobsRes := types.RetrieveWithHelpers(ctx, m.da, m.logger, daHeight)
+	blobsRes := types.RetrieveWithHelpers(ctx, m.da, m.logger, daHeight, []byte(m.genesis.ChainID))
 	switch blobsRes.Code {
 	case coreda.StatusError:
 		err = fmt.Errorf("failed to retrieve block: %s", blobsRes.Message)

block/retriever_test.go

@@ -136,11 +136,11 @@ func TestProcessNextDAHeader_Success_SingleHeaderAndData(t *testing.T) {
 	blockDataBytes, err := signedData.MarshalBinary()
 	require.NoError(t, err)
 	// -----------------------------------------------------------
-	mockDAClient.On("GetIDs", mock.Anything, daHeight).Return(&coreda.GetIDsResult{
+	mockDAClient.On("GetIDs", mock.Anything, daHeight, mock.Anything).Return(&coreda.GetIDsResult{
 		IDs:       []coreda.ID{[]byte("dummy-id")},
 		Timestamp: time.Now(),
 	}, nil).Once()
-	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}).Return(
+	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}, mock.Anything).Return(
 		[]coreda.Blob{headerBytes, blockDataBytes}, nil,
 	).Once()
 
@@ -248,11 +248,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).Return(&coreda.GetIDsResult{
+	mockDAClient.On("GetIDs", mock.Anything, daHeight, mock.Anything).Return(&coreda.GetIDsResult{
 		IDs:       []coreda.ID{[]byte("dummy-id")},
 		Timestamp: time.Now(),
 	}, nil).Once()
-	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}).Return(
+	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}, mock.Anything).Return(
 		blobs, nil,
 	).Once()
 
@@ -313,7 +313,7 @@ func TestProcessNextDAHeaderAndData_NotFound(t *testing.T) {
 
 	// Mock GetIDs to return empty IDs to simulate "not found" scenario
 	// Example updates needed for one instance:
-	mockDAClient.On("GetIDs", mock.Anything, daHeight).Return(&coreda.GetIDsResult{
+	mockDAClient.On("GetIDs", mock.Anything, daHeight, mock.Anything).Return(&coreda.GetIDsResult{
 		IDs:       []coreda.ID{},
 		Timestamp: time.Now(),
 	}, coreda.ErrBlobNotFound).Once()
@@ -346,13 +346,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).Return(&coreda.GetIDsResult{
+	mockDAClient.On("GetIDs", mock.Anything, daHeight, mock.Anything).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")}).Return(
+	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}, mock.Anything).Return(
 		[]coreda.Blob{invalidBytes}, nil,
 	).Once()
 
@@ -405,13 +405,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).Return(&coreda.GetIDsResult{
+	mockDAClient.On("GetIDs", mock.Anything, daHeight, mock.Anything).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")}).Return(
+	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}, mock.Anything).Return(
 		[]coreda.Blob{headerBytes}, nil,
 	).Once()
 
@@ -449,7 +449,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).Return(
+	mockDAClient.On("GetIDs", mock.Anything, daHeight, mock.Anything).Return(
 		nil, fetchErr,
 	).Times(dAFetcherRetries)
 
@@ -539,7 +539,7 @@ func TestProcessNextDAHeader_HeaderAndDataAlreadySeen(t *testing.T) {
 		Timestamp: time.Now(),
 	}, nil).Once()
 
-	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}).Return(
+	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}, mock.Anything).Return(
 		[]coreda.Blob{headerBytes, blockDataBytes}, nil,
 	).Once()
 
@@ -577,12 +577,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).Return(
+	mockDAClient.On("GetIDs", mock.Anything, startDAHeight, mock.Anything).Return(
 		nil, futureErr,
 	).Once()
 
 	// Optional: Mock for the next height if needed
-	mockDAClient.On("GetIDs", mock.Anything, startDAHeight+1).Return(
+	mockDAClient.On("GetIDs", mock.Anything, startDAHeight+1, mock.Anything).Return(
 		&coreda.GetIDsResult{IDs: []coreda.ID{}}, coreda.ErrBlobNotFound,
 	).Maybe()
 
@@ -625,7 +625,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).Return(
+	mockDAClient.On("GetIDs", mock.Anything, startDAHeight, mock.Anything).Return(
 		nil, otherErr,
 	).Times(dAFetcherRetries)
 
@@ -709,11 +709,11 @@ func TestProcessNextDAHeader_WithNoTxs(t *testing.T) {
 	emptyDataBytes, err := emptySignedData.MarshalBinary()
 	require.NoError(t, err)
 
-	mockDAClient.On("GetIDs", mock.Anything, daHeight).Return(&coreda.GetIDsResult{
+	mockDAClient.On("GetIDs", mock.Anything, daHeight, mock.Anything).Return(&coreda.GetIDsResult{
 		IDs:       []coreda.ID{[]byte("dummy-id")},
 		Timestamp: time.Now(),
 	}, nil).Once()
-	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}).Return(
+	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}, mock.Anything).Return(
 		[]coreda.Blob{headerBytes, emptyDataBytes}, nil,
 	).Once()
 
@@ -762,23 +762,23 @@ func TestRetrieveLoop_DAHeightIncrementsOnlyOnSuccess(t *testing.T) {
 	require.NoError(t, err)
 
 	// 1. First call: success (header)
-	mockDAClient.On("GetIDs", mock.Anything, startDAHeight).Return(&coreda.GetIDsResult{
+	mockDAClient.On("GetIDs", mock.Anything, startDAHeight, mock.Anything).Return(&coreda.GetIDsResult{
 		IDs:       []coreda.ID{[]byte("dummy-id")},
 		Timestamp: time.Now(),
 	}, nil).Once()
-	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}).Return(
+	mockDAClient.On("Get", mock.Anything, []coreda.ID{[]byte("dummy-id")}, mock.Anything).Return(
 		[]coreda.Blob{headerBytes}, nil,
 	).Once()
 
 	// 2. Second call: NotFound
-	mockDAClient.On("GetIDs", mock.Anything, startDAHeight+1).Return(&coreda.GetIDsResult{
+	mockDAClient.On("GetIDs", mock.Anything, startDAHeight+1, mock.Anything).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).Return(
+	mockDAClient.On("GetIDs", mock.Anything, startDAHeight+2, mock.Anything).Return(
 		&coreda.GetIDsResult{
 			IDs:       nil,
 			Timestamp: time.Now(),

block/submitter_test.go

@@ -98,7 +98,7 @@ func TestSubmitDataToDA_Success(t *testing.T) {
 			return m.submitDataToDA(ctx, items)
 		},
 		mockDASetup: func(da *mocks.MockDA) {
-			da.On("Submit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+			da.On("SubmitWithOptions", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
 				Return([]coreda.ID{getDummyID(1, []byte("commitment"))}, nil)
 		},
 	})
@@ -117,7 +117,7 @@ func TestSubmitHeadersToDA_Success(t *testing.T) {
 			return m.submitHeadersToDA(ctx, items)
 		},
 		mockDASetup: func(da *mocks.MockDA) {
-			da.On("Submit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+			da.On("SubmitWithOptions", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
 				Return([]coreda.ID{getDummyID(1, []byte("commitment"))}, nil)
 		},
 	})
@@ -187,7 +187,7 @@ func TestSubmitDataToDA_Failure(t *testing.T) {
 				daError:  tc.daError,
 				mockDASetup: func(da *mocks.MockDA, gasPriceHistory *[]float64, daError error) {
 					da.ExpectedCalls = nil
-					da.On("Submit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+					da.On("SubmitWithOptions", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
 						Run(func(args mock.Arguments) { *gasPriceHistory = append(*gasPriceHistory, args.Get(2).(float64)) }).
 						Return(nil, daError)
 				},
@@ -222,7 +222,7 @@ func TestSubmitHeadersToDA_Failure(t *testing.T) {
 				daError:  tc.daError,
 				mockDASetup: func(da *mocks.MockDA, gasPriceHistory *[]float64, daError error) {
 					da.ExpectedCalls = nil
-					da.On("Submit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+					da.On("SubmitWithOptions", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
 						Run(func(args mock.Arguments) { *gasPriceHistory = append(*gasPriceHistory, args.Get(2).(float64)) }).
 						Return(nil, daError)
 				},
@@ -262,15 +262,15 @@ func runRetryPartialFailuresCase[T any](t *testing.T, tc retryPartialFailuresCas
 
 	// Set up DA mock: three calls, each time only one item is accepted
 	da.On("GasMultiplier", mock.Anything).Return(2.0, nil).Times(3)
-	da.On("Submit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+	da.On("SubmitWithOptions", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
 		Run(func(args mock.Arguments) {
 			t.Logf("DA Submit call 1: args=%#v", args)
 		}).Once().Return([]coreda.ID{getDummyID(1, []byte("commitment2"))}, nil)
-	da.On("Submit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+	da.On("SubmitWithOptions", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
 		Run(func(args mock.Arguments) {
 			t.Logf("DA Submit call 2: args=%#v", args)
 		}).Once().Return([]coreda.ID{getDummyID(1, []byte("commitment3"))}, nil)
-	da.On("Submit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+	da.On("SubmitWithOptions", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
 		Run(func(args mock.Arguments) {
 			t.Logf("DA Submit call 3: args=%#v", args)
 		}).Once().Return([]coreda.ID{getDummyID(1, []byte("commitment4"))}, nil)
@@ -495,7 +495,7 @@ func TestSubmitHeadersToDA_WithMetricsRecorder(t *testing.T) {
 	require.NotEmpty(t, headers)
 
 	// Simulate DA layer successfully accepting the header submission
-	da.On("Submit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+	da.On("SubmitWithOptions", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
 		Return([]coreda.ID{[]byte("id")}, nil)
 
 	// Expect RecordMetrics to be called with the correct parameters
@@ -536,7 +536,7 @@ func TestSubmitDataToDA_WithMetricsRecorder(t *testing.T) {
 
 	// Simulate DA success
 	da.On("GasMultiplier", mock.Anything).Return(2.0, nil)
-	da.On("Submit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+	da.On("SubmitWithOptions", mock.Anything, 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,25 +13,28 @@ 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) ([]Blob, error)
+	Get(ctx context.Context, ids []ID, namespace []byte) ([]Blob, error)
 
 	// GetIDs returns IDs of all Blobs located in DA at given height.
-	GetIDs(ctx context.Context, height uint64) (*GetIDsResult, error)
+	GetIDs(ctx context.Context, height uint64, namespace []byte) (*GetIDsResult, error)
 
 	// GetProofs returns inclusion Proofs for Blobs specified by their IDs.
-	GetProofs(ctx context.Context, ids []ID) ([]Proof, error)
+	GetProofs(ctx context.Context, ids []ID, namespace []byte) ([]Proof, error)
 
 	// Commit creates a Commitment for each given Blob.
-	Commit(ctx context.Context, blobs []Blob) ([]Commitment, error)
+	Commit(ctx context.Context, blobs []Blob, namespace []byte) ([]Commitment, error)
 
-	// Submit submits the Blobs to Data Availability layer with additional options.
+	// Submit submits the Blobs to Data Availability layer.
 	//
 	// 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, options []byte) ([]ID, error)
+	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)
 
 	// Validate validates Commitments against the corresponding Proofs. This should be possible without retrieving the Blobs.
-	Validate(ctx context.Context, ids []ID, proofs []Proof) ([]bool, error)
+	Validate(ctx context.Context, ids []ID, proofs []Proof, namespace []byte) ([]bool, error)
 
 	// GasPrice returns the gas price for the DA layer.
 	GasPrice(ctx context.Context) (float64, error)