diff --git a/c_src/enacl.c b/c_src/enacl.c
index b505331..3b39796 100644
--- a/c_src/enacl.c
+++ b/c_src/enacl.c
@@ -2,7 +2,7 @@
 
 #include "enacl.h"
 
-ERL_NIF_TERM enacl_error_tuplee(ErlNifEnv *env, char *error_atom) {
+ERL_NIF_TERM enacl_error_tuple(ErlNifEnv *env, char *error_atom) {
   return enif_make_tuple2(env, enif_make_atom(env, "error"),
                           enif_make_atom(env, error_atom));
 }
diff --git a/c_src/enacl.h b/c_src/enacl.h
index a343aba..e772d1d 100644
--- a/c_src/enacl.h
+++ b/c_src/enacl.h
@@ -8,6 +8,6 @@
 #define ATOM_TRUE "true"
 #define ATOM_FALSE "false"
 
-ERL_NIF_TERM enacl_error_tuplee(ErlNifEnv *, char *);
+ERL_NIF_TERM enacl_error_tuple(ErlNifEnv *, char *);
 
 #endif
diff --git a/c_src/generichash.c b/c_src/generichash.c
index 2c0a77b..eb72791 100644
--- a/c_src/generichash.c
+++ b/c_src/generichash.c
@@ -93,7 +93,7 @@ ERL_NIF_TERM enacl_crypto_generichash(ErlNifEnv *env, int argc,
   // crypto_generichash_BYTES/crypto_generichash_BYTES_MIN/crypto_generichash_BYTES_MAX
   if ((hash_size <= crypto_generichash_BYTES_MIN) ||
       (hash_size >= crypto_generichash_BYTES_MAX)) {
-    ret = enacl_error_tuplee(env, "invalid_hash_size");
+    ret = enacl_error_tuple(env, "invalid_hash_size");
     goto done;
   }
 
@@ -103,20 +103,20 @@ ERL_NIF_TERM enacl_crypto_generichash(ErlNifEnv *env, int argc,
     k = NULL;
   } else if (key.size <= crypto_generichash_KEYBYTES_MIN ||
              key.size >= crypto_generichash_KEYBYTES_MAX) {
-    ret = enacl_error_tuplee(env, "invalid_key_size");
+    ret = enacl_error_tuple(env, "invalid_key_size");
     goto done;
   }
 
   // allocate memory for hash
   if (!enif_alloc_binary(hash_size, &hash)) {
-    ret = enacl_error_tuplee(env, "alloc_failed");
+    ret = enacl_error_tuple(env, "alloc_failed");
     goto done;
   }
 
   // calculate hash
   if (0 != crypto_generichash(hash.data, hash.size, message.data, message.size,
                               k, key.size)) {
-    ret = enacl_error_tuplee(env, "hash_error");
+    ret = enacl_error_tuple(env, "hash_error");
     goto release;
   }
 
@@ -152,7 +152,7 @@ ERL_NIF_TERM enacl_crypto_generichash_init(ErlNifEnv *env, int argc,
   // Verify that hash size is valid
   if ((hash_size <= crypto_generichash_BYTES_MIN) ||
       (hash_size >= crypto_generichash_BYTES_MAX)) {
-    ret = enacl_error_tuplee(env, "invalid_hash_size");
+    ret = enacl_error_tuple(env, "invalid_hash_size");
     goto done;
   }
 
@@ -162,7 +162,7 @@ ERL_NIF_TERM enacl_crypto_generichash_init(ErlNifEnv *env, int argc,
     k = NULL;
   } else if (key.size <= crypto_generichash_KEYBYTES_MIN ||
              key.size >= crypto_generichash_KEYBYTES_MAX) {
-    ret = enacl_error_tuplee(env, "invalid_key_size");
+    ret = enacl_error_tuple(env, "invalid_key_size");
     goto done;
   }
 
@@ -189,7 +189,7 @@ ERL_NIF_TERM enacl_crypto_generichash_init(ErlNifEnv *env, int argc,
 
   // Call the library function
   if (0 != crypto_generichash_init(obj->ctx, k, key.size, obj->outlen)) {
-    ret = enacl_error_tuplee(env, "hash_init_error");
+    ret = enacl_error_tuple(env, "hash_init_error");
     goto err;
   }
 
@@ -199,7 +199,7 @@ bad_arg:
   return enif_make_badarg(env);
 
 err:
-  ret = enacl_error_tuplee(env, "internal_error");
+  ret = enacl_error_tuple(env, "internal_error");
   if (obj != NULL) {
     if (obj->alive) {
       sodium_free(obj->ctx);
@@ -231,13 +231,13 @@ ERL_NIF_TERM enacl_crypto_generichash_update(ErlNifEnv *env, int argc,
     goto bad_arg;
 
   if (!obj->alive) {
-    ret = enacl_error_tuplee(env, "finalized");
+    ret = enacl_error_tuple(env, "finalized");
     goto done;
   }
 
   // Update hash state
   if (0 != crypto_generichash_update(obj->ctx, data.data, data.size)) {
-    ret = enacl_error_tuplee(env, "hash_update_error");
+    ret = enacl_error_tuple(env, "hash_update_error");
     goto done;
   }
 
@@ -263,17 +263,17 @@ ERL_NIF_TERM enacl_crypto_generichash_final(ErlNifEnv *env, int argc,
     goto bad_arg;
 
   if (!obj->alive) {
-    ret = enacl_error_tuplee(env, "finalized");
+    ret = enacl_error_tuple(env, "finalized");
     goto done;
   }
 
   if (!enif_alloc_binary(obj->outlen, &hash)) {
-    ret = enacl_error_tuplee(env, "alloc_failed");
+    ret = enacl_error_tuple(env, "alloc_failed");
     goto done;
   }
 
   if (0 != crypto_generichash_final(obj->ctx, hash.data, hash.size)) {
-    ret = enacl_error_tuplee(env, "hash_error");
+    ret = enacl_error_tuple(env, "hash_error");
     goto release;
   }
 
diff --git a/c_src/hash.c b/c_src/hash.c
index 6475596..5820a24 100644
--- a/c_src/hash.c
+++ b/c_src/hash.c
@@ -28,7 +28,7 @@ ERL_NIF_TERM enacl_crypto_shorthash(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(crypto_shorthash_BYTES, &a)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_shorthash(a.data, m.data, m.size, k.data);
@@ -56,7 +56,7 @@ bad_arg:
   return enif_make_badarg(env);
 
 err:
-  ret = nacl_error_tuple(env, "alloc_failed");
+  ret = enacl_error_tuple(env, "alloc_failed");
 done:
   return ret;
 }
diff --git a/c_src/public.c b/c_src/public.c
index 62f6a03..05ae0c7 100644
--- a/c_src/public.c
+++ b/c_src/public.c
@@ -45,11 +45,11 @@ ERL_NIF_TERM enacl_crypto_box_keypair(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(crypto_box_PUBLICKEYBYTES, &pk)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (!enif_alloc_binary(crypto_box_SECRETKEYBYTES, &sk)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_box_keypair(pk.data, sk.data);
@@ -78,12 +78,12 @@ ERL_NIF_TERM enacl_crypto_box(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(padded_msg.size, &result)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (0 != crypto_box(result.data, padded_msg.data, padded_msg.size, nonce.data,
                       pk.data, sk.data)) {
-    return enacl_error_tuplee(env, "box_error");
+    return enacl_error_tuple(env, "box_error");
   }
 
   return enif_make_sub_binary(env, enif_make_binary(env, &result),
@@ -111,14 +111,14 @@ ERL_NIF_TERM enacl_crypto_box_open(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(padded_ciphertext.size, &result)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (0 != crypto_box_open(result.data, padded_ciphertext.data,
                            padded_ciphertext.size, nonce.data, pk.data,
                            sk.data)) {
     enif_release_binary(&result);
-    return enacl_error_tuplee(env, "failed_verification");
+    return enacl_error_tuple(env, "failed_verification");
   }
 
   return enif_make_sub_binary(env, enif_make_binary(env, &result),
@@ -140,12 +140,12 @@ ERL_NIF_TERM enacl_crypto_box_beforenm(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(crypto_box_BEFORENMBYTES, &k)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (0 != crypto_box_beforenm(k.data, pk.data, sk.data)) {
     // error
-    return enacl_error_tuplee(env, "error_gen_shared_secret");
+    return enacl_error_tuple(env, "error_gen_shared_secret");
   }
 
   return enif_make_binary(env, &k);
@@ -165,7 +165,7 @@ ERL_NIF_TERM enacl_crypto_box_afternm(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(m.size, &result)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_box_afternm(result.data, m.data, m.size, nonce.data, k.data);
@@ -189,13 +189,13 @@ ERL_NIF_TERM enacl_crypto_box_open_afternm(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(m.size, &result)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (0 != crypto_box_open_afternm(result.data, m.data, m.size, nonce.data,
                                    k.data)) {
     enif_release_binary(&result);
-    return enacl_error_tuplee(env, "failed_verification");
+    return enacl_error_tuple(env, "failed_verification");
   }
 
   return enif_make_sub_binary(env, enif_make_binary(env, &result),
@@ -220,7 +220,7 @@ ERL_NIF_TERM enacl_crypto_box_seal(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(msg.size + crypto_box_SEALBYTES, &ciphertext)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_box_seal(ciphertext.data, msg.data, msg.size, key.data);
@@ -244,13 +244,13 @@ ERL_NIF_TERM enacl_crypto_box_seal_open(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(ciphertext.size - crypto_box_SEALBYTES, &msg)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (crypto_box_seal_open(msg.data, ciphertext.data, ciphertext.size, pk.data,
                            sk.data) != 0) {
     enif_release_binary(&msg);
-    return enacl_error_tuplee(env, "failed_verification");
+    return enacl_error_tuple(env, "failed_verification");
   }
 
   return enif_make_binary(env, &msg);
diff --git a/c_src/pwhash.c b/c_src/pwhash.c
index 5f33dda..be5df5d 100644
--- a/c_src/pwhash.c
+++ b/c_src/pwhash.c
@@ -78,19 +78,19 @@ ERL_NIF_TERM enacl_crypto_pwhash(ErlNifEnv *env, int argc,
 
   // Check Salt size
   if (s.size != crypto_pwhash_SALTBYTES) {
-    return enacl_error_tuplee(env, "invalid_salt_size");
+    return enacl_error_tuple(env, "invalid_salt_size");
   }
 
   // Allocate memory for return binary
   if (!enif_alloc_binary(crypto_box_SEEDBYTES, &h)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (crypto_pwhash(h.data, h.size, (char *)p.data, p.size, s.data, o, m,
                     crypto_pwhash_ALG_DEFAULT) != 0) {
     /* out of memory */
     enif_release_binary(&h);
-    return enacl_error_tuplee(env, "out_of_memory");
+    return enacl_error_tuple(env, "out_of_memory");
   }
 
   ERL_NIF_TERM ok = enif_make_atom(env, ATOM_OK);
@@ -119,13 +119,13 @@ ERL_NIF_TERM enacl_crypto_pwhash_str(ErlNifEnv *env, int argc,
 
   // Allocate memory for return binary
   if (!enif_alloc_binary(crypto_pwhash_STRBYTES, &h)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (crypto_pwhash_str((char *)h.data, (char *)p.data, p.size, o, m) != 0) {
     /* out of memory */
     enif_release_binary(&h);
-    return enacl_error_tuplee(env, "out_of_memory");
+    return enacl_error_tuple(env, "out_of_memory");
   }
 
   ERL_NIF_TERM ok = enif_make_atom(env, ATOM_OK);
diff --git a/c_src/randombytes.c b/c_src/randombytes.c
index 015781e..5c978a8 100644
--- a/c_src/randombytes.c
+++ b/c_src/randombytes.c
@@ -15,7 +15,7 @@ ERL_NIF_TERM enif_randombytes(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(req_size, &result)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   randombytes(result.data, result.size);
diff --git a/c_src/sign.c b/c_src/sign.c
index 0dc7d30..56e1b48 100644
--- a/c_src/sign.c
+++ b/c_src/sign.c
@@ -52,19 +52,19 @@ ERL_NIF_TERM enacl_crypto_sign_init(ErlNifEnv *env, int argc,
 
   if ((obj = enif_alloc_resource(enacl_sign_ctx_rtype,
                                  sizeof(enacl_sign_ctx))) == NULL) {
-    ret = enacl_error_tuplee(env, "alloc_failed");
+    ret = enacl_error_tuple(env, "alloc_failed");
     goto done;
   }
   obj->alive = 0;
   obj->state = enif_alloc(crypto_sign_statebytes());
   if (obj->state == NULL) {
-    ret = enacl_error_tuplee(env, "state_malloc");
+    ret = enacl_error_tuple(env, "state_malloc");
     goto release;
   }
   obj->alive = 1;
 
   if (0 != crypto_sign_init(obj->state)) {
-    ret = enacl_error_tuplee(env, "sign_init_error");
+    ret = enacl_error_tuple(env, "sign_init_error");
     goto free;
   }
 
@@ -111,12 +111,12 @@ ERL_NIF_TERM enacl_crypto_sign_update(ErlNifEnv *env, int argc,
     goto bad_arg;
 
   if (!obj->alive) {
-    ret = enacl_error_tuplee(env, "finalized");
+    ret = enacl_error_tuple(env, "finalized");
     goto done;
   }
 
   if (0 != crypto_sign_update(obj->state, data.data, data.size)) {
-    ret = enacl_error_tuplee(env, "sign_update_error");
+    ret = enacl_error_tuple(env, "sign_update_error");
     goto done;
   }
 
@@ -146,17 +146,17 @@ ERL_NIF_TERM enacl_crypto_sign_final_create(ErlNifEnv *env, int argc,
     goto bad_arg;
 
   if (!obj->alive) {
-    ret = enacl_error_tuplee(env, "finalized");
+    ret = enacl_error_tuple(env, "finalized");
     goto done;
   }
 
   if (!enif_alloc_binary(crypto_sign_BYTES, &sig)) {
-    ret = enacl_error_tuplee(env, "alloc_failed");
+    ret = enacl_error_tuple(env, "alloc_failed");
     goto done;
   }
 
   if (0 != crypto_sign_final_create(obj->state, sig.data, &siglen, sk.data)) {
-    ret = enacl_error_tuplee(env, "sign_error");
+    ret = enacl_error_tuple(env, "sign_error");
     goto release;
   }
 
@@ -198,7 +198,7 @@ ERL_NIF_TERM enacl_crypto_sign_final_verify(ErlNifEnv *env, int argc,
   if (0 == crypto_sign_final_verify(obj->state, sig.data, pk.data)) {
     ret = enif_make_atom(env, ATOM_OK);
   } else {
-    ret = enacl_error_tuplee(env, "failed_verification");
+    ret = enacl_error_tuple(env, "failed_verification");
   }
   // Mark as done
   goto cleanup;
@@ -226,11 +226,11 @@ enacl_crypto_sign_ed25519_keypair(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(crypto_sign_ed25519_PUBLICKEYBYTES, &pk)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (!enif_alloc_binary(crypto_sign_ed25519_SECRETKEYBYTES, &sk)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_sign_ed25519_keypair(pk.data, sk.data);
@@ -250,11 +250,11 @@ enacl_crypto_sign_ed25519_sk_to_pk(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(crypto_sign_ed25519_PUBLICKEYBYTES, &pk)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (crypto_sign_ed25519_sk_to_pk(pk.data, sk.data) != 0) {
-    return enacl_error_tuplee(env, "crypto_sign_ed25519_sk_to_pk_failed");
+    return enacl_error_tuple(env, "crypto_sign_ed25519_sk_to_pk_failed");
   }
 
   return enif_make_binary(env, &pk);
@@ -271,12 +271,12 @@ enacl_crypto_sign_ed25519_public_to_curve25519(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(crypto_scalarmult_curve25519_BYTES, &curve25519_pk)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (crypto_sign_ed25519_pk_to_curve25519(curve25519_pk.data,
                                            ed25519_pk.data) != 0) {
-    return enacl_error_tuplee(env, "ed25519_public_to_curve25519_failed");
+    return enacl_error_tuple(env, "ed25519_public_to_curve25519_failed");
   }
 
   return enif_make_binary(env, &curve25519_pk);
@@ -293,12 +293,12 @@ enacl_crypto_sign_ed25519_secret_to_curve25519(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(crypto_scalarmult_curve25519_BYTES, &curve25519_sk)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (crypto_sign_ed25519_sk_to_curve25519(curve25519_sk.data,
                                            ed25519_sk.data) != 0) {
-    return enacl_error_tuplee(env, "ed25519_secret_to_curve25519_failed");
+    return enacl_error_tuple(env, "ed25519_secret_to_curve25519_failed");
   }
 
   return enif_make_binary(env, &curve25519_sk);
@@ -340,11 +340,11 @@ ERL_NIF_TERM enacl_crypto_sign_keypair(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(crypto_sign_PUBLICKEYBYTES, &pk)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (!enif_alloc_binary(crypto_sign_SECRETKEYBYTES, &sk)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_sign_keypair(pk.data, sk.data);
@@ -362,11 +362,11 @@ ERL_NIF_TERM enacl_crypto_sign_seed_keypair(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(crypto_sign_PUBLICKEYBYTES, &pk)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (!enif_alloc_binary(crypto_sign_SECRETKEYBYTES, &sk)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_sign_seed_keypair(pk.data, sk.data, seed.data);
@@ -395,7 +395,7 @@ ERL_NIF_TERM enacl_crypto_sign(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(m.size + crypto_sign_BYTES, &sm)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_sign(sm.data, &smlen, m.data, m.size, sk.data);
@@ -423,14 +423,14 @@ ERL_NIF_TERM enacl_crypto_sign_open(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(sm.size, &m)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (0 == crypto_sign_open(m.data, &mlen, sm.data, sm.size, pk.data)) {
     return enif_make_sub_binary(env, enif_make_binary(env, &m), 0, mlen);
   } else {
     enif_release_binary(&m);
-    return enacl_error_tuplee(env, "failed_verification");
+    return enacl_error_tuple(env, "failed_verification");
   }
 }
 
@@ -454,7 +454,7 @@ ERL_NIF_TERM enacl_crypto_sign_detached(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(crypto_sign_BYTES, &sig)) {
-    return enacl_error_tuplee(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_sign_detached(sig.data, &siglen, m.data, m.size, sk.data);