gitlab.com/yannislg/go-pulse@v0.0.0-20210722055913-a3e24e95638d/core/rawdb/accessors_chain_test.go (about) 1 // Copyright 2018 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package rawdb 18 19 import ( 20 "bytes" 21 "encoding/hex" 22 "fmt" 23 "io/ioutil" 24 "math/big" 25 "os" 26 "testing" 27 28 "github.com/ethereum/go-ethereum/common" 29 "github.com/ethereum/go-ethereum/core/types" 30 "github.com/ethereum/go-ethereum/params" 31 "github.com/ethereum/go-ethereum/rlp" 32 "golang.org/x/crypto/sha3" 33 ) 34 35 // Tests block header storage and retrieval operations. 36 func TestHeaderStorage(t *testing.T) { 37 db := NewMemoryDatabase() 38 39 // Create a test header to move around the database and make sure it's really new 40 header := &types.Header{Number: big.NewInt(42), Extra: []byte("test header")} 41 if entry := ReadHeader(db, header.Hash(), header.Number.Uint64()); entry != nil { 42 t.Fatalf("Non existent header returned: %v", entry) 43 } 44 // Write and verify the header in the database 45 WriteHeader(db, header) 46 if entry := ReadHeader(db, header.Hash(), header.Number.Uint64()); entry == nil { 47 t.Fatalf("Stored header not found") 48 } else if entry.Hash() != header.Hash() { 49 t.Fatalf("Retrieved header mismatch: have %v, want %v", entry, header) 50 } 51 if entry := ReadHeaderRLP(db, header.Hash(), header.Number.Uint64()); entry == nil { 52 t.Fatalf("Stored header RLP not found") 53 } else { 54 hasher := sha3.NewLegacyKeccak256() 55 hasher.Write(entry) 56 57 if hash := common.BytesToHash(hasher.Sum(nil)); hash != header.Hash() { 58 t.Fatalf("Retrieved RLP header mismatch: have %v, want %v", entry, header) 59 } 60 } 61 // Delete the header and verify the execution 62 DeleteHeader(db, header.Hash(), header.Number.Uint64()) 63 if entry := ReadHeader(db, header.Hash(), header.Number.Uint64()); entry != nil { 64 t.Fatalf("Deleted header returned: %v", entry) 65 } 66 } 67 68 // Tests block body storage and retrieval operations. 69 func TestBodyStorage(t *testing.T) { 70 db := NewMemoryDatabase() 71 72 // Create a test body to move around the database and make sure it's really new 73 body := &types.Body{Uncles: []*types.Header{{Extra: []byte("test header")}}} 74 75 hasher := sha3.NewLegacyKeccak256() 76 rlp.Encode(hasher, body) 77 hash := common.BytesToHash(hasher.Sum(nil)) 78 79 if entry := ReadBody(db, hash, 0); entry != nil { 80 t.Fatalf("Non existent body returned: %v", entry) 81 } 82 // Write and verify the body in the database 83 WriteBody(db, hash, 0, body) 84 if entry := ReadBody(db, hash, 0); entry == nil { 85 t.Fatalf("Stored body not found") 86 } else if types.DeriveSha(types.Transactions(entry.Transactions)) != types.DeriveSha(types.Transactions(body.Transactions)) || types.CalcUncleHash(entry.Uncles) != types.CalcUncleHash(body.Uncles) { 87 t.Fatalf("Retrieved body mismatch: have %v, want %v", entry, body) 88 } 89 if entry := ReadBodyRLP(db, hash, 0); entry == nil { 90 t.Fatalf("Stored body RLP not found") 91 } else { 92 hasher := sha3.NewLegacyKeccak256() 93 hasher.Write(entry) 94 95 if calc := common.BytesToHash(hasher.Sum(nil)); calc != hash { 96 t.Fatalf("Retrieved RLP body mismatch: have %v, want %v", entry, body) 97 } 98 } 99 // Delete the body and verify the execution 100 DeleteBody(db, hash, 0) 101 if entry := ReadBody(db, hash, 0); entry != nil { 102 t.Fatalf("Deleted body returned: %v", entry) 103 } 104 } 105 106 // Tests block storage and retrieval operations. 107 func TestBlockStorage(t *testing.T) { 108 db := NewMemoryDatabase() 109 110 // Create a test block to move around the database and make sure it's really new 111 block := types.NewBlockWithHeader(&types.Header{ 112 Extra: []byte("test block"), 113 UncleHash: types.EmptyUncleHash, 114 TxHash: types.EmptyRootHash, 115 ReceiptHash: types.EmptyRootHash, 116 }) 117 if entry := ReadBlock(db, block.Hash(), block.NumberU64()); entry != nil { 118 t.Fatalf("Non existent block returned: %v", entry) 119 } 120 if entry := ReadHeader(db, block.Hash(), block.NumberU64()); entry != nil { 121 t.Fatalf("Non existent header returned: %v", entry) 122 } 123 if entry := ReadBody(db, block.Hash(), block.NumberU64()); entry != nil { 124 t.Fatalf("Non existent body returned: %v", entry) 125 } 126 // Write and verify the block in the database 127 WriteBlock(db, block) 128 if entry := ReadBlock(db, block.Hash(), block.NumberU64()); entry == nil { 129 t.Fatalf("Stored block not found") 130 } else if entry.Hash() != block.Hash() { 131 t.Fatalf("Retrieved block mismatch: have %v, want %v", entry, block) 132 } 133 if entry := ReadHeader(db, block.Hash(), block.NumberU64()); entry == nil { 134 t.Fatalf("Stored header not found") 135 } else if entry.Hash() != block.Header().Hash() { 136 t.Fatalf("Retrieved header mismatch: have %v, want %v", entry, block.Header()) 137 } 138 if entry := ReadBody(db, block.Hash(), block.NumberU64()); entry == nil { 139 t.Fatalf("Stored body not found") 140 } else if types.DeriveSha(types.Transactions(entry.Transactions)) != types.DeriveSha(block.Transactions()) || types.CalcUncleHash(entry.Uncles) != types.CalcUncleHash(block.Uncles()) { 141 t.Fatalf("Retrieved body mismatch: have %v, want %v", entry, block.Body()) 142 } 143 // Delete the block and verify the execution 144 DeleteBlock(db, block.Hash(), block.NumberU64()) 145 if entry := ReadBlock(db, block.Hash(), block.NumberU64()); entry != nil { 146 t.Fatalf("Deleted block returned: %v", entry) 147 } 148 if entry := ReadHeader(db, block.Hash(), block.NumberU64()); entry != nil { 149 t.Fatalf("Deleted header returned: %v", entry) 150 } 151 if entry := ReadBody(db, block.Hash(), block.NumberU64()); entry != nil { 152 t.Fatalf("Deleted body returned: %v", entry) 153 } 154 } 155 156 // Tests that partial block contents don't get reassembled into full blocks. 157 func TestPartialBlockStorage(t *testing.T) { 158 db := NewMemoryDatabase() 159 block := types.NewBlockWithHeader(&types.Header{ 160 Extra: []byte("test block"), 161 UncleHash: types.EmptyUncleHash, 162 TxHash: types.EmptyRootHash, 163 ReceiptHash: types.EmptyRootHash, 164 }) 165 // Store a header and check that it's not recognized as a block 166 WriteHeader(db, block.Header()) 167 if entry := ReadBlock(db, block.Hash(), block.NumberU64()); entry != nil { 168 t.Fatalf("Non existent block returned: %v", entry) 169 } 170 DeleteHeader(db, block.Hash(), block.NumberU64()) 171 172 // Store a body and check that it's not recognized as a block 173 WriteBody(db, block.Hash(), block.NumberU64(), block.Body()) 174 if entry := ReadBlock(db, block.Hash(), block.NumberU64()); entry != nil { 175 t.Fatalf("Non existent block returned: %v", entry) 176 } 177 DeleteBody(db, block.Hash(), block.NumberU64()) 178 179 // Store a header and a body separately and check reassembly 180 WriteHeader(db, block.Header()) 181 WriteBody(db, block.Hash(), block.NumberU64(), block.Body()) 182 183 if entry := ReadBlock(db, block.Hash(), block.NumberU64()); entry == nil { 184 t.Fatalf("Stored block not found") 185 } else if entry.Hash() != block.Hash() { 186 t.Fatalf("Retrieved block mismatch: have %v, want %v", entry, block) 187 } 188 } 189 190 // Tests block total difficulty storage and retrieval operations. 191 func TestTdStorage(t *testing.T) { 192 db := NewMemoryDatabase() 193 194 // Create a test TD to move around the database and make sure it's really new 195 hash, td := common.Hash{}, big.NewInt(314) 196 if entry := ReadTd(db, hash, 0); entry != nil { 197 t.Fatalf("Non existent TD returned: %v", entry) 198 } 199 // Write and verify the TD in the database 200 WriteTd(db, hash, 0, td) 201 if entry := ReadTd(db, hash, 0); entry == nil { 202 t.Fatalf("Stored TD not found") 203 } else if entry.Cmp(td) != 0 { 204 t.Fatalf("Retrieved TD mismatch: have %v, want %v", entry, td) 205 } 206 // Delete the TD and verify the execution 207 DeleteTd(db, hash, 0) 208 if entry := ReadTd(db, hash, 0); entry != nil { 209 t.Fatalf("Deleted TD returned: %v", entry) 210 } 211 } 212 213 // Tests that canonical numbers can be mapped to hashes and retrieved. 214 func TestCanonicalMappingStorage(t *testing.T) { 215 db := NewMemoryDatabase() 216 217 // Create a test canonical number and assinged hash to move around 218 hash, number := common.Hash{0: 0xff}, uint64(314) 219 if entry := ReadCanonicalHash(db, number); entry != (common.Hash{}) { 220 t.Fatalf("Non existent canonical mapping returned: %v", entry) 221 } 222 // Write and verify the TD in the database 223 WriteCanonicalHash(db, hash, number) 224 if entry := ReadCanonicalHash(db, number); entry == (common.Hash{}) { 225 t.Fatalf("Stored canonical mapping not found") 226 } else if entry != hash { 227 t.Fatalf("Retrieved canonical mapping mismatch: have %v, want %v", entry, hash) 228 } 229 // Delete the TD and verify the execution 230 DeleteCanonicalHash(db, number) 231 if entry := ReadCanonicalHash(db, number); entry != (common.Hash{}) { 232 t.Fatalf("Deleted canonical mapping returned: %v", entry) 233 } 234 } 235 236 // Tests that head headers and head blocks can be assigned, individually. 237 func TestHeadStorage(t *testing.T) { 238 db := NewMemoryDatabase() 239 240 blockHead := types.NewBlockWithHeader(&types.Header{Extra: []byte("test block header")}) 241 blockFull := types.NewBlockWithHeader(&types.Header{Extra: []byte("test block full")}) 242 blockFast := types.NewBlockWithHeader(&types.Header{Extra: []byte("test block fast")}) 243 244 // Check that no head entries are in a pristine database 245 if entry := ReadHeadHeaderHash(db); entry != (common.Hash{}) { 246 t.Fatalf("Non head header entry returned: %v", entry) 247 } 248 if entry := ReadHeadBlockHash(db); entry != (common.Hash{}) { 249 t.Fatalf("Non head block entry returned: %v", entry) 250 } 251 if entry := ReadHeadFastBlockHash(db); entry != (common.Hash{}) { 252 t.Fatalf("Non fast head block entry returned: %v", entry) 253 } 254 // Assign separate entries for the head header and block 255 WriteHeadHeaderHash(db, blockHead.Hash()) 256 WriteHeadBlockHash(db, blockFull.Hash()) 257 WriteHeadFastBlockHash(db, blockFast.Hash()) 258 259 // Check that both heads are present, and different (i.e. two heads maintained) 260 if entry := ReadHeadHeaderHash(db); entry != blockHead.Hash() { 261 t.Fatalf("Head header hash mismatch: have %v, want %v", entry, blockHead.Hash()) 262 } 263 if entry := ReadHeadBlockHash(db); entry != blockFull.Hash() { 264 t.Fatalf("Head block hash mismatch: have %v, want %v", entry, blockFull.Hash()) 265 } 266 if entry := ReadHeadFastBlockHash(db); entry != blockFast.Hash() { 267 t.Fatalf("Fast head block hash mismatch: have %v, want %v", entry, blockFast.Hash()) 268 } 269 } 270 271 // Tests that receipts associated with a single block can be stored and retrieved. 272 func TestBlockReceiptStorage(t *testing.T) { 273 db := NewMemoryDatabase() 274 275 // Create a live block since we need metadata to reconstruct the receipt 276 tx1 := types.NewTransaction(1, common.HexToAddress("0x1"), big.NewInt(1), 1, big.NewInt(1), nil) 277 tx2 := types.NewTransaction(2, common.HexToAddress("0x2"), big.NewInt(2), 2, big.NewInt(2), nil) 278 279 body := &types.Body{Transactions: types.Transactions{tx1, tx2}} 280 281 // Create the two receipts to manage afterwards 282 receipt1 := &types.Receipt{ 283 Status: types.ReceiptStatusFailed, 284 CumulativeGasUsed: 1, 285 Logs: []*types.Log{ 286 {Address: common.BytesToAddress([]byte{0x11})}, 287 {Address: common.BytesToAddress([]byte{0x01, 0x11})}, 288 }, 289 TxHash: tx1.Hash(), 290 ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}), 291 GasUsed: 111111, 292 } 293 receipt1.Bloom = types.CreateBloom(types.Receipts{receipt1}) 294 295 receipt2 := &types.Receipt{ 296 PostState: common.Hash{2}.Bytes(), 297 CumulativeGasUsed: 2, 298 Logs: []*types.Log{ 299 {Address: common.BytesToAddress([]byte{0x22})}, 300 {Address: common.BytesToAddress([]byte{0x02, 0x22})}, 301 }, 302 TxHash: tx2.Hash(), 303 ContractAddress: common.BytesToAddress([]byte{0x02, 0x22, 0x22}), 304 GasUsed: 222222, 305 } 306 receipt2.Bloom = types.CreateBloom(types.Receipts{receipt2}) 307 receipts := []*types.Receipt{receipt1, receipt2} 308 309 // Check that no receipt entries are in a pristine database 310 hash := common.BytesToHash([]byte{0x03, 0x14}) 311 if rs := ReadReceipts(db, hash, 0, params.TestChainConfig); len(rs) != 0 { 312 t.Fatalf("non existent receipts returned: %v", rs) 313 } 314 // Insert the body that corresponds to the receipts 315 WriteBody(db, hash, 0, body) 316 317 // Insert the receipt slice into the database and check presence 318 WriteReceipts(db, hash, 0, receipts) 319 if rs := ReadReceipts(db, hash, 0, params.TestChainConfig); len(rs) == 0 { 320 t.Fatalf("no receipts returned") 321 } else { 322 if err := checkReceiptsRLP(rs, receipts); err != nil { 323 t.Fatalf(err.Error()) 324 } 325 } 326 // Delete the body and ensure that the receipts are no longer returned (metadata can't be recomputed) 327 DeleteBody(db, hash, 0) 328 if rs := ReadReceipts(db, hash, 0, params.TestChainConfig); rs != nil { 329 t.Fatalf("receipts returned when body was deleted: %v", rs) 330 } 331 // Ensure that receipts without metadata can be returned without the block body too 332 if err := checkReceiptsRLP(ReadRawReceipts(db, hash, 0), receipts); err != nil { 333 t.Fatalf(err.Error()) 334 } 335 // Sanity check that body alone without the receipt is a full purge 336 WriteBody(db, hash, 0, body) 337 338 DeleteReceipts(db, hash, 0) 339 if rs := ReadReceipts(db, hash, 0, params.TestChainConfig); len(rs) != 0 { 340 t.Fatalf("deleted receipts returned: %v", rs) 341 } 342 } 343 344 func checkReceiptsRLP(have, want types.Receipts) error { 345 if len(have) != len(want) { 346 return fmt.Errorf("receipts sizes mismatch: have %d, want %d", len(have), len(want)) 347 } 348 for i := 0; i < len(want); i++ { 349 rlpHave, err := rlp.EncodeToBytes(have[i]) 350 if err != nil { 351 return err 352 } 353 rlpWant, err := rlp.EncodeToBytes(want[i]) 354 if err != nil { 355 return err 356 } 357 if !bytes.Equal(rlpHave, rlpWant) { 358 return fmt.Errorf("receipt #%d: receipt mismatch: have %s, want %s", i, hex.EncodeToString(rlpHave), hex.EncodeToString(rlpWant)) 359 } 360 } 361 return nil 362 } 363 364 func TestAncientStorage(t *testing.T) { 365 // Freezer style fast import the chain. 366 frdir, err := ioutil.TempDir("", "") 367 if err != nil { 368 t.Fatalf("failed to create temp freezer dir: %v", err) 369 } 370 defer os.Remove(frdir) 371 372 db, err := NewDatabaseWithFreezer(NewMemoryDatabase(), frdir, "") 373 if err != nil { 374 t.Fatalf("failed to create database with ancient backend") 375 } 376 // Create a test block 377 block := types.NewBlockWithHeader(&types.Header{ 378 Number: big.NewInt(0), 379 Extra: []byte("test block"), 380 UncleHash: types.EmptyUncleHash, 381 TxHash: types.EmptyRootHash, 382 ReceiptHash: types.EmptyRootHash, 383 }) 384 // Ensure nothing non-existent will be read 385 hash, number := block.Hash(), block.NumberU64() 386 if blob := ReadHeaderRLP(db, hash, number); len(blob) > 0 { 387 t.Fatalf("non existent header returned") 388 } 389 if blob := ReadBodyRLP(db, hash, number); len(blob) > 0 { 390 t.Fatalf("non existent body returned") 391 } 392 if blob := ReadReceiptsRLP(db, hash, number); len(blob) > 0 { 393 t.Fatalf("non existent receipts returned") 394 } 395 if blob := ReadTdRLP(db, hash, number); len(blob) > 0 { 396 t.Fatalf("non existent td returned") 397 } 398 // Write and verify the header in the database 399 WriteAncientBlock(db, block, nil, big.NewInt(100)) 400 if blob := ReadHeaderRLP(db, hash, number); len(blob) == 0 { 401 t.Fatalf("no header returned") 402 } 403 if blob := ReadBodyRLP(db, hash, number); len(blob) == 0 { 404 t.Fatalf("no body returned") 405 } 406 if blob := ReadReceiptsRLP(db, hash, number); len(blob) == 0 { 407 t.Fatalf("no receipts returned") 408 } 409 if blob := ReadTdRLP(db, hash, number); len(blob) == 0 { 410 t.Fatalf("no td returned") 411 } 412 // Use a fake hash for data retrieval, nothing should be returned. 413 fakeHash := common.BytesToHash([]byte{0x01, 0x02, 0x03}) 414 if blob := ReadHeaderRLP(db, fakeHash, number); len(blob) != 0 { 415 t.Fatalf("invalid header returned") 416 } 417 if blob := ReadBodyRLP(db, fakeHash, number); len(blob) != 0 { 418 t.Fatalf("invalid body returned") 419 } 420 if blob := ReadReceiptsRLP(db, fakeHash, number); len(blob) != 0 { 421 t.Fatalf("invalid receipts returned") 422 } 423 if blob := ReadTdRLP(db, fakeHash, number); len(blob) != 0 { 424 t.Fatalf("invalid td returned") 425 } 426 }