Use pkg/errors for all errors

Author: ethanfrey

go/ops.go

@@ -7,67 +7,71 @@ import (
 	_ "crypto/sha256"
 	// adds sha512 capability to crypto.SHA512
 	_ "crypto/sha512"
-	fmt "fmt"
 
 	// adds ripemd160 capability to crypto.RIPEMD160
 	_ "golang.org/x/crypto/ripemd160"
+	
+	"github.com/pkg/errors"
 )
 
+// Apply will calculate the leaf hash given the key and value being proven
 func (op *LeafOp) Apply(key []byte, value []byte) ([]byte, error) {
 	if len(key) == 0 {
-		return nil, fmt.Errorf("Leaf op needs key")
+		return nil, errors.New("Leaf op needs key")
 	}
 	if len(value) == 0 {
-		return nil, fmt.Errorf("Leaf op needs value")
+		return nil, errors.New("Leaf op needs value")
 	}
 	pkey, err := prepareLeafData(op.PrehashKey, op.Length, key)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "prehash key")
 	}
 	pvalue, err := prepareLeafData(op.PrehashValue, op.Length, value)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "prehash value")
 	}
 	data := append(op.Prefix, pkey...)
 	data = append(data, pvalue...)
 	return doHash(op.Hash, data)
 }
 
+// CheckAgainstSpec will verify the LeafOp is in the format defined in spec
 func (op *LeafOp)CheckAgainstSpec(spec *ProofSpec) error {
 	lspec := spec.LeafSpec
 
 	if op.Hash != lspec.Hash {
-		return fmt.Errorf("Unexpected HashOp: %d", op.Hash)
+		return errors.Errorf("Unexpected HashOp: %d", op.Hash)
 	}
 	if op.PrehashKey != lspec.PrehashKey {
-		return fmt.Errorf("Unexpected PrehashKey: %d", op.PrehashKey)
+		return errors.Errorf("Unexpected PrehashKey: %d", op.PrehashKey)
 	}
 	if op.PrehashValue != lspec.PrehashValue {
-		return fmt.Errorf("Unexpected PrehashValue: %d", op.PrehashValue)
+		return errors.Errorf("Unexpected PrehashValue: %d", op.PrehashValue)
 	}
 	if op.Length != lspec.Length {
-		return fmt.Errorf("Unexpected LengthOp: %d", op.Length)
+		return errors.Errorf("Unexpected LengthOp: %d", op.Length)
 	}
 	if !bytes.HasPrefix(op.Prefix, lspec.Prefix) {
-		return fmt.Errorf("Leaf Prefix doesn't start with %X", lspec.Prefix)
+		return errors.Errorf("Leaf Prefix doesn't start with %X", lspec.Prefix)
 	}
 	return nil
 }
 
-
+// Apply will calculate the hash of the next step, given the hash of the previous step
 func (op *InnerOp) Apply(child []byte) ([]byte, error) {
 	if len(child) == 0 {
-		return nil, fmt.Errorf("Inner op needs child value")
+		return nil, errors.Errorf("Inner op needs child value")
 	}
 	preimage := append(op.Prefix, child...)
 	preimage = append(preimage, op.Suffix...)
 	return doHash(op.Hash, preimage)
 }
 
-func (inner *InnerOp)CheckAgainstSpec(spec *ProofSpec) error {
+// CheckAgainstSpec will verify the InnerOp is in the format defined in spec
+func (op *InnerOp)CheckAgainstSpec(spec *ProofSpec) error {
 	leafPrefix := spec.LeafSpec.Prefix
-	if bytes.HasPrefix(inner.Prefix, leafPrefix) {
-		return fmt.Errorf("Inner Prefix starts with %X", leafPrefix)
+	if bytes.HasPrefix(op.Prefix, leafPrefix) {
+		return errors.Errorf("Inner Prefix starts with %X", leafPrefix)
 	}
 	return nil
 }
@@ -117,7 +121,7 @@ func doHash(hashOp HashOp, preimage []byte) ([]byte, error) {
 		hash.Write(tmp)
 		return hash.Sum(nil), nil
 	}
-	return nil, fmt.Errorf("Unsupported hashop: %d", hashOp)
+	return nil, errors.Errorf("Unsupported hashop: %d", hashOp)
 }
 
 // doLengthOp will calculate the proper prefix and return it prepended
@@ -131,12 +135,12 @@ func doLengthOp(lengthOp LengthOp, data []byte) ([]byte, error) {
 		return res, nil
 	case LengthOp_REQUIRE_32_BYTES:
 		if len(data) != 32 {
-			return nil, fmt.Errorf("Data was %d bytes, not 32", len(data))
+			return nil, errors.Errorf("Data was %d bytes, not 32", len(data))
 		}
 		return data, nil
 	case LengthOp_REQUIRE_64_BYTES:
 		if len(data) != 64 {
-			return nil, fmt.Errorf("Data was %d bytes, not 64", len(data))
+			return nil, errors.Errorf("Data was %d bytes, not 64", len(data))
 		}
 		return data, nil
 		// TODO
@@ -146,7 +150,7 @@ func doLengthOp(lengthOp LengthOp, data []byte) ([]byte, error) {
 		// case LengthOp_FIXED32_LITTLE:
 		// case LengthOp_FIXED64_LITTLE:
 	}
-	return nil, fmt.Errorf("Unsupported lengthop: %d", lengthOp)
+	return nil, errors.Errorf("Unsupported lengthop: %d", lengthOp)
 }
 
 func encodeVarintProto(l int) []byte {

go/proof.go

@@ -2,7 +2,6 @@ package proofs
 
 import (
 	"bytes"
-	"fmt"
 
 	"github.com/pkg/errors"
 )
@@ -53,42 +52,42 @@ func (p *ExistenceProof) Verify(spec *ProofSpec, root CommitmentRoot, key []byte
 
 }
 
-
 // Calculate determines the root hash that matches the given proof.
 // You must validate the result is what you have in a header.
 // Returns error if the calculations cannot be performed.
 func (p *ExistenceProof) Calculate() (CommitmentRoot, error) {
 	if p.GetLeaf() == nil {
-		return nil, fmt.Errorf("Existence Proof needs defined LeafOp")
+		return nil, errors.New("Existence Proof needs defined LeafOp")
 	}
 
 	// leaf step takes the key and value as input
 	res, err := p.Leaf.Apply(p.Key, p.Value)
 	if err != nil {
-		return nil, err
+		return nil, errors.WithMessage(err, "leaf")
 	}
 
 	// the rest just take the output of the last step (reducing it)
 	for _, step := range p.Path {
 		res, err = step.Apply(res)
 		if err != nil {
-			return nil, err
+			return nil, errors.WithMessage(err, "inner")
 		}
 	}
 	return res, nil
 }
 
+// CheckAgainstSpec will verify the leaf and all path steps are in the format defined in spec
 func (p *ExistenceProof) CheckAgainstSpec(spec *ProofSpec) error {
 	if p.GetLeaf() == nil {
-		return fmt.Errorf("Existence Proof needs defined LeafOp")
+		return errors.New("Existence Proof needs defined LeafOp")
 	}
 	err := p.Leaf.CheckAgainstSpec(spec)
 	if err != nil {
-		return err
+		return errors.WithMessage(err, "leaf")
 	}
 	for _, inner := range p.Path {
 		if err := inner.CheckAgainstSpec(spec); err != nil {
-			return err
+			return errors.WithMessage(err, "inner")
 		}
 	}
 	return nil