diff --git a/modules/net/dap_chain_net_balancer.c b/modules/net/dap_chain_net_balancer.c
index 7ab9b4c167ef23207e8c52f1dd5d178e78c04f59..11538ee28484bd127934c34f1a298d9617ccad09 100644
--- a/modules/net/dap_chain_net_balancer.c
+++ b/modules/net/dap_chain_net_balancer.c
@@ -33,6 +33,7 @@ along with any CellFrame SDK based project.  If not, see <http://www.gnu.org/lic
 #include "dap_client_http.h"
 #include "dap_enc_base64.h"
 #include "dap_notify_srv.h"
+#include "dap_chain_node_rpc.h"
 
 #define LOG_TAG "dap_chain_net_balancer"
 
@@ -55,9 +56,6 @@ static_assert(sizeof(dap_chain_net_links_t) + sizeof(dap_chain_node_info_old_t)
 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 dap_balancer_request_info_t* s_request_info_items = NULL;
 
-static bool s_balancer_node = true;
-static bool s_balancer_rpc = true;
-
 const char *s_uri[] = {
     "f0intlt4eyl03htogu",
     "GxDsAUEiAKJtAaw55CFbRh"    // md5 + base58 encode
@@ -392,11 +390,6 @@ int dap_chain_net_balancer_handshake(dap_chain_node_info_t *a_node_info, dap_cha
  */
 void s_http_node_issue_link(dap_http_simple_t *a_http_simple, http_status_code_t *a_return_code)
 {
-    if (!s_balancer_node) {
-        log_it(L_ERROR, "Balancer validator mode is off");
-        *a_return_code = Http_Status_MethodNotAllowed;
-        return;
-    }
     int l_protocol_version = 0;
     char l_issue_method = 0;
     const char l_net_token[] = "net=", l_ignored_token[] = "ignored=";
@@ -452,14 +445,13 @@ void s_http_node_issue_link(dap_http_simple_t *a_http_simple, http_status_code_t
  */
 void s_http_rpc_issue_link(dap_http_simple_t *a_http_simple, http_status_code_t *a_return_code)
 {
-    if (!s_balancer_node) {
+    if (!dap_chain_node_rpc_is_balancer_node()) {
         log_it(L_ERROR, "Balancer rpc mode is off");
         *a_return_code = Http_Status_MethodNotAllowed;
         return;
     }
     int l_protocol_version = 0;
     char l_issue_method = 0;
-    const char l_net_token[] = "net=";
     sscanf(a_http_simple->http_client->in_query_string, "version=%d,method=%c",
                                                             &l_protocol_version, &l_issue_method);
     if (l_protocol_version > DAP_BALANCER_PROTOCOL_VERSION || l_protocol_version < 1 || l_issue_method != 'r') {
@@ -467,16 +459,16 @@ void s_http_rpc_issue_link(dap_http_simple_t *a_http_simple, http_status_code_t
         *a_return_code = Http_Status_MethodNotAllowed;
         return;
     }
-    char *l_net_str = strstr(a_http_simple->http_client->in_query_string, l_net_token);
-    if (!l_net_str) {
-        log_it(L_ERROR, "Net name token not found in the request to dap_chain_net_balancer module");
-        *a_return_code = Http_Status_NotFound;
+    size_t l_count = 0;
+    dap_chain_node_rpc_states_info_t *l_rpc_info = dap_chain_node_rpc_get_states_sort(&l_count);
+    if (!l_rpc_info) {
+        log_it(L_DEBUG, "Can't issue rpc node states, no any info found");
+        *a_return_code = Http_Status_NoContent;
         return;
     }
-    l_net_str += sizeof(l_net_token) - 1;
-
-    // dap_http_simple_reply(a_http_simple, l_link_full_node_list, l_data_send_size);
-    // DAP_DELETE(l_link_full_node_list);
+    *a_return_code = Http_Status_OK;
+    dap_http_simple_reply(a_http_simple, l_rpc_info, sizeof(dap_chain_node_rpc_states_info_t) *l_count);
+    DAP_DELETE(l_rpc_info);
 }
 
 /**
diff --git a/modules/net/dap_chain_node_rpc.c b/modules/net/dap_chain_node_rpc.c
index aafd0fa73928f8153d1eec659781c654ceef7cb4..97908825673e9badd4e4329a86cfee14311ab4c5 100644
--- a/modules/net/dap_chain_node_rpc.c
+++ b/modules/net/dap_chain_node_rpc.c
@@ -46,6 +46,7 @@ static const char s_rpc_server_states_group[] = "rpc.states";
 static const char s_rpc_node_list_group[] = "rpc.list";
 static dap_global_db_cluster_t *s_rpc_server_states_cluster = NULL;
 static dap_global_db_cluster_t *s_rpc_node_list_cluster = NULL;
+static rpc_role_t s_curretn_role = RPC_ROLE_INVALID;
 
 
 static struct cmd_call_stat *s_cmd_call_stat = NULL;
@@ -235,7 +236,7 @@ dap_string_t *dap_chain_node_rpc_list()
  * @brief get states rpc info about current
  * @param a_arg - pointer to callback arg
  */
-dap_list_t *dap_chain_node_rpc_get_sorted_list(size_t *a_count)
+dap_list_t *dap_chain_node_rpc_get_states_list_sort(size_t *a_count)
 {
     size_t l_count = 0;
     dap_list_t *l_ret = NULL;
@@ -256,4 +257,35 @@ dap_list_t *dap_chain_node_rpc_get_sorted_list(size_t *a_count)
     if (a_count)
         *a_count = l_count;
     return l_ret;
+}
+
+dap_chain_node_rpc_states_info_t *dap_chain_node_rpc_get_states_sort(size_t *a_count)
+{
+    size_t l_count = 0;
+    dap_list_t *l_nodes_list = dap_chain_node_rpc_get_states_list_sort(&l_count);
+    if(!l_nodes_list || !l_count) {
+        log_it(L_DEBUG, "No any information about rpc states");
+        return NULL;
+    }
+    // memory alloc
+    dap_chain_node_rpc_states_info_t *l_ret = DAP_NEW_Z_COUNT(dap_chain_node_rpc_states_info_t, l_count);
+    if (!l_ret) {
+        log_it(L_ERROR, "%s", c_error_memory_alloc);
+        dap_list_free_full(l_nodes_list, NULL);
+        return NULL;
+    }
+// func work
+    size_t j = 0;
+    for(dap_list_t *i = l_nodes_list; i && j < l_count; i = i->next, ++j) {
+        dap_mempcpy(l_ret + j, i->data, sizeof(dap_chain_node_rpc_states_info_t));
+    }
+    dap_list_free_full(l_nodes_list, NULL);
+    if (a_count)
+        *a_count = l_count;
+    return l_ret;
+}
+
+DAP_INLINE bool dap_chain_node_rpc_is_balancer_node()
+{
+    return s_curretn_role == RPC_ROLE_BALANCER;
 }
\ No newline at end of file
diff --git a/modules/net/include/dap_chain_node_rpc.h b/modules/net/include/dap_chain_node_rpc.h
index b382be9d2868c58da8366490dede405111598433..f8b9cb74d010b8559e423b716163c7b873d713a1 100644
--- a/modules/net/include/dap_chain_node_rpc.h
+++ b/modules/net/include/dap_chain_node_rpc.h
@@ -39,9 +39,12 @@ typedef struct dap_chain_node_rpc_states_info {
 } DAP_ALIGN_PACKED dap_chain_node_rpc_states_info_t;
 
  void dap_chain_node_rpc_init(dap_config_t *a_cfg);
- bool dap_chain_node_rpc_is_my_node_authorized();
+ void dap_chain_node_rpc_deinit();
  int dap_chain_node_rpc_info_save(dap_chain_node_info_t *a_node_info);
  dap_string_t *dap_chain_node_rpc_list();
+ dap_chain_node_rpc_states_info_t *dap_chain_node_rpc_get_states_sort(size_t *a_count);
+ bool dap_chain_node_rpc_is_my_node_authorized();
+ bool dap_chain_node_rpc_is_balancer_node();
 
  DAP_STATIC_INLINE size_t dap_chain_node_rpc_get_states_info_size(dap_chain_node_rpc_states_info_t *a_info)
  {