core(da): da path and metadata refactor

block/fraud_test.go

@@ -318,9 +318,7 @@ func TestApplyBatchFromSLWithFraud(t *testing.T) {
 		})
 	}
 	slBatch := &settlement.Batch{
-		MetaData: &settlement.BatchMetaData{
-			DA: daResultSubmitBatch.SubmitMetaData,
-		},
+		MetaData:         daResultSubmitBatch.SubmitMetaData,
 		BlockDescriptors: bds,
 	}
 

block/manager_test.go

@@ -15,6 +15,7 @@ import (
 	"github.com/libp2p/go-libp2p/core/crypto"
 
 	"github.com/dymensionxyz/dymint/block"
+	"github.com/dymensionxyz/dymint/da/local"
 	"github.com/dymensionxyz/dymint/p2p"
 	"github.com/dymensionxyz/dymint/settlement"
 	"github.com/dymensionxyz/dymint/testutil"
@@ -207,12 +208,13 @@ func TestRetrieveDaBatchesFailed(t *testing.T) {
 	manager.DAClient = testutil.GetMockDALC(log.TestingLogger())
 	manager.Retriever = manager.DAClient.(da.BatchRetriever)
 
+	submitMetadata := local.SubmitMetaData{
+		Height: 1,
+	}
 	batch := &settlement.Batch{
-		MetaData: &settlement.BatchMetaData{
-			DA: &da.DASubmitMetaData{
-				Client: da.Mock,
-				Height: 1,
-			},
+		MetaData: &da.DASubmitMetaData{
+			Client: da.Mock,
+			DAPath: submitMetadata.ToPath(),
 		},
 	}
 
@@ -545,7 +547,7 @@ func TestDAFetch(t *testing.T) {
 		{
 			name:       "wrong DA",
 			manager:    manager,
-			daMetaData: &da.DASubmitMetaData{Client: da.Celestia, Height: daResultSubmitBatch.SubmitMetaData.Height},
+			daMetaData: &da.DASubmitMetaData{Client: da.Celestia, DAPath: daResultSubmitBatch.SubmitMetaData.ToPath()},
 			batch:      batch,
 			err:        da.ErrDAMismatch,
 		},
@@ -566,9 +568,7 @@ func TestDAFetch(t *testing.T) {
 				})
 			}
 			slBatch := &settlement.Batch{
-				MetaData: &settlement.BatchMetaData{
-					DA: c.daMetaData,
-				},
+				MetaData:         c.daMetaData,
 				BlockDescriptors: bds,
 				EndHeight:        batch.EndHeight(),
 			}

block/retriever.go

@@ -11,13 +11,13 @@ import (
 )
 
 func (m *Manager) ApplyBatchFromSL(slBatch *settlement.Batch) error {
-	m.logger.Debug("trying to retrieve batch from DA", "daHeight", slBatch.MetaData.DA.Height)
-	batchResp := m.fetchBatch(slBatch.MetaData.DA)
+	m.logger.Debug("trying to retrieve batch from DA", "DA Metadata", slBatch.MetaData)
+	batchResp := m.fetchBatch(slBatch.MetaData)
 	if batchResp.Code != da.StatusSuccess {
 		return batchResp.Error
 	}
 
-	m.logger.Debug("retrieved batches", "n", len(batchResp.Batches), "daHeight", slBatch.MetaData.DA.Height)
+	m.logger.Debug("retrieved batches", "n", len(batchResp.Batches), "dametadata", slBatch.MetaData)
 
 	m.retrieverMu.Lock()
 	defer m.retrieverMu.Unlock()
@@ -46,7 +46,7 @@ func (m *Manager) ApplyBatchFromSL(slBatch *settlement.Batch) error {
 			}
 
 			// We dont validate because validateBlockBeforeApply already checks if the block is already applied, and we don't need to fail there.
-			err := m.validateAndApplyBlock(block, batch.Commits[i], types.BlockMetaData{Source: types.DA, DAHeight: slBatch.MetaData.DA.Height})
+			err := m.validateAndApplyBlock(block, batch.Commits[i], types.BlockMetaData{Source: types.DA})
 			if err != nil {
 				return fmt.Errorf("apply block: height: %d: %w", block.Header.Height, err)
 			}
@@ -113,7 +113,7 @@ func (m *Manager) fetchBatch(daMetaData *da.DASubmitMetaData) da.ResultRetrieveB
 	}
 
 	// batchRes.MetaData includes proofs necessary to open disputes with the Hub
-	batchRes := m.Retriever.RetrieveBatches(daMetaData)
+	batchRes := m.Retriever.RetrieveBatches(daMetaData.DAPath)
 	// TODO(srene) : for invalid transactions there is no specific error code since it will need to be validated somewhere else for fraud proving.
 	// NMT proofs (availRes.MetaData.Proofs) are included in the result batchRes, necessary to be included in the dispute
 	return batchRes

block/slvalidator.go

@@ -3,7 +3,6 @@ package block
 import (
 	"bytes"
 	"crypto/sha256"
-	"encoding/hex"
 	"errors"
 	"fmt"
 	"sync/atomic"
@@ -73,20 +72,20 @@ func (v *SettlementValidator) ValidateStateUpdate(batch *settlement.ResultRetrie
 	// load all DA blocks from the batch to be validated
 	var daBatch da.ResultRetrieveBatch
 	for {
-		daBatch = v.blockManager.Retriever.RetrieveBatches(batch.MetaData.DA)
+		daBatch = v.blockManager.fetchBatch(batch.MetaData)
 		if daBatch.Code == da.StatusSuccess {
 			break
 		}
 
 		// fraud detected in case blob is retrieved but unable to get blocks from it.
 		if errors.Is(daBatch.BaseResult.Error, da.ErrBlobNotParsed) {
-			return types.NewErrStateUpdateBlobCorruptedFraud(batch.StateIndex, string(batch.MetaData.DA.Client), batch.MetaData.DA.Height, hex.EncodeToString(batch.MetaData.DA.Commitment))
+			return types.NewErrStateUpdateBlobCorruptedFraud(batch.StateIndex, string(batch.MetaData.Client), batch.MetaData.DAPath)
 		}
 
 		// fraud detected in case availability checks fail and therefore there certainty the blob, according to the state update DA path, is not available.
-		checkBatchResult := v.blockManager.Retriever.CheckBatchAvailability(batch.MetaData.DA)
+		checkBatchResult := v.blockManager.Retriever.CheckBatchAvailability(batch.MetaData.DAPath)
 		if errors.Is(checkBatchResult.Error, da.ErrBlobNotIncluded) {
-			return types.NewErrStateUpdateBlobNotAvailableFraud(batch.StateIndex, string(batch.MetaData.DA.Client), batch.MetaData.DA.Height, hex.EncodeToString(batch.MetaData.DA.Commitment))
+			return types.NewErrStateUpdateBlobNotAvailableFraud(batch.StateIndex, string(batch.MetaData.Client), batch.MetaData.DAPath)
 		}
 
 		// FIXME: how to handle non-happy case? not returning error?

block/slvalidator_test.go

@@ -414,13 +414,11 @@ func getSLBatch(bds []rollapp.BlockDescriptor, daMetaData *da.DASubmitMetaData,
 	return &settlement.ResultRetrieveBatch{
 		Batch: &settlement.Batch{
 			BlockDescriptors: bds,
-			MetaData: &settlement.BatchMetaData{
-				DA: daMetaData,
-			},
-			StartHeight:   startHeight,
-			EndHeight:     endHeight,
-			NumBlocks:     endHeight - startHeight + 1,
-			NextSequencer: nextSequencer,
+			MetaData:         daMetaData,
+			StartHeight:      startHeight,
+			EndHeight:        endHeight,
+			NumBlocks:        endHeight - startHeight + 1,
+			NextSequencer:    nextSequencer,
 		},
 		ResultBase: settlement.ResultBase{
 			StateIndex: 1,

da/avail/avail.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"fmt"
 	"math"
+	"strconv"
 	"time"
 
 	"github.com/avast/retry-go/v4"
@@ -71,6 +72,31 @@ type DataAvailabilityLayerClient struct {
 	synced             chan struct{}
 }
 
+// SubmitMetaData contains meta data about a batch on the Data Availability Layer.
+type SubmitMetaData struct {
+	// Height is the height of the block in the da layer
+	Height uint64
+}
+
+// ToPath converts a SubmitMetaData to a path.
+func (d *SubmitMetaData) ToPath() string {
+	return strconv.FormatUint(d.Height, 10)
+}
+
+// FromPath parses a path to a SubmitMetaData.
+func (d *SubmitMetaData) FromPath(path string) (*SubmitMetaData, error) {
+	height, err := strconv.ParseUint(path, 10, 64)
+	if err != nil {
+		return nil, err
+	}
+
+	submitData := &SubmitMetaData{
+		Height: height,
+	}
+
+	return submitData, nil
+}
+
 var (
 	_ da.DataAvailabilityLayerClient = &DataAvailabilityLayerClient{}
 	_ da.BatchRetriever              = &DataAvailabilityLayerClient{}
@@ -169,7 +195,12 @@ func (c *DataAvailabilityLayerClient) GetClientType() da.Client {
 }
 
 // RetrieveBatches retrieves batch from DataAvailabilityLayerClient instance.
-func (c *DataAvailabilityLayerClient) RetrieveBatches(daMetaData *da.DASubmitMetaData) da.ResultRetrieveBatch {
+func (c *DataAvailabilityLayerClient) RetrieveBatches(daPath string) da.ResultRetrieveBatch {
+	daMetaData := &SubmitMetaData{}
+	daMetaData, err := daMetaData.FromPath(daPath)
+	if err != nil {
+		return da.ResultRetrieveBatch{BaseResult: da.BaseResult{Code: da.StatusError, Message: "read da path", Error: err}}
+	}
 	//nolint:typecheck
 	blockHash, err := c.client.GetBlockHash(daMetaData.Height)
 	if err != nil {
@@ -238,9 +269,6 @@ func (c *DataAvailabilityLayerClient) RetrieveBatches(daMetaData *da.DASubmitMet
 		BaseResult: da.BaseResult{
 			Code: da.StatusSuccess,
 		},
-		CheckMetaData: &da.DACheckMetaData{
-			Height: daMetaData.Height,
-		},
 		Batches: batches,
 	}
 }
@@ -308,6 +336,7 @@ func (c *DataAvailabilityLayerClient) submitBatchLoop(dataBlob []byte) da.Result
 				continue
 			}
 			metrics.RollappConsecutiveFailedDASubmission.Set(0)
+			submitMetadata := &SubmitMetaData{Height: daBlockHeight}
 
 			c.logger.Debug("Successfully submitted batch.")
 			return da.ResultSubmitBatch{
@@ -316,8 +345,8 @@ func (c *DataAvailabilityLayerClient) submitBatchLoop(dataBlob []byte) da.Result
 					Message: "success",
 				},
 				SubmitMetaData: &da.DASubmitMetaData{
+					DAPath: submitMetadata.ToPath(),
 					Client: da.Avail,
-					Height: daBlockHeight,
 				},
 			}
 		}
@@ -425,7 +454,7 @@ func (c *DataAvailabilityLayerClient) broadcastTx(tx []byte) (uint64, error) {
 }
 
 // CheckBatchAvailability checks batch availability in DataAvailabilityLayerClient instance.
-func (c *DataAvailabilityLayerClient) CheckBatchAvailability(daMetaData *da.DASubmitMetaData) da.ResultCheckBatch {
+func (c *DataAvailabilityLayerClient) CheckBatchAvailability(daPath string) da.ResultCheckBatch {
 	return da.ResultCheckBatch{
 		BaseResult: da.BaseResult{
 			Code:    da.StatusSuccess,

da/avail/avail_test.go

@@ -98,10 +98,10 @@ func TestRetrieveBatches(t *testing.T) {
 	mockSubstrateApiClient.On("GetBlock", mock.Anything).Return(signedBlock, nil)
 
 	// Retrieve the batches and make sure we only get the batches relevant for our app id
-	daMetaData := &da.DASubmitMetaData{
+	daMetaData := &avail.SubmitMetaData{
 		Height: 1,
 	}
-	batchResult := dalc.RetrieveBatches(daMetaData)
+	batchResult := dalc.RetrieveBatches(daMetaData.ToPath())
 	assert.Equal(1, len(batchResult.Batches))
 	assert.Equal(batch1.StartHeight(), batchResult.Batches[0].StartHeight())
 }