Rename "nacl_error_tuple" -> "enacl_error_tuple"

The new name is consistent where the old name was not.

c_src/aead.c

@@ -57,14 +57,14 @@ enacl_crypto_aead_chacha20poly1305_encrypt(ErlNifEnv *env, int argc,
   if (!enif_alloc_binary(message.size +
                              crypto_aead_chacha20poly1305_ietf_ABYTES,
                          &ciphertext)) {
-    ret = nacl_error_tuple(env, "alloc_failed");
+    ret = enacl_error_tuple(env, "alloc_failed");
     goto done;
   }
 
   if (crypto_aead_chacha20poly1305_ietf_encrypt(
           ciphertext.data, NULL, message.data, message.size, ad.data, ad.size,
           NULL, nonce.data, key.data) < 0) {
-    ret = nacl_error_tuple(env, "aead_chacha20poly1305_ietf_encrypt_failed");
+    ret = enacl_error_tuple(env, "aead_chacha20poly1305_ietf_encrypt_failed");
     goto release;
   }
 
@@ -106,14 +106,14 @@ enacl_crypto_aead_chacha20poly1305_decrypt(ErlNifEnv *env, int argc,
   if (!enif_alloc_binary(ciphertext.size -
                              crypto_aead_chacha20poly1305_ietf_ABYTES,
                          &message)) {
-    ret = nacl_error_tuple(env, "alloc_failed");
+    ret = enacl_error_tuple(env, "alloc_failed");
     goto done;
   }
 
   if (crypto_aead_chacha20poly1305_ietf_decrypt(
           message.data, NULL, NULL, ciphertext.data, ciphertext.size, ad.data,
           ad.size, nonce.data, key.data) < 0) {
-    ret = nacl_error_tuple(env, "aead_chacha20poly1305_ietf_decrypt_failed");
+    ret = enacl_error_tuple(env, "aead_chacha20poly1305_ietf_decrypt_failed");
     goto release;
   }
 
@@ -172,13 +172,13 @@ enacl_crypto_aead_xchacha20poly1305_encrypt(ErlNifEnv *env, int argc,
   if (!enif_alloc_binary(message.size +
                              crypto_aead_xchacha20poly1305_ietf_ABYTES,
                          &ciphertext)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (crypto_aead_xchacha20poly1305_ietf_encrypt(
           ciphertext.data, NULL, message.data, message.size, ad.data, ad.size,
           NULL, nonce.data, key.data) < 0) {
-    return nacl_error_tuple(env, "aead_xchacha20poly1305_ietf_encrypt_failed");
+    return enacl_error_tuple(env, "aead_xchacha20poly1305_ietf_encrypt_failed");
   }
 
   return enif_make_binary(env, &ciphertext);
@@ -202,13 +202,13 @@ enacl_crypto_aead_xchacha20poly1305_decrypt(ErlNifEnv *env, int argc,
   if (!enif_alloc_binary(ciphertext.size -
                              crypto_aead_xchacha20poly1305_ietf_ABYTES,
                          &message)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (crypto_aead_xchacha20poly1305_ietf_decrypt(
           message.data, NULL, NULL, ciphertext.data, ciphertext.size, ad.data,
           ad.size, nonce.data, key.data) < 0) {
-    return nacl_error_tuple(env, "aead_xchacha20poly1305_ietf_decrypt_failed");
+    return enacl_error_tuple(env, "aead_xchacha20poly1305_ietf_decrypt_failed");
   }
 
   return enif_make_binary(env, &message);

c_src/enacl.c

@@ -2,7 +2,7 @@
 
 #include "enacl.h"
 
-ERL_NIF_TERM nacl_error_tuple(ErlNifEnv *env, char *error_atom) {
+ERL_NIF_TERM enacl_error_tuplee(ErlNifEnv *env, char *error_atom) {
   return enif_make_tuple2(env, enif_make_atom(env, "error"),
                           enif_make_atom(env, error_atom));
 }

c_src/enacl.h

@@ -8,6 +8,6 @@
 #define ATOM_TRUE "true"
 #define ATOM_FALSE "false"
 
-ERL_NIF_TERM nacl_error_tuple(ErlNifEnv *, char *);
+ERL_NIF_TERM enacl_error_tuplee(ErlNifEnv *, char *);
 
 #endif

c_src/enacl_nif.c

@@ -121,12 +121,12 @@ enacl_crypto_curve25519_scalarmult(ErlNifEnv *env, int argc,
 
   do {
     if (!enif_alloc_binary(crypto_scalarmult_curve25519_BYTES, &output)) {
-      result = nacl_error_tuple(env, "alloc_failed");
+      result = enacl_error_tuple(env, "alloc_failed");
       continue;
     }
 
     if (crypto_scalarmult_curve25519(output.data, secret.data, bp) < 0) {
-      result = nacl_error_tuple(env, "scalarmult_curve25519_failed");
+      result = enacl_error_tuple(env, "scalarmult_curve25519_failed");
       continue;
     }
 
@@ -151,12 +151,12 @@ enacl_crypto_curve25519_scalarmult_base(ErlNifEnv *env, int argc,
 
   do {
     if (!enif_alloc_binary(crypto_scalarmult_curve25519_BYTES, &output)) {
-      result = nacl_error_tuple(env, "alloc_failed");
+      result = enacl_error_tuple(env, "alloc_failed");
       continue;
     }
 
     if (crypto_scalarmult_curve25519_base(output.data, secret.data) < 0) {
-      result = nacl_error_tuple(env, "scalarmult_curve25519_base_failed");
+      result = enacl_error_tuple(env, "scalarmult_curve25519_base_failed");
       continue;
     }
 
@@ -238,7 +238,7 @@ static ERL_NIF_TERM enif_scramble_block_16(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(in.size, &out)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_block(out.data, in.data, key.data);

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 = nacl_error_tuple(env, "invalid_hash_size");
+    ret = enacl_error_tuplee(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 = nacl_error_tuple(env, "invalid_key_size");
+    ret = enacl_error_tuplee(env, "invalid_key_size");
     goto done;
   }
 
   // allocate memory for hash
   if (!enif_alloc_binary(hash_size, &hash)) {
-    ret = nacl_error_tuple(env, "alloc_failed");
+    ret = enacl_error_tuplee(env, "alloc_failed");
     goto done;
   }
 
   // calculate hash
   if (0 != crypto_generichash(hash.data, hash.size, message.data, message.size,
                               k, key.size)) {
-    ret = nacl_error_tuple(env, "hash_error");
+    ret = enacl_error_tuplee(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 = nacl_error_tuple(env, "invalid_hash_size");
+    ret = enacl_error_tuplee(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 = nacl_error_tuple(env, "invalid_key_size");
+    ret = enacl_error_tuplee(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 = nacl_error_tuple(env, "hash_init_error");
+    ret = enacl_error_tuplee(env, "hash_init_error");
     goto err;
   }
 
@@ -199,7 +199,7 @@ bad_arg:
   return enif_make_badarg(env);
 
 err:
-  ret = nacl_error_tuple(env, "internal_error");
+  ret = enacl_error_tuplee(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 = nacl_error_tuple(env, "finalized");
+    ret = enacl_error_tuplee(env, "finalized");
     goto done;
   }
 
   // Update hash state
   if (0 != crypto_generichash_update(obj->ctx, data.data, data.size)) {
-    ret = nacl_error_tuple(env, "hash_update_error");
+    ret = enacl_error_tuplee(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 = nacl_error_tuple(env, "finalized");
+    ret = enacl_error_tuplee(env, "finalized");
     goto done;
   }
 
   if (!enif_alloc_binary(obj->outlen, &hash)) {
-    ret = nacl_error_tuple(env, "alloc_failed");
+    ret = enacl_error_tuplee(env, "alloc_failed");
     goto done;
   }
 
   if (0 != crypto_generichash_final(obj->ctx, hash.data, hash.size)) {
-    ret = nacl_error_tuple(env, "hash_error");
+    ret = enacl_error_tuplee(env, "hash_error");
     goto release;
   }
 

c_src/kx.c

@@ -31,12 +31,12 @@ ERL_NIF_TERM enacl_crypto_kx_keypair(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(crypto_kx_PUBLICKEYBYTES, &pk)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (!enif_alloc_binary(crypto_kx_SECRETKEYBYTES, &sk)) {
     enif_release_binary(&pk);
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_kx_keypair(pk.data, sk.data);
@@ -68,19 +68,19 @@ enacl_crypto_kx_server_session_keys(ErlNifEnv *env, int argc,
     goto bad_arg;
 
   if (!enif_alloc_binary(crypto_kx_SESSIONKEYBYTES, &rx)) {
-    ret = nacl_error_tuple(env, "alloc_failed");
+    ret = enacl_error_tuple(env, "alloc_failed");
     goto done;
   }
 
   if (!enif_alloc_binary(crypto_kx_SESSIONKEYBYTES, &tx)) {
-    ret = nacl_error_tuple(env, "alloc_failed");
+    ret = enacl_error_tuple(env, "alloc_failed");
     goto release_rx;
   }
 
   if (0 != crypto_kx_server_session_keys(rx.data, tx.data, server_pk.data,
                                          server_sk.data, client_pk.data)) {
     // suspicious client public key
-    ret = nacl_error_tuple(env, "invalid_client_public_key");
+    ret = enacl_error_tuple(env, "invalid_client_public_key");
     goto release_tx;
   }
 
@@ -121,19 +121,19 @@ enacl_crypto_kx_client_session_keys(ErlNifEnv *env, int argc,
     goto bad_arg;
 
   if (!enif_alloc_binary(crypto_kx_SESSIONKEYBYTES, &rx)) {
-    ret = nacl_error_tuple(env, "alloc_failed");
+    ret = enacl_error_tuple(env, "alloc_failed");
     goto done;
   }
 
   if (!enif_alloc_binary(crypto_kx_SESSIONKEYBYTES, &tx)) {
-    ret = nacl_error_tuple(env, "alloc_failed");
+    ret = enacl_error_tuple(env, "alloc_failed");
     goto release_rx;
   }
 
   if (0 != crypto_kx_client_session_keys(rx.data, tx.data, client_pk.data,
                                          client_sk.data, server_pk.data)) {
     // suspicious server public key
-    ret = nacl_error_tuple(env, "invalid_server_public_key");
+    ret = enacl_error_tuple(env, "invalid_server_public_key");
     goto release_tx;
   }
 

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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(env, "alloc_failed");
   }
 
   if (!enif_alloc_binary(crypto_box_SECRETKEYBYTES, &sk)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(env, "alloc_failed");
   }
 
   if (0 != crypto_box(result.data, padded_msg.data, padded_msg.size, nonce.data,
                       pk.data, sk.data)) {
-    return nacl_error_tuple(env, "box_error");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "failed_verification");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(env, "alloc_failed");
   }
 
   if (0 != crypto_box_beforenm(k.data, pk.data, sk.data)) {
     // error
-    return nacl_error_tuple(env, "error_gen_shared_secret");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(env, "alloc_failed");
   }
 
   if (0 != crypto_box_open_afternm(result.data, m.data, m.size, nonce.data,
                                    k.data)) {
     enif_release_binary(&result);
-    return nacl_error_tuple(env, "failed_verification");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(env, "alloc_failed");
   }
 
   if (crypto_box_seal_open(msg.data, ciphertext.data, ciphertext.size, pk.data,
                            sk.data) != 0) {
     enif_release_binary(&msg);
-    return nacl_error_tuple(env, "failed_verification");
+    return enacl_error_tuplee(env, "failed_verification");
   }
 
   return enif_make_binary(env, &msg);

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 nacl_error_tuple(env, "invalid_salt_size");
+    return enacl_error_tuplee(env, "invalid_salt_size");
   }
 
   // Allocate memory for return binary
   if (!enif_alloc_binary(crypto_box_SEEDBYTES, &h)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "out_of_memory");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "out_of_memory");
+    return enacl_error_tuplee(env, "out_of_memory");
   }
 
   ERL_NIF_TERM ok = enif_make_atom(env, ATOM_OK);

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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(env, "alloc_failed");
   }
 
   randombytes(result.data, result.size);

c_src/secret.c

@@ -91,7 +91,7 @@ ERL_NIF_TERM enacl_crypto_secretbox(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(padded_msg.size, &padded_ciphertext)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_secretbox(padded_ciphertext.data, padded_msg.data, padded_msg.size,
@@ -120,14 +120,14 @@ ERL_NIF_TERM enacl_crypto_secretbox_open(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(padded_ciphertext.size, &padded_msg)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   if (crypto_secretbox_open(padded_msg.data, padded_ciphertext.data,
                             padded_ciphertext.size, nonce.data,
                             key.data) != 0) {
     enif_release_binary(&padded_msg);
-    return nacl_error_tuple(env, "failed_verification");
+    return enacl_error_tuple(env, "failed_verification");
   }
 
   return enif_make_sub_binary(
@@ -152,7 +152,7 @@ ERL_NIF_TERM enacl_crypto_stream_chacha20(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(clen, &c)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_stream_chacha20(c.data, c.size, n.data, k.data);
@@ -177,7 +177,7 @@ enacl_crypto_stream_chacha20_xor(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(m.size, &c)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_stream_chacha20_xor(c.data, m.data, m.size, n.data, k.data);
@@ -202,7 +202,7 @@ ERL_NIF_TERM enacl_crypto_stream(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(clen, &c)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_stream(c.data, c.size, n.data, k.data);
@@ -226,7 +226,7 @@ ERL_NIF_TERM enacl_crypto_stream_xor(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(m.size, &c)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_stream_xor(c.data, m.data, m.size, n.data, k.data);
@@ -248,7 +248,7 @@ ERL_NIF_TERM enacl_crypto_auth(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(crypto_auth_BYTES, &a)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_auth(a.data, m.data, m.size, k.data);
@@ -291,7 +291,7 @@ ERL_NIF_TERM enacl_crypto_onetimeauth(ErlNifEnv *env, int argc,
   }
 
   if (!enif_alloc_binary(crypto_onetimeauth_BYTES, &a)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuple(env, "alloc_failed");
   }
 
   crypto_onetimeauth(a.data, m.data, m.size, k.data);

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 = nacl_error_tuple(env, "alloc_failed");
+    ret = enacl_error_tuplee(env, "alloc_failed");
     goto done;
   }
   obj->alive = 0;
   obj->state = enif_alloc(crypto_sign_statebytes());
   if (obj->state == NULL) {
-    ret = nacl_error_tuple(env, "state_malloc");
+    ret = enacl_error_tuplee(env, "state_malloc");
     goto release;
   }
   obj->alive = 1;
 
   if (0 != crypto_sign_init(obj->state)) {
-    ret = nacl_error_tuple(env, "sign_init_error");
+    ret = enacl_error_tuplee(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 = nacl_error_tuple(env, "finalized");
+    ret = enacl_error_tuplee(env, "finalized");
     goto done;
   }
 
   if (0 != crypto_sign_update(obj->state, data.data, data.size)) {
-    ret = nacl_error_tuple(env, "sign_update_error");
+    ret = enacl_error_tuplee(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 = nacl_error_tuple(env, "finalized");
+    ret = enacl_error_tuplee(env, "finalized");
     goto done;
   }
 
   if (!enif_alloc_binary(crypto_sign_BYTES, &sig)) {
-    ret = nacl_error_tuple(env, "alloc_failed");
+    ret = enacl_error_tuplee(env, "alloc_failed");
     goto done;
   }
 
   if (0 != crypto_sign_final_create(obj->state, sig.data, &siglen, sk.data)) {
-    ret = nacl_error_tuple(env, "sign_error");
+    ret = enacl_error_tuplee(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 = nacl_error_tuple(env, "failed_verification");
+    ret = enacl_error_tuplee(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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(env, "alloc_failed");
   }
 
   if (!enif_alloc_binary(crypto_sign_ed25519_SECRETKEYBYTES, &sk)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(env, "alloc_failed");
   }
 
   if (crypto_sign_ed25519_sk_to_pk(pk.data, sk.data) != 0) {
-    return nacl_error_tuple(env, "crypto_sign_ed25519_sk_to_pk_failed");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(env, "alloc_failed");
   }
 
   if (crypto_sign_ed25519_pk_to_curve25519(curve25519_pk.data,
                                            ed25519_pk.data) != 0) {
-    return nacl_error_tuple(env, "ed25519_public_to_curve25519_failed");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(env, "alloc_failed");
   }
 
   if (crypto_sign_ed25519_sk_to_curve25519(curve25519_sk.data,
                                            ed25519_sk.data) != 0) {
-    return nacl_error_tuple(env, "ed25519_secret_to_curve25519_failed");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(env, "alloc_failed");
   }
 
   if (!enif_alloc_binary(crypto_sign_SECRETKEYBYTES, &sk)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(env, "alloc_failed");
   }
 
   if (!enif_alloc_binary(crypto_sign_SECRETKEYBYTES, &sk)) {
-    return nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "failed_verification");
+    return enacl_error_tuplee(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 nacl_error_tuple(env, "alloc_failed");
+    return enacl_error_tuplee(env, "alloc_failed");
   }
 
   crypto_sign_detached(sig.data, &siglen, m.data, m.size, sk.data);