improve scale encode, event/extrinsic params add params raw

freehere107 · freehere107 · commit 0031c15c79c1 · 2024-07-17T15:02:35.000+08:00
diff --git a/event.go b/event.go
@@ -53,6 +53,7 @@ type EventRecord struct {
 	Params       []EventParam             `json:"params"`
 	Event        scaleType.MetadataEvents `json:"event"`
 	Topic        []string                 `json:"topic"`
+	ParamsRaw    string                   `json:"params_raw"`
 }
 
 func (e *EventRecord) Process() map[string]interface{} {
@@ -79,6 +80,7 @@ func (e *EventRecord) Process() map[string]interface{} {
 
 	e.Event = call.Call
 	e.Module = call.Module.Name
+	offset := e.Data.Offset
 	for index, argType := range e.Event.Args {
 		value := e.ProcessAndUpdateData(argType)
 		param := EventParam{Type: argType, Value: value}
@@ -90,6 +92,7 @@ func (e *EventRecord) Process() map[string]interface{} {
 		}
 		e.Params = append(e.Params, param)
 	}
+	e.ParamsRaw = utiles.BytesToHex(e.Data.Data[offset:e.Data.Offset])
 
 	if e.Metadata.MetadataVersion >= 5 {
 		if topic := e.ProcessAndUpdateData("Vec<Hash>"); topic != nil {
@@ -108,6 +111,7 @@ func (e *EventRecord) Process() map[string]interface{} {
 		"event_id":      e.Event.Name,
 		"params":        e.Params,
 		"topic":         e.Topic,
+		"params_raw":    e.ParamsRaw,
 	}
 
 }
diff --git a/extrinsic.go b/extrinsic.go
@@ -31,6 +31,7 @@ type ExtrinsicDecoder struct {
 	Era                 string           `json:"era"`
 	CallIndex           string           `json:"call_index"`
 	Params              []ExtrinsicParam `json:"params"`
+	ParamsRaw           string           `json:"params_raw"`
 	Metadata            *scaleType.MetadataStruct
 	SignedExtensions    []scaleType.SignedExtension `json:"signed_extensions"`
 	AdditionalCheck     []string
@@ -96,6 +97,7 @@ type GenericExtrinsic struct {
 	CallCode           string                 `json:"call_code"`
 	CallModule         string                 `json:"call_module"`
 	Params             []ExtrinsicParam       `json:"params"`
+	ParamsRaw          string                 `json:"params_raw"`
 }
 
 func (e *ExtrinsicDecoder) Process() {
@@ -181,10 +183,11 @@ func (e *ExtrinsicDecoder) Process() {
 		panic(fmt.Sprintf("Not find Extrinsic Lookup %s, please check metadata info", e.CallIndex))
 	}
 	e.Module = call.Module.Name
-
+	offset := e.Data.Offset
 	for _, arg := range call.Call.Args {
 		e.Params = append(e.Params, ExtrinsicParam{Name: arg.Name, Type: arg.Type, Value: e.ProcessAndUpdateData(arg.Type), TypeName: arg.TypeName})
 	}
+	e.ParamsRaw = utiles.BytesToHex(e.Data.Data[offset:e.Data.Offset])
 
 	if e.ContainsTransaction {
 		result.AccountId = e.Address
@@ -197,6 +200,7 @@ func (e *ExtrinsicDecoder) Process() {
 	result.CallModuleFunction = call.Call.Name
 	result.CallModule = call.Module.Name
 	result.Params = e.Params
+	result.ParamsRaw = e.ParamsRaw
 	e.Value = &result
 }
 
diff --git a/extrinsic_test.go b/extrinsic_test.go
@@ -2,7 +2,7 @@ package scalecodec_test
 
 import (
 	"fmt"
-	"io/ioutil"
+	"os"
 	"testing"
 
 	"github.com/itering/scale.go"
@@ -18,7 +18,7 @@ func TestV14ExtrinsicDecoder(t *testing.T) {
 	m := scalecodec.MetadataDecoder{}
 	m.Init(utiles.HexToBytes(kusamaV14))
 	_ = m.Process()
-	c, err := ioutil.ReadFile(fmt.Sprintf("%s.json", "network/kusama"))
+	c, err := os.ReadFile(fmt.Sprintf("%s.json", "network/kusama"))
 	if err != nil {
 		panic(err)
 	}
@@ -28,6 +28,7 @@ func TestV14ExtrinsicDecoder(t *testing.T) {
 	extrinsicRaw := "0x1d03840018c7717a3c5d2930f10eb5b0f67c191210e018bc55481bc44c1c1c7e810e945c01922c584c1c205b9747e76aad28cf2e73f729a9b3180072c47cd3abd205bb4b54f78a2627fa62a799f363fde25b5db74e5f8d8f3bde7a9a7f2ea8c95033d84e8585030800630301000400000000070088526a74080700000000070088526a74005ed0b200000000005ed0b20000000000000101000100000000010100707fd754e80e531ad411eb8b433548acbe669bf46a7e896e440feadc5ef3530800bca06501000000"
 	e.Init(scaleBytes.ScaleBytes{Data: utiles.HexToBytes(extrinsicRaw)}, &option)
 	e.Process()
+	assert.Equal(t, e.Value.(*scalecodec.GenericExtrinsic).ParamsRaw, "01000400000000070088526a74080700000000070088526a74005ed0b200000000005ed0b20000000000000101000100000000010100707fd754e80e531ad411eb8b433548acbe669bf46a7e896e440feadc5ef3530800bca06501000000")
 }
 
 func TestCallEncode(t *testing.T) {
diff --git a/source/base.go b/source/base.go
diff --git a/source/grandpa/definitions.json b/source/grandpa/definitions.json
@@ -107,7 +107,6 @@
     ],
     "type": "enum"
   },
-  "NextAuthority": "(AuthorityId, AuthorityWeight)",
   "AuthorityIndex": "u64",
   "GrandpaEquivocationProof": {
     "type_mapping": [
diff --git a/types/Call.go b/types/Call.go
@@ -33,6 +33,7 @@ func (s *Call) Process() {
 type BoxCall struct {
 	CallIndex string           `json:"call_Index"`
 	Params    []ExtrinsicParam `json:"params"`
+	CallArgs  []ExtrinsicParam `json:"call_args"`
 }
 
 func (s *Call) Encode(value interface{}) string {
@@ -51,6 +52,9 @@ func (s *Call) Encode(value interface{}) string {
 	default:
 		panic("input value is not valid boxCall")
 	}
+	if len(boxCall.CallArgs) > 0 {
+		boxCall.Params = boxCall.CallArgs
+	}
 	callIndex := utiles.TrimHex(boxCall.CallIndex)
 	raw := callIndex
 	callModule, ok := s.Metadata.CallIndex[callIndex]
diff --git a/types/Enum.go b/types/Enum.go
@@ -91,23 +91,32 @@ func (e *Enum) Encode(data interface{}) string {
 				}
 			}
 		}
-		for enumKey, value := range data.(map[string]interface{}) {
-			index := 0
-			for k, v := range e.TypeMapping.Names {
-				if v == enumKey {
-					subType := e.TypeMapping.Types[k]
-					var typeMap [][]string
-					if len(subType) > 4 && subType[0:2] == "[[" && json.Unmarshal([]byte(subType), &typeMap) == nil && len(typeMap) > 0 && len(typeMap[0]) == 2 {
-						var raw string
-						valueStruct := value.(map[string]interface{})
-						for _, st := range typeMap {
-							raw += EncodeWithOpt(st[1], valueStruct[st[0]], &ScaleDecoderOption{Spec: e.Spec, Metadata: e.Metadata})
+		switch dataValue := data.(type) {
+		case map[string]interface{}:
+			for enumKey, value := range dataValue {
+				index := 0
+				for k, v := range e.TypeMapping.Names {
+					if v == enumKey {
+						subType := e.TypeMapping.Types[k]
+						var typeMap [][]string
+						if len(subType) > 4 && subType[0:2] == "[[" && json.Unmarshal([]byte(subType), &typeMap) == nil && len(typeMap) > 0 && len(typeMap[0]) == 2 {
+							var raw string
+							valueStruct := value.(map[string]interface{})
+							for _, st := range typeMap {
+								raw += EncodeWithOpt(st[1], valueStruct[st[0]], &ScaleDecoderOption{Spec: e.Spec, Metadata: e.Metadata})
+							}
+							return utiles.U8Encode(index) + raw
 						}
-						return utiles.U8Encode(index) + raw
+						return utiles.U8Encode(index) + EncodeWithOpt(subType, value, &ScaleDecoderOption{Spec: e.Spec, Metadata: e.Metadata})
 					}
-					return utiles.U8Encode(index) + EncodeWithOpt(subType, value, &ScaleDecoderOption{Spec: e.Spec, Metadata: e.Metadata})
+					index++
+				}
+			}
+		case string:
+			for index, v := range e.TypeMapping.Names {
+				if v == dataValue {
+					return utiles.U8Encode(index)
 				}
-				index++
 			}
 		}
 	}
diff --git a/types/FixedU8.go b/types/FixedU8.go
@@ -2,6 +2,7 @@ package types
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/itering/scale.go/utiles"
 )
@@ -21,15 +22,19 @@ func (s *FixedU8) Process() {
 }
 
 func (s *FixedU8) Encode(value interface{}) string {
-	switch value.(type) {
+	switch v := value.(type) {
 	case string:
-		return utiles.TrimHex(value.(string))
+		valueStr := v
+		if strings.HasPrefix(valueStr, "0x") {
+			return utiles.TrimHex(valueStr)
+		} else {
+			return utiles.BytesToHex([]byte(valueStr))
+		}
 	case []byte:
-		return utiles.TrimHex(utiles.BytesToHex(value.([]byte)))
+		return utiles.TrimHex(utiles.BytesToHex(v))
 	default:
 		panic("type error,only support string or []byte")
 	}
-	return ""
 }
 
 func (s *FixedU8) TypeStructString() string {
diff --git a/types/base.go b/types/base.go
@@ -98,7 +98,9 @@ func (s *ScaleDecoder) Init(data scaleBytes.ScaleBytes, option *ScaleDecoderOpti
 
 func (s *ScaleDecoder) Process() {}
 
-func (s *ScaleDecoder) Encode(interface{}) string { return "" }
+func (s *ScaleDecoder) Encode(interface{}) string {
+	panic(fmt.Sprintf("not found base type %s", s.TypeName))
+}
 
 // TypeStructString Type Struct string
 func (s *ScaleDecoder) TypeStructString() string {
@@ -190,12 +192,13 @@ func Encode(typeString string, data interface{}) string {
 
 func EncodeWithOpt(typeString string, data interface{}, opt *ScaleDecoderOption) string {
 	r := RuntimeType{}
-	if typeString == "Null" {
+	if strings.EqualFold(typeString, "Null") {
 		return ""
 	}
 	if opt == nil {
 		opt = &ScaleDecoderOption{Spec: -1}
 	}
+	opt.TypeName = typeString
 	class, value, subType := r.GetCodecClass(typeString, opt.Spec)
 	if class == nil {
 		panic(fmt.Sprintf("Not found decoder class %s", typeString))
diff --git a/types/types.go b/types/types.go
@@ -41,6 +41,8 @@ func (e *Empty) Process() {
 	e.Value = "NULL"
 }
 
+func (e *Empty) Encode(interface{}) string { return "" }
+
 func (h *H160) Process() {
 	h.Value = utiles.AddHex(utiles.BytesToHex(h.NextBytes(20)))
 }
@@ -170,11 +172,7 @@ func (a *GenericAddress) Process() {
 }
 
 type Signature struct {
-	ScaleDecoder
-}
-
-func (s *Signature) Process() {
-	s.Value = utiles.BytesToHex(s.NextBytes(64))
+	H512
 }
 
 type AccountId struct {
@@ -330,7 +328,7 @@ func (e *EcdsaSignature) Process() {
 }
 
 type EthereumAddress struct {
-	ScaleDecoder
+	H160
 }
 
 func (e *EthereumAddress) Process() {
diff --git a/types/v15.go b/types/v15.go
@@ -175,8 +175,8 @@ func (m *MetadataV15Decoder) Process() {
 		}
 	}
 
-	_ = utiles.UnmarshalAny(m.ProcessAndUpdateData("OuterEnumsMetadataV15").(interface{}), &result.OuterEnums)
-	_ = utiles.UnmarshalAny(m.ProcessAndUpdateData("CustomMetadataV15").(interface{}), &result.Customer)
+	_ = utiles.UnmarshalAny(m.ProcessAndUpdateData("OuterEnumsMetadataV15"), &result.OuterEnums)
+	_ = utiles.UnmarshalAny(m.ProcessAndUpdateData("CustomMetadataV15"), &result.Customer)
 	m.Value = result
 }
 
@@ -198,11 +198,12 @@ type RuntimeApiMetadataV15 struct {
 }
 
 // Process
-// "RuntimeApiMetadataV15": {
-//    "name": "Text",
-//    "methods": "Vec<RuntimeApiMethodMetadataV15>",
-//    "docs": "Vec<Text>"
-//  }
+//
+//	"RuntimeApiMetadataV15": {
+//	   "name": "Text",
+//	   "methods": "Vec<RuntimeApiMethodMetadataV15>",
+//	   "docs": "Vec<Text>"
+//	 }
 func (m *RuntimeApiMetadataV15) Process() {
 	runtimeApiMetadata := RuntimeApiMetadata{}
 	runtimeApiMetadata.Name = m.ProcessAndUpdateData("Text").(string)
@@ -216,10 +217,11 @@ type RuntimeApiMethodParamMetadataV15 struct {
 }
 
 // Process
-// "RuntimeApiMethodParamMetadataV15": {
-//    "name": "Text",
-//    "type": "SiLookupTypeId"
-//  },
+//
+//	"RuntimeApiMethodParamMetadataV15": {
+//	   "name": "Text",
+//	   "type": "SiLookupTypeId"
+//	 },
 func (r *RuntimeApiMethodParamMetadataV15) Process() {
 	ra := RuntimeApiMethodParamMetadata{}
 	ra.Name = r.ProcessAndUpdateData("Text").(string)

Original file line number	Diff line number	Diff line change
`@@ -53,6 +53,7 @@ type EventRecord struct {`
`53`	`53`	Params []EventParam `json:"params"`
`54`	`54`	Event scaleType.MetadataEvents `json:"event"`
`55`	`55`	Topic []string `json:"topic"`
	`56`	+ ParamsRaw string `json:"params_raw"`
`56`	`57`	`}`
`57`	`58`
`58`	`59`	`func (e *EventRecord) Process() map[string]interface{} {`
`@@ -79,6 +80,7 @@ func (e *EventRecord) Process() map[string]interface{} {`
`79`	`80`
`80`	`81`	`e.Event = call.Call`
`81`	`82`	`e.Module = call.Module.Name`
	`83`	`+ offset := e.Data.Offset`
`82`	`84`	`for index, argType := range e.Event.Args {`
`83`	`85`	`value := e.ProcessAndUpdateData(argType)`
`84`	`86`	`param := EventParam{Type: argType, Value: value}`
`@@ -90,6 +92,7 @@ func (e *EventRecord) Process() map[string]interface{} {`
`90`	`92`	`}`
`91`	`93`	`e.Params = append(e.Params, param)`
`92`	`94`	`}`
	`95`	`+ e.ParamsRaw = utiles.BytesToHex(e.Data.Data[offset:e.Data.Offset])`
`93`	`96`
`94`	`97`	`if e.Metadata.MetadataVersion >= 5 {`
`95`	`98`	`if topic := e.ProcessAndUpdateData("Vec<Hash>"); topic != nil {`
`@@ -108,6 +111,7 @@ func (e *EventRecord) Process() map[string]interface{} {`
`108`	`111`	`"event_id": e.Event.Name,`
`109`	`112`	`"params": e.Params,`
`110`	`113`	`"topic": e.Topic,`
	`114`	`+ "params_raw": e.ParamsRaw,`
`111`	`115`	`}`
`112`	`116`
`113`	`117`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,23 +91,32 @@ func (e *Enum) Encode(data interface{}) string {`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`	`}`
`94`		`- for enumKey, value := range data.(map[string]interface{}) {`
`95`		`- index := 0`
`96`		`- for k, v := range e.TypeMapping.Names {`
`97`		`- if v == enumKey {`
`98`		`- subType := e.TypeMapping.Types[k]`
`99`		`- var typeMap [][]string`
`100`		`- if len(subType) > 4 && subType[0:2] == "[[" && json.Unmarshal([]byte(subType), &typeMap) == nil && len(typeMap) > 0 && len(typeMap[0]) == 2 {`
`101`		`- var raw string`
`102`		`- valueStruct := value.(map[string]interface{})`
`103`		`- for _, st := range typeMap {`
`104`		`- raw += EncodeWithOpt(st[1], valueStruct[st[0]], &ScaleDecoderOption{Spec: e.Spec, Metadata: e.Metadata})`
	`94`	`+ switch dataValue := data.(type) {`
	`95`	`+ case map[string]interface{}:`
	`96`	`+ for enumKey, value := range dataValue {`
	`97`	`+ index := 0`
	`98`	`+ for k, v := range e.TypeMapping.Names {`
	`99`	`+ if v == enumKey {`
	`100`	`+ subType := e.TypeMapping.Types[k]`
	`101`	`+ var typeMap [][]string`
	`102`	`+ if len(subType) > 4 && subType[0:2] == "[[" && json.Unmarshal([]byte(subType), &typeMap) == nil && len(typeMap) > 0 && len(typeMap[0]) == 2 {`
	`103`	`+ var raw string`
	`104`	`+ valueStruct := value.(map[string]interface{})`
	`105`	`+ for _, st := range typeMap {`
	`106`	`+ raw += EncodeWithOpt(st[1], valueStruct[st[0]], &ScaleDecoderOption{Spec: e.Spec, Metadata: e.Metadata})`
	`107`	`+ }`
	`108`	`+ return utiles.U8Encode(index) + raw`
`105`	`109`	`}`
`106`		`- return utiles.U8Encode(index) + raw`
	`110`	`+ return utiles.U8Encode(index) + EncodeWithOpt(subType, value, &ScaleDecoderOption{Spec: e.Spec, Metadata: e.Metadata})`
`107`	`111`	`}`
`108`		`- return utiles.U8Encode(index) + EncodeWithOpt(subType, value, &ScaleDecoderOption{Spec: e.Spec, Metadata: e.Metadata})`
	`112`	`+ index++`
	`113`	`+ }`
	`114`	`+ }`
	`115`	`+ case string:`
	`116`	`+ for index, v := range e.TypeMapping.Names {`
	`117`	`+ if v == dataValue {`
	`118`	`+ return utiles.U8Encode(index)`
`109`	`119`	`}`
`110`		`- index++`
`111`	`120`	`}`
`112`	`121`	`}`
`113`	`122`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,8 @@ func (e *Empty) Process() {`
`41`	`41`	`e.Value = "NULL"`
`42`	`42`	`}`
`43`	`43`
	`44`	`+func (e *Empty) Encode(interface{}) string { return "" }`
	`45`	`+`
`44`	`46`	`func (h *H160) Process() {`
`45`	`47`	`h.Value = utiles.AddHex(utiles.BytesToHex(h.NextBytes(20)))`
`46`	`48`	`}`
`@@ -170,11 +172,7 @@ func (a *GenericAddress) Process() {`
`170`	`172`	`}`
`171`	`173`
`172`	`174`	`type Signature struct {`
`173`		`- ScaleDecoder`
`174`		`-}`
`175`		`-`
`176`		`-func (s *Signature) Process() {`
`177`		`- s.Value = utiles.BytesToHex(s.NextBytes(64))`
	`175`	`+ H512`
`178`	`176`	`}`
`179`	`177`
`180`	`178`	`type AccountId struct {`
`@@ -330,7 +328,7 @@ func (e *EcdsaSignature) Process() {`
`330`	`328`	`}`
`331`	`329`
`332`	`330`	`type EthereumAddress struct {`
`333`		`- ScaleDecoder`
	`331`	`+ H160`
`334`	`332`	`}`
`335`	`333`
`336`	`334`	`func (e *EthereumAddress) Process() {`