Extract serializer/deserializer to hive.go (#290)

* Extract serialization/deserialization to hive.go repository.

* Update hive.go dependency.

* Move constants and serializer errors to hive.go

* Move specific values back from hive.go

* Update go.mod

Author: piotrm50

address.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 
+	"github.com/iotaledger/hive.go/serializer"
 	"github.com/iotaledger/iota.go/v2/bech32"
 	"github.com/iotaledger/iota.go/v2/ed25519"
 	"golang.org/x/crypto/blake2b"
@@ -31,12 +32,12 @@ const (
 	// Ed25519AddressBytesLength is the length of an Ed25519 address.
 	Ed25519AddressBytesLength = blake2b.Size256
 	// Ed25519AddressSerializedBytesSize is the size of a serialized Ed25519 address with its type denoting byte.
-	Ed25519AddressSerializedBytesSize = SmallTypeDenotationByteSize + Ed25519AddressBytesLength
+	Ed25519AddressSerializedBytesSize = serializer.SmallTypeDenotationByteSize + Ed25519AddressBytesLength
 )
 
 // Address describes a general address.
 type Address interface {
-	Serializable
+	serializer.Serializable
 	fmt.Stringer
 
 	// Type returns the type of the address.
@@ -47,7 +48,7 @@ type Address interface {
 }
 
 // AddressSelector implements SerializableSelectorFunc for address types.
-func AddressSelector(addressType uint32) (Serializable, error) {
+func AddressSelector(addressType uint32) (serializer.Serializable, error) {
 	return newAddress(byte(addressType))
 }
 
@@ -61,7 +62,7 @@ func newAddress(addressType byte) (address Address, err error) {
 }
 
 func bech32String(hrp NetworkPrefix, addr Address) string {
-	bytes, _ := addr.Serialize(DeSeriModeNoValidation)
+	bytes, _ := addr.Serialize(serializer.DeSeriModeNoValidation)
 	s, err := bech32.Encode(string(hrp), bytes)
 	if err != nil {
 		panic(err)
@@ -77,21 +78,21 @@ func ParseBech32(s string) (NetworkPrefix, Address, error) {
 	}
 
 	if len(addrData) == 0 {
-		return "", nil, ErrDeserializationNotEnoughData
+		return "", nil, serializer.ErrDeserializationNotEnoughData
 	}
 
 	addr, err := newAddress(addrData[0])
 	if err != nil {
 		return "", nil, err
 	}
 
-	n, err := addr.Deserialize(addrData, DeSeriModePerformValidation)
+	n, err := addr.Deserialize(addrData, serializer.DeSeriModePerformValidation)
 	if err != nil {
 		return "", nil, err
 	}
 
 	if n != len(addrData) {
-		return "", nil, ErrDeserializationNotAllConsumed
+		return "", nil, serializer.ErrDeserializationNotAllConsumed
 	}
 
 	return NetworkPrefix(hrp), addr, nil
@@ -134,23 +135,23 @@ func (edAddr *Ed25519Address) String() string {
 	return hex.EncodeToString(edAddr[:])
 }
 
-func (edAddr *Ed25519Address) Deserialize(data []byte, deSeriMode DeSerializationMode) (int, error) {
-	if deSeriMode.HasMode(DeSeriModePerformValidation) {
-		if err := checkMinByteLength(Ed25519AddressSerializedBytesSize, len(data)); err != nil {
+func (edAddr *Ed25519Address) Deserialize(data []byte, deSeriMode serializer.DeSerializationMode) (int, error) {
+	if deSeriMode.HasMode(serializer.DeSeriModePerformValidation) {
+		if err := serializer.CheckMinByteLength(Ed25519AddressSerializedBytesSize, len(data)); err != nil {
 			return 0, fmt.Errorf("invalid Ed25519 address bytes: %w", err)
 		}
-		if err := checkTypeByte(data, AddressEd25519); err != nil {
+		if err := serializer.CheckTypeByte(data, AddressEd25519); err != nil {
 			return 0, fmt.Errorf("unable to deserialize Ed25519 address: %w", err)
 		}
 	}
-	copy(edAddr[:], data[SmallTypeDenotationByteSize:])
+	copy(edAddr[:], data[serializer.SmallTypeDenotationByteSize:])
 	return Ed25519AddressSerializedBytesSize, nil
 }
 
-func (edAddr *Ed25519Address) Serialize(deSeriMode DeSerializationMode) (data []byte, err error) {
+func (edAddr *Ed25519Address) Serialize(deSeriMode serializer.DeSerializationMode) (data []byte, err error) {
 	var b [Ed25519AddressSerializedBytesSize]byte
 	b[0] = AddressEd25519
-	copy(b[SmallTypeDenotationByteSize:], edAddr[:])
+	copy(b[serializer.SmallTypeDenotationByteSize:], edAddr[:])
 	return b[:], nil
 }
 
@@ -197,12 +198,12 @@ type jsonEd25519Address struct {
 	Address string `json:"address"`
 }
 
-func (j *jsonEd25519Address) ToSerializable() (Serializable, error) {
+func (j *jsonEd25519Address) ToSerializable() (serializer.Serializable, error) {
 	addrBytes, err := hex.DecodeString(j.Address)
 	if err != nil {
 		return nil, fmt.Errorf("unable to decode address from JSON for Ed25519 address: %w", err)
 	}
-	if err := checkExactByteLength(len(addrBytes), Ed25519AddressBytesLength); err != nil {
+	if err := serializer.CheckExactByteLength(len(addrBytes), Ed25519AddressBytesLength); err != nil {
 		return nil, fmt.Errorf("unable to decode address from JSON for Ed25519 address: %w", err)
 	}
 	addr := &Ed25519Address{}

address_signer.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/iotaledger/hive.go/serializer"
 	"github.com/iotaledger/iota.go/v2/ed25519"
 )
 
@@ -17,13 +18,13 @@ var (
 // AddressSigner produces signatures for messages which get verified against a given address.
 type AddressSigner interface {
 	// Sign produces the signature for the given message.
-	Sign(addr Address, msg []byte) (signature Serializable, err error)
+	Sign(addr Address, msg []byte) (signature serializer.Serializable, err error)
 }
 
 // AddressSignerFunc implements the AddressSigner interface.
-type AddressSignerFunc func(addr Address, msg []byte) (signature Serializable, err error)
+type AddressSignerFunc func(addr Address, msg []byte) (signature serializer.Serializable, err error)
 
-func (s AddressSignerFunc) Sign(addr Address, msg []byte) (signature Serializable, err error) {
+func (s AddressSignerFunc) Sign(addr Address, msg []byte) (signature serializer.Serializable, err error) {
 	return s(addr, msg)
 }
 
@@ -56,7 +57,7 @@ type InMemoryAddressSigner struct {
 	addrKeys map[string]interface{}
 }
 
-func (s *InMemoryAddressSigner) Sign(addr Address, msg []byte) (signature Serializable, err error) {
+func (s *InMemoryAddressSigner) Sign(addr Address, msg []byte) (signature serializer.Serializable, err error) {
 	switch addr.(type) {
 	case *Ed25519Address:
 		maybePrvKey, ok := s.addrKeys[addr.String()]

address_test.go

@@ -2,6 +2,7 @@ package iotago_test
 
 import (
 	"errors"
+	"github.com/iotaledger/hive.go/serializer"
 	"github.com/iotaledger/iota.go/v2/tpkg"
 	"testing"
 
@@ -29,21 +30,21 @@ func TestEd25519Address_Deserialize(t *testing.T) {
 				_, edAddrData := tpkg.RandEd25519Address()
 				return edAddrData[:iotago.Ed25519AddressSerializedBytesSize-1]
 			}(),
-			iotago.ErrDeserializationNotEnoughData,
+			serializer.ErrDeserializationNotEnoughData,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			edAddr := &iotago.Ed25519Address{}
-			bytesRead, err := edAddr.Deserialize(tt.edAddrData, iotago.DeSeriModePerformValidation)
+			bytesRead, err := edAddr.Deserialize(tt.edAddrData, serializer.DeSeriModePerformValidation)
 			if tt.err != nil {
 				assert.True(t, errors.Is(err, tt.err))
 				return
 			}
 			assert.NoError(t, err)
 			assert.Equal(t, len(tt.edAddrData), bytesRead)
-			assert.Equal(t, tt.edAddrData[iotago.SmallTypeDenotationByteSize:], edAddr[:])
+			assert.Equal(t, tt.edAddrData[serializer.SmallTypeDenotationByteSize:], edAddr[:])
 		})
 	}
 }
@@ -61,7 +62,7 @@ func TestEd25519Address_Serialize(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			edData, err := tt.source.Serialize(iotago.DeSeriModePerformValidation)
+			edData, err := tt.source.Serialize(serializer.DeSeriModePerformValidation)
 			assert.NoError(t, err)
 			assert.Equal(t, tt.target, edData)
 		})

benches_test.go

@@ -1,6 +1,7 @@
 package iotago_test
 
 import (
+	"github.com/iotaledger/hive.go/serializer"
 	"github.com/iotaledger/iota.go/v2/tpkg"
 	"testing"
 
@@ -9,54 +10,54 @@ import (
 )
 
 func BenchmarkDeserializeWithValidationOneIOTxPayload(b *testing.B) {
-	data, err := tpkg.OneInputOutputTransaction().Serialize(iotago.DeSeriModeNoValidation)
+	data, err := tpkg.OneInputOutputTransaction().Serialize(serializer.DeSeriModeNoValidation)
 	if err != nil {
 		b.Fatal(err)
 	}
 
 	target := &iotago.Transaction{}
-	_, err = target.Deserialize(data, iotago.DeSeriModeNoValidation)
+	_, err = target.Deserialize(data, serializer.DeSeriModeNoValidation)
 	if err != nil {
 		b.Fatal(err)
 	}
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		target.Deserialize(data, iotago.DeSeriModePerformValidation)
+		target.Deserialize(data, serializer.DeSeriModePerformValidation)
 	}
 }
 
 func BenchmarkDeserializeWithoutValidationOneIOTxPayload(b *testing.B) {
-	data, err := tpkg.OneInputOutputTransaction().Serialize(iotago.DeSeriModeNoValidation)
+	data, err := tpkg.OneInputOutputTransaction().Serialize(serializer.DeSeriModeNoValidation)
 	if err != nil {
 		b.Fatal(err)
 	}
 
 	target := &iotago.Transaction{}
-	_, err = target.Deserialize(data, iotago.DeSeriModeNoValidation)
+	_, err = target.Deserialize(data, serializer.DeSeriModeNoValidation)
 	if err != nil {
 		b.Fatal(err)
 	}
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		target.Deserialize(data, iotago.DeSeriModeNoValidation)
+		target.Deserialize(data, serializer.DeSeriModeNoValidation)
 	}
 }
 
 func BenchmarkSerializeWithValidationOneIOTxPayload(b *testing.B) {
 	txPayload := tpkg.OneInputOutputTransaction()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		txPayload.Serialize(iotago.DeSeriModePerformValidation)
+		txPayload.Serialize(serializer.DeSeriModePerformValidation)
 	}
 }
 
 func BenchmarkSerializeWithoutValidationOneIOTxPayload(b *testing.B) {
 	sigTxPayload := tpkg.OneInputOutputTransaction()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		sigTxPayload.Serialize(iotago.DeSeriModeNoValidation)
+		sigTxPayload.Serialize(serializer.DeSeriModeNoValidation)
 	}
 }
 

consts.go

@@ -1,48 +1,6 @@
 package iotago
 
 const (
-	// OneByte is the byte size of a single byte.
-	OneByte = 1
-	// Int16ByteSize is the byte size of an int16.
-	Int16ByteSize = 2
-	// UInt16ByteSize is the byte size of a uint16.
-	UInt16ByteSize = 2
-	// Int32ByteSize is the byte size of an int32.
-	Int32ByteSize = 4
-	// UInt32ByteSize is the byte size of a uint32.
-	UInt32ByteSize = 4
-	// Float32ByteSize is the byte size of a float32.
-	Float32ByteSize = 4
-	// Int64ByteSize is the byte size of an int64.
-	Int64ByteSize = 8
-	// UInt64ByteSize is the byte size of an uint64.
-	UInt64ByteSize = 8
-	// Float64ByteSize is the byte size of a float64.
-	Float64ByteSize = 8
-	// TypeDenotationByteSize is the size of a type denotation.
-	TypeDenotationByteSize = UInt32ByteSize
-	// SmallTypeDenotationByteSize is the size of a type denotation for a small range of possible values.
-	SmallTypeDenotationByteSize = OneByte
-	// StructArrayLengthByteSize is the byte size of struct array lengths.
-	StructArrayLengthByteSize = UInt16ByteSize
-	// ByteArrayLengthByteSize is the byte size of byte array lengths.
-	ByteArrayLengthByteSize = UInt32ByteSize
-	// PayloadLengthByteSize is the size of the payload length denoting bytes.
-	PayloadLengthByteSize = UInt32ByteSize
-	// MinPayloadByteSize is the minimum size of a payload (together with its length denotation).
-	MinPayloadByteSize = UInt32ByteSize + OneByte
 	// TokenSupply is the IOTA token supply.
 	TokenSupply = 2_779_530_283_277_761
 )
-
-// TypeDenotationType defines a type denotation.
-type TypeDenotationType byte
-
-const (
-	// TypeDenotationUint32 defines a denotation which defines a type ID by a uint32.
-	TypeDenotationUint32 TypeDenotationType = iota
-	// TypeDenotationByte defines a denotation which defines a type ID by a byte.
-	TypeDenotationByte
-	// TypeDenotationNone defines that there is no type denotation.
-	TypeDenotationNone
-)

error.go

@@ -1,17 +1,10 @@
 package iotago
 
 import (
-	"encoding/binary"
 	"errors"
-	"fmt"
 )
 
 var (
-	// ErrInvalidBytes gets returned when data is invalid for deserialization.
-	ErrInvalidBytes = errors.New("invalid bytes")
-	// ErrDeserializationTypeMismatch gets returned when a denoted type for a given object is mismatched.
-	// For example, while trying to deserialize a signature unlock block, a reference unlock block is seen.
-	ErrDeserializationTypeMismatch = errors.New("data type is invalid for deserialization")
 	// ErrUnsupportedPayloadType gets returned for unsupported payload types.
 	ErrUnsupportedPayloadType = errors.New("unsupported payload type")
 	// ErrUnsupportedObjectType gets returned for unsupported object types.
@@ -30,61 +23,4 @@ var (
 	ErrUnknownUnlockBlockType = errors.New("unknown unlock block type")
 	// ErrUnknownSignatureType gets returned for unknown signature types.
 	ErrUnknownSignatureType = errors.New("unknown signature type")
-	// ErrUnknownArrayValidationMode gets returned for unknown array validation modes.
-	ErrUnknownArrayValidationMode = errors.New("unknown array validation mode")
-	// ErrArrayValidationMinElementsNotReached gets returned if the count of elements is too small.
-	ErrArrayValidationMinElementsNotReached = errors.New("min count of elements within the array not reached")
-	// ErrArrayValidationMaxElementsExceeded gets returned if the count of elements is too big.
-	ErrArrayValidationMaxElementsExceeded = errors.New("max count of elements within the array exceeded")
-	// ErrArrayValidationViolatesUniqueness gets returned if the array elements are not unique.
-	ErrArrayValidationViolatesUniqueness = errors.New("array elements must be unique")
-	// ErrArrayValidationOrderViolatesLexicalOrder gets returned if the array elements are not in lexical order.
-	ErrArrayValidationOrderViolatesLexicalOrder = errors.New("array elements must be in their lexical order (byte wise)")
-	// ErrDeserializationNotEnoughData gets returned if there is not enough data available to deserialize a given object.
-	ErrDeserializationNotEnoughData = errors.New("not enough data for deserialization")
-	// ErrDeserializationInvalidBoolValue gets returned when a bool value is tried to be read but it is neither 0 or 1.
-	ErrDeserializationInvalidBoolValue = errors.New("invalid bool value")
-	// ErrDeserializationLengthInvalid gets returned if a length denotation exceeds a specified limit.
-	ErrDeserializationLengthInvalid = errors.New("length denotation invalid")
-	// ErrDeserializationNotAllConsumed gets returned if not all bytes were consumed during deserialization of a given type.
-	ErrDeserializationNotAllConsumed = errors.New("not all data has been consumed but should have been")
 )
-
-// checkType checks that the denoted type equals the shouldType.
-func checkType(data []byte, shouldType uint32) error {
-	if len(data) < 4 {
-		return fmt.Errorf("%w: can't check type denotation", ErrDeserializationNotEnoughData)
-	}
-	actualType := binary.LittleEndian.Uint32(data)
-	if actualType != shouldType {
-		return fmt.Errorf("%w: type denotation must be %d but is %d", ErrDeserializationTypeMismatch, shouldType, actualType)
-	}
-	return nil
-}
-
-// checkTypeByte checks that the denoted type byte equals the shouldType.
-func checkTypeByte(data []byte, shouldType byte) error {
-	if data == nil || len(data) == 0 {
-		return fmt.Errorf("%w: can't check type byte", ErrDeserializationNotEnoughData)
-	}
-	if data[0] != shouldType {
-		return fmt.Errorf("%w: type denotation must be %d but is %d", ErrDeserializationTypeMismatch, shouldType, data[0])
-	}
-	return nil
-}
-
-// checkExactByteLength checks that the given length equals exact.
-func checkExactByteLength(exact int, length int) error {
-	if length != exact {
-		return fmt.Errorf("%w: data must be at exact %d bytes long but is %d", ErrInvalidBytes, exact, length)
-	}
-	return nil
-}
-
-// checkMinByteLength checks that length is min. min.
-func checkMinByteLength(min int, length int) error {
-	if length < min {
-		return fmt.Errorf("%w: data must be at least %d bytes long but is %d", ErrDeserializationNotEnoughData, min, length)
-	}
-	return nil
-}

fuzzing/indexation/go.mod

@@ -5,6 +5,6 @@ go 1.16
 replace github.com/iotaledger/iota.go/v2 => ./../..
 
 require (
-	github.com/dvyukov/go-fuzz v0.0.0-20210103155950-6a8e9d1f2415 // indirect
+	github.com/iotaledger/hive.go v0.0.0-20210907083658-27edf6b49375
 	github.com/iotaledger/iota.go/v2 v2.0.0-20210303080450-b3ab28991fc8
 )