feat(schema/appdata)!: efficiency & data model improvements aligned with server/v2 (#21305)

schema/decoding/decoding_test.go

@@ -297,12 +297,14 @@ func (t testStore) GetUInt64(key []byte) uint64 {
 
 func (t testStore) Set(key, value []byte) {
 	if t.listener.OnKVPair != nil {
-		err := t.listener.OnKVPair(appdata.KVPairData{Updates: []appdata.ModuleKVPairUpdate{
+		err := t.listener.OnKVPair(appdata.KVPairData{Updates: []appdata.ActorKVPairUpdate{
 			{
-				ModuleName: t.modName,
-				Update: schema.KVPairUpdate{
-					Key:   key,
-					Value: value,
+				Actor: []byte(t.modName),
+				StateChanges: []schema.KVPairUpdate{
+					{
+						Key:   key,
+						Value: value,
+					},
 				},
 			},
 		}})

schema/decoding/middleware.go

@@ -23,6 +23,7 @@ func Middleware(target appdata.Listener, resolver DecoderResolver, opts Middlewa
 	onKVPair := target.OnKVPair
 
 	moduleCodecs := map[string]*schema.ModuleCodec{}
+	moduleNames := map[string]string{}
 
 	target.OnKVPair = func(data appdata.KVPairData) error {
 		// first forward kv pair updates
@@ -34,17 +35,28 @@ func Middleware(target appdata.Listener, resolver DecoderResolver, opts Middlewa
 		}
 
 		for _, kvUpdate := range data.Updates {
-			// look for an existing codec
-			pcdc, ok := moduleCodecs[kvUpdate.ModuleName]
+			moduleName, ok := moduleNames[string(kvUpdate.Actor)]
 			if !ok {
-				if opts.ModuleFilter != nil && !opts.ModuleFilter(kvUpdate.ModuleName) {
+				var err error
+				moduleName, err = resolver.DecodeModuleName(kvUpdate.Actor)
+				if err != nil {
+					return err
+				}
+
+				moduleNames[string(kvUpdate.Actor)] = moduleName
+			}
+
+			// look for an existing codec
+			pcdc, ok := moduleCodecs[moduleName]
+			if !ok {
+				if opts.ModuleFilter != nil && !opts.ModuleFilter(moduleName) {
 					// we don't care about this module so store nil and continue
-					moduleCodecs[kvUpdate.ModuleName] = nil
+					moduleCodecs[moduleName] = nil
 					continue
 				}
 
 				// look for a new codec
-				cdc, found, err := resolver.LookupDecoder(kvUpdate.ModuleName)
+				cdc, found, err := resolver.LookupDecoder(moduleName)
 				if err != nil {
 					return err
 				}
@@ -52,16 +64,16 @@ func Middleware(target appdata.Listener, resolver DecoderResolver, opts Middlewa
 				if !found {
 					// store nil to indicate we've seen this module and don't have a codec
 					// and keep processing the kv updates
-					moduleCodecs[kvUpdate.ModuleName] = nil
+					moduleCodecs[moduleName] = nil
 					continue
 				}
 
 				pcdc = &cdc
-				moduleCodecs[kvUpdate.ModuleName] = pcdc
+				moduleCodecs[moduleName] = pcdc
 
 				if initializeModuleData != nil {
 					err = initializeModuleData(appdata.ModuleInitializationData{
-						ModuleName: kvUpdate.ModuleName,
+						ModuleName: moduleName,
 						Schema:     cdc.Schema,
 					})
 					if err != nil {
@@ -80,22 +92,24 @@ func Middleware(target appdata.Listener, resolver DecoderResolver, opts Middlewa
 				continue
 			}
 
-			updates, err := pcdc.KVDecoder(kvUpdate.Update)
-			if err != nil {
-				return err
-			}
+			for _, u := range kvUpdate.StateChanges {
+				updates, err := pcdc.KVDecoder(u)
+				if err != nil {
+					return err
+				}
 
-			if len(updates) == 0 {
-				// no updates
-				continue
-			}
+				if len(updates) == 0 {
+					// no updates
+					continue
+				}
 
-			err = target.OnObjectUpdate(appdata.ObjectUpdateData{
-				ModuleName: kvUpdate.ModuleName,
-				Updates:    updates,
-			})
-			if err != nil {
-				return err
+				err = target.OnObjectUpdate(appdata.ObjectUpdateData{
+					ModuleName: moduleName,
+					Updates:    updates,
+				})
+				if err != nil {
+					return err
+				}
 			}
 		}
 

schema/decoding/resolver.go

@@ -1,6 +1,7 @@
 package decoding
 
 import (
+	"fmt"
 	"sort"
 
 	"cosmossdk.io/schema"
@@ -8,6 +9,12 @@ import (
 
 // DecoderResolver is an interface that allows indexers to discover and use module decoders.
 type DecoderResolver interface {
+	// DecodeModuleName decodes a module name from a byte slice passed as the actor in a KVPairUpdate.
+	DecodeModuleName([]byte) (string, error)
+
+	// EncodeModuleName encodes a module name into a byte slice that can be used as the actor in a KVPairUpdate.
+	EncodeModuleName(string) ([]byte, error)
+
 	// IterateAll iterates over all available module decoders.
 	IterateAll(func(moduleName string, cdc schema.ModuleCodec) error) error
 
@@ -27,6 +34,20 @@ type moduleSetDecoderResolver struct {
 	moduleSet map[string]interface{}
 }
 
+func (a moduleSetDecoderResolver) DecodeModuleName(bytes []byte) (string, error) {
+	if _, ok := a.moduleSet[string(bytes)]; ok {
+		return string(bytes), nil
+	}
+	return "", fmt.Errorf("module %s not found", bytes)
+}
+
+func (a moduleSetDecoderResolver) EncodeModuleName(s string) ([]byte, error) {
+	if _, ok := a.moduleSet[s]; ok {
+		return []byte(s), nil
+	}
+	return nil, fmt.Errorf("module %s not found", s)
+}
+
 func (a moduleSetDecoderResolver) IterateAll(f func(string, schema.ModuleCodec) error) error {
 	keys := make([]string, 0, len(a.moduleSet))
 	for k := range a.moduleSet {