improve the code and readme

Author: jiaohu

README.md

@@ -3,3 +3,135 @@
 
 Scale Codec written by golang, reference from [polkascan/py-scale-codec](https://github.com/polkascan/py-scale-codec).
 
+---
+
+# Interface
+define a  interface ```Compact``` that means what we want to deal with. 
+```go
+type Compact interface {
+	Encode() ([]byte, error)
+	Decode(val []byte) (int, error)
+	GetVal() interface{}
+	GetType() PrimitiveType
+	CloneNew() Compact
+}
+```
+
+---
+
+
+# Usage
+
+Here are the examples for the types that we supported.
+
++ ##### Fix Number
+use ```uint8``` as the example, we wrap the real val with a struct, the implement the interface. 
+```go
+// encode
+c := FixU8{Val: 25}
+res, err := c.Encode()
+
+
+// decode
+c := FixU8{}
+res, err := c.Decode([]byte{25})
+```
+
++ ##### Compact Number
+compact number use the compact encode way which can save the space of memory.
+```go
+// encode
+a := CompactU8{Val: uint8(25)}
+res, err := a.Encode()
+
+// decode
+a := CompactU8{}
+num, err := a.Decode([]byte{100})
+```
+
++ ##### Bool
+same as fix number, but the real value is a ```bool```.
+```go
+// encode
+a := CompactBool{Val: true}
+res, err := a.Encode()
+
+// decode
+a := CompactBool{}
+num, err := a.Decode([]byte{1})
+```
+
++ ##### String
+```go
+// encode
+s := CompactString{
+		Val: "set_hash",
+	}
+res, err := s.Encode()
+
+// decode
+s := &CompactString{}
+s.Decode(Hex2Bytes("0x207365745f686173680c6b657914776f726c64"))
+```
+
++ ##### Vec
+
+```go
+// encode
+v := &CompactVec{Val: []Compact{&FixU16{
+Val: uint16(1),
+}, &FixU16{
+Val: uint16(64),
+}}, NextList: []PrimitiveType{Uint16}}
+res, err := v.Encode()
+
+// decode
+s := &CompactVec{NextList: []PrimitiveType{Uint16}}
+_, err := s.Decode([]byte{8, 1, 0, 64, 0})
+```
+
++ ##### Array
+```go
+// encode
+v := &CompactArray{Val: []Compact{&FixU16{
+Val: uint16(1),
+}, &FixU16{
+Val: uint16(64),
+}}, NextList: []PrimitiveType{Uint16}, Len: 2}
+res, err := v.Encode()
+
+// decode
+s := &CompactArray{NextList: []PrimitiveType{Uint16}, Len: 2}
+_, err := s.Decode([]byte{1, 0, 64, 0})
+```
+
++ ##### Enum
+
+```go
+// encode
+a := CompactEnum{Val: &FixU8{Val: 42}, index: 0}
+ans, err := a.Encode()
+
+//decode
+a := CompactEnum{Val: &FixU8{}, index: 0}
+ans, err := a.Decode([]byte{0, 42})
+```
+
++ ##### Tuple
+```go
+// encode
+a := CompactTuple{Val: []Compact{
+			&CompactU32{Val: 3},
+			&CompactBool{Val: false},
+		}}
+ans, err := a.Encode()
+
+// decode
+a := CompactTuple{Val: []Compact{
+&CompactU32{},
+&CompactBool{},
+}}
+_, err := a.Decode([]byte{12, 0})
+```
+
+

array.go

@@ -8,7 +8,7 @@ import (
 type CompactArray struct {
 	Val      []Compact
 	Len      int
-	NextList []TypeString
+	NextList []PrimitiveType
 }
 
 func (c *CompactArray) Encode() ([]byte, error) {
@@ -58,12 +58,12 @@ func (c *CompactArray) GetVal() interface{} {
 	return c.Val
 }
 
-func (c *CompactArray) GetType() TypeString {
-	return ArrayName
+func (c *CompactArray) GetType() PrimitiveType {
+	return Array
 }
 
 func (c *CompactArray) getNextCompact(i int) (Compact, error) {
-	switch changeStringToType(c.NextList[0]) {
+	switch c.NextList[0] {
 	case String:
 		return &CompactString{}, nil
 	case Uint8:

array_test.go

@@ -10,17 +10,17 @@ func TestCompactArray_Encode(t *testing.T) {
 		Val: uint16(1),
 	}, &FixU16{
 		Val: uint16(64),
-	}}, NextList: []TypeString{Uint16Name}, Len: 2}
+	}}, NextList: []PrimitiveType{Uint16}, Len: 2}
 	res, err := v.Encode()
 	if err != nil {
 		t.Error(err)
 	}
 	assert.Equal(t, []byte{1, 0, 64, 0}, res)
-	assert.Equal(t, ArrayName, v.GetType())
+	assert.Equal(t, Array, v.GetType())
 }
 
 func TestCompactArray_Decode(t *testing.T) {
-	s := &CompactArray{NextList: []TypeString{Uint16Name}, Len: 2}
+	s := &CompactArray{NextList: []PrimitiveType{Uint16}, Len: 2}
 	_, err := s.Decode([]byte{1, 0, 64, 0})
 	if err != nil {
 		t.Error(err)

base.go

@@ -7,7 +7,7 @@ import (
 
 type littleEncode struct {
 	Val  interface{}
-	Type TypeString
+	Type PrimitiveType
 }
 
 var BaseIntEncode littleEncode

bool.go

@@ -24,8 +24,8 @@ func (c *CompactBool) Decode(val []byte) (int, error) {
 	return 1, nil
 }
 
-func (c *CompactBool) GetType() TypeString {
-	return BoolName
+func (c *CompactBool) GetType() PrimitiveType {
+	return Bool
 }
 
 func (c *CompactBool) CloneNew() Compact {

bool_test.go

@@ -18,7 +18,7 @@ func TestBool(t *testing.T) {
 		res2, err := b.Encode()
 		assert.Nil(t, err)
 		assert.Equal(t, []byte{0}, res2)
-		assert.Equal(t, BoolName, a.GetType())
+		assert.Equal(t, Bool, a.GetType())
 	})
 	t.Run("decode", func(t *testing.T) {
 		a := CompactBool{}

compact.go

@@ -8,13 +8,13 @@ import (
 )
 
 // Compact base interface for encoding and decoding. We redefine
-// the way to encode and decode all the types in abi file.
+// the way to encode and decode all the types that supported by us.
 // For more details see [SCALE Codec](https://docs.substrate.io/v3/advanced/scale-codec/)
 type Compact interface {
 	Encode() ([]byte, error)
 	Decode(val []byte) (int, error)
 	GetVal() interface{}
-	GetType() TypeString
+	GetType() PrimitiveType
 	CloneNew() Compact
 }
 
@@ -57,8 +57,8 @@ func (c *CompactU8) GetVal() interface{} {
 	return c.Val
 }
 
-func (c *CompactU8) GetType() TypeString {
-	return CompactUInt8Name
+func (c *CompactU8) GetType() PrimitiveType {
+	return CompactUInt8
 }
 
 func (c *CompactU8) CloneNew() Compact {
@@ -112,8 +112,8 @@ func (u *CompactU16) Decode(val []byte) (int, error) {
 	}
 }
 
-func (u *CompactU16) GetType() TypeString {
-	return CompactUint16Name
+func (u *CompactU16) GetType() PrimitiveType {
+	return CompactUint16
 }
 
 func (u *CompactU16) CloneNew() Compact {
@@ -178,8 +178,8 @@ func (u *CompactU32) Decode(val []byte) (int, error) {
 	return 0, nil
 }
 
-func (u *CompactU32) GetType() TypeString {
-	return CompactUint32Name
+func (u *CompactU32) GetType() PrimitiveType {
+	return CompactUint32
 }
 
 func (u *CompactU32) CloneNew() Compact {
@@ -278,8 +278,8 @@ func (c *CompactU64) Decode(val []byte) (int, error) {
 	return 0, nil
 }
 
-func (c *CompactU64) GetType() TypeString {
-	return CompactUint64Name
+func (c *CompactU64) GetType() PrimitiveType {
+	return CompactUint64
 }
 
 func (c *CompactU64) CloneNew() Compact {
@@ -294,8 +294,8 @@ func (c *CompactU128) GetVal() interface{} {
 	return c.Val
 }
 
-func (c *CompactU128) GetType() TypeString {
-	return CompactBigIntName
+func (c *CompactU128) GetType() PrimitiveType {
+	return CompactBigInt
 }
 
 func (c *CompactU128) Encode() ([]byte, error) {

compact_test.go

@@ -13,7 +13,7 @@ func TestCompactU8(t *testing.T) {
 		res, err := a.Encode()
 		assert.Nil(t, err)
 		assert.Equal(t, []byte{100}, res)
-		assert.Equal(t, CompactUInt8Name, a.GetType())
+		assert.Equal(t, CompactUInt8, a.GetType())
 	})
 	t.Run("encode2", func(t *testing.T) {
 		a := CompactU8{Val: 64}
@@ -43,7 +43,7 @@ func TestCompactU16(t *testing.T) {
 		res, err := a.Encode()
 		assert.Nil(t, err)
 		assert.Equal(t, []byte{100}, res)
-		assert.Equal(t, CompactUint16Name, a.GetType())
+		assert.Equal(t, CompactUint16, a.GetType())
 	})
 	t.Run("encode2", func(t *testing.T) {
 		a := CompactU16{Val: uint16(69)}
@@ -86,7 +86,7 @@ func TestCompactU32(t *testing.T) {
 		res, err := a.Encode()
 		assert.Nil(t, err)
 		assert.Equal(t, []byte{186, 201, 2, 0}, res)
-		assert.Equal(t, CompactUint32Name, a.GetType())
+		assert.Equal(t, CompactUint32, a.GetType())
 	})
 	t.Run("encode2", func(t *testing.T) {
 		a := CompactU32{Val: 25}
@@ -210,7 +210,7 @@ func TestCompactU128(t *testing.T) {
 		res, err := s.Encode()
 		assert.Nil(t, err)
 		assert.Equal(t, []byte{32}, res)
-		assert.Equal(t, CompactBigIntName, s.GetType())
+		assert.Equal(t, CompactBigInt, s.GetType())
 	})
 	t.Run("encode2", func(t *testing.T) {
 		s := CompactU128{Val: new(big.Int).SetUint64(100000000000000)}

const.go

@@ -48,39 +48,3 @@ const (
 	Tuple
 	Enum
 )
-
-type TypeString string
-
-const (
-	NoneName          TypeString = TypeString("None")
-	StringName        TypeString = "String"
-	StructName        TypeString = "struct"
-	Uint8Name         TypeString = "u8"
-	Int8Name          TypeString = "i8"
-	CompactUInt8Name  TypeString = "Compact < u8 >"
-	Uint16Name        TypeString = "u16"
-	Int16Name         TypeString = "i16"
-	CompactUint16Name TypeString = "Compact < u16 >"
-	Uint32Name        TypeString = "u32"
-	Int32Name         TypeString = "i32"
-	CompactUint32Name TypeString = "Compact < u32 >"
-	Uint64Name        TypeString = "u64"
-	Int64Name         TypeString = "i64"
-	CompactUint64Name TypeString = "Compact < u64 >"
-	BigIntName        TypeString = "i128"
-	BigUIntName       TypeString = "u128"
-	CompactBigIntName TypeString = "Compact < u128 >"
-	BoolName          TypeString = "bool"
-	VecName           TypeString = "Vec"
-	PrimitiveName     TypeString = "primitive"
-	ArrayName         TypeString = "Array"
-	TupleName         TypeString = "tuple"
-	EnumName          TypeString = "enum"
-)
-
-func (t TypeString) String() string {
-	return string(t)
-}
-
-// CustomParamsSection custom section named `params` in wasm defined by us.
-const CustomParamsSection = "params"