fix: remove RangeProofs

basic_test.go

@@ -510,13 +510,17 @@ func TestProof(t *testing.T) {
 
 	// Now for each item, construct a proof and verify
 	tree.Iterate(func(key []byte, value []byte) bool {
-		value2, proof, err := tree.GetWithProof(key)
+		proof, err := tree.GetMembershipProof(key)
 		assert.NoError(t, err)
-		assert.Equal(t, value, value2)
-		if assert.NotNil(t, proof) {
-			hash, err := tree.WorkingHash()
-			require.NoError(t, err)
-			verifyProof(t, proof, hash)
+		assert.Equal(t, value, proof.GetExist().Value)
+		res, err := tree.VerifyMembership(proof, key)
+		assert.NoError(t, err)
+		value2, err := tree.ImmutableTree.Get(key)
+		assert.NoError(t, err)
+		if value2 != nil {
+			assert.True(t, res)
+		} else {
+			assert.False(t, res)
 		}
 		return false
 	})
@@ -531,11 +535,8 @@ func TestTreeProof(t *testing.T) {
 	assert.Equal(t, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", hex.EncodeToString(hash))
 
 	// should get false for proof with nil root
-	value, proof, err := tree.GetWithProof([]byte("foo"))
-	assert.Nil(t, value)
-	assert.Nil(t, proof)
-	assert.Error(t, proof.Verify([]byte(nil)))
-	assert.NoError(t, err)
+	_, err = tree.GetWithProof([]byte("foo"))
+	require.Error(t, err)
 
 	// insert lots of info and store the bytes
 	keys := make([][]byte, 200)
@@ -548,27 +549,18 @@ func TestTreeProof(t *testing.T) {
 	tree.SaveVersion()
 
 	// query random key fails
-	value, proof, err = tree.GetWithProof([]byte("foo"))
-	assert.Nil(t, value)
-	assert.NotNil(t, proof)
-	assert.NoError(t, err)
-	hash, err = tree.Hash()
-	assert.NoError(t, err)
-	assert.NoError(t, proof.Verify(hash))
-	assert.NoError(t, proof.VerifyAbsence([]byte("foo")))
+	_, err = tree.GetMembershipProof([]byte("foo"))
+	assert.Error(t, err)
 
 	// valid proof for real keys
-	root, err := tree.WorkingHash()
-	assert.NoError(t, err)
 	for _, key := range keys {
-		value, proof, err := tree.GetWithProof(key)
+		proof, err := tree.GetMembershipProof(key)
 		if assert.NoError(t, err) {
 			require.Nil(t, err, "Failed to read proof from bytes: %v", err)
-			assert.Equal(t, key, value)
-			err := proof.Verify(root)
-			assert.NoError(t, err, "#### %v", proof.String())
-			err = proof.VerifyItem(key, key)
-			assert.NoError(t, err, "#### %v", proof.String())
+			assert.Equal(t, key, proof.GetExist().Value)
+			res, err := tree.VerifyMembership(proof, key)
+			require.NoError(t, err)
+			require.True(t, res)
 		}
 	}
 }

mutable_tree_test.go

@@ -120,17 +120,18 @@ func TestDelete(t *testing.T) {
 
 	require.NoError(t, tree.DeleteVersion(version))
 
-	k1Value, _, _ := tree.GetVersionedWithProof([]byte("k1"), version)
-	require.Nil(t, k1Value)
+	proof, err := tree.GetVersionedWithProof([]byte("k1"), version)
+	require.EqualError(t, err, ErrVersionDoesNotExist.Error())
+	require.Nil(t, proof)
 
 	key := tree.ndb.rootKey(version)
 	err = tree.ndb.db.Set(key, hash)
 	require.NoError(t, err)
 	tree.versions[version] = true
 
-	k1Value, _, err = tree.GetVersionedWithProof([]byte("k1"), version)
+	proof, err = tree.GetVersionedWithProof([]byte("k1"), version)
 	require.Nil(t, err)
-	require.Equal(t, 0, bytes.Compare([]byte("Fred"), k1Value))
+	require.Equal(t, 0, bytes.Compare([]byte("Fred"), proof.GetExist().Value))
 }
 
 func TestGetRemove(t *testing.T) {

proof.go

@@ -5,12 +5,10 @@ import (
 	"crypto/sha256"
 	"errors"
 	"fmt"
-	"math"
 	"sync"
 
 	hexbytes "github.com/cosmos/iavl/internal/bytes"
 	"github.com/cosmos/iavl/internal/encoding"
-	iavlproto "github.com/cosmos/iavl/proto"
 )
 
 var bufPool = &sync.Pool{
@@ -108,34 +106,6 @@ func (pin ProofInnerNode) Hash(childHash []byte) ([]byte, error) {
 	return hasher.Sum(nil), nil
 }
 
-// toProto converts the inner node proof to Protobuf, for use in ProofOps.
-func (pin ProofInnerNode) toProto() *iavlproto.ProofInnerNode {
-	return &iavlproto.ProofInnerNode{
-		Height:  int32(pin.Height),
-		Size_:   pin.Size,
-		Version: pin.Version,
-		Left:    pin.Left,
-		Right:   pin.Right,
-	}
-}
-
-// proofInnerNodeFromProto converts a Protobuf ProofInnerNode to a ProofInnerNode.
-func proofInnerNodeFromProto(pbInner *iavlproto.ProofInnerNode) (ProofInnerNode, error) {
-	if pbInner == nil {
-		return ProofInnerNode{}, errors.New("inner node cannot be nil")
-	}
-	if pbInner.Height > math.MaxInt8 || pbInner.Height < math.MinInt8 {
-		return ProofInnerNode{}, fmt.Errorf("height must fit inside an int8, got %v", pbInner.Height)
-	}
-	return ProofInnerNode{
-		Height:  int8(pbInner.Height),
-		Size:    pbInner.Size_,
-		Version: pbInner.Version,
-		Left:    pbInner.Left,
-		Right:   pbInner.Right,
-	}, nil
-}
-
 //----------------------------------------
 
 type ProofLeafNode struct {
@@ -191,27 +161,6 @@ func (pln ProofLeafNode) Hash() ([]byte, error) {
 	return hasher.Sum(nil), nil
 }
 
-// toProto converts the leaf node proof to Protobuf, for use in ProofOps.
-func (pln ProofLeafNode) toProto() *iavlproto.ProofLeafNode {
-	return &iavlproto.ProofLeafNode{
-		Key:       pln.Key,
-		ValueHash: pln.ValueHash,
-		Version:   pln.Version,
-	}
-}
-
-// proofLeafNodeFromProto converts a Protobuf ProofLeadNode to a ProofLeafNode.
-func proofLeafNodeFromProto(pbLeaf *iavlproto.ProofLeafNode) (ProofLeafNode, error) {
-	if pbLeaf == nil {
-		return ProofLeafNode{}, errors.New("leaf node cannot be nil")
-	}
-	return ProofLeafNode{
-		Key:       pbLeaf.Key,
-		ValueHash: pbLeaf.ValueHash,
-		Version:   pbLeaf.Version,
-	}, nil
-}
-
 //----------------------------------------
 
 // If the key does not exist, returns the path to the next leaf left of key (w/