diff --git a/CMakeLists.txt b/CMakeLists.txt
index eef94a73f28c5ab5ca0dd0554c91e8e69f4a8186..59c5885ae7f25fa984426405d1fdd71c4bda92c3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,7 +2,7 @@ project(cellframe-sdk C)
 cmake_minimum_required(VERSION 2.8)
 
 set(CMAKE_C_STANDARD 11)
-set(CELLFRAME_SDK_NATIVE_VERSION "2.5-15")
+set(CELLFRAME_SDK_NATIVE_VERSION "2.5-16")
 add_definitions ("-DCELLFRAME_SDK_VERSION=\"${CELLFRAME_SDK_NATIVE_VERSION}\"")
 
 set(DAPSDK_MODULES "")
diff --git a/dap-sdk/net/client/dap_client.c b/dap-sdk/net/client/dap_client.c
index d977b219ddadbed22628cee1e67eeeb78bdbe1bb..b164bab85779d8dda73f833c52a7384dd49b14cf 100644
--- a/dap-sdk/net/client/dap_client.c
+++ b/dap-sdk/net/client/dap_client.c
@@ -459,9 +459,8 @@ dap_stream_ch_t * dap_client_get_stream_ch(dap_client_t * a_client, uint8_t a_ch
 {
     dap_stream_ch_t * l_ch = NULL;
     dap_client_pvt_t * l_client_internal = a_client ? DAP_CLIENT_PVT(a_client) : NULL;
-    if(l_client_internal && l_client_internal->stream)
+    if(l_client_internal && l_client_internal->stream && l_client_internal->stream_es)
         for(int i = 0; i < l_client_internal->stream->channel_count; i++) {
-            dap_stream_ch_proc_t *l_ch_id = l_client_internal->stream->channel[i]->proc;
             if(l_client_internal->stream->channel[i]->proc->id == a_ch_id) {
                 l_ch = l_client_internal->stream->channel[i];
                 break;
diff --git a/dap-sdk/net/client/dap_client_pvt.c b/dap-sdk/net/client/dap_client_pvt.c
index 011d380a78aadfb7888542d045b5a740b8c2126f..63db3542a11c4015f350aebc98bd215eec1706a6 100644
--- a/dap-sdk/net/client/dap_client_pvt.c
+++ b/dap-sdk/net/client/dap_client_pvt.c
@@ -326,18 +326,23 @@ static void dap_client_pvt_delete_in(dap_client_pvt_t * a_client_pvt)
 
     if(a_client_pvt->session_key_id)
         DAP_DELETE(a_client_pvt->session_key_id);
+    a_client_pvt->session_key_id = NULL;
 
     if(a_client_pvt->active_channels)
         DAP_DELETE(a_client_pvt->active_channels);
+    a_client_pvt->active_channels = NULL;
 
     if(a_client_pvt->session_key)
         dap_enc_key_delete(a_client_pvt->session_key);
+    a_client_pvt->session_key = NULL;
 
     if(a_client_pvt->session_key_open)
         dap_enc_key_delete(a_client_pvt->session_key_open);
+    a_client_pvt->session_key_open = NULL;
 
     if(a_client_pvt->stream_key)
         dap_enc_key_delete(a_client_pvt->stream_key);
+    a_client_pvt->stream_key = NULL;
 
     //a_client_pvt->client = NULL;
    // DAP_DELETE(a_client_pvt);
diff --git a/modules/channel/chain/dap_stream_ch_chain.c b/modules/channel/chain/dap_stream_ch_chain.c
index 607a183509803aa709b230b7353c527da02fae72..1d6eb6a2d6f28c2ec9e75f885f077a0e4285278b 100644
--- a/modules/channel/chain/dap_stream_ch_chain.c
+++ b/modules/channel/chain/dap_stream_ch_chain.c
@@ -161,7 +161,7 @@ bool s_sync_chains_callback(dap_proc_thread_t *a_thread, void *a_arg)
         l_ch_chain->state = CHAIN_STATE_SYNC_CHAINS;
         dap_chain_node_addr_t l_node_addr = { 0 };
         dap_chain_net_t *l_net = dap_chain_net_by_id(l_ch_chain->request_net_id);
-        l_node_addr.uint64 = l_net ? dap_db_get_cur_node_addr(l_net->pub.name) : 0;
+        l_node_addr.uint64 = dap_chain_net_get_cur_addr_int(l_net);
         dap_stream_ch_chain_pkt_write_unsafe(l_ch, DAP_STREAM_CH_CHAIN_PKT_TYPE_FIRST_CHAIN,
                 l_ch_chain->request_net_id, l_ch_chain->request_chain_id,
                 l_ch_chain->request_cell_id, &l_node_addr, sizeof(dap_chain_node_addr_t));
@@ -200,7 +200,7 @@ bool s_sync_gdb_callback(dap_proc_thread_t *a_thread, void *a_arg)
     dap_list_t *l_add_groups = dap_chain_net_get_add_gdb_group(l_net, l_ch_chain->request.node_addr);
     dap_db_log_list_t *l_db_log = dap_db_log_list_start(l_start_item + 1, l_add_groups);
     dap_chain_node_addr_t l_node_addr = { 0 };
-    l_node_addr.uint64 = l_net ? dap_db_get_cur_node_addr(l_net->pub.name) : 0;
+    l_node_addr.uint64 = dap_chain_net_get_cur_addr_int(l_net);
     dap_stream_ch_chain_pkt_write_unsafe(l_ch, DAP_STREAM_CH_CHAIN_PKT_TYPE_FIRST_GLOBAL_DB,
             l_ch_chain->request_net_id, l_ch_chain->request_chain_id,
             l_ch_chain->request_cell_id, &l_node_addr, sizeof(dap_chain_node_addr_t));
@@ -213,7 +213,7 @@ bool s_sync_gdb_callback(dap_proc_thread_t *a_thread, void *a_arg)
     } else {
         dap_stream_ch_chain_sync_request_t l_request = {};
         //log_it(L_DEBUG, "No items to sync from %u", l_request->id_start + 1);
-        l_request.node_addr.uint64 = l_net ? dap_db_get_cur_node_addr(l_net->pub.name) : 0;
+        l_request.node_addr.uint64 = dap_chain_net_get_cur_addr_int(l_net);
         l_request.id_start = dap_db_log_get_last_id_remote(l_ch_chain->request.node_addr.uint64);
         dap_stream_ch_chain_pkt_write_unsafe(l_ch, DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNCED_GLOBAL_DB,
                                              l_ch_chain->request_net_id, l_ch_chain->request_chain_id,
@@ -559,9 +559,7 @@ void s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
         dap_stream_ch_chain_sync_request_t l_sync_gdb = {};
         memcpy(&l_sync_gdb, l_chain_pkt->data, l_chain_pkt_data_size);
         dap_chain_net_t *l_net = dap_chain_net_by_id(l_chain_pkt->hdr.net_id);
-        l_sync_gdb.node_addr.uint64 = dap_chain_net_get_cur_addr(l_net) ?
-                                          dap_chain_net_get_cur_addr(l_net)->uint64 :
-                                          dap_db_get_cur_node_addr(l_net->pub.name);
+        l_sync_gdb.node_addr.uint64 = dap_chain_net_get_cur_addr_int(l_net);
         // Get last timestamp in log
         l_sync_gdb.id_start = (uint64_t) dap_db_log_get_last_id_remote(l_ch_chain->request.node_addr.uint64);
         // no limit
@@ -678,7 +676,7 @@ bool s_out_pkt_callback(dap_proc_thread_t *a_thread, void *a_arg)
                     // last message
                     dap_stream_ch_chain_sync_request_t l_request = {};
                     dap_chain_net_t *l_net = dap_chain_net_by_id(l_ch_chain->request_net_id);
-                    l_request.node_addr.uint64 = l_net ? dap_db_get_cur_node_addr(l_net->pub.name) : 0;
+                    l_request.node_addr.uint64 = dap_chain_net_get_cur_addr_int(l_net);
                     l_request.id_start = dap_db_log_get_last_id_remote(l_ch_chain->request.node_addr.uint64);
                     l_request.id_end = 0;
 
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index b7e3639f0e27d2bb2574e2cc0d9e86828cecc113..586c36a59f959d3d6797e5a86edfa1384832c7de 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -344,10 +344,8 @@ static void s_chain_callback_notify(void * a_arg, dap_chain_t *a_chain, dap_chai
  */
 static int s_net_states_proc(dap_chain_net_t * l_net)
 {
-
     dap_chain_net_pvt_t *l_pvt_net = PVT(l_net);
-
-    int ret=0;
+    int ret = 0;
 
     switch (l_pvt_net->state) {
         case NET_STATE_OFFLINE: {
@@ -373,71 +371,89 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
 
         case NET_STATE_LINKS_PREPARE: {
             log_it(L_NOTICE,"%s.state: NET_STATE_LINKS_PREPARE",l_net->pub.name);
+            uint64_t l_own_addr = dap_chain_net_get_cur_addr_int(l_net);
             if (l_pvt_net->node_info) {
                 for (size_t i = 0; i < l_pvt_net->node_info->hdr.links_number; i++) {
                     dap_chain_node_info_t *l_link_node_info = dap_chain_node_info_read(l_net, &l_pvt_net->node_info->links[i]);
-                    if (!l_link_node_info || l_link_node_info->hdr.address.uint64 == l_pvt_net->node_info->hdr.address.uint64) {
+                    if (!l_link_node_info || l_link_node_info->hdr.address.uint64 == l_own_addr) {
                         continue;   // Do not link with self
                     }
                     l_pvt_net->links_info = dap_list_append(l_pvt_net->links_info, l_link_node_info);
+                    if (dap_list_length(l_pvt_net->links_info) >= s_max_links_count) {
+                        break;
+                    }
                 }
             } else {
                 log_it(L_WARNING,"No nodeinfo in global_db to prepare links for connecting, find nearest 3 links and fill global_db");
             }
-            if (!l_pvt_net->seed_aliases_count) {
-                log_it(L_ERROR, "No root servers present in configuration file. Can't establish DNS requests");
-                l_pvt_net->state_target = l_pvt_net->state = NET_STATE_OFFLINE;
-                break;
-            }
-            switch (l_pvt_net->node_role.enums) {
-                case NODE_ROLE_ROOT:
-                case NODE_ROLE_ROOT_MASTER:
-                case NODE_ROLE_ARCHIVE:
-                case NODE_ROLE_CELL_MASTER: {
-                    // Add other root nodes as synchronization links
-                    for (int i = 0; i < MIN(s_max_links_count, l_pvt_net->seed_aliases_count); i++) {
-                        dap_chain_node_addr_t *l_link_addr = dap_chain_node_alias_find(l_net, l_pvt_net->seed_aliases[i]);
-                        dap_chain_node_info_t *l_link_node_info = dap_chain_node_info_read(l_net, l_link_addr);
-                        if(l_link_node_info) {
-                            l_pvt_net->links_info = dap_list_append(l_pvt_net->links_info, l_link_addr);
-                        }
-                        else{
-                            log_it(L_WARNING, "Not found link "NODE_ADDR_FP_STR" in the node list", NODE_ADDR_FPS_ARGS(l_link_addr));
-                        }
+            if (dap_list_length(l_pvt_net->links_info) < s_max_links_count) {
+                if (l_pvt_net->seed_aliases_count) {
+                    switch (l_pvt_net->node_role.enums) {
+                        case NODE_ROLE_ROOT:
+                        case NODE_ROLE_ROOT_MASTER:
+                        case NODE_ROLE_ARCHIVE:
+                        case NODE_ROLE_CELL_MASTER: {
+                            // Add other root nodes as synchronization links
+                            for (int i = 0; i < MIN(s_max_links_count, l_pvt_net->seed_aliases_count); i++) {
+                                dap_chain_node_addr_t *l_link_addr = dap_chain_node_alias_find(l_net, l_pvt_net->seed_aliases[i]);
+                                if (l_link_addr->uint64 == l_own_addr) {
+                                    continue;   // Do not link with self
+                                }
+                                dap_chain_node_info_t *l_link_node_info = dap_chain_node_info_read(l_net, l_link_addr);
+                                if(l_link_node_info) {
+                                    l_pvt_net->links_info = dap_list_append(l_pvt_net->links_info, l_link_node_info);
+                                }
+                                else{
+                                    log_it(L_WARNING, "Not found link "NODE_ADDR_FP_STR" in the node list", NODE_ADDR_FPS_ARGS(l_link_addr));
+                                }
+                                if (dap_list_length(l_pvt_net->links_info) >= s_max_links_count) {
+                                    break;
+                                }
+                            }
+                        } break;
+                        case NODE_ROLE_FULL:
+                        case NODE_ROLE_MASTER:
+                        case NODE_ROLE_LIGHT:
+                        default: {
+                            // Get DNS request result from root nodes as synchronization links
+                            while (dap_list_length(l_pvt_net->links_info) < s_max_links_count) {
+                                int i = rand() % l_pvt_net->seed_aliases_count;
+                                dap_chain_node_addr_t *l_remote_addr = dap_chain_node_alias_find(l_net, l_pvt_net->seed_aliases[i]);
+                                dap_chain_node_info_t *l_remote_node_info = dap_chain_node_info_read(l_net, l_remote_addr);
+                                if(l_remote_node_info) {
+                                    dap_chain_node_info_t *l_link_node_info = DAP_NEW_Z(dap_chain_node_info_t);
+                                    int res = 0; //dap_dns_client_get_addr(l_remote_node_info->hdr.ext_addr_v4.s_addr, l_net->pub.name, l_link_node_info);
+                                    memcpy(l_link_node_info, l_remote_node_info, sizeof(dap_chain_node_info_t));
+                                    if (l_link_node_info->hdr.address.uint64 != l_own_addr) {
+                                        l_pvt_net->links_info = dap_list_append(l_pvt_net->links_info, l_link_node_info);
+                                    }
+                                    DAP_DELETE(l_remote_node_info);
+                                }
+                                else{
+                                    log_it(L_WARNING, "Not found link "NODE_ADDR_FP_STR" in the node list", NODE_ADDR_FPS_ARGS(l_remote_addr));
+                                }
+                                if (l_pvt_net->state_target == NET_STATE_OFFLINE) {
+                                    l_pvt_net->state = NET_STATE_OFFLINE;
+                                    break;
+                                }
+                            }
+                        } break;
                     }
-                } break;
-                case NODE_ROLE_FULL:
-                case NODE_ROLE_MASTER:
-                case NODE_ROLE_LIGHT:
-                default: {
-                    // Get DNS request result from root nodes as synchronization links
-                    while (dap_list_length(l_pvt_net->links_info) < s_max_links_count) {
-                        int i = rand() % l_pvt_net->seed_aliases_count;
-                        dap_chain_node_addr_t *l_remote_addr = dap_chain_node_alias_find(l_net, l_pvt_net->seed_aliases[i]);
-                        dap_chain_node_info_t *l_remote_node_info = dap_chain_node_info_read(l_net, l_remote_addr);
-                        if(l_remote_node_info) {
-                            dap_chain_node_info_t *l_link_node_info = DAP_NEW_Z(dap_chain_node_info_t);
-                            int res = 0; //dap_dns_client_get_addr(l_remote_node_info->hdr.ext_addr_v4.s_addr, l_net->pub.name, l_link_node_info);
-                            memcpy(l_link_node_info, l_remote_node_info, sizeof(dap_chain_node_info_t));
-                            l_pvt_net->links_info = dap_list_append(l_pvt_net->links_info, l_link_node_info);
-                            //DAP_DELETE(l_link_node_info);
-                            DAP_DELETE(l_remote_node_info);
-                        }
-                        else{
-                            log_it(L_WARNING, "Not found link "NODE_ADDR_FP_STR" in the node list", NODE_ADDR_FPS_ARGS(l_remote_addr));
-                        }
-                        if (l_pvt_net->state_target == NET_STATE_OFFLINE) {
-                            l_pvt_net->state = NET_STATE_OFFLINE;
-                            break;
-                        }
+                } else {
+                    log_it(L_ERROR, "No root servers present in configuration file. Can't establish DNS requests");
+                    if (!dap_list_length(l_pvt_net->links_info)) {   // No links can be prepared, go offline
+                        l_pvt_net->state_target = NET_STATE_OFFLINE;
                     }
-                } break;
+                }
             }
             if (l_pvt_net->state_target != NET_STATE_OFFLINE) {
-                l_pvt_net->state = NET_STATE_LINKS_CONNECTING;
-                log_it(L_DEBUG, "Prepared %u links, start to establish them", dap_list_length(l_pvt_net->links_info));
+                if (dap_list_length(l_pvt_net->links_info)) {
+                    l_pvt_net->state = NET_STATE_LINKS_CONNECTING;
+                    log_it(L_DEBUG, "Prepared %u links, start to establish them", dap_list_length(l_pvt_net->links_info));
+                }
+            // If no links prepared go again to NET_STATE_LINKS_PREPARE
             } else {
-                l_pvt_net->state = l_pvt_net->state_target = NET_STATE_OFFLINE;
+                l_pvt_net->state = NET_STATE_OFFLINE;
             }
         } break;
 
@@ -454,13 +470,11 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
                         log_it(L_DEBUG, "Established connection with "NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS_S(l_link_info->hdr.address));
                         l_pvt_net->links = dap_list_append(l_pvt_net->links, l_node_client);
                     } else {
+                        log_it(L_DEBUG, "Can't establish link with "NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS_S(l_link_info->hdr.address));
                         dap_chain_node_client_close(l_node_client);
                         l_node_client = NULL;
                     }
-                }
-                if (!l_node_client) {
-                    log_it(L_DEBUG, "Can't establish link with "NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS_S(l_link_info->hdr.address));
-                }
+                }                    
                 if (dap_list_length(l_pvt_net->links) >= s_required_links_count) {
                     break;
                 }
@@ -491,9 +505,7 @@ static int s_net_states_proc(dap_chain_net_t * l_net)
                 // no limit
                 l_sync_gdb.id_end = (uint64_t)0;
 
-                l_sync_gdb.node_addr.uint64 = dap_chain_net_get_cur_addr(l_net) ?
-                                                  dap_chain_net_get_cur_addr(l_net)->uint64 :
-                                                  dap_db_get_cur_node_addr(l_net->pub.name);
+                l_sync_gdb.node_addr.uint64 = dap_chain_net_get_cur_addr_int(l_net);
                 log_it(L_DEBUG, "Prepared request to gdb sync from %llu to %llu", l_sync_gdb.id_start, l_sync_gdb.id_end);
                 // find dap_chain_id_t
                 dap_chain_t *l_chain = dap_chain_net_get_chain_by_name(l_net, "gdb");
diff --git a/modules/type/dag/dap_chain_cs_dag.c b/modules/type/dag/dap_chain_cs_dag.c
index c0de3cc2d7d37f9955134fec723f3fe6d9adebf8..44c31b78720f26857924d5786b85fc88052b4f0f 100644
--- a/modules/type/dag/dap_chain_cs_dag.c
+++ b/modules/type/dag/dap_chain_cs_dag.c
@@ -787,6 +787,7 @@ static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create_from(dap_chain_t
     dap_chain_atom_iter_t * l_atom_iter = DAP_NEW_Z(dap_chain_atom_iter_t);
     l_atom_iter->chain = a_chain;
     l_atom_iter->cur = a_atom;
+    l_atom_iter->cur_size = a_atom_size;
 
     if ( a_atom ){
         dap_chain_hash_fast_t l_atom_hash;
@@ -976,8 +977,8 @@ static dap_chain_atom_ptr_t s_chain_callback_atom_iter_get_next( dap_chain_atom_
         l_event_item = (dap_chain_cs_dag_event_item_t*) a_atom_iter->cur_item;
         // if l_event_item=NULL then items are over
         a_atom_iter->cur = l_event_item ? l_event_item->event : NULL;
+        a_atom_iter->cur_size = a_atom_iter->cur ? l_event_item->event_size : 0;
     }
-    a_atom_iter->cur_size = a_atom_iter->cur?a_atom_iter->cur_size: 0;
     if(a_atom_size)
         *a_atom_size = a_atom_iter->cur_size;