forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-26 14:46:42 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

eth/protocols/eth: add tests for ReceiptList68

Browse source
This commit is contained in:
Felix Lange 2025-04-16 20:58:36 +02:00
parent 1fa7e70da4
commit 230e66074a
1 changed files with 100 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

123
eth/protocols/eth/receipt_test.go
View file

@ -32,49 +32,70 @@ func miniDeriveFields(r *types.Receipt, txType byte) {
r.Bloom = types.CreateBloom(r) r.Bloom = types.CreateBloom(r)
} }
func TestReceiptList69(t *testing.T) { var receiptsTestLogs1 = []*types.Log{{Address: common.Address{1}, Topics: []common.Hash{{1}}}}
logs := []*types.Log{{Address: common.Address{1}, Topics: []common.Hash{{1}}}} var receiptsTestLogs2 = []*types.Log{
encLogs, _ := rlp.EncodeToBytes(logs) {Address: common.Address{2}, Topics: []common.Hash{{21}, {22}}, Data: []byte{2, 2, 32, 32}},
{Address: common.Address{3}, Topics: []common.Hash{{31}, {32}}, Data: []byte{3, 3, 32, 32}},
}
tests := []struct { var receiptsTests = []struct {
input []types.ReceiptForStorage input []types.ReceiptForStorage
txs []*types.Transaction txs []*types.Transaction
output []Receipt root common.Hash
}{ }{
{ {
input: []types.ReceiptForStorage{{CumulativeGasUsed: 123, Status: 1, Logs: nil}}, input: []types.ReceiptForStorage{{CumulativeGasUsed: 555, Status: 1, Logs: nil}},
txs: []*types.Transaction{types.NewTx(&types.LegacyTx{})}, txs: []*types.Transaction{types.NewTx(&types.LegacyTx{})},
output: []Receipt{{GasUsed: 123, PostStateOrStatus: []byte{1}, Logs: rlp.EmptyList}},
}, },
{ {
input: []types.ReceiptForStorage{{CumulativeGasUsed: 123, Status: 1, Logs: nil}}, input: []types.ReceiptForStorage{{CumulativeGasUsed: 555, Status: 1, Logs: nil}},
txs: []*types.Transaction{types.NewTx(&types.DynamicFeeTx{})}, txs: []*types.Transaction{types.NewTx(&types.DynamicFeeTx{})},
output: []Receipt{{GasUsed: 123, PostStateOrStatus: []byte{1}, Logs: rlp.EmptyList, TxType: 2}},
}, },
{ {
input: []types.ReceiptForStorage{{CumulativeGasUsed: 123, Status: 1, Logs: nil}}, input: []types.ReceiptForStorage{{CumulativeGasUsed: 555, Status: 1, Logs: nil}},
txs: []*types.Transaction{types.NewTx(&types.AccessListTx{})}, txs: []*types.Transaction{types.NewTx(&types.AccessListTx{})},
output: []Receipt{{GasUsed: 123, PostStateOrStatus: []byte{1}, Logs: rlp.EmptyList, TxType: 1}},
}, },
{ {
input: []types.ReceiptForStorage{{CumulativeGasUsed: 123, Status: 1, Logs: logs}}, input: []types.ReceiptForStorage{{CumulativeGasUsed: 555, Status: 1, Logs: receiptsTestLogs1}},
txs: []*types.Transaction{types.NewTx(&types.AccessListTx{})}, txs: []*types.Transaction{types.NewTx(&types.LegacyTx{})},
output: []Receipt{{GasUsed: 123, PostStateOrStatus: []byte{1}, Logs: encLogs, TxType: 1}},
}, },
} {
input: []types.ReceiptForStorage{{CumulativeGasUsed: 555, Status: 1, Logs: receiptsTestLogs2}},
txs: []*types.Transaction{types.NewTx(&types.AccessListTx{})},
},
}
for i, test := range tests { func init() {
// encode receipts from types object. for i := range receiptsTests {
in, _ := rlp.EncodeToBytes(test.input) // derive basic fields
for j := range receiptsTests[i].input {
r := (*types.Receipt)(&receiptsTests[i].input[j])
txType := receiptsTests[i].txs[j].Type()
miniDeriveFields(r, txType)
}
// compute expected root
receipts := make(types.Receipts, len(receiptsTests[i].input))
for j, sr := range receiptsTests[i].input {
r := types.Receipt(sr)
receipts[j] = &r
}
receiptsTests[i].root = types.DeriveSha(receipts, trie.NewStackTrie(nil))
}
}
func TestReceiptList69(t *testing.T) {
for i, test := range receiptsTests {
// encode receipts from types.ReceiptForStorage object.
canonDB, _ := rlp.EncodeToBytes(test.input)
// encode block body from types object. // encode block body from types object.
blockBody := types.Body{Transactions: test.txs} blockBody := types.Body{Transactions: test.txs}
encBlockBody, _ := rlp.EncodeToBytes(blockBody) canonBody, _ := rlp.EncodeToBytes(blockBody)
// convert from storage encoding to network encoding // convert from storage encoding to network encoding
network, err := blockReceiptsToNetwork69(in, encBlockBody) network, err := blockReceiptsToNetwork69(canonDB, canonBody)
if err != nil { if err != nil {
t.Fatalf("test[%d]: blockReceiptsToNetwork error: %v", i, err) t.Fatalf("test[%d]: blockReceiptsToNetwork69 error: %v", i, err)
} }
// parse as Receipts response list from network encoding // parse as Receipts response list from network encoding
@ -82,24 +103,56 @@ func TestReceiptList69(t *testing.T) {
if err := rlp.DecodeBytes(network, &rl); err != nil { if err := rlp.DecodeBytes(network, &rl); err != nil {
t.Fatalf("test[%d]: can't decode network receipts: %v", i, err) t.Fatalf("test[%d]: can't decode network receipts: %v", i, err)
} }
storageEnc := rl.EncodeForStorage() rlStorageEnc := rl.EncodeForStorage()
if !bytes.Equal(storageEnc, in) { if !bytes.Equal(rlStorageEnc, canonDB) {
t.Fatalf("test[%d]: re-encoded receipts not equal\nhave: %x\nwant: %x", i, storageEnc, in) t.Fatalf("test[%d]: re-encoded receipts not equal\nhave: %x\nwant: %x", i, rlStorageEnc, canonDB)
} }
rlNetworkEnc, _ := rlp.EncodeToBytes(&rl)
// compute expected root hash if !bytes.Equal(rlNetworkEnc, network) {
receipts := make(types.Receipts, len(test.input)) t.Fatalf("test[%d]: re-encoded network receipt list not equal\nhave: %x\nwant: %x", i, rlNetworkEnc, network)
for i := range test.input {
r := types.Receipt(test.input[i])
miniDeriveFields(&r, test.txs[i].Type())
receipts[i] = &r
} }
expectedHash := types.DeriveSha(receipts, trie.NewStackTrie(nil))
// compute root hash from ReceiptList69 and compare. // compute root hash from ReceiptList69 and compare.
responseHash := types.DeriveSha(&rl, trie.NewStackTrie(nil)) responseHash := types.DeriveSha(&rl, trie.NewStackTrie(nil))
if responseHash != expectedHash { if responseHash != test.root {
t.Fatalf("test[%d]: wrong root hash from ReceiptList69\nhave: %v\nwant: %v", i, responseHash, expectedHash) t.Fatalf("test[%d]: wrong root hash from ReceiptList69\nhave: %v\nwant: %v", i, responseHash, test.root)
}
}
}
func TestReceiptList68(t *testing.T) {
for i, test := range receiptsTests {
// encode receipts from types.ReceiptForStorage object.
canonDB, _ := rlp.EncodeToBytes(test.input)
// encode block body from types object.
blockBody := types.Body{Transactions: test.txs}
canonBody, _ := rlp.EncodeToBytes(blockBody)
// convert from storage encoding to network encoding
network, err := blockReceiptsToNetwork68(canonDB, canonBody)
if err != nil {
t.Fatalf("test[%d]: blockReceiptsToNetwork68 error: %v", i, err)
}
// parse as Receipts response list from network encoding
var rl ReceiptList68
if err := rlp.DecodeBytes(network, &rl); err != nil {
t.Fatalf("test[%d]: can't decode network receipts: %v", i, err)
}
rlStorageEnc := rl.EncodeForStorage()
if !bytes.Equal(rlStorageEnc, canonDB) {
t.Fatalf("test[%d]: re-encoded receipts not equal\nhave: %x\nwant: %x", i, rlStorageEnc, canonDB)
}
rlNetworkEnc, _ := rlp.EncodeToBytes(&rl)
if !bytes.Equal(rlNetworkEnc, network) {
t.Fatalf("test[%d]: re-encoded network receipt list not equal\nhave: %x\nwant: %x", i, rlNetworkEnc, network)
}
// compute root hash from ReceiptList68 and compare.
responseHash := types.DeriveSha(&rl, trie.NewStackTrie(nil))
if responseHash != test.root {
t.Fatalf("test[%d]: wrong root hash from ReceiptList68\nhave: %v\nwant: %v", i, responseHash, test.root)
} }
} }
} }