7997657861

Committed 22 Feb 2024 12:42AM UTC coverage: 74.867%. Remained the same

Build # 7997657861

Build Type

Pull #113

github

Committed by

web-flow

Commit Message

build(deps): bump github.com/ethereum/go-ethereum in /examples

Bumps [github.com/ethereum/go-ethereum](https://github.com/ethereum/go-ethereum) from 1.13.11 to 1.13.13.
- [Release notes](https://github.com/ethereum/go-ethereum/releases)
- [Commits](https://github.com/ethereum/go-ethereum/compare/v1.13.11...v1.13.13)

---
updated-dependencies:
- dependency-name: github.com/ethereum/go-ethereum
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Pull Request Pull Request #113: build(deps): bump github.com/ethereum/go-ethereum from 1.13.11 to 1.13.13 in /examples

Run Details

1966 of 2626 relevant lines covered (74.87%)

1349.6 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

57.73

/internal/abi/copy.go

package abi

import (
        "errors"
        "fmt"
        "math/big"
        "reflect"

        "github.com/ethereum/go-ethereum/accounts/abi"
        "github.com/ethereum/go-ethereum/common"
)

var (
        errUnassignable = errors.New("unassignable")

        // src non slice/array/struct types
        srcBasicTypes = map[reflect.Type]struct{}{
                reflect.TypeOf(true):             {},
                reflect.TypeOf(uint(0)):          {},
                reflect.TypeOf(uint8(0)):         {},
                reflect.TypeOf(uint16(0)):        {},
                reflect.TypeOf(uint32(0)):        {},
                reflect.TypeOf(uint64(0)):        {},
                reflect.TypeOf(int(0)):           {},
                reflect.TypeOf(int8(0)):          {},
                reflect.TypeOf(int16(0)):         {},
                reflect.TypeOf(int32(0)):         {},
                reflect.TypeOf(int64(0)):         {},
                reflect.TypeOf([1]byte{}):        {},
                reflect.TypeOf([2]byte{}):        {},
                reflect.TypeOf([3]byte{}):        {},
                reflect.TypeOf([4]byte{}):        {},
                reflect.TypeOf([5]byte{}):        {},
                reflect.TypeOf([6]byte{}):        {},
                reflect.TypeOf([7]byte{}):        {},
                reflect.TypeOf([8]byte{}):        {},
                reflect.TypeOf([9]byte{}):        {},
                reflect.TypeOf([10]byte{}):       {},
                reflect.TypeOf([11]byte{}):       {},
                reflect.TypeOf([12]byte{}):       {},
                reflect.TypeOf([13]byte{}):       {},
                reflect.TypeOf([14]byte{}):       {},
                reflect.TypeOf([15]byte{}):       {},
                reflect.TypeOf([16]byte{}):       {},
                reflect.TypeOf([17]byte{}):       {},
                reflect.TypeOf([18]byte{}):       {},
                reflect.TypeOf([19]byte{}):       {},
                reflect.TypeOf([20]byte{}):       {},
                reflect.TypeOf([21]byte{}):       {},
                reflect.TypeOf([22]byte{}):       {},
                reflect.TypeOf([23]byte{}):       {},
                reflect.TypeOf([24]byte{}):       {},
                reflect.TypeOf([25]byte{}):       {},
                reflect.TypeOf([26]byte{}):       {},
                reflect.TypeOf([27]byte{}):       {},
                reflect.TypeOf([28]byte{}):       {},
                reflect.TypeOf([29]byte{}):       {},
                reflect.TypeOf([30]byte{}):       {},
                reflect.TypeOf([31]byte{}):       {},
                reflect.TypeOf([32]byte{}):       {},
                reflect.TypeOf(common.Address{}): {},
                reflect.TypeOf(common.Hash{}):    {},
                reflect.TypeOf(""):               {},
                reflect.TypeOf([]byte{}):         {},
                reflect.TypeOf(&big.Int{}):       {},
                reflect.TypeOf(big.Int{}):        {},
        }

        typeBig = reflect.TypeOf(&big.Int{})
)

// Copy shallow copies the value src to dst. If src is an anonymous struct or an
// array/slice of anonymous structs, the fields of the anonymous struct are
// copied to dst.
func Copy(dst, src any) error {
        // check if dst is valid
        if dst == nil {
                return fmt.Errorf("abi: decode nil")
        }

        rDst := reflect.ValueOf(dst)
        if rDst.Kind() != reflect.Pointer {
                return fmt.Errorf("abi: decode non-pointer %T", dst)
        }
        if rDst.IsNil() {
                return fmt.Errorf("abi: decode nil %T", dst)
        }

        err := rCopy(
                dereference(rDst),
                reflect.ValueOf(src),
        )
        if errors.Is(err, errUnassignable) {
                return fmt.Errorf("abi: can't assign %T to %T", src, dst)
        } else if err != nil {
                return fmt.Errorf("abi: %w", err)
        }

        return nil
}

func rCopy(dst, src reflect.Value) error {
        if _, ok := srcBasicTypes[src.Type()]; ok {
                return set(dst, reference(src))
        } else if k := src.Kind(); k == reflect.Struct {
                return setStruct(dst, src)
        } else if k == reflect.Slice {
                return setSlice(dst, src)
        } else if k == reflect.Array {
                return setArray(dst, src)
        } else {
                return fmt.Errorf("unsupported src type %T", src.Interface())
        }
}

func set(dst, src reflect.Value) error {
        if src.Kind() != reflect.Ptr && dst.Kind() == reflect.Ptr {
                src = reference(src)
        } else if src.Kind() == reflect.Pointer && dst.Kind() != reflect.Pointer {
                src = src.Elem()
        }

        st, dt := src.Type(), dst.Type()
        if !st.AssignableTo(dt) {
                if st.ConvertibleTo(dt) {
                        src = src.Convert(dt)
                } else {
                        return errUnassignable
                }
        }

        if dst.CanAddr() {
                dst.Set(src)
        } else {
                dst.Elem().Set(src.Elem())
        }
        return nil
}

func setStruct(dst, src reflect.Value) error {
        if dst.Kind() == reflect.Pointer {
                if dst.IsNil() {
                        dst.Set(reflect.New(dst.Type().Elem()))
                }
                dst = dst.Elem()
        }

        st, dt := src.Type(), dst.Type()

        // field tag mapping (tags take precedence over names)
        srcFields := make(map[string]reflect.StructField)
        for i := 0; i < src.NumField(); i++ {
                field := st.Field(i)
                srcFields[field.Name] = field
        }

        for i := 0; i < dst.NumField(); i++ {
                dstField := dt.Field(i)
                srcField, ok := srcFields[dstField.Name]
                if !ok {
                        if tag, ok := dstField.Tag.Lookup("abi"); ok {
                                name := abi.ToCamelCase(tag)
                                if srcField, ok = srcFields[name]; !ok {
                                        continue
                                }
                        } else {
                                continue
                        }
                }

                rCopy(
                        dst.FieldByName(dstField.Name),
                        src.FieldByName(srcField.Name),
                )
        }
        return nil
}

func setSlice(dst, src reflect.Value) error {
        if dst.IsNil() && dst.Kind() == reflect.Pointer {
                dst = reflect.New(dst.Type().Elem())
        }
        if dst.Kind() == reflect.Pointer {
                dst.Elem().Set(reflect.MakeSlice(dst.Elem().Type(), src.Len(), src.Len()))
        } else {
                dst.Set(reflect.MakeSlice(dst.Type(), src.Len(), src.Len()))
        }

        for i := 0; i < src.Len(); i++ {
                if dst.Kind() == reflect.Pointer {
                        rCopy(dst.Elem().Index(i), src.Index(i))
                } else {
                        rCopy(dst.Index(i), src.Index(i))
                }
        }
        return nil
}

func setArray(dst, src reflect.Value) error {
        if dst.Kind() == reflect.Pointer && dst.IsNil() {
                dst = reflect.New(dst.Type().Elem())
        }

        for i := 0; i < src.Len(); i++ {
                if dst.Kind() == reflect.Pointer {
                        rCopy(dst.Elem().Index(i), src.Index(i))
                } else {
                        rCopy(dst.Index(i), src.Index(i))
                }
        }
        return nil
}

// indirect recursively dereferences the value until it either gets the value
// or finds a big.Int
func indirect(v reflect.Value) reflect.Value {
        if v.Kind() == reflect.Pointer && v.Type() != typeBig {
                return indirect(v.Elem())
        }
        return v
}

func dereference(v reflect.Value) reflect.Value {
        for v.Kind() == reflect.Pointer && v.Elem().Kind() == reflect.Pointer {
                v = v.Elem()
        }
        return v
}

func reference(v reflect.Value) reflect.Value {
        if v.Kind() != reflect.Pointer {
                if v.CanAddr() {
                        v = v.Addr()
                } else {
                        switch vv := v.Interface().(type) {
                        case bool:
                                v = reflect.ValueOf(&vv)
                        case uint:
                                v = reflect.ValueOf(&vv)
                        case uint8:
                                v = reflect.ValueOf(&vv)
                        case uint16:
                                v = reflect.ValueOf(&vv)
                        case uint32:
                                v = reflect.ValueOf(&vv)
                        case uint64:
                                v = reflect.ValueOf(&vv)
                        case int:
                                v = reflect.ValueOf(&vv)
                        case int8:
                                v = reflect.ValueOf(&vv)
                        case int16:
                                v = reflect.ValueOf(&vv)
                        case int32:
                                v = reflect.ValueOf(&vv)
                        case int64:
                                v = reflect.ValueOf(&vv)
                        case [1]byte:
                                v = reflect.ValueOf(&vv)
                        case [2]byte:
                                v = reflect.ValueOf(&vv)
                        case [3]byte:
                                v = reflect.ValueOf(&vv)
                        case [4]byte:
                                v = reflect.ValueOf(&vv)
                        case [5]byte:
                                v = reflect.ValueOf(&vv)
                        case [6]byte:
                                v = reflect.ValueOf(&vv)
                        case [7]byte:
                                v = reflect.ValueOf(&vv)
                        case [8]byte:
                                v = reflect.ValueOf(&vv)
                        case [9]byte:
                                v = reflect.ValueOf(&vv)
                        case [10]byte:
                                v = reflect.ValueOf(&vv)
                        case [11]byte:
                                v = reflect.ValueOf(&vv)
                        case [12]byte:
                                v = reflect.ValueOf(&vv)
                        case [13]byte:
                                v = reflect.ValueOf(&vv)
                        case [14]byte:
                                v = reflect.ValueOf(&vv)
                        case [15]byte:
                                v = reflect.ValueOf(&vv)
                        case [16]byte:
                                v = reflect.ValueOf(&vv)
                        case [17]byte:
                                v = reflect.ValueOf(&vv)
                        case [18]byte:
                                v = reflect.ValueOf(&vv)
                        case [19]byte:
                                v = reflect.ValueOf(&vv)
                        case [20]byte:
                                v = reflect.ValueOf(&vv)
                        case [21]byte:
                                v = reflect.ValueOf(&vv)
                        case [22]byte:
                                v = reflect.ValueOf(&vv)
                        case [23]byte:
                                v = reflect.ValueOf(&vv)
                        case [24]byte:
                                v = reflect.ValueOf(&vv)
                        case [25]byte:
                                v = reflect.ValueOf(&vv)
                        case [26]byte:
                                v = reflect.ValueOf(&vv)
                        case [27]byte:
                                v = reflect.ValueOf(&vv)
                        case [28]byte:
                                v = reflect.ValueOf(&vv)
                        case [29]byte:
                                v = reflect.ValueOf(&vv)
                        case [30]byte:
                                v = reflect.ValueOf(&vv)
                        case [31]byte:
                                v = reflect.ValueOf(&vv)
                        case [32]byte:
                                v = reflect.ValueOf(&vv)
                        case common.Address:
                                v = reflect.ValueOf(&vv)
                        case common.Hash:
                                v = reflect.ValueOf(&vv)
                        case string:
                                v = reflect.ValueOf(&vv)
                        case []byte:
                                v = reflect.ValueOf(&vv)
                        }
                }
        }
        return v
}

1	package abi
2
3	import (
4	"errors"
5	"fmt"
6	"math/big"
7	"reflect"
8
9	"github.com/ethereum/go-ethereum/accounts/abi"
10	"github.com/ethereum/go-ethereum/common"
11	)
12
13	var (
14	errUnassignable = errors.New("unassignable")
15
16	// src non slice/array/struct types
17	srcBasicTypes = map[reflect.Type]struct{}{
18	reflect.TypeOf(true): {},
19	reflect.TypeOf(uint(0)): {},
20	reflect.TypeOf(uint8(0)): {},
21	reflect.TypeOf(uint16(0)): {},
22	reflect.TypeOf(uint32(0)): {},
23	reflect.TypeOf(uint64(0)): {},
24	reflect.TypeOf(int(0)): {},
25	reflect.TypeOf(int8(0)): {},
26	reflect.TypeOf(int16(0)): {},
27	reflect.TypeOf(int32(0)): {},
28	reflect.TypeOf(int64(0)): {},
29	reflect.TypeOf([1]byte{}): {},
30	reflect.TypeOf([2]byte{}): {},
31	reflect.TypeOf([3]byte{}): {},
32	reflect.TypeOf([4]byte{}): {},
33	reflect.TypeOf([5]byte{}): {},
34	reflect.TypeOf([6]byte{}): {},
35	reflect.TypeOf([7]byte{}): {},
36	reflect.TypeOf([8]byte{}): {},
37	reflect.TypeOf([9]byte{}): {},
38	reflect.TypeOf([10]byte{}): {},
39	reflect.TypeOf([11]byte{}): {},
40	reflect.TypeOf([12]byte{}): {},
41	reflect.TypeOf([13]byte{}): {},
42	reflect.TypeOf([14]byte{}): {},
43	reflect.TypeOf([15]byte{}): {},
44	reflect.TypeOf([16]byte{}): {},
45	reflect.TypeOf([17]byte{}): {},
46	reflect.TypeOf([18]byte{}): {},
47	reflect.TypeOf([19]byte{}): {},
48	reflect.TypeOf([20]byte{}): {},
49	reflect.TypeOf([21]byte{}): {},
50	reflect.TypeOf([22]byte{}): {},
51	reflect.TypeOf([23]byte{}): {},
52	reflect.TypeOf([24]byte{}): {},
53	reflect.TypeOf([25]byte{}): {},
54	reflect.TypeOf([26]byte{}): {},
55	reflect.TypeOf([27]byte{}): {},
56	reflect.TypeOf([28]byte{}): {},
57	reflect.TypeOf([29]byte{}): {},
58	reflect.TypeOf([30]byte{}): {},
59	reflect.TypeOf([31]byte{}): {},
60	reflect.TypeOf([32]byte{}): {},
61	reflect.TypeOf(common.Address{}): {},
62	reflect.TypeOf(common.Hash{}): {},
63	reflect.TypeOf(""): {},
64	reflect.TypeOf([]byte{}): {},
65	reflect.TypeOf(&big.Int{}): {},
66	reflect.TypeOf(big.Int{}): {},
67	}
68
69	typeBig = reflect.TypeOf(&big.Int{})
70	)
71
72	// Copy shallow copies the value src to dst. If src is an anonymous struct or an
73	// array/slice of anonymous structs, the fields of the anonymous struct are
74	// copied to dst.
75	func Copy(dst, src any) error {	41✔
76	// check if dst is valid	41✔
77	if dst == nil {	42✔
78	return fmt.Errorf("abi: decode nil")	1✔
79	}	1✔
80
81	rDst := reflect.ValueOf(dst)	40✔
82	if rDst.Kind() != reflect.Pointer {	43✔
83	return fmt.Errorf("abi: decode non-pointer %T", dst)	3✔
84	}	3✔
85	if rDst.IsNil() {	39✔
86	return fmt.Errorf("abi: decode nil %T", dst)	2✔
87	}	2✔
88
89	err := rCopy(	35✔
90	dereference(rDst),	35✔
91	reflect.ValueOf(src),	35✔
92	)	35✔
93	if errors.Is(err, errUnassignable) {	37✔
94	return fmt.Errorf("abi: can't assign %T to %T", src, dst)	2✔
95	} else if err != nil {	36✔
96	return fmt.Errorf("abi: %w", err)	1✔
97	}	1✔
98
99	return nil	32✔
100	}
101
102	func rCopy(dst, src reflect.Value) error {	125✔
103	if _, ok := srcBasicTypes[src.Type()]; ok {	205✔
104	return set(dst, reference(src))	80✔
105	} else if k := src.Kind(); k == reflect.Struct {	144✔
106	return setStruct(dst, src)	19✔
107	} else if k == reflect.Slice {	60✔
108	return setSlice(dst, src)	15✔
109	} else if k == reflect.Array {	36✔
110	return setArray(dst, src)	10✔
111	} else {	11✔
112	return fmt.Errorf("unsupported src type %T", src.Interface())	1✔
113	}	1✔
114	}
115
116	func set(dst, src reflect.Value) error {	80✔
117	if src.Kind() != reflect.Ptr && dst.Kind() == reflect.Ptr {	81✔
118	src = reference(src)	1✔
119	} else if src.Kind() == reflect.Pointer && dst.Kind() != reflect.Pointer {	128✔
120	src = src.Elem()	48✔
121	}	48✔
122
123	st, dt := src.Type(), dst.Type()	80✔
124	if !st.AssignableTo(dt) {	82✔
125	if st.ConvertibleTo(dt) {	2✔
126	src = src.Convert(dt)	×
127	} else {	2✔
128	return errUnassignable	2✔
129	}	2✔
130	}
131
132	if dst.CanAddr() {	150✔
133	dst.Set(src)	72✔
134	} else {	78✔
135	dst.Elem().Set(src.Elem())	6✔
136	}	6✔
137	return nil	78✔
138	}
139
140	func setStruct(dst, src reflect.Value) error {	19✔
141	if dst.Kind() == reflect.Pointer {	38✔
142	if dst.IsNil() {	31✔
143	dst.Set(reflect.New(dst.Type().Elem()))	12✔
144	}	12✔
145	dst = dst.Elem()	19✔
146	}
147
148	st, dt := src.Type(), dst.Type()	19✔
149		19✔
150	// field tag mapping (tags take precedence over names)	19✔
151	srcFields := make(map[string]reflect.StructField)	19✔
152	for i := 0; i < src.NumField(); i++ {	56✔
153	field := st.Field(i)	37✔
154	srcFields[field.Name] = field	37✔
155	}	37✔
156
157	for i := 0; i < dst.NumField(); i++ {	57✔
158	dstField := dt.Field(i)	38✔
159	srcField, ok := srcFields[dstField.Name]	38✔
160	if !ok {	40✔
161	if tag, ok := dstField.Tag.Lookup("abi"); ok {	3✔
162	name := abi.ToCamelCase(tag)	1✔
163	if srcField, ok = srcFields[name]; !ok {	1✔
164	continue	×
165	}
166	} else {	1✔
167	continue	1✔
168	}
169	}
170
171	rCopy(	37✔
172	dst.FieldByName(dstField.Name),	37✔
173	src.FieldByName(srcField.Name),	37✔
174	)	37✔
175	}
176	return nil	19✔
177	}
178
179	func setSlice(dst, src reflect.Value) error {	15✔
180	if dst.IsNil() && dst.Kind() == reflect.Pointer {	15✔
181	dst = reflect.New(dst.Type().Elem())	×
182	}	×
183	if dst.Kind() == reflect.Pointer {	23✔
184	dst.Elem().Set(reflect.MakeSlice(dst.Elem().Type(), src.Len(), src.Len()))	8✔
185	} else {	15✔
186	dst.Set(reflect.MakeSlice(dst.Type(), src.Len(), src.Len()))	7✔
187	}	7✔
188
189	for i := 0; i < src.Len(); i++ {	46✔
190	if dst.Kind() == reflect.Pointer {	48✔
191	rCopy(dst.Elem().Index(i), src.Index(i))	17✔
192	} else {	31✔
193	rCopy(dst.Index(i), src.Index(i))	14✔
194	}	14✔
195	}
196	return nil	15✔
197	}
198
199	func setArray(dst, src reflect.Value) error {	10✔
200	if dst.Kind() == reflect.Pointer && dst.IsNil() {	10✔
201	dst = reflect.New(dst.Type().Elem())	×
202	}	×
203
204	for i := 0; i < src.Len(); i++ {	32✔
205	if dst.Kind() == reflect.Pointer {	36✔
206	rCopy(dst.Elem().Index(i), src.Index(i))	14✔
207	} else {	22✔
208	rCopy(dst.Index(i), src.Index(i))	8✔
209	}	8✔
210	}
211	return nil	10✔
212	}
213
214	// indirect recursively dereferences the value until it either gets the value
215	// or finds a big.Int
216	func indirect(v reflect.Value) reflect.Value {	×
217	if v.Kind() == reflect.Pointer && v.Type() != typeBig {	×
218	return indirect(v.Elem())	×
219	}	×
220	return v	×
221	}
222
223	func dereference(v reflect.Value) reflect.Value {	35✔
224	for v.Kind() == reflect.Pointer && v.Elem().Kind() == reflect.Pointer {	41✔
225	v = v.Elem()	6✔
226	}	6✔
227	return v	35✔
228	}
229
230	func reference(v reflect.Value) reflect.Value {	81✔
231	if v.Kind() != reflect.Pointer {	138✔
232	if v.CanAddr() {	85✔
233	v = v.Addr()	28✔
234	} else {	57✔
235	switch vv := v.Interface().(type) {	29✔
236	case bool:	4✔
237	v = reflect.ValueOf(&vv)	4✔
238	case uint:	2✔
239	v = reflect.ValueOf(&vv)	2✔
240	case uint8:	×
241	v = reflect.ValueOf(&vv)	×
242	case uint16:	×
243	v = reflect.ValueOf(&vv)	×
244	case uint32:	×
245	v = reflect.ValueOf(&vv)	×
246	case uint64:	1✔
247	v = reflect.ValueOf(&vv)	1✔
248	case int:	×
249	v = reflect.ValueOf(&vv)	×
250	case int8:	×
251	v = reflect.ValueOf(&vv)	×
252	case int16:	×
253	v = reflect.ValueOf(&vv)	×
254	case int32:	×
255	v = reflect.ValueOf(&vv)	×
256	case int64:	×
257	v = reflect.ValueOf(&vv)	×
258	case [1]byte:	×
259	v = reflect.ValueOf(&vv)	×
260	case [2]byte:	1✔
261	v = reflect.ValueOf(&vv)	1✔
262	case [3]byte:	×
263	v = reflect.ValueOf(&vv)	×
264	case [4]byte:	×
265	v = reflect.ValueOf(&vv)	×
266	case [5]byte:	×
267	v = reflect.ValueOf(&vv)	×
268	case [6]byte:	×
269	v = reflect.ValueOf(&vv)	×
270	case [7]byte:	×
271	v = reflect.ValueOf(&vv)	×
272	case [8]byte:	×
273	v = reflect.ValueOf(&vv)	×
274	case [9]byte:	×
275	v = reflect.ValueOf(&vv)	×
276	case [10]byte:	×
277	v = reflect.ValueOf(&vv)	×
278	case [11]byte:	×
279	v = reflect.ValueOf(&vv)	×
280	case [12]byte:	×
281	v = reflect.ValueOf(&vv)	×
282	case [13]byte:	×
283	v = reflect.ValueOf(&vv)	×
284	case [14]byte:	×
285	v = reflect.ValueOf(&vv)	×
286	case [15]byte:	×
287	v = reflect.ValueOf(&vv)	×
288	case [16]byte:	×
289	v = reflect.ValueOf(&vv)	×
290	case [17]byte:	×
291	v = reflect.ValueOf(&vv)	×
292	case [18]byte:	×
293	v = reflect.ValueOf(&vv)	×
294	case [19]byte:	×
295	v = reflect.ValueOf(&vv)	×
296	case [20]byte:	×
297	v = reflect.ValueOf(&vv)	×
298	case [21]byte:	×
299	v = reflect.ValueOf(&vv)	×
300	case [22]byte:	×
301	v = reflect.ValueOf(&vv)	×
302	case [23]byte:	×
303	v = reflect.ValueOf(&vv)	×
304	case [24]byte:	×
305	v = reflect.ValueOf(&vv)	×
306	case [25]byte:	×
307	v = reflect.ValueOf(&vv)	×
308	case [26]byte:	×
309	v = reflect.ValueOf(&vv)	×
310	case [27]byte:	×
311	v = reflect.ValueOf(&vv)	×
312	case [28]byte:	×
313	v = reflect.ValueOf(&vv)	×
314	case [29]byte:	×
315	v = reflect.ValueOf(&vv)	×
316	case [30]byte:	×
317	v = reflect.ValueOf(&vv)	×
318	case [31]byte:	×
319	v = reflect.ValueOf(&vv)	×
320	case [32]byte:	×
321	v = reflect.ValueOf(&vv)	×
322	case common.Address:	18✔
323	v = reflect.ValueOf(&vv)	18✔
324	case common.Hash:	×
325	v = reflect.ValueOf(&vv)	×
326	case string:	×
327	v = reflect.ValueOf(&vv)	×
328	case []byte:	1✔
329	v = reflect.ValueOf(&vv)	1✔
330	}
331	}
332	}
333	return v	81✔
334	}

lmittmann / w3 / 7997657861

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous