diff --git a/dap_chain_global_db.c b/dap_chain_global_db.c
index d8207871990f57a85c4361ee4df143b437746e1a..20400651685ba65fac46b0d67fbcf5211c6757ec 100755
--- a/dap_chain_global_db.c
+++ b/dap_chain_global_db.c
@@ -22,12 +22,12 @@
  along with any DAP based project.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <string.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <pthread.h>
 #include <time.h>
 #include <assert.h>
+#include <string.h>
 
 #include "uthash.h"
 
@@ -83,7 +83,7 @@ char * extract_group_prefix(const char * a_group);
  * @param a_group
  * @return
  */
-char * extract_group_prefix(const char * a_group)
+char * extract_group_prefix(const char* a_group)
 {
     char * l_group_prefix = NULL, *l_delimeter;
     size_t l_group_prefix_size;
@@ -340,7 +340,7 @@ bool dap_chain_global_db_set( char *a_key,  void *a_value, size_t a_value_len)
 /**
  * Delete entry from base
  */
-bool dap_chain_global_db_gr_del(const char *a_key, const char *a_group)
+bool dap_chain_global_db_gr_del(char *a_key, char *a_group)
 {
     if(!a_key)
         return NULL;
@@ -376,7 +376,7 @@ bool dap_chain_global_db_gr_del(const char *a_key, const char *a_group)
         return true;
     return false;
 }
-bool dap_chain_global_db_del(const char *a_key)
+bool dap_chain_global_db_del(char *a_key)
 {
     return dap_chain_global_db_gr_del(a_key, GROUP_LOCAL_GENERAL);
 }
@@ -477,7 +477,7 @@ bool dap_chain_global_db_obj_save(void* a_store_data, size_t a_objs_count)
     if(!l_res) {
         for(size_t i = 0; i < a_objs_count; i++) {
             history_group_item_t * l_history_group_item = NULL;
-            dap_store_obj_t* l_obj = a_store_data + i;
+            dap_store_obj_t* l_obj = (dap_store_obj_t*)a_store_data + i;
             char * l_group_prefix = extract_group_prefix(l_obj->group);
             if(l_group_prefix)
                 HASH_FIND_STR(s_history_group_items, l_group_prefix, l_history_group_item);
@@ -485,13 +485,13 @@ bool dap_chain_global_db_obj_save(void* a_store_data, size_t a_objs_count)
             if(l_history_group_item) {
                 if(l_history_group_item->auto_track) {
                     lock();
-                    dap_db_history_add(l_obj->type, l_obj, 1);
+                    dap_db_history_add((char)l_obj->type, l_obj, 1);
                     unlock();
                 }
                 if(l_history_group_item->callback_notify) {
                     if(l_obj) {
                         l_history_group_item->callback_notify(l_history_group_item->callback_arg,
-                                l_obj->type,
+                                (const char)l_obj->type,
                                 l_group_prefix, l_obj->group, l_obj->key,
                                 l_obj->value, l_obj->value_len);
                     } else {
diff --git a/dap_chain_global_db.h b/dap_chain_global_db.h
index 42217a81a931c98e8eb7fc92e76f54df4afda9ad..bfac6c4bc32259340255e0ff4af1ba21ce59c713 100755
--- a/dap_chain_global_db.h
+++ b/dap_chain_global_db.h
@@ -68,8 +68,8 @@ bool dap_chain_global_db_set( char *a_key, void *a_value, size_t a_value_len);
 /**
  * Delete entry from base
  */
-bool dap_chain_global_db_gr_del(const char *a_key, const char *a_group);
-bool dap_chain_global_db_del(const char *a_key);
+bool dap_chain_global_db_gr_del(char *a_key, char *a_group);
+bool dap_chain_global_db_del(char *a_key);
 
 /**
  * Read the entire database into an array of size bytes
diff --git a/dap_chain_global_db_driver.c b/dap_chain_global_db_driver.c
index f3fffbd6fb8b0547811144007af8b87c3b2d6b13..0909f3874de1e101d5e725b1b7d01f1d57a4582d 100755
--- a/dap_chain_global_db_driver.c
+++ b/dap_chain_global_db_driver.c
@@ -310,7 +310,7 @@ char* dap_chain_global_db_driver_hash(const uint8_t *data, size_t data_size)
     dap_hash_fast(data, data_size, &l_hash);
     size_t a_str_max = (sizeof(l_hash.raw) + 1) * 2 + 2; /* heading 0x */
     char *a_str = DAP_NEW_Z_SIZE(char, a_str_max);
-    size_t hash_len = dap_chain_hash_fast_to_str(&l_hash, a_str, a_str_max);
+    size_t hash_len = (size_t)dap_chain_hash_fast_to_str(&l_hash, a_str, a_str_max);
     if(!hash_len) {
         DAP_DELETE(a_str);
         return NULL;
diff --git a/dap_chain_global_db_driver.h b/dap_chain_global_db_driver.h
index a0f88d8cdef187bb2db4271894935b7be041316d..30785a401b3c1e25f16cbc21b5dbef061a564e8d 100755
--- a/dap_chain_global_db_driver.h
+++ b/dap_chain_global_db_driver.h
@@ -34,7 +34,7 @@ typedef struct dap_store_obj {
     time_t timestamp;
 	uint8_t type;
     char *group;
-	char *key;
+    char *key;
     const char *c_group;
     const char *c_key;
     uint8_t *value;
diff --git a/dap_chain_global_db_driver_cdb.c b/dap_chain_global_db_driver_cdb.c
index 6f8e9e075f66170aeee6253c7baa6b484f1c62be..40fb4a0245ca97685ab9f7cddd40f03c71517ce9 100644
--- a/dap_chain_global_db_driver_cdb.c
+++ b/dap_chain_global_db_driver_cdb.c
@@ -90,10 +90,16 @@ static void cdb_serialize_val_to_dap_store_obj(pdap_store_obj_t a_obj, const cha
     a_obj->value = DAP_NEW_SIZE(uint8_t, a_obj->value_len);
     memcpy(a_obj->value, val + offset, a_obj->value_len);
     offset += a_obj->value_len;
-    a_obj->timestamp = dap_cdb_hex_to_uint(val + offset, sizeof(time_t));
+    a_obj->timestamp = (time_t)dap_cdb_hex_to_uint(val + offset, sizeof(time_t));
 }
 
 bool dap_cdb_get_last_obj_iter_callback(void *arg, const char *key, int ksize, const char *val, int vsize, uint32_t expire, uint64_t oid) {
+    UNUSED(ksize);
+    UNUSED(val);
+    UNUSED(vsize);
+    UNUSED(expire);
+    UNUSED(oid);
+
     if (--((pobj_arg)arg)->q == 0) {
         cdb_serialize_val_to_dap_store_obj((pdap_store_obj_t)(((pobj_arg)arg)->o), key, val);
         return false;
@@ -102,6 +108,12 @@ bool dap_cdb_get_last_obj_iter_callback(void *arg, const char *key, int ksize, c
 }
 
 bool dap_cdb_get_some_obj_iter_callback(void *arg, const char *key, int ksize, const char *val, int vsize, uint32_t expire, uint64_t oid) {
+    UNUSED(ksize);
+    UNUSED(val);
+    UNUSED(vsize);
+    UNUSED(expire);
+    UNUSED(oid);
+
     pdap_store_obj_t l_obj = (pdap_store_obj_t)((pobj_arg)arg)->o;
     cdb_serialize_val_to_dap_store_obj(&l_obj[((pobj_arg)arg)->n - ((pobj_arg)arg)->q], key, val);
     if (--((pobj_arg)arg)->q == 0) {
@@ -111,6 +123,12 @@ bool dap_cdb_get_some_obj_iter_callback(void *arg, const char *key, int ksize, c
 }
 
 bool dap_cdb_get_cond_obj_iter_callback(void *arg, const char *key, int ksize, const char *val, int vsize, uint32_t expire, uint64_t oid) {
+    UNUSED(ksize);
+    UNUSED(val);
+    UNUSED(vsize);
+    UNUSED(expire);
+    UNUSED(oid);
+
     if (dap_cdb_hex_to_uint(val, sizeof(uint64_t)) < ((pobj_arg)arg)->id) {
         return true;
     }
@@ -172,6 +190,7 @@ pcdb_instance dap_cdb_init_group(char *a_group, int a_flags) {
         log_it(L_INFO, "Group \"%s\" truncated"             , l_cdb_i->local_group);
         l_cdb_i->id = 0;
     }
+
 FIN:
     pthread_mutex_unlock(&cdb_mutex);
     return l_cdb_i;
@@ -225,7 +244,7 @@ pcdb_instance dap_cdb_get_db_by_group(const char *a_group) {
 }
 
 int dap_cdb_add_group(const char *a_group) {
-    char l_cdb_path[strlen(s_cdb_path) + strlen(a_group) + 2];
+    char* l_cdb_path = malloc(strlen(s_cdb_path) + strlen(a_group) + 2);
     memset(l_cdb_path, '\0', strlen(s_cdb_path) + strlen(a_group) + 2);
     strcat(l_cdb_path, s_cdb_path);
     strcat(l_cdb_path, "/");
@@ -237,6 +256,7 @@ int dap_cdb_add_group(const char *a_group) {
     mkdir(l_cdb_path, 0755);
 #endif
 
+    free(l_cdb_path);
     return 0;
 }
 
@@ -288,7 +308,7 @@ dap_store_obj_t *dap_db_driver_cdb_read_store_obj(const char *a_group, const cha
     if (a_key) {
         char *l_value;
         int l_vsize;
-        cdb_get(l_cdb, a_key, strlen(a_key), (void**)&l_value, &l_vsize);
+        cdb_get(l_cdb, a_key, (int)strlen(a_key), (void**)&l_value, &l_vsize);
         if (!l_value) {
             return NULL;
         }
@@ -404,7 +424,7 @@ int dap_db_driver_cdb_apply_store_obj(pdap_store_obj_t a_store_obj) {
         dap_cdb_uint_to_hex(l_val + offset, l_time, sizeof(time_t));
         offset += sizeof(time_t);
         l_rec.val = l_val;
-        if (cdb_set2(l_cdb_i->cdb, l_rec.key, strlen(l_rec.key), l_rec.val, offset, CDB_INSERTCACHE | CDB_OVERWRITE, 0) != CDB_SUCCESS) {
+        if (cdb_set2(l_cdb_i->cdb, l_rec.key, (int)strlen(l_rec.key), l_rec.val, offset, CDB_INSERTCACHE | CDB_OVERWRITE, 0) != CDB_SUCCESS) {
             log_it(L_ERROR, "Couldn't add record with key [%s] to CDB: \"%s\"", l_rec.key, cdb_errmsg(cdb_errno(l_cdb_i->cdb)));
             ret = -1;
         }
@@ -412,7 +432,7 @@ int dap_db_driver_cdb_apply_store_obj(pdap_store_obj_t a_store_obj) {
         DAP_DELETE(l_rec.val);
     } else if(a_store_obj->type == 'd') {
         if(a_store_obj->key) {
-            cdb_del(l_cdb_i->cdb, a_store_obj->key, strlen(a_store_obj->key));
+            cdb_del(l_cdb_i->cdb, a_store_obj->key, (int)strlen(a_store_obj->key));
         } else {
             cdb_destroy(l_cdb_i->cdb);
             if (!dap_cdb_init_group(a_store_obj->group, CDB_TRUNC | CDB_PAGEWARMUP)) {
diff --git a/dap_chain_global_db_driver_cdb.h b/dap_chain_global_db_driver_cdb.h
index e24254f06d64ffd3e4b7d7589b05d3f691a97861..0ac61e23d7c404c9351ef5727fbe36344e264377 100644
--- a/dap_chain_global_db_driver_cdb.h
+++ b/dap_chain_global_db_driver_cdb.h
@@ -24,6 +24,7 @@
 
 #include "cuttdb.h"
 #include "dap_chain_global_db_driver.h"
+#define UNUSED(x) (void)(x)
 
 typedef struct _cdb_options {
     int hsize;      // Main hash table size, 1%-10% of total records, immutable
diff --git a/dap_chain_global_db_driver_sqlite.c b/dap_chain_global_db_driver_sqlite.c
index 990bda5c7a0917411b7dc7b7267f320d34ac9f2b..3083dc21c6ad4aabcc585de9839f7554b001d47c 100755
--- a/dap_chain_global_db_driver_sqlite.c
+++ b/dap_chain_global_db_driver_sqlite.c
@@ -45,13 +45,14 @@ typedef struct _SQLITE_VALUE_
      #define SQLITE_BLOB     4
      #define SQLITE_NULL     5
      */
+    uint8_t reserv[3];
     union
     {
         int val_int;
         long long val_int64;
         double val_float;
-        char *val_str;
-        unsigned char *val_blob;
+        const char *val_str;
+        const unsigned char *val_blob;
     } val;
 } SQLITE_VALUE;
 
@@ -59,6 +60,7 @@ typedef struct _SQLITE_VALUE_
 typedef struct _SQLITE_ROW_VALUE_
 {
     int count; // number of columns in a row
+    int reserv;
     SQLITE_VALUE *val; // array of field values
 } SQLITE_ROW_VALUE;
 
@@ -116,10 +118,10 @@ int dap_db_driver_sqlite_deinit(void)
 // additional function for sqlite to convert byte to number
 static void byte_to_bin(sqlite3_context *l_context, int a_argc, sqlite3_value **a_argv)
 {
-    unsigned char *l_text;
+    const unsigned char *l_text;
     if(a_argc != 1)
         sqlite3_result_null(l_context);
-    l_text = (unsigned char *) sqlite3_value_blob(a_argv[0]);
+    l_text = (const unsigned char *) sqlite3_value_blob(a_argv[0]);
     if(l_text && l_text[0])
             {
         int l_result = (int) l_text[0];
@@ -331,7 +333,7 @@ static int dap_db_driver_sqlite_fetch_array(sqlite3_stmt *l_res, SQLITE_ROW_VALU
         l_row = (SQLITE_ROW_VALUE*) sqlite3_malloc(sizeof(SQLITE_ROW_VALUE));
         int l_count = sqlite3_column_count(l_res); // get the number of columns
         // allocate memory for all columns
-        l_row->val = (SQLITE_VALUE*) sqlite3_malloc(l_count * sizeof(SQLITE_VALUE));
+        l_row->val = (SQLITE_VALUE*) sqlite3_malloc(l_count * (int)sizeof(SQLITE_VALUE));
         if(l_row->val)
         {
             l_row->count = l_count; // number of columns
@@ -339,7 +341,7 @@ static int dap_db_driver_sqlite_fetch_array(sqlite3_stmt *l_res, SQLITE_ROW_VALU
                     {
                 SQLITE_VALUE *cur_val = l_row->val + l_iCol;
                 cur_val->len = sqlite3_column_bytes(l_res, l_iCol); // how many bytes will be needed
-                cur_val->type = sqlite3_column_type(l_res, l_iCol); // field type
+                cur_val->type = (signed char)sqlite3_column_type(l_res, l_iCol); // field type
                 if(cur_val->type == SQLITE_INTEGER)
                 {
                     cur_val->val.val_int64 = sqlite3_column_int64(l_res, l_iCol);
@@ -348,9 +350,9 @@ static int dap_db_driver_sqlite_fetch_array(sqlite3_stmt *l_res, SQLITE_ROW_VALU
                 else if(cur_val->type == SQLITE_FLOAT)
                     cur_val->val.val_float = sqlite3_column_double(l_res, l_iCol);
                 else if(cur_val->type == SQLITE_BLOB)
-                    cur_val->val.val_blob = (unsigned char*) sqlite3_column_blob(l_res, l_iCol);
+                    cur_val->val.val_blob = (const unsigned char*) sqlite3_column_blob(l_res, l_iCol);
                 else if(cur_val->type == SQLITE_TEXT)
-                    cur_val->val.val_str = (char*) sqlite3_column_text(l_res, l_iCol); //sqlite3_mprintf("%s",sqlite3_column_text(l_res,iCol));
+                    cur_val->val.val_str = (const char*) sqlite3_column_text(l_res, l_iCol); //sqlite3_mprintf("%s",sqlite3_column_text(l_res,iCol));
                 else
                     cur_val->val.val_str = NULL;
             }
@@ -388,7 +390,7 @@ static char* dap_db_driver_get_string_from_blob(uint8_t *blob, int len)
     if(!blob)
         return NULL;
     str_out = (char*) sqlite3_malloc(len * 2 + 1);
-    ret = dap_bin2hex((char*) str_out, blob, len);
+    ret = (int)dap_bin2hex(str_out, (const void*)blob, (size_t)len);
     str_out[len * 2] = 0;
     return str_out;
 
@@ -442,7 +444,7 @@ int dap_db_driver_sqlite_end_transaction(void)
 char *dap_db_driver_sqlite_make_table_name(const char *a_group_name)
 {
     char *l_group_name = dap_strdup(a_group_name);
-    ssize_t l_group_name_len = dap_strlen(l_group_name);
+    ssize_t l_group_name_len = (ssize_t)dap_strlen(l_group_name);
     const char *l_needle = ".";
     // replace '.' to '_'
     while(1){
@@ -472,7 +474,7 @@ int dap_db_driver_sqlite_apply_store_obj(dap_store_obj_t *a_store_obj)
         //dap_hash_fast(a_store_obj->value, a_store_obj->value_len, &l_hash);
 
         char *l_blob_hash = "";//dap_db_driver_get_string_from_blob((uint8_t*) &l_hash, sizeof(dap_chain_hash_fast_t));
-        char *l_blob_value = dap_db_driver_get_string_from_blob(a_store_obj->value, a_store_obj->value_len);
+        char *l_blob_value = dap_db_driver_get_string_from_blob(a_store_obj->value, (int)a_store_obj->value_len);
         //add one record
         char *table_name = dap_db_driver_sqlite_make_table_name(a_store_obj->group);
         l_query = sqlite3_mprintf("insert into '%s' values(NULL, '%s', x'%s', '%lld', x'%s')",
@@ -544,7 +546,7 @@ static void fill_one_item(const char *a_group, dap_store_obj_t *a_obj, SQLITE_RO
         switch (l_iCol) {
         case 0:
             if(l_cur_val->type == SQLITE_INTEGER)
-                a_obj->id = l_cur_val->val.val_int64;
+                a_obj->id = (uint64_t)l_cur_val->val.val_int64;
             break; // id
         case 1:
             if(l_cur_val->type == SQLITE_INTEGER)
@@ -622,7 +624,7 @@ dap_store_obj_t* dap_db_driver_sqlite_read_cond_store_obj(const char *a_group, u
     // no limit
     int l_count_out = 0;
     if(a_count_out)
-        l_count_out = *a_count_out;
+        l_count_out = (int)*a_count_out;
     char *l_str_query;
     if(l_count_out)
         l_str_query = sqlite3_mprintf("SELECT id,ts,key,value FROM '%s' WHERE id>'%lld' ORDER BY id ASC LIMIT %d",
@@ -652,8 +654,8 @@ dap_store_obj_t* dap_db_driver_sqlite_read_cond_store_obj(const char *a_group, u
             // realloc memory
             if(l_count_out >= l_count_sized) {
                 l_count_sized += 10;
-                l_obj = DAP_REALLOC(l_obj, sizeof(dap_store_obj_t) * l_count_sized);
-                memset(l_obj + l_count_out, 0, sizeof(dap_store_obj_t) * (l_count_sized - l_count_out));
+                l_obj = DAP_REALLOC(l_obj, sizeof(dap_store_obj_t) * (uint64_t)l_count_sized);
+                memset(l_obj + l_count_out, 0, sizeof(dap_store_obj_t) * (uint64_t)(l_count_sized - l_count_out));
             }
             // fill current item
             dap_store_obj_t *l_obj_cur = l_obj + l_count_out;
@@ -666,7 +668,7 @@ dap_store_obj_t* dap_db_driver_sqlite_read_cond_store_obj(const char *a_group, u
     dap_db_driver_sqlite_query_free(l_res);
 
     if(a_count_out)
-        *a_count_out = l_count_out;
+        *a_count_out = (size_t)l_count_out;
     return l_obj;
 }
 
@@ -686,7 +688,7 @@ dap_store_obj_t* dap_db_driver_sqlite_read_store_obj(const char *a_group, const
     if(!a_group)
         return NULL;
     // no limit
-    int l_count_out = 0;
+    uint64_t l_count_out = 0;
     if(a_count_out)
         l_count_out = *a_count_out;
     char *l_str_query;
@@ -716,7 +718,7 @@ dap_store_obj_t* dap_db_driver_sqlite_read_store_obj(const char *a_group, const
     //int b = qlite3_column_count(s_db);
     SQLITE_ROW_VALUE *l_row = NULL;
     l_count_out = 0;
-    int l_count_sized = 0;
+    uint64_t l_count_sized = 0;
     do {
         l_ret = dap_db_driver_sqlite_fetch_array(l_res, &l_row);
         if(l_ret != SQLITE_ROW && l_ret != SQLITE_DONE)
diff --git a/dap_chain_global_db_hist.c b/dap_chain_global_db_hist.c
index 8d6c7a4c8d993ee09d107a1d73b6efd26063b693..dfd70e4973be3cc54733f877135b27ccfcfaa8b0 100755
--- a/dap_chain_global_db_hist.c
+++ b/dap_chain_global_db_hist.c
@@ -22,6 +22,7 @@ typedef struct dap_tx_data{
         size_t obj_num;
         size_t pos_num;
         dap_chain_addr_t addr;
+        char reserv[3];
         UT_hash_handle hh;
 } dap_tx_data_t;
 
@@ -109,12 +110,12 @@ uint8_t* dap_db_log_pack(dap_global_db_obj_t *a_obj, size_t *a_data_size_out)
             return NULL;
         }
         // save record type: 'a' or 'd'
-        l_obj->type = l_rec.type;
+        l_obj->type = (uint8_t)l_rec.type;
 
         memcpy(l_store_obj + i, l_obj, sizeof(dap_store_obj_t));
         DAP_DELETE(l_obj);
         i++;
-    };
+    }
     // serialize data
     dap_store_obj_pkt_t *l_data_out = dap_store_packet_multiple(l_store_obj, l_timestamp, l_count);
 
@@ -787,7 +788,7 @@ char* dap_db_history_filter(dap_chain_addr_t * a_addr, const char *a_group_mempo
                     dap_list_t *l_list_out_items = dap_chain_datum_tx_items_get(l_tx, TX_ITEM_TYPE_OUT, &l_count);
                     dap_list_t *l_list_tmp = l_list_out_items;
                     while(l_list_tmp) {
-                        const dap_chain_tx_out_t *l_tx_out = (const dap_chain_tx_out_t*) l_list_tmp->data;
+                        dap_chain_tx_out_t *l_tx_out = (dap_chain_tx_out_t*) l_list_tmp->data;
                         // save OUT item l_tx_out
                         {
                             // save tx hash
@@ -801,7 +802,7 @@ char* dap_db_history_filter(dap_chain_addr_t * a_addr, const char *a_group_mempo
                             // save token name
                             if(l_tx_data && l_list_tx_token) {
                                 dap_chain_tx_token_t *tk = l_list_tx_token->data;
-                                int d = sizeof(l_tx_data->token_ticker);
+//                                int d = sizeof(l_tx_data->token_ticker);
                                 memcpy(l_tx_data->token_ticker, tk->header.ticker, sizeof(l_tx_data->token_ticker));
                             }
                             HASH_ADD(hh, l_tx_data_hash, tx_hash, sizeof(dap_chain_hash_fast_t), l_tx_data);
diff --git a/dap_chain_global_db_remote.h b/dap_chain_global_db_remote.h
index 2453611dc84e875cf38d5c01f75911e67a935891..e85bf5d889b7dace5a3258d297ef358f77d67382 100755
--- a/dap_chain_global_db_remote.h
+++ b/dap_chain_global_db_remote.h
@@ -13,4 +13,3 @@ uint64_t dap_db_get_cur_node_addr(void);
 bool dap_db_log_set_last_id_remote(uint64_t a_node_addr, uint64_t a_id);
 // Get last id for remote node
 uint64_t dap_db_log_get_last_id_remote(uint64_t a_node_addr);
-