github.com/haliliceylan/bsc@v1.1.10-0.20220501224556-eb78d644ebcb/eth/api_test.go (about) 1 // Copyright 2017 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 eth 18 19 import ( 20 "bytes" 21 "fmt" 22 "math/big" 23 "reflect" 24 "sort" 25 "testing" 26 27 "github.com/davecgh/go-spew/spew" 28 "github.com/ethereum/go-ethereum/common" 29 "github.com/ethereum/go-ethereum/core/rawdb" 30 "github.com/ethereum/go-ethereum/core/state" 31 "github.com/ethereum/go-ethereum/crypto" 32 ) 33 34 var dumper = spew.ConfigState{Indent: " "} 35 36 func accountRangeTest(t *testing.T, trie *state.Trie, statedb *state.StateDB, start common.Hash, requestedNum int, expectedNum int) state.IteratorDump { 37 result := statedb.IteratorDump(true, true, false, start.Bytes(), requestedNum) 38 39 if len(result.Accounts) != expectedNum { 40 t.Fatalf("expected %d results, got %d", expectedNum, len(result.Accounts)) 41 } 42 for address := range result.Accounts { 43 if address == (common.Address{}) { 44 t.Fatalf("empty address returned") 45 } 46 if !statedb.Exist(address) { 47 t.Fatalf("account not found in state %s", address.Hex()) 48 } 49 } 50 return result 51 } 52 53 type resultHash []common.Hash 54 55 func (h resultHash) Len() int { return len(h) } 56 func (h resultHash) Swap(i, j int) { h[i], h[j] = h[j], h[i] } 57 func (h resultHash) Less(i, j int) bool { return bytes.Compare(h[i].Bytes(), h[j].Bytes()) < 0 } 58 59 func TestAccountRange(t *testing.T) { 60 t.Parallel() 61 62 var ( 63 statedb = state.NewDatabaseWithConfig(rawdb.NewMemoryDatabase(), nil) 64 state, _ = state.New(common.Hash{}, statedb, nil) 65 addrs = [AccountRangeMaxResults * 2]common.Address{} 66 m = map[common.Address]bool{} 67 ) 68 69 for i := range addrs { 70 hash := common.HexToHash(fmt.Sprintf("%x", i)) 71 addr := common.BytesToAddress(crypto.Keccak256Hash(hash.Bytes()).Bytes()) 72 addrs[i] = addr 73 state.SetBalance(addrs[i], big.NewInt(1)) 74 if _, ok := m[addr]; ok { 75 t.Fatalf("bad") 76 } else { 77 m[addr] = true 78 } 79 } 80 state.Finalise(true) 81 state.AccountsIntermediateRoot() 82 state.Commit(nil) 83 root := state.IntermediateRoot(true) 84 85 trie, err := statedb.OpenTrie(root) 86 if err != nil { 87 t.Fatal(err) 88 } 89 accountRangeTest(t, &trie, state, common.Hash{}, AccountRangeMaxResults/2, AccountRangeMaxResults/2) 90 // test pagination 91 firstResult := accountRangeTest(t, &trie, state, common.Hash{}, AccountRangeMaxResults, AccountRangeMaxResults) 92 secondResult := accountRangeTest(t, &trie, state, common.BytesToHash(firstResult.Next), AccountRangeMaxResults, AccountRangeMaxResults) 93 94 hList := make(resultHash, 0) 95 for addr1 := range firstResult.Accounts { 96 // If address is empty, then it makes no sense to compare 97 // them as they might be two different accounts. 98 if addr1 == (common.Address{}) { 99 continue 100 } 101 if _, duplicate := secondResult.Accounts[addr1]; duplicate { 102 t.Fatalf("pagination test failed: results should not overlap") 103 } 104 hList = append(hList, crypto.Keccak256Hash(addr1.Bytes())) 105 } 106 // Test to see if it's possible to recover from the middle of the previous 107 // set and get an even split between the first and second sets. 108 sort.Sort(hList) 109 middleH := hList[AccountRangeMaxResults/2] 110 middleResult := accountRangeTest(t, &trie, state, middleH, AccountRangeMaxResults, AccountRangeMaxResults) 111 missing, infirst, insecond := 0, 0, 0 112 for h := range middleResult.Accounts { 113 if _, ok := firstResult.Accounts[h]; ok { 114 infirst++ 115 } else if _, ok := secondResult.Accounts[h]; ok { 116 insecond++ 117 } else { 118 missing++ 119 } 120 } 121 if missing != 0 { 122 t.Fatalf("%d hashes in the 'middle' set were neither in the first not the second set", missing) 123 } 124 if infirst != AccountRangeMaxResults/2 { 125 t.Fatalf("Imbalance in the number of first-test results: %d != %d", infirst, AccountRangeMaxResults/2) 126 } 127 if insecond != AccountRangeMaxResults/2 { 128 t.Fatalf("Imbalance in the number of second-test results: %d != %d", insecond, AccountRangeMaxResults/2) 129 } 130 } 131 132 func TestEmptyAccountRange(t *testing.T) { 133 t.Parallel() 134 135 var ( 136 statedb = state.NewDatabase(rawdb.NewMemoryDatabase()) 137 state, _ = state.New(common.Hash{}, statedb, nil) 138 ) 139 state.Commit(nil) 140 state.IntermediateRoot(true) 141 results := state.IteratorDump(true, true, true, (common.Hash{}).Bytes(), AccountRangeMaxResults) 142 if bytes.Equal(results.Next, (common.Hash{}).Bytes()) { 143 t.Fatalf("Empty results should not return a second page") 144 } 145 if len(results.Accounts) != 0 { 146 t.Fatalf("Empty state should not return addresses: %v", results.Accounts) 147 } 148 } 149 150 func TestStorageRangeAt(t *testing.T) { 151 t.Parallel() 152 153 // Create a state where account 0x010000... has a few storage entries. 154 var ( 155 state, _ = state.New(common.Hash{}, state.NewDatabase(rawdb.NewMemoryDatabase()), nil) 156 addr = common.Address{0x01} 157 keys = []common.Hash{ // hashes of Keys of storage 158 common.HexToHash("340dd630ad21bf010b4e676dbfa9ba9a02175262d1fa356232cfde6cb5b47ef2"), 159 common.HexToHash("426fcb404ab2d5d8e61a3d918108006bbb0a9be65e92235bb10eefbdb6dcd053"), 160 common.HexToHash("48078cfed56339ea54962e72c37c7f588fc4f8e5bc173827ba75cb10a63a96a5"), 161 common.HexToHash("5723d2c3a83af9b735e3b7f21531e5623d183a9095a56604ead41f3582fdfb75"), 162 } 163 storage = storageMap{ 164 keys[0]: {Key: &common.Hash{0x02}, Value: common.Hash{0x01}}, 165 keys[1]: {Key: &common.Hash{0x04}, Value: common.Hash{0x02}}, 166 keys[2]: {Key: &common.Hash{0x01}, Value: common.Hash{0x03}}, 167 keys[3]: {Key: &common.Hash{0x03}, Value: common.Hash{0x04}}, 168 } 169 ) 170 for _, entry := range storage { 171 state.SetState(addr, *entry.Key, entry.Value) 172 } 173 174 // Check a few combinations of limit and start/end. 175 tests := []struct { 176 start []byte 177 limit int 178 want StorageRangeResult 179 }{ 180 { 181 start: []byte{}, limit: 0, 182 want: StorageRangeResult{storageMap{}, &keys[0]}, 183 }, 184 { 185 start: []byte{}, limit: 100, 186 want: StorageRangeResult{storage, nil}, 187 }, 188 { 189 start: []byte{}, limit: 2, 190 want: StorageRangeResult{storageMap{keys[0]: storage[keys[0]], keys[1]: storage[keys[1]]}, &keys[2]}, 191 }, 192 { 193 start: []byte{0x00}, limit: 4, 194 want: StorageRangeResult{storage, nil}, 195 }, 196 { 197 start: []byte{0x40}, limit: 2, 198 want: StorageRangeResult{storageMap{keys[1]: storage[keys[1]], keys[2]: storage[keys[2]]}, &keys[3]}, 199 }, 200 } 201 for _, test := range tests { 202 result, err := storageRangeAt(state.StorageTrie(addr), test.start, test.limit) 203 if err != nil { 204 t.Error(err) 205 } 206 if !reflect.DeepEqual(result, test.want) { 207 t.Fatalf("wrong result for range 0x%x.., limit %d:\ngot %s\nwant %s", 208 test.start, test.limit, dumper.Sdump(result), dumper.Sdump(&test.want)) 209 } 210 } 211 }