trie: extend range proof (#21250)
* trie: support non-existent right proof * trie: improve test * trie: minor linter fix Co-authored-by: Péter Szilágyi <peterke@gmail.com>
This commit is contained in:
gary rong
GitHub
@ -166,15 +166,13 @@ func TestRangeProof(t *testing.T) {
|
||||
sort.Sort(entries)
|
||||
for i := 0; i < 500; i++ {
|
||||
start := mrand.Intn(len(entries))
|
||||
end := mrand.Intn(len(entries)-start) + start
|
||||
if start == end {
|
||||
continue
|
||||
}
|
||||
firstProof, lastProof := memorydb.New(), memorydb.New()
|
||||
if err := trie.Prove(entries[start].k, 0, firstProof); err != nil {
|
||||
end := mrand.Intn(len(entries)-start) + start + 1
|
||||
|
||||
proof := memorydb.New()
|
||||
if err := trie.Prove(entries[start].k, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
if err := trie.Prove(entries[end-1].k, 0, lastProof); err != nil {
|
||||
if err := trie.Prove(entries[end-1].k, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the last node %v", err)
|
||||
}
|
||||
var keys [][]byte
|
||||
@ -183,15 +181,15 @@ func TestRangeProof(t *testing.T) {
|
||||
keys = append(keys, entries[i].k)
|
||||
vals = append(vals, entries[i].v)
|
||||
}
|
||||
err, _ := VerifyRangeProof(trie.Hash(), keys[0], keys, vals, firstProof, lastProof)
|
||||
err, _ := VerifyRangeProof(trie.Hash(), keys[0], keys[len(keys)-1], keys, vals, proof)
|
||||
if err != nil {
|
||||
t.Fatalf("Case %d(%d->%d) expect no error, got %v", i, start, end-1, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestRangeProof tests normal range proof with the first edge proof
|
||||
// as the non-existent proof. The test cases are generated randomly.
|
||||
// TestRangeProof tests normal range proof with two non-existent proofs.
|
||||
// The test cases are generated randomly.
|
||||
func TestRangeProofWithNonExistentProof(t *testing.T) {
|
||||
trie, vals := randomTrie(4096)
|
||||
var entries entrySlice
|
||||
@ -201,20 +199,31 @@ func TestRangeProofWithNonExistentProof(t *testing.T) {
|
||||
sort.Sort(entries)
|
||||
for i := 0; i < 500; i++ {
|
||||
start := mrand.Intn(len(entries))
|
||||
end := mrand.Intn(len(entries)-start) + start
|
||||
if start == end {
|
||||
continue
|
||||
}
|
||||
firstProof, lastProof := memorydb.New(), memorydb.New()
|
||||
end := mrand.Intn(len(entries)-start) + start + 1
|
||||
proof := memorydb.New()
|
||||
|
||||
// Short circuit if the decreased key is same with the previous key
|
||||
first := decreseKey(common.CopyBytes(entries[start].k))
|
||||
if start != 0 && bytes.Equal(first, entries[start-1].k) {
|
||||
continue
|
||||
}
|
||||
if err := trie.Prove(first, 0, firstProof); err != nil {
|
||||
// Short circuit if the decreased key is underflow
|
||||
if bytes.Compare(first, entries[start].k) > 0 {
|
||||
continue
|
||||
}
|
||||
// Short circuit if the increased key is same with the next key
|
||||
last := increseKey(common.CopyBytes(entries[end-1].k))
|
||||
if end != len(entries) && bytes.Equal(last, entries[end].k) {
|
||||
continue
|
||||
}
|
||||
// Short circuit if the increased key is overflow
|
||||
if bytes.Compare(last, entries[end-1].k) < 0 {
|
||||
continue
|
||||
}
|
||||
if err := trie.Prove(first, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
if err := trie.Prove(entries[end-1].k, 0, lastProof); err != nil {
|
||||
if err := trie.Prove(last, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the last node %v", err)
|
||||
}
|
||||
var keys [][]byte
|
||||
@ -223,16 +232,36 @@ func TestRangeProofWithNonExistentProof(t *testing.T) {
|
||||
keys = append(keys, entries[i].k)
|
||||
vals = append(vals, entries[i].v)
|
||||
}
|
||||
err, _ := VerifyRangeProof(trie.Hash(), first, keys, vals, firstProof, lastProof)
|
||||
err, _ := VerifyRangeProof(trie.Hash(), first, last, keys, vals, proof)
|
||||
if err != nil {
|
||||
t.Fatalf("Case %d(%d->%d) expect no error, got %v", i, start, end-1, err)
|
||||
}
|
||||
}
|
||||
// Special case, two edge proofs for two edge key.
|
||||
proof := memorydb.New()
|
||||
first := common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000").Bytes()
|
||||
last := common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").Bytes()
|
||||
if err := trie.Prove(first, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
if err := trie.Prove(last, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the last node %v", err)
|
||||
}
|
||||
var k [][]byte
|
||||
var v [][]byte
|
||||
for i := 0; i < len(entries); i++ {
|
||||
k = append(k, entries[i].k)
|
||||
v = append(v, entries[i].v)
|
||||
}
|
||||
err, _ := VerifyRangeProof(trie.Hash(), first, last, k, v, proof)
|
||||
if err != nil {
|
||||
t.Fatal("Failed to verify whole rang with non-existent edges")
|
||||
}
|
||||
}
|
||||
|
||||
// TestRangeProofWithInvalidNonExistentProof tests such scenarios:
|
||||
// - The last edge proof is an non-existent proof
|
||||
// - There exists a gap between the first element and the left edge proof
|
||||
// - There exists a gap between the last element and the right edge proof
|
||||
func TestRangeProofWithInvalidNonExistentProof(t *testing.T) {
|
||||
trie, vals := randomTrie(4096)
|
||||
var entries entrySlice
|
||||
@ -243,44 +272,45 @@ func TestRangeProofWithInvalidNonExistentProof(t *testing.T) {
|
||||
|
||||
// Case 1
|
||||
start, end := 100, 200
|
||||
first, last := decreseKey(common.CopyBytes(entries[start].k)), increseKey(common.CopyBytes(entries[end].k))
|
||||
firstProof, lastProof := memorydb.New(), memorydb.New()
|
||||
if err := trie.Prove(first, 0, firstProof); err != nil {
|
||||
first := decreseKey(common.CopyBytes(entries[start].k))
|
||||
|
||||
proof := memorydb.New()
|
||||
if err := trie.Prove(first, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
if err := trie.Prove(last, 0, lastProof); err != nil {
|
||||
if err := trie.Prove(entries[end-1].k, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the last node %v", err)
|
||||
}
|
||||
var k [][]byte
|
||||
var v [][]byte
|
||||
start = 105 // Gap created
|
||||
k := make([][]byte, 0)
|
||||
v := make([][]byte, 0)
|
||||
for i := start; i < end; i++ {
|
||||
k = append(k, entries[i].k)
|
||||
v = append(v, entries[i].v)
|
||||
}
|
||||
err, _ := VerifyRangeProof(trie.Hash(), first, k, v, firstProof, lastProof)
|
||||
err, _ := VerifyRangeProof(trie.Hash(), first, k[len(k)-1], k, v, proof)
|
||||
if err == nil {
|
||||
t.Fatalf("Expected to detect the error, got nil")
|
||||
}
|
||||
|
||||
// Case 2
|
||||
start, end = 100, 200
|
||||
first = decreseKey(common.CopyBytes(entries[start].k))
|
||||
|
||||
firstProof, lastProof = memorydb.New(), memorydb.New()
|
||||
if err := trie.Prove(first, 0, firstProof); err != nil {
|
||||
last := increseKey(common.CopyBytes(entries[end-1].k))
|
||||
proof = memorydb.New()
|
||||
if err := trie.Prove(entries[start].k, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
if err := trie.Prove(entries[end-1].k, 0, lastProof); err != nil {
|
||||
if err := trie.Prove(last, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the last node %v", err)
|
||||
}
|
||||
start = 105 // Gap created
|
||||
end = 195 // Capped slice
|
||||
k = make([][]byte, 0)
|
||||
v = make([][]byte, 0)
|
||||
for i := start; i < end; i++ {
|
||||
k = append(k, entries[i].k)
|
||||
v = append(v, entries[i].v)
|
||||
}
|
||||
err, _ = VerifyRangeProof(trie.Hash(), first, k, v, firstProof, lastProof)
|
||||
err, _ = VerifyRangeProof(trie.Hash(), k[0], last, k, v, proof)
|
||||
if err == nil {
|
||||
t.Fatalf("Expected to detect the error, got nil")
|
||||
}
|
||||
@ -297,31 +327,59 @@ func TestOneElementRangeProof(t *testing.T) {
|
||||
}
|
||||
sort.Sort(entries)
|
||||
|
||||
// One element with existent edge proof
|
||||
// One element with existent edge proof, both edge proofs
|
||||
// point to the SAME key.
|
||||
start := 1000
|
||||
firstProof, lastProof := memorydb.New(), memorydb.New()
|
||||
if err := trie.Prove(entries[start].k, 0, firstProof); err != nil {
|
||||
proof := memorydb.New()
|
||||
if err := trie.Prove(entries[start].k, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
if err := trie.Prove(entries[start].k, 0, lastProof); err != nil {
|
||||
t.Fatalf("Failed to prove the last node %v", err)
|
||||
}
|
||||
err, _ := VerifyRangeProof(trie.Hash(), entries[start].k, [][]byte{entries[start].k}, [][]byte{entries[start].v}, firstProof, lastProof)
|
||||
err, _ := VerifyRangeProof(trie.Hash(), entries[start].k, entries[start].k, [][]byte{entries[start].k}, [][]byte{entries[start].v}, proof)
|
||||
if err != nil {
|
||||
t.Fatalf("Expected no error, got %v", err)
|
||||
}
|
||||
|
||||
// One element with non-existent edge proof
|
||||
// One element with left non-existent edge proof
|
||||
start = 1000
|
||||
first := decreseKey(common.CopyBytes(entries[start].k))
|
||||
firstProof, lastProof = memorydb.New(), memorydb.New()
|
||||
if err := trie.Prove(first, 0, firstProof); err != nil {
|
||||
proof = memorydb.New()
|
||||
if err := trie.Prove(first, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
if err := trie.Prove(entries[start].k, 0, lastProof); err != nil {
|
||||
if err := trie.Prove(entries[start].k, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the last node %v", err)
|
||||
}
|
||||
err, _ = VerifyRangeProof(trie.Hash(), first, [][]byte{entries[start].k}, [][]byte{entries[start].v}, firstProof, lastProof)
|
||||
err, _ = VerifyRangeProof(trie.Hash(), first, entries[start].k, [][]byte{entries[start].k}, [][]byte{entries[start].v}, proof)
|
||||
if err != nil {
|
||||
t.Fatalf("Expected no error, got %v", err)
|
||||
}
|
||||
|
||||
// One element with right non-existent edge proof
|
||||
start = 1000
|
||||
last := increseKey(common.CopyBytes(entries[start].k))
|
||||
proof = memorydb.New()
|
||||
if err := trie.Prove(entries[start].k, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
if err := trie.Prove(last, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the last node %v", err)
|
||||
}
|
||||
err, _ = VerifyRangeProof(trie.Hash(), entries[start].k, last, [][]byte{entries[start].k}, [][]byte{entries[start].v}, proof)
|
||||
if err != nil {
|
||||
t.Fatalf("Expected no error, got %v", err)
|
||||
}
|
||||
|
||||
// One element with two non-existent edge proofs
|
||||
start = 1000
|
||||
first, last = decreseKey(common.CopyBytes(entries[start].k)), increseKey(common.CopyBytes(entries[start].k))
|
||||
proof = memorydb.New()
|
||||
if err := trie.Prove(first, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
if err := trie.Prove(last, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the last node %v", err)
|
||||
}
|
||||
err, _ = VerifyRangeProof(trie.Hash(), first, last, [][]byte{entries[start].k}, [][]byte{entries[start].v}, proof)
|
||||
if err != nil {
|
||||
t.Fatalf("Expected no error, got %v", err)
|
||||
}
|
||||
@ -343,20 +401,35 @@ func TestAllElementsProof(t *testing.T) {
|
||||
k = append(k, entries[i].k)
|
||||
v = append(v, entries[i].v)
|
||||
}
|
||||
err, _ := VerifyRangeProof(trie.Hash(), k[0], k, v, nil, nil)
|
||||
err, _ := VerifyRangeProof(trie.Hash(), nil, nil, k, v, nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Expected no error, got %v", err)
|
||||
}
|
||||
|
||||
// Even with edge proofs, it should still work.
|
||||
firstProof, lastProof := memorydb.New(), memorydb.New()
|
||||
if err := trie.Prove(entries[0].k, 0, firstProof); err != nil {
|
||||
// With edge proofs, it should still work.
|
||||
proof := memorydb.New()
|
||||
if err := trie.Prove(entries[0].k, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
if err := trie.Prove(entries[len(entries)-1].k, 0, lastProof); err != nil {
|
||||
if err := trie.Prove(entries[len(entries)-1].k, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the last node %v", err)
|
||||
}
|
||||
err, _ = VerifyRangeProof(trie.Hash(), k[0], k, v, firstProof, lastProof)
|
||||
err, _ = VerifyRangeProof(trie.Hash(), k[0], k[len(k)-1], k, v, proof)
|
||||
if err != nil {
|
||||
t.Fatalf("Expected no error, got %v", err)
|
||||
}
|
||||
|
||||
// Even with non-existent edge proofs, it should still work.
|
||||
proof = memorydb.New()
|
||||
first := common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000").Bytes()
|
||||
last := common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").Bytes()
|
||||
if err := trie.Prove(first, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
if err := trie.Prove(last, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the last node %v", err)
|
||||
}
|
||||
err, _ = VerifyRangeProof(trie.Hash(), first, last, k, v, proof)
|
||||
if err != nil {
|
||||
t.Fatalf("Expected no error, got %v", err)
|
||||
}
|
||||
@ -376,11 +449,11 @@ func TestSingleSideRangeProof(t *testing.T) {
|
||||
|
||||
var cases = []int{0, 1, 50, 100, 1000, 2000, len(entries) - 1}
|
||||
for _, pos := range cases {
|
||||
firstProof, lastProof := memorydb.New(), memorydb.New()
|
||||
if err := trie.Prove(common.Hash{}.Bytes(), 0, firstProof); err != nil {
|
||||
proof := memorydb.New()
|
||||
if err := trie.Prove(common.Hash{}.Bytes(), 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
if err := trie.Prove(entries[pos].k, 0, lastProof); err != nil {
|
||||
if err := trie.Prove(entries[pos].k, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
k := make([][]byte, 0)
|
||||
@ -389,7 +462,43 @@ func TestSingleSideRangeProof(t *testing.T) {
|
||||
k = append(k, entries[i].k)
|
||||
v = append(v, entries[i].v)
|
||||
}
|
||||
err, _ := VerifyRangeProof(trie.Hash(), common.Hash{}.Bytes(), k, v, firstProof, lastProof)
|
||||
err, _ := VerifyRangeProof(trie.Hash(), common.Hash{}.Bytes(), k[len(k)-1], k, v, proof)
|
||||
if err != nil {
|
||||
t.Fatalf("Expected no error, got %v", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestReverseSingleSideRangeProof tests the range ends with 0xffff...fff.
|
||||
func TestReverseSingleSideRangeProof(t *testing.T) {
|
||||
for i := 0; i < 64; i++ {
|
||||
trie := new(Trie)
|
||||
var entries entrySlice
|
||||
for i := 0; i < 4096; i++ {
|
||||
value := &kv{randBytes(32), randBytes(20), false}
|
||||
trie.Update(value.k, value.v)
|
||||
entries = append(entries, value)
|
||||
}
|
||||
sort.Sort(entries)
|
||||
|
||||
var cases = []int{0, 1, 50, 100, 1000, 2000, len(entries) - 1}
|
||||
for _, pos := range cases {
|
||||
proof := memorydb.New()
|
||||
if err := trie.Prove(entries[pos].k, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
last := common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
|
||||
if err := trie.Prove(last.Bytes(), 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the last node %v", err)
|
||||
}
|
||||
k := make([][]byte, 0)
|
||||
v := make([][]byte, 0)
|
||||
for i := pos; i < len(entries); i++ {
|
||||
k = append(k, entries[i].k)
|
||||
v = append(v, entries[i].v)
|
||||
}
|
||||
err, _ := VerifyRangeProof(trie.Hash(), k[0], last.Bytes(), k, v, proof)
|
||||
if err != nil {
|
||||
t.Fatalf("Expected no error, got %v", err)
|
||||
}
|
||||
@ -409,15 +518,12 @@ func TestBadRangeProof(t *testing.T) {
|
||||
|
||||
for i := 0; i < 500; i++ {
|
||||
start := mrand.Intn(len(entries))
|
||||
end := mrand.Intn(len(entries)-start) + start
|
||||
if start == end {
|
||||
continue
|
||||
}
|
||||
firstProof, lastProof := memorydb.New(), memorydb.New()
|
||||
if err := trie.Prove(entries[start].k, 0, firstProof); err != nil {
|
||||
end := mrand.Intn(len(entries)-start) + start + 1
|
||||
proof := memorydb.New()
|
||||
if err := trie.Prove(entries[start].k, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
if err := trie.Prove(entries[end-1].k, 0, lastProof); err != nil {
|
||||
if err := trie.Prove(entries[end-1].k, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the last node %v", err)
|
||||
}
|
||||
var keys [][]byte
|
||||
@ -426,6 +532,7 @@ func TestBadRangeProof(t *testing.T) {
|
||||
keys = append(keys, entries[i].k)
|
||||
vals = append(vals, entries[i].v)
|
||||
}
|
||||
var first, last = keys[0], keys[len(keys)-1]
|
||||
testcase := mrand.Intn(6)
|
||||
var index int
|
||||
switch testcase {
|
||||
@ -439,17 +546,6 @@ func TestBadRangeProof(t *testing.T) {
|
||||
vals[index] = randBytes(20) // In theory it can't be same
|
||||
case 2:
|
||||
// Gapped entry slice
|
||||
|
||||
// There are only two elements, skip it. Dropped any element
|
||||
// will lead to single edge proof which is always correct.
|
||||
if end-start <= 2 {
|
||||
continue
|
||||
}
|
||||
// If the dropped element is the first or last one and it's a
|
||||
// batch of small size elements. In this special case, it can
|
||||
// happen that the proof for the edge element is exactly same
|
||||
// with the first/last second element(since small values are
|
||||
// embedded in the parent). Avoid this case.
|
||||
index = mrand.Intn(end - start)
|
||||
if (index == 0 && start < 100) || (index == end-start-1 && end <= 100) {
|
||||
continue
|
||||
@ -457,20 +553,24 @@ func TestBadRangeProof(t *testing.T) {
|
||||
keys = append(keys[:index], keys[index+1:]...)
|
||||
vals = append(vals[:index], vals[index+1:]...)
|
||||
case 3:
|
||||
// Switched entry slice, same effect with gapped
|
||||
index = mrand.Intn(end - start)
|
||||
keys[index] = entries[len(entries)-1].k
|
||||
vals[index] = entries[len(entries)-1].v
|
||||
// Out of order
|
||||
index1 := mrand.Intn(end - start)
|
||||
index2 := mrand.Intn(end - start)
|
||||
if index1 == index2 {
|
||||
continue
|
||||
}
|
||||
keys[index1], keys[index2] = keys[index2], keys[index1]
|
||||
vals[index1], vals[index2] = vals[index2], vals[index1]
|
||||
case 4:
|
||||
// Set random key to nil
|
||||
// Set random key to nil, do nothing
|
||||
index = mrand.Intn(end - start)
|
||||
keys[index] = nil
|
||||
case 5:
|
||||
// Set random value to nil
|
||||
// Set random value to nil, deletion
|
||||
index = mrand.Intn(end - start)
|
||||
vals[index] = nil
|
||||
}
|
||||
err, _ := VerifyRangeProof(trie.Hash(), keys[0], keys, vals, firstProof, lastProof)
|
||||
err, _ := VerifyRangeProof(trie.Hash(), first, last, keys, vals, proof)
|
||||
if err == nil {
|
||||
t.Fatalf("%d Case %d index %d range: (%d->%d) expect error, got nil", i, testcase, index, start, end-1)
|
||||
}
|
||||
@ -488,11 +588,11 @@ func TestGappedRangeProof(t *testing.T) {
|
||||
entries = append(entries, value)
|
||||
}
|
||||
first, last := 2, 8
|
||||
firstProof, lastProof := memorydb.New(), memorydb.New()
|
||||
if err := trie.Prove(entries[first].k, 0, firstProof); err != nil {
|
||||
proof := memorydb.New()
|
||||
if err := trie.Prove(entries[first].k, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
if err := trie.Prove(entries[last-1].k, 0, lastProof); err != nil {
|
||||
if err := trie.Prove(entries[last-1].k, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the last node %v", err)
|
||||
}
|
||||
var keys [][]byte
|
||||
@ -504,12 +604,55 @@ func TestGappedRangeProof(t *testing.T) {
|
||||
keys = append(keys, entries[i].k)
|
||||
vals = append(vals, entries[i].v)
|
||||
}
|
||||
err, _ := VerifyRangeProof(trie.Hash(), keys[0], keys, vals, firstProof, lastProof)
|
||||
err, _ := VerifyRangeProof(trie.Hash(), keys[0], keys[len(keys)-1], keys, vals, proof)
|
||||
if err == nil {
|
||||
t.Fatal("expect error, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
// TestSameSideProofs tests the element is not in the range covered by proofs
|
||||
func TestSameSideProofs(t *testing.T) {
|
||||
trie, vals := randomTrie(4096)
|
||||
var entries entrySlice
|
||||
for _, kv := range vals {
|
||||
entries = append(entries, kv)
|
||||
}
|
||||
sort.Sort(entries)
|
||||
|
||||
pos := 1000
|
||||
first := decreseKey(common.CopyBytes(entries[pos].k))
|
||||
first = decreseKey(first)
|
||||
last := decreseKey(common.CopyBytes(entries[pos].k))
|
||||
|
||||
proof := memorydb.New()
|
||||
if err := trie.Prove(first, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
if err := trie.Prove(last, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the last node %v", err)
|
||||
}
|
||||
err, _ := VerifyRangeProof(trie.Hash(), first, last, [][]byte{entries[pos].k}, [][]byte{entries[pos].v}, proof)
|
||||
if err == nil {
|
||||
t.Fatalf("Expected error, got nil")
|
||||
}
|
||||
|
||||
first = increseKey(common.CopyBytes(entries[pos].k))
|
||||
last = increseKey(common.CopyBytes(entries[pos].k))
|
||||
last = increseKey(last)
|
||||
|
||||
proof = memorydb.New()
|
||||
if err := trie.Prove(first, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
if err := trie.Prove(last, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the last node %v", err)
|
||||
}
|
||||
err, _ = VerifyRangeProof(trie.Hash(), first, last, [][]byte{entries[pos].k}, [][]byte{entries[pos].v}, proof)
|
||||
if err == nil {
|
||||
t.Fatalf("Expected error, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHasRightElement(t *testing.T) {
|
||||
trie := new(Trie)
|
||||
var entries entrySlice
|
||||
@ -530,38 +673,49 @@ func TestHasRightElement(t *testing.T) {
|
||||
{0, 10, true},
|
||||
{50, 100, true},
|
||||
{50, len(entries), false}, // No more element expected
|
||||
{len(entries) - 1, len(entries), false}, // Single last element
|
||||
{len(entries) - 1, len(entries), false}, // Single last element with two existent proofs(point to same key)
|
||||
{len(entries) - 1, -1, false}, // Single last element with non-existent right proof
|
||||
{0, len(entries), false}, // The whole set with existent left proof
|
||||
{-1, len(entries), false}, // The whole set with non-existent left proof
|
||||
{-1, -1, false}, // The whole set with non-existent left/right proof
|
||||
}
|
||||
for _, c := range cases {
|
||||
var (
|
||||
firstKey []byte
|
||||
start = c.start
|
||||
firstProof = memorydb.New()
|
||||
lastProof = memorydb.New()
|
||||
firstKey []byte
|
||||
lastKey []byte
|
||||
start = c.start
|
||||
end = c.end
|
||||
proof = memorydb.New()
|
||||
)
|
||||
if c.start == -1 {
|
||||
firstKey, start = common.Hash{}.Bytes(), 0
|
||||
if err := trie.Prove(firstKey, 0, firstProof); err != nil {
|
||||
if err := trie.Prove(firstKey, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
} else {
|
||||
firstKey = entries[c.start].k
|
||||
if err := trie.Prove(entries[c.start].k, 0, firstProof); err != nil {
|
||||
if err := trie.Prove(entries[c.start].k, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
}
|
||||
if err := trie.Prove(entries[c.end-1].k, 0, lastProof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
if c.end == -1 {
|
||||
lastKey, end = common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").Bytes(), len(entries)
|
||||
if err := trie.Prove(lastKey, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
} else {
|
||||
lastKey = entries[c.end-1].k
|
||||
if err := trie.Prove(entries[c.end-1].k, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
}
|
||||
k := make([][]byte, 0)
|
||||
v := make([][]byte, 0)
|
||||
for i := start; i < c.end; i++ {
|
||||
for i := start; i < end; i++ {
|
||||
k = append(k, entries[i].k)
|
||||
v = append(v, entries[i].v)
|
||||
}
|
||||
err, hasMore := VerifyRangeProof(trie.Hash(), firstKey, k, v, firstProof, lastProof)
|
||||
err, hasMore := VerifyRangeProof(trie.Hash(), firstKey, lastKey, k, v, proof)
|
||||
if err != nil {
|
||||
t.Fatalf("Expected no error, got %v", err)
|
||||
}
|
||||
@ -589,12 +743,12 @@ func TestEmptyRangeProof(t *testing.T) {
|
||||
{500, true},
|
||||
}
|
||||
for _, c := range cases {
|
||||
firstProof := memorydb.New()
|
||||
proof := memorydb.New()
|
||||
first := increseKey(common.CopyBytes(entries[c.pos].k))
|
||||
if err := trie.Prove(first, 0, firstProof); err != nil {
|
||||
if err := trie.Prove(first, 0, proof); err != nil {
|
||||
t.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
err, _ := VerifyRangeProof(trie.Hash(), first, nil, nil, firstProof, nil)
|
||||
err, _ := VerifyRangeProof(trie.Hash(), first, nil, nil, nil, proof)
|
||||
if c.err && err == nil {
|
||||
t.Fatalf("Expected error, got nil")
|
||||
}
|
||||
@ -688,11 +842,11 @@ func benchmarkVerifyRangeProof(b *testing.B, size int) {
|
||||
|
||||
start := 2
|
||||
end := start + size
|
||||
firstProof, lastProof := memorydb.New(), memorydb.New()
|
||||
if err := trie.Prove(entries[start].k, 0, firstProof); err != nil {
|
||||
proof := memorydb.New()
|
||||
if err := trie.Prove(entries[start].k, 0, proof); err != nil {
|
||||
b.Fatalf("Failed to prove the first node %v", err)
|
||||
}
|
||||
if err := trie.Prove(entries[end-1].k, 0, lastProof); err != nil {
|
||||
if err := trie.Prove(entries[end-1].k, 0, proof); err != nil {
|
||||
b.Fatalf("Failed to prove the last node %v", err)
|
||||
}
|
||||
var keys [][]byte
|
||||
@ -704,7 +858,7 @@ func benchmarkVerifyRangeProof(b *testing.B, size int) {
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
err, _ := VerifyRangeProof(trie.Hash(), keys[0], keys, values, firstProof, lastProof)
|
||||
err, _ := VerifyRangeProof(trie.Hash(), keys[0], keys[len(keys)-1], keys, values, proof)
|
||||
if err != nil {
|
||||
b.Fatalf("Case %d(%d->%d) expect no error, got %v", i, start, end-1, err)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user