diff --git a/dap_chain_cert.c b/dap_chain_cert.c
index cbb86f7decd3e3a89c60fca9d9410ec4038ac0af..58236df28bb79de636fbd8f786ef39e2bdae4d12 100755
--- a/dap_chain_cert.c
+++ b/dap_chain_cert.c
@@ -60,12 +60,10 @@ typedef struct dap_chain_cert_pvt
 } dap_chain_cert_pvt_t;
 
 
-#define PVT(a) ( ( dap_chain_cert_pvt_t *)(a->_pvt) )
+#define PVT(a) ( ( dap_chain_cert_pvt_t *)((a)->_pvt) )
 
 static dap_chain_cert_item_t * s_certs = NULL;
 
-dap_chain_cert_t * dap_chain_cert_new(const char * a_name);
-void dap_chain_cert_delete(dap_chain_cert_t * a_cert);
 /**
  * @brief dap_chain_cert_init
  * @return
@@ -135,7 +133,7 @@ size_t dap_chain_cert_parse_str_list(const char * a_certs_str, dap_chain_cert_t
  */
 size_t dap_chain_cert_sign_output_size(dap_chain_cert_t * a_cert, size_t a_size_wished)
 {
-    return dap_chain_sign_create_output_cals_size( a_cert->enc_key,a_size_wished);
+    return dap_chain_sign_create_output_unserialized_calc_size( a_cert->enc_key,a_size_wished);
 }
 
 /**
diff --git a/dap_chain_cert_file.c b/dap_chain_cert_file.c
index 50e51c1b605368225bdb895ddead5e672c0356f9..fc11c1e5a2f6597a9e4b85459e52d6bcb2b5fa8c 100755
--- a/dap_chain_cert_file.c
+++ b/dap_chain_cert_file.c
@@ -77,8 +77,8 @@ uint8_t* dap_chain_cert_mem_save(dap_chain_cert_t * a_cert, uint32_t *a_cert_siz
     dap_enc_key_t * l_key = a_cert->enc_key;
     uint8_t *l_data = NULL;
 
-    size_t l_priv_key_data_size = a_cert->enc_key->priv_key_data_size,
-            l_pub_key_data_size = a_cert->enc_key->pub_key_data_size;
+    size_t l_priv_key_data_size = a_cert->enc_key->priv_key_data_size;
+    size_t l_pub_key_data_size = a_cert->enc_key->pub_key_data_size;
     uint8_t *l_pub_key_data = a_cert->enc_key->pub_key_data_size ?
                 dap_enc_key_serealize_pub_key(l_key, &l_pub_key_data_size) :
                 NULL;
diff --git a/dap_chain_sign.c b/dap_chain_sign.c
index 92f8b102717688a52a13ca84706bb5f3c94c7af1..54f7c639f3254870635f6c308a53f6c67a4666d7 100755
--- a/dap_chain_sign.c
+++ b/dap_chain_sign.c
@@ -37,14 +37,14 @@ static dap_chain_sign_t * s_sign_null = NULL;
 static bliss_signature_t s_sign_bliss_null = {0};
 
 // calc signature size
-size_t dap_chain_sign_create_output_cals_size(dap_enc_key_t * a_key, size_t a_output_wish_size )
+size_t dap_chain_sign_create_output_unserialized_calc_size(dap_enc_key_t * a_key, size_t a_output_wish_size )
 {
     size_t l_sign_size = 0;
     switch (a_key->type){
         case DAP_ENC_KEY_TYPE_SIG_BLISS: l_sign_size = sizeof(s_sign_bliss_null); break;
         case DAP_ENC_KEY_TYPE_SIG_PICNIC: l_sign_size = dap_enc_picnic_calc_signature_size(a_key); break;
         case DAP_ENC_KEY_TYPE_SIG_TESLA: l_sign_size = dap_enc_tesla_calc_signature_size(); break;
-        case DAP_ENC_KEY_TYPE_SIG_DILITHIUM: l_sign_size = dap_enc_dilithium_calc_signature_size(); break;
+        case DAP_ENC_KEY_TYPE_SIG_DILITHIUM: l_sign_size = dap_enc_dilithium_calc_signature_unserialized_size(); break;
         default : return 0;
 
     }
@@ -52,6 +52,7 @@ size_t dap_chain_sign_create_output_cals_size(dap_enc_key_t * a_key, size_t a_ou
     //return sizeof(s_sign_null->header)+ a_key->pub_key_data_size + l_sign_size;
 }
 
+
 /**
  * @brief dap_chain_sign_type_from_key_type
  * @param a_key_type
@@ -143,17 +144,20 @@ static int dap_chain_sign_create_output(dap_enc_key_t *a_key, const void * a_dat
         return -1;
     }
     switch (a_key->type) {
-    case DAP_ENC_KEY_TYPE_SIG_TESLA:
-    case DAP_ENC_KEY_TYPE_SIG_PICNIC:
-    case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
-            // For PICNIC a_output_size should decrease
-        *a_output_size = a_key->enc_na(a_key, a_data, a_data_size, a_output, *a_output_size);
-        return (*a_output_size > 0) ? 0 : -1;
-    case DAP_ENC_KEY_TYPE_SIG_BLISS:
-        return (dap_enc_sig_bliss_get_sign(a_key, a_data, a_data_size, a_output, *a_output_size) == BLISS_B_NO_ERROR)
-               ? 0 : -1;
-    default:
-        return -1;
+        case DAP_ENC_KEY_TYPE_SIG_TESLA:
+        case DAP_ENC_KEY_TYPE_SIG_PICNIC:
+        case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
+                // For PICNIC a_output_size should decrease
+            *a_output_size = dap_enc_sig_dilithium_get_sign(a_key,a_data,a_data_size,a_output,sizeof(dilithium_signature_t));
+             //       a_key->enc_na(a_key, a_data, a_data_size, a_output, *a_output_size);
+            return (*a_output_size > 0) ? 0 : -1;
+
+
+        case DAP_ENC_KEY_TYPE_SIG_BLISS:
+            return (dap_enc_sig_bliss_get_sign(a_key, a_data, a_data_size, a_output, *a_output_size) == BLISS_B_NO_ERROR)
+                   ? 0 : -1;
+        default:
+            return -1;
     }
 }
 
@@ -169,33 +173,40 @@ dap_chain_sign_t * dap_chain_sign_create(dap_enc_key_t *a_key, const void * a_da
         const size_t a_data_size, size_t a_output_wish_size)
 {
     // calculate max signature size
-    size_t l_sign_size = dap_chain_sign_create_output_cals_size(a_key, a_output_wish_size);
-    if(l_sign_size > 0) {
+    size_t l_sign_unserialized_size = dap_chain_sign_create_output_unserialized_calc_size(a_key, a_output_wish_size);
+    if(l_sign_unserialized_size > 0) {
         size_t l_pub_key_size = 0;
         uint8_t *l_pub_key = dap_enc_key_serealize_pub_key(a_key, &l_pub_key_size);
         if(!l_pub_key)
             return NULL;
-        uint8_t* l_sign = DAP_NEW_Z_SIZE(uint8_t, l_sign_size);
+        uint8_t* l_sign_unserialized = DAP_NEW_Z_SIZE(uint8_t, l_sign_unserialized_size);
         // calc signature [sign_size may decrease slightly]
-        if(dap_chain_sign_create_output(a_key, a_data, a_data_size, l_sign, &l_sign_size) != 0) {
-            dap_enc_key_signature_delete(a_key->type, l_sign);
+        if( dap_chain_sign_create_output(a_key, a_data, a_data_size,
+                                         l_sign_unserialized, &l_sign_unserialized_size) != 0) {
+            dap_enc_key_signature_delete(a_key->type, l_sign_unserialized);
             DAP_DELETE(l_pub_key);
             return NULL;
         } else {
-            uint8_t *l_sign_ser = dap_enc_key_serealize_sign(a_key->type, l_sign, &l_sign_size);
-            dap_chain_sign_t * l_ret = DAP_NEW_Z_SIZE(dap_chain_sign_t,
-                    sizeof(dap_chain_sign_t) + l_sign_size + l_pub_key_size);
-            // write serialized public key to dap_chain_sign_t
-            memcpy(l_ret->pkey_n_sign, l_pub_key, l_pub_key_size);
-            l_ret->header.type = dap_chain_sign_type_from_key_type(a_key->type);
-            // write serialized signature to dap_chain_sign_t
-            memcpy(l_ret->pkey_n_sign + l_pub_key_size, l_sign_ser, l_sign_size);
-            l_ret->header.sign_pkey_size = l_pub_key_size;
-            l_ret->header.sign_size = l_sign_size;
-            DAP_DELETE(l_sign_ser);
-            dap_enc_key_signature_delete(a_key->type, l_sign);
-            DAP_DELETE(l_pub_key);
-            return l_ret;
+            size_t l_sign_ser_size =0;
+            uint8_t *l_sign_ser = dap_enc_key_serealize_sign(a_key->type, l_sign_unserialized, &l_sign_ser_size);
+            if ( l_sign_ser ){
+                dap_chain_sign_t * l_ret = DAP_NEW_Z_SIZE(dap_chain_sign_t,
+                        sizeof(dap_chain_sign_hdr_t) + l_sign_ser_size + l_pub_key_size);
+                // write serialized public key to dap_chain_sign_t
+                memcpy(l_ret->pkey_n_sign, l_pub_key, l_pub_key_size);
+                l_ret->header.type = dap_chain_sign_type_from_key_type(a_key->type);
+                // write serialized signature to dap_chain_sign_t
+                memcpy(l_ret->pkey_n_sign + l_pub_key_size, l_sign_ser, l_sign_ser_size);
+                l_ret->header.sign_pkey_size =(uint32_t) l_pub_key_size;
+                l_ret->header.sign_size = (uint32_t) l_sign_ser_size;
+                DAP_DELETE(l_sign_ser);
+                dap_enc_key_signature_delete(a_key->type, l_sign_unserialized);
+                DAP_DELETE(l_pub_key);
+                return l_ret;
+            }else {
+                log_it(L_WARNING,"Can't serialize signature: NULL returned");
+                return NULL;
+            }
         }
     }
     return NULL;
@@ -258,7 +269,8 @@ int dap_chain_sign_verify(dap_chain_sign_t * a_chain_sign, const void * a_data,
     int l_ret;
     dap_enc_key_t * l_key = dap_chain_sign_to_enc_key(a_chain_sign);
     size_t l_sign_size = a_chain_sign->header.sign_size;
-    uint8_t *l_sign_ser = dap_chain_sign_get_sign(a_chain_sign, &l_sign_size);
+    size_t l_sign_ser_size;
+    uint8_t *l_sign_ser = dap_chain_sign_get_sign(a_chain_sign, &l_sign_ser_size);
     // deserialize signature
     uint8_t * l_sign = dap_enc_key_deserealize_sign(l_key->type, l_sign_ser, &l_sign_size);
 
diff --git a/dap_chain_sign.h b/dap_chain_sign.h
index a5def39e94267468f052a61acd2e20c4a2cae62d..812e0da00cc278a5c7498b8d0a0d2bf5774e34ec 100755
--- a/dap_chain_sign.h
+++ b/dap_chain_sign.h
@@ -33,17 +33,20 @@
 
 
 
-/**
-  * @struct dap_chain_sign
-  * @brief Chain storage format for digital signature
-  */
-typedef struct dap_chain_sign{
-    struct {
+typedef struct dap_chain_sign_hdr{
         dap_chain_sign_type_t type; /// Signature type
         uint8_t padding[2]; /// Padding for better aligmnent
         uint16_t sign_size; /// Signature size
         uint32_t sign_pkey_size; /// Signature serialized public key size
-    } header; /// Only header's hash is used for verification
+} DAP_ALIGN_PACKED dap_chain_sign_hdr_t;
+
+/**
+  * @struct dap_chain_sign
+  * @brief Chain storage format for digital signature
+  */
+typedef struct dap_chain_sign
+{
+    dap_chain_sign_hdr_t header; /// Only header's hash is used for verification
     uint8_t pkey_n_sign[]; /// @param sig @brief raw signature data
 } DAP_ALIGN_PACKED dap_chain_sign_t;
 
@@ -53,7 +56,7 @@ int dap_chain_sign_verify (dap_chain_sign_t * a_chain_sign, const void * a_data,
 
 dap_chain_sign_t * dap_chain_sign_create(dap_enc_key_t *a_key, const void * a_data, const size_t a_data_size
                                          ,  size_t a_output_wish_size );
-size_t dap_chain_sign_create_output_cals_size(dap_enc_key_t * a_key,size_t a_output_wish_size );
+size_t dap_chain_sign_create_output_unserialized_calc_size(dap_enc_key_t * a_key,size_t a_output_wish_size );
 //int dap_chain_sign_create_output(dap_enc_key_t *a_key, const void * a_data, const size_t a_data_size
 //                                 , void * a_output, size_t a_output_size );