add decoding

Author: ceyonur

common/hexutil/hexutil.go

@@ -112,6 +112,23 @@ func MustDecodeUint64(input string) uint64 {
 	return dec
 }
 
+// DecodeUint16 decodes a hex string with 0x prefix as a quantity.
+func DecodeUint16(input string) (uint16, error) {
+	raw, err := checkNumber(input)
+	if err != nil {
+		return 0, err
+	}
+	dec, err := strconv.ParseUint(raw, 16, 16)
+	if err != nil {
+		err = mapError(err)
+		if err == ErrUint64Range {
+			return 0, ErrUint16Range
+		}
+	}
+	return uint16(dec), err
+}
+
+// MustDecodeUint16 decodes a hex string with 0x prefix as a quantity.
 // EncodeUint64 encodes i as a hex string with 0x prefix.
 func EncodeUint64(i uint64) string {
 	enc := make([]byte, 2, 10)

common/hexutil/hexutil_test.go

@@ -141,6 +141,24 @@ var (
 		{input: `0xbbb`, want: uint64(0xbbb)},
 		{input: `0xffffffffffffffff`, want: uint64(0xffffffffffffffff)},
 	}
+
+	decodeUint16Tests = []unmarshalTest{
+		// invalid
+		{input: `0`, wantErr: ErrMissingPrefix},
+		{input: `0x`, wantErr: ErrEmptyNumber},
+		{input: `0x01`, wantErr: ErrLeadingZero},
+		{input: `0xfffff`, wantErr: ErrUint16Range},
+		{input: `0xz1`, wantErr: ErrSyntax},
+		// valid
+		{input: `0x0`, want: uint16(0)},
+		{input: `0x2`, want: uint16(0x2)},
+		{input: `0x2F2`, want: uint16(0x2f2)},
+		{input: `0X2F2`, want: uint16(0x2f2)},
+		{input: `0xff`, want: uint16(0xff)},
+		{input: `0x12af`, want: uint16(0x12af)},
+		{input: `0xbbb`, want: uint16(0xbbb)},
+		{input: `0xffff`, want: uint16(0xffff)},
+	}
 )
 
 func TestEncode(t *testing.T) {
@@ -218,6 +236,19 @@ func TestDecodeUint64(t *testing.T) {
 	}
 }
 
+func TestDecodeUint16(t *testing.T) {
+	for _, test := range decodeUint16Tests {
+		dec, err := DecodeUint16(test.input)
+		if !checkError(t, test.input, err, test.wantErr) {
+			continue
+		}
+		if dec != test.want.(uint16) {
+			t.Errorf("input %s: value mismatch: got %x, want %x", test.input, dec, test.want)
+			continue
+		}
+	}
+}
+
 func BenchmarkEncodeBig(b *testing.B) {
 	for _, bench := range encodeBigTests {
 		b.Run(bench.want, func(b *testing.B) {

common/hexutil/json_test.go

@@ -408,7 +408,7 @@ var unmarshalUint16Tests = []unmarshalTest{
 	{input: `"0x01"`, wantErr: wrapTypeError(ErrLeadingZero, uint16T)},
 	{input: `"0x10000"`, wantErr: wrapTypeError(ErrUint16Range, uint16T)},
 	{input: `"0xx"`, wantErr: wrapTypeError(ErrSyntax, uint16T)},
-	{input: `"0x1zz01"`, wantErr: wrapTypeError(ErrSyntax, uint16T)},
+	{input: `"0xz1"`, wantErr: wrapTypeError(ErrSyntax, uint16T)},
 
 	// valid encoding
 	{input: `""`, want: uint16(0)},