From f412d205231e21014527b66e99383434cf7a6cff Mon Sep 17 00:00:00 2001 From: Alex Vanin Date: Tue, 8 Sep 2020 11:38:23 +0300 Subject: [PATCH] [#21] Add neofs unbind event Signed-off-by: Alex Vanin --- pkg/morph/event/neofs/unbind.go | 69 ++++++++++++++++++++ pkg/morph/event/neofs/unbind_test.go | 97 ++++++++++++++++++++++++++++ 2 files changed, 166 insertions(+) create mode 100644 pkg/morph/event/neofs/unbind.go create mode 100644 pkg/morph/event/neofs/unbind_test.go diff --git a/pkg/morph/event/neofs/unbind.go b/pkg/morph/event/neofs/unbind.go new file mode 100644 index 000000000..b06b06360 --- /dev/null +++ b/pkg/morph/event/neofs/unbind.go @@ -0,0 +1,69 @@ +package neofs + +import ( + "crypto/elliptic" + + "github.com/nspcc-dev/neo-go/pkg/crypto/keys" + "github.com/nspcc-dev/neo-go/pkg/smartcontract" + "github.com/nspcc-dev/neo-go/pkg/util" + "github.com/nspcc-dev/neofs-node/pkg/morph/client" + "github.com/nspcc-dev/neofs-node/pkg/morph/event" + "github.com/pkg/errors" +) + +type Unbind struct { + user util.Uint160 + 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 []smartcontract.Parameter) (event.Event, error) { + var ( + ev Unbind + err error + ) + + if ln := len(params); ln != 2 { + return nil, event.WrongNumberOfParameters(2, ln) + } + + // parse user + user, err := client.BytesFromStackParameter(params[0]) + if err != nil { + return nil, errors.Wrap(err, "could not get bind user") + } + + ev.user, err = util.Uint160DecodeBytesBE(user) + if err != nil { + return nil, errors.Wrap(err, "could not convert unbind user to uint160") + } + + // parse keys + unbindKeys, err := client.ArrayFromStackParameter(params[1]) + if err != nil { + return nil, errors.Wrap(err, "could not get unbind keys") + } + + ev.keys = make([]*keys.PublicKey, 0, len(unbindKeys)) + for i := range unbindKeys { + rawKey, err := client.BytesFromStackParameter(unbindKeys[i]) + if err != nil { + return nil, errors.Wrap(err, "could not get unbind public key") + } + + key, err := keys.NewPublicKeyFromBytes(rawKey, elliptic.P256()) + if err != nil { + return nil, errors.Wrap(err, "could not parse unbind public key") + } + + ev.keys = append(ev.keys, key) + } + + return ev, nil +} diff --git a/pkg/morph/event/neofs/unbind_test.go b/pkg/morph/event/neofs/unbind_test.go new file mode 100644 index 000000000..dbb6a0354 --- /dev/null +++ b/pkg/morph/event/neofs/unbind_test.go @@ -0,0 +1,97 @@ +package neofs + +import ( + "crypto/ecdsa" + "crypto/elliptic" + "testing" + + "github.com/nspcc-dev/neo-go/pkg/crypto/keys" + "github.com/nspcc-dev/neo-go/pkg/smartcontract" + "github.com/nspcc-dev/neo-go/pkg/util" + 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} + publicKeys = []*ecdsa.PublicKey{ + &test.DecodeKey(1).PublicKey, + &test.DecodeKey(2).PublicKey, + &test.DecodeKey(3).PublicKey, + } + ) + + t.Run("wrong number of parameters", func(t *testing.T) { + prms := []smartcontract.Parameter{ + {}, + } + + _, err := ParseUnbind(prms) + require.EqualError(t, err, event.WrongNumberOfParameters(2, len(prms)).Error()) + }) + + t.Run("wrong first parameter", func(t *testing.T) { + _, err := ParseUnbind([]smartcontract.Parameter{ + { + Type: smartcontract.ArrayType, + }, + }) + + require.Error(t, err) + }) + + t.Run("wrong second parameter", func(t *testing.T) { + _, err := ParseUnbind([]smartcontract.Parameter{ + { + Type: smartcontract.ByteArrayType, + Value: user.BytesBE(), + }, + { + Type: smartcontract.ArrayType, + }, + }) + + require.Error(t, err) + }) + + t.Run("correct", func(t *testing.T) { + ev, err := ParseUnbind([]smartcontract.Parameter{ + { + Type: smartcontract.ByteArrayType, + Value: user.BytesBE(), + }, + { + Type: smartcontract.ArrayType, + Value: []smartcontract.Parameter{ + { + Type: smartcontract.ByteArrayType, + Value: crypto.MarshalPublicKey(publicKeys[0]), + }, + { + Type: smartcontract.ByteArrayType, + Value: crypto.MarshalPublicKey(publicKeys[1]), + }, + { + Type: smartcontract.ByteArrayType, + Value: crypto.MarshalPublicKey(publicKeys[2]), + }, + }, + }, + }) + require.NoError(t, err) + + expKeys := make([]*keys.PublicKey, len(publicKeys)) + for i := range publicKeys { + expKeys[i], err = keys.NewPublicKeyFromBytes(crypto.MarshalPublicKey(publicKeys[i]), elliptic.P256()) + require.NoError(t, err) + } + + require.Equal(t, Unbind{ + user: user, + keys: expKeys, + }, ev) + }) +}