all: check error returned from rlp.Encode

Author: wit765

core/rawdb/accessors_chain_test.go

@@ -75,19 +75,24 @@ func TestBodyStorage(t *testing.T) {
 	body := &types.Body{Uncles: []*types.Header{{Extra: []byte("test header")}}}
 
 	hasher := sha3.NewLegacyKeccak256()
-	rlp.Encode(hasher, body)
+	if err := rlp.Encode(hasher, body); err != nil {
+		t.Fatalf("encode body err: %v", err)
+	}
 	hash := common.BytesToHash(hasher.Sum(nil))
 
 	if entry := ReadBody(db, hash, 0); entry != nil {
 		t.Fatalf("Non existent body returned: %v", entry)
 	}
+
 	// Write and verify the body in the database
 	WriteBody(db, hash, 0, body)
 	if entry := ReadBody(db, hash, 0); entry == nil {
 		t.Fatalf("Stored body not found")
-	} else if types.DeriveSha(types.Transactions(entry.Transactions), newTestHasher()) != types.DeriveSha(types.Transactions(body.Transactions), newTestHasher()) || types.CalcUncleHash(entry.Uncles) != types.CalcUncleHash(body.Uncles) {
+	} else if types.DeriveSha(types.Transactions(entry.Transactions), newTestHasher()) != types.DeriveSha(types.Transactions(body.Transactions), newTestHasher()) ||
+		types.CalcUncleHash(entry.Uncles) != types.CalcUncleHash(body.Uncles) {
 		t.Fatalf("Retrieved body mismatch: have %v, want %v", entry, body)
 	}
+
 	if entry := ReadBodyRLP(db, hash, 0); entry == nil {
 		t.Fatalf("Stored body RLP not found")
 	} else {
@@ -98,6 +103,7 @@ func TestBodyStorage(t *testing.T) {
 			t.Fatalf("Retrieved RLP body mismatch: have %v, want %v", entry, body)
 		}
 	}
+
 	// Delete the body and verify the execution
 	DeleteBody(db, hash, 0)
 	if entry := ReadBody(db, hash, 0); entry != nil {

core/types/types_test.go

@@ -44,6 +44,7 @@ func benchRLP(b *testing.B, encode bool) {
 	key, _ := crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 	to := common.HexToAddress("0x00000000000000000000000000000000deadbeef")
 	signer := NewLondonSigner(big.NewInt(1337))
+
 	for _, tc := range []struct {
 		name string
 		obj  interface{}
@@ -127,13 +128,18 @@ func benchRLP(b *testing.B, encode bool) {
 				b.ReportAllocs()
 				var null = &devnull{}
 				for b.Loop() {
-					rlp.Encode(null, tc.obj)
+					if err := rlp.Encode(null, tc.obj); err != nil {
+						b.Fatal(err)
+					}
 				}
 				b.SetBytes(int64(null.len / b.N))
 			})
 		} else {
-			data, _ := rlp.EncodeToBytes(tc.obj)
 			// Test decoding
+			data, err := rlp.EncodeToBytes(tc.obj)
+			if err != nil {
+				b.Fatal(err)
+			}
 			b.Run(tc.name, func(b *testing.B) {
 				b.ReportAllocs()
 				for b.Loop() {

p2p/enode/idscheme.go

@@ -50,12 +50,16 @@ func SignV4(r *enr.Record, privkey *ecdsa.PrivateKey) error {
 	cpy.Set(Secp256k1(privkey.PublicKey))
 
 	h := sha3.NewLegacyKeccak256()
-	rlp.Encode(h, cpy.AppendElements(nil))
+	if err := rlp.Encode(h, cpy.AppendElements(nil)); err != nil {
+		panic("can't encode: " + err.Error())
+	}
+
 	sig, err := crypto.Sign(h.Sum(nil), privkey)
 	if err != nil {
 		return err
 	}
 	sig = sig[:len(sig)-1] // remove v
+
 	if err = cpy.SetSig(V4ID{}, sig); err == nil {
 		*r = cpy
 	}
@@ -71,7 +75,10 @@ func (V4ID) Verify(r *enr.Record, sig []byte) error {
 	}
 
 	h := sha3.NewLegacyKeccak256()
-	rlp.Encode(h, r.AppendElements(nil))
+	if err := rlp.Encode(h, r.AppendElements(nil)); err != nil {
+		panic("can't encode: " + err.Error())
+	}
+
 	if !crypto.VerifySignature(entry, h.Sum(nil), sig) {
 		return enr.ErrInvalidSig
 	}

trie/node_test.go

@@ -45,7 +45,9 @@ func TestDecodeNestedNode(t *testing.T) {
 	fullNodeData[15] = data
 
 	buf := bytes.NewBuffer([]byte{})
-	rlp.Encode(buf, fullNodeData)
+	if err := rlp.Encode(buf, fullNodeData); err != nil {
+		t.Fatalf("encode full node err: %v", err)
+	}
 
 	if _, err := decodeNode([]byte("testdecode"), buf.Bytes()); err != nil {
 		t.Fatalf("decode nested full node err: %v", err)
@@ -55,8 +57,11 @@ func TestDecodeNestedNode(t *testing.T) {
 func TestDecodeFullNodeWrongSizeChild(t *testing.T) {
 	fullNodeData := newTestFullNode([]byte("wrongsizechild"))
 	fullNodeData[0] = []byte("00")
+
 	buf := bytes.NewBuffer([]byte{})
-	rlp.Encode(buf, fullNodeData)
+	if err := rlp.Encode(buf, fullNodeData); err != nil {
+		t.Fatalf("encode full node err: %v", err)
+	}
 
 	_, err := decodeNode([]byte("testdecode"), buf.Bytes())
 	if _, ok := err.(*decodeError); !ok {
@@ -75,7 +80,9 @@ func TestDecodeFullNodeWrongNestedFullNode(t *testing.T) {
 	fullNodeData[15] = data
 
 	buf := bytes.NewBuffer([]byte{})
-	rlp.Encode(buf, fullNodeData)
+	if err := rlp.Encode(buf, fullNodeData); err != nil {
+		t.Fatalf("encode full node err: %v", err)
+	}
 
 	_, err := decodeNode([]byte("testdecode"), buf.Bytes())
 	if _, ok := err.(*decodeError); !ok {
@@ -86,7 +93,9 @@ func TestDecodeFullNodeWrongNestedFullNode(t *testing.T) {
 func TestDecodeFullNode(t *testing.T) {
 	fullNodeData := newTestFullNode([]byte("decodefullnode"))
 	buf := bytes.NewBuffer([]byte{})
-	rlp.Encode(buf, fullNodeData)
+	if err := rlp.Encode(buf, fullNodeData); err != nil {
+		t.Fatalf("encode full node err: %v", err)
+	}
 
 	_, err := decodeNode([]byte("testdecode"), buf.Bytes())
 	if err != nil {