Support for Enums (#42)

* add support for enums

* fix tests

* fix tests

Author: vedhavyas

examples/documents/documents.go

@@ -1,6 +1,6 @@
 package documentspb
 
-//go:generate protoc -I $PROTOBUF/src/ -I. -I $GOPATH/src --go_out=$GOPATH/src/ examples.proto
+//go:generate protoc -I $PROTOBUF/src/ -I. -I $GOPATH/src --go_out=$GOPATH/src/ example.proto
 
 import (
 	"time"
@@ -26,6 +26,8 @@ var ExampleDocumentSalts SaltedExampleDocument = SaltedExampleDocument{
 	ValueBytes1:     salt,
 	ValueCamelCased: salt,
 	ValueNotIgnored: salt,
+	ValueMap:        salt,
+	EnumType:        salt,
 }
 
 var ExampleTimeString string = "2018-04-10T01:23:12.697116Z"
@@ -79,32 +81,32 @@ var ExampleSaltedNestedRepeatedDocument = SaltedNestedRepeatedDocument{
 	ValueD:       &SaltedTwoLevelItem{ValueA: &SaltedSimpleItem{ValueA: salt}, ValueB: salt},
 }
 
-var ExampleSimpleMapDocument = SimpleMapDocument {
-    ValueA: "ValueAA",
-    ValueB: "ValueBB",
-    ValueC: map[string]string{
-        "ValueCAKey": "ValueCAValue",
-        "ValueCBKey": "ValueCBValue",
-    },
-    ValueD: map[int32]string{
-        -1: "negative one",
-        0: "zero",
-        1: "one",
-    },
+var ExampleSimpleMapDocument = SimpleMapDocument{
+	ValueA: "ValueAA",
+	ValueB: "ValueBB",
+	ValueC: map[string]string{
+		"ValueCAKey": "ValueCAValue",
+		"ValueCBKey": "ValueCBValue",
+	},
+	ValueD: map[int32]string{
+		-1: "negative one",
+		0:  "zero",
+		1:  "one",
+	},
 }
 
-var ExampleSaltedSimpleMapDocument = SaltedSimpleMapDocument {
-    ValueA: salt,
-    ValueB: salt,
-    ValueC: map[string][]byte{
-        "ValueCAKey": salt,
-        "ValueCBKey": salt,
-    },
-    ValueCLength: salt,
-    ValueD: map[int32][]byte{
-        -1: salt,
-        0: salt,
-        1: salt,
-    },
-    ValueDLength: salt,
+var ExampleSaltedSimpleMapDocument = SaltedSimpleMapDocument{
+	ValueA: salt,
+	ValueB: salt,
+	ValueC: map[string][]byte{
+		"ValueCAKey": salt,
+		"ValueCBKey": salt,
+	},
+	ValueCLength: salt,
+	ValueD: map[int32][]byte{
+		-1: salt,
+		0:  salt,
+		1:  salt,
+	},
+	ValueDLength: salt,
 }

examples/documents/example.pb.go

@@ -26,6 +26,7 @@ message ExampleDocument {
   bytes value_not_hashed = 9 [
     (proofs.hashed_field) = true
   ];
+  Enum enum_type = 10;
 }
 
 message AllFieldTypes {
@@ -274,4 +275,10 @@ message SaltedExampleDocument {
   bytes ValueCamelCased = 6;
   bytes value_not_ignored = 7;
   bytes valueMap = 10;
+  bytes enum_type = 11;
+}
+
+enum Enum {
+  type_one = 0;
+  type_two = 1;
 }

examples/documents/example.proto

@@ -11,42 +11,43 @@ import (
 	"github.com/centrifuge/precise-proofs/proofs"
 )
 
-func printError(err error) {
-	if err != nil {
-		fmt.Printf("There was an error: [%v]\n", err)
-	}
-}
-
 func main() {
 	// ExampleDocument is a protobuf message
 	document := documentspb.ExampleDocument{
 		Value1:      1,
 		ValueA:      "Foo",
 		ValueB:      "Bar",
 		ValueBytes1: []byte("foobar"),
+		EnumType:    documentspb.Enum_type_two,
 	}
 
 	// The FillSalts method is a helper function that fills all fields with 32
 	// random bytes. SaltedExampleDocument is a protobuf message that has the
 	// same structure as ExampleDocument but has all `bytes` field types.
 	salts := documentspb.SaltedExampleDocument{}
-	proofs.FillSalts(&document, &salts)
+	checkErr(proofs.FillSalts(&document, &salts))
 
 	doctree := proofs.NewDocumentTree(proofs.TreeOptions{Hash: sha256.New()})
 
-	doctree.AddLeavesFromDocument(&document, &salts)
-	doctree.Generate()
+	checkErr(doctree.AddLeavesFromDocument(&document, &salts))
+	checkErr(doctree.Generate())
 	fmt.Printf("Generated tree: %s\n", doctree.String())
 
 	// Generate the actual proof for a field. In this case the field called "ValueA".
-	proof, err := doctree.CreateProof("valueA")
-	printError(err)
+	proof, err := doctree.CreateProof("enum_type")
+	checkErr(err)
 	proofJson, _ := json.Marshal(proof)
 	fmt.Println("Proof:\n", string(proofJson))
 
 	// Validate the proof that was just generated
 	valid, err := doctree.ValidateProof(&proof)
-	printError(err)
+	checkErr(err)
 
 	fmt.Printf("Proof validated: %v\n", valid)
 }
+
+func checkErr(err error) {
+	if err != nil {
+		panic(err)
+	}
+}

examples/simple.go

@@ -188,6 +188,12 @@ func (f *messageFlattener) valueToString(value interface{}) (s string, err error
 		}
 		return ptypes.TimestampString(v), nil
 	default:
+		// special case for enums
+		rv := reflect.ValueOf(value)
+		if rv.Kind() == reflect.Int32 {
+			return strconv.FormatInt(rv.Int(), 10), nil
+		}
+
 		return "", errors.Errorf("Got unsupported value of type %T", v)
 	}
 }

proofs/flatten.go

@@ -306,8 +306,8 @@ func (doctree *DocumentTree) AddLeavesFromDocument(document, salts proto.Message
 	if err != nil {
 		return err
 	}
-	err = doctree.AddLeaves(leaves)
-	return err
+
+	return doctree.AddLeaves(leaves)
 }
 
 // Generate calculated the merkle root with all supplied leaves. This method can only be called once and makes
@@ -319,9 +319,13 @@ func (doctree *DocumentTree) Generate() error {
 
 	hashes := make([][]byte, len(doctree.leaves))
 	for i, leaf := range doctree.leaves {
-		if (!leaf.Hashed) || (len(leaf.Hash) == 0) {
-			leaf.HashNode(doctree.hash, doctree.compactProperties)
+		if len(leaf.Hash) < 1 || leaf.Hashed {
+			err := leaf.HashNode(doctree.hash, doctree.compactProperties)
+			if err != nil {
+				return err
+			}
 		}
+
 		hashes[i] = leaf.Hash
 	}
 	err := doctree.merkleTree.Generate(hashes, doctree.hash)
@@ -413,7 +417,6 @@ func (doctree *DocumentTree) CreateProof(prop string) (proof proofspb.Proof, err
 // pickHashesFromMerkleTree takes the required hashes needed to create a proof
 func (doctree *DocumentTree) pickHashesFromMerkleTree(leaf uint64) (hashes []*proofspb.MerkleHash, err error) {
 	proofNodes, err := CalculateProofNodeList(leaf, uint64(len(doctree.merkleTree.Leaves())))
-
 	if err != nil {
 		return hashes, err
 	}
@@ -466,15 +469,6 @@ func (doctree *DocumentTree) ValidateProof(proof *proofspb.Proof) (valid bool, e
 	return
 }
 
-func dereferencePointer(value interface{}) interface{} {
-	reflectValue := reflect.Indirect(reflect.ValueOf(value))
-	if !reflectValue.IsValid() {
-		return nil
-	}
-
-	return reflectValue.Interface()
-}
-
 // LeafNode represents a field that can be hashed to create a merkle tree
 type LeafNode struct {
 	Property Property
@@ -490,13 +484,14 @@ type LeafNode struct {
 // HashNode calculates the hash of a node provided it isn't already calculated.
 func (n *LeafNode) HashNode(h hash.Hash, compact bool) error {
 	if len(n.Hash) > 0 || n.Hashed {
-		return errors.New("Hash already set")
+		return nil
 	}
 
 	payload, err := ConcatValues(n.Property.Name(compact), n.Value, n.Salt)
 	if err != nil {
 		return err
 	}
+
 	defer h.Reset()
 	_, err = h.Write(payload)
 	if err != nil {