feat(da): RetrieveBatchesV2 method

da/da.go

@@ -207,9 +207,8 @@ type ResultRetrieveBatch struct {
 // ResultRetrieveBatchV2 contains a batch of blocks returned from the DA layer client.
 type ResultRetrieveBatchV2 struct {
 	BaseResult
-	// Batches is the full block retrieved from the DA layer.
-	// If BaseResult.Code is not StatusSuccess, this field is nil.
-	Batches []*types.Batch
+	// Batch is the full block retrieved from the DA layer.
+	Batch types.Batch
 }
 
 // Path TODO: move to the Dymension proto file
@@ -260,7 +259,7 @@ type ClientV2 interface {
 	Stop() error
 
 	// SubmitBatchV2 submits the passed in block to the DA layer.
-	SubmitBatchV2(*types.Batch) ResultSubmitBatchV2
+	SubmitBatchV2(types.Batch) ResultSubmitBatchV2
 
 	GetClientType() Client
 

da/interchain/chain_client.go

@@ -51,6 +51,16 @@ func (c *daClient) Params(ctx context.Context) (interchainda.Params, error) {
 	return resp.GetParams(), nil
 }
 
+func (c *daClient) Blob(ctx context.Context, id interchainda.BlobID) (*interchainda.QueryBlobResponse, error) {
+	resp, err := c.queryClient.Blob(ctx, &interchainda.QueryBlobRequest{
+		BlobId: uint64(id),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("can't query DA layer params: %w", err)
+	}
+	return resp, nil
+}
+
 func (c *daClient) GetTx(ctx context.Context, txHash string) (*tx.GetTxResponse, error) {
 	return c.txService.GetTx(ctx, &tx.GetTxRequest{Hash: txHash})
 }

da/interchain/helpers.go

@@ -0,0 +1,50 @@
+package interchain
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/dymensionxyz/dymint/da/interchain/ioutils"
+	"github.com/dymensionxyz/dymint/types"
+)
+
+// EncodeBatch encodes the batch to the interchain DA layer format.
+// The batch is represented in binary and gzipped.
+func EncodeBatch(b types.Batch) ([]byte, error) {
+	// Prepare the blob data
+	blob, err := b.MarshalBinary()
+	if err != nil {
+		return nil, fmt.Errorf("can't marshal batch: %w", err)
+	}
+
+	// Gzip the blob
+	gzipped, err := ioutils.Gzip(blob)
+	if err != nil {
+		return nil, fmt.Errorf("can't gzip batch: %w", err)
+	}
+
+	return gzipped, nil
+}
+
+// DecodeBatch decodes the batch from the interchain DA layer format.
+// The incoming batch must be a gzipped binary.
+func DecodeBatch(b []byte) (types.Batch, error) {
+	if !ioutils.IsGzip(b) {
+		return types.Batch{}, errors.New("batch is not gzip-compressed")
+	}
+
+	// Gunzip the blob
+	binary, err := ioutils.Gunzip(b)
+	if err != nil {
+		return types.Batch{}, fmt.Errorf("can't gunzip batch: %w", err)
+	}
+
+	// Prepare the blob data
+	var batch types.Batch
+	err = batch.UnmarshalBinary(binary)
+	if err != nil {
+		return types.Batch{}, fmt.Errorf("can't unmarshal batch: %w", err)
+	}
+
+	return batch, nil
+}

da/interchain/helpers_test.go

@@ -0,0 +1,69 @@
+package interchain_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/dymensionxyz/dymint/da/interchain"
+	"github.com/dymensionxyz/dymint/types"
+)
+
+func FuzzEncodeDecodeBatch1(f *testing.F) {
+	f.Add(uint64(0), uint64(0))
+
+	f.Fuzz(func(t *testing.T, h1, h2 uint64) {
+		// Generate batches with random headers
+		expected := types.Batch{
+			StartHeight: h1,
+			EndHeight:   h2,
+			Blocks:      []*types.Block{},
+			Commits:     []*types.Commit{},
+		}
+
+		data, err := interchain.EncodeBatch(expected)
+		require.NoError(t, err)
+
+		actual, err := interchain.DecodeBatch(data)
+		require.NoError(t, err)
+
+		require.Equal(t, expected, actual)
+	})
+}
+
+func TestEncodeDecodeBatch(t *testing.T) {
+	expected := types.Batch{
+		StartHeight: 1,
+		EndHeight:   123,
+		Blocks: []*types.Block{
+			{
+				Header: types.Header{
+					Height: 1,
+				},
+			},
+			{
+				Header: types.Header{
+					Height: 2,
+				},
+			},
+		},
+		Commits: []*types.Commit{
+			{
+				Height: 1,
+			},
+			{
+				Height: 2,
+			},
+		},
+	}
+
+	data, err := interchain.EncodeBatch(expected)
+	require.NoError(t, err)
+
+	actual, err := interchain.DecodeBatch(data)
+	require.NoError(t, err)
+
+	require.True(t, reflect.DeepEqual(expected, actual))
+	require.Equal(t, expected, actual)
+}

da/interchain/interchain.go

@@ -31,6 +31,7 @@ type DAClient interface {
 	Context() sdkclient.Context
 	BroadcastTx(string, ...sdk.Msg) (cosmosclient.Response, error)
 	Params(context.Context) (interchainda.Params, error)
+	Blob(ctx context.Context, id interchainda.BlobID) (*interchainda.QueryBlobResponse, error)
 	GetTx(context.Context, string) (*tx.GetTxResponse, error)
 	ABCIQueryWithProof(ctx context.Context, path string, data bytes.HexBytes, height int64) (*ctypes.ResultABCIQuery, error)
 }

da/interchain/interchain_test.go

@@ -13,7 +13,7 @@ import (
 )
 
 // TODO: add interchain DA chain mock
-func TestDALayerClient_Init(t *testing.T) {
+func TestDALayerClient(t *testing.T) {
 	t.Skip() // Test is not finished yet
 
 	client := new(interchain.DALayerClient)
@@ -25,12 +25,18 @@ func TestDALayerClient_Init(t *testing.T) {
 	err = client.Init(rawConfig, nil, nil, logger)
 	require.NoError(t, err)
 
-	result := client.SubmitBatchV2(&types.Batch{
+	batch := types.Batch{
 		StartHeight: 1,
 		EndHeight:   3,
 		Blocks:      []*types.Block{{Header: types.Header{Height: 1}}},
 		Commits:     []*types.Commit{{Height: 1}},
-	})
-	require.NoError(t, result.Error)
-	t.Logf("result: %#v", result)
+	}
+
+	submitResult := client.SubmitBatchV2(batch)
+	require.NoError(t, submitResult.Error)
+
+	retrieveResult := client.RetrieveBatchesV2(submitResult)
+	require.NoError(t, retrieveResult.Error)
+
+	require.Equal(t, batch, retrieveResult.Batch)
 }

da/interchain/retrieve_batches.go

@@ -1,11 +1,59 @@
 package interchain
 
-import "github.com/dymensionxyz/dymint/da"
+import (
+	"fmt"
+
+	"github.com/dymensionxyz/dymint/da"
+	"github.com/dymensionxyz/dymint/types"
+	interchainda "github.com/dymensionxyz/dymint/types/pb/interchain_da"
+)
 
 func (c *DALayerClient) RetrieveBatches(daMetaData *da.DASubmitMetaData) da.ResultRetrieveBatch {
 	panic("RetrieveBatches method is not supported by the interchain DA clint")
 }
 
-func (c *DALayerClient) RetrieveBatchesV2(da.ResultSubmitBatchV2) da.ResultRetrieveBatchV2 {
-	panic("implement me")
+func (c *DALayerClient) RetrieveBatchesV2(b da.ResultSubmitBatchV2) da.ResultRetrieveBatchV2 {
+	batch, err := c.retrieveBatches(b)
+	if err != nil {
+		return da.ResultRetrieveBatchV2{
+			BaseResult: da.BaseResult{
+				Code:    da.StatusError,
+				Message: fmt.Sprintf("can't retrieve batch from the interchain DA layer: %s", err.Error()),
+				Error:   err,
+			},
+			Batch: types.Batch{},
+		}
+	}
+
+	return da.ResultRetrieveBatchV2{
+		BaseResult: da.BaseResult{
+			Code:    da.StatusSuccess,
+			Message: "Retrieve successful",
+		},
+		Batch: batch,
+	}
+}
+
+func (c *DALayerClient) retrieveBatches(b da.ResultSubmitBatchV2) (types.Batch, error) {
+	var commitment *interchainda.Commitment
+	err := c.cdc.UnpackAny(b.DAPath.Commitment, &commitment)
+	if err != nil {
+		return types.Batch{}, fmt.Errorf("can't unpack commitment: %w", err)
+	}
+
+	resp, err := c.daClient.Blob(c.ctx, interchainda.BlobID(commitment.BlobId))
+	if err != nil {
+		return types.Batch{}, fmt.Errorf("can't get blob from the interchain DA layer: %w", err)
+	}
+
+	if resp.BlobMetadata.BlobHash != commitment.BlobHash {
+		return types.Batch{}, fmt.Errorf("commitment blob hash doesn't match interchain DA layer blob hash")
+	}
+
+	batch, err := DecodeBatch(resp.Blob)
+	if err != nil {
+		return types.Batch{}, fmt.Errorf("can't decode batch from interchain DA layer: %w", err)
+	}
+
+	return batch, nil
 }

da/interchain/submit_batch.go

@@ -13,7 +13,6 @@ import (
 	"github.com/dymensionxyz/cosmosclient/cosmosclient"
 
 	"github.com/dymensionxyz/dymint/da"
-	"github.com/dymensionxyz/dymint/da/interchain/ioutils"
 	"github.com/dymensionxyz/dymint/types"
 	interchainda "github.com/dymensionxyz/dymint/types/pb/interchain_da"
 )
@@ -22,7 +21,7 @@ func (c *DALayerClient) SubmitBatch(*types.Batch) da.ResultSubmitBatch {
 	panic("SubmitBatch method is not supported by the interchain DA clint")
 }
 
-func (c *DALayerClient) SubmitBatchV2(batch *types.Batch) da.ResultSubmitBatchV2 {
+func (c *DALayerClient) SubmitBatchV2(batch types.Batch) da.ResultSubmitBatchV2 {
 	commitment, err := c.submitBatch(batch)
 	if err != nil {
 		return da.ResultSubmitBatchV2{
@@ -62,17 +61,10 @@ func (c *DALayerClient) SubmitBatchV2(batch *types.Batch) da.ResultSubmitBatchV2
 }
 
 // submitBatch is used to process and transmit batches to the interchain DA.
-func (c *DALayerClient) submitBatch(batch *types.Batch) (*interchainda.Commitment, error) {
-	// Prepare the blob data
-	blob, err := batch.MarshalBinary()
+func (c *DALayerClient) submitBatch(batch types.Batch) (*interchainda.Commitment, error) {
+	blob, err := EncodeBatch(batch)
 	if err != nil {
-		return nil, fmt.Errorf("can't marshal batch: %w", err)
-	}
-
-	// Gzip the blob
-	gzipped, err := ioutils.Gzip(blob)
-	if err != nil {
-		return nil, fmt.Errorf("can't gzip batch: %w", err)
+		return nil, fmt.Errorf("can't encode batch to interchain DA format: %w", err)
 	}
 
 	// Verify the size of the blob is within the limit
@@ -86,7 +78,7 @@ func (c *DALayerClient) submitBatch(batch *types.Batch) (*interchainda.Commitmen
 	// Prepare the message to be sent to the DA layer
 	msg := interchainda.MsgSubmitBlob{
 		Creator: c.accountAddress,
-		Blob:    gzipped,
+		Blob:    blob,
 		Fees:    feesToPay,
 	}