Disk storage mock dalc 134

da/mock/mock.go

@@ -1,6 +1,8 @@
 package mock
 
 import (
+	"encoding/binary"
+
 	"github.com/celestiaorg/optimint/da"
 	"github.com/celestiaorg/optimint/log"
 	"github.com/celestiaorg/optimint/store"
@@ -14,16 +16,19 @@ type MockDataAvailabilityLayerClient struct {
 
 	Blocks     map[[32]byte]*types.Block
 	BlockIndex map[uint64][32]byte
+
+	dalcKV store.KVStore
 }
 
 var _ da.DataAvailabilityLayerClient = &MockDataAvailabilityLayerClient{}
 var _ da.BlockRetriever = &MockDataAvailabilityLayerClient{}
 
 // Init is called once to allow DA client to read configuration and initialize resources.
-func (m *MockDataAvailabilityLayerClient) Init(config []byte, kvStore store.KVStore, logger log.Logger) error {
+func (m *MockDataAvailabilityLayerClient) Init(config []byte, dalcKV store.KVStore, logger log.Logger) error {
 	m.logger = logger
 	m.Blocks = make(map[[32]byte]*types.Block)
 	m.BlockIndex = make(map[uint64][32]byte)
+	m.dalcKV = dalcKV
 	return nil
 }
 
@@ -46,6 +51,22 @@ func (m *MockDataAvailabilityLayerClient) SubmitBlock(block *types.Block) da.Res
 	m.logger.Debug("Submitting block to DA layer!", "height", block.Header.Height)
 
 	hash := block.Header.Hash()
+	blob, err := block.MarshalBinary()
+	if err != nil {
+		return da.ResultSubmitBlock{
+			DAResult: da.DAResult{
+				Code:    da.StatusError,
+				Message: err.Error(),
+			},
+		}
+	}
+
+	b := make([]byte, 8)
+	binary.LittleEndian.PutUint64(b, block.Header.Height)
+
+	m.dalcKV.Set(b, hash[:])
+	m.dalcKV.Set(hash[:], blob)
+
 	m.Blocks[hash] = block
 	m.BlockIndex[block.Header.Height] = hash
 
@@ -65,6 +86,22 @@ func (m *MockDataAvailabilityLayerClient) CheckBlockAvailability(header *types.H
 
 // RetrieveBlock returns block at given height from data availability layer.
 func (m *MockDataAvailabilityLayerClient) RetrieveBlock(height uint64) da.ResultRetrieveBlock {
-	hash := m.BlockIndex[height]
-	return da.ResultRetrieveBlock{DAResult: da.DAResult{Code: da.StatusSuccess}, Block: m.Blocks[hash]}
+	b := make([]byte, 8)
+	binary.LittleEndian.PutUint64(b, height)
+	hash, err := m.dalcKV.Get(b)
+	if err != nil {
+		return da.ResultRetrieveBlock{DAResult: da.DAResult{Code: da.StatusError, Message: err.Error()}}
+	}
+	blob, err := m.dalcKV.Get(hash)
+	if err != nil {
+		return da.ResultRetrieveBlock{DAResult: da.DAResult{Code: da.StatusError, Message: err.Error()}}
+	}
+
+	block := &types.Block{}
+	err = block.UnmarshalBinary(blob)
+	if err != nil {
+		return da.ResultRetrieveBlock{DAResult: da.DAResult{Code: da.StatusError, Message: err.Error()}}
+	}
+
+	return da.ResultRetrieveBlock{DAResult: da.DAResult{Code: da.StatusSuccess}, Block: block}
 }

da/mock/mock_test.go

@@ -9,15 +9,21 @@ import (
 
 	"github.com/celestiaorg/optimint/da"
 	"github.com/celestiaorg/optimint/log/test"
+	"github.com/celestiaorg/optimint/store"
 	"github.com/celestiaorg/optimint/types"
 )
 
+var (
+	dalcPrefix                 = []byte{1}
+	dalcKV     *store.PrefixKV = store.NewPrefixKV(store.NewInMemoryKVStore(), dalcPrefix)
+)
+
 func TestLifecycle(t *testing.T) {
 	var da da.DataAvailabilityLayerClient = &MockDataAvailabilityLayerClient{}
 
 	require := require.New(t)
 
-	err := da.Init([]byte{}, nil, &test.TestLogger{T: t})
+	err := da.Init([]byte{}, dalcKV, &test.TestLogger{T: t})
 	require.NoError(err)
 
 	err = da.Start()
@@ -33,7 +39,7 @@ func TestMockDALC(t *testing.T) {
 	require := require.New(t)
 	assert := assert.New(t)
 
-	err := dalc.Init([]byte{}, nil, &test.TestLogger{T: t})
+	err := dalc.Init([]byte{}, dalcKV, &test.TestLogger{T: t})
 	require.NoError(err)
 
 	err = dalc.Start()
@@ -72,7 +78,7 @@ func TestRetrieve(t *testing.T) {
 	require := require.New(t)
 	assert := assert.New(t)
 
-	err := dalc.Init([]byte{}, nil, &test.TestLogger{T: t})
+	err := dalc.Init([]byte{}, dalcKV, &test.TestLogger{T: t})
 	require.NoError(err)
 
 	err = dalc.Start()
@@ -109,6 +115,13 @@ func getRandomBlock(height uint64, nTxs int) *types.Block {
 		block.Data.IntermediateStateRoots.RawRootsList[i] = getRandomBytes(32)
 	}
 
+	// TODO(https://github.com/celestiaorg/optimint/issues/143)
+	// This is a hack to get around equality checks on serialization round trips
+	if nTxs == 0 {
+		block.Data.Txs = nil
+		block.Data.IntermediateStateRoots.RawRootsList = nil
+	}
+
 	return block
 }
 

types/serialization_test.go

@@ -69,7 +69,6 @@ func TestBlockSerializationRoundTrip(t *testing.T) {
 			deserialized := &Block{}
 			err = deserialized.UnmarshalBinary(blob)
 			assert.NoError(err)
-
 			assert.Equal(c.input, deserialized)
 		})
 	}