stackitem: introduce Convertible interface

We have a lot of native contract types that are converted to stack items
before serialization, then deserialized as stack items and converted back to
regular structures. stackitem.Convertible allows to remove a lot of repetitive
io.Serializable code.

This also introduces to/from converter in testserdes which unfortunately
required to change util tests to avoid circular references.

pkg/vm/stackitem/item.go

@@ -52,6 +52,12 @@ type Item interface {
 	Convert(Type) (Item, error)
 }
 
+// Convertible is something that can be converted to/from Item.
+type Convertible interface {
+	ToStackItem() (Item, error)
+	FromStackItem(Item) error
+}
+
 var (
 	// ErrInvalidConversion is returned on attempt to make an incorrect
 	// conversion between item types.

pkg/vm/stackitem/serialization.go

@@ -254,3 +254,21 @@ func decodeBinary(r *io.BinReader, allowInvalid bool) Item {
 		return nil
 	}
 }
+
+// SerializeConvertible serializes Convertible into a slice of bytes.
+func SerializeConvertible(conv Convertible) ([]byte, error) {
+	item, err := conv.ToStackItem()
+	if err != nil {
+		return nil, err
+	}
+	return Serialize(item)
+}
+
+// DeserializeConvertible deserializes Convertible from a slice of bytes.
+func DeserializeConvertible(data []byte, conv Convertible) error {
+	item, err := Deserialize(data)
+	if err != nil {
+		return err
+	}
+	return conv.FromStackItem(item)
+}