diff --git a/c_src/enacl_nif.c b/c_src/enacl_nif.c
index 1dae63f..8065cd2 100644
--- a/c_src/enacl_nif.c
+++ b/c_src/enacl_nif.c
@@ -20,8 +20,8 @@
 #endif
 
 /* Initialization */
-static int enif_crypto_load(ErlNifEnv *env, void **priv_data,
-                            ERL_NIF_TERM load_info) {
+static int enacl_crypto_load(ErlNifEnv *env, void **priv_data,
+                             ERL_NIF_TERM load_info) {
   // Create a new resource type for crypto_generichash_state
   if (!enacl_init_generic_hash_ctx(env)) {
     return -1;
@@ -34,8 +34,8 @@ static int enif_crypto_load(ErlNifEnv *env, void **priv_data,
   return sodium_init();
 }
 
-static ERL_NIF_TERM enif_crypto_verify_16(ErlNifEnv *env, int argc,
-                                          ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_verify_16(ErlNifEnv *env, int argc,
+                                           ERL_NIF_TERM const argv[]) {
   ErlNifBinary x, y;
 
   if ((argc != 2) || (!enif_inspect_binary(env, argv[0], &x)) ||
@@ -54,8 +54,8 @@ static ERL_NIF_TERM enif_crypto_verify_16(ErlNifEnv *env, int argc,
   }
 }
 
-static ERL_NIF_TERM enif_crypto_verify_32(ErlNifEnv *env, int argc,
-                                          ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_verify_32(ErlNifEnv *env, int argc,
+                                           ERL_NIF_TERM const argv[]) {
   ErlNifBinary x, y;
 
   if ((argc != 2) || (!enif_inspect_binary(env, argv[0], &x)) ||
@@ -92,8 +92,8 @@ static ERL_NIF_TERM enif_sodium_memzero(ErlNifEnv *env, int argc,
 
 /* Curve 25519 */
 static ERL_NIF_TERM
-enif_crypto_curve25519_scalarmult(ErlNifEnv *env, int argc,
-                                  ERL_NIF_TERM const argv[]) {
+enacl_crypto_curve25519_scalarmult(ErlNifEnv *env, int argc,
+                                   ERL_NIF_TERM const argv[]) {
   ERL_NIF_TERM result;
   ErlNifBinary secret, basepoint, output;
   uint8_t bp[crypto_scalarmult_curve25519_BYTES];
@@ -130,8 +130,8 @@ enif_crypto_curve25519_scalarmult(ErlNifEnv *env, int argc,
 }
 
 static ERL_NIF_TERM
-enif_crypto_curve25519_scalarmult_base(ErlNifEnv *env, int argc,
-                                       ERL_NIF_TERM const argv[]) {
+enacl_crypto_curve25519_scalarmult_base(ErlNifEnv *env, int argc,
+                                        ERL_NIF_TERM const argv[]) {
   ERL_NIF_TERM result;
   ErlNifBinary secret, output;
 
@@ -157,140 +157,39 @@ enif_crypto_curve25519_scalarmult_base(ErlNifEnv *env, int argc,
   return result;
 }
 
-/* Ed 25519 */
-static ERL_NIF_TERM
-enif_crypto_sign_ed25519_keypair(ErlNifEnv *env, int argc,
-                                 ERL_NIF_TERM const argv[]) {
-  ErlNifBinary pk, sk;
-
-  if (argc != 0) {
-    return enif_make_badarg(env);
-  }
-
-  if (!enif_alloc_binary(crypto_sign_ed25519_PUBLICKEYBYTES, &pk)) {
-    return nacl_error_tuple(env, "alloc_failed");
-  }
-
-  if (!enif_alloc_binary(crypto_sign_ed25519_SECRETKEYBYTES, &sk)) {
-    return nacl_error_tuple(env, "alloc_failed");
-  }
-
-  crypto_sign_ed25519_keypair(pk.data, sk.data);
-
-  return enif_make_tuple2(env, enif_make_binary(env, &pk),
-                          enif_make_binary(env, &sk));
-}
-
-static ERL_NIF_TERM
-enif_crypto_sign_ed25519_sk_to_pk(ErlNifEnv *env, int argc,
-                                  ERL_NIF_TERM const argv[]) {
-  ErlNifBinary pk, sk;
-
-  if ((argc != 1) || (!enif_inspect_binary(env, argv[0], &sk)) ||
-      (sk.size != crypto_sign_ed25519_SECRETKEYBYTES)) {
-    return enif_make_badarg(env);
-  }
-
-  if (!enif_alloc_binary(crypto_sign_ed25519_PUBLICKEYBYTES, &pk)) {
-    return nacl_error_tuple(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 enif_make_binary(env, &pk);
-}
-
-static ERL_NIF_TERM
-enif_crypto_sign_ed25519_public_to_curve25519(ErlNifEnv *env, int argc,
-                                              ERL_NIF_TERM const argv[]) {
-  ErlNifBinary curve25519_pk, ed25519_pk;
-
-  if ((argc != 1) || (!enif_inspect_binary(env, argv[0], &ed25519_pk)) ||
-      (ed25519_pk.size != crypto_sign_ed25519_PUBLICKEYBYTES)) {
-    return enif_make_badarg(env);
-  }
-
-  if (!enif_alloc_binary(crypto_scalarmult_curve25519_BYTES, &curve25519_pk)) {
-    return nacl_error_tuple(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 enif_make_binary(env, &curve25519_pk);
-}
-
-static ERL_NIF_TERM
-enif_crypto_sign_ed25519_secret_to_curve25519(ErlNifEnv *env, int argc,
-                                              ERL_NIF_TERM const argv[]) {
-  ErlNifBinary curve25519_sk, ed25519_sk;
-
-  if ((argc != 1) || (!enif_inspect_binary(env, argv[0], &ed25519_sk)) ||
-      (ed25519_sk.size != crypto_sign_ed25519_SECRETKEYBYTES)) {
-    return enif_make_badarg(env);
-  }
-
-  if (!enif_alloc_binary(crypto_scalarmult_curve25519_BYTES, &curve25519_sk)) {
-    return nacl_error_tuple(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 enif_make_binary(env, &curve25519_sk);
-}
-
-static ERL_NIF_TERM
-enif_crypto_sign_ed25519_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
-                                        ERL_NIF_TERM const argv[]) {
-  return enif_make_int64(env, crypto_sign_ed25519_PUBLICKEYBYTES);
-}
-
-static ERL_NIF_TERM
-enif_crypto_sign_ed25519_SECRETKEYBYTES(ErlNifEnv *env, int argc,
-                                        ERL_NIF_TERM const argv[]) {
-  return enif_make_int64(env, crypto_sign_ed25519_SECRETKEYBYTES);
-}
-
 /* Public-key cryptography */
-static ERL_NIF_TERM enif_crypto_box_NONCEBYTES(ErlNifEnv *env, int argc,
-                                               ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_box_NONCEBYTES(ErlNifEnv *env, int argc,
+                                                ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_box_NONCEBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_box_ZEROBYTES(ErlNifEnv *env, int argc,
-                                              ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_box_ZEROBYTES(ErlNifEnv *env, int argc,
+                                               ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_box_ZEROBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_box_BOXZEROBYTES(ErlNifEnv *env, int argc,
-                                                 ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_box_BOXZEROBYTES(ErlNifEnv *env, int argc,
+                                                  ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_box_BOXZEROBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_box_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
-                                                   ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_box_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
+                                                    ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_box_PUBLICKEYBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_box_SECRETKEYBYTES(ErlNifEnv *env, int argc,
-                                                   ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_box_SECRETKEYBYTES(ErlNifEnv *env, int argc,
+                                                    ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_box_SECRETKEYBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_box_BEFORENMBYTES(ErlNifEnv *env, int argc,
-                                                  ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_box_BEFORENMBYTES(ErlNifEnv *env, int argc,
+                                                   ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_box_BEFORENMBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_box_keypair(ErlNifEnv *env, int argc,
-                                            ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_box_keypair(ErlNifEnv *env, int argc,
+                                             ERL_NIF_TERM const argv[]) {
   ErlNifBinary pk, sk;
 
   if (argc != 0) {
@@ -311,8 +210,8 @@ static ERL_NIF_TERM enif_crypto_box_keypair(ErlNifEnv *env, int argc,
                           enif_make_binary(env, &sk));
 }
 
-static ERL_NIF_TERM enif_crypto_box(ErlNifEnv *env, int argc,
-                                    ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_box(ErlNifEnv *env, int argc,
+                                     ERL_NIF_TERM const argv[]) {
   ErlNifBinary padded_msg, nonce, pk, sk, result;
 
   if ((argc != 4) ||
@@ -344,8 +243,8 @@ static ERL_NIF_TERM enif_crypto_box(ErlNifEnv *env, int argc,
                               padded_msg.size - crypto_box_BOXZEROBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_box_open(ErlNifEnv *env, int argc,
-                                         ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_box_open(ErlNifEnv *env, int argc,
+                                          ERL_NIF_TERM const argv[]) {
   ErlNifBinary padded_ciphertext, nonce, pk, sk, result;
 
   if ((argc != 4) ||
@@ -381,8 +280,8 @@ static ERL_NIF_TERM enif_crypto_box_open(ErlNifEnv *env, int argc,
 
 /* Precomputed crypto boxes */
 
-static ERL_NIF_TERM enif_crypto_box_beforenm(ErlNifEnv *env, int argc,
-                                             ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_box_beforenm(ErlNifEnv *env, int argc,
+                                              ERL_NIF_TERM const argv[]) {
   ErlNifBinary k, pk, sk;
 
   if ((argc != 2) || (!enif_inspect_binary(env, argv[0], &pk)) ||
@@ -404,8 +303,8 @@ static ERL_NIF_TERM enif_crypto_box_beforenm(ErlNifEnv *env, int argc,
   return enif_make_binary(env, &k);
 }
 
-static ERL_NIF_TERM enif_crypto_box_afternm(ErlNifEnv *env, int argc,
-                                            ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_box_afternm(ErlNifEnv *env, int argc,
+                                             ERL_NIF_TERM const argv[]) {
   ErlNifBinary result, m, nonce, k;
 
   if ((argc != 3) || (!enif_inspect_iolist_as_binary(env, argv[0], &m)) ||
@@ -428,8 +327,8 @@ static ERL_NIF_TERM enif_crypto_box_afternm(ErlNifEnv *env, int argc,
                               m.size - crypto_box_BOXZEROBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_box_open_afternm(ErlNifEnv *env, int argc,
-                                                 ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_box_open_afternm(ErlNifEnv *env, int argc,
+                                                  ERL_NIF_TERM const argv[]) {
   ErlNifBinary result, m, nonce, k;
 
   if ((argc != 3) || (!enif_inspect_iolist_as_binary(env, argv[0], &m)) ||
@@ -456,190 +355,15 @@ static ERL_NIF_TERM enif_crypto_box_open_afternm(ErlNifEnv *env, int argc,
                               m.size - crypto_box_ZEROBYTES);
 }
 
-/* Signing */
-static ERL_NIF_TERM enif_crypto_sign_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
-                                                    ERL_NIF_TERM const argv[]) {
-  return enif_make_int64(env, crypto_sign_PUBLICKEYBYTES);
-}
-
-static ERL_NIF_TERM enif_crypto_sign_SECRETKEYBYTES(ErlNifEnv *env, int argc,
-                                                    ERL_NIF_TERM const argv[]) {
-  return enif_make_int64(env, crypto_sign_SECRETKEYBYTES);
-}
-
-static ERL_NIF_TERM enif_crypto_sign_SEEDBYTES(ErlNifEnv *env, int argc,
-                                               ERL_NIF_TERM const argv[]) {
-  return enif_make_int64(env, crypto_sign_SEEDBYTES);
-}
-
-static ERL_NIF_TERM enif_crypto_sign_keypair(ErlNifEnv *env, int argc,
-                                             ERL_NIF_TERM const argv[]) {
-  ErlNifBinary pk, sk;
-
-  if (argc != 0) {
-    return enif_make_badarg(env);
-  }
-
-  if (!enif_alloc_binary(crypto_sign_PUBLICKEYBYTES, &pk)) {
-    return nacl_error_tuple(env, "alloc_failed");
-  }
-
-  if (!enif_alloc_binary(crypto_sign_SECRETKEYBYTES, &sk)) {
-    return nacl_error_tuple(env, "alloc_failed");
-  }
-
-  crypto_sign_keypair(pk.data, sk.data);
-
-  return enif_make_tuple2(env, enif_make_binary(env, &pk),
-                          enif_make_binary(env, &sk));
-}
-
-static ERL_NIF_TERM enif_crypto_sign_seed_keypair(ErlNifEnv *env, int argc,
-                                                  ERL_NIF_TERM const argv[]) {
-  ErlNifBinary pk, sk, seed;
-
-  if ((argc != 1) || (!enif_inspect_binary(env, argv[0], &seed))) {
-    return enif_make_badarg(env);
-  }
-
-  if (!enif_alloc_binary(crypto_sign_PUBLICKEYBYTES, &pk)) {
-    return nacl_error_tuple(env, "alloc_failed");
-  }
-
-  if (!enif_alloc_binary(crypto_sign_SECRETKEYBYTES, &sk)) {
-    return nacl_error_tuple(env, "alloc_failed");
-  }
-
-  crypto_sign_seed_keypair(pk.data, sk.data, seed.data);
-
-  return enif_make_tuple2(env, enif_make_binary(env, &pk),
-                          enif_make_binary(env, &sk));
-}
-
-/*
-int crypto_sign(unsigned char *sm, unsigned long long *smlen,
-                const unsigned char *m, unsigned long long mlen,
-                const unsigned char *sk);
- */
-static ERL_NIF_TERM enif_crypto_sign(ErlNifEnv *env, int argc,
-                                     ERL_NIF_TERM const argv[]) {
-  ErlNifBinary m, sk, sm;
-  unsigned long long smlen;
-
-  if ((argc != 2) || (!enif_inspect_iolist_as_binary(env, argv[0], &m)) ||
-      (!enif_inspect_binary(env, argv[1], &sk))) {
-    return enif_make_badarg(env);
-  }
-
-  if (sk.size != crypto_sign_SECRETKEYBYTES) {
-    return enif_make_badarg(env);
-  }
-
-  if (!enif_alloc_binary(m.size + crypto_sign_BYTES, &sm)) {
-    return nacl_error_tuple(env, "alloc_failed");
-  }
-
-  crypto_sign(sm.data, &smlen, m.data, m.size, sk.data);
-
-  return enif_make_sub_binary(env, enif_make_binary(env, &sm), 0, smlen);
-}
-
-/*
-int crypto_sign_open(unsigned char *m, unsigned long long *mlen,
-                     const unsigned char *sm, unsigned long long smlen,
-                     const unsigned char *pk);
- */
-static ERL_NIF_TERM enif_crypto_sign_open(ErlNifEnv *env, int argc,
-                                          ERL_NIF_TERM const argv[]) {
-  ErlNifBinary m, sm, pk;
-  unsigned long long mlen;
-
-  if ((argc != 2) || (!enif_inspect_iolist_as_binary(env, argv[0], &sm)) ||
-      (!enif_inspect_binary(env, argv[1], &pk))) {
-    return enif_make_badarg(env);
-  }
-
-  if (pk.size != crypto_sign_PUBLICKEYBYTES) {
-    return enif_make_badarg(env);
-  }
-
-  if (!enif_alloc_binary(sm.size, &m)) {
-    return nacl_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 nacl_error_tuple(env, "failed_verification");
-  }
-}
-
-/*
-int crypto_sign_detached(unsigned char *sig, unsigned long long *siglen,
-                         const unsigned char *m, unsigned long long mlen,
-                         const unsigned char *sk);
- */
-static ERL_NIF_TERM enif_crypto_sign_detached(ErlNifEnv *env, int argc,
-                                              ERL_NIF_TERM const argv[]) {
-  ErlNifBinary m, sk, sig;
-  unsigned long long siglen;
-
-  if ((argc != 2) || (!enif_inspect_iolist_as_binary(env, argv[0], &m)) ||
-      (!enif_inspect_binary(env, argv[1], &sk))) {
-    return enif_make_badarg(env);
-  }
-
-  if (sk.size != crypto_sign_SECRETKEYBYTES) {
-    return enif_make_badarg(env);
-  }
-
-  if (!enif_alloc_binary(crypto_sign_BYTES, &sig)) {
-    return nacl_error_tuple(env, "alloc_failed");
-  }
-
-  crypto_sign_detached(sig.data, &siglen, m.data, m.size, sk.data);
-
-  return enif_make_binary(env, &sig);
-}
-
-/*
-int crypto_sign_verify_detached(const unsigned char *sig,
-                                const unsigned char *m,
-                                unsigned long long mlen,
-                                const unsigned char *pk);
- */
-static ERL_NIF_TERM
-enif_crypto_sign_verify_detached(ErlNifEnv *env, int argc,
-                                 ERL_NIF_TERM const argv[]) {
-  ErlNifBinary m, sig, pk;
-
-  if ((argc != 3) || (!enif_inspect_binary(env, argv[0], &sig)) ||
-      (!enif_inspect_iolist_as_binary(env, argv[1], &m)) ||
-      (!enif_inspect_binary(env, argv[2], &pk))) {
-    return enif_make_badarg(env);
-  }
-
-  if (pk.size != crypto_sign_PUBLICKEYBYTES) {
-    return enif_make_badarg(env);
-  }
-
-  if (0 == crypto_sign_verify_detached(sig.data, m.data, m.size, pk.data)) {
-    return enif_make_atom(env, "true");
-  } else {
-    return enif_make_atom(env, "false");
-  }
-}
-
 /* Sealed box functions */
 
-static ERL_NIF_TERM enif_crypto_box_SEALBYTES(ErlNifEnv *env, int argc,
-                                              ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_box_SEALBYTES(ErlNifEnv *env, int argc,
+                                               ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_box_SEALBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_box_seal(ErlNifEnv *env, int argc,
-                                         ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_box_seal(ErlNifEnv *env, int argc,
+                                          ERL_NIF_TERM const argv[]) {
   ErlNifBinary key, msg, ciphertext;
 
   if ((argc != 2) || (!enif_inspect_iolist_as_binary(env, argv[0], &msg)) ||
@@ -656,8 +380,8 @@ static ERL_NIF_TERM enif_crypto_box_seal(ErlNifEnv *env, int argc,
   return enif_make_binary(env, &ciphertext);
 }
 
-static ERL_NIF_TERM enif_crypto_box_seal_open(ErlNifEnv *env, int argc,
-                                              ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_box_seal_open(ErlNifEnv *env, int argc,
+                                               ERL_NIF_TERM const argv[]) {
   ErlNifBinary pk, sk, ciphertext, msg;
 
   if ((argc != 3) ||
@@ -687,82 +411,83 @@ static ERL_NIF_TERM enif_crypto_box_seal_open(ErlNifEnv *env, int argc,
 /* Secret key cryptography */
 
 static ERL_NIF_TERM
-enif_crypto_secretbox_NONCEBYTES(ErlNifEnv *env, int argc,
-                                 ERL_NIF_TERM const argv[]) {
+enacl_crypto_secretbox_NONCEBYTES(ErlNifEnv *env, int argc,
+                                  ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_secretbox_NONCEBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_secretbox_KEYBYTES(ErlNifEnv *env, int argc,
-                                                   ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_secretbox_KEYBYTES(ErlNifEnv *env, int argc,
+                                                    ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_secretbox_KEYBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_secretbox_ZEROBYTES(ErlNifEnv *env, int argc,
-                                                    ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM
+enacl_crypto_secretbox_ZEROBYTES(ErlNifEnv *env, int argc,
+                                 ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_secretbox_ZEROBYTES);
 }
 
 static ERL_NIF_TERM
-enif_crypto_secretbox_BOXZEROBYTES(ErlNifEnv *env, int argc,
-                                   ERL_NIF_TERM const argv[]) {
+enacl_crypto_secretbox_BOXZEROBYTES(ErlNifEnv *env, int argc,
+                                    ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_secretbox_BOXZEROBYTES);
 }
 
 static ERL_NIF_TERM
-enif_crypto_stream_chacha20_KEYBYTES(ErlNifEnv *env, int argc,
-                                     ERL_NIF_TERM const argv[]) {
+enacl_crypto_stream_chacha20_KEYBYTES(ErlNifEnv *env, int argc,
+                                      ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_stream_chacha20_KEYBYTES);
 }
 
 static ERL_NIF_TERM
-enif_crypto_stream_chacha20_NONCEBYTES(ErlNifEnv *env, int argc,
-                                       ERL_NIF_TERM const argv[]) {
+enacl_crypto_stream_chacha20_NONCEBYTES(ErlNifEnv *env, int argc,
+                                        ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_stream_chacha20_NONCEBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_stream_KEYBYTES(ErlNifEnv *env, int argc,
-                                                ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_stream_KEYBYTES(ErlNifEnv *env, int argc,
+                                                 ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_stream_KEYBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_stream_NONCEBYTES(ErlNifEnv *env, int argc,
-                                                  ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_stream_NONCEBYTES(ErlNifEnv *env, int argc,
+                                                   ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_stream_NONCEBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_auth_BYTES(ErlNifEnv *env, int argc,
-                                           ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_auth_BYTES(ErlNifEnv *env, int argc,
+                                            ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_auth_BYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_auth_KEYBYTES(ErlNifEnv *env, int argc,
-                                              ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_auth_KEYBYTES(ErlNifEnv *env, int argc,
+                                               ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_auth_KEYBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_shorthash_BYTES(ErlNifEnv *env, int argc,
-                                                ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_shorthash_BYTES(ErlNifEnv *env, int argc,
+                                                 ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_shorthash_BYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_shorthash_KEYBYTES(ErlNifEnv *env, int argc,
-                                                   ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_shorthash_KEYBYTES(ErlNifEnv *env, int argc,
+                                                    ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_shorthash_KEYBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_onetimeauth_BYTES(ErlNifEnv *env, int argc,
-                                                  ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_onetimeauth_BYTES(ErlNifEnv *env, int argc,
+                                                   ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_onetimeauth_BYTES);
 }
 
 static ERL_NIF_TERM
-enif_crypto_onetimeauth_KEYBYTES(ErlNifEnv *env, int argc,
-                                 ERL_NIF_TERM const argv[]) {
+enacl_crypto_onetimeauth_KEYBYTES(ErlNifEnv *env, int argc,
+                                  ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_onetimeauth_KEYBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_secretbox(ErlNifEnv *env, int argc,
-                                          ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_secretbox(ErlNifEnv *env, int argc,
+                                           ERL_NIF_TERM const argv[]) {
   ErlNifBinary key, nonce, padded_msg, padded_ciphertext;
 
   if ((argc != 3) ||
@@ -790,8 +515,8 @@ static ERL_NIF_TERM enif_crypto_secretbox(ErlNifEnv *env, int argc,
                               padded_msg.size - crypto_secretbox_BOXZEROBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_secretbox_open(ErlNifEnv *env, int argc,
-                                               ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_secretbox_open(ErlNifEnv *env, int argc,
+                                                ERL_NIF_TERM const argv[]) {
   ErlNifBinary key, nonce, padded_ciphertext, padded_msg;
 
   if ((argc != 3) ||
@@ -823,8 +548,8 @@ static ERL_NIF_TERM enif_crypto_secretbox_open(ErlNifEnv *env, int argc,
       padded_ciphertext.size - crypto_secretbox_ZEROBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_stream_chacha20(ErlNifEnv *env, int argc,
-                                                ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_stream_chacha20(ErlNifEnv *env, int argc,
+                                                 ERL_NIF_TERM const argv[]) {
   ErlNifBinary c, n, k;
   ErlNifUInt64 clen;
 
@@ -848,8 +573,9 @@ static ERL_NIF_TERM enif_crypto_stream_chacha20(ErlNifEnv *env, int argc,
   return enif_make_binary(env, &c);
 }
 
-static ERL_NIF_TERM enif_crypto_stream_chacha20_xor(ErlNifEnv *env, int argc,
-                                                    ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM
+enacl_crypto_stream_chacha20_xor(ErlNifEnv *env, int argc,
+                                 ERL_NIF_TERM const argv[]) {
   ErlNifBinary c, m, n, k;
 
   if ((argc != 3) || (!enif_inspect_iolist_as_binary(env, argv[0], &m)) ||
@@ -872,8 +598,8 @@ static ERL_NIF_TERM enif_crypto_stream_chacha20_xor(ErlNifEnv *env, int argc,
   return enif_make_binary(env, &c);
 }
 
-static ERL_NIF_TERM enif_crypto_stream(ErlNifEnv *env, int argc,
-                                       ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_stream(ErlNifEnv *env, int argc,
+                                        ERL_NIF_TERM const argv[]) {
   ErlNifBinary c, n, k;
   ErlNifUInt64 clen;
 
@@ -897,8 +623,8 @@ static ERL_NIF_TERM enif_crypto_stream(ErlNifEnv *env, int argc,
   return enif_make_binary(env, &c);
 }
 
-static ERL_NIF_TERM enif_crypto_stream_xor(ErlNifEnv *env, int argc,
-                                           ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_stream_xor(ErlNifEnv *env, int argc,
+                                            ERL_NIF_TERM const argv[]) {
   ErlNifBinary c, m, n, k;
 
   if ((argc != 3) || (!enif_inspect_iolist_as_binary(env, argv[0], &m)) ||
@@ -921,8 +647,8 @@ static ERL_NIF_TERM enif_crypto_stream_xor(ErlNifEnv *env, int argc,
   return enif_make_binary(env, &c);
 }
 
-static ERL_NIF_TERM enif_crypto_auth(ErlNifEnv *env, int argc,
-                                     ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_auth(ErlNifEnv *env, int argc,
+                                      ERL_NIF_TERM const argv[]) {
   ErlNifBinary a, m, k;
 
   if ((argc != 2) || (!enif_inspect_iolist_as_binary(env, argv[0], &m)) ||
@@ -943,8 +669,8 @@ static ERL_NIF_TERM enif_crypto_auth(ErlNifEnv *env, int argc,
   return enif_make_binary(env, &a);
 }
 
-static ERL_NIF_TERM enif_crypto_auth_verify(ErlNifEnv *env, int argc,
-                                            ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_auth_verify(ErlNifEnv *env, int argc,
+                                             ERL_NIF_TERM const argv[]) {
   ErlNifBinary a, m, k;
 
   if ((argc != 3) || (!enif_inspect_binary(env, argv[0], &a)) ||
@@ -964,8 +690,8 @@ static ERL_NIF_TERM enif_crypto_auth_verify(ErlNifEnv *env, int argc,
   }
 }
 
-static ERL_NIF_TERM enif_crypto_shorthash(ErlNifEnv *env, int argc,
-                                          ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_shorthash(ErlNifEnv *env, int argc,
+                                           ERL_NIF_TERM const argv[]) {
   ErlNifBinary a, m, k;
 
   if ((argc != 2) || (!enif_inspect_iolist_as_binary(env, argv[0], &m)) ||
@@ -986,8 +712,8 @@ static ERL_NIF_TERM enif_crypto_shorthash(ErlNifEnv *env, int argc,
   return enif_make_binary(env, &a);
 }
 
-static ERL_NIF_TERM enif_crypto_onetimeauth(ErlNifEnv *env, int argc,
-                                            ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_onetimeauth(ErlNifEnv *env, int argc,
+                                             ERL_NIF_TERM const argv[]) {
   ErlNifBinary a, m, k;
 
   if ((argc != 2) || (!enif_inspect_iolist_as_binary(env, argv[0], &m)) ||
@@ -1008,8 +734,8 @@ static ERL_NIF_TERM enif_crypto_onetimeauth(ErlNifEnv *env, int argc,
   return enif_make_binary(env, &a);
 }
 
-static ERL_NIF_TERM enif_crypto_onetimeauth_verify(ErlNifEnv *env, int argc,
-                                                   ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_onetimeauth_verify(ErlNifEnv *env, int argc,
+                                                    ERL_NIF_TERM const argv[]) {
   ErlNifBinary a, m, k;
 
   if ((argc != 3) || (!enif_inspect_binary(env, argv[0], &a)) ||
@@ -1075,23 +801,23 @@ static ERL_NIF_TERM enif_randombytes_uniform(ErlNifEnv *env, int argc,
 
 /* Key exchange */
 
-static ERL_NIF_TERM enif_crypto_kx_SECRETKEYBYTES(ErlNifEnv *env, int argc,
-                                                  ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_kx_SECRETKEYBYTES(ErlNifEnv *env, int argc,
+                                                   ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_kx_SECRETKEYBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_kx_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
-                                                  ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_kx_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
+                                                   ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_kx_PUBLICKEYBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_kx_SESSIONKEYBYTES(ErlNifEnv *env, int argc,
-                                                   ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_kx_SESSIONKEYBYTES(ErlNifEnv *env, int argc,
+                                                    ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_kx_SESSIONKEYBYTES);
 }
 
-static ERL_NIF_TERM enif_crypto_kx_keypair(ErlNifEnv *env, int argc,
-                                           ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_kx_keypair(ErlNifEnv *env, int argc,
+                                            ERL_NIF_TERM const argv[]) {
   ErlNifBinary pk, sk;
 
   if (argc != 0) {
@@ -1113,8 +839,8 @@ static ERL_NIF_TERM enif_crypto_kx_keypair(ErlNifEnv *env, int argc,
 }
 
 static ERL_NIF_TERM
-enif_crypto_kx_server_session_keys(ErlNifEnv *env, int argc,
-                                   ERL_NIF_TERM const argv[]) {
+enacl_crypto_kx_server_session_keys(ErlNifEnv *env, int argc,
+                                    ERL_NIF_TERM const argv[]) {
   ErlNifBinary rx, tx, server_pk, server_sk, client_pk;
 
   if ((argc != 3) || (!enif_inspect_binary(env, argv[0], &server_pk)) ||
@@ -1145,8 +871,8 @@ enif_crypto_kx_server_session_keys(ErlNifEnv *env, int argc,
 }
 
 static ERL_NIF_TERM
-enif_crypto_kx_client_session_keys(ErlNifEnv *env, int argc,
-                                   ERL_NIF_TERM const argv[]) {
+enacl_crypto_kx_client_session_keys(ErlNifEnv *env, int argc,
+                                    ERL_NIF_TERM const argv[]) {
   ErlNifBinary rx, tx, client_pk, client_sk, server_pk;
 
   if ((argc != 3) || (!enif_inspect_binary(env, argv[0], &client_pk)) ||
@@ -1308,8 +1034,8 @@ static size_t enacl_pwhash_memlimit(ErlNifEnv *env, ERL_NIF_TERM arg) {
   return 0;
 }
 
-static ERL_NIF_TERM enif_crypto_pwhash(ErlNifEnv *env, int argc,
-                                       ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_pwhash(ErlNifEnv *env, int argc,
+                                        ERL_NIF_TERM const argv[]) {
   ErlNifBinary h, p, s;
   size_t o, m;
 
@@ -1350,8 +1076,8 @@ static ERL_NIF_TERM enif_crypto_pwhash(ErlNifEnv *env, int argc,
   return enif_make_tuple2(env, ok, ret);
 }
 
-static ERL_NIF_TERM enif_crypto_pwhash_str(ErlNifEnv *env, int argc,
-                                           ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_pwhash_str(ErlNifEnv *env, int argc,
+                                            ERL_NIF_TERM const argv[]) {
   ErlNifBinary h, p;
   size_t o, m;
 
@@ -1385,8 +1111,8 @@ static ERL_NIF_TERM enif_crypto_pwhash_str(ErlNifEnv *env, int argc,
   return enif_make_tuple2(env, ok, ret);
 }
 
-static ERL_NIF_TERM enif_crypto_pwhash_str_verify(ErlNifEnv *env, int argc,
-                                                  ERL_NIF_TERM const argv[]) {
+static ERL_NIF_TERM enacl_crypto_pwhash_str_verify(ErlNifEnv *env, int argc,
+                                                   ERL_NIF_TERM const argv[]) {
   ErlNifBinary h, p;
 
   // Validate the arguments
@@ -1406,43 +1132,43 @@ static ERL_NIF_TERM enif_crypto_pwhash_str_verify(ErlNifEnv *env, int argc,
 
 /* Tie the knot to the Erlang world */
 static ErlNifFunc nif_funcs[] = {
-    {"crypto_box_NONCEBYTES", 0, enif_crypto_box_NONCEBYTES},
-    {"crypto_box_ZEROBYTES", 0, enif_crypto_box_ZEROBYTES},
-    {"crypto_box_BOXZEROBYTES", 0, enif_crypto_box_BOXZEROBYTES},
-    {"crypto_box_PUBLICKEYBYTES", 0, enif_crypto_box_PUBLICKEYBYTES},
-    {"crypto_box_SECRETKEYBYTES", 0, enif_crypto_box_SECRETKEYBYTES},
-    {"crypto_box_BEFORENMBYTES", 0, enif_crypto_box_BEFORENMBYTES},
+    {"crypto_box_NONCEBYTES", 0, enacl_crypto_box_NONCEBYTES},
+    {"crypto_box_ZEROBYTES", 0, enacl_crypto_box_ZEROBYTES},
+    {"crypto_box_BOXZEROBYTES", 0, enacl_crypto_box_BOXZEROBYTES},
+    {"crypto_box_PUBLICKEYBYTES", 0, enacl_crypto_box_PUBLICKEYBYTES},
+    {"crypto_box_SECRETKEYBYTES", 0, enacl_crypto_box_SECRETKEYBYTES},
+    {"crypto_box_BEFORENMBYTES", 0, enacl_crypto_box_BEFORENMBYTES},
 
     erl_nif_dirty_job_cpu_bound_macro("crypto_box_keypair", 0,
-                                      enif_crypto_box_keypair),
+                                      enacl_crypto_box_keypair),
 
-    erl_nif_dirty_job_cpu_bound_macro("crypto_box", 4, enif_crypto_box),
+    erl_nif_dirty_job_cpu_bound_macro("crypto_box", 4, enacl_crypto_box),
     erl_nif_dirty_job_cpu_bound_macro("crypto_box_open", 4,
-                                      enif_crypto_box_open),
+                                      enacl_crypto_box_open),
 
-    {"crypto_box_beforenm", 2, enif_crypto_box_beforenm},
-    {"crypto_box_afternm_b", 3, enif_crypto_box_afternm},
+    {"crypto_box_beforenm", 2, enacl_crypto_box_beforenm},
+    {"crypto_box_afternm_b", 3, enacl_crypto_box_afternm},
     erl_nif_dirty_job_cpu_bound_macro("crypto_box_afternm", 3,
-                                      enif_crypto_box_afternm),
-    {"crypto_box_open_afternm_b", 3, enif_crypto_box_open_afternm},
+                                      enacl_crypto_box_afternm),
+    {"crypto_box_open_afternm_b", 3, enacl_crypto_box_open_afternm},
     erl_nif_dirty_job_cpu_bound_macro("crypto_box_open_afternm", 3,
-                                      enif_crypto_box_open_afternm),
+                                      enacl_crypto_box_open_afternm),
 
-    {"crypto_sign_PUBLICKEYBYTES", 0, enif_crypto_sign_PUBLICKEYBYTES},
-    {"crypto_sign_SECRETKEYBYTES", 0, enif_crypto_sign_SECRETKEYBYTES},
+    {"crypto_sign_PUBLICKEYBYTES", 0, enacl_crypto_sign_PUBLICKEYBYTES},
+    {"crypto_sign_SECRETKEYBYTES", 0, enacl_crypto_sign_SECRETKEYBYTES},
     erl_nif_dirty_job_cpu_bound_macro("crypto_sign_keypair", 0,
-                                      enif_crypto_sign_keypair),
+                                      enacl_crypto_sign_keypair),
     erl_nif_dirty_job_cpu_bound_macro("crypto_sign_seed_keypair", 1,
-                                      enif_crypto_sign_seed_keypair),
+                                      enacl_crypto_sign_seed_keypair),
 
-    erl_nif_dirty_job_cpu_bound_macro("crypto_sign", 2, enif_crypto_sign),
+    erl_nif_dirty_job_cpu_bound_macro("crypto_sign", 2, enacl_crypto_sign),
     erl_nif_dirty_job_cpu_bound_macro("crypto_sign_open", 2,
-                                      enif_crypto_sign_open),
+                                      enacl_crypto_sign_open),
 
     erl_nif_dirty_job_cpu_bound_macro("crypto_sign_detached", 2,
-                                      enif_crypto_sign_detached),
+                                      enacl_crypto_sign_detached),
     erl_nif_dirty_job_cpu_bound_macro("crypto_sign_verify_detached", 3,
-                                      enif_crypto_sign_verify_detached),
+                                      enacl_crypto_sign_verify_detached),
     {"crypto_sign_init", 0, enacl_crypto_sign_init},
     {"crypto_sign_update", 2, enacl_crypto_sign_update},
     erl_nif_dirty_job_cpu_bound_macro("crypto_sign_final_create", 2,
@@ -1450,93 +1176,93 @@ static ErlNifFunc nif_funcs[] = {
     erl_nif_dirty_job_cpu_bound_macro("crypto_sign_final_verify", 3,
                                       enacl_crypto_sign_final_verify),
 
-    {"crypto_sign_ed25519_sk_to_pk", 1, enif_crypto_sign_ed25519_sk_to_pk},
+    {"crypto_sign_ed25519_sk_to_pk", 1, enacl_crypto_sign_ed25519_sk_to_pk},
 
-    {"crypto_box_SEALBYTES", 0, enif_crypto_box_SEALBYTES},
+    {"crypto_box_SEALBYTES", 0, enacl_crypto_box_SEALBYTES},
 
     erl_nif_dirty_job_cpu_bound_macro("crypto_box_seal", 2,
-                                      enif_crypto_box_seal),
+                                      enacl_crypto_box_seal),
     erl_nif_dirty_job_cpu_bound_macro("crypto_box_seal_open", 3,
-                                      enif_crypto_box_seal_open),
+                                      enacl_crypto_box_seal_open),
 
-    {"crypto_secretbox_NONCEBYTES", 0, enif_crypto_secretbox_NONCEBYTES},
-    {"crypto_secretbox_ZEROBYTES", 0, enif_crypto_secretbox_ZEROBYTES},
-    {"crypto_secretbox_BOXZEROBYTES", 0, enif_crypto_secretbox_BOXZEROBYTES},
-    {"crypto_secretbox_KEYBYTES", 0, enif_crypto_secretbox_KEYBYTES},
-    {"crypto_secretbox_b", 3, enif_crypto_secretbox},
+    {"crypto_secretbox_NONCEBYTES", 0, enacl_crypto_secretbox_NONCEBYTES},
+    {"crypto_secretbox_ZEROBYTES", 0, enacl_crypto_secretbox_ZEROBYTES},
+    {"crypto_secretbox_BOXZEROBYTES", 0, enacl_crypto_secretbox_BOXZEROBYTES},
+    {"crypto_secretbox_KEYBYTES", 0, enacl_crypto_secretbox_KEYBYTES},
+    {"crypto_secretbox_b", 3, enacl_crypto_secretbox},
     erl_nif_dirty_job_cpu_bound_macro("crypto_secretbox", 3,
-                                      enif_crypto_secretbox),
-    {"crypto_secretbox_open_b", 3, enif_crypto_secretbox_open},
+                                      enacl_crypto_secretbox),
+    {"crypto_secretbox_open_b", 3, enacl_crypto_secretbox_open},
     erl_nif_dirty_job_cpu_bound_macro("crypto_secretbox_open", 3,
-                                      enif_crypto_secretbox_open),
+                                      enacl_crypto_secretbox_open),
 
     {"crypto_stream_chacha20_KEYBYTES", 0,
-     enif_crypto_stream_chacha20_KEYBYTES},
+     enacl_crypto_stream_chacha20_KEYBYTES},
     {"crypto_stream_chacha20_NONCEBYTES", 0,
-     enif_crypto_stream_chacha20_NONCEBYTES},
-    {"crypto_stream_chacha20_b", 3, enif_crypto_stream_chacha20},
+     enacl_crypto_stream_chacha20_NONCEBYTES},
+    {"crypto_stream_chacha20_b", 3, enacl_crypto_stream_chacha20},
     erl_nif_dirty_job_cpu_bound_macro("crypto_stream_chacha20", 3,
-                                      enif_crypto_stream_chacha20),
-    {"crypto_stream_chacha20_xor_b", 3, enif_crypto_stream_chacha20_xor},
+                                      enacl_crypto_stream_chacha20),
+    {"crypto_stream_chacha20_xor_b", 3, enacl_crypto_stream_chacha20_xor},
     erl_nif_dirty_job_cpu_bound_macro("crypto_stream_chacha20_xor", 3,
-                                      enif_crypto_stream_chacha20_xor),
+                                      enacl_crypto_stream_chacha20_xor),
 
-    {"crypto_stream_KEYBYTES", 0, enif_crypto_stream_KEYBYTES},
-    {"crypto_stream_NONCEBYTES", 0, enif_crypto_stream_NONCEBYTES},
-    {"crypto_stream_b", 3, enif_crypto_stream},
-    erl_nif_dirty_job_cpu_bound_macro("crypto_stream", 3, enif_crypto_stream),
-    {"crypto_stream_xor_b", 3, enif_crypto_stream_xor},
+    {"crypto_stream_KEYBYTES", 0, enacl_crypto_stream_KEYBYTES},
+    {"crypto_stream_NONCEBYTES", 0, enacl_crypto_stream_NONCEBYTES},
+    {"crypto_stream_b", 3, enacl_crypto_stream},
+    erl_nif_dirty_job_cpu_bound_macro("crypto_stream", 3, enacl_crypto_stream),
+    {"crypto_stream_xor_b", 3, enacl_crypto_stream_xor},
     erl_nif_dirty_job_cpu_bound_macro("crypto_stream_xor", 3,
-                                      enif_crypto_stream_xor),
+                                      enacl_crypto_stream_xor),
 
-    {"crypto_auth_BYTES", 0, enif_crypto_auth_BYTES},
-    {"crypto_auth_KEYBYTES", 0, enif_crypto_auth_KEYBYTES},
-    {"crypto_auth_b", 2, enif_crypto_auth},
-    erl_nif_dirty_job_cpu_bound_macro("crypto_auth", 2, enif_crypto_auth),
-    {"crypto_auth_verify_b", 3, enif_crypto_auth_verify},
+    {"crypto_auth_BYTES", 0, enacl_crypto_auth_BYTES},
+    {"crypto_auth_KEYBYTES", 0, enacl_crypto_auth_KEYBYTES},
+    {"crypto_auth_b", 2, enacl_crypto_auth},
+    erl_nif_dirty_job_cpu_bound_macro("crypto_auth", 2, enacl_crypto_auth),
+    {"crypto_auth_verify_b", 3, enacl_crypto_auth_verify},
     erl_nif_dirty_job_cpu_bound_macro("crypto_auth_verify", 3,
-                                      enif_crypto_auth_verify),
+                                      enacl_crypto_auth_verify),
 
-    {"crypto_shorthash_BYTES", 0, enif_crypto_shorthash_BYTES},
-    {"crypto_shorthash_KEYBYTES", 0, enif_crypto_shorthash_KEYBYTES},
-    {"crypto_shorthash", 2, enif_crypto_shorthash},
+    {"crypto_shorthash_BYTES", 0, enacl_crypto_shorthash_BYTES},
+    {"crypto_shorthash_KEYBYTES", 0, enacl_crypto_shorthash_KEYBYTES},
+    {"crypto_shorthash", 2, enacl_crypto_shorthash},
 
-    {"crypto_onetimeauth_BYTES", 0, enif_crypto_onetimeauth_BYTES},
-    {"crypto_onetimeauth_KEYBYTES", 0, enif_crypto_onetimeauth_KEYBYTES},
-    {"crypto_onetimeauth_b", 2, enif_crypto_onetimeauth},
+    {"crypto_onetimeauth_BYTES", 0, enacl_crypto_onetimeauth_BYTES},
+    {"crypto_onetimeauth_KEYBYTES", 0, enacl_crypto_onetimeauth_KEYBYTES},
+    {"crypto_onetimeauth_b", 2, enacl_crypto_onetimeauth},
     erl_nif_dirty_job_cpu_bound_macro("crypto_onetimeauth", 2,
-                                      enif_crypto_onetimeauth),
-    {"crypto_onetimeauth_verify_b", 3, enif_crypto_onetimeauth_verify},
+                                      enacl_crypto_onetimeauth),
+    {"crypto_onetimeauth_verify_b", 3, enacl_crypto_onetimeauth_verify},
     erl_nif_dirty_job_cpu_bound_macro("crypto_onetimeauth_verify", 3,
-                                      enif_crypto_onetimeauth_verify),
+                                      enacl_crypto_onetimeauth_verify),
 
     {"crypto_hash_b", 1, enacl_crypto_hash},
     erl_nif_dirty_job_cpu_bound_macro("crypto_hash", 1, enacl_crypto_hash),
-    {"crypto_verify_16", 2, enif_crypto_verify_16},
-    {"crypto_verify_32", 2, enif_crypto_verify_32},
+    {"crypto_verify_16", 2, enacl_crypto_verify_16},
+    {"crypto_verify_32", 2, enacl_crypto_verify_32},
     {"sodium_memzero", 1, enif_sodium_memzero},
 
-    erl_nif_dirty_job_cpu_bound_macro("crypto_pwhash", 4, enif_crypto_pwhash),
+    erl_nif_dirty_job_cpu_bound_macro("crypto_pwhash", 4, enacl_crypto_pwhash),
     erl_nif_dirty_job_cpu_bound_macro("crypto_pwhash_str", 3,
-                                      enif_crypto_pwhash_str),
+                                      enacl_crypto_pwhash_str),
     erl_nif_dirty_job_cpu_bound_macro("crypto_pwhash_str_verify", 2,
-                                      enif_crypto_pwhash_str_verify),
+                                      enacl_crypto_pwhash_str_verify),
 
     erl_nif_dirty_job_cpu_bound_macro("crypto_curve25519_scalarmult", 2,
-                                      enif_crypto_curve25519_scalarmult),
+                                      enacl_crypto_curve25519_scalarmult),
     erl_nif_dirty_job_cpu_bound_macro("crypto_curve25519_scalarmult_base", 1,
-                                      enif_crypto_curve25519_scalarmult_base),
+                                      enacl_crypto_curve25519_scalarmult_base),
 
     erl_nif_dirty_job_cpu_bound_macro("crypto_sign_ed25519_keypair", 0,
-                                      enif_crypto_sign_ed25519_keypair),
+                                      enacl_crypto_sign_ed25519_keypair),
     {"crypto_sign_ed25519_public_to_curve25519", 1,
-     enif_crypto_sign_ed25519_public_to_curve25519},
+     enacl_crypto_sign_ed25519_public_to_curve25519},
     {"crypto_sign_ed25519_secret_to_curve25519", 1,
-     enif_crypto_sign_ed25519_secret_to_curve25519},
+     enacl_crypto_sign_ed25519_secret_to_curve25519},
     {"crypto_sign_ed25519_PUBLICKEYBYTES", 0,
-     enif_crypto_sign_ed25519_PUBLICKEYBYTES},
+     enacl_crypto_sign_ed25519_PUBLICKEYBYTES},
     {"crypto_sign_ed25519_SECRETKEYBYTES", 0,
-     enif_crypto_sign_ed25519_SECRETKEYBYTES},
+     enacl_crypto_sign_ed25519_SECRETKEYBYTES},
 
     // Linux might block here if early in the boot sequence, so get it off the
     // main scheduler. Otherwise, it it would probably be fine to run on the
@@ -1548,14 +1274,14 @@ static ErlNifFunc nif_funcs[] = {
                                       enif_randombytes_uniform),
 
     erl_nif_dirty_job_cpu_bound_macro("crypto_kx_keypair", 0,
-                                      enif_crypto_kx_keypair),
+                                      enacl_crypto_kx_keypair),
     erl_nif_dirty_job_cpu_bound_macro("crypto_kx_client_session_keys", 3,
-                                      enif_crypto_kx_client_session_keys),
+                                      enacl_crypto_kx_client_session_keys),
     erl_nif_dirty_job_cpu_bound_macro("crypto_kx_server_session_keys", 3,
-                                      enif_crypto_kx_server_session_keys),
-    {"crypto_kx_PUBLICKEYBYTES", 0, enif_crypto_kx_PUBLICKEYBYTES},
-    {"crypto_kx_SECRETKEYBYTES", 0, enif_crypto_kx_SECRETKEYBYTES},
-    {"crypto_kx_SESSIONKEYBYTES", 0, enif_crypto_kx_SESSIONKEYBYTES},
+                                      enacl_crypto_kx_server_session_keys),
+    {"crypto_kx_PUBLICKEYBYTES", 0, enacl_crypto_kx_PUBLICKEYBYTES},
+    {"crypto_kx_SECRETKEYBYTES", 0, enacl_crypto_kx_SECRETKEYBYTES},
+    {"crypto_kx_SESSIONKEYBYTES", 0, enacl_crypto_kx_SESSIONKEYBYTES},
 
     {"scramble_block_16", 2, enif_scramble_block_16},
 
@@ -1589,14 +1315,14 @@ static ErlNifFunc nif_funcs[] = {
         "crypto_aead_xchacha20poly1305_decrypt", 4,
         enacl_crypto_aead_xchacha20poly1305_decrypt),
 
-    {"crypto_generichash_BYTES", 0, enif_crypto_generichash_BYTES},
-    {"crypto_generichash_BYTES_MIN", 0, enif_crypto_generichash_BYTES_MIN},
-    {"crypto_generichash_BYTES_MAX", 0, enif_crypto_generichash_BYTES_MAX},
-    {"crypto_generichash_KEYBYTES", 0, enif_crypto_generichash_KEYBYTES},
+    {"crypto_generichash_BYTES", 0, enacl_crypto_generichash_BYTES},
+    {"crypto_generichash_BYTES_MIN", 0, enacl_crypto_generichash_BYTES_MIN},
+    {"crypto_generichash_BYTES_MAX", 0, enacl_crypto_generichash_BYTES_MAX},
+    {"crypto_generichash_KEYBYTES", 0, enacl_crypto_generichash_KEYBYTES},
     {"crypto_generichash_KEYBYTES_MIN", 0,
-     enif_crypto_generichash_KEYBYTES_MIN},
+     enacl_crypto_generichash_KEYBYTES_MIN},
     {"crypto_generichash_KEYBYTES_MAX", 0,
-     enif_crypto_generichash_KEYBYTES_MAX},
+     enacl_crypto_generichash_KEYBYTES_MAX},
     {"crypto_generichash", 3, enacl_crypto_generichash},
     {"crypto_generichash_init", 2, enacl_crypto_generichash_init},
     {"crypto_generichash_update", 2, enacl_crypto_generichash_update},
@@ -1604,4 +1330,4 @@ static ErlNifFunc nif_funcs[] = {
 
 };
 
-ERL_NIF_INIT(enacl_nif, nif_funcs, enif_crypto_load, NULL, NULL, NULL);
+ERL_NIF_INIT(enacl_nif, nif_funcs, enacl_crypto_load, NULL, NULL, NULL);
diff --git a/c_src/generichash.c b/c_src/generichash.c
index 9993bf7..82afd32 100644
--- a/c_src/generichash.c
+++ b/c_src/generichash.c
@@ -43,33 +43,33 @@ static void enacl_generic_hash_ctx_dtor(ErlNifEnv *env,
 /*
  * Generic hash
  */
-ERL_NIF_TERM enif_crypto_generichash_BYTES(ErlNifEnv *env, int argc,
-                                           ERL_NIF_TERM const argv[]) {
+ERL_NIF_TERM enacl_crypto_generichash_BYTES(ErlNifEnv *env, int argc,
+                                            ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_generichash_BYTES);
 }
 
-ERL_NIF_TERM enif_crypto_generichash_BYTES_MIN(ErlNifEnv *env, int argc,
-                                               ERL_NIF_TERM const argv[]) {
+ERL_NIF_TERM enacl_crypto_generichash_BYTES_MIN(ErlNifEnv *env, int argc,
+                                                ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_generichash_BYTES_MIN);
 }
 
-ERL_NIF_TERM enif_crypto_generichash_BYTES_MAX(ErlNifEnv *env, int argc,
-                                               ERL_NIF_TERM const argv[]) {
+ERL_NIF_TERM enacl_crypto_generichash_BYTES_MAX(ErlNifEnv *env, int argc,
+                                                ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_generichash_BYTES_MAX);
 }
 
-ERL_NIF_TERM enif_crypto_generichash_KEYBYTES(ErlNifEnv *env, int argc,
-                                              ERL_NIF_TERM const argv[]) {
+ERL_NIF_TERM enacl_crypto_generichash_KEYBYTES(ErlNifEnv *env, int argc,
+                                               ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_generichash_KEYBYTES);
 }
 
-ERL_NIF_TERM enif_crypto_generichash_KEYBYTES_MIN(ErlNifEnv *env, int argc,
-                                                  ERL_NIF_TERM const argv[]) {
+ERL_NIF_TERM enacl_crypto_generichash_KEYBYTES_MIN(ErlNifEnv *env, int argc,
+                                                   ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_generichash_KEYBYTES_MIN);
 }
 
-ERL_NIF_TERM enif_crypto_generichash_KEYBYTES_MAX(ErlNifEnv *env, int argc,
-                                                  ERL_NIF_TERM const argv[]) {
+ERL_NIF_TERM enacl_crypto_generichash_KEYBYTES_MAX(ErlNifEnv *env, int argc,
+                                                   ERL_NIF_TERM const argv[]) {
   return enif_make_int64(env, crypto_generichash_KEYBYTES_MAX);
 }
 
diff --git a/c_src/generichash.h b/c_src/generichash.h
index a348893..aaa9c66 100644
--- a/c_src/generichash.h
+++ b/c_src/generichash.h
@@ -3,19 +3,19 @@
 
 int enacl_init_generic_hash_ctx(ErlNifEnv *env);
 
-ERL_NIF_TERM enif_crypto_generichash_BYTES(ErlNifEnv *env, int argc,
-                                           const ERL_NIF_TERM argv[]);
-ERL_NIF_TERM enif_crypto_generichash_BYTES_MIN(ErlNifEnv *env, int argc,
-                                               const ERL_NIF_TERM argv[]);
-ERL_NIF_TERM enif_crypto_generichash_BYTES_MAX(ErlNifEnv *env, int argc,
-                                               const ERL_NIF_TERM argv[]);
+ERL_NIF_TERM enacl_crypto_generichash_BYTES(ErlNifEnv *env, int argc,
+                                            const ERL_NIF_TERM argv[]);
+ERL_NIF_TERM enacl_crypto_generichash_BYTES_MIN(ErlNifEnv *env, int argc,
+                                                const ERL_NIF_TERM argv[]);
+ERL_NIF_TERM enacl_crypto_generichash_BYTES_MAX(ErlNifEnv *env, int argc,
+                                                const ERL_NIF_TERM argv[]);
 
-ERL_NIF_TERM enif_crypto_generichash_KEYBYTES(ErlNifEnv *env, int argc,
-                                              const ERL_NIF_TERM argv[]);
-ERL_NIF_TERM enif_crypto_generichash_KEYBYTES_MIN(ErlNifEnv *env, int argc,
-                                                  const ERL_NIF_TERM argv[]);
-ERL_NIF_TERM enif_crypto_generichash_KEYBYTES_MAX(ErlNifEnv *env, int argc,
-                                                  const ERL_NIF_TERM argv[]);
+ERL_NIF_TERM enacl_crypto_generichash_KEYBYTES(ErlNifEnv *env, int argc,
+                                               const ERL_NIF_TERM argv[]);
+ERL_NIF_TERM enacl_crypto_generichash_KEYBYTES_MIN(ErlNifEnv *env, int argc,
+                                                   const ERL_NIF_TERM argv[]);
+ERL_NIF_TERM enacl_crypto_generichash_KEYBYTES_MAX(ErlNifEnv *env, int argc,
+                                                   const ERL_NIF_TERM argv[]);
 
 ERL_NIF_TERM enacl_crypto_generichash(ErlNifEnv *env, int argc,
                                       const ERL_NIF_TERM argv[]);
diff --git a/c_src/sign.c b/c_src/sign.c
index bb82f65..1413873 100644
--- a/c_src/sign.c
+++ b/c_src/sign.c
@@ -10,9 +10,9 @@ typedef struct enacl_sign_ctx {
   int alive; // Is the context still valid for updates/finalization
 } enacl_sign_ctx;
 
-static ErlNifResourceType *enacl_sign_ctx_rtype = NULL;
+ErlNifResourceType *enacl_sign_ctx_rtype = NULL;
 
-static void enacl_sign_ctx_dtor(ErlNifEnv *env, enacl_sign_ctx *);
+void enacl_sign_ctx_dtor(ErlNifEnv *env, enacl_sign_ctx *);
 
 int enacl_init_sign_ctx(ErlNifEnv *env) {
   enacl_sign_ctx_rtype =
@@ -26,7 +26,7 @@ int enacl_init_sign_ctx(ErlNifEnv *env) {
   return 1;
 }
 
-static void enacl_sign_ctx_dtor(ErlNifEnv *env, enacl_sign_ctx *obj) {
+void enacl_sign_ctx_dtor(ErlNifEnv *env, enacl_sign_ctx *obj) {
   if (!obj->alive)
     return;
 
@@ -214,3 +214,278 @@ cleanup:
 
   return ret;
 }
+
+/* Ed 25519 */
+ERL_NIF_TERM
+enacl_crypto_sign_ed25519_keypair(ErlNifEnv *env, int argc,
+                                  ERL_NIF_TERM const argv[]) {
+  ErlNifBinary pk, sk;
+
+  if (argc != 0) {
+    return enif_make_badarg(env);
+  }
+
+  if (!enif_alloc_binary(crypto_sign_ed25519_PUBLICKEYBYTES, &pk)) {
+    return nacl_error_tuple(env, "alloc_failed");
+  }
+
+  if (!enif_alloc_binary(crypto_sign_ed25519_SECRETKEYBYTES, &sk)) {
+    return nacl_error_tuple(env, "alloc_failed");
+  }
+
+  crypto_sign_ed25519_keypair(pk.data, sk.data);
+
+  return enif_make_tuple2(env, enif_make_binary(env, &pk),
+                          enif_make_binary(env, &sk));
+}
+
+ERL_NIF_TERM
+enacl_crypto_sign_ed25519_sk_to_pk(ErlNifEnv *env, int argc,
+                                   ERL_NIF_TERM const argv[]) {
+  ErlNifBinary pk, sk;
+
+  if ((argc != 1) || (!enif_inspect_binary(env, argv[0], &sk)) ||
+      (sk.size != crypto_sign_ed25519_SECRETKEYBYTES)) {
+    return enif_make_badarg(env);
+  }
+
+  if (!enif_alloc_binary(crypto_sign_ed25519_PUBLICKEYBYTES, &pk)) {
+    return nacl_error_tuple(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 enif_make_binary(env, &pk);
+}
+
+ERL_NIF_TERM
+enacl_crypto_sign_ed25519_public_to_curve25519(ErlNifEnv *env, int argc,
+                                               ERL_NIF_TERM const argv[]) {
+  ErlNifBinary curve25519_pk, ed25519_pk;
+
+  if ((argc != 1) || (!enif_inspect_binary(env, argv[0], &ed25519_pk)) ||
+      (ed25519_pk.size != crypto_sign_ed25519_PUBLICKEYBYTES)) {
+    return enif_make_badarg(env);
+  }
+
+  if (!enif_alloc_binary(crypto_scalarmult_curve25519_BYTES, &curve25519_pk)) {
+    return nacl_error_tuple(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 enif_make_binary(env, &curve25519_pk);
+}
+
+ERL_NIF_TERM
+enacl_crypto_sign_ed25519_secret_to_curve25519(ErlNifEnv *env, int argc,
+                                               ERL_NIF_TERM const argv[]) {
+  ErlNifBinary curve25519_sk, ed25519_sk;
+
+  if ((argc != 1) || (!enif_inspect_binary(env, argv[0], &ed25519_sk)) ||
+      (ed25519_sk.size != crypto_sign_ed25519_SECRETKEYBYTES)) {
+    return enif_make_badarg(env);
+  }
+
+  if (!enif_alloc_binary(crypto_scalarmult_curve25519_BYTES, &curve25519_sk)) {
+    return nacl_error_tuple(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 enif_make_binary(env, &curve25519_sk);
+}
+
+ERL_NIF_TERM
+enacl_crypto_sign_ed25519_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
+                                         ERL_NIF_TERM const argv[]) {
+  return enif_make_int64(env, crypto_sign_ed25519_PUBLICKEYBYTES);
+}
+
+ERL_NIF_TERM
+enacl_crypto_sign_ed25519_SECRETKEYBYTES(ErlNifEnv *env, int argc,
+                                         ERL_NIF_TERM const argv[]) {
+  return enif_make_int64(env, crypto_sign_ed25519_SECRETKEYBYTES);
+}
+
+ERL_NIF_TERM enacl_crypto_sign_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
+                                              ERL_NIF_TERM const argv[]) {
+  return enif_make_int64(env, crypto_sign_PUBLICKEYBYTES);
+}
+
+ERL_NIF_TERM enacl_crypto_sign_SECRETKEYBYTES(ErlNifEnv *env, int argc,
+                                              ERL_NIF_TERM const argv[]) {
+  return enif_make_int64(env, crypto_sign_SECRETKEYBYTES);
+}
+
+ERL_NIF_TERM enacl_crypto_sign_SEEDBYTES(ErlNifEnv *env, int argc,
+                                         ERL_NIF_TERM const argv[]) {
+  return enif_make_int64(env, crypto_sign_SEEDBYTES);
+}
+
+ERL_NIF_TERM enacl_crypto_sign_keypair(ErlNifEnv *env, int argc,
+                                       ERL_NIF_TERM const argv[]) {
+  ErlNifBinary pk, sk;
+
+  if (argc != 0) {
+    return enif_make_badarg(env);
+  }
+
+  if (!enif_alloc_binary(crypto_sign_PUBLICKEYBYTES, &pk)) {
+    return nacl_error_tuple(env, "alloc_failed");
+  }
+
+  if (!enif_alloc_binary(crypto_sign_SECRETKEYBYTES, &sk)) {
+    return nacl_error_tuple(env, "alloc_failed");
+  }
+
+  crypto_sign_keypair(pk.data, sk.data);
+
+  return enif_make_tuple2(env, enif_make_binary(env, &pk),
+                          enif_make_binary(env, &sk));
+}
+
+ERL_NIF_TERM enacl_crypto_sign_seed_keypair(ErlNifEnv *env, int argc,
+                                            ERL_NIF_TERM const argv[]) {
+  ErlNifBinary pk, sk, seed;
+
+  if ((argc != 1) || (!enif_inspect_binary(env, argv[0], &seed))) {
+    return enif_make_badarg(env);
+  }
+
+  if (!enif_alloc_binary(crypto_sign_PUBLICKEYBYTES, &pk)) {
+    return nacl_error_tuple(env, "alloc_failed");
+  }
+
+  if (!enif_alloc_binary(crypto_sign_SECRETKEYBYTES, &sk)) {
+    return nacl_error_tuple(env, "alloc_failed");
+  }
+
+  crypto_sign_seed_keypair(pk.data, sk.data, seed.data);
+
+  return enif_make_tuple2(env, enif_make_binary(env, &pk),
+                          enif_make_binary(env, &sk));
+}
+
+/*
+int crypto_sign(unsigned char *sm, unsigned long long *smlen,
+                const unsigned char *m, unsigned long long mlen,
+                const unsigned char *sk);
+ */
+ERL_NIF_TERM enacl_crypto_sign(ErlNifEnv *env, int argc,
+                               ERL_NIF_TERM const argv[]) {
+  ErlNifBinary m, sk, sm;
+  unsigned long long smlen;
+
+  if ((argc != 2) || (!enif_inspect_iolist_as_binary(env, argv[0], &m)) ||
+      (!enif_inspect_binary(env, argv[1], &sk))) {
+    return enif_make_badarg(env);
+  }
+
+  if (sk.size != crypto_sign_SECRETKEYBYTES) {
+    return enif_make_badarg(env);
+  }
+
+  if (!enif_alloc_binary(m.size + crypto_sign_BYTES, &sm)) {
+    return nacl_error_tuple(env, "alloc_failed");
+  }
+
+  crypto_sign(sm.data, &smlen, m.data, m.size, sk.data);
+
+  return enif_make_sub_binary(env, enif_make_binary(env, &sm), 0, smlen);
+}
+
+/*
+int crypto_sign_open(unsigned char *m, unsigned long long *mlen,
+                     const unsigned char *sm, unsigned long long smlen,
+                     const unsigned char *pk);
+ */
+ERL_NIF_TERM enacl_crypto_sign_open(ErlNifEnv *env, int argc,
+                                    ERL_NIF_TERM const argv[]) {
+  ErlNifBinary m, sm, pk;
+  unsigned long long mlen;
+
+  if ((argc != 2) || (!enif_inspect_iolist_as_binary(env, argv[0], &sm)) ||
+      (!enif_inspect_binary(env, argv[1], &pk))) {
+    return enif_make_badarg(env);
+  }
+
+  if (pk.size != crypto_sign_PUBLICKEYBYTES) {
+    return enif_make_badarg(env);
+  }
+
+  if (!enif_alloc_binary(sm.size, &m)) {
+    return nacl_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 nacl_error_tuple(env, "failed_verification");
+  }
+}
+
+/*
+int crypto_sign_detached(unsigned char *sig, unsigned long long *siglen,
+                         const unsigned char *m, unsigned long long mlen,
+                         const unsigned char *sk);
+ */
+ERL_NIF_TERM enacl_crypto_sign_detached(ErlNifEnv *env, int argc,
+                                        ERL_NIF_TERM const argv[]) {
+  ErlNifBinary m, sk, sig;
+  unsigned long long siglen;
+
+  if ((argc != 2) || (!enif_inspect_iolist_as_binary(env, argv[0], &m)) ||
+      (!enif_inspect_binary(env, argv[1], &sk))) {
+    return enif_make_badarg(env);
+  }
+
+  if (sk.size != crypto_sign_SECRETKEYBYTES) {
+    return enif_make_badarg(env);
+  }
+
+  if (!enif_alloc_binary(crypto_sign_BYTES, &sig)) {
+    return nacl_error_tuple(env, "alloc_failed");
+  }
+
+  crypto_sign_detached(sig.data, &siglen, m.data, m.size, sk.data);
+
+  return enif_make_binary(env, &sig);
+}
+
+/*
+int crypto_sign_verify_detached(const unsigned char *sig,
+                                const unsigned char *m,
+                                unsigned long long mlen,
+                                const unsigned char *pk);
+ */
+ERL_NIF_TERM
+enacl_crypto_sign_verify_detached(ErlNifEnv *env, int argc,
+                                  ERL_NIF_TERM const argv[]) {
+  ErlNifBinary m, sig, pk;
+
+  if ((argc != 3) || (!enif_inspect_binary(env, argv[0], &sig)) ||
+      (!enif_inspect_iolist_as_binary(env, argv[1], &m)) ||
+      (!enif_inspect_binary(env, argv[2], &pk))) {
+    return enif_make_badarg(env);
+  }
+
+  if (pk.size != crypto_sign_PUBLICKEYBYTES) {
+    return enif_make_badarg(env);
+  }
+
+  if (0 == crypto_sign_verify_detached(sig.data, m.data, m.size, pk.data)) {
+    return enif_make_atom(env, "true");
+  } else {
+    return enif_make_atom(env, "false");
+  }
+}
diff --git a/c_src/sign.h b/c_src/sign.h
index 5b91ce3..fced63a 100644
--- a/c_src/sign.h
+++ b/c_src/sign.h
@@ -16,4 +16,55 @@ ERL_NIF_TERM enacl_crypto_sign_final_create(ErlNifEnv *env, int argc,
 
 ERL_NIF_TERM enacl_crypto_sign_final_verify(ErlNifEnv *env, int argc,
                                             ERL_NIF_TERM const argv[]);
+
+ERL_NIF_TERM enacl_crypto_sign_ed25519_keypair(ErlNifEnv *env, int argc,
+                                               ERL_NIF_TERM const argv[]);
+
+ERL_NIF_TERM enacl_crypto_sign_ed25519_sk_to_pk(ErlNifEnv *env, int argc,
+                                                ERL_NIF_TERM const argv[]);
+
+ERL_NIF_TERM
+enacl_crypto_sign_ed25519_public_to_curve25519(ErlNifEnv *env, int argc,
+                                               ERL_NIF_TERM const argv[]);
+
+ERL_NIF_TERM
+enacl_crypto_sign_ed25519_secret_to_curve25519(ErlNifEnv *env, int argc,
+                                               ERL_NIF_TERM const argv[]);
+
+ERL_NIF_TERM
+enacl_crypto_sign_ed25519_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
+                                         ERL_NIF_TERM const argv[]);
+
+ERL_NIF_TERM
+enacl_crypto_sign_ed25519_SECRETKEYBYTES(ErlNifEnv *env, int argc,
+                                         ERL_NIF_TERM const argv[]);
+
+ERL_NIF_TERM enacl_crypto_sign_PUBLICKEYBYTES(ErlNifEnv *env, int argc,
+                                              ERL_NIF_TERM const argv[]);
+
+ERL_NIF_TERM enacl_crypto_sign_SECRETKEYBYTES(ErlNifEnv *env, int argc,
+                                              ERL_NIF_TERM const argv[]);
+
+ERL_NIF_TERM enacl_crypto_sign_SEEDBYTES(ErlNifEnv *env, int argc,
+                                         ERL_NIF_TERM const argv[]);
+
+ERL_NIF_TERM enacl_crypto_sign_keypair(ErlNifEnv *env, int argc,
+                                       ERL_NIF_TERM const argv[]);
+
+ERL_NIF_TERM enacl_crypto_sign_seed_keypair(ErlNifEnv *env, int argc,
+                                            ERL_NIF_TERM const argv[]);
+
+ERL_NIF_TERM enacl_crypto_sign(ErlNifEnv *env, int argc,
+                               ERL_NIF_TERM const argv[]);
+
+ERL_NIF_TERM enacl_crypto_sign_open(ErlNifEnv *env, int argc,
+                                    ERL_NIF_TERM const argv[]);
+
+ERL_NIF_TERM enacl_crypto_sign_detached(ErlNifEnv *env, int argc,
+                                        ERL_NIF_TERM const argv[]);
+
+ERL_NIF_TERM
+enacl_crypto_sign_verify_detached(ErlNifEnv *env, int argc,
+                                  ERL_NIF_TERM const argv[]);
+
 #endif
\ No newline at end of file