refactor: return errors instead of bools and add String funcs

rln/rln.go

@@ -192,7 +192,7 @@ func (r *RLN) Verify(data []byte, proof RateLimitProof) bool {
 }
 
 // InsertMember adds the member to the tree
-func (r *RLN) InsertMember(idComm IDCommitment) bool {
+func (r *RLN) InsertMember(idComm IDCommitment) error {
 	buf := toBuffer(idComm[:])
 
 	size := int(unsafe.Sizeof(buf))
@@ -200,15 +200,22 @@ func (r *RLN) InsertMember(idComm IDCommitment) bool {
 	*in = buf
 
 	res := C.update_next_member(r.ptr, in)
-	return bool(res)
+
+	if !bool(res) {
+		return errors.New("couldn't insert member")
+	}
+	return nil
 }
 
 // DeleteMember removes an IDCommitment key from the tree. The index
 // parameter is the position of the id commitment key to be deleted from the tree.
 // The deleted id commitment key is replaced with a zero leaf
-func (r *RLN) DeleteMember(index MembershipIndex) bool {
+func (r *RLN) DeleteMember(index MembershipIndex) error {
 	deletionSuccess := bool(C.delete_member(r.ptr, C.ulong(index)))
-	return deletionSuccess
+	if !bool(deletionSuccess) {
+		return errors.New("couldn't delete member")
+	}
+	return nil
 }
 
 // GetMerkleRoot reads the Merkle Tree root after insertion
@@ -233,13 +240,13 @@ func (r *RLN) GetMerkleRoot() (MerkleNode, error) {
 }
 
 // AddAll adds members to the Merkle tree
-func (r *RLN) AddAll(list []IDCommitment) bool {
+func (r *RLN) AddAll(list []IDCommitment) error {
 	for _, member := range list {
-		if !r.InsertMember(member) {
-			return false
+		if err := r.InsertMember(member); err != nil {
+			return err
 		}
 	}
-	return true
+	return nil
 }
 
 // CalcMerkleRoot returns the root of the Merkle tree that is computed from the supplied list
@@ -251,8 +258,8 @@ func CalcMerkleRoot(list []IDCommitment, params []byte) (MerkleNode, error) {
 
 	// create a Merkle tree
 	for _, c := range list {
-		if !rln.InsertMember(c) {
-			return MerkleNode{}, errors.New("could not add member")
+		if err := rln.InsertMember(c); err != nil {
+			return MerkleNode{}, err
 		}
 	}
 
@@ -280,8 +287,8 @@ func CreateMembershipList(n int, params []byte) ([]MembershipKeyPair, MerkleNode
 		output = append(output, *keypair)
 
 		// insert the key to the Merkle tree
-		if !rln.InsertMember(keypair.IDCommitment) {
-			return nil, MerkleNode{}, errors.New("could not insert member")
+		if err := rln.InsertMember(keypair.IDCommitment); err != nil {
+			return nil, MerkleNode{}, err
 		}
 	}
 

rln/rln_test.go

@@ -74,16 +74,16 @@ func (s *RLNSuite) TestInsertMember() {
 	keypair, err := rln.MembershipKeyGen()
 	s.NoError(err)
 
-	inserted := rln.InsertMember(keypair.IDCommitment)
-	s.True(inserted)
+	err = rln.InsertMember(keypair.IDCommitment)
+	s.NoError(err)
 }
 
 func (s *RLNSuite) TestRemoveMember() {
 	rln, err := NewRLNWithDepth(32, s.parameters)
 	s.NoError(err)
 
-	deleted := rln.DeleteMember(MembershipIndex(0))
-	s.True(deleted)
+	err = rln.DeleteMember(MembershipIndex(0))
+	s.NoError(err)
 }
 
 func (s *RLNSuite) TestMerkleTreeConsistenceBetweenDeletionAndInsertion() {
@@ -97,8 +97,8 @@ func (s *RLNSuite) TestMerkleTreeConsistenceBetweenDeletionAndInsertion() {
 	keypair, err := rln.MembershipKeyGen()
 	s.NoError(err)
 
-	inserted := rln.InsertMember(keypair.IDCommitment)
-	s.True(inserted)
+	err = rln.InsertMember(keypair.IDCommitment)
+	s.NoError(err)
 
 	// read the Merkle Tree root after insertion
 	root2, err := rln.GetMerkleRoot()
@@ -107,8 +107,8 @@ func (s *RLNSuite) TestMerkleTreeConsistenceBetweenDeletionAndInsertion() {
 
 	// delete the first member
 	deleted_member_index := MembershipIndex(0)
-	deleted := rln.DeleteMember(deleted_member_index)
-	s.True(deleted)
+	err = rln.DeleteMember(deleted_member_index)
+	s.NoError(err)
 
 	// read the Merkle Tree root after the deletion
 	root3, err := rln.GetMerkleRoot()
@@ -180,18 +180,18 @@ func (s *RLNSuite) TestValidProof() {
 
 	// Create a Merkle tree with random members
 	for i := 0; i < 10; i++ {
-		memberIsAdded := false
+		var err error
 		if i == index {
 			// insert the current peer's pk
-			memberIsAdded = rln.InsertMember(memKeys.IDCommitment)
+			err = rln.InsertMember(memKeys.IDCommitment)
 		} else {
 			// create a new key pair
 			memberKeys, err := rln.MembershipKeyGen()
 			s.NoError(err)
 
-			memberIsAdded = rln.InsertMember(memberKeys.IDCommitment)
+			err = rln.InsertMember(memberKeys.IDCommitment)
 		}
-		s.True(memberIsAdded)
+		s.NoError(err)
 	}
 
 	// prepare the message
@@ -222,18 +222,18 @@ func (s *RLNSuite) TestInvalidProof() {
 
 	// Create a Merkle tree with random members
 	for i := 0; i < 10; i++ {
-		memberIsAdded := false
+		var err error
 		if i == index {
 			// insert the current peer's pk
-			memberIsAdded = rln.InsertMember(memKeys.IDCommitment)
+			err = rln.InsertMember(memKeys.IDCommitment)
 		} else {
 			// create a new key pair
 			memberKeys, err := rln.MembershipKeyGen()
 			s.NoError(err)
 
-			memberIsAdded = rln.InsertMember(memberKeys.IDCommitment)
+			err = rln.InsertMember(memberKeys.IDCommitment)
 		}
-		s.True(memberIsAdded)
+		s.NoError(err)
 	}
 
 	// prepare the message

rln/types.go

@@ -3,22 +3,43 @@ package rln
 import (
 	"bytes"
 	"encoding/binary"
+	"encoding/hex"
 	"time"
 )
 
 // IDKey is an identity key as defined in https://hackmd.io/tMTLMYmTR5eynw2lwK9n1w?view#Membership
 type IDKey [32]byte
 
+func (i IDKey) String() string {
+	return hex.EncodeToString(i[:])
+}
+
 // IDCommintment is hash of identity key as defined in https://hackmd.io/tMTLMYmTR5eynw2lwK9n1w?view#Membership
 type IDCommitment [32]byte
 
+func (i IDCommitment) String() string {
+	return hex.EncodeToString(i[:])
+}
+
 // Each node of the Merkle tee is a Poseidon hash which is a 32 byte value
 type MerkleNode [32]byte
 
+func (m MerkleNode) String() string {
+	return hex.EncodeToString(m[:])
+}
+
 type Nullifier [32]byte
 
+func (n Nullifier) String() string {
+	return hex.EncodeToString(n[:])
+}
+
 type ZKSNARK [256]byte
 
+func (z ZKSNARK) String() string {
+	return hex.EncodeToString(z[:])
+}
+
 // Custom data types defined for waku rln relay -------------------------
 
 type MembershipKeyPair struct {