diff --git a/dap-sdk/crypto/include/dap_enc_base64.h b/dap-sdk/crypto/include/dap_enc_base64.h
index 2fc27e454fc717a1cb97166e3beeb71c1e3d8596..7d69ba7bc85192a97bd6132e2d02abded9c311b0 100755
--- a/dap-sdk/crypto/include/dap_enc_base64.h
+++ b/dap-sdk/crypto/include/dap_enc_base64.h
@@ -38,6 +38,8 @@ extern "C" {
 
 size_t dap_enc_base64_decode(const char * in, size_t in_size, void * out, dap_enc_data_type_t standard);
 size_t dap_enc_base64_encode(const void * in, size_t in_size, char * out, dap_enc_data_type_t standard);
+char * dap_enc_strdup_to_base64(const char * a_string);
+char * dap_enc_strdup_from_base64(const char * a_string_base64);
 
 #ifdef __cplusplus
 }
diff --git a/dap-sdk/crypto/src/dap_enc_base64.c b/dap-sdk/crypto/src/dap_enc_base64.c
index 4501e7d3ab6705efae9c6332a03ae38d533459f9..b0f1351cead5ee1bb8329ec6fd6b50dbddbfa74d 100755
--- a/dap-sdk/crypto/src/dap_enc_base64.c
+++ b/dap-sdk/crypto/src/dap_enc_base64.c
@@ -271,6 +271,33 @@ size_t dap_enc_base64_encode(const void * a_in, size_t a_in_size, char * a_out,
     return size;
 }
 
+char * dap_enc_strdup_to_base64(const char * a_string){
+    size_t l_string_len = strlen(a_string);
+    size_t l_string_base64_len = DAP_ENC_BASE64_ENCODE_SIZE(l_string_len) + 1;
+    char * l_string_base64 = DAP_NEW_SIZE(char, l_string_base64_len);
+    size_t l_string_base64_len_res = dap_enc_base64_encode(a_string, l_string_len, l_string_base64, DAP_ENC_DATA_TYPE_B64);
+    l_string_base64[l_string_base64_len_res] = '\0';
+    return l_string_base64;
+}
+
+char * dap_enc_strdup_from_base64(const char * a_string_base64){
+    if(!a_string_base64)
+        return NULL;
+
+    size_t l_string_base64_len = strlen(a_string_base64);
+    if(!l_string_base64_len)
+        return NULL;
+
+    char * l_string = DAP_NEW_Z_SIZE(byte_t, l_string_base64_len * 2);
+    size_t l_string_len = dap_enc_base64_decode(a_string_base64, l_string_base64_len, l_string, DAP_ENC_DATA_TYPE_B64_URLSAFE);
+
+    if(!l_string_len){
+        DAP_DELETE(l_string);
+        return NULL;
+    }
+    return l_string;
+}
+
 
 // get the size of the result buffer required for Base-64
 // encoding/decoding.
diff --git a/modules/app-cli/dap_app_cli_net.c b/modules/app-cli/dap_app_cli_net.c
index 2ab51bd7625ccc0d9e6184809599c1515d271e52..517a42d105e349fc71a4ff1431c9c5b44cabe31e 100644
--- a/modules/app-cli/dap_app_cli_net.c
+++ b/modules/app-cli/dap_app_cli_net.c
@@ -169,15 +169,6 @@ bool s_dap_app_cli_cmd_contains_forbidden_symbol(const char * a_cmd_param){
     return false;
 }
 
-char * s_dap_app_cli_strdup_to_base64(const char * a_cmd_param){
-    size_t l_cmd_param_len = strlen(a_cmd_param);
-    size_t l_cmd_param_base64_len = DAP_ENC_BASE64_ENCODE_SIZE(l_cmd_param_len) + 1;
-    char * l_cmd_param_base64 = DAP_NEW_SIZE(char, l_cmd_param_base64_len);
-    size_t l_cmd_param_base64_len_res = dap_enc_base64_encode(a_cmd_param, l_cmd_param_len, l_cmd_param_base64, DAP_ENC_DATA_TYPE_B64);
-    l_cmd_param_base64[l_cmd_param_base64_len_res] = '\0';
-    return l_cmd_param_base64;
-}
-
 /**
  * Send request to kelvin-node
  *
@@ -198,7 +189,7 @@ int dap_app_cli_post_command( dap_app_cli_connect_param_t *a_socket, dap_app_cli
             if (a_cmd->cmd_param[i]) {
                 dap_string_append(l_cmd_data, "\r\n");
                 if(s_dap_app_cli_cmd_contains_forbidden_symbol(a_cmd->cmd_param[i])){
-                    char * l_cmd_param_base64 = s_dap_app_cli_strdup_to_base64(a_cmd->cmd_param[i]);
+                    char * l_cmd_param_base64 = dap_enc_strdup_to_base64(a_cmd->cmd_param[i]);
                     dap_string_append(l_cmd_data, l_cmd_param_base64);
                     DAP_DELETE(l_cmd_param_base64);
                 }else{
diff --git a/modules/common/dap_chain_datum_tx.c b/modules/common/dap_chain_datum_tx.c
index 0bdb9260550bdd590f66badd8d3f5076660aa29e..2c8a7d8f450c1f5ce4e3f0f538fa1cae008a2212 100644
--- a/modules/common/dap_chain_datum_tx.c
+++ b/modules/common/dap_chain_datum_tx.c
@@ -227,7 +227,7 @@ int dap_chain_datum_tx_verify_sign(dap_chain_datum_tx_t *tx)
     while(tx_items_pos < tx_items_size) {
         uint8_t *item = tx->tx_items + tx_items_pos;
         size_t l_item_tx_size = dap_chain_datum_item_tx_get_size(item);
-        if(!l_item_tx_size)
+        if(!l_item_tx_size || l_item_tx_size > tx_items_size)
             return -3;
         if(dap_chain_datum_tx_item_get_type(item) == TX_ITEM_TYPE_SIG) {
             dap_chain_tx_sig_t *l_item_tx_sig = (dap_chain_tx_sig_t*) item;
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index 3ce4bad29790c13c02403a5d40b57e079ac7a21f..39f82f919e49a75a52a96b22c5be6267c3324ce2 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -503,19 +503,21 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
                 default:
                     log_it(L_INFO, "Node sync error %d",l_res);
                 }
-                l_res = dap_stream_ch_chain_pkt_write(dap_client_get_stream_ch(l_node_client->client, dap_stream_ch_chain_get_id()),
-                                                      DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_GLOBAL_DB_RVRS, l_net->pub.id, l_chain_id,
-                                                      l_net->pub.cell_id, &l_sync_gdb, sizeof(l_sync_gdb));
-                l_res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_SYNCED, timeout_ms);
-                switch (l_res) {
-                case -1:
-                    log_it(L_WARNING,"Timeout with link sync");
-                    break;
-                case 0:
-                    log_it(L_INFO, "Node sync completed");
-                    break;
-                default:
-                    log_it(L_INFO, "Node sync error %d",l_res);
+                if (!dap_client_get_stream_ch(l_node_client->client, dap_stream_ch_chain_get_id())) {
+                    l_res = dap_stream_ch_chain_pkt_write(dap_client_get_stream_ch(l_node_client->client, dap_stream_ch_chain_get_id()),
+                                                          DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_GLOBAL_DB_RVRS, l_net->pub.id, l_chain_id,
+                                                          l_net->pub.cell_id, &l_sync_gdb, sizeof(l_sync_gdb));
+                    l_res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_SYNCED, timeout_ms);
+                    switch (l_res) {
+                    case -1:
+                        log_it(L_WARNING,"Timeout with link sync");
+                        break;
+                    case 0:
+                        log_it(L_INFO, "Node sync completed");
+                        break;
+                    default:
+                        log_it(L_INFO, "Node sync error %d",l_res);
+                    }
                 }
                 l_tmp = dap_list_next(l_tmp);
             }
@@ -542,6 +544,7 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
                     continue;
                 }
                 dap_chain_t * l_chain = NULL;
+                int l_res = 0;
                 DL_FOREACH (l_net->pub.chains, l_chain) {
                     l_node_client->state = NODE_CLIENT_STATE_CONNECTED;
                     dap_stream_ch_chain_sync_request_t l_request ;
@@ -551,37 +554,41 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
                     // wait for finishing of request
                     int timeout_ms = 120000; // 2 min = 120 sec = 120 000 ms
                     // TODO add progress info to console
-                    int l_res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_SYNCED, timeout_ms);
-                    switch (l_res) {
-                    case -1:
-                        log_it(L_WARNING,"Timeout with sync of chain '%s' ", l_chain->name);
-                        break;
-                    case 0:
-                        l_need_flush = true;
-                        log_it(L_INFO, "Sync of chain '%s' completed ", l_chain->name);
-                        break;
-                    default:
-                        log_it(L_ERROR, "Sync of chain '%s' error %d", l_chain->name,l_res);
+                    if (dap_client_get_stream_ch(l_node_client->client, dap_stream_ch_chain_get_id())) {
+                        l_res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_SYNCED, timeout_ms);
+                        switch (l_res) {
+                        case -1:
+                            log_it(L_WARNING,"Timeout with sync of chain '%s' ", l_chain->name);
+                            break;
+                        case 0:
+                            l_need_flush = true;
+                            log_it(L_INFO, "Sync of chain '%s' completed ", l_chain->name);
+                            break;
+                        default:
+                            log_it(L_ERROR, "Sync of chain '%s' error %d", l_chain->name,l_res);
+                        }
                     }
-                    dap_stream_ch_chain_pkt_write(l_ch_chain, DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_CHAINS_RVRS, l_net->pub.id,
-                                                  l_chain->id, l_net->pub.cell_id, &l_request, sizeof(l_request));
-                    l_res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_SYNCED, timeout_ms);
-                    switch (l_res) {
-                    case -1:
-                        log_it(L_WARNING,"Timeout with reverse sync of chain '%s' ", l_chain->name);
-                        break;
-                    case 0:
-                        l_need_flush = true;
-                        log_it(L_INFO, "Reverse sync of chain '%s' completed ", l_chain->name);
-                        // set time of last sync
-                        {
-                            struct timespec l_to;
-                            clock_gettime(CLOCK_MONOTONIC, &l_to);
-                            l_pvt_net->last_sync = l_to.tv_sec;
+                    if (dap_client_get_stream_ch(l_node_client->client, dap_stream_ch_chain_get_id())) {
+                        dap_stream_ch_chain_pkt_write(l_ch_chain, DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_CHAINS_RVRS, l_net->pub.id,
+                                                      l_chain->id, l_net->pub.cell_id, &l_request, sizeof(l_request));
+                        l_res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_SYNCED, timeout_ms);
+                        switch (l_res) {
+                        case -1:
+                            log_it(L_WARNING,"Timeout with reverse sync of chain '%s' ", l_chain->name);
+                            break;
+                        case 0:
+                            l_need_flush = true;
+                            log_it(L_INFO, "Reverse sync of chain '%s' completed ", l_chain->name);
+                            // set time of last sync
+                            {
+                                struct timespec l_to;
+                                clock_gettime(CLOCK_MONOTONIC, &l_to);
+                                l_pvt_net->last_sync = l_to.tv_sec;
+                            }
+                            break;
+                        default:
+                            log_it(L_ERROR, "Reverse sync of chain '%s' error %d", l_chain->name,l_res);
                         }
-                        break;
-                    default:
-                        log_it(L_ERROR, "Reverse sync of chain '%s' error %d", l_chain->name,l_res);
                     }
                 }
                 l_tmp = dap_list_next(l_tmp);