feat(lib/runtime): Implement trie_blake2_256_verify_proof host function

lib/runtime/wasmer/imports.go

@@ -48,7 +48,7 @@ package wasmer
 //
 // extern int32_t ext_trie_blake2_256_root_version_1(void *context, int64_t a);
 // extern int32_t ext_trie_blake2_256_ordered_root_version_1(void *context, int64_t a);
-// extern int32_t ext_trie_blake2_256_verify_proof_version_1(void *context, int32_t a, int64_t b, int64_t c, int64_t d);
+// extern int32_t ext_trie_blake2_256_verify_proof_version_1(void *context, int64_t a, int64_t b, int64_t c, int64_t d);
 //
 // extern int64_t ext_misc_runtime_version_version_1(void *context, int64_t a);
 // extern void ext_misc_print_hex_version_1(void *context, int64_t a);
@@ -899,10 +899,35 @@ func ext_trie_blake2_256_ordered_root_version_1(context unsafe.Pointer, dataSpan
 }
 
 //export ext_trie_blake2_256_verify_proof_version_1
-func ext_trie_blake2_256_verify_proof_version_1(context unsafe.Pointer, a C.int32_t, b, c, d C.int64_t) C.int32_t {
+func ext_trie_blake2_256_verify_proof_version_1(context unsafe.Pointer, rootSpan, proofSpan, keySpan, valueSpan C.int64_t) C.int32_t {
 	logger.Debug("[ext_trie_blake2_256_verify_proof_version_1] executing...")
-	logger.Warn("[ext_trie_blake2_256_verify_proof_version_1] unimplemented")
-	return 0
+
+	instanceContext := wasm.IntoInstanceContext(context)
+
+	toDecProofs := asMemorySlice(instanceContext, proofSpan)
+	var decProofs [][]byte
+	err := scale.Unmarshal(toDecProofs, &decProofs)
+	if err != nil {
+		logger.Error("[ext_trie_blake2_256_verify_proof_version_1]", "error", err)
+		return C.int32_t(0)
+	}
+
+	key := asMemorySlice(instanceContext, keySpan)
+	value := asMemorySlice(instanceContext, valueSpan)
+	trieRoot := asMemorySlice(instanceContext, rootSpan)
+
+	exists, err := trie.VerifyProof(decProofs, trieRoot, []trie.Pair{{Key: key, Value: value}})
+	if err != nil {
+		logger.Error("[ext_trie_blake2_256_verify_proof_version_1]", "error", err)
+		return C.int32_t(0)
+	}
+
+	var result C.int32_t = 0
+	if exists {
+		result = 1
+	}
+
+	return result
 }
 
 //export ext_misc_print_hex_version_1

lib/runtime/wasmer/imports_test.go

@@ -19,10 +19,12 @@ package wasmer
 import (
 	"bytes"
 	"encoding/binary"
+	"io/ioutil"
 	"os"
 	"sort"
 	"testing"
 
+	"github.com/ChainSafe/chaindb"
 	"github.com/ChainSafe/gossamer/lib/common"
 	"github.com/ChainSafe/gossamer/lib/common/optional"
 	"github.com/ChainSafe/gossamer/lib/common/types"
@@ -1506,3 +1508,93 @@ func Test_ext_trie_blake2_256_root_version_1(t *testing.T) {
 	expected := tt.MustHash()
 	require.Equal(t, expected[:], hash)
 }
+
+func Test_ext_trie_blake2_256_verify_proof_version_1(t *testing.T) {
+	t.Parallel()
+
+	tmp, err := ioutil.TempDir("", "*-test-trie")
+	require.NoError(t, err)
+
+	memdb, err := chaindb.NewBadgerDB(&chaindb.Config{
+		InMemory: true,
+		DataDir:  tmp,
+	})
+	require.NoError(t, err)
+
+	otherTrie := trie.NewEmptyTrie()
+	otherTrie.Put([]byte("simple"), []byte("cat"))
+
+	otherHash, err := otherTrie.Hash()
+	require.NoError(t, err)
+
+	tr := trie.NewEmptyTrie()
+	tr.Put([]byte("do"), []byte("verb"))
+	tr.Put([]byte("domain"), []byte("website"))
+	tr.Put([]byte("other"), []byte("random"))
+	tr.Put([]byte("otherwise"), []byte("randomstuff"))
+	tr.Put([]byte("cat"), []byte("another animal"))
+
+	err = tr.Store(memdb)
+	require.NoError(t, err)
+
+	hash, err := tr.Hash()
+	require.NoError(t, err)
+
+	keys := [][]byte{
+		[]byte("do"),
+		[]byte("domain"),
+		[]byte("other"),
+		[]byte("otherwise"),
+		[]byte("cat"),
+	}
+
+	root := hash.ToBytes()
+	otherRoot := otherHash.ToBytes()
+
+	proof, err := trie.GenerateProof(root, keys, memdb)
+	require.NoError(t, err)
+
+	testcases := []struct {
+		root, key, value []byte
+		proof            [][]byte
+		expect           bool
+	}{
+		{root: root, key: []byte("do"), proof: proof, value: []byte("verb"), expect: true},
+		{root: []byte{}, key: []byte("do"), proof: proof, value: []byte("verb"), expect: false},
+		{root: otherRoot, key: []byte("do"), proof: proof, value: []byte("verb"), expect: false},
+		{root: root, key: []byte("do"), proof: proof, value: nil, expect: true},
+		{root: root, key: []byte("unknow"), proof: proof, value: nil, expect: false},
+		{root: root, key: []byte("unknow"), proof: proof, value: []byte("unknow"), expect: false},
+		{root: root, key: []byte("do"), proof: [][]byte{}, value: nil, expect: false},
+	}
+
+	inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME)
+
+	for _, testcase := range testcases {
+		hashEnc, err := scale.Marshal(testcase.root)
+		require.NoError(t, err)
+
+		args := []byte{}
+		args = append(args, hashEnc...)
+
+		encProof, err := scale.Marshal(testcase.proof)
+		require.NoError(t, err)
+		args = append(args, encProof...)
+
+		keyEnc, err := scale.Marshal(testcase.key)
+		require.NoError(t, err)
+		args = append(args, keyEnc...)
+
+		valueEnc, err := scale.Marshal(testcase.value)
+		require.NoError(t, err)
+		args = append(args, valueEnc...)
+
+		res, err := inst.Exec("rtm_ext_trie_blake2_256_verify_proof_version_1", args)
+		require.NoError(t, err)
+
+		var got bool
+		err = scale.Unmarshal(res, &got)
+		require.NoError(t, err)
+		require.Equal(t, testcase.expect, got)
+	}
+}

lib/trie/proof.go

@@ -27,21 +27,23 @@ import (
 )
 
 var (
-	// ErrEmptyTrieRoot occurs when trying to craft a prove with an empty trie root
+	// ErrEmptyTrieRoot ...
 	ErrEmptyTrieRoot = errors.New("provided trie must have a root")
 
-	// ErrValueNotFound indicates that a returned verify proof value doesnt match with the expected value on items array
+	// ErrValueNotFound ...
 	ErrValueNotFound = errors.New("expected value not found in the trie")
 
-	// ErrDuplicateKeys not allowed to verify proof with duplicate keys
+	// ErrKeyNotFound ...
+	ErrKeyNotFound = errors.New("expected key not found in the trie")
+
+	// ErrDuplicateKeys ...
 	ErrDuplicateKeys = errors.New("duplicate keys on verify proof")
 
-	// ErrLoadFromProof occurs when there are problems with the proof slice while building the partial proof trie
+	// ErrLoadFromProof ...
 	ErrLoadFromProof = errors.New("failed to build the proof trie")
 )
 
 // GenerateProof receive the keys to proof, the trie root and a reference to database
-// will
 func GenerateProof(root []byte, keys [][]byte, db chaindb.Database) ([][]byte, error) {
 	trackedProofs := make(map[string][]byte)
 
@@ -100,9 +102,11 @@ func VerifyProof(proof [][]byte, root []byte, items []Pair) (bool, error) {
 
 	for _, item := range items {
 		recValue := proofTrie.Get(item.Key)
-
+		if recValue == nil {
+			return false, ErrKeyNotFound
+		}
 		// here we need to compare value only if the caller pass the value
-		if item.Value != nil && !bytes.Equal(item.Value, recValue) {
+		if len(item.Value) > 0 && !bytes.Equal(item.Value, recValue) {
 			return false, ErrValueNotFound
 		}
 	}