fix(codec): MarshalInterface should err when UnmarshalInterface will fail

client/grpc_query.go

@@ -176,3 +176,7 @@ func (f failingInterfaceRegistry) ListAllInterfaces() []string {
 func (f failingInterfaceRegistry) ListImplementations(ifaceTypeURL string) []string {
 	panic("cannot be called")
 }
+
+func (f failingInterfaceRegistry) EnsureRegistered(iface interface{}) error {
+	panic("cannot be called")
+}

codec/proto_codec.go

@@ -194,6 +194,10 @@ func (pc *ProtoCodec) MarshalInterface(i gogoproto.Message) ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
+	err = pc.interfaceRegistry.EnsureRegistered(i)
+	if err != nil {
+		return nil, err
+	}
 
 	return pc.Marshal(any)
 }

codec/proto_codec_test.go

@@ -3,6 +3,7 @@ package codec_test
 import (
 	"errors"
 	"fmt"
+	"reflect"
 	"testing"
 
 	"github.com/gogo/protobuf/proto"
@@ -46,6 +47,52 @@ func (lpm *lyingProtoMarshaler) Size() int {
 	return lpm.falseSize
 }
 
+func TestProtoCodecMarshal(t *testing.T) {
+	interfaceRegistry := types.NewInterfaceRegistry()
+	interfaceRegistry.RegisterInterface("testdata.Animal",
+		(*testdata.Animal)(nil),
+		&testdata.Cat{},
+	)
+	cdc := codec.NewProtoCodec(interfaceRegistry)
+
+	cartonRegistry := types.NewInterfaceRegistry()
+	cartonRegistry.RegisterInterface("testdata.Cartoon",
+		(*testdata.Cartoon)(nil),
+		&testdata.Bird{},
+	)
+	cartoonCdc := codec.NewProtoCodec(cartonRegistry)
+
+	cat := &testdata.Cat{Moniker: "Garfield", Lives: 6}
+	bird := &testdata.Bird{Species: "Passerina ciris"}
+	require.NoError(t, interfaceRegistry.EnsureRegistered(cat))
+
+	var (
+		animal  testdata.Animal
+		cartoon testdata.Cartoon
+	)
+
+	// sanity check
+	require.True(t, reflect.TypeOf(cat).Implements(reflect.TypeOf((*testdata.Animal)(nil)).Elem()))
+
+	bz, err := cdc.MarshalInterface(cat)
+	require.NoError(t, err)
+
+	err = cdc.UnmarshalInterface(bz, &animal)
+	require.NoError(t, err)
+
+	bz, err = cdc.MarshalInterface(bird)
+	require.ErrorContains(t, err, "does not have a registered interface")
+
+	bz, err = cartoonCdc.MarshalInterface(bird)
+	require.NoError(t, err)
+
+	err = cdc.UnmarshalInterface(bz, &cartoon)
+	require.ErrorContains(t, err, "no registered implementations")
+
+	err = cartoonCdc.UnmarshalInterface(bz, &cartoon)
+	require.NoError(t, err)
+}
+
 func TestProtoCodecUnmarshalLengthPrefixedChecks(t *testing.T) {
 	cdc := codec.NewProtoCodec(createTestInterfaceRegistry())
 

codec/types/interface_registry.go

@@ -52,6 +52,9 @@ type InterfaceRegistry interface {
 	// ListImplementations lists the valid type URLs for the given interface name that can be used
 	// for the provided interface type URL.
 	ListImplementations(ifaceTypeURL string) []string
+
+	// EnsureRegistered ensures there is a registered implementation for the given concrete type.
+	EnsureRegistered(iface interface{}) error
 }
 
 // UnpackInterfacesMessage is meant to extend protobuf types (which implement
@@ -81,6 +84,7 @@ type UnpackInterfacesMessage interface {
 type interfaceRegistry struct {
 	interfaceNames map[string]reflect.Type
 	interfaceImpls map[reflect.Type]interfaceMap
+	implInterfaces map[reflect.Type]reflect.Type
 	typeURLMap     map[string]reflect.Type
 }
 
@@ -91,6 +95,7 @@ func NewInterfaceRegistry() InterfaceRegistry {
 	return &interfaceRegistry{
 		interfaceNames: map[string]reflect.Type{},
 		interfaceImpls: map[reflect.Type]interfaceMap{},
+		implInterfaces: map[reflect.Type]reflect.Type{},
 		typeURLMap:     map[string]reflect.Type{},
 	}
 }
@@ -100,10 +105,26 @@ func (registry *interfaceRegistry) RegisterInterface(protoName string, iface int
 	if typ.Elem().Kind() != reflect.Interface {
 		panic(fmt.Errorf("%T is not an interface type", iface))
 	}
+
 	registry.interfaceNames[protoName] = typ
 	registry.RegisterImplementations(iface, impls...)
 }
 
+// EnsureRegistered ensures there is a registered implementation for the given concrete type.
+//
+// Returns an error if not, and nil if so.
+func (registry *interfaceRegistry) EnsureRegistered(impl interface{}) error {
+	if reflect.ValueOf(impl).Kind() != reflect.Ptr {
+		return fmt.Errorf("%T is not a pointer", impl)
+	}
+
+	if _, found := registry.implInterfaces[reflect.TypeOf(impl)]; !found {
+		return fmt.Errorf("%T does not have a registered interface", impl)
+	}
+
+	return nil
+}
+
 // RegisterImplementations registers a concrete proto Message which implements
 // the given interface.
 //
@@ -162,7 +183,7 @@ func (registry *interfaceRegistry) registerImpl(iface interface{}, typeURL strin
 
 	imap[typeURL] = implType
 	registry.typeURLMap[typeURL] = implType
-
+	registry.implInterfaces[implType] = ityp
 	registry.interfaceImpls[ityp] = imap
 }
 

testutil/testdata/animal.go

@@ -17,10 +17,20 @@ type Animal interface {
 	Greet() string
 }
 
-func (c Cat) Greet() string {
+type Cartoon interface {
+	proto.Message
+
+	Identify() string
+}
+
+func (c *Cat) Greet() string {
 	return fmt.Sprintf("Meow, my name is %s", c.Moniker)
 }
 
+func (c *Bird) Identify() string {
+	return "This is Tweety."
+}
+
 func (d Dog) Greet() string {
 	return fmt.Sprintf("Roof, my name is %s", d.Name)
 }