diff --git a/dap-sdk b/dap-sdk
index 0627912dea7ea2911187760adda47f113595bbc2..f5409cdd40208193ec7d0e577318bfeb30f994e5 160000
--- a/dap-sdk
+++ b/dap-sdk
@@ -1 +1 @@
-Subproject commit 0627912dea7ea2911187760adda47f113595bbc2
+Subproject commit f5409cdd40208193ec7d0e577318bfeb30f994e5
diff --git a/modules/chain/dap_chain.c b/modules/chain/dap_chain.c
index 69ad2691ccb1701d2459d2be443715a3114d290d..4bbdd262c612efbac628e68bc2ed08e8484aae39 100644
--- a/modules/chain/dap_chain.c
+++ b/modules/chain/dap_chain.c
@@ -519,7 +519,7 @@ dap_chain_t *dap_chain_load_from_cfg(const char *a_chain_net_name, dap_chain_net
 				} else
 					l_chain->autoproc_datum_types_count = 0;
 			}
-            dap_config_close(l_cfg);
+            l_chain->config = l_cfg;
             return l_chain;
         } else
             return NULL;
diff --git a/modules/chain/include/dap_chain.h b/modules/chain/include/dap_chain.h
index 6a7ea85760edc71f21878fd59c2bc8b481729a8b..48e364afb112e2714ad9731919035e40648328e0 100644
--- a/modules/chain/include/dap_chain.h
+++ b/modules/chain/include/dap_chain.h
@@ -202,6 +202,8 @@ typedef struct dap_chain {
 
     dap_list_t *atom_notifiers;
 
+    dap_config_t *config;
+
     void * _pvt; // private data
     void * _inheritor; // inheritor object
 } dap_chain_t;
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index 19794d788ef2cc654e924d99789ee6a850f3c016..f9e95d943c2b584aeab478039c91084ec14d47ce 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -1839,7 +1839,7 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
         dap_config_close(l_cfg);
         return -1;
     }
-    
+
     l_net->pub.gdb_groups_prefix = dap_strdup(
                 dap_config_get_item_str_default(l_cfg, "general", "gdb_groups_prefix",
                                                 dap_config_get_item_str(l_cfg, "general", "name")));
@@ -2077,6 +2077,8 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
     // Decrees initializing
     dap_chain_net_decree_init(l_net);
 
+    l_net->pub.config = l_cfg;
+
     return 0;
 }
 
@@ -2265,7 +2267,7 @@ bool s_net_load(void *a_arg)
             l_chain->callback_created(l_chain, l_cfg);
 
      if ( dap_config_get_item_bool_default(g_config, "server", "enabled", false) ) {
-        if ( !l_net_pvt->node_info ) {
+        if ( !l_net_pvt->node_info->ext_port ) {
             char l_host[DAP_HOSTADDR_STRLEN + 1] = { '\0' };
             uint16_t l_ext_port = 0;
             const char *l_ext_addr = dap_config_get_item_str_default(g_config, "server", "ext_address", NULL);
diff --git a/modules/net/dap_chain_net_balancer.c b/modules/net/dap_chain_net_balancer.c
index 1c0ed5b4ce56a3023ecdeb22c1f1f5e351f9a199..9d969ad754e4227c41a7084cbb1d3c39711734bc 100644
--- a/modules/net/dap_chain_net_balancer.c
+++ b/modules/net/dap_chain_net_balancer.c
@@ -46,6 +46,7 @@ typedef struct dap_balancer_link_request {
 
 static_assert(sizeof(dap_chain_net_links_t) + sizeof(dap_chain_node_info_old_t) < DAP_BALANCER_MAX_REPLY_SIZE, "DAP_BALANCER_MAX_REPLY_SIZE cannot accommodate information minimum about 1 link");
 static const size_t s_max_links_response_count = (DAP_BALANCER_MAX_REPLY_SIZE - sizeof(dap_chain_net_links_t)) / sizeof(dap_chain_node_info_old_t);
+static const dap_time_t s_request_period = 5; // sec
 
 /**
  * @brief forming json file with balancer info: class networkName nodeAddress hostAddress hostPort
@@ -78,19 +79,23 @@ static dap_chain_net_links_t *s_get_ignored_node_addrs(dap_chain_net_t *a_net, s
         l_size = 0,
         l_uplinks_count = 0,
         l_low_availability_count = 0;
-    dap_stream_node_addr_t *l_uplinks = dap_link_manager_get_net_links_addrs(a_net->pub.id.uint64, &l_uplinks_count, NULL, true);
-    dap_stream_node_addr_t *l_low_availability = dap_link_manager_get_ignored_addrs(&l_low_availability_count);
-    if(!l_uplinks && !l_low_availability) {
+    const dap_stream_node_addr_t
+        *l_curr_addr = &dap_chain_net_get_my_node_info(a_net)->address,
+        *l_uplinks = dap_link_manager_get_net_links_addrs(a_net->pub.id.uint64, &l_uplinks_count, NULL, true),
+        *l_low_availability = dap_link_manager_get_ignored_addrs(&l_low_availability_count);
+    if(!l_curr_addr->uint64 && !l_uplinks && !l_low_availability) {
+        log_it(L_WARNING, "Error forming ignore list, please check, should be minimum self addr");
         return NULL;
     }
-    l_size = sizeof(dap_chain_net_links_t) + sizeof(dap_stream_node_addr_t) * (l_uplinks_count + l_low_availability_count);
+    l_size = sizeof(dap_chain_net_links_t) + sizeof(dap_stream_node_addr_t) * (l_uplinks_count + l_low_availability_count + 1);
 // memory alloc
     dap_chain_net_links_t *l_ret = NULL;
-    DAP_NEW_Z_SIZE_RET_VAL(l_ret, dap_chain_net_links_t, l_size, NULL, NULL);
+    DAP_NEW_Z_SIZE_RET_VAL(l_ret, dap_chain_net_links_t, l_size, NULL, l_uplinks, l_low_availability);
 // func work
-    memcpy(l_ret->nodes_info, l_uplinks, l_uplinks_count * sizeof(dap_stream_node_addr_t));
-    memcpy(l_ret->nodes_info + l_uplinks_count, l_low_availability, l_low_availability_count * sizeof(dap_stream_node_addr_t));
-    l_ret->count_node = l_uplinks_count + l_low_availability_count;
+    memcpy(l_ret->nodes_info, l_curr_addr, sizeof(dap_stream_node_addr_t));
+    memcpy(l_ret->nodes_info + sizeof(dap_stream_node_addr_t), l_uplinks, l_uplinks_count * sizeof(dap_stream_node_addr_t));
+    memcpy(l_ret->nodes_info + (l_uplinks_count + 1) * sizeof(dap_stream_node_addr_t), l_low_availability, l_low_availability_count * sizeof(dap_stream_node_addr_t));
+    l_ret->count_node = l_uplinks_count + l_low_availability_count + 1;
     if (a_size)
         *a_size = l_size;
     DAP_DEL_MULTY(l_uplinks, l_low_availability);
@@ -283,8 +288,8 @@ static dap_chain_net_links_t *s_balancer_issue_link(const char *a_net_name, uint
     if (l_ignored_size) {
         DAP_NEW_Z_SIZE_RET_VAL(l_ignored_dec, dap_chain_net_links_t, l_ignored_size, NULL, NULL);
         dap_enc_base64_decode(a_ignored_enc, l_ignored_size, l_ignored_dec, DAP_ENC_DATA_TYPE_B64);
-        if (l_ignored_size < DAP_ENC_BASE64_ENCODE_SIZE(sizeof(dap_chain_net_links_t) + sizeof(dap_stream_node_addr_t) * l_ignored_dec->count_node)) {
-            log_it(L_ERROR, "Cant't decode ignored node list, %zu %zu", l_ignored_size, DAP_ENC_BASE64_ENCODE_SIZE(sizeof(dap_chain_net_links_t) + sizeof(dap_stream_node_addr_t) * l_ignored_dec->count_node));
+        if (l_ignored_size < DAP_ENC_BASE64_ENCODE_SIZE((sizeof(dap_chain_net_links_t) + sizeof(dap_stream_node_addr_t) * l_ignored_dec->count_node))) {
+            log_it(L_ERROR, "Can't decode ignored node list, received size %zu < expected size %zu", l_ignored_size, DAP_ENC_BASE64_ENCODE_SIZE((sizeof(dap_chain_net_links_t) + sizeof(dap_stream_node_addr_t) * l_ignored_dec->count_node)));
             DAP_DEL_Z(l_ignored_dec);
         }
     }
@@ -293,6 +298,14 @@ static dap_chain_net_links_t *s_balancer_issue_link(const char *a_net_name, uint
     return l_ret;
 }
 
+/**
+ * @brief balancer deinit
+ */
+void dap_chain_net_balancer_deinit()
+{
+
+}
+
 /**
  * @brief balancer handshake
  * @param a_node_info
@@ -402,23 +415,31 @@ int dap_chain_net_balancer_request(dap_chain_net_t *a_net, const char *a_host_ad
 // sanity check
     dap_return_val_if_pass(!a_net, -1);
 // func work
-    size_t l_ignored_addrs_size = 0; // prepare list of the ignored addrs
-    dap_chain_net_links_t *l_ignored_addrs = s_get_ignored_node_addrs(a_net, &l_ignored_addrs_size);
-    size_t l_required_links_count = dap_link_manager_needed_links_count(a_net->pub.id.uint64);
-    // links from local GDB
-    dap_chain_net_links_t *l_links = s_get_node_addrs(a_net, l_required_links_count, l_ignored_addrs, false);
+    // request each 5 sec
+    static dap_time_t l_last_time = 0;
+    if (dap_time_now() - l_last_time < s_request_period) {
+        log_it(L_DEBUG, "Who understands life, he is in no hurry");
+        return 0;
+    }
+    l_last_time = dap_time_now();
+    size_t
+        l_ignored_addrs_size = 0,
+        l_required_links_count = dap_link_manager_needed_links_count(a_net->pub.id.uint64);
+    dap_chain_net_links_t
+        *l_ignored_addrs = s_get_ignored_node_addrs(a_net, &l_ignored_addrs_size),
+        *l_links = s_get_node_addrs(a_net, l_required_links_count, l_ignored_addrs, false);     // links from local GDB
     if (l_links) {
         s_balancer_link_prepare_success(a_net, l_links, NULL, 0);
         if (l_links->count_node >= l_required_links_count) {
             DAP_DEL_MULTY(l_ignored_addrs, l_links);
             return 0;
         }
-        else
-            l_required_links_count -= l_links->count_node;
+        l_required_links_count -= l_links->count_node;
         DAP_DELETE(l_links);
     }
     if (!a_host_addr || !a_host_port) {
         log_it(L_INFO, "Can't read seed nodes addresses, work with local balancer only");
+        DAP_DEL_Z(l_ignored_addrs);
         return 0;
     }
     // dynamic links from http balancer request
diff --git a/modules/net/dap_chain_net_node_list.c b/modules/net/dap_chain_net_node_list.c
index 205a5bf2193ce6215302ad42108e1230eeedc2e3..85d7f8228fd55cf953a015bef1132509fb0f9169 100644
--- a/modules/net/dap_chain_net_node_list.c
+++ b/modules/net/dap_chain_net_node_list.c
@@ -302,8 +302,7 @@ int dap_chain_net_node_list_request(dap_chain_net_t *a_net, uint16_t a_port, boo
             }
         }
     }
-    DAP_DELETE(l_request);
-    DAP_DELETE(l_seeds_addrs);
+    DAP_DEL_MULTY(l_request, l_seeds_addrs);
     s_node_list_request_deinit(l_link_node_request);
     return l_ret;
 }
diff --git a/modules/net/include/dap_chain_net.h b/modules/net/include/dap_chain_net.h
index 5c669c06e9484d2936ff31db25a8e62b688d2959..ef73031a2d480d83d59cfedcbe5fe408c0b3e981 100644
--- a/modules/net/include/dap_chain_net.h
+++ b/modules/net/include/dap_chain_net.h
@@ -73,6 +73,7 @@ typedef struct dap_chain_net{
         dap_chain_addr_t fee_addr;
         
         dap_list_t *bridged_networks;   // List of bridged network ID's allowed to cross-network TX
+        dap_config_t *config;
     } pub;
     uint8_t pvt[];
 } dap_chain_net_t;
diff --git a/modules/net/include/dap_chain_net_balancer.h b/modules/net/include/dap_chain_net_balancer.h
index a7aa901dab156a6f97d077359f7c1fd752d11b5f..b5e1d0bd26bf0d06335676b698f41256e79895e7 100644
--- a/modules/net/include/dap_chain_net_balancer.h
+++ b/modules/net/include/dap_chain_net_balancer.h
@@ -49,7 +49,7 @@ DAP_STATIC_INLINE const char *dap_chain_net_balancer_type_to_str(dap_balancer_ty
         default: return "UNDEFINED";
     }
 }
-
+void dap_chain_net_balancer_deinit();
 void dap_chain_net_balancer_http_issue_link(dap_http_simple_t *a_http_simple, void *a_arg);
 dap_link_info_t *dap_chain_net_balancer_dns_issue_link(const char *a_net_name);
 int dap_chain_net_balancer_handshake(dap_chain_node_info_t *a_node_info, dap_chain_net_t * a_net);
diff --git a/modules/type/blocks/dap_chain_cs_blocks.c b/modules/type/blocks/dap_chain_cs_blocks.c
index 12f492c0ed9dcc510e74a7a1cc505f1264705ede..f7beb00efe174b5332586799c14ee8a7e9c5ab90 100644
--- a/modules/type/blocks/dap_chain_cs_blocks.c
+++ b/modules/type/blocks/dap_chain_cs_blocks.c
@@ -668,7 +668,15 @@ static int s_cli_blocks(int a_argc, char ** a_argv, void **a_str_reply)
         }break;
 
         case SUBCMD_DUMP:{
+            const char *l_hash_out_type = NULL;
             dap_chain_hash_fast_t l_block_hash={0};
+            dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-H", &l_hash_out_type);
+            if(!l_hash_out_type)
+                l_hash_out_type = "hex";
+            if(dap_strcmp(l_hash_out_type,"hex") && dap_strcmp(l_hash_out_type,"base58")) {
+                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_BLOCK_PARAM_ERR, "invalid parameter -H, valid values: -H <hex | base58>");
+                return DAP_CHAIN_NODE_CLI_COM_BLOCK_PARAM_ERR;
+            }
             if (!l_subcmd_str_arg) {
                 dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_BLOCK_HASH_ERR, "Enter block hash ");
                 return DAP_CHAIN_NODE_CLI_COM_BLOCK_HASH_ERR;