feat(pkg/scale): encoding and decoding of maps in scale

pkg/scale/decode.go

@@ -159,6 +159,8 @@ func (ds *decodeState) unmarshal(dstv reflect.Value) (err error) {
 			err = ds.decodeArray(dstv)
 		case reflect.Slice:
 			err = ds.decodeSlice(dstv)
+		case reflect.Map:
+			err = ds.decodeMap(dstv)
 		default:
 			err = fmt.Errorf("unsupported type: %T", in)
 		}
@@ -426,6 +428,34 @@ func (ds *decodeState) decodeArray(dstv reflect.Value) (err error) {
 	return
 }
 
+func (ds *decodeState) decodeMap(dstv reflect.Value) (err error) {
+	l, err := ds.decodeLength()
+	if err != nil {
+		return
+	}
+	in := dstv.Interface()
+
+	for i := uint(0); i < l; i++ {
+		tempKeyType := reflect.TypeOf(in).Key()
+		tempKey := reflect.New(tempKeyType).Elem()
+		err = ds.unmarshal(tempKey)
+		if err != nil {
+			return
+		}
+
+		tempElemType := reflect.TypeOf(in).Elem()
+		tempElem := reflect.New(tempElemType).Elem()
+		err = ds.unmarshal(tempElem)
+		if err != nil {
+			return
+		}
+
+		dstv.SetMapIndex(tempKey, tempElem)
+	}
+
+	return
+}
+
 // decodeStruct decodes a byte array representing a SCALE tuple.  The order of data is
 // determined by the source tuple in rust, or the struct field order in a go struct
 func (ds *decodeState) decodeStruct(dstv reflect.Value) (err error) {

pkg/scale/decode_test.go

@@ -132,6 +132,40 @@ func Test_decodeState_decodeSlice(t *testing.T) {
 	}
 }
 
+func Test_decodeState_decodeMap(t *testing.T) {
+	mapTests = tests{
+		{
+			name: "testMap1",
+			in:   map[int8][]byte{2: []byte("some string")},
+			want: []byte{4, 2, 44, 115, 111, 109, 101, 32, 115, 116, 114, 105, 110, 103},
+		},
+		{
+			name: "testMap2",
+			in: map[int8][]byte{
+				2:  []byte("some string"),
+				16: []byte("lorem ipsum"),
+			},
+			want: []byte{
+				8, 2, 44, 115, 111, 109, 101, 32, 115, 116, 114, 105, 110, 103, 16, 44, 108, 111, 114, 101, 109, 32,
+				105, 112, 115, 117, 109,
+			},
+		},
+	}
+
+	for _, tt := range mapTests {
+		t.Run(tt.name, func(t *testing.T) {
+			dst := map[int8][]byte{}
+			if err := Unmarshal(tt.want, &dst); (err != nil) != tt.wantErr {
+				t.Errorf("decodeState.unmarshal() error = %v, wantErr %v", err, tt.wantErr)
+			}
+
+			if !reflect.DeepEqual(dst, tt.in) {
+				t.Errorf("decodeState.unmarshal() = %v, want %v", dst, tt.in)
+			}
+		})
+	}
+}
+
 func Test_unmarshal_optionality(t *testing.T) {
 	var ptrTests tests
 	for _, t := range append(tests{}, allTests...) {

pkg/scale/encode.go

@@ -106,6 +106,8 @@ func (es *encodeState) marshal(in interface{}) (err error) {
 			err = es.encodeArray(in)
 		case reflect.Slice:
 			err = es.encodeSlice(in)
+		case reflect.Map:
+			err = es.encodeMap(in)
 		default:
 			err = fmt.Errorf("unsupported type: %T", in)
 		}
@@ -223,6 +225,35 @@ func (es *encodeState) encodeArray(in interface{}) (err error) {
 	return
 }
 
+func (es *encodeState) encodeMap(in interface{}) (err error) {
+	v := reflect.ValueOf(in)
+	err = es.encodeLength(v.Len())
+	if err != nil {
+		return
+	}
+
+	for i := v.MapRange(); i.Next(); {
+		fmt.Println(i.Key(), "\t:", i.Value())
+
+		key := i.Key()
+		err = es.marshal(key.Interface())
+		if err != nil {
+			return
+		}
+
+		mapValue := i.Value()
+		if !mapValue.CanInterface() {
+			continue
+		}
+
+		err = es.marshal(mapValue.Interface())
+		if err != nil {
+			return
+		}
+	}
+	return
+}
+
 // encodeBigInt performs the same encoding as encodeInteger, except on a big.Int.
 // if 2^30 <= n < 2^536 write
 // [lower 2 bits of first byte = 11] [upper 6 bits of first byte = # of bytes following less 4]

pkg/scale/encode_test.go

@@ -909,9 +909,27 @@ var (
 		},
 	}
 
+	mapTests = tests{
+		{
+			name: "testMap1",
+			in:   map[int8][]byte{2: []byte("some string")},
+			want: []byte{4, 2, 44, 115, 111, 109, 101, 32, 115, 116, 114, 105, 110, 103},
+		},
+		{
+			name: "testMap2",
+			in: map[int8][]byte{
+				2:  []byte("some string"),
+				16: []byte("lorem ipsum"),
+			},
+			want: []byte{
+				8, 2, 44, 115, 111, 109, 101, 32, 115, 116, 114, 105, 110, 103, 16, 44, 108, 111, 114, 101, 109, 32,
+				105, 112, 115, 117, 109,
+			}},
+	}
+
 	allTests = newTests(
 		fixedWidthIntegerTests, variableWidthIntegerTests, stringTests,
-		boolTests, structTests, sliceTests, arrayTests,
+		boolTests, structTests, sliceTests, arrayTests, mapTests,
 		varyingDataTypeTests,
 	)
 )
@@ -1096,6 +1114,24 @@ func Test_encodeState_encodeArray(t *testing.T) {
 	}
 }
 
+func Test_encodeState_encodeMap(t *testing.T) {
+	for _, tt := range mapTests {
+		t.Run(tt.name, func(t *testing.T) {
+			buffer := bytes.NewBuffer(nil)
+			es := &encodeState{
+				Writer:                 buffer,
+				fieldScaleIndicesCache: cache,
+			}
+			if err := es.marshal(tt.in); (err != nil) != tt.wantErr {
+				t.Errorf("encodeState.encodeMap() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if !reflect.DeepEqual(buffer.Bytes(), tt.want) {
+				t.Errorf("encodeState.encodeMap() = %v, want %v", buffer.Bytes(), tt.want)
+			}
+		})
+	}
+}
+
 func Test_marshal_optionality(t *testing.T) {
 	var ptrTests tests
 	for i := range allTests {