44 "bytes"
55 "crypto"
66 "encoding/binary"
7+ "errors"
8+ "fmt"
79
810 // adds sha256 capability to crypto.SHA256
911 _ "crypto/sha256"
@@ -12,8 +14,6 @@ import (
1214
1315 // adds ripemd160 capability to crypto.RIPEMD160
1416 _ "golang.org/x/crypto/ripemd160"
15-
16- "github.com/pkg/errors"
1717)
1818
1919// Apply will calculate the leaf hash given the key and value being proven
@@ -26,11 +26,11 @@ func (op *LeafOp) Apply(key []byte, value []byte) ([]byte, error) {
2626 }
2727 pkey , err := prepareLeafData (op .PrehashKey , op .Length , key )
2828 if err != nil {
29- return nil , errors . Wrap ( err , "prehash key" )
29+ return nil , fmt . Errorf ( "prehash key, %w" , err )
3030 }
3131 pvalue , err := prepareLeafData (op .PrehashValue , op .Length , value )
3232 if err != nil {
33- return nil , errors . Wrap ( err , "prehash value" )
33+ return nil , fmt . Errorf ( "prehash value, %w" , err )
3434 }
3535 data := append (op .Prefix , pkey ... )
3636 data = append (data , pvalue ... )
@@ -42,27 +42,27 @@ func (op *LeafOp) CheckAgainstSpec(spec *ProofSpec) error {
4242 lspec := spec .LeafSpec
4343
4444 if op .Hash != lspec .Hash {
45- return errors .Errorf ("Unexpected HashOp: %d" , op .Hash )
45+ return fmt .Errorf ("Unexpected HashOp: %d" , op .Hash )
4646 }
4747 if op .PrehashKey != lspec .PrehashKey {
48- return errors .Errorf ("Unexpected PrehashKey: %d" , op .PrehashKey )
48+ return fmt .Errorf ("Unexpected PrehashKey: %d" , op .PrehashKey )
4949 }
5050 if op .PrehashValue != lspec .PrehashValue {
51- return errors .Errorf ("Unexpected PrehashValue: %d" , op .PrehashValue )
51+ return fmt .Errorf ("Unexpected PrehashValue: %d" , op .PrehashValue )
5252 }
5353 if op .Length != lspec .Length {
54- return errors .Errorf ("Unexpected LengthOp: %d" , op .Length )
54+ return fmt .Errorf ("Unexpected LengthOp: %d" , op .Length )
5555 }
5656 if ! bytes .HasPrefix (op .Prefix , lspec .Prefix ) {
57- return errors .Errorf ("Leaf Prefix doesn't start with %X" , lspec .Prefix )
57+ return fmt .Errorf ("Leaf Prefix doesn't start with %X" , lspec .Prefix )
5858 }
5959 return nil
6060}
6161
6262// Apply will calculate the hash of the next step, given the hash of the previous step
6363func (op * InnerOp ) Apply (child []byte ) ([]byte , error ) {
6464 if len (child ) == 0 {
65- return nil , errors .Errorf ("Inner op needs child value" )
65+ return nil , errors .New ("Inner op needs child value" )
6666 }
6767 preimage := append (op .Prefix , child ... )
6868 preimage = append (preimage , op .Suffix ... )
@@ -72,19 +72,19 @@ func (op *InnerOp) Apply(child []byte) ([]byte, error) {
7272// CheckAgainstSpec will verify the InnerOp is in the format defined in spec
7373func (op * InnerOp ) CheckAgainstSpec (spec * ProofSpec ) error {
7474 if op .Hash != spec .InnerSpec .Hash {
75- return errors .Errorf ("Unexpected HashOp: %d" , op .Hash )
75+ return fmt .Errorf ("Unexpected HashOp: %d" , op .Hash )
7676 }
7777
7878 leafPrefix := spec .LeafSpec .Prefix
7979 if bytes .HasPrefix (op .Prefix , leafPrefix ) {
80- return errors .Errorf ("Inner Prefix starts with %X" , leafPrefix )
80+ return fmt .Errorf ("Inner Prefix starts with %X" , leafPrefix )
8181 }
8282 if len (op .Prefix ) < int (spec .InnerSpec .MinPrefixLength ) {
83- return errors .Errorf ("InnerOp prefix too short (%d)" , len (op .Prefix ))
83+ return fmt .Errorf ("InnerOp prefix too short (%d)" , len (op .Prefix ))
8484 }
8585 maxLeftChildBytes := (len (spec .InnerSpec .ChildOrder ) - 1 ) * int (spec .InnerSpec .ChildSize )
8686 if len (op .Prefix ) > int (spec .InnerSpec .MaxPrefixLength )+ maxLeftChildBytes {
87- return errors .Errorf ("InnerOp prefix too long (%d)" , len (op .Prefix ))
87+ return fmt .Errorf ("InnerOp prefix too long (%d)" , len (op .Prefix ))
8888 }
8989 return nil
9090}
@@ -137,11 +137,12 @@ func doHash(hashOp HashOp, preimage []byte) ([]byte, error) {
137137 hash .Write (preimage )
138138 return hash .Sum (nil ), nil
139139 }
140- return nil , errors .Errorf ("Unsupported hashop: %d" , hashOp )
140+ return nil , fmt .Errorf ("Unsupported hashop: %d" , hashOp )
141141}
142142
143143// doLengthOp will calculate the proper prefix and return it prepended
144- // doLengthOp(op, data) -> length(data) || data
144+ //
145+ // doLengthOp(op, data) -> length(data) || data
145146func doLengthOp (lengthOp LengthOp , data []byte ) ([]byte , error ) {
146147 switch lengthOp {
147148 case LengthOp_NO_PREFIX :
@@ -151,12 +152,12 @@ func doLengthOp(lengthOp LengthOp, data []byte) ([]byte, error) {
151152 return res , nil
152153 case LengthOp_REQUIRE_32_BYTES :
153154 if len (data ) != 32 {
154- return nil , errors .Errorf ("Data was %d bytes, not 32" , len (data ))
155+ return nil , fmt .Errorf ("Data was %d bytes, not 32" , len (data ))
155156 }
156157 return data , nil
157158 case LengthOp_REQUIRE_64_BYTES :
158159 if len (data ) != 64 {
159- return nil , errors .Errorf ("Data was %d bytes, not 64" , len (data ))
160+ return nil , fmt .Errorf ("Data was %d bytes, not 64" , len (data ))
160161 }
161162 return data , nil
162163 case LengthOp_FIXED32_LITTLE :
@@ -170,7 +171,7 @@ func doLengthOp(lengthOp LengthOp, data []byte) ([]byte, error) {
170171 // case LengthOp_FIXED64_BIG:
171172 // case LengthOp_FIXED64_LITTLE:
172173 }
173- return nil , errors .Errorf ("Unsupported lengthop: %d" , lengthOp )
174+ return nil , fmt .Errorf ("Unsupported lengthop: %d" , lengthOp )
174175}
175176
176177func encodeVarintProto (l int ) []byte {
0 commit comments