scale: encode/decode []string in struct (#560)

* create encoder for []string

* save commit

* added ability to decode []string

* go fmt project

* removed extra logging

* cleanup error check

* refactor flow

* added DecodeStringArray function

* go fmt code

codec/decode.go

@@ -281,22 +281,6 @@ func (sd *Decoder) DecodeByteArray() (o []byte, err error) {
 	return b, nil
 }
 
-// DecodePtrByteArray accepts a byte array representing a SCALE encoded byte array and performs SCALE decoding
-// of the byte array
-func (sd *Decoder) DecodePtrByteArray(output interface{}) error {
-	_, err := sd.DecodeInteger()
-	if err != nil {
-		return err
-	}
-
-	_, err = sd.Reader.Read(output.([]byte))
-	if err != nil {
-		return errors.New("could not decode invalid byte array: reached early EOF")
-	}
-
-	return nil
-}
-
 // DecodeBool accepts a byte array representing a SCALE encoded bool and performs SCALE decoding
 // of the bool then returns it. if invalid, return false and an error
 func (sd *Decoder) DecodeBool() (bool, error) {
@@ -534,6 +518,13 @@ func (sd *Decoder) DecodeTuple(t interface{}) (interface{}, error) {
 				// get the pointer to the value and set the value
 				ptr := fieldValue.(*string)
 				*ptr = string(o.([]byte))
+			case []string:
+				o, err = sd.DecodeStringArray()
+				if err != nil {
+					break
+				}
+				ptr := fieldValue.(*[]string)
+				*ptr = o.([]string)
 			default:
 				_, err = sd.Decode(v.Field(i).Interface())
 				if err != nil {
@@ -604,3 +595,20 @@ func (sd *Decoder) DecodeBoolArray() ([]bool, error) {
 	}
 	return o, nil
 }
+
+func (sd *Decoder) DecodeStringArray() ([]string, error) {
+	length, err := sd.DecodeInteger()
+	if err != nil {
+		return nil, err
+	}
+	s := make([]string, length)
+
+	for i := 0; i < int(length); i++ {
+		o, err := sd.DecodeByteArray()
+		if err != nil {
+			return nil, err
+		}
+		s[i] = string(o[:]) // cast []byte into string
+	}
+	return s, nil
+}

codec/decode_ptr.go

@@ -117,6 +117,22 @@ func (sd *Decoder) DecodePtrFixedWidthInt(t interface{}) (err error) {
 	return err
 }
 
+// DecodePtrByteArray accepts a byte array representing a SCALE encoded byte array and performs SCALE decoding
+// of the byte array
+func (sd *Decoder) DecodePtrByteArray(output interface{}) error {
+	_, err := sd.DecodeInteger()
+	if err != nil {
+		return err
+	}
+
+	_, err = sd.Reader.Read(output.([]byte))
+	if err != nil {
+		return errors.New("could not decode invalid byte array: reached early EOF")
+	}
+
+	return nil
+}
+
 // DecodePtrBigInt decodes a SCALE encoded byte array into a *big.Int
 //  Changes the value of output to decoded value
 // Works for all integers, including ints > 2**64

codec/encode.go

@@ -306,6 +306,14 @@ func (se *Encoder) encodeArray(t interface{}) (bytesEncoded int, err error) {
 			n, err = se.encodeArray(elem)
 			bytesEncoded += n
 		}
+	case []string:
+		n, err = se.encodeInteger(uint(len(arr)))
+		bytesEncoded += n
+
+		for _, elem := range arr {
+			n, err = se.encodeByteArray([]byte(elem))
+			bytesEncoded += n
+		}
 	}
 
 	return bytesEncoded, err

codec/encode_test.go

@@ -22,6 +22,8 @@ import (
 	"reflect"
 	"strings"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 type encodeTest struct {
@@ -190,3 +192,21 @@ func TestEncodeAndDecodeStringInStruct(t *testing.T) {
 		t.Fatalf("Fail: got %v expected %v", dec, test)
 	}
 }
+
+func TestEncodeAndDecodeStringArrayInStruct(t *testing.T) {
+	test := &struct {
+		A []string
+	}{
+		A: []string{"noot", "noot2"},
+	}
+
+	enc, err := Encode(test)
+	require.Nil(t, err)
+	require.NotEqual(t, 0, len(enc), "Failed to encode StringArrayInStruct")
+
+	var result = &struct{ A []string }{}
+
+	err = DecodePtr(enc, result)
+	require.Nil(t, err)
+	require.Equal(t, test, result, "Decoding failed")
+}