rpcbinding: improve indentation for internal unwrappers

cli/smartcontract/testdata/types/rpcbindings.out

@@ -39,54 +39,54 @@ func (c *ContractReader) AAAStrings(s [][][]string) ([][][]string, error) {
 			return nil, err
 		}
 		return func (item stackitem.Item) ([][][]string, error) {
-		arr, ok := item.Value().([]stackitem.Item)
+			arr, ok := item.Value().([]stackitem.Item)
-		if !ok {
+			if !ok {
-			return nil, errors.New("not an array")
+				return nil, errors.New("not an array")
-		}
-		res := make([][][]string, len(arr))
-		for i := range res {
-			res[i], err = func (item stackitem.Item) ([][]string, error) {
-				arr, ok := item.Value().([]stackitem.Item)
-				if !ok {
-					return nil, errors.New("not an array")
-				}
-				res := make([][]string, len(arr))
-				for i := range res {
-					res[i], err = func (item stackitem.Item) ([]string, error) {
-						arr, ok := item.Value().([]stackitem.Item)
-						if !ok {
-							return nil, errors.New("not an array")
-						}
-						res := make([]string, len(arr))
-						for i := range res {
-							res[i], err = func (item stackitem.Item) (string, error) {
-								b, err := item.TryBytes()
-								if err != nil {
-									return "", err
-								}
-								if !utf8.Valid(b) {
-									return "", errors.New("not a UTF-8 string")
-								}
-								return string(b), nil
-							} (arr[i])
-							if err != nil {
-								return nil, err
-							}
-						}
-						return res, nil
-					} (arr[i])
-					if err != nil {
-						return nil, err
-					}
-				}
-				return res, nil
-			} (arr[i])
-			if err != nil {
-				return nil, err
 			}
-		}
+			res := make([][][]string, len(arr))
-		return res, nil
+			for i := range res {
-	} (item)
+				res[i], err = func (item stackitem.Item) ([][]string, error) {
+					arr, ok := item.Value().([]stackitem.Item)
+					if !ok {
+						return nil, errors.New("not an array")
+					}
+					res := make([][]string, len(arr))
+					for i := range res {
+						res[i], err = func (item stackitem.Item) ([]string, error) {
+							arr, ok := item.Value().([]stackitem.Item)
+							if !ok {
+								return nil, errors.New("not an array")
+							}
+							res := make([]string, len(arr))
+							for i := range res {
+								res[i], err = func (item stackitem.Item) (string, error) {
+									b, err := item.TryBytes()
+									if err != nil {
+										return "", err
+									}
+									if !utf8.Valid(b) {
+										return "", errors.New("not a UTF-8 string")
+									}
+									return string(b), nil
+								} (arr[i])
+								if err != nil {
+									return nil, err
+								}
+							}
+							return res, nil
+						} (arr[i])
+						if err != nil {
+							return nil, err
+						}
+					}
+					return res, nil
+				} (arr[i])
+				if err != nil {
+					return nil, err
+				}
+			}
+			return res, nil
+		} (item)
 	} (unwrap.Item(c.invoker.Call(Hash, "aAAStrings", s)))
 }
 
@@ -117,87 +117,87 @@ func (c *ContractReader) CrazyMaps(m map[*big.Int][]map[string][]util.Uint160) (
 			return nil, err
 		}
 		return func (item stackitem.Item) (map[*big.Int][]map[string][]util.Uint160, error) {
-		m, ok := item.Value().([]stackitem.MapElement)
+			m, ok := item.Value().([]stackitem.MapElement)
-		if !ok {
+			if !ok {
-			return nil, fmt.Errorf("%s is not a map", item.Type().String())
+				return nil, fmt.Errorf("%s is not a map", item.Type().String())
-		}
-		res := make(map[*big.Int][]map[string][]util.Uint160)
-		for i := range m {
-			k, err := m[i].Key.TryInteger()
-			if err != nil {
-				return nil, err
 			}
-			v, err := func (item stackitem.Item) ([]map[string][]util.Uint160, error) {
+			res := make(map[*big.Int][]map[string][]util.Uint160)
-				arr, ok := item.Value().([]stackitem.Item)
+			for i := range m {
-				if !ok {
+				k, err := m[i].Key.TryInteger()
-					return nil, errors.New("not an array")
+				if err != nil {
+					return nil, err
 				}
-				res := make([]map[string][]util.Uint160, len(arr))
+				v, err := func (item stackitem.Item) ([]map[string][]util.Uint160, error) {
-				for i := range res {
+					arr, ok := item.Value().([]stackitem.Item)
-					res[i], err = func (item stackitem.Item) (map[string][]util.Uint160, error) {
+					if !ok {
-						m, ok := item.Value().([]stackitem.MapElement)
+						return nil, errors.New("not an array")
-						if !ok {
-							return nil, fmt.Errorf("%s is not a map", item.Type().String())
-						}
-						res := make(map[string][]util.Uint160)
-						for i := range m {
-							k, err := func (item stackitem.Item) (string, error) {
-								b, err := item.TryBytes()
-								if err != nil {
-									return "", err
-								}
-								if !utf8.Valid(b) {
-									return "", errors.New("not a UTF-8 string")
-								}
-								return string(b), nil
-							} (m[i].Key)
-							if err != nil {
-								return nil, err
-							}
-							v, err := func (item stackitem.Item) ([]util.Uint160, error) {
-								arr, ok := item.Value().([]stackitem.Item)
-								if !ok {
-									return nil, errors.New("not an array")
-								}
-								res := make([]util.Uint160, len(arr))
-								for i := range res {
-									res[i], err = func (item stackitem.Item) (util.Uint160, error) {
-										b, err := item.TryBytes()
-										if err != nil {
-											return util.Uint160{}, err
-										}
-										u, err := util.Uint160DecodeBytesBE(b)
-										if err != nil {
-											return util.Uint160{}, err
-										}
-										return u, nil
-									} (arr[i])
-									if err != nil {
-										return nil, err
-									}
-								}
-								return res, nil
-							} (m[i].Value)
-							if err != nil {
-								return nil, err
-							}
-							res[k] = v
-						}
-						return res, nil
-					} (arr[i])
-					if err != nil {
-						return nil, err
 					}
+					res := make([]map[string][]util.Uint160, len(arr))
+					for i := range res {
+						res[i], err = func (item stackitem.Item) (map[string][]util.Uint160, error) {
+							m, ok := item.Value().([]stackitem.MapElement)
+							if !ok {
+								return nil, fmt.Errorf("%s is not a map", item.Type().String())
+							}
+							res := make(map[string][]util.Uint160)
+							for i := range m {
+								k, err := func (item stackitem.Item) (string, error) {
+									b, err := item.TryBytes()
+									if err != nil {
+										return "", err
+									}
+									if !utf8.Valid(b) {
+										return "", errors.New("not a UTF-8 string")
+									}
+									return string(b), nil
+								} (m[i].Key)
+								if err != nil {
+									return nil, err
+								}
+								v, err := func (item stackitem.Item) ([]util.Uint160, error) {
+									arr, ok := item.Value().([]stackitem.Item)
+									if !ok {
+										return nil, errors.New("not an array")
+									}
+									res := make([]util.Uint160, len(arr))
+									for i := range res {
+										res[i], err = func (item stackitem.Item) (util.Uint160, error) {
+											b, err := item.TryBytes()
+											if err != nil {
+												return util.Uint160{}, err
+											}
+											u, err := util.Uint160DecodeBytesBE(b)
+											if err != nil {
+												return util.Uint160{}, err
+											}
+											return u, nil
+										} (arr[i])
+										if err != nil {
+											return nil, err
+										}
+									}
+									return res, nil
+								} (m[i].Value)
+								if err != nil {
+									return nil, err
+								}
+								res[k] = v
+							}
+							return res, nil
+						} (arr[i])
+						if err != nil {
+							return nil, err
+						}
+					}
+					return res, nil
+				} (m[i].Value)
+				if err != nil {
+					return nil, err
 				}
-				return res, nil
+				res[k] = v
-			} (m[i].Value)
-			if err != nil {
-				return nil, err
 			}
-			res[k] = v
+			return res, nil
-		}
+		} (item)
-		return res, nil
-	} (item)
 	} (unwrap.Item(c.invoker.Call(Hash, "crazyMaps", m)))
 }
 
@@ -238,42 +238,42 @@ func (c *ContractReader) Maps(m map[string]string) (map[string]string, error) {
 			return nil, err
 		}
 		return func (item stackitem.Item) (map[string]string, error) {
-		m, ok := item.Value().([]stackitem.MapElement)
+			m, ok := item.Value().([]stackitem.MapElement)
-		if !ok {
+			if !ok {
-			return nil, fmt.Errorf("%s is not a map", item.Type().String())
+				return nil, fmt.Errorf("%s is not a map", item.Type().String())
-		}
-		res := make(map[string]string)
-		for i := range m {
-			k, err := func (item stackitem.Item) (string, error) {
-				b, err := item.TryBytes()
-				if err != nil {
-					return "", err
-				}
-				if !utf8.Valid(b) {
-					return "", errors.New("not a UTF-8 string")
-				}
-				return string(b), nil
-			} (m[i].Key)
-			if err != nil {
-				return nil, err
 			}
-			v, err := func (item stackitem.Item) (string, error) {
+			res := make(map[string]string)
-				b, err := item.TryBytes()
+			for i := range m {
+				k, err := func (item stackitem.Item) (string, error) {
+					b, err := item.TryBytes()
+					if err != nil {
+						return "", err
+					}
+					if !utf8.Valid(b) {
+						return "", errors.New("not a UTF-8 string")
+					}
+					return string(b), nil
+				} (m[i].Key)
 				if err != nil {
-					return "", err
+					return nil, err
 				}
-				if !utf8.Valid(b) {
+				v, err := func (item stackitem.Item) (string, error) {
-					return "", errors.New("not a UTF-8 string")
+					b, err := item.TryBytes()
+					if err != nil {
+						return "", err
+					}
+					if !utf8.Valid(b) {
+						return "", errors.New("not a UTF-8 string")
+					}
+					return string(b), nil
+				} (m[i].Value)
+				if err != nil {
+					return nil, err
 				}
-				return string(b), nil
+				res[k] = v
-			} (m[i].Value)
-			if err != nil {
-				return nil, err
 			}
-			res[k] = v
+			return res, nil
-		}
+		} (item)
-		return res, nil
-	} (item)
 	} (unwrap.Item(c.invoker.Call(Hash, "maps", m)))
 }
 

pkg/smartcontract/rpcbinding/binding.go

@@ -23,7 +23,7 @@ func (c *ContractReader) {{.Name}}({{range $index, $arg := .Arguments -}}
 		if err != nil {
 			return nil, err
 		}
-		return {{etTypeConverter .ExtendedReturn "item"}}
+		return {{addIndent (etTypeConverter .ExtendedReturn "item") "\t"}}
 	} ( {{- end -}} {{if .ItemTo -}} itemTo{{ .ItemTo }}( {{- end -}}
 			unwrap.{{.Unwrapper}}(c.invoker.Call(Hash, "{{ .NameABI }}"
 		{{- range $arg := .Arguments -}}, {{.Name}}{{end -}} )) {{- if or .ItemTo (eq .Unwrapper "Item") -}} ) {{- end}}
@@ -319,6 +319,7 @@ func Generate(cfg binding.Config) error {
 	ctr.NamedTypes = cfg.NamedTypes
 
 	var srcTemplate = template.Must(template.New("generate").Funcs(template.FuncMap{
+		"addIndent":       addIndent,
 		"etTypeConverter": etTypeConverter,
 		"etTypeToStr": func(et binding.ExtendedType) string {
 			r, _ := extendedTypeToGo(et, ctr.NamedTypes)
@@ -467,7 +468,7 @@ func etTypeConverter(et binding.ExtendedType, v string) string {
 		}
 		res := make(` + at + `, len(arr))
 		for i := range res {
-			res[i], err = ` + strings.ReplaceAll(etTypeConverter(*et.Value, "arr[i]"), "\n", "\n\t\t") + `
+			res[i], err = ` + addIndent(etTypeConverter(*et.Value, "arr[i]"), "\t\t") + `
 			if err != nil {
 				return nil, err
 			}
@@ -491,11 +492,11 @@ func etTypeConverter(et binding.ExtendedType, v string) string {
 		}
 		res := make(` + at + `)
 		for i := range m {
-			k, err := ` + strings.ReplaceAll(etTypeConverter(binding.ExtendedType{Base: et.Key}, "m[i].Key"), "\n", "\n\t\t") + `
+			k, err := ` + addIndent(etTypeConverter(binding.ExtendedType{Base: et.Key}, "m[i].Key"), "\t\t") + `
 			if err != nil {
 				return nil, err
 			}
-			v, err := ` + strings.ReplaceAll(etTypeConverter(*et.Value, "m[i].Value"), "\n", "\n\t\t") + `
+			v, err := ` + addIndent(etTypeConverter(*et.Value, "m[i].Value"), "\t\t") + `
 			if err != nil {
 				return nil, err
 			}
@@ -673,3 +674,7 @@ func toTypeName(s string) string {
 		return c
 	}, strings.ToUpper(s[0:1])+s[1:])
 }
+
+func addIndent(str string, ind string) string {
+	return strings.ReplaceAll(str, "\n", "\n"+ind)
+}