diff --git a/dap_chain_node_cli_cmd.c b/dap_chain_node_cli_cmd.c
index b04b22512b672bcbd2e112d6c62d84c63e94b56e..24819ba45db7431d68b5ac5c65b899f1fa4a2dde 100644
--- a/dap_chain_node_cli_cmd.c
+++ b/dap_chain_node_cli_cmd.c
@@ -516,14 +516,14 @@ static int node_info_dump_with_reply(dap_chain_net_t * a_net, dap_chain_node_add
                 if(l_objs)
                     dap_string_append_printf(l_string_reply,
                             "node address "NODE_ADDR_FP_STR"\tcell 0x%016llx\tipv4 %s\tnumber of links %u",
-                            node_info_read->hdr.address.uint64, node_info_read->hdr.cell_id.uint64,
-                            str_ip4, node_info_read->hdr.links_number);
+                            node_info_read->hdr.address.uint64,str_ip4, node_info_read->hdr.cell_id.uint64,
+                             node_info_read->hdr.links_number);
                 else
                     // set full reply with node param
                     dap_string_append_printf(l_string_reply,
                             "node address " NODE_ADDR_FP_STR "\ncell 0x%016llx%s\nipv4 %s\nipv6 %s\nlinks %u%s",
-                            NODE_ADDR_FP_ARGS_S(node_info_read->hdr.address) , node_info_read->hdr.cell_id.uint64, aliases_string->str,
-                            str_ip4, str_ip6,
+                            NODE_ADDR_FP_ARGS_S(node_info_read->hdr.address) , str_ip4, str_ip6,
+                     node_info_read->hdr.cell_id.uint64, aliases_string->str,
                             node_info_read->hdr.links_number, links_string->str);
                 dap_string_free(aliases_string, true);
                 dap_string_free(links_string, true);
@@ -797,7 +797,15 @@ int com_node(int a_argc, const char ** a_argv, char **a_str_reply)
         timeout_ms = 120000; // 2 min = 120 sec = 120 000 ms
         // TODO add progress info to console
         res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_SYNCED, timeout_ms);
+        if ( res <0 ){
+            dap_chain_node_client_close(l_node_client);
+            DAP_DELETE(l_remote_node_info);
+            dap_chain_node_cli_set_reply_text(a_str_reply, "Error: can't connect to node "NODE_ADDR_FP_STR,
+                                              NODE_ADDR_FP_ARGS_S(l_node_client->remote_node_addr));
+
+            return -2;
 
+        }
         // Requesting chains
         dap_chain_t *l_chain = NULL;
         DL_FOREACH(l_net->pub.chains, l_chain)
@@ -811,7 +819,7 @@ int com_node(int a_argc, const char ** a_argv, char **a_str_reply)
                 // clean client struct
                 dap_chain_node_client_close(l_node_client);
                 DAP_DELETE(l_remote_node_info);
-                return -1;
+                return -3;
             }
             log_it(L_NOTICE, "Requested syncronization for chain \"%s\"", l_chain->name);
             dap_stream_ch_set_ready_to_write(l_ch_chain, true);
@@ -840,24 +848,24 @@ int com_node(int a_argc, const char ** a_argv, char **a_str_reply)
             }
             else {
                 dap_chain_node_cli_set_reply_text(a_str_reply, "no address found by alias");
-                return -1;
+                return -4;
             }
         }
         if(!l_node_addr.uint64) {
             dap_chain_node_cli_set_reply_text(a_str_reply, "addr not found");
-            return -1;
+            return -5;
         }
 
         dap_chain_node_info_t *node_info = node_info_read_and_reply(l_net,&l_node_addr, a_str_reply);
         if(!node_info)
-            return -1;
+            return -6;
         int timeout_ms = 10000; //10 sec = 10000 ms
         // start handshake
         dap_chain_node_client_t *client = dap_chain_node_client_connect(node_info);
         if(!client) {
             dap_chain_node_cli_set_reply_text(a_str_reply, "can't connect");
             DAP_DELETE(node_info);
-            return -1;
+            return -7;
         }
         // wait handshake
         int res = dap_chain_node_client_wait(client, NODE_CLIENT_STATE_CONNECTED, timeout_ms);
@@ -866,7 +874,7 @@ int com_node(int a_argc, const char ** a_argv, char **a_str_reply)
             // clean client struct
             dap_chain_node_client_close(client);
             DAP_DELETE(node_info);
-            return -1;
+            return -8;
         }
         DAP_DELETE(node_info);
 
@@ -877,11 +885,11 @@ int com_node(int a_argc, const char ** a_argv, char **a_str_reply)
         case -1:
             dap_chain_node_client_close(client);
             dap_chain_node_cli_set_reply_text(a_str_reply, "connection established, but not saved");
-            return -1;
+            return -9;
         case -2:
             dap_chain_node_client_close(client);
             dap_chain_node_cli_set_reply_text(a_str_reply, "connection already present");
-            return -1;
+            return -10;
         }
         dap_chain_node_cli_set_reply_text(a_str_reply, "connection established");
     }
diff --git a/dap_chain_node_client.c b/dap_chain_node_client.c
index d8a88057d438030a19c462c7065f44b3405bbd27..e583cafb9af992c96df209f3e652d4305c0cf690 100644
--- a/dap_chain_node_client.c
+++ b/dap_chain_node_client.c
@@ -48,7 +48,7 @@
 #define SYSTEM_CONFIGS_DIR SYSTEM_PREFIX"/etc"
 
 static int listen_port_tcp = 8079;
-static void s_stage_end_callback(dap_client_t *a_client, void *a_arg);
+static void s_stage_connected_callback(dap_client_t *a_client, void *a_arg);
 static void s_ch_chain_callback_notify_packet_out(dap_stream_ch_chain_t*, uint8_t a_pkt_type,
                                                       dap_stream_ch_chain_pkt_t *a_pkt, size_t a_pkt_data_size,
                                                       void * a_arg);
@@ -107,12 +107,19 @@ static void stage_status_callback(dap_client_t *a_client, void *a_arg)
 static void s_stage_status_error_callback(dap_client_t *a_client, void *a_arg)
 {
     (void) a_arg;
+    dap_chain_node_client_t *l_node_client = a_client->_inheritor;
     if ( DAP_CHAIN_NODE_CLIENT(a_client)->keep_connection &&
          ( ( dap_client_get_stage(a_client) != STAGE_STREAM_STREAMING )||
            ( dap_client_get_stage_status(a_client) == STAGE_STATUS_ERROR  ) ) ){
         log_it(L_NOTICE,"Some errors happends, current state is %s but we need to return back to STAGE_STREAM_STREAMING",
                  dap_client_get_stage_str(a_client) ) ;
-        dap_client_go_stage( a_client , STAGE_STREAM_STREAMING, s_stage_end_callback );
+
+        pthread_mutex_unlock(&l_node_client->wait_mutex);
+        log_it(L_DEBUG,"Wakeup all who waits");
+        l_node_client->state = NODE_CLIENT_STATE_ERROR;
+        pthread_cond_signal(&l_node_client->wait_cond);
+
+        //dap_client_go_stage( a_client , STAGE_STREAM_STREAMING, s_stage_end_callback );
     }
     //printf("* tage_status_error_callback client=%x data=%x\n", a_client, a_arg);
 }
@@ -122,7 +129,7 @@ static void s_stage_status_error_callback(dap_client_t *a_client, void *a_arg)
  * @param a_client
  * @param a_arg
  */
-static void s_stage_end_callback(dap_client_t *a_client, void *a_arg)
+static void s_stage_connected_callback(dap_client_t *a_client, void *a_arg)
 {
     dap_chain_node_client_t *l_node_client = a_client->_inheritor;
     assert(l_node_client);
@@ -259,12 +266,14 @@ static void s_ch_chain_callback_notify_packet_out(dap_stream_ch_chain_t* a_ch_ch
  *
  * return a connection handle, or NULL, if an error
  */
-dap_chain_node_client_t* dap_chain_node_client_connect(dap_chain_node_info_t *node_info)
+dap_chain_node_client_t* dap_chain_node_client_connect(dap_chain_node_info_t *a_node_info)
 {
-    if(!node_info)
+    if(!a_node_info){
+        log_it(L_ERROR,"Can't connect to the node: null object node_info");
         return NULL;
+    }
     dap_chain_node_client_t *l_node_client = DAP_NEW_Z(dap_chain_node_client_t);
-    l_node_client->state = NODE_CLIENT_STATE_INIT;
+    l_node_client->state = NODE_CLIENT_STATE_DISCONNECTED;
     pthread_condattr_t attr;
     pthread_condattr_init(&attr);
     pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
@@ -273,18 +282,19 @@ dap_chain_node_client_t* dap_chain_node_client_connect(dap_chain_node_info_t *no
     l_node_client->events = NULL; //dap_events_new();
     l_node_client->client = dap_client_new(l_node_client->events, stage_status_callback, s_stage_status_error_callback);
     l_node_client->client->_inheritor = l_node_client;
+    l_node_client->remote_node_addr.uint64 = a_node_info->hdr.address.uint64;
     dap_client_set_active_channels(l_node_client->client,"CN");
 
     int hostlen = 128;
     char host[hostlen];
-    if(node_info->hdr.ext_addr_v4.s_addr)
+    if(a_node_info->hdr.ext_addr_v4.s_addr)
     {
-        struct sockaddr_in sa4 = { .sin_family = AF_INET, .sin_addr = node_info->hdr.ext_addr_v4 };
+        struct sockaddr_in sa4 = { .sin_family = AF_INET, .sin_addr = a_node_info->hdr.ext_addr_v4 };
         inet_ntop(AF_INET, &(((struct sockaddr_in *) &sa4)->sin_addr), host, hostlen);
     }
     else
     {
-        struct sockaddr_in6 sa6 = { .sin6_family = AF_INET6, .sin6_addr = node_info->hdr.ext_addr_v6 };
+        struct sockaddr_in6 sa6 = { .sin6_family = AF_INET6, .sin6_addr = a_node_info->hdr.ext_addr_v6 };
         inet_ntop(AF_INET6, &(((struct sockaddr_in6 *) &sa6)->sin6_addr), host, hostlen);
     }
     // address not defined
@@ -298,7 +308,7 @@ dap_chain_node_client_t* dap_chain_node_client_connect(dap_chain_node_info_t *no
 
     l_node_client->state = NODE_CLIENT_STATE_CONNECT;
     // Handshake & connect
-    dap_client_go_stage(l_node_client->client, l_stage_target, s_stage_end_callback);
+    dap_client_go_stage(l_node_client->client, l_stage_target, s_stage_connected_callback);
     return l_node_client;
 }
 
diff --git a/dap_chain_node_client.h b/dap_chain_node_client.h
index 6f79407f027e7465eb51c8941f2cbb790b5d2ce8..200519dbcd8541931fa82185872d5ed344ffd17d 100644
--- a/dap_chain_node_client.h
+++ b/dap_chain_node_client.h
@@ -31,7 +31,7 @@
 // connection states
 typedef enum dap_chain_node_client_state{
     NODE_CLIENT_STATE_ERROR = -1,
-    NODE_CLIENT_STATE_INIT=0,
+    NODE_CLIENT_STATE_DISCONNECTED=0,
     NODE_CLIENT_STATE_GET_NODE_ADDR=1,
     NODE_CLIENT_STATE_NODE_ADDR_LEASED=2,
     NODE_CLIENT_STATE_PING=3,