github.com/snowblossomcoin/go-ethereum@v1.9.25/trie/proof_test.go (about) 1 // Copyright 2015 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 trie 18 19 import ( 20 "bytes" 21 crand "crypto/rand" 22 mrand "math/rand" 23 "sort" 24 "testing" 25 "time" 26 27 "github.com/ethereum/go-ethereum/common" 28 "github.com/ethereum/go-ethereum/crypto" 29 "github.com/ethereum/go-ethereum/ethdb/memorydb" 30 ) 31 32 func init() { 33 mrand.Seed(time.Now().Unix()) 34 } 35 36 // makeProvers creates Merkle trie provers based on different implementations to 37 // test all variations. 38 func makeProvers(trie *Trie) []func(key []byte) *memorydb.Database { 39 var provers []func(key []byte) *memorydb.Database 40 41 // Create a direct trie based Merkle prover 42 provers = append(provers, func(key []byte) *memorydb.Database { 43 proof := memorydb.New() 44 trie.Prove(key, 0, proof) 45 return proof 46 }) 47 // Create a leaf iterator based Merkle prover 48 provers = append(provers, func(key []byte) *memorydb.Database { 49 proof := memorydb.New() 50 if it := NewIterator(trie.NodeIterator(key)); it.Next() && bytes.Equal(key, it.Key) { 51 for _, p := range it.Prove() { 52 proof.Put(crypto.Keccak256(p), p) 53 } 54 } 55 return proof 56 }) 57 return provers 58 } 59 60 func TestProof(t *testing.T) { 61 trie, vals := randomTrie(500) 62 root := trie.Hash() 63 for i, prover := range makeProvers(trie) { 64 for _, kv := range vals { 65 proof := prover(kv.k) 66 if proof == nil { 67 t.Fatalf("prover %d: missing key %x while constructing proof", i, kv.k) 68 } 69 val, err := VerifyProof(root, kv.k, proof) 70 if err != nil { 71 t.Fatalf("prover %d: failed to verify proof for key %x: %v\nraw proof: %x", i, kv.k, err, proof) 72 } 73 if !bytes.Equal(val, kv.v) { 74 t.Fatalf("prover %d: verified value mismatch for key %x: have %x, want %x", i, kv.k, val, kv.v) 75 } 76 } 77 } 78 } 79 80 func TestOneElementProof(t *testing.T) { 81 trie := new(Trie) 82 updateString(trie, "k", "v") 83 for i, prover := range makeProvers(trie) { 84 proof := prover([]byte("k")) 85 if proof == nil { 86 t.Fatalf("prover %d: nil proof", i) 87 } 88 if proof.Len() != 1 { 89 t.Errorf("prover %d: proof should have one element", i) 90 } 91 val, err := VerifyProof(trie.Hash(), []byte("k"), proof) 92 if err != nil { 93 t.Fatalf("prover %d: failed to verify proof: %v\nraw proof: %x", i, err, proof) 94 } 95 if !bytes.Equal(val, []byte("v")) { 96 t.Fatalf("prover %d: verified value mismatch: have %x, want 'k'", i, val) 97 } 98 } 99 } 100 101 func TestBadProof(t *testing.T) { 102 trie, vals := randomTrie(800) 103 root := trie.Hash() 104 for i, prover := range makeProvers(trie) { 105 for _, kv := range vals { 106 proof := prover(kv.k) 107 if proof == nil { 108 t.Fatalf("prover %d: nil proof", i) 109 } 110 it := proof.NewIterator(nil, nil) 111 for i, d := 0, mrand.Intn(proof.Len()); i <= d; i++ { 112 it.Next() 113 } 114 key := it.Key() 115 val, _ := proof.Get(key) 116 proof.Delete(key) 117 it.Release() 118 119 mutateByte(val) 120 proof.Put(crypto.Keccak256(val), val) 121 122 if _, err := VerifyProof(root, kv.k, proof); err == nil { 123 t.Fatalf("prover %d: expected proof to fail for key %x", i, kv.k) 124 } 125 } 126 } 127 } 128 129 // Tests that missing keys can also be proven. The test explicitly uses a single 130 // entry trie and checks for missing keys both before and after the single entry. 131 func TestMissingKeyProof(t *testing.T) { 132 trie := new(Trie) 133 updateString(trie, "k", "v") 134 135 for i, key := range []string{"a", "j", "l", "z"} { 136 proof := memorydb.New() 137 trie.Prove([]byte(key), 0, proof) 138 139 if proof.Len() != 1 { 140 t.Errorf("test %d: proof should have one element", i) 141 } 142 val, err := VerifyProof(trie.Hash(), []byte(key), proof) 143 if err != nil { 144 t.Fatalf("test %d: failed to verify proof: %v\nraw proof: %x", i, err, proof) 145 } 146 if val != nil { 147 t.Fatalf("test %d: verified value mismatch: have %x, want nil", i, val) 148 } 149 } 150 } 151 152 type entrySlice []*kv 153 154 func (p entrySlice) Len() int { return len(p) } 155 func (p entrySlice) Less(i, j int) bool { return bytes.Compare(p[i].k, p[j].k) < 0 } 156 func (p entrySlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } 157 158 // TestRangeProof tests normal range proof with both edge proofs 159 // as the existent proof. The test cases are generated randomly. 160 func TestRangeProof(t *testing.T) { 161 trie, vals := randomTrie(4096) 162 var entries entrySlice 163 for _, kv := range vals { 164 entries = append(entries, kv) 165 } 166 sort.Sort(entries) 167 for i := 0; i < 500; i++ { 168 start := mrand.Intn(len(entries)) 169 end := mrand.Intn(len(entries)-start) + start + 1 170 171 proof := memorydb.New() 172 if err := trie.Prove(entries[start].k, 0, proof); err != nil { 173 t.Fatalf("Failed to prove the first node %v", err) 174 } 175 if err := trie.Prove(entries[end-1].k, 0, proof); err != nil { 176 t.Fatalf("Failed to prove the last node %v", err) 177 } 178 var keys [][]byte 179 var vals [][]byte 180 for i := start; i < end; i++ { 181 keys = append(keys, entries[i].k) 182 vals = append(vals, entries[i].v) 183 } 184 err, _ := VerifyRangeProof(trie.Hash(), keys[0], keys[len(keys)-1], keys, vals, proof) 185 if err != nil { 186 t.Fatalf("Case %d(%d->%d) expect no error, got %v", i, start, end-1, err) 187 } 188 } 189 } 190 191 // TestRangeProof tests normal range proof with two non-existent proofs. 192 // The test cases are generated randomly. 193 func TestRangeProofWithNonExistentProof(t *testing.T) { 194 trie, vals := randomTrie(4096) 195 var entries entrySlice 196 for _, kv := range vals { 197 entries = append(entries, kv) 198 } 199 sort.Sort(entries) 200 for i := 0; i < 500; i++ { 201 start := mrand.Intn(len(entries)) 202 end := mrand.Intn(len(entries)-start) + start + 1 203 proof := memorydb.New() 204 205 // Short circuit if the decreased key is same with the previous key 206 first := decreseKey(common.CopyBytes(entries[start].k)) 207 if start != 0 && bytes.Equal(first, entries[start-1].k) { 208 continue 209 } 210 // Short circuit if the decreased key is underflow 211 if bytes.Compare(first, entries[start].k) > 0 { 212 continue 213 } 214 // Short circuit if the increased key is same with the next key 215 last := increseKey(common.CopyBytes(entries[end-1].k)) 216 if end != len(entries) && bytes.Equal(last, entries[end].k) { 217 continue 218 } 219 // Short circuit if the increased key is overflow 220 if bytes.Compare(last, entries[end-1].k) < 0 { 221 continue 222 } 223 if err := trie.Prove(first, 0, proof); err != nil { 224 t.Fatalf("Failed to prove the first node %v", err) 225 } 226 if err := trie.Prove(last, 0, proof); err != nil { 227 t.Fatalf("Failed to prove the last node %v", err) 228 } 229 var keys [][]byte 230 var vals [][]byte 231 for i := start; i < end; i++ { 232 keys = append(keys, entries[i].k) 233 vals = append(vals, entries[i].v) 234 } 235 err, _ := VerifyRangeProof(trie.Hash(), first, last, keys, vals, proof) 236 if err != nil { 237 t.Fatalf("Case %d(%d->%d) expect no error, got %v", i, start, end-1, err) 238 } 239 } 240 // Special case, two edge proofs for two edge key. 241 proof := memorydb.New() 242 first := common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000").Bytes() 243 last := common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").Bytes() 244 if err := trie.Prove(first, 0, proof); err != nil { 245 t.Fatalf("Failed to prove the first node %v", err) 246 } 247 if err := trie.Prove(last, 0, proof); err != nil { 248 t.Fatalf("Failed to prove the last node %v", err) 249 } 250 var k [][]byte 251 var v [][]byte 252 for i := 0; i < len(entries); i++ { 253 k = append(k, entries[i].k) 254 v = append(v, entries[i].v) 255 } 256 err, _ := VerifyRangeProof(trie.Hash(), first, last, k, v, proof) 257 if err != nil { 258 t.Fatal("Failed to verify whole rang with non-existent edges") 259 } 260 } 261 262 // TestRangeProofWithInvalidNonExistentProof tests such scenarios: 263 // - There exists a gap between the first element and the left edge proof 264 // - There exists a gap between the last element and the right edge proof 265 func TestRangeProofWithInvalidNonExistentProof(t *testing.T) { 266 trie, vals := randomTrie(4096) 267 var entries entrySlice 268 for _, kv := range vals { 269 entries = append(entries, kv) 270 } 271 sort.Sort(entries) 272 273 // Case 1 274 start, end := 100, 200 275 first := decreseKey(common.CopyBytes(entries[start].k)) 276 277 proof := memorydb.New() 278 if err := trie.Prove(first, 0, proof); err != nil { 279 t.Fatalf("Failed to prove the first node %v", err) 280 } 281 if err := trie.Prove(entries[end-1].k, 0, proof); err != nil { 282 t.Fatalf("Failed to prove the last node %v", err) 283 } 284 start = 105 // Gap created 285 k := make([][]byte, 0) 286 v := make([][]byte, 0) 287 for i := start; i < end; i++ { 288 k = append(k, entries[i].k) 289 v = append(v, entries[i].v) 290 } 291 err, _ := VerifyRangeProof(trie.Hash(), first, k[len(k)-1], k, v, proof) 292 if err == nil { 293 t.Fatalf("Expected to detect the error, got nil") 294 } 295 296 // Case 2 297 start, end = 100, 200 298 last := increseKey(common.CopyBytes(entries[end-1].k)) 299 proof = memorydb.New() 300 if err := trie.Prove(entries[start].k, 0, proof); err != nil { 301 t.Fatalf("Failed to prove the first node %v", err) 302 } 303 if err := trie.Prove(last, 0, proof); err != nil { 304 t.Fatalf("Failed to prove the last node %v", err) 305 } 306 end = 195 // Capped slice 307 k = make([][]byte, 0) 308 v = make([][]byte, 0) 309 for i := start; i < end; i++ { 310 k = append(k, entries[i].k) 311 v = append(v, entries[i].v) 312 } 313 err, _ = VerifyRangeProof(trie.Hash(), k[0], last, k, v, proof) 314 if err == nil { 315 t.Fatalf("Expected to detect the error, got nil") 316 } 317 } 318 319 // TestOneElementRangeProof tests the proof with only one 320 // element. The first edge proof can be existent one or 321 // non-existent one. 322 func TestOneElementRangeProof(t *testing.T) { 323 trie, vals := randomTrie(4096) 324 var entries entrySlice 325 for _, kv := range vals { 326 entries = append(entries, kv) 327 } 328 sort.Sort(entries) 329 330 // One element with existent edge proof, both edge proofs 331 // point to the SAME key. 332 start := 1000 333 proof := memorydb.New() 334 if err := trie.Prove(entries[start].k, 0, proof); err != nil { 335 t.Fatalf("Failed to prove the first node %v", err) 336 } 337 err, _ := VerifyRangeProof(trie.Hash(), entries[start].k, entries[start].k, [][]byte{entries[start].k}, [][]byte{entries[start].v}, proof) 338 if err != nil { 339 t.Fatalf("Expected no error, got %v", err) 340 } 341 342 // One element with left non-existent edge proof 343 start = 1000 344 first := decreseKey(common.CopyBytes(entries[start].k)) 345 proof = memorydb.New() 346 if err := trie.Prove(first, 0, proof); err != nil { 347 t.Fatalf("Failed to prove the first node %v", err) 348 } 349 if err := trie.Prove(entries[start].k, 0, proof); err != nil { 350 t.Fatalf("Failed to prove the last node %v", err) 351 } 352 err, _ = VerifyRangeProof(trie.Hash(), first, entries[start].k, [][]byte{entries[start].k}, [][]byte{entries[start].v}, proof) 353 if err != nil { 354 t.Fatalf("Expected no error, got %v", err) 355 } 356 357 // One element with right non-existent edge proof 358 start = 1000 359 last := increseKey(common.CopyBytes(entries[start].k)) 360 proof = memorydb.New() 361 if err := trie.Prove(entries[start].k, 0, proof); err != nil { 362 t.Fatalf("Failed to prove the first node %v", err) 363 } 364 if err := trie.Prove(last, 0, proof); err != nil { 365 t.Fatalf("Failed to prove the last node %v", err) 366 } 367 err, _ = VerifyRangeProof(trie.Hash(), entries[start].k, last, [][]byte{entries[start].k}, [][]byte{entries[start].v}, proof) 368 if err != nil { 369 t.Fatalf("Expected no error, got %v", err) 370 } 371 372 // One element with two non-existent edge proofs 373 start = 1000 374 first, last = decreseKey(common.CopyBytes(entries[start].k)), increseKey(common.CopyBytes(entries[start].k)) 375 proof = memorydb.New() 376 if err := trie.Prove(first, 0, proof); err != nil { 377 t.Fatalf("Failed to prove the first node %v", err) 378 } 379 if err := trie.Prove(last, 0, proof); err != nil { 380 t.Fatalf("Failed to prove the last node %v", err) 381 } 382 err, _ = VerifyRangeProof(trie.Hash(), first, last, [][]byte{entries[start].k}, [][]byte{entries[start].v}, proof) 383 if err != nil { 384 t.Fatalf("Expected no error, got %v", err) 385 } 386 } 387 388 // TestAllElementsProof tests the range proof with all elements. 389 // The edge proofs can be nil. 390 func TestAllElementsProof(t *testing.T) { 391 trie, vals := randomTrie(4096) 392 var entries entrySlice 393 for _, kv := range vals { 394 entries = append(entries, kv) 395 } 396 sort.Sort(entries) 397 398 var k [][]byte 399 var v [][]byte 400 for i := 0; i < len(entries); i++ { 401 k = append(k, entries[i].k) 402 v = append(v, entries[i].v) 403 } 404 err, _ := VerifyRangeProof(trie.Hash(), nil, nil, k, v, nil) 405 if err != nil { 406 t.Fatalf("Expected no error, got %v", err) 407 } 408 409 // With edge proofs, it should still work. 410 proof := memorydb.New() 411 if err := trie.Prove(entries[0].k, 0, proof); err != nil { 412 t.Fatalf("Failed to prove the first node %v", err) 413 } 414 if err := trie.Prove(entries[len(entries)-1].k, 0, proof); err != nil { 415 t.Fatalf("Failed to prove the last node %v", err) 416 } 417 err, _ = VerifyRangeProof(trie.Hash(), k[0], k[len(k)-1], k, v, proof) 418 if err != nil { 419 t.Fatalf("Expected no error, got %v", err) 420 } 421 422 // Even with non-existent edge proofs, it should still work. 423 proof = memorydb.New() 424 first := common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000").Bytes() 425 last := common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").Bytes() 426 if err := trie.Prove(first, 0, proof); err != nil { 427 t.Fatalf("Failed to prove the first node %v", err) 428 } 429 if err := trie.Prove(last, 0, proof); err != nil { 430 t.Fatalf("Failed to prove the last node %v", err) 431 } 432 err, _ = VerifyRangeProof(trie.Hash(), first, last, k, v, proof) 433 if err != nil { 434 t.Fatalf("Expected no error, got %v", err) 435 } 436 } 437 438 // TestSingleSideRangeProof tests the range starts from zero. 439 func TestSingleSideRangeProof(t *testing.T) { 440 for i := 0; i < 64; i++ { 441 trie := new(Trie) 442 var entries entrySlice 443 for i := 0; i < 4096; i++ { 444 value := &kv{randBytes(32), randBytes(20), false} 445 trie.Update(value.k, value.v) 446 entries = append(entries, value) 447 } 448 sort.Sort(entries) 449 450 var cases = []int{0, 1, 50, 100, 1000, 2000, len(entries) - 1} 451 for _, pos := range cases { 452 proof := memorydb.New() 453 if err := trie.Prove(common.Hash{}.Bytes(), 0, proof); err != nil { 454 t.Fatalf("Failed to prove the first node %v", err) 455 } 456 if err := trie.Prove(entries[pos].k, 0, proof); err != nil { 457 t.Fatalf("Failed to prove the first node %v", err) 458 } 459 k := make([][]byte, 0) 460 v := make([][]byte, 0) 461 for i := 0; i <= pos; i++ { 462 k = append(k, entries[i].k) 463 v = append(v, entries[i].v) 464 } 465 err, _ := VerifyRangeProof(trie.Hash(), common.Hash{}.Bytes(), k[len(k)-1], k, v, proof) 466 if err != nil { 467 t.Fatalf("Expected no error, got %v", err) 468 } 469 } 470 } 471 } 472 473 // TestReverseSingleSideRangeProof tests the range ends with 0xffff...fff. 474 func TestReverseSingleSideRangeProof(t *testing.T) { 475 for i := 0; i < 64; i++ { 476 trie := new(Trie) 477 var entries entrySlice 478 for i := 0; i < 4096; i++ { 479 value := &kv{randBytes(32), randBytes(20), false} 480 trie.Update(value.k, value.v) 481 entries = append(entries, value) 482 } 483 sort.Sort(entries) 484 485 var cases = []int{0, 1, 50, 100, 1000, 2000, len(entries) - 1} 486 for _, pos := range cases { 487 proof := memorydb.New() 488 if err := trie.Prove(entries[pos].k, 0, proof); err != nil { 489 t.Fatalf("Failed to prove the first node %v", err) 490 } 491 last := common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff") 492 if err := trie.Prove(last.Bytes(), 0, proof); err != nil { 493 t.Fatalf("Failed to prove the last node %v", err) 494 } 495 k := make([][]byte, 0) 496 v := make([][]byte, 0) 497 for i := pos; i < len(entries); i++ { 498 k = append(k, entries[i].k) 499 v = append(v, entries[i].v) 500 } 501 err, _ := VerifyRangeProof(trie.Hash(), k[0], last.Bytes(), k, v, proof) 502 if err != nil { 503 t.Fatalf("Expected no error, got %v", err) 504 } 505 } 506 } 507 } 508 509 // TestBadRangeProof tests a few cases which the proof is wrong. 510 // The prover is expected to detect the error. 511 func TestBadRangeProof(t *testing.T) { 512 trie, vals := randomTrie(4096) 513 var entries entrySlice 514 for _, kv := range vals { 515 entries = append(entries, kv) 516 } 517 sort.Sort(entries) 518 519 for i := 0; i < 500; i++ { 520 start := mrand.Intn(len(entries)) 521 end := mrand.Intn(len(entries)-start) + start + 1 522 proof := memorydb.New() 523 if err := trie.Prove(entries[start].k, 0, proof); err != nil { 524 t.Fatalf("Failed to prove the first node %v", err) 525 } 526 if err := trie.Prove(entries[end-1].k, 0, proof); err != nil { 527 t.Fatalf("Failed to prove the last node %v", err) 528 } 529 var keys [][]byte 530 var vals [][]byte 531 for i := start; i < end; i++ { 532 keys = append(keys, entries[i].k) 533 vals = append(vals, entries[i].v) 534 } 535 var first, last = keys[0], keys[len(keys)-1] 536 testcase := mrand.Intn(6) 537 var index int 538 switch testcase { 539 case 0: 540 // Modified key 541 index = mrand.Intn(end - start) 542 keys[index] = randBytes(32) // In theory it can't be same 543 case 1: 544 // Modified val 545 index = mrand.Intn(end - start) 546 vals[index] = randBytes(20) // In theory it can't be same 547 case 2: 548 // Gapped entry slice 549 index = mrand.Intn(end - start) 550 if (index == 0 && start < 100) || (index == end-start-1 && end <= 100) { 551 continue 552 } 553 keys = append(keys[:index], keys[index+1:]...) 554 vals = append(vals[:index], vals[index+1:]...) 555 case 3: 556 // Out of order 557 index1 := mrand.Intn(end - start) 558 index2 := mrand.Intn(end - start) 559 if index1 == index2 { 560 continue 561 } 562 keys[index1], keys[index2] = keys[index2], keys[index1] 563 vals[index1], vals[index2] = vals[index2], vals[index1] 564 case 4: 565 // Set random key to nil, do nothing 566 index = mrand.Intn(end - start) 567 keys[index] = nil 568 case 5: 569 // Set random value to nil, deletion 570 index = mrand.Intn(end - start) 571 vals[index] = nil 572 } 573 err, _ := VerifyRangeProof(trie.Hash(), first, last, keys, vals, proof) 574 if err == nil { 575 t.Fatalf("%d Case %d index %d range: (%d->%d) expect error, got nil", i, testcase, index, start, end-1) 576 } 577 } 578 } 579 580 // TestGappedRangeProof focuses on the small trie with embedded nodes. 581 // If the gapped node is embedded in the trie, it should be detected too. 582 func TestGappedRangeProof(t *testing.T) { 583 trie := new(Trie) 584 var entries []*kv // Sorted entries 585 for i := byte(0); i < 10; i++ { 586 value := &kv{common.LeftPadBytes([]byte{i}, 32), []byte{i}, false} 587 trie.Update(value.k, value.v) 588 entries = append(entries, value) 589 } 590 first, last := 2, 8 591 proof := memorydb.New() 592 if err := trie.Prove(entries[first].k, 0, proof); err != nil { 593 t.Fatalf("Failed to prove the first node %v", err) 594 } 595 if err := trie.Prove(entries[last-1].k, 0, proof); err != nil { 596 t.Fatalf("Failed to prove the last node %v", err) 597 } 598 var keys [][]byte 599 var vals [][]byte 600 for i := first; i < last; i++ { 601 if i == (first+last)/2 { 602 continue 603 } 604 keys = append(keys, entries[i].k) 605 vals = append(vals, entries[i].v) 606 } 607 err, _ := VerifyRangeProof(trie.Hash(), keys[0], keys[len(keys)-1], keys, vals, proof) 608 if err == nil { 609 t.Fatal("expect error, got nil") 610 } 611 } 612 613 // TestSameSideProofs tests the element is not in the range covered by proofs 614 func TestSameSideProofs(t *testing.T) { 615 trie, vals := randomTrie(4096) 616 var entries entrySlice 617 for _, kv := range vals { 618 entries = append(entries, kv) 619 } 620 sort.Sort(entries) 621 622 pos := 1000 623 first := decreseKey(common.CopyBytes(entries[pos].k)) 624 first = decreseKey(first) 625 last := decreseKey(common.CopyBytes(entries[pos].k)) 626 627 proof := memorydb.New() 628 if err := trie.Prove(first, 0, proof); err != nil { 629 t.Fatalf("Failed to prove the first node %v", err) 630 } 631 if err := trie.Prove(last, 0, proof); err != nil { 632 t.Fatalf("Failed to prove the last node %v", err) 633 } 634 err, _ := VerifyRangeProof(trie.Hash(), first, last, [][]byte{entries[pos].k}, [][]byte{entries[pos].v}, proof) 635 if err == nil { 636 t.Fatalf("Expected error, got nil") 637 } 638 639 first = increseKey(common.CopyBytes(entries[pos].k)) 640 last = increseKey(common.CopyBytes(entries[pos].k)) 641 last = increseKey(last) 642 643 proof = memorydb.New() 644 if err := trie.Prove(first, 0, proof); err != nil { 645 t.Fatalf("Failed to prove the first node %v", err) 646 } 647 if err := trie.Prove(last, 0, proof); err != nil { 648 t.Fatalf("Failed to prove the last node %v", err) 649 } 650 err, _ = VerifyRangeProof(trie.Hash(), first, last, [][]byte{entries[pos].k}, [][]byte{entries[pos].v}, proof) 651 if err == nil { 652 t.Fatalf("Expected error, got nil") 653 } 654 } 655 656 func TestHasRightElement(t *testing.T) { 657 trie := new(Trie) 658 var entries entrySlice 659 for i := 0; i < 4096; i++ { 660 value := &kv{randBytes(32), randBytes(20), false} 661 trie.Update(value.k, value.v) 662 entries = append(entries, value) 663 } 664 sort.Sort(entries) 665 666 var cases = []struct { 667 start int 668 end int 669 hasMore bool 670 }{ 671 {-1, 1, true}, // single element with non-existent left proof 672 {0, 1, true}, // single element with existent left proof 673 {0, 10, true}, 674 {50, 100, true}, 675 {50, len(entries), false}, // No more element expected 676 {len(entries) - 1, len(entries), false}, // Single last element with two existent proofs(point to same key) 677 {len(entries) - 1, -1, false}, // Single last element with non-existent right proof 678 {0, len(entries), false}, // The whole set with existent left proof 679 {-1, len(entries), false}, // The whole set with non-existent left proof 680 {-1, -1, false}, // The whole set with non-existent left/right proof 681 } 682 for _, c := range cases { 683 var ( 684 firstKey []byte 685 lastKey []byte 686 start = c.start 687 end = c.end 688 proof = memorydb.New() 689 ) 690 if c.start == -1 { 691 firstKey, start = common.Hash{}.Bytes(), 0 692 if err := trie.Prove(firstKey, 0, proof); err != nil { 693 t.Fatalf("Failed to prove the first node %v", err) 694 } 695 } else { 696 firstKey = entries[c.start].k 697 if err := trie.Prove(entries[c.start].k, 0, proof); err != nil { 698 t.Fatalf("Failed to prove the first node %v", err) 699 } 700 } 701 if c.end == -1 { 702 lastKey, end = common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").Bytes(), len(entries) 703 if err := trie.Prove(lastKey, 0, proof); err != nil { 704 t.Fatalf("Failed to prove the first node %v", err) 705 } 706 } else { 707 lastKey = entries[c.end-1].k 708 if err := trie.Prove(entries[c.end-1].k, 0, proof); err != nil { 709 t.Fatalf("Failed to prove the first node %v", err) 710 } 711 } 712 k := make([][]byte, 0) 713 v := make([][]byte, 0) 714 for i := start; i < end; i++ { 715 k = append(k, entries[i].k) 716 v = append(v, entries[i].v) 717 } 718 err, hasMore := VerifyRangeProof(trie.Hash(), firstKey, lastKey, k, v, proof) 719 if err != nil { 720 t.Fatalf("Expected no error, got %v", err) 721 } 722 if hasMore != c.hasMore { 723 t.Fatalf("Wrong hasMore indicator, want %t, got %t", c.hasMore, hasMore) 724 } 725 } 726 } 727 728 // TestEmptyRangeProof tests the range proof with "no" element. 729 // The first edge proof must be a non-existent proof. 730 func TestEmptyRangeProof(t *testing.T) { 731 trie, vals := randomTrie(4096) 732 var entries entrySlice 733 for _, kv := range vals { 734 entries = append(entries, kv) 735 } 736 sort.Sort(entries) 737 738 var cases = []struct { 739 pos int 740 err bool 741 }{ 742 {len(entries) - 1, false}, 743 {500, true}, 744 } 745 for _, c := range cases { 746 proof := memorydb.New() 747 first := increseKey(common.CopyBytes(entries[c.pos].k)) 748 if err := trie.Prove(first, 0, proof); err != nil { 749 t.Fatalf("Failed to prove the first node %v", err) 750 } 751 err, _ := VerifyRangeProof(trie.Hash(), first, nil, nil, nil, proof) 752 if c.err && err == nil { 753 t.Fatalf("Expected error, got nil") 754 } 755 if !c.err && err != nil { 756 t.Fatalf("Expected no error, got %v", err) 757 } 758 } 759 } 760 761 // mutateByte changes one byte in b. 762 func mutateByte(b []byte) { 763 for r := mrand.Intn(len(b)); ; { 764 new := byte(mrand.Intn(255)) 765 if new != b[r] { 766 b[r] = new 767 break 768 } 769 } 770 } 771 772 func increseKey(key []byte) []byte { 773 for i := len(key) - 1; i >= 0; i-- { 774 key[i]++ 775 if key[i] != 0x0 { 776 break 777 } 778 } 779 return key 780 } 781 782 func decreseKey(key []byte) []byte { 783 for i := len(key) - 1; i >= 0; i-- { 784 key[i]-- 785 if key[i] != 0xff { 786 break 787 } 788 } 789 return key 790 } 791 792 func BenchmarkProve(b *testing.B) { 793 trie, vals := randomTrie(100) 794 var keys []string 795 for k := range vals { 796 keys = append(keys, k) 797 } 798 799 b.ResetTimer() 800 for i := 0; i < b.N; i++ { 801 kv := vals[keys[i%len(keys)]] 802 proofs := memorydb.New() 803 if trie.Prove(kv.k, 0, proofs); proofs.Len() == 0 { 804 b.Fatalf("zero length proof for %x", kv.k) 805 } 806 } 807 } 808 809 func BenchmarkVerifyProof(b *testing.B) { 810 trie, vals := randomTrie(100) 811 root := trie.Hash() 812 var keys []string 813 var proofs []*memorydb.Database 814 for k := range vals { 815 keys = append(keys, k) 816 proof := memorydb.New() 817 trie.Prove([]byte(k), 0, proof) 818 proofs = append(proofs, proof) 819 } 820 821 b.ResetTimer() 822 for i := 0; i < b.N; i++ { 823 im := i % len(keys) 824 if _, err := VerifyProof(root, []byte(keys[im]), proofs[im]); err != nil { 825 b.Fatalf("key %x: %v", keys[im], err) 826 } 827 } 828 } 829 830 func BenchmarkVerifyRangeProof10(b *testing.B) { benchmarkVerifyRangeProof(b, 10) } 831 func BenchmarkVerifyRangeProof100(b *testing.B) { benchmarkVerifyRangeProof(b, 100) } 832 func BenchmarkVerifyRangeProof1000(b *testing.B) { benchmarkVerifyRangeProof(b, 1000) } 833 func BenchmarkVerifyRangeProof5000(b *testing.B) { benchmarkVerifyRangeProof(b, 5000) } 834 835 func benchmarkVerifyRangeProof(b *testing.B, size int) { 836 trie, vals := randomTrie(8192) 837 var entries entrySlice 838 for _, kv := range vals { 839 entries = append(entries, kv) 840 } 841 sort.Sort(entries) 842 843 start := 2 844 end := start + size 845 proof := memorydb.New() 846 if err := trie.Prove(entries[start].k, 0, proof); err != nil { 847 b.Fatalf("Failed to prove the first node %v", err) 848 } 849 if err := trie.Prove(entries[end-1].k, 0, proof); err != nil { 850 b.Fatalf("Failed to prove the last node %v", err) 851 } 852 var keys [][]byte 853 var values [][]byte 854 for i := start; i < end; i++ { 855 keys = append(keys, entries[i].k) 856 values = append(values, entries[i].v) 857 } 858 859 b.ResetTimer() 860 for i := 0; i < b.N; i++ { 861 err, _ := VerifyRangeProof(trie.Hash(), keys[0], keys[len(keys)-1], keys, values, proof) 862 if err != nil { 863 b.Fatalf("Case %d(%d->%d) expect no error, got %v", i, start, end-1, err) 864 } 865 } 866 } 867 868 func randomTrie(n int) (*Trie, map[string]*kv) { 869 trie := new(Trie) 870 vals := make(map[string]*kv) 871 for i := byte(0); i < 100; i++ { 872 value := &kv{common.LeftPadBytes([]byte{i}, 32), []byte{i}, false} 873 value2 := &kv{common.LeftPadBytes([]byte{i + 10}, 32), []byte{i}, false} 874 trie.Update(value.k, value.v) 875 trie.Update(value2.k, value2.v) 876 vals[string(value.k)] = value 877 vals[string(value2.k)] = value2 878 } 879 for i := 0; i < n; i++ { 880 value := &kv{randBytes(32), randBytes(20), false} 881 trie.Update(value.k, value.v) 882 vals[string(value.k)] = value 883 } 884 return trie, vals 885 } 886 887 func randBytes(n int) []byte { 888 r := make([]byte, n) 889 crand.Read(r) 890 return r 891 }