feat(dot/rpc/modules) implement state_queryStorage rpc method

dot/core/interface.go

@@ -61,6 +61,7 @@ type StorageState interface {
 	TrieState(root *common.Hash) (*rtstorage.TrieState, error)
 	StoreTrie(*rtstorage.TrieState, *types.Header) error
 	GetStateRootFromBlock(bhash *common.Hash) (*common.Hash, error)
+	GetStorage(root *common.Hash, key []byte) ([]byte, error)
 }
 
 // TransactionState is the interface for transaction state methods

dot/core/service.go

@@ -17,6 +17,7 @@ package core
 
 import (
 	"context"
+	"errors"
 	"math/big"
 	"os"
 	"sync"
@@ -40,6 +41,9 @@ var (
 	logger log.Logger       = log.New("pkg", "core")
 )
 
+// QueryKeyValueChanges represents the key-value data inside a block storage
+type QueryKeyValueChanges map[string]string
+
 // Service is an overhead layer that allows communication between the runtime,
 // BABE session, and network service. It deals with the validation of transactions
 // and blocks by calling their respective validation functions in the runtime.
@@ -550,3 +554,61 @@ func (s *Service) GetMetadata(bhash *common.Hash) ([]byte, error) {
 	rt.SetContextStorage(ts)
 	return rt.Metadata()
 }
+
+// QueryStorage returns the key-value data by block based on `keys` params
+// on every block starting `from` until `to` block, if `to` is not nil
+func (s *Service) QueryStorage(from *common.Hash, to *common.Hash, keys ...string) (map[common.Hash]QueryKeyValueChanges, error) {
+	if from == nil {
+		return nil, errors.New("cannot query data without a starting block hash")
+	}
+
+	var err error
+	blocksToQuery := []common.Hash{*from}
+	if to != nil {
+		if blocksToQuery, err = s.blockState.SubChain(*from, *to); err != nil {
+			return nil, err
+		}
+	}
+
+	queries := make(map[common.Hash]QueryKeyValueChanges)
+
+	for _, hash := range blocksToQuery {
+		changes, err := s.tryQueryStorage(hash, keys...)
+		if err != nil {
+			return nil, err
+		}
+
+		queries[hash] = changes
+	}
+
+	return queries, nil
+}
+
+// tryQueryStorage will try to get all the `keys` inside the block's current state
+func (s *Service) tryQueryStorage(block common.Hash, keys ...string) (QueryKeyValueChanges, error) {
+	stateRootHash, err := s.storageState.GetStateRootFromBlock(&block)
+	if err != nil {
+		return nil, err
+	}
+
+	changes := make(QueryKeyValueChanges)
+	for _, k := range keys {
+		keyBytes, err := common.HexToBytes(k)
+		if err != nil {
+			return nil, err
+		}
+
+		storedData, err := s.storageState.GetStorage(stateRootHash, keyBytes)
+		if err != nil {
+			return nil, err
+		}
+
+		if storedData == nil {
+			continue
+		}
+
+		changes[k] = common.BytesToHex(storedData)
+	}
+
+	return changes, nil
+}

dot/core/service_test.go

@@ -32,8 +32,10 @@ import (
 	"github.com/ChainSafe/gossamer/lib/keystore"
 	"github.com/ChainSafe/gossamer/lib/runtime"
 	"github.com/ChainSafe/gossamer/lib/runtime/extrinsic"
+	"github.com/ChainSafe/gossamer/lib/runtime/storage"
 	"github.com/ChainSafe/gossamer/lib/runtime/wasmer"
 	"github.com/ChainSafe/gossamer/lib/transaction"
+	"github.com/ChainSafe/gossamer/lib/trie"
 	"github.com/ChainSafe/gossamer/lib/utils"
 	log "github.com/ChainSafe/log15"
 	"github.com/stretchr/testify/require"
@@ -614,3 +616,171 @@ func TestService_HandleRuntimeChangesAfterCodeSubstitutes(t *testing.T) {
 
 	require.NotEqualf(t, codeHashBefore, rt.GetCodeHash(), "expected different code hash after runtime update") // codeHash should change after runtime change
 }
+
+func TestTryQueryStore_WhenThereIsDataToRetrieve(t *testing.T) {
+	s := NewTestService(t, nil)
+	storageStateTrie, err := storage.NewTrieState(trie.NewTrie(nil))
+
+	testKey, testValue := []byte("to"), []byte("0x1723712318238AB12312")
+	storageStateTrie.Set(testKey, testValue)
+	require.NoError(t, err)
+
+	header, err := types.NewHeader(s.blockState.GenesisHash(), storageStateTrie.MustRoot(),
+		common.Hash{}, big.NewInt(1), nil)
+	require.NoError(t, err)
+
+	err = s.storageState.StoreTrie(storageStateTrie, header)
+	require.NoError(t, err)
+
+	testBlock := &types.Block{
+		Header: header,
+		Body:   types.NewBody([]byte{}),
+	}
+
+	err = s.blockState.AddBlock(testBlock)
+	require.NoError(t, err)
+
+	blockhash := testBlock.Header.Hash()
+	hexKey := common.BytesToHex(testKey)
+	keys := []string{hexKey}
+
+	changes, err := s.tryQueryStorage(blockhash, keys...)
+	require.NoError(t, err)
+
+	require.Equal(t, changes[hexKey], common.BytesToHex(testValue))
+}
+
+func TestTryQueryStore_WhenDoesNotHaveDataToRetrieve(t *testing.T) {
+	s := NewTestService(t, nil)
+	storageStateTrie, err := storage.NewTrieState(trie.NewTrie(nil))
+	require.NoError(t, err)
+
+	header, err := types.NewHeader(s.blockState.GenesisHash(), storageStateTrie.MustRoot(),
+		common.Hash{}, big.NewInt(1), nil)
+	require.NoError(t, err)
+
+	err = s.storageState.StoreTrie(storageStateTrie, header)
+	require.NoError(t, err)
+
+	testBlock := &types.Block{
+		Header: header,
+		Body:   types.NewBody([]byte{}),
+	}
+
+	err = s.blockState.AddBlock(testBlock)
+	require.NoError(t, err)
+
+	testKey := []byte("to")
+	blockhash := testBlock.Header.Hash()
+	hexKey := common.BytesToHex(testKey)
+	keys := []string{hexKey}
+
+	changes, err := s.tryQueryStorage(blockhash, keys...)
+	require.NoError(t, err)
+
+	require.Empty(t, changes)
+}
+
+func TestTryQueryState_WhenDoesNotHaveStateRoot(t *testing.T) {
+	s := NewTestService(t, nil)
+
+	header, err := types.NewHeader(s.blockState.GenesisHash(), common.Hash{}, common.Hash{}, big.NewInt(1), nil)
+	require.NoError(t, err)
+
+	testBlock := &types.Block{
+		Header: header,
+		Body:   types.NewBody([]byte{}),
+	}
+
+	err = s.blockState.AddBlock(testBlock)
+	require.NoError(t, err)
+
+	testKey := []byte("to")
+	blockhash := testBlock.Header.Hash()
+	hexKey := common.BytesToHex(testKey)
+	keys := []string{hexKey}
+
+	changes, err := s.tryQueryStorage(blockhash, keys...)
+	require.Error(t, err)
+	require.Nil(t, changes)
+}
+
+func TestQueryStorate_WhenBlocksHasData(t *testing.T) {
+	keys := []string{
+		common.BytesToHex([]byte("transfer.to")),
+		common.BytesToHex([]byte("transfer.from")),
+		common.BytesToHex([]byte("transfer.value")),
+	}
+
+	s := NewTestService(t, nil)
+	firstKey, firstValue := []byte("transfer.to"), []byte("some-address-herer")
+
+	firstBlock := createNewBlockAndStoreDataAtBlock(
+		t, s, firstKey, firstValue, s.blockState.GenesisHash(), 1,
+	)
+
+	secondKey, secondValue := []byte("transfer.from"), []byte("another-address-here")
+	secondBlock := createNewBlockAndStoreDataAtBlock(
+		t, s, secondKey, secondValue, firstBlock.Header.Hash(), 2,
+	)
+
+	thirdKey, thirdValue := []byte("transfer.value"), []byte("value-gigamegablaster")
+	thirdBlock := createNewBlockAndStoreDataAtBlock(
+		t, s, thirdKey, thirdValue, secondBlock.Header.Hash(), 3,
+	)
+
+	from := firstBlock.Header.Hash()
+
+	data, err := s.QueryStorage(&from, nil, keys...)
+	require.NoError(t, err)
+	require.Len(t, data, 1)
+
+	require.Equal(t, data[firstBlock.Header.Hash()], QueryKeyValueChanges(
+		map[string]string{
+			common.BytesToHex(firstKey): common.BytesToHex(firstValue),
+		},
+	))
+
+	from = secondBlock.Header.Hash()
+	to := thirdBlock.Header.Hash()
+
+	data, err = s.QueryStorage(&from, &to, keys...)
+	require.NoError(t, err)
+	require.Len(t, data, 2)
+
+	require.Equal(t, data[secondBlock.Header.Hash()], QueryKeyValueChanges(
+		map[string]string{
+			common.BytesToHex(secondKey): common.BytesToHex(secondValue),
+		},
+	))
+	require.Equal(t, data[thirdBlock.Header.Hash()], QueryKeyValueChanges(
+		map[string]string{
+			common.BytesToHex(thirdKey): common.BytesToHex(thirdValue),
+		},
+	))
+}
+
+func createNewBlockAndStoreDataAtBlock(t *testing.T, s *Service, key, value []byte, parentHash common.Hash, number int64) *types.Block {
+	t.Helper()
+
+	storageStateTrie, err := storage.NewTrieState(trie.NewTrie(nil))
+	storageStateTrie.Set(key, value)
+	require.NoError(t, err)
+
+	header, err := types.NewHeader(parentHash, storageStateTrie.MustRoot(),
+		common.Hash{}, big.NewInt(number), nil)
+	require.NoError(t, err)
+
+	err = s.storageState.StoreTrie(storageStateTrie, header)
+	require.NoError(t, err)
+
+	testBlock := &types.Block{
+		Header: header,
+		Body:   types.NewBody([]byte{}),
+	}
+
+	err = s.blockState.AddBlock(testBlock)
+	require.NoError(t, err)
+
+	return testBlock
+}

dot/rpc/modules/api.go

@@ -3,6 +3,7 @@ package modules
 import (
 	"math/big"
 
+	"github.com/ChainSafe/gossamer/dot/core"
 	"github.com/ChainSafe/gossamer/dot/state"
 	"github.com/ChainSafe/gossamer/dot/types"
 	"github.com/ChainSafe/gossamer/lib/common"
@@ -76,6 +77,7 @@ type CoreAPI interface {
 	GetRuntimeVersion(bhash *common.Hash) (runtime.Version, error)
 	HandleSubmittedExtrinsic(types.Extrinsic) error
 	GetMetadata(bhash *common.Hash) ([]byte, error)
+	QueryStorage(from *common.Hash, to *common.Hash, keys ...string) (map[common.Hash]core.QueryKeyValueChanges, error)
 }
 
 // RPCAPI is the interface for methods related to RPC service

dot/rpc/modules/state.go

@@ -85,9 +85,9 @@ type StateStorageRequest struct {
 
 // StateStorageQueryRangeRequest holds json fields
 type StateStorageQueryRangeRequest struct {
-	Keys       []*common.Hash `json:"keys" validate:"required"`
-	StartBlock *common.Hash   `json:"startBlock" validate:"required"`
-	Block      *common.Hash   `json:"block"`
+	Keys       []string     `json:"keys" validate:"required"`
+	StartBlock *common.Hash `json:"startBlock" validate:"required"`
+	EndBlock   *common.Hash `json:"block"`
 }
 
 // StateStorageKeysQuery field to store storage keys
@@ -129,8 +129,8 @@ type StateMetadataResponse string
 
 // StorageChangeSetResponse is the struct that holds the block and changes
 type StorageChangeSetResponse struct {
-	Block   *common.Hash
-	Changes []KeyValueOption
+	Block   *common.Hash `json:"block"`
+	Changes [][]string   `json:"changes"`
 }
 
 // KeyValueOption struct holds json fields
@@ -387,8 +387,28 @@ func (sm *StateModule) GetStorageSize(r *http.Request, req *StateStorageSizeRequ
 }
 
 // QueryStorage isn't implemented properly yet.
-func (sm *StateModule) QueryStorage(r *http.Request, req *StateStorageQueryRangeRequest, res *StorageChangeSetResponse) error {
-	// TODO implement change storage trie so that block hash parameter works (See issue #834)
+func (sm *StateModule) QueryStorage(r *http.Request, req *StateStorageQueryRangeRequest, res *[]StorageChangeSetResponse) error {
+	changesByBlock, err := sm.coreAPI.QueryStorage(req.StartBlock, req.EndBlock, req.Keys...)
+	if err != nil {
+		return err
+	}
+
+	response := make([]StorageChangeSetResponse, 0, len(changesByBlock))
+
+	for block, c := range changesByBlock {
+		var changes [][]string
+
+		for key, value := range c {
+			changes = append(changes, []string{key, value})
+		}
+
+		response = append(response, StorageChangeSetResponse{
+			Block:   &block,
+			Changes: changes,
+		})
+	}
+
+	*res = response
 	return nil
 }