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/childstate.go

@@ -29,6 +29,13 @@ type GetKeysRequest struct {
 	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
 type ChildStateModule struct {
 	storageAPI StorageAPI
@@ -68,3 +75,26 @@ 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 {
+	if req.Hash == common.EmptyHash {
+		req.Hash = cs.blockAPI.BestBlockHash()
+	}
+
+	stateRoot, err := cs.storageAPI.GetStateRootFromBlock(&req.Hash)
+	if err != nil {
+		return err
+	}
+
+	item, err := cs.storageAPI.GetStorageFromChild(stateRoot, req.KeyChild, req.EntryKey)
+	if err != nil {
+		return err
+	}
+
+	if len(item) > 0 {
+		*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"
@@ -67,6 +70,65 @@ func TestChildStateGetKeys(t *testing.T) {
 	}
 }
 
+func TestGetStorageHash(t *testing.T) {
+	mod, blockHash := setupChildStateStorage(t)
+
+	tests := []struct {
+		expect   string
+		err      error
+		hash     common.Hash
+		keyChild []byte
+		entry    []byte
+	}{
+		{
+			err:      nil,
+			expect:   common.BytesToHash([]byte(":child_first_value")).String(),
+			hash:     common.EmptyHash,
+			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: common.BytesToHash([]byte("invalid block hash")),
+		},
+	}
+
+	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()