forked from cosmos/iavl
-
Notifications
You must be signed in to change notification settings - Fork 0
/
proof_path.go
127 lines (108 loc) · 2.74 KB
/
proof_path.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
package iavl
import (
"bytes"
"fmt"
"strings"
cmn "github.com/tendermint/tendermint/libs/common"
)
// pathWithLeaf is a path to a leaf node and the leaf node itself.
type pathWithLeaf struct {
Path PathToLeaf `json:"path"`
Leaf proofLeafNode `json:"leaf"`
}
func (pwl pathWithLeaf) String() string {
return pwl.StringIndented("")
}
func (pwl pathWithLeaf) StringIndented(indent string) string {
return fmt.Sprintf(`pathWithLeaf{
%s Path: %v
%s Leaf: %v
%s}`,
indent, pwl.Path.StringIndented(indent+" "),
indent, pwl.Leaf.StringIndented(indent+" "),
indent)
}
func (pwl pathWithLeaf) verify(root []byte) cmn.Error {
return pwl.Path.verify(pwl.Leaf.Hash(), root)
}
//----------------------------------------
// PathToLeaf represents an inner path to a leaf node.
// Note that the nodes are ordered such that the last one is closest
// to the root of the tree.
type PathToLeaf []proofInnerNode
func (pl PathToLeaf) String() string {
return pl.StringIndented("")
}
func (pl PathToLeaf) StringIndented(indent string) string {
if len(pl) == 0 {
return "empty-PathToLeaf"
}
strs := make([]string, len(pl))
for i, pin := range pl {
if i == 20 {
strs[i] = fmt.Sprintf("... (%v total)", len(pl))
break
}
strs[i] = fmt.Sprintf("%v:%v", i, pin.StringIndented(indent+" "))
}
return fmt.Sprintf(`PathToLeaf{
%s %v
%s}`,
indent, strings.Join(strs, "\n"+indent+" "),
indent)
}
// verify checks that the leaf node's hash + the inner nodes merkle-izes to the
// given root. If it returns an error, it means the leafHash or the PathToLeaf
// is incorrect.
func (pl PathToLeaf) verify(leafHash []byte, root []byte) cmn.Error {
hash := leafHash
for i := len(pl) - 1; i >= 0; i-- {
pin := pl[i]
hash = pin.Hash(hash)
}
if !bytes.Equal(root, hash) {
return cmn.ErrorWrap(ErrInvalidProof, "")
}
return nil
}
func (pl PathToLeaf) isLeftmost() bool {
for _, node := range pl {
if len(node.Left) > 0 {
return false
}
}
return true
}
func (pl PathToLeaf) isRightmost() bool {
for _, node := range pl {
if len(node.Right) > 0 {
return false
}
}
return true
}
func (pl PathToLeaf) isEmpty() bool {
return pl == nil || len(pl) == 0
}
func (pl PathToLeaf) dropRoot() PathToLeaf {
if pl.isEmpty() {
return pl
}
return PathToLeaf(pl[:len(pl)-1])
}
func (pl PathToLeaf) hasCommonRoot(pl2 PathToLeaf) bool {
if pl.isEmpty() || pl2.isEmpty() {
return false
}
leftEnd := pl[len(pl)-1]
rightEnd := pl2[len(pl2)-1]
return bytes.Equal(leftEnd.Left, rightEnd.Left) &&
bytes.Equal(leftEnd.Right, rightEnd.Right)
}
func (pl PathToLeaf) isLeftAdjacentTo(pl2 PathToLeaf) bool {
for pl.hasCommonRoot(pl2) {
pl, pl2 = pl.dropRoot(), pl2.dropRoot()
}
pl, pl2 = pl.dropRoot(), pl2.dropRoot()
return pl.isRightmost() && pl2.isLeftmost()
}