feat(rpc): Implement childstate_getStorageHash RPC call

dot/rpc/modules/api.go

@@ -19,6 +19,7 @@ import (
 type StorageAPI interface {
 	GetStorage(root *common.Hash, key []byte) ([]byte, error)
 	GetStorageChild(root *common.Hash, keyToChild []byte) (*trie.Trie, error)
+	GetStorageFromChild(root *common.Hash, keyToChild, key []byte) ([]byte, error)
 	GetStorageByBlockHash(bhash common.Hash, key []byte) ([]byte, error)
 	Entries(root *common.Hash) (map[string][]byte, error)
 	GetStateRootFromBlock(bhash *common.Hash) (*common.Hash, error)

dot/rpc/modules/chain_test.go

@@ -332,6 +332,7 @@ func newTestStateService(t *testing.T) *state.Service {
 	stateSrvc.UseMemDB()
 
 	gen, genTrie, genesisHeader := genesis.NewTestGenesisWithTrieAndHeader(t)
+
 	err = stateSrvc.Initialise(gen, genesisHeader, genTrie)
 	require.NoError(t, err)
 

dot/rpc/modules/childstate.go

@@ -26,7 +26,14 @@ import (
 type GetKeysRequest struct {
 	Key    []byte
 	Prefix []byte
-	Hash   common.Hash
+	Hash   *common.Hash
+}
+
+// GetStorageHash the request to get the entry child storage hash
+type GetStorageHash struct {
+	KeyChild []byte
+	EntryKey []byte
+	Hash     *common.Hash
 }
 
 // ChildStateModule is the module responsible to implement all the childstate RPC calls
@@ -45,11 +52,15 @@ func NewChildStateModule(s StorageAPI, b BlockAPI) *ChildStateModule {
 
 // GetKeys returns the keys from the specified child storage. The keys can also be filtered based on a prefix.
 func (cs *ChildStateModule) GetKeys(_ *http.Request, req *GetKeysRequest, res *[]string) error {
-	if req.Hash == common.EmptyHash {
-		req.Hash = cs.blockAPI.BestBlockHash()
+	var hash common.Hash
+
+	if req.Hash == nil {
+		hash = cs.blockAPI.BestBlockHash()
+	} else {
+		hash = *req.Hash
 	}
 
-	stateRoot, err := cs.storageAPI.GetStateRootFromBlock(&req.Hash)
+	stateRoot, err := cs.storageAPI.GetStateRootFromBlock(&hash)
 	if err != nil {
 		return err
 	}
@@ -68,3 +79,30 @@ func (cs *ChildStateModule) GetKeys(_ *http.Request, req *GetKeysRequest, res *[
 	*res = hexKeys
 	return nil
 }
+
+// GetStorageHash returns the hash of a child storage entry
+func (cs *ChildStateModule) GetStorageHash(_ *http.Request, req *GetStorageHash, res *string) error {
+	var hash common.Hash
+
+	if req.Hash == nil {
+		hash = cs.blockAPI.BestBlockHash()
+	} else {
+		hash = *req.Hash
+	}
+
+	stateRoot, err := cs.storageAPI.GetStateRootFromBlock(&hash)
+	if err != nil {
+		return err
+	}
+
+	item, err := cs.storageAPI.GetStorageFromChild(stateRoot, req.KeyChild, req.EntryKey)
+	if err != nil {
+		return err
+	}
+
+	if item != nil {
+		*res = common.BytesToHash(item).String()
+	}
+
+	return nil
+}

dot/rpc/modules/childstate_test.go

@@ -17,9 +17,12 @@
 package modules
 
 import (
+	"fmt"
 	"math/big"
 	"testing"
 
+	"github.com/ChainSafe/chaindb"
+
 	"github.com/ChainSafe/gossamer/dot/types"
 	"github.com/ChainSafe/gossamer/lib/common"
 	"github.com/ChainSafe/gossamer/lib/trie"
@@ -32,7 +35,7 @@ func TestChildStateGetKeys(t *testing.T) {
 	req := &GetKeysRequest{
 		Key:    []byte(":child_storage_key"),
 		Prefix: []byte{},
-		Hash:   common.EmptyHash,
+		Hash:   nil,
 	}
 
 	res := make([]string, 0)
@@ -51,7 +54,7 @@ func TestChildStateGetKeys(t *testing.T) {
 	req = &GetKeysRequest{
 		Key:    []byte(":child_storage_key"),
 		Prefix: []byte(":child_"),
-		Hash:   currBlockHash,
+		Hash:   &currBlockHash,
 	}
 
 	err = childStateModule.GetKeys(nil, req, &res)
@@ -67,6 +70,66 @@ func TestChildStateGetKeys(t *testing.T) {
 	}
 }
 
+func TestGetStorageHash(t *testing.T) {
+	mod, blockHash := setupChildStateStorage(t)
+	invalidBlockHash := common.BytesToHash([]byte("invalid block hash"))
+
+	tests := []struct {
+		expect   string
+		err      error
+		hash     *common.Hash
+		keyChild []byte
+		entry    []byte
+	}{
+		{
+			err:      nil,
+			expect:   common.BytesToHash([]byte(":child_first_value")).String(),
+			hash:     nil,
+			entry:    []byte(":child_first"),
+			keyChild: []byte(":child_storage_key"),
+		},
+		{
+			err:      nil,
+			expect:   common.BytesToHash([]byte(":child_second_value")).String(),
+			hash:     &blockHash,
+			entry:    []byte(":child_second"),
+			keyChild: []byte(":child_storage_key"),
+		},
+		{
+			err:      fmt.Errorf("child trie does not exist at key %s%s", trie.ChildStorageKeyPrefix, []byte(":not_exist")),
+			hash:     &blockHash,
+			entry:    []byte(":child_second"),
+			keyChild: []byte(":not_exist"),
+		},
+		{
+			err:  chaindb.ErrKeyNotFound,
+			hash: &invalidBlockHash,
+		},
+	}
+
+	for _, test := range tests {
+		var req GetStorageHash
+		var res string
+
+		req.Hash = test.hash
+		req.EntryKey = test.entry
+		req.KeyChild = test.keyChild
+
+		err := mod.GetStorageHash(nil, &req, &res)
+
+		if test.err != nil {
+			require.Error(t, err)
+			require.Equal(t, err, test.err)
+		} else {
+			require.NoError(t, err)
+		}
+
+		if test.expect != "" {
+			require.Equal(t, test.expect, res)
+		}
+	}
+}
+
 func setupChildStateStorage(t *testing.T) (*ChildStateModule, common.Hash) {
 	t.Helper()