all: use fmt.Appendf instead of fmt.Sprintf where possible (#31301)

islishude · web-flow · commit 4ff5093df1db · 2025-03-25T14:53:02.000+01:00
diff --git a/cmd/utils/export_test.go b/cmd/utils/export_test.go
@@ -54,8 +54,8 @@ func (iter *testIterator) Next() (byte, []byte, []byte, bool) {
 	if iter.index == 42 {
 		iter.index += 1
 	}
-	return OpBatchAdd, []byte(fmt.Sprintf("key-%04d", iter.index)),
-		[]byte(fmt.Sprintf("value %d", iter.index)), true
+	return OpBatchAdd, fmt.Appendf(nil, "key-%04d", iter.index),
+		fmt.Appendf(nil, "value %d", iter.index), true
 }
 
 func (iter *testIterator) Release() {}
@@ -72,7 +72,7 @@ func testExport(t *testing.T, f string) {
 	}
 	// verify
 	for i := 0; i < 1000; i++ {
-		v, err := db.Get([]byte(fmt.Sprintf("key-%04d", i)))
+		v, err := db.Get(fmt.Appendf(nil, "key-%04d", i))
 		if (i < 5 || i == 42) && err == nil {
 			t.Fatalf("expected no element at idx %d, got '%v'", i, string(v))
 		}
@@ -85,7 +85,7 @@ func testExport(t *testing.T, f string) {
 			}
 		}
 	}
-	v, err := db.Get([]byte(fmt.Sprintf("key-%04d", 1000)))
+	v, err := db.Get(fmt.Appendf(nil, "key-%04d", 1000))
 	if err == nil {
 		t.Fatalf("expected no element at idx %d, got '%v'", 1000, string(v))
 	}
@@ -120,7 +120,7 @@ func (iter *deletionIterator) Next() (byte, []byte, []byte, bool) {
 	if iter.index == 42 {
 		iter.index += 1
 	}
-	return OpBatchDel, []byte(fmt.Sprintf("key-%04d", iter.index)), nil, true
+	return OpBatchDel, fmt.Appendf(nil, "key-%04d", iter.index), nil, true
 }
 
 func (iter *deletionIterator) Release() {}
@@ -132,14 +132,14 @@ func testDeletion(t *testing.T, f string) {
 	}
 	db := rawdb.NewMemoryDatabase()
 	for i := 0; i < 1000; i++ {
-		db.Put([]byte(fmt.Sprintf("key-%04d", i)), []byte(fmt.Sprintf("value %d", i)))
+		db.Put(fmt.Appendf(nil, "key-%04d", i), fmt.Appendf(nil, "value %d", i))
 	}
 	err = ImportLDBData(db, f, 5, make(chan struct{}))
 	if err != nil {
 		t.Fatal(err)
 	}
 	for i := 0; i < 1000; i++ {
-		v, err := db.Get([]byte(fmt.Sprintf("key-%04d", i)))
+		v, err := db.Get(fmt.Appendf(nil, "key-%04d", i))
 		if i < 5 || i == 42 {
 			if err != nil {
 				t.Fatalf("expected element at idx %d, got '%v'", i, err)
diff --git a/common/math/big.go b/common/math/big.go
@@ -72,7 +72,7 @@ func (i *HexOrDecimal256) MarshalText() ([]byte, error) {
 	if i == nil {
 		return []byte("0x0"), nil
 	}
-	return []byte(fmt.Sprintf("%#x", (*big.Int)(i))), nil
+	return fmt.Appendf(nil, "%#x", (*big.Int)(i)), nil
 }
 
 // Decimal256 unmarshals big.Int as a decimal string. When unmarshalling,
diff --git a/common/math/integer.go b/common/math/integer.go
@@ -48,7 +48,7 @@ func (i *HexOrDecimal64) UnmarshalText(input []byte) error {
 
 // MarshalText implements encoding.TextMarshaler.
 func (i HexOrDecimal64) MarshalText() ([]byte, error) {
-	return []byte(fmt.Sprintf("%#x", uint64(i))), nil
+	return fmt.Appendf(nil, "%#x", uint64(i)), nil
 }
 
 // ParseUint64 parses s as an integer in decimal or hexadecimal syntax.
diff --git a/core/state/snapshot/generate_test.go b/core/state/snapshot/generate_test.go
@@ -655,7 +655,7 @@ func testGenerateWithManyExtraAccounts(t *testing.T, scheme string) {
 		for i := 0; i < 1000; i++ {
 			acc := &types.StateAccount{Balance: uint256.NewInt(uint64(i)), Root: types.EmptyRootHash, CodeHash: types.EmptyCodeHash.Bytes()}
 			val, _ := rlp.EncodeToBytes(acc)
-			key := hashData([]byte(fmt.Sprintf("acc-%d", i)))
+			key := hashData(fmt.Appendf(nil, "acc-%d", i))
 			rawdb.WriteAccountSnapshot(helper.diskdb, key, val)
 		}
 	}
diff --git a/core/state/snapshot/iterator_test.go b/core/state/snapshot/iterator_test.go
@@ -329,27 +329,27 @@ func TestAccountIteratorTraversalValues(t *testing.T) {
 		h = make(map[common.Hash][]byte)
 	)
 	for i := byte(2); i < 0xff; i++ {
-		a[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 0, i))
+		a[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 0, i)
 		if i > 20 && i%2 == 0 {
-			b[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 1, i))
+			b[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 1, i)
 		}
 		if i%4 == 0 {
-			c[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 2, i))
+			c[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 2, i)
 		}
 		if i%7 == 0 {
-			d[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 3, i))
+			d[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 3, i)
 		}
 		if i%8 == 0 {
-			e[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 4, i))
+			e[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 4, i)
 		}
 		if i > 50 || i < 85 {
-			f[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 5, i))
+			f[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 5, i)
 		}
 		if i%64 == 0 {
-			g[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 6, i))
+			g[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 6, i)
 		}
 		if i%128 == 0 {
-			h[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 7, i))
+			h[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 7, i)
 		}
 	}
 	// Assemble a stack of snapshots from the account layers
@@ -428,27 +428,27 @@ func TestStorageIteratorTraversalValues(t *testing.T) {
 		h = make(map[common.Hash][]byte)
 	)
 	for i := byte(2); i < 0xff; i++ {
-		a[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 0, i))
+		a[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 0, i)
 		if i > 20 && i%2 == 0 {
-			b[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 1, i))
+			b[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 1, i)
 		}
 		if i%4 == 0 {
-			c[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 2, i))
+			c[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 2, i)
 		}
 		if i%7 == 0 {
-			d[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 3, i))
+			d[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 3, i)
 		}
 		if i%8 == 0 {
-			e[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 4, i))
+			e[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 4, i)
 		}
 		if i > 50 || i < 85 {
-			f[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 5, i))
+			f[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 5, i)
 		}
 		if i%64 == 0 {
-			g[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 6, i))
+			g[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 6, i)
 		}
 		if i%128 == 0 {
-			h[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 7, i))
+			h[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 7, i)
 		}
 	}
 	// Assemble a stack of snapshots from the account layers
diff --git a/p2p/nat/nat.go b/p2p/nat/nat.go
@@ -140,7 +140,7 @@ type ExtIP net.IP
 
 func (n ExtIP) ExternalIP() (net.IP, error)  { return net.IP(n), nil }
 func (n ExtIP) String() string               { return fmt.Sprintf("ExtIP(%v)", net.IP(n)) }
-func (n ExtIP) MarshalText() ([]byte, error) { return []byte(fmt.Sprintf("extip:%v", net.IP(n))), nil }
+func (n ExtIP) MarshalText() ([]byte, error) { return fmt.Appendf(nil, "extip:%v", net.IP(n)), nil }
 
 // These do nothing.
 
diff --git a/p2p/nat/natpmp.go b/p2p/nat/natpmp.go
@@ -71,7 +71,7 @@ func (n *pmp) DeleteMapping(protocol string, extport, intport int) (err error) {
 }
 
 func (n *pmp) MarshalText() ([]byte, error) {
-	return []byte(fmt.Sprintf("natpmp:%v", n.gw)), nil
+	return fmt.Appendf(nil, "natpmp:%v", n.gw), nil
 }
 
 func discoverPMP() Interface {
diff --git a/signer/core/apitypes/signed_data_internal_test.go b/signer/core/apitypes/signed_data_internal_test.go
@@ -282,7 +282,7 @@ func TestTypedDataArrayValidate(t *testing.T) {
 			messageHash, tErr := td.HashStruct(td.PrimaryType, td.Message)
 			assert.NoError(t, tErr, "failed to hash message: %v", tErr)
 
-			digest := crypto.Keccak256Hash([]byte(fmt.Sprintf("%s%s%s", "\x19\x01", string(domainSeparator), string(messageHash))))
+			digest := crypto.Keccak256Hash(fmt.Appendf(nil, "%s%s%s", "\x19\x01", string(domainSeparator), string(messageHash)))
 			assert.Equal(t, tc.Digest, digest.String(), "digest doesn't not match")
 
 			assert.NoError(t, td.validate(), "validation failed", tErr)
diff --git a/signer/core/signed_data_test.go b/signer/core/signed_data_test.go
@@ -369,7 +369,7 @@ func sign(typedData apitypes.TypedData) ([]byte, []byte, error) {
 	if err != nil {
 		return nil, nil, err
 	}
-	rawData := []byte(fmt.Sprintf("\x19\x01%s%s", string(domainSeparator), string(typedDataHash)))
+	rawData := fmt.Appendf(nil, "\x19\x01%s%s", string(domainSeparator), string(typedDataHash))
 	sighash := crypto.Keccak256(rawData)
 	return typedDataHash, sighash, nil
 }
diff --git a/triedb/pathdb/iterator_test.go b/triedb/pathdb/iterator_test.go
@@ -371,27 +371,27 @@ func TestAccountIteratorTraversalValues(t *testing.T) {
 		h = make(map[common.Hash][]byte)
 	)
 	for i := byte(2); i < 0xff; i++ {
-		a[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 0, i))
+		a[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 0, i)
 		if i > 20 && i%2 == 0 {
-			b[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 1, i))
+			b[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 1, i)
 		}
 		if i%4 == 0 {
-			c[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 2, i))
+			c[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 2, i)
 		}
 		if i%7 == 0 {
-			d[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 3, i))
+			d[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 3, i)
 		}
 		if i%8 == 0 {
-			e[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 4, i))
+			e[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 4, i)
 		}
 		if i > 50 || i < 85 {
-			f[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 5, i))
+			f[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 5, i)
 		}
 		if i%64 == 0 {
-			g[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 6, i))
+			g[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 6, i)
 		}
 		if i%128 == 0 {
-			h[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 7, i))
+			h[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 7, i)
 		}
 	}
 	// Assemble a stack of snapshots from the account layers
@@ -480,27 +480,27 @@ func TestStorageIteratorTraversalValues(t *testing.T) {
 		h = make(map[common.Hash][]byte)
 	)
 	for i := byte(2); i < 0xff; i++ {
-		a[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 0, i))
+		a[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 0, i)
 		if i > 20 && i%2 == 0 {
-			b[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 1, i))
+			b[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 1, i)
 		}
 		if i%4 == 0 {
-			c[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 2, i))
+			c[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 2, i)
 		}
 		if i%7 == 0 {
-			d[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 3, i))
+			d[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 3, i)
 		}
 		if i%8 == 0 {
-			e[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 4, i))
+			e[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 4, i)
 		}
 		if i > 50 || i < 85 {
-			f[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 5, i))
+			f[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 5, i)
 		}
 		if i%64 == 0 {
-			g[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 6, i))
+			g[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 6, i)
 		}
 		if i%128 == 0 {
-			h[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 7, i))
+			h[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 7, i)
 		}
 	}
 	// Assemble a stack of snapshots from the account layers

Original file line number	Diff line number	Diff line change
`@@ -54,8 +54,8 @@ func (iter *testIterator) Next() (byte, []byte, []byte, bool) {`
`54`	`54`	`if iter.index == 42 {`
`55`	`55`	`iter.index += 1`
`56`	`56`	`}`
`57`		`- return OpBatchAdd, []byte(fmt.Sprintf("key-%04d", iter.index)),`
`58`		`- []byte(fmt.Sprintf("value %d", iter.index)), true`
	`57`	`+ return OpBatchAdd, fmt.Appendf(nil, "key-%04d", iter.index),`
	`58`	`+ fmt.Appendf(nil, "value %d", iter.index), true`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`func (iter *testIterator) Release() {}`
`@@ -72,7 +72,7 @@ func testExport(t *testing.T, f string) {`
`72`	`72`	`}`
`73`	`73`	`// verify`
`74`	`74`	`for i := 0; i < 1000; i++ {`
`75`		`- v, err := db.Get([]byte(fmt.Sprintf("key-%04d", i)))`
	`75`	`+ v, err := db.Get(fmt.Appendf(nil, "key-%04d", i))`
`76`	`76`	`if (i < 5 \|\| i == 42) && err == nil {`
`77`	`77`	`t.Fatalf("expected no element at idx %d, got '%v'", i, string(v))`
`78`	`78`	`}`
`@@ -85,7 +85,7 @@ func testExport(t *testing.T, f string) {`
`85`	`85`	`}`
`86`	`86`	`}`
`87`	`87`	`}`
`88`		`- v, err := db.Get([]byte(fmt.Sprintf("key-%04d", 1000)))`
	`88`	`+ v, err := db.Get(fmt.Appendf(nil, "key-%04d", 1000))`
`89`	`89`	`if err == nil {`
`90`	`90`	`t.Fatalf("expected no element at idx %d, got '%v'", 1000, string(v))`
`91`	`91`	`}`
`@@ -120,7 +120,7 @@ func (iter *deletionIterator) Next() (byte, []byte, []byte, bool) {`
`120`	`120`	`if iter.index == 42 {`
`121`	`121`	`iter.index += 1`
`122`	`122`	`}`
`123`		`- return OpBatchDel, []byte(fmt.Sprintf("key-%04d", iter.index)), nil, true`
	`123`	`+ return OpBatchDel, fmt.Appendf(nil, "key-%04d", iter.index), nil, true`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`func (iter *deletionIterator) Release() {}`
`@@ -132,14 +132,14 @@ func testDeletion(t *testing.T, f string) {`
`132`	`132`	`}`
`133`	`133`	`db := rawdb.NewMemoryDatabase()`
`134`	`134`	`for i := 0; i < 1000; i++ {`
`135`		`- db.Put([]byte(fmt.Sprintf("key-%04d", i)), []byte(fmt.Sprintf("value %d", i)))`
	`135`	`+ db.Put(fmt.Appendf(nil, "key-%04d", i), fmt.Appendf(nil, "value %d", i))`
`136`	`136`	`}`
`137`	`137`	`err = ImportLDBData(db, f, 5, make(chan struct{}))`
`138`	`138`	`if err != nil {`
`139`	`139`	`t.Fatal(err)`
`140`	`140`	`}`
`141`	`141`	`for i := 0; i < 1000; i++ {`
`142`		`- v, err := db.Get([]byte(fmt.Sprintf("key-%04d", i)))`
	`142`	`+ v, err := db.Get(fmt.Appendf(nil, "key-%04d", i))`
`143`	`143`	`if i < 5 \|\| i == 42 {`
`144`	`144`	`if err != nil {`
`145`	`145`	`t.Fatalf("expected element at idx %d, got '%v'", i, err)`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ func (i *HexOrDecimal256) MarshalText() ([]byte, error) {`
`72`	`72`	`if i == nil {`
`73`	`73`	`return []byte("0x0"), nil`
`74`	`74`	`}`
`75`		`- return []byte(fmt.Sprintf("%#x", (*big.Int)(i))), nil`
	`75`	`+ return fmt.Appendf(nil, "%#x", (*big.Int)(i)), nil`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`// Decimal256 unmarshals big.Int as a decimal string. When unmarshalling,`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ func (i *HexOrDecimal64) UnmarshalText(input []byte) error {`
`48`	`48`
`49`	`49`	`// MarshalText implements encoding.TextMarshaler.`
`50`	`50`	`func (i HexOrDecimal64) MarshalText() ([]byte, error) {`
`51`		`- return []byte(fmt.Sprintf("%#x", uint64(i))), nil`
	`51`	`+ return fmt.Appendf(nil, "%#x", uint64(i)), nil`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`// ParseUint64 parses s as an integer in decimal or hexadecimal syntax.`
Original file line number	Diff line number	Diff line change
`@@ -655,7 +655,7 @@ func testGenerateWithManyExtraAccounts(t *testing.T, scheme string) {`
`655`	`655`	`for i := 0; i < 1000; i++ {`
`656`	`656`	`acc := &types.StateAccount{Balance: uint256.NewInt(uint64(i)), Root: types.EmptyRootHash, CodeHash: types.EmptyCodeHash.Bytes()}`
`657`	`657`	`val, _ := rlp.EncodeToBytes(acc)`
`658`		`- key := hashData([]byte(fmt.Sprintf("acc-%d", i)))`
	`658`	`+ key := hashData(fmt.Appendf(nil, "acc-%d", i))`
`659`	`659`	`rawdb.WriteAccountSnapshot(helper.diskdb, key, val)`
`660`	`660`	`}`
`661`	`661`	`}`
Original file line number	Diff line number	Diff line change
`@@ -329,27 +329,27 @@ func TestAccountIteratorTraversalValues(t *testing.T) {`
`329`	`329`	`h = make(map[common.Hash][]byte)`
`330`	`330`	`)`
`331`	`331`	`for i := byte(2); i < 0xff; i++ {`
`332`		`- a[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 0, i))`
	`332`	`+ a[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 0, i)`
`333`	`333`	`if i > 20 && i%2 == 0 {`
`334`		`- b[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 1, i))`
	`334`	`+ b[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 1, i)`
`335`	`335`	`}`
`336`	`336`	`if i%4 == 0 {`
`337`		`- c[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 2, i))`
	`337`	`+ c[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 2, i)`
`338`	`338`	`}`
`339`	`339`	`if i%7 == 0 {`
`340`		`- d[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 3, i))`
	`340`	`+ d[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 3, i)`
`341`	`341`	`}`
`342`	`342`	`if i%8 == 0 {`
`343`		`- e[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 4, i))`
	`343`	`+ e[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 4, i)`
`344`	`344`	`}`
`345`	`345`	`if i > 50 \|\| i < 85 {`
`346`		`- f[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 5, i))`
	`346`	`+ f[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 5, i)`
`347`	`347`	`}`
`348`	`348`	`if i%64 == 0 {`
`349`		`- g[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 6, i))`
	`349`	`+ g[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 6, i)`
`350`	`350`	`}`
`351`	`351`	`if i%128 == 0 {`
`352`		`- h[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 7, i))`
	`352`	`+ h[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 7, i)`
`353`	`353`	`}`
`354`	`354`	`}`
`355`	`355`	`// Assemble a stack of snapshots from the account layers`
`@@ -428,27 +428,27 @@ func TestStorageIteratorTraversalValues(t *testing.T) {`
`428`	`428`	`h = make(map[common.Hash][]byte)`
`429`	`429`	`)`
`430`	`430`	`for i := byte(2); i < 0xff; i++ {`
`431`		`- a[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 0, i))`
	`431`	`+ a[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 0, i)`
`432`	`432`	`if i > 20 && i%2 == 0 {`
`433`		`- b[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 1, i))`
	`433`	`+ b[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 1, i)`
`434`	`434`	`}`
`435`	`435`	`if i%4 == 0 {`
`436`		`- c[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 2, i))`
	`436`	`+ c[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 2, i)`
`437`	`437`	`}`
`438`	`438`	`if i%7 == 0 {`
`439`		`- d[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 3, i))`
	`439`	`+ d[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 3, i)`
`440`	`440`	`}`
`441`	`441`	`if i%8 == 0 {`
`442`		`- e[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 4, i))`
	`442`	`+ e[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 4, i)`
`443`	`443`	`}`
`444`	`444`	`if i > 50 \|\| i < 85 {`
`445`		`- f[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 5, i))`
	`445`	`+ f[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 5, i)`
`446`	`446`	`}`
`447`	`447`	`if i%64 == 0 {`
`448`		`- g[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 6, i))`
	`448`	`+ g[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 6, i)`
`449`	`449`	`}`
`450`	`450`	`if i%128 == 0 {`
`451`		`- h[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 7, i))`
	`451`	`+ h[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 7, i)`
`452`	`452`	`}`
`453`	`453`	`}`
`454`	`454`	`// Assemble a stack of snapshots from the account layers`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ func (n *pmp) DeleteMapping(protocol string, extport, intport int) (err error) {`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`func (n *pmp) MarshalText() ([]byte, error) {`
`74`		`- return []byte(fmt.Sprintf("natpmp:%v", n.gw)), nil`
	`74`	`+ return fmt.Appendf(nil, "natpmp:%v", n.gw), nil`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`func discoverPMP() Interface {`
Original file line number	Diff line number	Diff line change
`@@ -369,7 +369,7 @@ func sign(typedData apitypes.TypedData) ([]byte, []byte, error) {`
`369`	`369`	`if err != nil {`
`370`	`370`	`return nil, nil, err`
`371`	`371`	`}`
`372`		`- rawData := []byte(fmt.Sprintf("\x19\x01%s%s", string(domainSeparator), string(typedDataHash)))`
	`372`	`+ rawData := fmt.Appendf(nil, "\x19\x01%s%s", string(domainSeparator), string(typedDataHash))`
`373`	`373`	`sighash := crypto.Keccak256(rawData)`
`374`	`374`	`return typedDataHash, sighash, nil`
`375`	`375`	`}`
Original file line number	Diff line number	Diff line change
`@@ -371,27 +371,27 @@ func TestAccountIteratorTraversalValues(t *testing.T) {`
`371`	`371`	`h = make(map[common.Hash][]byte)`
`372`	`372`	`)`
`373`	`373`	`for i := byte(2); i < 0xff; i++ {`
`374`		`- a[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 0, i))`
	`374`	`+ a[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 0, i)`
`375`	`375`	`if i > 20 && i%2 == 0 {`
`376`		`- b[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 1, i))`
	`376`	`+ b[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 1, i)`
`377`	`377`	`}`
`378`	`378`	`if i%4 == 0 {`
`379`		`- c[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 2, i))`
	`379`	`+ c[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 2, i)`
`380`	`380`	`}`
`381`	`381`	`if i%7 == 0 {`
`382`		`- d[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 3, i))`
	`382`	`+ d[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 3, i)`
`383`	`383`	`}`
`384`	`384`	`if i%8 == 0 {`
`385`		`- e[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 4, i))`
	`385`	`+ e[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 4, i)`
`386`	`386`	`}`
`387`	`387`	`if i > 50 \|\| i < 85 {`
`388`		`- f[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 5, i))`
	`388`	`+ f[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 5, i)`
`389`	`389`	`}`
`390`	`390`	`if i%64 == 0 {`
`391`		`- g[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 6, i))`
	`391`	`+ g[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 6, i)`
`392`	`392`	`}`
`393`	`393`	`if i%128 == 0 {`
`394`		`- h[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 7, i))`
	`394`	`+ h[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 7, i)`
`395`	`395`	`}`
`396`	`396`	`}`
`397`	`397`	`// Assemble a stack of snapshots from the account layers`
`@@ -480,27 +480,27 @@ func TestStorageIteratorTraversalValues(t *testing.T) {`
`480`	`480`	`h = make(map[common.Hash][]byte)`
`481`	`481`	`)`
`482`	`482`	`for i := byte(2); i < 0xff; i++ {`
`483`		`- a[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 0, i))`
	`483`	`+ a[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 0, i)`
`484`	`484`	`if i > 20 && i%2 == 0 {`
`485`		`- b[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 1, i))`
	`485`	`+ b[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 1, i)`
`486`	`486`	`}`
`487`	`487`	`if i%4 == 0 {`
`488`		`- c[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 2, i))`
	`488`	`+ c[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 2, i)`
`489`	`489`	`}`
`490`	`490`	`if i%7 == 0 {`
`491`		`- d[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 3, i))`
	`491`	`+ d[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 3, i)`
`492`	`492`	`}`
`493`	`493`	`if i%8 == 0 {`
`494`		`- e[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 4, i))`
	`494`	`+ e[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 4, i)`
`495`	`495`	`}`
`496`	`496`	`if i > 50 \|\| i < 85 {`
`497`		`- f[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 5, i))`
	`497`	`+ f[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 5, i)`
`498`	`498`	`}`
`499`	`499`	`if i%64 == 0 {`
`500`		`- g[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 6, i))`
	`500`	`+ g[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 6, i)`
`501`	`501`	`}`
`502`	`502`	`if i%128 == 0 {`
`503`		`- h[common.Hash{i}] = []byte(fmt.Sprintf("layer-%d, key %d", 7, i))`
	`503`	`+ h[common.Hash{i}] = fmt.Appendf(nil, "layer-%d, key %d", 7, i)`
`504`	`504`	`}`
`505`	`505`	`}`
`506`	`506`	`// Assemble a stack of snapshots from the account layers`