Skip to content

Commit b9df890

Browse files
ethanfreyethanfrey
committed
Update go code with new format
1 parent 48932ef commit b9df890

File tree

5 files changed

+119
-507
lines changed

5 files changed

+119
-507
lines changed

‎go/ops.go

+1-32
Original file line numberDiff line numberDiff line change
@@ -7,42 +7,11 @@ import (
77
// adds sha512 capability to crypto.SHA512
88
_ "crypto/sha512"
99
fmt "fmt"
10+
1011
// adds ripemd160 capability to crypto.RIPEMD160
1112
_ "golang.org/x/crypto/ripemd160"
1213
)
1314

14-
func WrapLeaf(leaf *LeafOp) *ProofOp {
15-
return &ProofOp{
16-
Op: &ProofOp_Leaf{
17-
Leaf: leaf,
18-
},
19-
}
20-
}
21-
22-
func WrapInner(inner *InnerOp) *ProofOp {
23-
return &ProofOp{
24-
Op: &ProofOp_Inner{
25-
Inner: inner,
26-
},
27-
}
28-
}
29-
30-
func asLeaf(op *ProofOp) (*LeafOp, error) {
31-
leaf, ok := op.Op.(*ProofOp_Leaf)
32-
if !ok {
33-
return nil, fmt.Errorf("op is not leaf")
34-
}
35-
return leaf.Leaf, nil
36-
}
37-
38-
func asInner(op *ProofOp) (*InnerOp, error) {
39-
inner, ok := op.Op.(*ProofOp_Inner)
40-
if !ok {
41-
return nil, fmt.Errorf("op is not inner")
42-
}
43-
return inner.Inner, nil
44-
}
45-
4615
func (op *LeafOp) Apply(key []byte, value []byte) ([]byte, error) {
4716
if len(key) == 0 {
4817
return nil, fmt.Errorf("Leaf op needs key")

‎go/proof.go

+8-30
Original file line numberDiff line numberDiff line change
@@ -18,19 +18,18 @@ var IavlSpec = &ProofSpec{
1818
// You must validate the result is what you have in a header.
1919
// Returns error if the calculations cannot be performed.
2020
func (p *ExistenceProof) Calculate() ([]byte, error) {
21-
leaf, inners, err := p.TypeCastSteps()
22-
if err != nil {
23-
return nil, err
21+
if p.GetLeaf() == nil {
22+
return nil, fmt.Errorf("Existence Proof needs defined LeafOp")
2423
}
2524

2625
// leaf step takes the key and value as input
27-
res, err := leaf.Apply(p.Key, p.Value)
26+
res, err := p.Leaf.Apply(p.Key, p.Value)
2827
if err != nil {
2928
return nil, err
3029
}
3130

3231
// the rest just take the output of the last step (reducing it)
33-
for _, step := range inners {
32+
for _, step := range p.Path {
3433
res, err = step.Apply(res)
3534
if err != nil {
3635
return nil, err
@@ -40,42 +39,21 @@ func (p *ExistenceProof) Calculate() ([]byte, error) {
4039
}
4140

4241
func (p *ExistenceProof) CheckAgainstSpec(spec *ProofSpec) error {
43-
leaf, inners, err := p.TypeCastSteps()
44-
if err != nil {
45-
return err
42+
if p.GetLeaf() == nil {
43+
return fmt.Errorf("Existence Proof needs defined LeafOp")
4644
}
47-
err = checkLeaf(leaf, spec.LeafSpec)
45+
err := checkLeaf(p.Leaf, spec.LeafSpec)
4846
if err != nil {
4947
return err
5048
}
51-
for _, inner := range inners {
49+
for _, inner := range p.Path {
5250
if err := checkInner(inner, spec.LeafSpec.Prefix); err != nil {
5351
return err
5452
}
5553
}
5654
return nil
5755
}
5856

59-
func (p *ExistenceProof) TypeCastSteps() (*LeafOp, []*InnerOp, error) {
60-
if len(p.Steps) == 0 {
61-
return nil, nil, fmt.Errorf("Existence Proof needs at least one step")
62-
}
63-
leafOp, inners := p.Steps[0], p.Steps[1:]
64-
leaf, err := asLeaf(leafOp)
65-
if err != nil {
66-
return nil, nil, err
67-
}
68-
var result []*InnerOp
69-
for _, innerOp := range inners {
70-
inner, err := asInner(innerOp)
71-
if err != nil {
72-
return nil, nil, err
73-
}
74-
result = append(result, inner)
75-
}
76-
return leaf, result, nil
77-
}
78-
7957
func checkLeaf(leaf *LeafOp, spec *LeafOp) error {
8058
if leaf.Hash != spec.Hash {
8159
return fmt.Errorf("Unexpected HashOp: %d", leaf.Hash)

‎go/proof_test.go

+34-61
Original file line numberDiff line numberDiff line change
@@ -23,11 +23,9 @@ func TestExistenceProof(t *testing.T) {
2323
proof: &ExistenceProof{
2424
Key: []byte("food"),
2525
Value: []byte("some longer text"),
26-
Steps: []*ProofOp{
27-
WrapLeaf(&LeafOp{
28-
Hash: HashOp_SHA256,
29-
Length: LengthOp_VAR_PROTO,
30-
}),
26+
Leaf: &LeafOp{
27+
Hash: HashOp_SHA256,
28+
Length: LengthOp_VAR_PROTO,
3129
},
3230
},
3331
expected: fromHex("b68f5d298e915ae1753dd333da1f9cf605411a5f2e12516be6758f365e6db265"),
@@ -38,10 +36,8 @@ func TestExistenceProof(t *testing.T) {
3836
proof: &ExistenceProof{
3937
Key: append([]byte{4}, []byte("food")...),
4038
Value: append([]byte{16}, []byte("some longer text")...),
41-
Steps: []*ProofOp{
42-
WrapLeaf(&LeafOp{
43-
Hash: HashOp_SHA256,
44-
}),
39+
Leaf: &LeafOp{
40+
Hash: HashOp_SHA256,
4541
},
4642
},
4743
expected: fromHex("b68f5d298e915ae1753dd333da1f9cf605411a5f2e12516be6758f365e6db265"),
@@ -50,59 +46,40 @@ func TestExistenceProof(t *testing.T) {
5046
proof: &ExistenceProof{
5147
Key: append([]byte("od"), byte(16)),
5248
Value: []byte("some longer text"),
53-
Steps: []*ProofOp{
54-
WrapLeaf(&LeafOp{
55-
Prefix: []byte{4, 'f', 'o'},
56-
Hash: HashOp_SHA256,
57-
}),
49+
Leaf: &LeafOp{
50+
Prefix: []byte{4, 'f', 'o'},
51+
Hash: HashOp_SHA256,
5852
},
5953
},
6054
expected: fromHex("b68f5d298e915ae1753dd333da1f9cf605411a5f2e12516be6758f365e6db265"),
6155
},
62-
"cannot execute two leafs": {
63-
proof: &ExistenceProof{
64-
Key: []byte("food"),
65-
Value: []byte("some longer text"),
66-
Steps: []*ProofOp{
67-
WrapLeaf(&LeafOp{
68-
Hash: HashOp_SHA256,
69-
Length: LengthOp_VAR_PROTO,
70-
}),
71-
WrapLeaf(&LeafOp{
72-
Hash: HashOp_SHA256,
73-
Length: LengthOp_VAR_PROTO,
74-
}),
75-
},
76-
},
77-
isErr: true,
78-
},
7956
"cannot execute inner first": {
8057
proof: &ExistenceProof{
8158
Key: []byte("food"),
8259
Value: []byte("some longer text"),
83-
Steps: []*ProofOp{
84-
WrapInner(&InnerOp{
60+
Path: []*InnerOp{
61+
&InnerOp{
8562
Hash: HashOp_SHA256,
8663
Prefix: fromHex("deadbeef00cafe00"),
87-
}),
64+
},
8865
},
8966
},
9067
isErr: true,
9168
},
92-
"executes lead then inner op": {
69+
"executes leaf then inner op": {
9370
proof: &ExistenceProof{
9471
Key: []byte("food"),
9572
Value: []byte("some longer text"),
96-
Steps: []*ProofOp{
97-
WrapLeaf(&LeafOp{
98-
Hash: HashOp_SHA256,
99-
Length: LengthOp_VAR_PROTO,
100-
}),
101-
// output: b68f5d298e915ae1753dd333da1f9cf605411a5f2e12516be6758f365e6db265
102-
WrapInner(&InnerOp{
73+
Leaf: &LeafOp{
74+
Hash: HashOp_SHA256,
75+
Length: LengthOp_VAR_PROTO,
76+
},
77+
// output: b68f5d298e915ae1753dd333da1f9cf605411a5f2e12516be6758f365e6db265
78+
Path: []*InnerOp{
79+
&InnerOp{
10380
Hash: HashOp_SHA256,
10481
Prefix: fromHex("deadbeef00cafe00"),
105-
}),
82+
},
10683
// echo -n deadbeef00cafe00b68f5d298e915ae1753dd333da1f9cf605411a5f2e12516be6758f365e6db265 | xxd -r -p | sha256sum
10784
},
10885
},
@@ -259,13 +236,13 @@ func TestCheckLeaf(t *testing.T) {
259236
}
260237

261238
func TestCheckAgainstSpec(t *testing.T) {
262-
validInner := WrapInner(&InnerOp{
239+
validInner := &InnerOp{
263240
Prefix: fromHex("aa"),
264-
})
265-
invalidInner := WrapInner(&InnerOp{
241+
}
242+
invalidInner := &InnerOp{
266243
Prefix: fromHex("00aa"),
267244
Suffix: fromHex("bb"),
268-
})
245+
}
269246

270247
cases := map[string]struct {
271248
proof *ExistenceProof
@@ -284,22 +261,18 @@ func TestCheckAgainstSpec(t *testing.T) {
284261
proof: &ExistenceProof{
285262
Key: []byte("food"),
286263
Value: []byte("bar"),
287-
Steps: []*ProofOp{
288-
WrapLeaf(IavlSpec.LeafSpec),
289-
},
264+
Leaf: IavlSpec.LeafSpec,
290265
},
291266
spec: IavlSpec,
292267
},
293268
"rejects invalid leaf": {
294269
proof: &ExistenceProof{
295270
Key: []byte("food"),
296271
Value: []byte("bar"),
297-
Steps: []*ProofOp{
298-
WrapLeaf(&LeafOp{
299-
Prefix: []byte{0},
300-
Hash: HashOp_SHA256,
301-
Length: LengthOp_VAR_PROTO,
302-
}),
272+
Leaf: &LeafOp{
273+
Prefix: []byte{0},
274+
Hash: HashOp_SHA256,
275+
Length: LengthOp_VAR_PROTO,
303276
},
304277
},
305278
spec: IavlSpec,
@@ -309,7 +282,7 @@ func TestCheckAgainstSpec(t *testing.T) {
309282
proof: &ExistenceProof{
310283
Key: []byte("food"),
311284
Value: []byte("bar"),
312-
Steps: []*ProofOp{
285+
Path: []*InnerOp{
313286
validInner,
314287
},
315288
},
@@ -320,8 +293,8 @@ func TestCheckAgainstSpec(t *testing.T) {
320293
proof: &ExistenceProof{
321294
Key: []byte("food"),
322295
Value: []byte("bar"),
323-
Steps: []*ProofOp{
324-
WrapLeaf(IavlSpec.LeafSpec),
296+
Leaf: IavlSpec.LeafSpec,
297+
Path: []*InnerOp{
325298
validInner,
326299
validInner,
327300
},
@@ -332,8 +305,8 @@ func TestCheckAgainstSpec(t *testing.T) {
332305
proof: &ExistenceProof{
333306
Key: []byte("food"),
334307
Value: []byte("bar"),
335-
Steps: []*ProofOp{
336-
WrapLeaf(IavlSpec.LeafSpec),
308+
Leaf: IavlSpec.LeafSpec,
309+
Path: []*InnerOp{
337310
validInner,
338311
invalidInner,
339312
validInner,

0 commit comments

Comments
 (0)