[#556] morph/container: Do not parse public key in Put event parser

Morph event structures defined in `pkg/morph/event` should only carry
notification values without any additional interpretation. All logical work
should be concentrated on app-side. Change `Bind.User` / `Unbind.User` to
return byte slice. Change `Bind.Keys` / `Unbind.Keys` to return `[][]byte`.
`ParseBind` / `ParseUnbind` don't decode data from now.

Signed-off-by: Leonard Lyubich <leonard@nspcc.ru>

pkg/morph/event/neofs/bind.go

@@ -1,27 +1,28 @@
 package neofs
 
 import (
-	"crypto/elliptic"
 	"fmt"
 
-	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
-	"github.com/nspcc-dev/neo-go/pkg/util"
 	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
 	"github.com/nspcc-dev/neofs-node/pkg/morph/client"
 	"github.com/nspcc-dev/neofs-node/pkg/morph/event"
 )
 
 type Bind struct {
-	user util.Uint160
+	bindCommon
-	keys []*keys.PublicKey
+}
+
+type bindCommon struct {
+	user []byte
+	keys [][]byte
 }
 
 // MorphEvent implements Neo:Morph Event interface.
-func (Bind) MorphEvent() {}
+func (bindCommon) MorphEvent() {}
 
-func (b Bind) Keys() []*keys.PublicKey { return b.keys }
+func (b bindCommon) Keys() [][]byte { return b.keys }
 
-func (b Bind) User() util.Uint160 { return b.user }
+func (b bindCommon) User() []byte { return b.user }
 
 func ParseBind(params []stackitem.Item) (event.Event, error) {
 	var (
@@ -29,41 +30,43 @@ func ParseBind(params []stackitem.Item) (event.Event, error) {
 		err error
 	)
 
-	if ln := len(params); ln != 2 {
+	err = parseBind(&ev.bindCommon, params)
-		return nil, event.WrongNumberOfParameters(2, ln)
+	if err != nil {
+		return nil, err
 	}
 
+	return ev, nil
+}
+
+func parseBind(dst *bindCommon, params []stackitem.Item) error {
+	if ln := len(params); ln != 2 {
+		return event.WrongNumberOfParameters(2, ln)
+	}
+
+	var err error
+
 	// parse user
-	user, err := client.BytesFromStackItem(params[0])
+	dst.user, err = client.BytesFromStackItem(params[0])
 	if err != nil {
-		return nil, fmt.Errorf("could not get bind user: %w", err)
+		return fmt.Errorf("could not get bind user: %w", err)
-	}
-
-	ev.user, err = util.Uint160DecodeBytesBE(user)
-	if err != nil {
-		return nil, fmt.Errorf("could not convert bind user to uint160: %w", err)
 	}
 
 	// parse keys
 	bindKeys, err := client.ArrayFromStackItem(params[1])
 	if err != nil {
-		return nil, fmt.Errorf("could not get bind keys: %w", err)
+		return fmt.Errorf("could not get bind keys: %w", err)
 	}
 
-	ev.keys = make([]*keys.PublicKey, 0, len(bindKeys))
+	dst.keys = make([][]byte, 0, len(bindKeys))
+
 	for i := range bindKeys {
 		rawKey, err := client.BytesFromStackItem(bindKeys[i])
 		if err != nil {
-			return nil, fmt.Errorf("could not get bind public key: %w", err)
+			return fmt.Errorf("could not get bind public key: %w", err)
 		}
 
-		key, err := keys.NewPublicKeyFromBytes(rawKey, elliptic.P256())
+		dst.keys = append(dst.keys, rawKey)
-		if err != nil {
-			return nil, fmt.Errorf("could not parse bind public key: %w", err)
 	}
 
-		ev.keys = append(ev.keys, key)
+	return nil
-	}
-
-	return ev, nil
 }

pkg/morph/event/neofs/bind_test.go

@@ -1,26 +1,20 @@
 package neofs
 
 import (
-	"crypto/ecdsa"
-	"crypto/elliptic"
 	"testing"
 
-	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
-	"github.com/nspcc-dev/neo-go/pkg/util"
 	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
-	crypto "github.com/nspcc-dev/neofs-crypto"
 	"github.com/nspcc-dev/neofs-node/pkg/morph/event"
-	"github.com/nspcc-dev/neofs-node/pkg/util/test"
 	"github.com/stretchr/testify/require"
 )
 
 func TestParseBind(t *testing.T) {
 	var (
-		user       = util.Uint160{0x1, 0x2, 0x3}
+		user       = []byte{0x1, 0x2, 0x3}
-		publicKeys = []*ecdsa.PublicKey{
+		publicKeys = [][]byte{
-			&test.DecodeKey(1).PublicKey,
+			[]byte("key1"),
-			&test.DecodeKey(2).PublicKey,
+			[]byte("key2"),
-			&test.DecodeKey(3).PublicKey,
+			[]byte("key3"),
 		}
 	)
 
@@ -43,7 +37,7 @@ func TestParseBind(t *testing.T) {
 
 	t.Run("wrong second parameter", func(t *testing.T) {
 		_, err := ParseBind([]stackitem.Item{
-			stackitem.NewByteArray(user.BytesBE()),
+			stackitem.NewByteArray(user),
 			stackitem.NewMap(),
 		})
 
@@ -51,27 +45,19 @@ func TestParseBind(t *testing.T) {
 	})
 
 	t.Run("correct", func(t *testing.T) {
-
 		ev, err := ParseBind([]stackitem.Item{
-			stackitem.NewByteArray(user.BytesBE()),
+			stackitem.NewByteArray(user),
 			stackitem.NewArray([]stackitem.Item{
-				stackitem.NewByteArray(crypto.MarshalPublicKey(publicKeys[0])),
+				stackitem.NewByteArray(publicKeys[0]),
-				stackitem.NewByteArray(crypto.MarshalPublicKey(publicKeys[1])),
+				stackitem.NewByteArray(publicKeys[1]),
-				stackitem.NewByteArray(crypto.MarshalPublicKey(publicKeys[2])),
+				stackitem.NewByteArray(publicKeys[2]),
 			}),
 		})
 		require.NoError(t, err)
 
-		expKeys := make([]*keys.PublicKey, len(publicKeys))
+		e := ev.(Bind)
-		for i := range publicKeys {
-			expKeys[i], err = keys.NewPublicKeyFromBytes(
-				crypto.MarshalPublicKey(publicKeys[i]), elliptic.P256())
-			require.NoError(t, err)
-		}
 
-		require.Equal(t, Bind{
+		require.Equal(t, user, e.User())
-			user: user,
+		require.Equal(t, publicKeys, e.Keys())
-			keys: expKeys,
-		}, ev)
 	})
 }

pkg/morph/event/neofs/unbind.go

@@ -1,68 +1,23 @@
 package neofs
 
 import (
-	"crypto/elliptic"
-	"fmt"
-
-	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
-	"github.com/nspcc-dev/neo-go/pkg/util"
 	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
-	"github.com/nspcc-dev/neofs-node/pkg/morph/client"
 	"github.com/nspcc-dev/neofs-node/pkg/morph/event"
 )
 
 type Unbind struct {
-	user util.Uint160
+	bindCommon
-	keys []*keys.PublicKey
 }
 
-// MorphEvent implements Neo:Morph Event interface.
-func (Unbind) MorphEvent() {}
-
-func (u Unbind) Keys() []*keys.PublicKey { return u.keys }
-
-func (u Unbind) User() util.Uint160 { return u.user }
-
 func ParseUnbind(params []stackitem.Item) (event.Event, error) {
 	var (
 		ev  Unbind
 		err error
 	)
 
-	if ln := len(params); ln != 2 {
+	err = parseBind(&ev.bindCommon, params)
-		return nil, event.WrongNumberOfParameters(2, ln)
-	}
-
-	// parse user
-	user, err := client.BytesFromStackItem(params[0])
 	if err != nil {
-		return nil, fmt.Errorf("could not get bind user: %w", err)
+		return nil, err
-	}
-
-	ev.user, err = util.Uint160DecodeBytesBE(user)
-	if err != nil {
-		return nil, fmt.Errorf("could not convert unbind user to uint160: %w", err)
-	}
-
-	// parse keys
-	unbindKeys, err := client.ArrayFromStackItem(params[1])
-	if err != nil {
-		return nil, fmt.Errorf("could not get unbind keys: %w", err)
-	}
-
-	ev.keys = make([]*keys.PublicKey, 0, len(unbindKeys))
-	for i := range unbindKeys {
-		rawKey, err := client.BytesFromStackItem(unbindKeys[i])
-		if err != nil {
-			return nil, fmt.Errorf("could not get unbind public key: %w", err)
-		}
-
-		key, err := keys.NewPublicKeyFromBytes(rawKey, elliptic.P256())
-		if err != nil {
-			return nil, fmt.Errorf("could not parse unbind public key: %w", err)
-		}
-
-		ev.keys = append(ev.keys, key)
 	}
 
 	return ev, nil

pkg/morph/event/neofs/unbind_test.go

@@ -1,26 +1,20 @@
 package neofs
 
 import (
-	"crypto/ecdsa"
-	"crypto/elliptic"
 	"testing"
 
-	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
-	"github.com/nspcc-dev/neo-go/pkg/util"
 	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
-	crypto "github.com/nspcc-dev/neofs-crypto"
 	"github.com/nspcc-dev/neofs-node/pkg/morph/event"
-	"github.com/nspcc-dev/neofs-node/pkg/util/test"
 	"github.com/stretchr/testify/require"
 )
 
 func TestParseUnbind(t *testing.T) {
 	var (
-		user       = util.Uint160{0x1, 0x2, 0x3}
+		user       = []byte{0x1, 0x2, 0x3}
-		publicKeys = []*ecdsa.PublicKey{
+		publicKeys = [][]byte{
-			&test.DecodeKey(1).PublicKey,
+			[]byte("key1"),
-			&test.DecodeKey(2).PublicKey,
+			[]byte("key2"),
-			&test.DecodeKey(3).PublicKey,
+			[]byte("key3"),
 		}
 	)
 
@@ -43,7 +37,7 @@ func TestParseUnbind(t *testing.T) {
 
 	t.Run("wrong second parameter", func(t *testing.T) {
 		_, err := ParseUnbind([]stackitem.Item{
-			stackitem.NewByteArray(user.BytesBE()),
+			stackitem.NewByteArray(user),
 			stackitem.NewMap(),
 		})
 
@@ -52,25 +46,18 @@ func TestParseUnbind(t *testing.T) {
 
 	t.Run("correct", func(t *testing.T) {
 		ev, err := ParseUnbind([]stackitem.Item{
-			stackitem.NewByteArray(user.BytesBE()),
+			stackitem.NewByteArray(user),
 			stackitem.NewArray([]stackitem.Item{
-				stackitem.NewByteArray(crypto.MarshalPublicKey(publicKeys[0])),
+				stackitem.NewByteArray(publicKeys[0]),
-				stackitem.NewByteArray(crypto.MarshalPublicKey(publicKeys[1])),
+				stackitem.NewByteArray(publicKeys[1]),
-				stackitem.NewByteArray(crypto.MarshalPublicKey(publicKeys[2])),
+				stackitem.NewByteArray(publicKeys[2]),
 			}),
 		})
 		require.NoError(t, err)
 
-		expKeys := make([]*keys.PublicKey, len(publicKeys))
+		e := ev.(Unbind)
-		for i := range publicKeys {
-			expKeys[i], err = keys.NewPublicKeyFromBytes(
-				crypto.MarshalPublicKey(publicKeys[i]), elliptic.P256())
-			require.NoError(t, err)
-		}
 
-		require.Equal(t, Unbind{
+		require.Equal(t, user, e.User())
-			user: user,
+		require.Equal(t, publicKeys, e.Keys())
-			keys: expKeys,
-		}, ev)
 	})
 }