diff --git a/issuer.c b/issuer.c
index d7ce429..42127af 100644
--- a/issuer.c
+++ b/issuer.c
@@ -149,7 +149,7 @@ int issuer_joinstart(char *buffer) {
     bzero(buffer, MAX_BUFSIZE);
     strncpy(buffer, "JOINSTART ", 10);
     current = &buffer[10];
-    ecdaa_bintohex(issuer.nonce, current, NONCE_SIZE);
+    ecdaa_encode(issuer.nonce, current, NONCE_SIZE);
     buffer[2 * NONCE_SIZE + 10] = '\n';
     return 0;
 }
@@ -161,7 +161,7 @@ int issuer_joinproceed(char *buffer) {
     bzero(binbuf, MAX_BUFSIZE);
     int ret = 0;
 
-    ecdaa_hextobin(current, binbuf, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH);
+    ecdaa_decode(current, binbuf, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH);
     bzero(buffer, MAX_BUFSIZE);
     ret = ecdaa_member_public_key_FP256BN_deserialize(&issuer.mpk, binbuf, issuer.nonce, NONCE_SIZE);
     if(-1 == ret) {
@@ -185,14 +185,14 @@ int issuer_joinproceed(char *buffer) {
     current = &buffer[12];
     bzero(binbuf, MAX_BUFSIZE);
     ecdaa_credential_FP256BN_serialize(binbuf, &issuer.cred);
-    ecdaa_bintohex(binbuf, current, ECDAA_CREDENTIAL_FP256BN_LENGTH);
+    ret = ecdaa_encode(binbuf, current, ECDAA_CREDENTIAL_FP256BN_LENGTH);
 
-    current = &buffer[12 + 2 * ECDAA_CREDENTIAL_FP256BN_LENGTH + 1];
+    current = &current[ret];
     bzero(binbuf, MAX_BUFSIZE);
     ecdaa_credential_FP256BN_signature_serialize(binbuf, &issuer.cred_sig);
-    ecdaa_bintohex(binbuf, current, ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH);
+    ret = ecdaa_encode(binbuf, current, ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH);
 
-    buffer[2 * ECDAA_CREDENTIAL_FP256BN_LENGTH + 1 + 2 * ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH + 12] = '\n';
+    current[ret] = '\n';
     return 0;
 }
 
@@ -242,15 +242,16 @@ int issuer_publish(char *buffer) {
     char *current;
     uint8_t binbuf[MAX_BUFSIZE];
     bzero(buffer, MAX_BUFSIZE);
+    int ret = 0;
 
     strncpy(buffer, "PUBLISH ", 8);
 
     current = &buffer[8];
     bzero(binbuf, MAX_BUFSIZE);
     ecdaa_issuer_public_key_FP256BN_serialize(binbuf, &issuer.ipk);
-    ecdaa_bintohex(binbuf, current, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH);
+    ret = ecdaa_encode(binbuf, current, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH);
 
-    buffer[2 * ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH + 8] = '\n';
+    current[ret] = '\n';
 
     return 0;
 }
diff --git a/issuer.h b/issuer.h
index 71abf10..e0f9adc 100644
--- a/issuer.h
+++ b/issuer.h
@@ -2,8 +2,8 @@
 // Created by root on 11/5/19.
 //
 
-#ifndef ECDAA_ISSUER_ISSUER_H
-#define ECDAA_ISSUER_ISSUER_H
+#ifndef ECDAA_ISSUER_H
+#define ECDAA_ISSUER_H
 #include <ecdaa.h>
 #include "server.h"
 #include "client.h"
@@ -13,4 +13,4 @@ int process_issuer(char *buffer);
 const char* issuer_public_key_file = "ipk.bin";
 const char* issuer_secret_key_file = "isk.bin";
 
-#endif //ECDAA_ISSUER_ISSUER_H
+#endif //ECDAA_ISSUER_H
diff --git a/member.c b/member.c
index 2170705..8c4c073 100644
--- a/member.c
+++ b/member.c
@@ -102,7 +102,7 @@ int member_join(char *buffer) {
                 printf("ISSUER > MEMBER: %s", buffer);
                 uint8_t binbuf[MAX_BUFSIZE];
                 char *current = &buffer[8];
-                ecdaa_hextobin(current, binbuf, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH);
+                ecdaa_decode(current, binbuf, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH);
                 ret = ecdaa_issuer_public_key_FP256BN_deserialize(&member.ipk, binbuf);
                 if (-1 == ret) {
                     printf("member_getpublic: issuer public key is malformed!\n");
@@ -161,6 +161,7 @@ int member_verifymsg(char *buffer) {
     uint8_t has_nym = member.bsn_len > 0 ? 1 : 0;
     struct ecdaa_signature_FP256BN sig;
     size_t sig_len = has_nym ? ecdaa_signature_FP256BN_with_nym_length() : ecdaa_signature_FP256BN_length();
+    int ret = 0;
 
     if (0 == strncasecmp("OK", buffer, 2)) {
         return 1;
@@ -173,8 +174,8 @@ int member_verifymsg(char *buffer) {
     strncpy(current, "VERIFYMSG ", 10);
     current = &current[10];
 
-    ecdaa_bintohex(msg, current, msg_len);
-    current = &current[2 * MAX_MSGSIZE];
+    ret = ecdaa_encode(msg, current, msg_len);
+    current = &current[ret];
     if(has_nym) {
         if (0 != ecdaa_signature_FP256BN_sign(&sig, msg, msg_len, member.bsn, member.bsn_len, &member.msk, &member.cred, ecdaa_rand)) {
             printf("member_verifymsg: Signing message failed\n");
@@ -193,19 +194,20 @@ int member_verifymsg(char *buffer) {
 
     bzero(binbuf, MAX_BUFSIZE);
     ecdaa_signature_FP256BN_serialize(binbuf, &sig, has_nym);
-    ecdaa_bintohex(binbuf, current, sig_len);
+    ret = ecdaa_encode(binbuf, current, sig_len);
     printf("member_verifymsg: has_nym: %u, sig_len: %lu\n",has_nym, sig_len);
     printf("member_verifymsg: msg: %s, len: %lu\n",msg, msg_len);
     printf("member_verifymsg: bsn: %s, len: %lu\n",(char *)member.bsn, strlen((char *)member.bsn));
     printf("member_verifymsg: sig: %s, len: %lu\n", current, sig_len);
 
-    current[2 * sig_len] = '\n';
+    current[ret] = '\n';
     return 0;
 }
 
 //"PUBLISH" > "PUBLISH <member.mpk>"
 int member_publish(char *buffer) {
     char *current;
+    int ret = 0;
     uint8_t binbuf[MAX_BUFSIZE];
     bzero(buffer, MAX_BUFSIZE);
 
@@ -214,9 +216,9 @@ int member_publish(char *buffer) {
     current = &buffer[8];
     bzero(binbuf, MAX_BUFSIZE);
     ecdaa_member_public_key_FP256BN_serialize(binbuf, &member.mpk);
-    ecdaa_bintohex(binbuf, current, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH);
+    ret = ecdaa_encode(binbuf, current, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH);
 
-    current[2 * ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH] = '\n';
+    current[ret] = '\n';
 
     return 0;
 }
@@ -225,7 +227,7 @@ int member_publish(char *buffer) {
 int member_joinappend(char *buffer) {
     char *current = &buffer[10];
     uint8_t binbuf[MAX_BUFSIZE];
-    ecdaa_hextobin(current, member.nonce, NONCE_SIZE);
+    int ret = ecdaa_decode(current, member.nonce, NONCE_SIZE);
     ecdaa_write_buffer_to_file(member_nonce_file, member.nonce, NONCE_SIZE);
 //    if (0 != ecdaa_member_key_pair_TPM_FP256BN_generate(&member.mpk, member.nonce, NONCE_SIZE)) {
     if (0 != ecdaa_member_key_pair_FP256BN_generate(&member.mpk, &member.msk, member.nonce, NONCE_SIZE, ecdaa_rand)) {
@@ -238,8 +240,8 @@ int member_joinappend(char *buffer) {
     current = &buffer[7];
     bzero(binbuf, MAX_BUFSIZE);
     ecdaa_member_public_key_FP256BN_serialize(binbuf, &member.mpk);
-    ecdaa_bintohex(binbuf, current, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH);
-    current[2 * ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH] = '\n';
+    ret = ecdaa_encode(binbuf, current, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH);
+    current[ret] = '\n';
     return 0;
 }
 
@@ -250,11 +252,11 @@ int member_joinfinish(char *buffer) {
     uint8_t binbuf[MAX_BUFSIZE];
     int ret = 0;
     bzero(binbuf, MAX_BUFSIZE);
-    ecdaa_hextobin(current, binbuf, ECDAA_CREDENTIAL_FP256BN_LENGTH);
+    ret = ecdaa_decode(current, binbuf, ECDAA_CREDENTIAL_FP256BN_LENGTH);
 
-    current = &buffer[12 + 2 * ECDAA_CREDENTIAL_FP256BN_LENGTH + 1];
+    current = &current[ret];
     bincur = &binbuf[ECDAA_CREDENTIAL_FP256BN_LENGTH];
-    ecdaa_hextobin(current, bincur, ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH);
+    ecdaa_decode(current, bincur, ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH);
     ret = ecdaa_credential_FP256BN_deserialize_with_signature(&member.cred, &member.mpk, &member.ipk.gpk, binbuf, bincur);
     if(-1 == ret) {
         printf("member_joinfinish: credential is malformed!\n");
diff --git a/member.h b/member.h
index d55c583..bb75daf 100644
--- a/member.h
+++ b/member.h
@@ -1,9 +1,6 @@
-//
-// Created by root on 11/5/19.
-//
 
-#ifndef ECDAA_ISSUER_MEMBER_H
-#define ECDAA_ISSUER_MEMBER_H
+#ifndef ECDAA_MEMBER_H
+#define ECDAA_MEMBER_H
 #include <ecdaa.h>
 #include <ecdaa.h>
 #include "server.h"
@@ -17,4 +14,4 @@ const char* member_secret_key_file = "msk.bin";
 const char* member_credential_file = "mcred.bin";
 const char* member_nonce_file = "mnonce.bin";
 
-#endif //ECDAA_ISSUER_ISSUER_H
+#endif //ECDAA_ISSUER_H
diff --git a/verifier.c b/verifier.c
index 7a82567..654592a 100644
--- a/verifier.c
+++ b/verifier.c
@@ -131,7 +131,7 @@ int verifier_getissuer(char *buffer) {
                 printf("ISSUER > VERIFIER: %s", buffer);
                 uint8_t binbuf[MAX_BUFSIZE];
                 char *current = &buffer[8];
-                ecdaa_hextobin(current, binbuf, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH);
+                ecdaa_decode(current, binbuf, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH);
                 ret = ecdaa_issuer_public_key_FP256BN_deserialize(&verifier.ipk, binbuf);
                 if (-1 == ret) {
                     printf("verifier_getpublic: issuer public key is malformed!\n");
@@ -211,9 +211,9 @@ int verifier_checkattest(char *buffer) {
     int ret = 0;
 
     bzero(msg, MAX_MSGSIZE);
-    ecdaa_hextobin(current, msg, MAX_MSGSIZE);
+    ret = ecdaa_decode(current, msg, MAX_MSGSIZE);
     msg_len = strlen(msg);
-    current = &current[2 * MAX_MSGSIZE];
+    current = &current[ret];
     has_nym = current[0] - '0';
     current = &current[1];
 
@@ -229,7 +229,7 @@ int verifier_checkattest(char *buffer) {
         
     }
     bzero(binbuf, MAX_BUFSIZE);
-    ecdaa_hextobin(current, binbuf, sig_len);
+    ecdaa_decode(current, binbuf, sig_len);
 
     ret = ecdaa_signature_FP256BN_deserialize(&sig, binbuf, has_nym);
     if (0 != ret) {
diff --git a/verifier.h b/verifier.h
index 6139cce..5bf25f5 100644
--- a/verifier.h
+++ b/verifier.h
@@ -1,9 +1,6 @@
-//
-// Created by root on 11/5/19.
-//
 
-#ifndef ECDAA_ISSUER_MEMBER_H
-#define ECDAA_ISSUER_MEMBER_H
+#ifndef ECDAA_VERIFIER_H
+#define ECDAA_VERIFIER_H
 #include <ecdaa.h>
 // #include <ecdaa-tpm.h>
 #include "server.h"
@@ -12,4 +9,4 @@
 
 int process_verifier(char *buffer);
 
-#endif //ECDAA_ISSUER_ISSUER_H
+#endif //ECDAA_VERIFIER_H