diff --git a/dap-sdk b/dap-sdk
index 7cb4e6b9c8efa99c492cbd2ca68f9424647f1122..0e4b729ab659a7fc882b6df526cf2b9f87cdaaeb 160000
--- a/dap-sdk
+++ b/dap-sdk
@@ -1 +1 @@
-Subproject commit 7cb4e6b9c8efa99c492cbd2ca68f9424647f1122
+Subproject commit 0e4b729ab659a7fc882b6df526cf2b9f87cdaaeb
diff --git a/modules/consensus/esbocs/dap_chain_cs_esbocs.c b/modules/consensus/esbocs/dap_chain_cs_esbocs.c
index b7f5204d98d2c5cf94c7a681c8bce2e9c8758cd3..2c1d6399f17c67319e9eee4cd1440f75e83ec448 100644
--- a/modules/consensus/esbocs/dap_chain_cs_esbocs.c
+++ b/modules/consensus/esbocs/dap_chain_cs_esbocs.c
@@ -426,8 +426,11 @@ static void s_new_atom_notifier(void *a_arg, dap_chain_t *a_chain, dap_chain_cel
     pthread_mutex_lock(&l_session->mutex);
     dap_chain_hash_fast_t l_last_block_hash;
     dap_chain_get_atom_last_hash(l_session->chain, a_id, &l_last_block_hash);
-    if (!dap_hash_fast_compare(&l_last_block_hash, &l_session->cur_round.last_block_hash))
+    if (!dap_hash_fast_compare(&l_last_block_hash, &l_session->cur_round.last_block_hash) &&
+            !l_session->new_round_enqueued) {
+        l_session->new_round_enqueued = true;
         s_session_round_new(l_session);
+    }
     pthread_mutex_unlock(&l_session->mutex);
     if (!PVT(l_session->esbocs)->collecting_addr)
         return;
@@ -1109,6 +1112,7 @@ static bool s_session_round_new(void *a_arg)
             s_session_send_startsync(a_session);
     }
     a_session->round_fast_forward = false;
+    a_session->new_round_enqueued = false;
     a_session->sync_failed = false;
     a_session->listen_ensure = 0;
     return false;
@@ -1396,8 +1400,11 @@ static void s_session_state_change(dap_chain_esbocs_session_t *a_session, enum s
             s_session_state_change(a_session, a_session->old_state, a_time);
         else {
             log_it(L_ERROR, "No previous state registered, can't roll back");
-            dap_proc_thread_t *l_thread = DAP_PROC_THREAD(dap_context_current());
-            dap_proc_thread_callback_add(l_thread, s_session_round_new, a_session);
+            if (!a_session->new_round_enqueued) {
+                a_session->new_round_enqueued = true;
+                dap_proc_thread_t *l_thread = DAP_PROC_THREAD(dap_context_current());
+                dap_proc_thread_callback_add(l_thread, s_session_round_new, a_session);
+            }
         }
     }
     default:
@@ -1427,8 +1434,11 @@ static void s_session_proc_state(void *a_arg)
                                                                 " Round finished by reason: attempts is out",
                                                                     l_session->chain->net_name, l_session->chain->name,
                                                                         l_session->cur_round.id);
-                dap_proc_thread_t *l_thread = DAP_PROC_THREAD(dap_context_current());
-                dap_proc_thread_callback_add(l_thread, s_session_round_new, l_session);
+                if (!l_session->new_round_enqueued) {
+                    l_session->new_round_enqueued = true;
+                    dap_proc_thread_t *l_thread = DAP_PROC_THREAD(dap_context_current());
+                    dap_proc_thread_callback_add(l_thread, s_session_round_new, l_session);
+                }
                 break;
             }
             uint16_t l_min_validators_synced = PVT(l_session->esbocs)->emergency_mode ?
@@ -1447,8 +1457,11 @@ static void s_session_proc_state(void *a_arg)
                                                     l_session->cur_round.id, l_session->cur_round.attempt_num,
                                                         l_round_skip ? "skipped" : "can't synchronize minimum number of validators");
                 l_session->sync_failed = true;
-                dap_proc_thread_t *l_thread = DAP_PROC_THREAD(dap_context_current());
-                dap_proc_thread_callback_add(l_thread, s_session_round_new, l_session);
+                if (!l_session->new_round_enqueued) {
+                    l_session->new_round_enqueued = true;
+                    dap_proc_thread_t *l_thread = DAP_PROC_THREAD(dap_context_current());
+                    dap_proc_thread_callback_add(l_thread, s_session_round_new, l_session);
+                }
             }
         }
     } break;
@@ -2335,8 +2348,11 @@ static void s_session_packet_in(dap_chain_esbocs_session_t *a_session, dap_chain
                     l_session->round_fast_forward = true;
                     l_session->cur_round.id = l_message->hdr.round_id - 1;
                     l_session->cur_round.sync_attempt = l_sync_attempt - 1;
-                    dap_proc_thread_t *l_thread = DAP_PROC_THREAD(dap_context_current());
-                    dap_proc_thread_callback_add(l_thread, s_session_round_new, l_session);
+                    if (!l_session->new_round_enqueued) {
+                        l_session->new_round_enqueued = true;
+                        dap_proc_thread_t *l_thread = DAP_PROC_THREAD(dap_context_current());
+                        dap_proc_thread_callback_add(l_thread, s_session_round_new, l_session);
+                    }
                 }
             }
         } else // Send it immediatly, if was not sent yet
diff --git a/modules/consensus/esbocs/include/dap_chain_cs_esbocs.h b/modules/consensus/esbocs/include/dap_chain_cs_esbocs.h
index a7153258950de043d376d50717a82c775be9308e..5462d842fa66893095e97f6482b384720445016b 100644
--- a/modules/consensus/esbocs/include/dap_chain_cs_esbocs.h
+++ b/modules/consensus/esbocs/include/dap_chain_cs_esbocs.h
@@ -193,6 +193,7 @@ typedef struct dap_chain_esbocs_session {
     bool round_fast_forward;
     unsigned int listen_ensure;
     bool sync_failed;
+    bool new_round_enqueued;
 
     dap_time_t ts_round_sync_start; // time of start sync
     dap_time_t ts_stage_entry; // time of current stage entrance
diff --git a/modules/type/blocks/dap_chain_cs_blocks.c b/modules/type/blocks/dap_chain_cs_blocks.c
index 2f9b7cadd52e77877ffe8251b933839b74f41e8f..dfbb80e479893ba23cec12da599845c04688f35e 100644
--- a/modules/type/blocks/dap_chain_cs_blocks.c
+++ b/modules/type/blocks/dap_chain_cs_blocks.c
@@ -1202,40 +1202,46 @@ static int s_cli_blocks(int a_argc, char ** a_argv, void **a_str_reply)
         }break;
 
         case SUBCMD_AUTOCOLLECT: {
-            const char * l_cert_name  = NULL, * l_addr_str = NULL;
-            dap_pkey_t * l_pub_key = NULL;
+            const char *l_cert_name = NULL, *l_addr_str = NULL;
             dap_hash_fast_t l_pkey_hash = {};
-            dap_chain_addr_t *l_addr = NULL;
             size_t l_block_count = 0;
             char l_tmp_buff[128]={0};
-            int fl_renew = dap_cli_server_cmd_check_option(a_argv, arg_index,a_argc, "renew");
-            if(fl_renew != -1)
-            {
+            if (dap_cli_server_cmd_check_option(a_argv, arg_index,a_argc, "renew") > 0) {
                 dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-cert", &l_cert_name);
-                dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-addr", &l_addr_str);
-                l_addr = dap_chain_addr_from_str(l_addr_str);
                 if(!l_cert_name) {
                     dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_BLOCK_PARAM_ERR,
                                             "Command 'block autocollect renew' requires parameter '-cert'", l_subcmd_str);
                     return DAP_CHAIN_NODE_CLI_COM_BLOCK_PARAM_ERR;
                 }
-                if (!l_addr_str) {
-                    dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_BLOCK_PARAM_ERR,
-                                            "Command 'block autocollect renew' requires parameter '-addr'", l_subcmd_str);
-                    return DAP_CHAIN_NODE_CLI_COM_BLOCK_PARAM_ERR;
-                }
                 dap_cert_t *l_cert = dap_cert_find_by_name(l_cert_name);
                 if (!l_cert) {
                     dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_BLOCK_CERT_ERR,
                                             "Can't find \"%s\" certificate", l_cert_name);
                     return DAP_CHAIN_NODE_CLI_COM_BLOCK_CERT_ERR;
                 }
-                l_pub_key = dap_pkey_from_enc_key(l_cert->enc_key);
+                dap_pkey_t *l_pub_key = dap_pkey_from_enc_key(l_cert->enc_key);
                 if (!l_pub_key) {
                     dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_BLOCK_PUB_KEY_ERR,
                                             "Corrupted certificate \"%s\" have no public key data", l_cert_name);
                     return DAP_CHAIN_NODE_CLI_COM_BLOCK_PUB_KEY_ERR;
                 }
+                dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-addr", &l_addr_str);
+                if (!l_addr_str) {
+                    dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_BLOCK_PARAM_ERR,
+                                            "Command 'block autocollect renew' requires parameter '-addr'", l_subcmd_str);
+                    return DAP_CHAIN_NODE_CLI_COM_BLOCK_PARAM_ERR;
+                }
+                dap_chain_addr_t *l_addr = dap_chain_addr_from_str(l_addr_str);
+                if (!l_addr) {
+                    dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_BLOCK_CONVERT_ERR,
+                                            "Can't convert sring %s to wallet address", l_addr_str);
+                    return DAP_CHAIN_NODE_CLI_COM_BLOCK_PARAM_ERR;
+                }
+                if (l_addr->net_id.uint64 != l_net->pub.id.uint64) {
+                    dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_BLOCK_NET_ERR,
+                                            "Wallet address should be from the collecting network");
+                    return DAP_CHAIN_NODE_CLI_COM_BLOCK_NET_ERR;
+                }
                 dap_chain_esbocs_block_collect_t l_block_collect_params = (dap_chain_esbocs_block_collect_t){
                         .collecting_level = dap_chain_esbocs_get_collecting_level(l_chain),
                         .minimum_fee = dap_chain_esbocs_get_fee(l_chain->net_id),
@@ -1328,6 +1334,7 @@ static int s_cli_blocks(int a_argc, char ** a_argv, void **a_str_reply)
                     return DAP_CHAIN_NODE_CLI_COM_BLOCK_PARAM_ERR;
                 }
                 json_object* json_obj_out = json_object_new_object();
+                json_object_array_add(*json_arr_reply, json_obj_out);
                 bool l_status = dap_chain_esbocs_get_autocollect_status(l_net->pub.id);
                 char l_tmp_buff[150]={0};
                 sprintf(l_tmp_buff, "for network %s is %s\n", l_net->pub.name,
@@ -1337,7 +1344,6 @@ static int s_cli_blocks(int a_argc, char ** a_argv, void **a_str_reply)
                     break;
                 s_print_autocollect_table(l_net, json_obj_out, "Fees");
                 s_print_autocollect_table(l_net, json_obj_out, "Rewards");
-                json_object_array_add(*json_arr_reply, json_obj_out);
             }            
         } break;
 
diff --git a/modules/type/blocks/include/dap_chain_cs_blocks.h b/modules/type/blocks/include/dap_chain_cs_blocks.h
index 5b449d589384b85fc0800255006dd38d63991164..1cdca941d391f12feb731287fd526a73037b332d 100644
--- a/modules/type/blocks/include/dap_chain_cs_blocks.h
+++ b/modules/type/blocks/include/dap_chain_cs_blocks.h
@@ -79,6 +79,7 @@ typedef enum s_com_blocks_err{
     DAP_CHAIN_NODE_CLI_COM_BLOCK_CONVERT_ERR,
     DAP_CHAIN_NODE_CLI_COM_BLOCK_PVT_KEY_ERR,
     DAP_CHAIN_NODE_CLI_COM_BLOCK_SIGN_ERR,
+    DAP_CHAIN_NODE_CLI_COM_BLOCK_NET_ERR,
 
     /* add custom codes here */