Decoding/Encoding for []uint16, []uint32 and []uint64

README.md

@@ -13,7 +13,10 @@ Object{}    | concatenation of fields
 uint8       | compact u8 [TODO no need for compact u8]
 uint16      | compact u16
 uint32      | compact u32
-uint32      | compact u64
+uint34      | compact u64
+[]uint16    | length prefixed (compact u32) followed by compact u16s
+[]uint32    | length prefixed (compact u32) followed by compact u32s
+[]uint64    | length prefixed (compact u32) followed by compact u64s
 [...]Object | array with objects. encoded by consecutively encoding every object
 []Object    | slice with objects. prefixed with compact u32
 

decoder.go

@@ -330,6 +330,84 @@
 	return d.read(value)
 }
 
+func DecodeUint16Slice(d *Decoder) ([]uint16, int, error) {
+	return DecodeUint16SliceWithLimit(d, d.maxElements)
+}
+
+func DecodeUint16SliceWithLimit(d *Decoder, limit uint32) ([]uint16, int, error) {
+	lth, total, err := DecodeLen(d, limit)
+	if err != nil {
+		return nil, 0, err
+	}
+	if lth == 0 {
+		return nil, total, nil
+	}
+	values := make([]uint16, lth)
+
+	for i := uint32(0); i < lth; i++ {
+		v, n, err := DecodeCompact16(d)
+		if err != nil {
+			return nil, 0, err
+		}
+		total += n
+		values[i] = v
+	}
+
+	return values, total, nil
+}
+
+func DecodeUint32Slice(d *Decoder) ([]uint32, int, error) {
+	return DecodeUint32SliceWithLimit(d, d.maxElements)
+}
+
+func DecodeUint32SliceWithLimit(d *Decoder, limit uint32) ([]uint32, int, error) {
+	lth, total, err := DecodeLen(d, limit)
+	if err != nil {
+		return nil, 0, err
+	}
+	if lth == 0 {
+		return nil, total, nil
+	}
+	values := make([]uint32, lth)
+
+	for i := uint32(0); i < lth; i++ {
+		v, n, err := DecodeCompact32(d)
+		if err != nil {
+			return nil, 0, err
+		}
+		total += n
+		values[i] = v
+	}
+
+	return values, total, nil
+}
+
+func DecodeUint64Slice(d *Decoder) ([]uint64, int, error) {
+	return DecodeUint64SliceWithLimit(d, d.maxElements)
+}
+
+func DecodeUint64SliceWithLimit(d *Decoder, limit uint32) ([]uint64, int, error) {
+	lth, total, err := DecodeLen(d, limit)
+	if err != nil {
+		return nil, 0, err
+	}
+	if lth == 0 {
+		return nil, total, nil
+	}
+	values := make([]uint64, lth)
+
+	for i := uint32(0); i < lth; i++ {
+		v, n, err := DecodeCompact64(d)
+		if err != nil {
+			return nil, 0, err
+		}
+		total += n
+		values[i] = v
+	}
+
+	return values, total, nil
+}
+
 func DecodeString(d *Decoder) (string, int, error) {
 	return DecodeStringWithLimit(d, d.maxElements)
 }

decoder_test.go

@@ -39,6 +39,12 @@ func testEncode(tb testing.TB, value any) []byte {
 		_, err = EncodeCompact64(enc, val)
 	case []byte:
 		_, err = EncodeByteSlice(enc, val)
+	case []uint16:
+		_, err = EncodeUint16Slice(enc, val)
+	case []uint32:
+		_, err = EncodeUint32Slice(enc, val)
+	case []uint64:
+		_, err = EncodeUint64Slice(enc, val)
 	case string:
 		_, err = EncodeString(enc, val)
 	case []string:
@@ -65,6 +71,12 @@ func expectEqual(tb testing.TB, value any, r io.Reader) {
 		rst, _, err = DecodeCompact64(dec)
 	case []byte:
 		rst, _, err = DecodeByteSlice(dec)
+	case []uint16:
+		rst, _, err = DecodeUint16Slice(dec)
+	case []uint32:
+		rst, _, err = DecodeUint32Slice(dec)
+	case []uint64:
+		rst, _, err = DecodeUint64Slice(dec)
 	case string:
 		rst, _, err = DecodeString(dec)
 	case []string:
@@ -107,6 +119,18 @@ func TestReadFull(t *testing.T) {
 			desc:   "string slice",
 			expect: []string{"qwe123", "dsa456"},
 		},
+		{
+			desc:   "uint16 slice",
+			expect: []uint16{0, 1, 2, math.MaxUint8, math.MaxUint16},
+		},
+		{
+			desc:   "uint32 slice",
+			expect: []uint32{0, 1, 2, math.MaxUint8, math.MaxUint16, math.MaxUint32},
+		},
+		{
+			desc:   "uint64 slice",
+			expect: []uint64{0, 1, 2, math.MaxUint32, math.MaxUint64},
+		},
 	} {
 		t.Run(tc.desc, func(t *testing.T) {
 			t.Run("full", func(t *testing.T) {

encoder.go

@@ -105,6 +105,66 @@
 	return e.w.Write(value)
 }
 
+func EncodeUint16Slice(e *Encoder, value []uint16) (int, error) {
+	return EncodeUint16SliceWithLimit(e, value, e.maxElements)
+}
+
+func EncodeUint16SliceWithLimit(e *Encoder, value []uint16, limit uint32) (int, error) {
+	total, err := EncodeLen(e, uint32(len(value)), limit)
+	if err != nil {
+		return 0, err
+	}
+	for _, v := range value {
+		n, err := EncodeCompact16(e, v)
+		if err != nil {
+			return 0, err
+		}
+		total += n
+	}
+
+	return total, nil
+}
+
+func EncodeUint32Slice(e *Encoder, value []uint32) (int, error) {
+	return EncodeUint32SliceWithLimit(e, value, e.maxElements)
+}
+
+func EncodeUint32SliceWithLimit(e *Encoder, value []uint32, limit uint32) (int, error) {
+	total, err := EncodeLen(e, uint32(len(value)), limit)
+	if err != nil {
+		return 0, err
+	}
+	for _, v := range value {
+		n, err := EncodeCompact32(e, v)
+		if err != nil {
+			return 0, err
+		}
+		total += n
+	}
+
+	return total, nil
+}
+
+func EncodeUint64Slice(e *Encoder, value []uint64) (int, error) {
+	return EncodeUint64SliceWithLimit(e, value, e.maxElements)
+}
+
+func EncodeUint64SliceWithLimit(e *Encoder, value []uint64, limit uint32) (int, error) {
+	total, err := EncodeLen(e, uint32(len(value)), limit)
+	if err != nil {
+		return 0, err
+	}
+	for _, v := range value {
+		n, err := EncodeCompact64(e, v)
+		if err != nil {
+			return 0, err
+		}
+		total += n
+	}
+
+	return total, nil
+}
+
 func EncodeString(e *Encoder, value string) (int, error) {
 	return EncodeStringWithLimit(e, value, e.maxElements)
 }

encoder_test.go

@@ -2,6 +2,7 @@ package scale
 
 import (
 	"bytes"
+	"encoding/hex"
 	"math"
 	"testing"
 
@@ -128,6 +129,32 @@ func uint64TestCases() []compactTestCase[uint64] {
 	}
 }
 
+func mustDecodeHex(hexStr string) []byte {
+	b, err := hex.DecodeString(hexStr)
+	if err != nil {
+		panic(err)
+	}
+	return b
+}
+
+func uint16SliceTestCases() []compactTestCase[[]uint16] {
+	return []compactTestCase[[]uint16]{
+		{[]uint16{4, 15, 23, math.MaxUint16}, mustDecodeHex("10103c5cfeff0300")},
+	}
+}
+
+func uint32SliceTestCases() []compactTestCase[[]uint32] {
+	return []compactTestCase[[]uint32]{
+		{[]uint32{4, 15, 23, math.MaxUint32}, mustDecodeHex("10103c5c03ffffffff")},
+	}
+}
+
+func uint64SliceTestCases() []compactTestCase[[]uint64] {
+	return []compactTestCase[[]uint64]{
+		{[]uint64{4, 15, 23, math.MaxUint64}, mustDecodeHex("10103c5c13ffffffffffffffff")},
+	}
+}
+
 func encodeTest[T any](t *testing.T, value T, expect []byte) {
 	buf := bytes.NewBuffer(nil)
 	enc := NewEncoder(buf)
@@ -141,6 +168,14 @@ func encodeTest[T any](t *testing.T, value T, expect []byte) {
 		_, err = EncodeCompact32(enc, typed)
 	case uint64:
 		_, err = EncodeCompact64(enc, typed)
+	case []uint16:
+		_, err = EncodeUint16Slice(enc, typed)
+	case []uint32:
+		_, err = EncodeUint32Slice(enc, typed)
+	case []uint64:
+		_, err = EncodeUint64Slice(enc, typed)
+	default:
+		t.Fatal("unsupported type")
 	}
 	require.NoError(t, err)
 	require.Equal(t, expect, buf.Bytes())
@@ -175,4 +210,25 @@ func TestEncodeCompactIntegers(t *testing.T) {
 			})
 		}
 	})
+	t.Run("[]uint16", func(t *testing.T) {
+		for _, tc := range uint16SliceTestCases() {
+			t.Run("", func(t *testing.T) {
+				encodeTest(t, tc.value, tc.expect)
+			})
+		}
+	})
+	t.Run("[]uint32", func(t *testing.T) {
+		for _, tc := range uint32SliceTestCases() {
+			t.Run("", func(t *testing.T) {
+				encodeTest(t, tc.value, tc.expect)
+			})
+		}
+	})
+	t.Run("[]uint64", func(t *testing.T) {
+		for _, tc := range uint64SliceTestCases() {
+			t.Run("", func(t *testing.T) {
+				encodeTest(t, tc.value, tc.expect)
+			})
+		}
+	})
 }

generate.go

@@ -17,7 +17,7 @@ const (
 
 	// nolint
 	package {{ .Package }}
-	
+
 	import (
 		"github.com/spacemeshos/go-scale"
 		{{ range $pkg, $short := .Imported }}"{{ $pkg }}"
@@ -278,6 +278,7 @@ func getDecodeModifier(parentType reflect.Type, field reflect.StructField) strin
 
 func getScaleType(parentType reflect.Type, field reflect.StructField) (scaleType, error) {
 	decodeModifier := getDecodeModifier(parentType, field)
+	encodableType := reflect.TypeOf((*Encodable)(nil)).Elem()
 
 	switch field.Type.Kind() {
 	case reflect.Bool:
@@ -324,9 +325,18 @@ func getScaleType(parentType reflect.Type, field reflect.StructField) (scaleType
 		if maxElements == 0 {
 			return scaleType{}, errors.New("slices must have max scale tag")
 		}
-		if field.Type.Elem().Kind() == reflect.Uint8 {
+		if field.Type.Elem().Kind() == reflect.Uint8 && !field.Type.Elem().Implements(encodableType) {
 			return scaleType{Name: "ByteSliceWithLimit", Args: fmt.Sprintf(", %d", maxElements)}, nil
 		}
+		if field.Type.Elem().Kind() == reflect.Uint16 && !field.Type.Elem().Implements(encodableType) {
+			return scaleType{Name: "Uint16SliceWithLimit", Args: fmt.Sprintf(", %d", maxElements)}, nil
+		}
+		if field.Type.Elem().Kind() == reflect.Uint32 && !field.Type.Elem().Implements(encodableType) {
+			return scaleType{Name: "Uint32SliceWithLimit", Args: fmt.Sprintf(", %d", maxElements)}, nil
+		}
+		if field.Type.Elem().Kind() == reflect.Uint64 && !field.Type.Elem().Implements(encodableType) {
+			return scaleType{Name: "Uint64SliceWithLimit", Args: fmt.Sprintf(", %d", maxElements)}, nil
+		}
 		return scaleType{Name: "StructSliceWithLimit", Args: fmt.Sprintf(", %d", maxElements)}, nil
 	case reflect.Array:
 		if field.Type.Elem().Kind() == reflect.Uint8 {