feat(iavlx): membership and nonmembership proofs

go.mod

@@ -26,6 +26,7 @@ require (
 	github.com/cosmos/gogogateway v1.2.0
 	github.com/cosmos/gogoproto v1.7.2
 	github.com/cosmos/iavl v1.2.6
+	github.com/cosmos/ics23/go v0.11.0
 	github.com/cosmos/ledger-cosmos-go v0.16.0
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0
 	github.com/edsrzf/mmap-go v1.0.0
@@ -135,7 +136,6 @@ require (
 	github.com/cockroachdb/redact v1.1.6 // indirect
 	github.com/cockroachdb/tokenbucket v0.0.0-20250429170803-42689b6311bb // indirect
 	github.com/cometbft/cometbft-db v0.14.1 // indirect
-	github.com/cosmos/ics23/go v0.11.0 // indirect
 	github.com/danieljoos/wincred v1.2.2 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/desertbit/timer v0.0.0-20180107155436-c41aec40b27f // indirect

iavlx/commit_tree.go

@@ -7,7 +7,7 @@
 	"sync/atomic"
 
 	"cosmossdk.io/log"
 
 	pruningtypes "cosmossdk.io/store/pruning/types"
 	storetypes "cosmossdk.io/store/types"
 )
@@ -350,6 +350,20 @@
 	return NewImmutableTree(rootPtr), nil
 }
 
+func (c *CommitTree) GetImmutableImpl(version int64) (*ImmutableTree, error) {
+	var rootPtr *NodePointer
+	if version == c.lastCommitId.Version {
+		rootPtr = c.root
+	} else {
+		var err error
+		rootPtr, err = c.store.ResolveRoot(uint32(version))
+		if err != nil {
+			return nil, err
+		}
+	}
+	return NewImmutableTree(rootPtr), nil
+}
+
 func (c *CommitTree) Close() error {
 	if c.walQueue != nil {
 		c.walQueue.Close()
@@ -433,6 +447,6 @@
 	return count
 }
 
 var (
 	_ storetypes.CommitStore = &CommitTree{}
 )

iavlx/immutable_tree.go

@@ -1,8 +1,11 @@
 package iavlx
 
 import (
+	"errors"
 	io "io"
 
+	ics23 "github.com/cosmos/ics23/go"
+
 	storetypes "cosmossdk.io/store/types"
 )
 
@@ -68,6 +71,114 @@
 	return NewIterator(start, end, false, tree.root, true)
 }
 
+func (tree *ImmutableTree) GetMembershipProof(key []byte) (*ics23.CommitmentProof, error) {
+	root, err := tree.root.Resolve()
+	if err != nil {
+		return nil, err
+	}
+	exist, err := createExistenceProof(root, key)
+	if err != nil {
+		return nil, err
+	}
+	proof := &ics23.CommitmentProof{
+		Proof: &ics23.CommitmentProof_Exist{
+			Exist: exist,
+		},
+	}
+	return proof, nil
+}
+
+/*
+GetNonMembershipProof will produce a CommitmentProof that the given key doesn't exist in the iavl tree.
+If the key exists in the tree, this will return an error.
+*/
+func (t *ImmutableTree) GetNonMembershipProof(key []byte) (*ics23.CommitmentProof, error) {
+	// idx is one node right of what we want....
+	exists := t.Has(key)
+	if exists {
+		return nil, errors.New("cannot create non-membership proof with key that exists in tree")
+	}
+
+	nonexist := &ics23.NonExistenceProof{
+		Key: key,
+	}
+
+	root, err := t.root.Resolve()
+	if err != nil {
+		return nil, err
+	}
+	idx, err := NextIndex(root, key)
+	if err != nil {
+		return nil, err
+	}
+
+	if idx >= 1 {
+		leftNode, err := getByIndex(root, idx-1)
+		if err != nil {
+			return nil, err
+		}
+		leftKey, err := leftNode.Key()
+		if err != nil {
+			return nil, err
+		}
+
+		nonexist.Left, err = createExistenceProof(root, leftKey)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// this will be nil if nothing right of the queried key
+	rightNode, err := getByIndex(root, idx)
+	if err != nil {
+		return nil, err
+	}
+	if rightNode != nil {
+		rightKey, err := rightNode.Key()
+
+		if rightKey != nil {
+			nonexist.Right, err = createExistenceProof(root, rightKey)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	proof := &ics23.CommitmentProof{
+		Proof: &ics23.CommitmentProof_Nonexist{
+			Nonexist: nonexist,
+		},
+	}
+	return proof, nil
+}
+
+// VerifyMembership returns true iff proof is an ExistenceProof for the given key.
+func (t *ImmutableTree) VerifyMembership(proof *ics23.CommitmentProof, key []byte) (bool, error) {
+	val := t.Get(key)
+	if val == nil {
+		return false, errors.New("key not found")
+	}
+	rootNode, err := t.root.Resolve()
+	if err != nil {
+		return false, err
+	}
+
+	root := rootNode.Hash()
+
+	return ics23.VerifyMembership(ics23.IavlSpec, root, proof, key, val), nil
+}
+
+// VerifyNonMembership returns true iff proof is a NonExistenceProof for the given key.
+func (t *ImmutableTree) VerifyNonMembership(proof *ics23.CommitmentProof, key []byte) (bool, error) {
+	root, err := t.root.Resolve()
+	if err != nil {
+		return false, err
+	}
+	rootHash := root.Hash()
+
+	return ics23.VerifyNonMembership(ics23.IavlSpec, rootHash, proof, key), nil
+}
+
 var (
 	_ storetypes.KVStore = (*ImmutableTree)(nil)
 )