diff --git a/c_src/aead.c b/c_src/aead.c
index 24a71f1..055c222 100644
--- a/c_src/aead.c
+++ b/c_src/aead.c
@@ -131,85 +131,122 @@ done:
  * AEAD XChaCha20 Poly1305
  */
 ERL_NIF_TERM
-enacl_crypto_aead_xchacha20poly1305_KEYBYTES(ErlNifEnv *env, int argc,
-                                             ERL_NIF_TERM const argv[]) {
+enacl_crypto_aead_xchacha20poly1305_ietf_KEYBYTES(ErlNifEnv *env, int argc,
+                                                  ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_aead_xchacha20poly1305_ietf_KEYBYTES);
 }
 
 ERL_NIF_TERM
-enacl_crypto_aead_xchacha20poly1305_NPUBBYTES(ErlNifEnv *env, int argc,
-                                              ERL_NIF_TERM const argv[]) {
+enacl_crypto_aead_xchacha20poly1305_ietf_NPUBBYTES(ErlNifEnv *env, int argc,
+                                                   ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_aead_xchacha20poly1305_ietf_NPUBBYTES);
 }
 
 ERL_NIF_TERM
-enacl_crypto_aead_xchacha20poly1305_ABYTES(ErlNifEnv *env, int argc,
-                                           ERL_NIF_TERM const argv[]) {
+enacl_crypto_aead_xchacha20poly1305_ietf_ABYTES(ErlNifEnv *env, int argc,
+                                                ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_aead_xchacha20poly1305_ietf_ABYTES);
 }
 
 ERL_NIF_TERM
-enacl_crypto_aead_xchacha20poly1305_MESSAGEBYTES_MAX(
+enacl_crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX(
     ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env,
                          crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX);
 }
 
 ERL_NIF_TERM
-enacl_crypto_aead_xchacha20poly1305_encrypt(ErlNifEnv *env, int argc,
-                                            ERL_NIF_TERM const argv[]) {
+enacl_crypto_aead_xchacha20poly1305_ietf_encrypt(ErlNifEnv *env, int argc,
+                                                 ERL_NIF_TERM const argv[]) {
   ErlNifBinary key, nonce, ad, message, ciphertext;
+  ERL_NIF_TERM ret;
 
-  if ((argc != 4) || (!enif_inspect_binary(env, argv[0], &key)) ||
-      (!enif_inspect_binary(env, argv[1], &nonce)) ||
-      (!enif_inspect_binary(env, argv[2], &ad)) ||
-      (!enif_inspect_binary(env, argv[3], &message)) ||
-      (key.size != crypto_aead_xchacha20poly1305_ietf_KEYBYTES) ||
-      (nonce.size != crypto_aead_xchacha20poly1305_ietf_NPUBBYTES)) {
-    return enif_make_badarg(env);
-  }
+  if (argc != 4)
+    goto bad_arg;
+  if (!enif_inspect_binary(env, argv[0], &message))
+    goto bad_arg;
+  if (!enif_inspect_binary(env, argv[1], &ad))
+    goto bad_arg;
+  if (!enif_inspect_binary(env, argv[2], &nonce))
+    goto bad_arg;
+  if (!enif_inspect_binary(env, argv[3], &key))
+    goto bad_arg;
+
+  if (key.size != crypto_aead_xchacha20poly1305_ietf_KEYBYTES)
+    goto bad_arg;
+  if (nonce.size != crypto_aead_xchacha20poly1305_ietf_NPUBBYTES)
+    goto bad_arg;
 
   if (!enif_alloc_binary(message.size +
                              crypto_aead_xchacha20poly1305_ietf_ABYTES,
                          &ciphertext)) {
-    return enacl_error_tuple(env, "alloc_failed");
+    ret = enacl_error_tuple(env, "alloc_failed");
+    goto done;
   }
 
   if (crypto_aead_xchacha20poly1305_ietf_encrypt(
           ciphertext.data, NULL, message.data, message.size, ad.data, ad.size,
           NULL, nonce.data, key.data) < 0) {
-    return enacl_error_tuple(env, "aead_xchacha20poly1305_ietf_encrypt_failed");
+    ret = enacl_error_tuple(env, "aead_xchacha20poly1305_ietf_encrypt_failed");
+    goto release;
   }
 
-  return enif_make_binary(env, &ciphertext);
+  ret = enif_make_binary(env, &ciphertext);
+  goto done;
+
+bad_arg:
+  return enif_make_badarg(env);
+release:
+  enif_release_binary(&ciphertext);
+done:
+  return ret;
 }
 
 ERL_NIF_TERM
-enacl_crypto_aead_xchacha20poly1305_decrypt(ErlNifEnv *env, int argc,
-                                            ERL_NIF_TERM const argv[]) {
+enacl_crypto_aead_xchacha20poly1305_ietf_decrypt(ErlNifEnv *env, int argc,
+                                                 ERL_NIF_TERM const argv[]) {
   ErlNifBinary key, nonce, ad, message, ciphertext;
+  ERL_NIF_TERM ret;
 
-  if ((argc != 4) || (!enif_inspect_binary(env, argv[0], &key)) ||
-      (!enif_inspect_binary(env, argv[1], &nonce)) ||
-      (!enif_inspect_binary(env, argv[2], &ad)) ||
-      (!enif_inspect_binary(env, argv[3], &ciphertext)) ||
-      (ciphertext.size < crypto_aead_xchacha20poly1305_ietf_ABYTES) ||
-      (key.size != crypto_aead_xchacha20poly1305_ietf_KEYBYTES) ||
-      (nonce.size != crypto_aead_xchacha20poly1305_ietf_NPUBBYTES)) {
-    return enif_make_badarg(env);
-  }
+  if (argc != 4)
+    goto bad_arg;
+  if (!enif_inspect_binary(env, argv[0], &ciphertext))
+    goto bad_arg;
+  if (!enif_inspect_binary(env, argv[1], &ad))
+    goto bad_arg;
+  if (!enif_inspect_binary(env, argv[2], &nonce))
+    goto bad_arg;
+  if (!enif_inspect_binary(env, argv[3], &key))
+    goto bad_arg;
+
+  if (ciphertext.size < crypto_aead_xchacha20poly1305_ietf_ABYTES)
+    goto bad_arg;
+  if (key.size != crypto_aead_xchacha20poly1305_ietf_KEYBYTES)
+    goto bad_arg;
+  if (nonce.size != crypto_aead_xchacha20poly1305_ietf_NPUBBYTES)
+    goto bad_arg;
 
   if (!enif_alloc_binary(ciphertext.size -
                              crypto_aead_xchacha20poly1305_ietf_ABYTES,
                          &message)) {
-    return enacl_error_tuple(env, "alloc_failed");
+    ret = enacl_error_tuple(env, "alloc_failed");
+    goto done;
   }
 
   if (crypto_aead_xchacha20poly1305_ietf_decrypt(
           message.data, NULL, NULL, ciphertext.data, ciphertext.size, ad.data,
           ad.size, nonce.data, key.data) < 0) {
-    return enacl_error_tuple(env, "aead_xchacha20poly1305_ietf_decrypt_failed");
+    ret = enacl_error_tuple(env, "aead_xchacha20poly1305_ietf_decrypt_failed");
+    goto release;
   }
 
-  return enif_make_binary(env, &message);
+  ret = enif_make_binary(env, &message);
+  goto done;
+
+bad_arg:
+  return enif_make_badarg(env);
+release:
+  enif_release_binary(&message);
+done:
+  return ret;
 }
diff --git a/c_src/aead.h b/c_src/aead.h
index 948cc3d..1591b24 100644
--- a/c_src/aead.h
+++ b/c_src/aead.h
@@ -25,22 +25,22 @@ enacl_crypto_aead_chacha20poly1305_ietf_decrypt(ErlNifEnv *env, int argc,
 
 /* AEAD XChaCha20 Poly1305 */
 ERL_NIF_TERM
-enacl_crypto_aead_xchacha20poly1305_KEYBYTES(ErlNifEnv *env, int argc,
-                                             ERL_NIF_TERM const argv[]);
+enacl_crypto_aead_xchacha20poly1305_ietf_KEYBYTES(ErlNifEnv *env, int argc,
+                                                  ERL_NIF_TERM const argv[]);
 ERL_NIF_TERM
-enacl_crypto_aead_xchacha20poly1305_NPUBBYTES(ErlNifEnv *env, int argc,
-                                              ERL_NIF_TERM const argv[]);
+enacl_crypto_aead_xchacha20poly1305_ietf_NPUBBYTES(ErlNifEnv *env, int argc,
+                                                   ERL_NIF_TERM const argv[]);
 ERL_NIF_TERM
-enacl_crypto_aead_xchacha20poly1305_ABYTES(ErlNifEnv *env, int argc,
-                                           ERL_NIF_TERM const argv[]);
+enacl_crypto_aead_xchacha20poly1305_ietf_ABYTES(ErlNifEnv *env, int argc,
+                                                ERL_NIF_TERM const argv[]);
 ERL_NIF_TERM
-enacl_crypto_aead_xchacha20poly1305_MESSAGEBYTES_MAX(ErlNifEnv *env, int argc,
-                                                     ERL_NIF_TERM const argv[]);
+enacl_crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX(
+    ErlNifEnv *env, int argc, ERL_NIF_TERM const argv[]);
 ERL_NIF_TERM
-enacl_crypto_aead_xchacha20poly1305_encrypt(ErlNifEnv *env, int argc,
-                                            ERL_NIF_TERM const argv[]);
+enacl_crypto_aead_xchacha20poly1305_ietf_encrypt(ErlNifEnv *env, int argc,
+                                                 ERL_NIF_TERM const argv[]);
 ERL_NIF_TERM
-enacl_crypto_aead_xchacha20poly1305_decrypt(ErlNifEnv *env, int argc,
-                                            ERL_NIF_TERM const argv[]);
+enacl_crypto_aead_xchacha20poly1305_ietf_decrypt(ErlNifEnv *env, int argc,
+                                                 ERL_NIF_TERM const argv[]);
 
 #endif
diff --git a/c_src/enacl_nif.c b/c_src/enacl_nif.c
index cdf6e7d..5e33df3 100644
--- a/c_src/enacl_nif.c
+++ b/c_src/enacl_nif.c
@@ -420,20 +420,20 @@ static ErlNifFunc nif_funcs[] = {
         "crypto_aead_chacha20poly1305_ietf_decrypt", 4,
         enacl_crypto_aead_chacha20poly1305_ietf_decrypt),
 
-    {"crypto_aead_xchacha20poly1305_KEYBYTES", 0,
-     enacl_crypto_aead_xchacha20poly1305_KEYBYTES},
-    {"crypto_aead_xchacha20poly1305_NPUBBYTES", 0,
-     enacl_crypto_aead_xchacha20poly1305_NPUBBYTES},
-    {"crypto_aead_xchacha20poly1305_ABYTES", 0,
-     enacl_crypto_aead_xchacha20poly1305_ABYTES},
-    {"crypto_aead_xchacha20poly1305_MESSAGEBYTES_MAX", 0,
-     enacl_crypto_aead_xchacha20poly1305_MESSAGEBYTES_MAX},
+    {"crypto_aead_xchacha20poly1305_ietf_KEYBYTES", 0,
+     enacl_crypto_aead_xchacha20poly1305_ietf_KEYBYTES},
+    {"crypto_aead_xchacha20poly1305_ietf_NPUBBYTES", 0,
+     enacl_crypto_aead_xchacha20poly1305_ietf_NPUBBYTES},
+    {"crypto_aead_xchacha20poly1305_ietf_ABYTES", 0,
+     enacl_crypto_aead_xchacha20poly1305_ietf_ABYTES},
+    {"crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX", 0,
+     enacl_crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX},
     erl_nif_dirty_job_cpu_bound_macro(
-        "crypto_aead_xchacha20poly1305_encrypt", 4,
-        enacl_crypto_aead_xchacha20poly1305_encrypt),
+        "crypto_aead_xchacha20poly1305_ietf_encrypt", 4,
+        enacl_crypto_aead_xchacha20poly1305_ietf_encrypt),
     erl_nif_dirty_job_cpu_bound_macro(
-        "crypto_aead_xchacha20poly1305_decrypt", 4,
-        enacl_crypto_aead_xchacha20poly1305_decrypt),
+        "crypto_aead_xchacha20poly1305_ietf_decrypt", 4,
+        enacl_crypto_aead_xchacha20poly1305_ietf_decrypt),
 
     {"crypto_generichash_BYTES", 0, enacl_crypto_generichash_BYTES},
     {"crypto_generichash_BYTES_MIN", 0, enacl_crypto_generichash_BYTES_MIN},
diff --git a/src/enacl.erl b/src/enacl.erl
index d00256a..cdfd578 100644
--- a/src/enacl.erl
+++ b/src/enacl.erl
@@ -74,12 +74,12 @@
          aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX/0,
 
          %% No Tests!
-         aead_xchacha20poly1305_encrypt/4,
-         aead_xchacha20poly1305_decrypt/4,
-         aead_xchacha20poly1305_KEYBYTES/0,
-         aead_xchacha20poly1305_NONCEBYTES/0,
-         aead_xchacha20poly1305_ABYTES/0,
-         aead_xchacha20poly1305_MESSAGEBYTES_MAX/0,
+         aead_xchacha20poly1305_ietf_encrypt/4,
+         aead_xchacha20poly1305_ietf_decrypt/4,
+         aead_xchacha20poly1305_ietf_KEYBYTES/0,
+         aead_xchacha20poly1305_ietf_NPUBBYTES/0,
+         aead_xchacha20poly1305_ietf_ABYTES/0,
+         aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX/0,
 
          %% EQC
          stream_key_size/0,
@@ -1224,54 +1224,54 @@ aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX() ->
 %% `AD' using `Key' and `Nonce'. Returns the encrypted message followed by
 %% `aead_xchacha20poly1305_ABYTES/0' bytes of MAC.
 %% @end
--spec aead_xchacha20poly1305_encrypt(Key, Nonce, AD, Msg) -> binary() | {error, term()}
+-spec aead_xchacha20poly1305_ietf_encrypt(Msg, AD, Nonce, Key) -> binary() | {error, term()}
     when Key :: binary(),
          Nonce :: binary(),
          AD :: binary(),
          Msg :: binary().
-aead_xchacha20poly1305_encrypt(Key, Nonce, AD, Msg) ->
-    enacl_nif:crypto_aead_xchacha20poly1305_encrypt(Key, Nonce, AD, Msg).
+aead_xchacha20poly1305_ietf_encrypt(Msg, AD, Nonce, Key) ->
+    enacl_nif:crypto_aead_xchacha20poly1305_ietf_encrypt(Msg, AD, Nonce, Key).
 
 %% @doc aead_xchacha20poly1305_decrypt/4 decrypts ciphertext `CT' with additional
 %% data `AD' using `Key' and `Nonce'. Note: `CipherText' should contain
 %% `aead_xchacha20poly1305_ABYTES/0' bytes that is the MAC. Returns the decrypted
 %% message.
 %% @end
--spec aead_xchacha20poly1305_decrypt(Key, Nonce, AD, CT) -> binary() | {error, term()}
+-spec aead_xchacha20poly1305_ietf_decrypt(CT, AD, Nonce, Key) -> binary() | {error, term()}
     when Key :: binary(),
          Nonce :: binary(),
          AD :: binary(),
          CT :: binary().
-aead_xchacha20poly1305_decrypt(Key, Nonce, AD, CT) ->
-    enacl_nif:crypto_aead_xchacha20poly1305_decrypt(Key, Nonce, AD, CT).
+aead_xchacha20poly1305_ietf_decrypt(CT, AD, Nonce, Key) ->
+    enacl_nif:crypto_aead_xchacha20poly1305_ietf_decrypt(CT, AD, Nonce, Key).
 
 %% @doc aead_xchacha20poly1305_KEYBYTES/0 returns the number of bytes
 %% of the key used in AEAD XChaCha20 Poly1305 encryption/decryption.
 %% @end
--spec aead_xchacha20poly1305_KEYBYTES() -> pos_integer().
-aead_xchacha20poly1305_KEYBYTES() ->
-    enacl_nif:crypto_aead_xchacha20poly1305_KEYBYTES().
+-spec aead_xchacha20poly1305_ietf_KEYBYTES() -> pos_integer().
+aead_xchacha20poly1305_ietf_KEYBYTES() ->
+    enacl_nif:crypto_aead_xchacha20poly1305_ietf_KEYBYTES().
 
-%% @doc aead_xchacha20poly1305_NONCEBYTES/0 returns the number of bytes
+%% @doc aead_xchacha20poly1305_NPUBBYTES/0 returns the number of bytes
 %% of the Nonce in AEAD XChaCha20 Poly1305 encryption/decryption.
 %% @end
--spec aead_xchacha20poly1305_NONCEBYTES() -> pos_integer().
-aead_xchacha20poly1305_NONCEBYTES() ->
-    enacl_nif:crypto_aead_xchacha20poly1305_NPUBBYTES().
+-spec aead_xchacha20poly1305_ietf_NPUBBYTES() -> pos_integer().
+aead_xchacha20poly1305_ietf_NPUBBYTES() ->
+    enacl_nif:crypto_aead_xchacha20poly1305_ietf_NPUBBYTES().
 
 %% @doc aead_xchacha20poly1305_ABYTES/0 returns the number of bytes
 %% of the MAC in AEAD XChaCha20 Poly1305 encryption/decryption.
 %% @end
--spec aead_xchacha20poly1305_ABYTES() -> pos_integer().
-aead_xchacha20poly1305_ABYTES() ->
-    enacl_nif:crypto_aead_xchacha20poly1305_ABYTES().
+-spec aead_xchacha20poly1305_ietf_ABYTES() -> pos_integer().
+aead_xchacha20poly1305_ietf_ABYTES() ->
+    enacl_nif:crypto_aead_xchacha20poly1305_ietf_ABYTES().
 
 %% @doc aead_xchacha20poly1305_MESSAGEBYTES_MAX/0 returns the max number of bytes
 %% allowed in a message in AEAD XChaCha20 Poly1305 encryption/decryption.
 %% @end
--spec aead_xchacha20poly1305_MESSAGEBYTES_MAX() -> pos_integer().
-aead_xchacha20poly1305_MESSAGEBYTES_MAX() ->
-    enacl_nif:crypto_aead_xchacha20poly1305_MESSAGEBYTES_MAX().
+-spec aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX() -> pos_integer().
+aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX() ->
+    enacl_nif:crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX().
 
 %% Obtaining random bytes
 
diff --git a/src/enacl_nif.erl b/src/enacl_nif.erl
index 97816a0..1309a11 100644
--- a/src/enacl_nif.erl
+++ b/src/enacl_nif.erl
@@ -81,12 +81,12 @@
          crypto_aead_chacha20poly1305_ietf_ABYTES/0,
          crypto_aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX/0,
 
-         crypto_aead_xchacha20poly1305_encrypt/4,
-         crypto_aead_xchacha20poly1305_decrypt/4,
-         crypto_aead_xchacha20poly1305_KEYBYTES/0,
-         crypto_aead_xchacha20poly1305_NPUBBYTES/0,
-         crypto_aead_xchacha20poly1305_ABYTES/0,
-         crypto_aead_xchacha20poly1305_MESSAGEBYTES_MAX/0,
+         crypto_aead_xchacha20poly1305_ietf_encrypt/4,
+         crypto_aead_xchacha20poly1305_ietf_decrypt/4,
+         crypto_aead_xchacha20poly1305_ietf_KEYBYTES/0,
+         crypto_aead_xchacha20poly1305_ietf_NPUBBYTES/0,
+         crypto_aead_xchacha20poly1305_ietf_ABYTES/0,
+         crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX/0,
 
          crypto_auth_BYTES/0,
          crypto_auth_KEYBYTES/0,
@@ -279,12 +279,12 @@ crypto_aead_chacha20poly1305_ietf_NPUBBYTES()                          -> erlang
 crypto_aead_chacha20poly1305_ietf_ABYTES()                             -> erlang:nif_error(nif_not_loaded).
 crypto_aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX()                   -> erlang:nif_error(nif_not_loaded).
 
-crypto_aead_xchacha20poly1305_encrypt(_Message, _AD, _Nonce, _Key) -> erlang:nif_error(nif_not_loaded).
-crypto_aead_xchacha20poly1305_decrypt(_CipherText, _AD, _Nonce, _Key) -> erlang:nif_error(nif_not_loaded).
-crypto_aead_xchacha20poly1305_KEYBYTES()                           -> erlang:nif_error(nif_not_loaded).
-crypto_aead_xchacha20poly1305_NPUBBYTES()                          -> erlang:nif_error(nif_not_loaded).
-crypto_aead_xchacha20poly1305_ABYTES()                             -> erlang:nif_error(nif_not_loaded).
-crypto_aead_xchacha20poly1305_MESSAGEBYTES_MAX()                   -> erlang:nif_error(nif_not_loaded).
+crypto_aead_xchacha20poly1305_ietf_encrypt(_Message, _AD, _Nonce, _Key) -> erlang:nif_error(nif_not_loaded).
+crypto_aead_xchacha20poly1305_ietf_decrypt(_CipherText, _AD, _Nonce, _Key) -> erlang:nif_error(nif_not_loaded).
+crypto_aead_xchacha20poly1305_ietf_KEYBYTES()                           -> erlang:nif_error(nif_not_loaded).
+crypto_aead_xchacha20poly1305_ietf_NPUBBYTES()                          -> erlang:nif_error(nif_not_loaded).
+crypto_aead_xchacha20poly1305_ietf_ABYTES()                             -> erlang:nif_error(nif_not_loaded).
+crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX()                   -> erlang:nif_error(nif_not_loaded).
 
 crypto_auth_BYTES() -> erlang:nif_error(nif_not_loaded).
 crypto_auth_KEYBYTES() -> erlang:nif_error(nif_not_loaded).
diff --git a/test/enacl_SUITE.erl b/test/enacl_SUITE.erl
index 5798b7f..d36ba83 100644
--- a/test/enacl_SUITE.erl
+++ b/test/enacl_SUITE.erl
@@ -91,15 +91,15 @@ generichash_chunked(State, Msg, N) ->
     generichash_chunked(State2, Msg, N-1).
 
 aead_xchacha20poly1305(_Config) ->
-    NonceLen = enacl:aead_xchacha20poly1305_NONCEBYTES(),
-    KLen = enacl:aead_xchacha20poly1305_KEYBYTES(),
+    NonceLen = enacl:aead_xchacha20poly1305_ietf_NPUBBYTES(),
+    KLen = enacl:aead_xchacha20poly1305_ietf_KEYBYTES(),
     Key = binary:copy(<<"K">>, KLen),
     Msg = <<"test">>,
     AD = <<1,2,3,4,5,6>>,
     Nonce = binary:copy(<<"N">>, NonceLen),
 
-    CipherText = enacl:aead_xchacha20poly1305_encrypt(Key, Nonce, AD, Msg),
-    Msg = enacl:aead_xchacha20poly1305_decrypt(Key, Nonce, AD, CipherText),
+    CipherText = enacl:aead_xchacha20poly1305_ietf_encrypt(Msg, AD, Nonce, Key),
+    Msg = enacl:aead_xchacha20poly1305_ietf_decrypt(CipherText, AD, Nonce, Key),
     ok.
 
 aead_chacha20poly1305_ietf(_Config) ->