diff --git a/dap-sdk b/dap-sdk
index 6184e49af5e0e2536696eab1a520ad3536e40cc7..89400bc2340111a11ed7895a30983dffc875d488 160000
--- a/dap-sdk
+++ b/dap-sdk
@@ -1 +1 @@
-Subproject commit 6184e49af5e0e2536696eab1a520ad3536e40cc7
+Subproject commit 89400bc2340111a11ed7895a30983dffc875d488
diff --git a/modules/net/dap_chain_net_balancer.c b/modules/net/dap_chain_net_balancer.c
index 34a5f5985c59299886309a90c6f7af1f34bbceea..771c1e5560ad8b1110ac28fc07f40e5329884482 100644
--- a/modules/net/dap_chain_net_balancer.c
+++ b/modules/net/dap_chain_net_balancer.c
@@ -543,28 +543,36 @@ void dap_chain_net_balancer_request(void *a_arg)
  * @param a_net - net to report
  * @return if error NULL, other - report
  */
-dap_string_t *dap_chain_net_balancer_get_node_str(dap_chain_net_t *a_net)
+json_object *dap_chain_net_balancer_get_node_str(dap_chain_net_t *a_net)
 {
 // sanity check
     dap_return_val_if_pass(!a_net, NULL);
 // func work
+    json_object *l_jobj_out = json_object_new_object();
+    if (!l_jobj_out) return dap_json_rpc_allocation_put(l_jobj_out);
+    json_object *l_jobj_list_array = json_object_new_array();
+    if (!l_jobj_list_array) return dap_json_rpc_allocation_put(l_jobj_out);
+    json_object_object_add(l_jobj_out, "links_list", l_jobj_list_array);
     dap_net_links_t *l_links_info_list = s_get_node_addrs(a_net, 0, NULL, false);  // TODO
-    dap_string_t *l_ret = dap_string_new(
-        "-----------------------------------------------------------------\n"
-        "|\t\tNode addr\t|\tHost addr\t\t|\n"
-        "--Send in balancer http response---------------------------------\n");
+    
     uint64_t l_node_num = l_links_info_list ? l_links_info_list->count_node : 0;
     for (uint64_t i = 0; i < l_node_num; ++i) {
         dap_link_info_t *l_link_info = (dap_link_info_t *)l_links_info_list->nodes_info + i;
-        dap_string_append_printf(l_ret, "|\t"NODE_ADDR_FP_STR"\t|\t%-16s:%u\t|\n",
-                                    NODE_ADDR_FP_ARGS_S(l_link_info->node_addr),
-                                    l_link_info->uplink_addr, l_link_info->uplink_port);
+        json_object *l_jobj_link = json_object_new_object();
+        if (!l_jobj_link) return dap_json_rpc_allocation_put(l_jobj_out);
+        char * l_node_addr = dap_strdup_printf(""NODE_ADDR_FP_STR"",NODE_ADDR_FP_ARGS_S(l_link_info->node_addr));
+        json_object_object_add(l_jobj_link, "node_addr", json_object_new_string(l_node_addr));
+        DAP_DELETE(l_node_addr);
+        char * l_uplink_addr = dap_strdup_printf("%-16s", l_link_info->uplink_addr);
+        json_object_object_add(l_jobj_link, "host_addr", json_object_new_string(l_uplink_addr));
+        DAP_DELETE(l_uplink_addr);
+        json_object_object_add(l_jobj_link, "port", json_object_new_uint64(l_link_info->uplink_port));
         if(i + 1 == s_max_links_response_count && i + 1 < l_node_num) {
-            dap_string_append_printf(l_ret, "--Not send in http balancer response-----------------------------\n");
+            json_object_object_add(l_jobj_link, "status", json_object_new_string("Not send in http balancer response"));
         }
+        json_object_array_add(l_jobj_list_array, l_jobj_link);
     }
-    dap_string_prepend_printf(l_ret, "Balancer link list for total %" DAP_UINT64_FORMAT_U " records:\n", l_node_num);
-    dap_string_append(l_ret, "-----------------------------------------------------------------\n");
+    json_object_object_add(l_jobj_out, "links total", json_object_new_uint64(l_node_num));
     DAP_DELETE(l_links_info_list);
-    return l_ret;
+    return l_jobj_out;
 }
diff --git a/modules/net/include/dap_chain_net_balancer.h b/modules/net/include/dap_chain_net_balancer.h
index a691a177ab910fe79291ab916bc327ca4a2b2846..a83b0308f4be9a0a7163cf6f1d28e53d95a170f9 100644
--- a/modules/net/include/dap_chain_net_balancer.h
+++ b/modules/net/include/dap_chain_net_balancer.h
@@ -65,7 +65,7 @@ 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);
-dap_string_t *dap_chain_net_balancer_get_node_str(dap_chain_net_t *a_net);
+json_object *dap_chain_net_balancer_get_node_str(dap_chain_net_t *a_net);
 void dap_chain_net_balancer_request(void *a_arg);
 
 #ifdef __cplusplus
diff --git a/modules/node-cli/dap_chain_node_cli_cmd.c b/modules/node-cli/dap_chain_node_cli_cmd.c
index d64b1318ae8a42a1b30880471f3a26ac53f31487..a2c4b1b82756aad4c9bbcf1e76ad2d821fee511e 100644
--- a/modules/node-cli/dap_chain_node_cli_cmd.c
+++ b/modules/node-cli/dap_chain_node_cli_cmd.c
@@ -115,11 +115,12 @@ dap_chain_t *s_get_chain_with_datum(dap_chain_net_t *a_net, const char *a_datum_
  * @return dap_chain_node_info_t*
  */
 static dap_chain_node_info_t* node_info_read_and_reply(dap_chain_net_t * a_net, dap_chain_node_addr_t *a_address,
-        void **a_str_reply)
+        json_object* a_json_arr_reply)
 {
     dap_chain_node_info_t* l_res = dap_chain_node_info_read(a_net, a_address);
-    if (!l_res)
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "Node record is corrupted or doesn't exist");
+    if (!l_res && a_json_arr_reply)
+        dap_json_rpc_error_add(a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_LIST_NODE_RECORD_CORRUPTED_ERR,
+                                                        "Node record is corrupted or doesn't exist");
     return l_res;
 }
 
@@ -191,14 +192,13 @@ static int node_info_add_with_reply(dap_chain_net_t * a_net, dap_chain_node_info
  * @param a_addr
  * @param a_is_full
  * @param a_alias
- * @param a_str_reply
+ * @param a_json_arr_reply
  * @return int 0 Ok, -1 error
  */
 static int s_node_info_list_with_reply(dap_chain_net_t *a_net, dap_chain_node_addr_t * a_addr, bool a_is_full,
-        const char *a_alias, void **a_str_reply)
+        const char *a_alias, json_object* a_json_arr_reply)
 {
     int l_ret = 0;
-    dap_string_t *l_string_reply = dap_string_new("Node list:\n");
 
     if ((a_addr && a_addr->uint64) || a_alias) {
         dap_chain_node_addr_t *l_addr = a_alias
@@ -211,10 +211,9 @@ static int s_node_info_list_with_reply(dap_chain_net_t *a_net, dap_chain_node_ad
         }
 
         // read node
-        dap_chain_node_info_t *node_info_read = node_info_read_and_reply(a_net, l_addr, a_str_reply);
+        dap_chain_node_info_t *node_info_read = node_info_read_and_reply(a_net, l_addr, a_json_arr_reply);
         if(!node_info_read) {
             DAP_DEL_Z(l_addr);
-            dap_string_free(l_string_reply, true);
             return -2;
         }
 
@@ -287,14 +286,18 @@ static int s_node_info_list_with_reply(dap_chain_net_t *a_net, dap_chain_node_ad
         dap_global_db_obj_t *l_objs = dap_global_db_get_all_sync(a_net->pub.gdb_nodes, &l_nodes_count);
 
         if(!l_nodes_count || !l_objs) {
-            dap_string_append_printf(l_string_reply, "No records\n");
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "%s", l_string_reply->str);
-            dap_string_free(l_string_reply, true);
+            dap_json_rpc_error_add(a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_LIST_NO_RECORDS_ERR,
+                "No records\n");
             dap_global_db_objs_delete(l_objs, l_nodes_count);
-            return -1;
+            return -DAP_CHAIN_NODE_CLI_COM_NODE_LIST_NO_RECORDS_ERR;
         } else {
-            dap_string_append_printf(l_string_reply, "Got %zu nodes:\n", l_nodes_count);
-            dap_string_append_printf(l_string_reply, "%-26s%-20s%-8s%s", "Address", "IPv4", "Port", "Timestamp\n");
+            json_object* json_node_list_obj = json_object_new_object();
+            if (!json_node_list_obj) return dap_json_rpc_allocation_put(json_node_list_obj),DAP_CHAIN_NODE_CLI_COM_NODE_MEMORY_ALLOC_ERR;
+            json_object_object_add(json_node_list_obj, "got_nodes", json_object_new_uint64(l_nodes_count));
+            json_object* json_node_list_arr = json_object_new_array();
+            if (!json_node_list_arr) return dap_json_rpc_allocation_put(json_node_list_obj),DAP_CHAIN_NODE_CLI_COM_NODE_MEMORY_ALLOC_ERR;            
+            json_object_object_add(json_node_list_obj, "NODES", json_node_list_arr);
+            json_object_array_add(a_json_arr_reply, json_node_list_obj);
 
             for (size_t i = 0; i < l_nodes_count; i++) {
                 dap_chain_node_info_t *l_node_info = (dap_chain_node_info_t*)l_objs[i].value;
@@ -302,14 +305,18 @@ static int s_node_info_list_with_reply(dap_chain_net_t *a_net, dap_chain_node_ad
                     log_it(L_ERROR, "Node address is empty");
                     continue;
                 }
-
+                json_object* json_node_obj = json_object_new_object();
+                if (!json_node_obj) return dap_json_rpc_allocation_put(json_node_list_obj),DAP_CHAIN_NODE_CLI_COM_NODE_MEMORY_ALLOC_ERR;
                 char l_ts[DAP_TIME_STR_SIZE] = { '\0' };
                 dap_nanotime_to_str_rfc822(l_ts, sizeof(l_ts), l_objs[i].timestamp);
 
-                dap_string_append_printf(l_string_reply, NODE_ADDR_FP_STR"    %-20s%-8d%-32s\n",
-                                         NODE_ADDR_FP_ARGS_S(l_node_info->address),
-                                         l_node_info->ext_host, l_node_info->ext_port,
-                                         l_ts);
+                char *l_addr = dap_strdup_printf(NODE_ADDR_FP_STR, NODE_ADDR_FP_ARGS_S(l_node_info->address));
+                json_object_object_add(json_node_obj, "address", json_object_new_string(l_addr));
+                json_object_object_add(json_node_obj, "IPv4", json_object_new_string(l_node_info->ext_host));
+                json_object_object_add(json_node_obj, "port", json_object_new_uint64(l_node_info->ext_port));
+                json_object_object_add(json_node_obj, "timestamp", json_object_new_string(l_ts));
+                json_object_array_add(json_node_list_arr, json_node_obj);
+                DAP_DELETE(l_addr);
 
                 // TODO make correct work with aliases
                 /*dap_string_t *aliases_string = dap_string_new(NULL);
@@ -361,11 +368,11 @@ static int s_node_info_list_with_reply(dap_chain_net_t *a_net, dap_chain_node_ad
                 dap_string_free(aliases_string, true);
                 dap_string_free(links_string, true);*/
             }
+            json_object_object_add(json_node_list_obj, "NODES", json_node_list_arr);
+            json_object_array_add(a_json_arr_reply, json_node_list_obj);
         }
         dap_global_db_objs_delete(l_objs, l_nodes_count);
     }
-    dap_cli_server_cmd_set_reply_text(a_str_reply, "%s", l_string_reply->str);
-    dap_string_free(l_string_reply, true);
     return l_ret;
 }
 
@@ -414,7 +421,7 @@ int com_global_db(int a_argc, char ** a_argv, void **a_str_reply)
         switch (res_flush) {
         case 0:
             json_obj_flush = json_object_new_object();
-            json_object_object_add(json_obj_flush, "command_status", json_object_new_string("Commit data base and filesystem caches to disk completed.\n\n"));
+            json_object_object_add(json_obj_flush, "command_status", json_object_new_string("Commit data base and filesystem caches to disk completed."));
             json_object_array_add(*a_json_arr_reply, json_obj_flush);
             break;
         case -1:
@@ -808,11 +815,31 @@ static dap_tsd_t* s_chain_node_cli_com_node_create_tsd_addr(char **a_argv, int a
                                                        "specified to create a %s entry creation decree.", a_specified_decree), NULL;
 }
 
+static dap_tsd_t* s_chain_node_cli_com_node_create_tsd_addr_json(char **a_argv, int a_arg_start, int a_arg_end, json_object* a_json_arr_reply, const char *a_specified_decree) {
+    const char *l_ban_addr_str = NULL;
+    if (dap_cli_server_cmd_find_option_val(a_argv, a_arg_start, a_arg_end, "-addr", &l_ban_addr_str)) {
+        dap_stream_node_addr_t l_addr = {0};
+        if (dap_stream_node_addr_from_str(&l_addr, l_ban_addr_str)) {
+            dap_json_rpc_error_add(a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_BAN_CANT_CONVERT_ADDR_VALUE_ERR,
+                                   "Can't convert the -addr option value to node address");
+            return NULL;
+        }
+        return dap_tsd_create_string(DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STRING, l_ban_addr_str);
+    } else if (dap_cli_server_cmd_find_option_val(a_argv, a_arg_start, a_arg_end, "-host", &l_ban_addr_str))
+        return dap_tsd_create_string(DAP_CHAIN_DATUM_DECREE_TSD_TYPE_HOST, l_ban_addr_str);
+    else {
+        dap_json_rpc_error_add(a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_BAN_HOST_OPTION_WASNOT_SPECIFIED_ERR,
+                               "The -host or -addr option was not specified to create a %s entry creation decree.", a_specified_decree);
+        return NULL;
+    }
+}
+
 /**
  * Node command
  */
 int com_node(int a_argc, char ** a_argv, void **a_str_reply)
 {
+    json_object ** a_json_arr_reply = (json_object **) a_str_reply;
     enum {
         CMD_NONE, CMD_ADD, CMD_DEL, CMD_ALIAS, CMD_HANDSHAKE, CMD_CONNECT, CMD_LIST, CMD_DUMP, CMD_CONNECTIONS, CMD_BALANCER,
         CMD_BAN, CMD_UNBAN, CMD_BANLIST
@@ -853,8 +880,9 @@ int com_node(int a_argc, char ** a_argv, void **a_str_reply)
     }
     arg_index++;
     if(cmd_num == CMD_NONE) {
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "command %s not recognized", a_argv[1]);
-        return -1;
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_COMMAND_NOT_RECOGNIZED_ERR,
+            "command %s not recognized", a_argv[1]);
+        return -DAP_CHAIN_NODE_CLI_COM_NODE_COMMAND_NOT_RECOGNIZED_ERR;
     }
     const char *l_addr_str = NULL, *l_port_str = NULL, *alias_str = NULL;
     const char *l_cell_str = NULL, *l_link_str = NULL, *l_hostname = NULL;
@@ -887,15 +915,17 @@ int com_node(int a_argc, char ** a_argv, void **a_str_reply)
 
     if (l_addr_str) {
         if (dap_chain_node_addr_from_str(&l_node_info->address, l_addr_str)) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't parse node address %s", l_addr_str);
-            return -5;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_CANT_PARSE_NODE_ADDR_ERR,
+                "Can't parse node address %s", l_addr_str);
+            return -DAP_CHAIN_NODE_CLI_COM_NODE_CANT_PARSE_NODE_ADDR_ERR;
         }
     }
     if (l_port_str) {
         dap_digit_from_string(l_port_str, &l_node_info->ext_port, sizeof(uint16_t));
         if (!l_node_info->ext_port) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't parse host port %s", l_port_str);
-            return -4;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_CANT_PARSE_HOST_PORT_ERR,
+                "Can't parse host port %s", l_port_str);
+            return -DAP_CHAIN_NODE_CLI_COM_NODE_CANT_PARSE_HOST_PORT_ERR;
         }
     }
     if (l_cell_str) {
@@ -913,21 +943,36 @@ int com_node(int a_argc, char ** a_argv, void **a_str_reply)
         uint16_t l_port = 0;
         if (l_addr_str || l_hostname) {
             if (!dap_chain_net_is_my_node_authorized(l_net)) {
-                dap_cli_server_cmd_set_reply_text(a_str_reply, "You have no access rights");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_ADD_HAVE_NO_ACCESS_RIGHTS_ERR,
+                    "You have no access rights");
                 return l_res;
             }
             // We're in authorized list, add directly
             struct sockaddr_storage l_verifier = { };
             if ( 0 > dap_net_parse_config_address(l_hostname, l_node_info->ext_host, &l_port, &l_verifier, NULL) ) {
-                dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't parse host string %s", l_hostname);
-                return -6;
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_PARSE_HOST_STRING_ERR,
+                    "Can't parse host string %s", l_hostname);
+                return -DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_PARSE_HOST_STRING_ERR;
+            }
+            if ( !l_node_info->ext_port && !(l_node_info->ext_port = l_port) ) {
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_UNSPECIFIED_PORT_ERR,
+                                       "Unspecified port");
+                return -DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_UNSPECIFIED_PORT_ERR;
             }
-            if ( !l_node_info->ext_port && !(l_node_info->ext_port = l_port) )
-                return dap_cli_server_cmd_set_reply_text(a_str_reply, "Unspecified port"), -7;
 
             l_node_info->ext_host_len = dap_strlen(l_node_info->ext_host);
             l_res = dap_chain_node_info_save(l_net, l_node_info);
-            return dap_cli_server_cmd_set_reply_text(a_str_reply, l_res ? "Can't add node %s, error %d" : "Successfully added node %s", l_addr_str, l_res), l_res;
+
+            if (l_res) {
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_ADDED_NOT_ERR,
+                                       "Can't add node %s, error %d", l_addr_str, l_res);
+            } else {
+                json_object* json_obj_out = json_object_new_object();
+                if (!json_obj_out) return dap_json_rpc_allocation_put(json_obj_out),DAP_CHAIN_NODE_CLI_COM_NODE_MEMORY_ALLOC_ERR;
+                json_object_object_add(json_obj_out, "successfully_added_node", json_object_new_string(l_addr_str));
+                json_object_array_add(*a_json_arr_reply, json_obj_out);
+            }
+            return l_res;
         }
         // Synchronous request, wait for reply
         if ( !(l_port = l_node_info->ext_port) 
@@ -936,22 +981,42 @@ int com_node(int a_argc, char ** a_argv, void **a_str_reply)
         {
             if ( dap_config_get_item_bool_default(g_config, "server", "enabled", false) ) {
                 const char **l_listening = dap_config_get_array_str(g_config, "server", DAP_CFG_PARAM_LISTEN_ADDRS, NULL);
-                if ( l_listening && dap_net_parse_config_address(*l_listening, NULL, &l_port, NULL, NULL) < 0 )
-                    return dap_cli_server_cmd_set_reply_text(a_str_reply, "Invalid server IP address, check [server] section in cellframe-node.cfg"), -8;
+                if ( l_listening && dap_net_parse_config_address(*l_listening, NULL, &l_port, NULL, NULL) < 0 ) {
+                    dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_INVALID_SERVER_ERR,
+                                       "Invalid server IP address, check [server] section in cellframe-node.cfg");
+                    return -DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_INVALID_SERVER_ERR;
+                }
             }
-            if (!l_port)
-                return dap_cli_server_cmd_set_reply_text(a_str_reply, "Unspecified port"), -9; 
+            if (!l_port) {
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_UNSPECIFIED_PORT_ERR,
+                                       "Unspecified port");
+                return -DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_UNSPECIFIED_PORT_ERR;
+            } 
         }
+        json_object* json_obj_out = NULL;
         switch ( l_res = dap_chain_net_node_list_request(l_net, l_port, true, 'a') )
         {
-            case 1: return dap_cli_server_cmd_set_reply_text(a_str_reply, "Successfully added"), 0;
-            case 2: return dap_cli_server_cmd_set_reply_text(a_str_reply, "No server"), l_res;
-            case 3: return dap_cli_server_cmd_set_reply_text(a_str_reply, "Didn't add your address node to node list"), l_res;
-            case 4: return dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't calculate hash for your addr"), l_res;
-            case 5: return dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't do handshake for your node"), l_res;
-            case 6: return dap_cli_server_cmd_set_reply_text(a_str_reply, "The node already exists"), l_res;
-            case 7: return dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't process node list HTTP request"), l_res;
-            default:return dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't process request, error %d", l_res), l_res;
+            case 1:
+                json_obj_out = json_object_new_object();
+                if (!json_obj_out) return dap_json_rpc_allocation_put(json_obj_out),DAP_CHAIN_NODE_CLI_COM_NODE_MEMORY_ALLOC_ERR;
+                json_object_object_add(json_obj_out, "status", json_object_new_string("Successfully added"));
+                json_object_array_add(*a_json_arr_reply, json_obj_out);
+                 return DAP_CHAIN_NODE_CLI_COM_NODE_OK;
+            case 2: dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_ADD_NO_SERVER_ERR,
+                                                                                                "No server");break;
+            case 3: dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_ADD_DIDNT_ADD_ADDRESS_ERR,
+                                                                "Didn't add your address node to node list");break;
+            case 4: dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_CALCULATE_HASH_ERR,
+                                                                       "Can't calculate hash for your addr");break;
+            case 5: dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_DO_HANDSHAKE_ERR,
+                                                                         "Can't do handshake for your node");break;
+            case 6: dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_ADD_ALREADY_EXISTS_ERR,
+                                                                                  "The node already exists");break;
+            case 7: dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_PROCESS_NODE_LIST_ERR,
+                                                                     "Can't process node list HTTP request");break;
+            default:dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_PROCESS_REQUEST_ERR,
+                                                                   "Can't process request, error %d", l_res);break;
+            return l_res;
         }
     }
 
@@ -959,32 +1024,49 @@ int com_node(int a_argc, char ** a_argv, void **a_str_reply)
         // handler of command 'node del'
         if (l_addr_str) {
             if (!dap_chain_net_is_my_node_authorized(l_net)) {
-                dap_cli_server_cmd_set_reply_text(a_str_reply, "You have no access rights");
-                return -10;
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_DELL_NO_ACCESS_RIGHTS_ERR,
+                                        "You have no access rights");
+                return -DAP_CHAIN_NODE_CLI_COM_NODE_DELL_NO_ACCESS_RIGHTS_ERR;
             }
             int l_res = dap_chain_node_info_del(l_net, l_node_info);
             if (l_res)
-                dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't delete node %s, error %d", l_addr_str, l_res);
-            else
-                dap_cli_server_cmd_set_reply_text(a_str_reply, "Successfully deleted node %s", l_addr_str);
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_DELL_CANT_DEL_NODE_ERR,
+                                        "Can't delete node %s, error %d", l_addr_str, l_res);
+            else {
+                json_object* json_obj_out = json_object_new_object();
+                if (!json_obj_out) return dap_json_rpc_allocation_put(json_obj_out),DAP_CHAIN_NODE_CLI_COM_NODE_MEMORY_ALLOC_ERR;
+                json_object_object_add(json_obj_out, "successfully_deleted_node", json_object_new_string(l_addr_str));
+                json_object_array_add(*a_json_arr_reply, json_obj_out);
+            }
             return l_res;
         }
         // Synchronous request, wait for reply
         int l_res = dap_chain_net_node_list_request(l_net, 0, true, 'r');
+        json_object* json_obj_out = NULL;
         switch (l_res) {
-            case 8:  dap_cli_server_cmd_set_reply_text(a_str_reply, "Sucessfully deleted"); return 0;
-            default: dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't process request, error %d", l_res); return l_res;
+            case 8: 
+                json_obj_out = json_object_new_object();
+                if (!json_obj_out) return dap_json_rpc_allocation_put(json_obj_out),DAP_CHAIN_NODE_CLI_COM_NODE_MEMORY_ALLOC_ERR;
+                json_object_object_add(json_obj_out, "status", json_object_new_string("Successfully deleted"));
+                json_object_array_add(*a_json_arr_reply, json_obj_out); 
+            return DAP_CHAIN_NODE_CLI_COM_NODE_OK;
+            default: dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_DELL_CANT_PROCESS_REQUEST_ERR,
+                                       "Can't process request, error %d", l_res);
+            return l_res;
         }
     }
 
     case CMD_LIST:{
         // handler of command 'node dump'
         bool l_is_full = dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-full", NULL);
-        return s_node_info_list_with_reply(l_net, &l_node_addr, l_is_full, alias_str, a_str_reply);
+        return s_node_info_list_with_reply(l_net, &l_node_addr, l_is_full, alias_str, *a_json_arr_reply);
     }
     case CMD_DUMP: {
+        json_object* json_obj_out = json_object_new_object();
+        if (!json_obj_out) return dap_json_rpc_allocation_put(json_obj_out),DAP_CHAIN_NODE_CLI_COM_NODE_MEMORY_ALLOC_ERR;
         dap_string_t *l_string_reply = dap_chain_node_states_info_read(l_net, l_node_info->address);
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "%s", l_string_reply->str);
+        json_object_object_add(json_obj_out, "status_dump", json_object_new_string(l_string_reply->str));
+        json_object_array_add(*a_json_arr_reply, json_obj_out);
         dap_string_free(l_string_reply, true);
         return 0;
     }
@@ -996,23 +1078,29 @@ int com_node(int a_argc, char ** a_argv, void **a_str_reply)
                 if(!dap_chain_node_alias_register(l_net, alias_str, &l_node_addr))
                     log_it(L_WARNING, "can't save alias %s", alias_str);
                 else {
-                    dap_cli_server_cmd_set_reply_text(a_str_reply, "alias mapped successfully");
+                    json_object* json_obj_out = json_object_new_object();
+                    if (!json_obj_out) return dap_json_rpc_allocation_put(json_obj_out),DAP_CHAIN_NODE_CLI_COM_NODE_MEMORY_ALLOC_ERR;
+                    json_object_object_add(json_obj_out, "status_alias", json_object_new_string("alias mapped successfully"));
+                    json_object_array_add(*a_json_arr_reply, json_obj_out);
                 }
             }
             else {
-                dap_cli_server_cmd_set_reply_text(a_str_reply, "alias can't be mapped because -addr is not found");
-                return -1;
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_ALIAS_ADDR_NOT_FOUND_ERR,
+                                                                "alias can't be mapped because -addr is not found");
+                return -DAP_CHAIN_NODE_CLI_COM_NODE_ALIAS_ADDR_NOT_FOUND_ERR;
             }
         }
         else {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "alias can't be mapped because -alias is not found");
-            return -1;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_ALIAS_ALIAS_NOT_FOUND_ERR,
+                "alias can't be mapped because -alias is not found");
+            return -DAP_CHAIN_NODE_CLI_COM_NODE_ALIAS_ALIAS_NOT_FOUND_ERR;
         }
 
         break;
         // make connect
     case CMD_CONNECT:
-         dap_cli_server_cmd_set_reply_text(a_str_reply, "Not implemented yet");
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_CONNECT_NOT_IMPLEMENTED_ERR,
+                                                                                        "Not implemented yet");
          break;
 #if 0
         // get address from alias if addr not defined
@@ -1205,39 +1293,46 @@ int com_node(int a_argc, char ** a_argv, void **a_str_reply)
                 DAP_DELETE(address_tmp);
             }
             else {
-                dap_cli_server_cmd_set_reply_text(a_str_reply, "No address found by alias");
-                return -4;
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_HANDSHAKE_NO_FOUND_ADDR_ERR,
+                                            "No address found by alias");
+                return -DAP_CHAIN_NODE_CLI_COM_NODE_HANDSHAKE_NO_FOUND_ADDR_ERR;
             }
         }
         l_node_addr = l_node_info->address;
         if(!l_node_addr.uint64) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "Addr not found");
-            return -5;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_HANDSHAKE_NO_FOUND_ADDR_ERR,
+                                            "Addr not found");
+            return -DAP_CHAIN_NODE_CLI_COM_NODE_HANDSHAKE_NO_FOUND_ADDR_ERR;
         }
 
-        dap_chain_node_info_t *node_info = node_info_read_and_reply(l_net, &l_node_addr, a_str_reply);
+        dap_chain_node_info_t *node_info = node_info_read_and_reply(l_net, &l_node_addr, *a_json_arr_reply);
         if(!node_info)
             return -6;
         int timeout_ms = 5000; //5 sec = 5000 ms
         // start handshake
         dap_chain_node_client_t *l_client = dap_chain_node_client_connect_default_channels(l_net,node_info);
         if(!l_client) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't connect");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_HANDSHAKE_CANT_CONNECT_ERR,
+                "Can't connect");
             DAP_DELETE(node_info);
-            return -7;
+            return -DAP_CHAIN_NODE_CLI_COM_NODE_HANDSHAKE_CANT_CONNECT_ERR;
         }
         // wait handshake
         int res = dap_chain_node_client_wait(l_client, NODE_CLIENT_STATE_ESTABLISHED, timeout_ms);
         if (res) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "No response from node");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_HANDSHAKE_NO_RESPONSE_ERR,
+                                        "No response from node");
             // clean client struct
             // dap_chain_node_client_close_unsafe(l_client); del in s_go_stage_on_client_worker_unsafe
             DAP_DELETE(node_info);
-            return -8;
+            return -DAP_CHAIN_NODE_CLI_COM_NODE_HANDSHAKE_NO_RESPONSE_ERR;
         }
         DAP_DELETE(node_info);
         dap_chain_node_client_close_unsafe(l_client);
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "Connection established");
+        json_object* json_obj_out = json_object_new_object();
+        if (!json_obj_out) return dap_json_rpc_allocation_put(json_obj_out),DAP_CHAIN_NODE_CLI_COM_NODE_MEMORY_ALLOC_ERR;
+        json_object_object_add(json_obj_out, "status_handshake", json_object_new_string("Connection established"));
+        json_object_array_add(*a_json_arr_reply, json_obj_out);
     } break;
 
     case CMD_CONNECTIONS: {
@@ -1245,10 +1340,12 @@ int com_node(int a_argc, char ** a_argv, void **a_str_reply)
         if (l_net) {
             dap_cluster_t *l_links_cluster = dap_cluster_by_mnemonim(l_net->pub.name);
             if (!l_links_cluster) {
-                 dap_cli_server_cmd_set_reply_text(a_str_reply, "Not found links cluster for net %s", l_net->pub.name);
-                 break;
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_CONNECTION_NOT_FOUND_LINKS_ERR,
+                                            "Not found links cluster for net %s", l_net->pub.name);
+                break;
             }
-            *a_str_reply = dap_cluster_get_links_info(l_links_cluster);
+            json_object *l_jobj_links = dap_cluster_get_links_info_json(l_links_cluster);
+            json_object_array_add(*a_json_arr_reply, l_jobj_links);
         } else {
             const char *l_guuid_str = NULL;
             dap_cluster_t *l_cluster = NULL;
@@ -1257,50 +1354,56 @@ int com_node(int a_argc, char ** a_argv, void **a_str_reply)
                 bool l_success = false;
                 dap_guuid_t l_guuid = dap_guuid_from_hex_str(l_guuid_str, &l_success);
                 if (!l_success) {
-                    dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't parse cluster guid %s", l_guuid_str);
+                    dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_CONNECTION_CANT_PARSE_CLUSTER_ERR,
+                                                    "Can't parse cluster guid %s", l_guuid_str);
                     break;
                 }
                 l_cluster = dap_cluster_find(l_guuid);
                 
                 if (!l_cluster) {
-                    dap_cli_server_cmd_set_reply_text(a_str_reply, "Not found cluster with ID %s", l_guuid_str);
+                    dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_CONNECTION_NOT_FOUND_CLUSTER_ID_ERR,
+                                                    "Not found cluster with ID %s", l_guuid_str);
                     break;
                 }
             }
-            *a_str_reply = dap_cluster_get_links_info(l_cluster);
+            json_object *l_jobj_links = dap_cluster_get_links_info_json(l_cluster);
+            json_object_array_add(*a_json_arr_reply, l_jobj_links);
         }
     } break;
 
     case  CMD_BAN: {
         dap_chain_t *l_chain = dap_chain_net_get_default_chain_by_chain_type(l_net, CHAIN_TYPE_DECREE);
         if(!l_chain) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s does not support decrees.", l_net->pub.name);
-            return -11;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_BAN_NETWORK_DOESNOT_SUPPORT_ERR,
+                                        "Network %s does not support decrees.", l_net->pub.name);
+            return -DAP_CHAIN_NODE_CLI_COM_NODE_BAN_NETWORK_DOESNOT_SUPPORT_ERR;
         }
         const char * l_hash_out_type = NULL;
         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_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
-            return -1;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_BAN_INVALID_PARAMETER_ERR,
+                                        "invalid parameter -H, valid values: -H <hex | base58>");
+            return -DAP_CHAIN_NODE_CLI_COM_NODE_BAN_INVALID_PARAMETER_ERR;
         }
         const char *l_certs_str = NULL;
         size_t l_certs_count = 0;
         dap_cert_t **l_certs = NULL;
         dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-certs", &l_certs_str);
         if (!l_certs_str) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "ban create requires parameter '-certs'");
-            return -106;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_BAN_REQUIRES_PARAMETER_ERR,
+                                        "ban create requires parameter '-certs'");
+            return -DAP_CHAIN_NODE_CLI_COM_NODE_BAN_REQUIRES_PARAMETER_ERR;
         }
         dap_cert_parse_str_list(l_certs_str, &l_certs, &l_certs_count);
         if(!l_certs_count) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply,
-                                              "decree create command request at least one valid certificate to sign the decree");
-            return -106;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_BAN_LEAST_ONE_VALID_CERT_ERR,
+                                        "decree create command request at least one valid certificate to sign the decree");
+            return -DAP_CHAIN_NODE_CLI_COM_NODE_BAN_LEAST_ONE_VALID_CERT_ERR;
         }
         dap_chain_datum_decree_t *l_decree = NULL;
-        dap_tsd_t *l_addr_tsd = s_chain_node_cli_com_node_create_tsd_addr(a_argv, arg_index, a_argc, a_str_reply, "bun");
+        dap_tsd_t *l_addr_tsd = s_chain_node_cli_com_node_create_tsd_addr_json(a_argv, arg_index, a_argc, *a_json_arr_reply, "bun");
         if (!l_addr_tsd) {
             return -112;
         }
@@ -1318,9 +1421,9 @@ int com_node(int a_argc, char ** a_argv, void **a_str_reply)
         size_t l_total_signs_success = 0;
         l_decree = dap_chain_datum_decree_sign_in_cycle(l_certs, l_decree, l_certs_count, &l_total_signs_success);
         if (!l_decree || !l_total_signs_success) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply,
-                                              "Decree creation failed. Successful count of certificate signing is 0");
-            return -108;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_BAN_DECREE_CREATION_FAILED_ERR,
+                                            "Decree creation failed. Successful count of certificate signing is 0");
+            return -DAP_CHAIN_NODE_CLI_COM_NODE_BAN_DECREE_CREATION_FAILED_ERR;
         }
         dap_chain_datum_t *l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_DECREE, l_decree,
                                                             sizeof(*l_decree) + l_decree->header.data_size +
@@ -1328,42 +1431,47 @@ int com_node(int a_argc, char ** a_argv, void **a_str_reply)
         DAP_DELETE(l_decree);
         char *l_key_str_out = dap_chain_mempool_datum_add(l_datum, l_chain, l_hash_out_type);
         DAP_DELETE(l_datum);
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "Datum %s is %s placed in datum pool",
-                                          l_key_str_out ? l_key_str_out : "",
-                                          l_key_str_out ? "" : " not");
+        json_object* json_obj_out = json_object_new_object();
+        if (!json_obj_out) return dap_json_rpc_allocation_put(json_obj_out),DAP_CHAIN_NODE_CLI_COM_NODE_MEMORY_ALLOC_ERR;
+        json_object_object_add(json_obj_out, "datum_placed_status", l_key_str_out ? json_object_new_string(l_key_str_out) :
+                                                                                    json_object_new_string("not placed"));
+        json_object_array_add(*a_json_arr_reply, json_obj_out);
         DAP_DELETE(l_key_str_out);
     } break;
 
     case CMD_UNBAN: {
         dap_chain_t *l_chain = dap_chain_net_get_default_chain_by_chain_type(l_net, CHAIN_TYPE_DECREE);
         if(!l_chain) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s does not support decrees.", l_net->pub.name);
-            return -11;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_UNBAN_NETWORK_DOES_NOT_SUPPORT_ERR,
+                                            "Network %s does not support decrees.", l_net->pub.name);
+            return -DAP_CHAIN_NODE_CLI_COM_NODE_UNBAN_NETWORK_DOES_NOT_SUPPORT_ERR;
         }
         const char * l_hash_out_type = NULL;
         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_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
-            return -1;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_UNBAN_INVALID_PRAMETER_ERR,
+                                        "invalid parameter -H, valid values: -H <hex | base58>");
+            return -DAP_CHAIN_NODE_CLI_COM_NODE_UNBAN_INVALID_PRAMETER_ERR;
         }
         const char *l_certs_str = NULL;
         size_t l_certs_count = 0;
         dap_cert_t **l_certs = NULL;
         dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-certs", &l_certs_str);
         if (!l_certs_str) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "ban create requires parameter '-certs'");
-            return -106;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_UNBAN_REQUIRES_PARAMETER_CERT_ERR,
+                                        "ban create requires parameter '-certs'");
+            return -DAP_CHAIN_NODE_CLI_COM_NODE_UNBAN_REQUIRES_PARAMETER_CERT_ERR;
         }
         dap_cert_parse_str_list(l_certs_str, &l_certs, &l_certs_count);
         if(!l_certs_count) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply,
-                                              "decree create command request at least one valid certificate to sign the decree");
-            return -106;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_UNBAN_LEAST_ONE_VALID_CERT_ERR,
+                                        "decree create command request at least one valid certificate to sign the decree");
+            return -DAP_CHAIN_NODE_CLI_COM_NODE_UNBAN_LEAST_ONE_VALID_CERT_ERR;
         }
         dap_chain_datum_decree_t *l_decree = NULL;
-        dap_tsd_t *l_addr_tsd = s_chain_node_cli_com_node_create_tsd_addr(a_argv, arg_index, a_argc, a_str_reply, "unbun");
+        dap_tsd_t *l_addr_tsd = s_chain_node_cli_com_node_create_tsd_addr_json(a_argv, arg_index, a_argc, *a_json_arr_reply, "unbun");
         if (!l_addr_tsd) {
             return -112;
         }
@@ -1381,9 +1489,9 @@ int com_node(int a_argc, char ** a_argv, void **a_str_reply)
         size_t l_total_signs_success = 0;
         l_decree = dap_chain_datum_decree_sign_in_cycle(l_certs, l_decree, l_certs_count, &l_total_signs_success);
         if (!l_decree || !l_total_signs_success) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply,
-                                              "Decree creation failed. Successful count of certificate signing is 0");
-            return -108;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_UNBAN_DECREE_CREATION_FAILED_ERR,
+                                                    "Decree creation failed. Successful count of certificate signing is 0");
+            return -DAP_CHAIN_NODE_CLI_COM_NODE_UNBAN_DECREE_CREATION_FAILED_ERR;
         }
         dap_chain_datum_t *l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_DECREE, l_decree,
                                                             sizeof(*l_decree) + l_decree->header.data_size +
@@ -1391,28 +1499,28 @@ int com_node(int a_argc, char ** a_argv, void **a_str_reply)
         DAP_DELETE(l_decree);
         char *l_key_str_out = dap_chain_mempool_datum_add(l_datum, l_chain, l_hash_out_type);
         DAP_DELETE(l_datum);
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "Datum %s is %s placed in datum pool",
-                                          l_key_str_out ? l_key_str_out : "",
-                                          l_key_str_out ? "" : " not");
+        json_object* json_obj_out = json_object_new_object();
+        if (!json_obj_out) return dap_json_rpc_allocation_put(json_obj_out),DAP_CHAIN_NODE_CLI_COM_NODE_MEMORY_ALLOC_ERR;
+        json_object_object_add(json_obj_out, "datum_placed_status", l_key_str_out ? json_object_new_string(l_key_str_out) :
+                                                                                    json_object_new_string("not placed"));
+        json_object_array_add(*a_json_arr_reply, json_obj_out);
         DAP_DELETE(l_key_str_out);
     } break;
 
     case CMD_BANLIST: {
-        char *l_str_banlist = dap_http_ban_list_client_dump(NULL);
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "%s", l_str_banlist);
-        DAP_DELETE(l_str_banlist);
+        json_object* json_obj_out = dap_http_ban_list_client_dump(NULL);
+        json_object_array_add(*a_json_arr_reply, json_obj_out);
     } break;
 
     case CMD_BALANCER: {
         //balancer link list
-        dap_string_t *l_links_str = dap_chain_net_balancer_get_node_str(l_net);
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "%s", l_links_str->str);
-        dap_string_free(l_links_str, true);
+        json_object *l_links_list = dap_chain_net_balancer_get_node_str(l_net);
+        json_object_array_add(*a_json_arr_reply, l_links_list);
     } break;
 
     default:
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "Unrecognized subcommand '%s'",
-                                          arg_index < a_argc ? a_argv[arg_index] : "(null)");
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_NODE_UNRECOGNISED_SUB_ERR,
+                                    "Unrecognized subcommand '%s'", arg_index < a_argc ? a_argv[arg_index] : "(null)");
         break;
     }
     return 0;
@@ -1539,10 +1647,10 @@ static void s_wallet_list(const char *a_wallet_path, json_object *a_json_arr_out
  */
 int com_tx_wallet(int a_argc, char **a_argv, void **a_str_reply)
 {
-json_object ** a_json_arr_reply = (json_object **) a_str_reply;
-const char *c_wallets_path = dap_chain_wallet_get_path(g_config);
-enum { CMD_NONE, CMD_WALLET_NEW, CMD_WALLET_LIST, CMD_WALLET_INFO, CMD_WALLET_ACTIVATE, CMD_WALLET_DEACTIVATE, CMD_WALLET_CONVERT, CMD_WALLET_OUTPUTS };
-int l_arg_index = 1, l_rc, cmd_num = CMD_NONE;
+    json_object ** a_json_arr_reply = (json_object **) a_str_reply;
+    const char *c_wallets_path = dap_chain_wallet_get_path(g_config);
+    enum { CMD_NONE, CMD_WALLET_NEW, CMD_WALLET_LIST, CMD_WALLET_INFO, CMD_WALLET_ACTIVATE, CMD_WALLET_DEACTIVATE, CMD_WALLET_CONVERT, CMD_WALLET_OUTPUTS };
+    int l_arg_index = 1, l_rc, cmd_num = CMD_NONE;
 
     // find  add parameter ('alias' or 'handshake')
     if(dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, dap_min(a_argc, l_arg_index + 1), "new", NULL))
@@ -1652,7 +1760,7 @@ int l_arg_index = 1, l_rc, cmd_num = CMD_NONE;
                 }
             }
             json_object * json_obj_wall = json_object_new_object();
-            const char *l_l_addr_str = dap_chain_addr_to_str_static((dap_chain_addr_t*) l_addr);
+            const char *l_addr_str = dap_chain_addr_to_str_static((dap_chain_addr_t*) l_addr);
             if(l_wallet)
             {
                 json_object_object_add(json_obj_wall, "sign", json_object_new_string(
@@ -1660,7 +1768,7 @@ int l_arg_index = 1, l_rc, cmd_num = CMD_NONE;
                                                                   dap_chain_wallet_check_sign(l_wallet) : "correct"));
                 json_object_object_add(json_obj_wall, "wallet", json_object_new_string(l_wallet->name));
             }
-            json_object_object_add(json_obj_wall, "addr", l_l_addr_str ? json_object_new_string(l_l_addr_str) : json_object_new_string("-"));
+            json_object_object_add(json_obj_wall, "addr", l_addr_str ? json_object_new_string(l_addr_str) : json_object_new_string("-"));
             json_object_object_add(json_obj_wall, "network", l_net_name? json_object_new_string(l_net_name) : json_object_new_string("-"));
 
             size_t l_l_addr_tokens_size = 0;
@@ -3963,6 +4071,7 @@ static dap_chain_datum_anchor_t * s_sign_anchor_in_cycle(dap_cert_t ** a_certs,
 // Decree commands handlers
 int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
 {
+    json_object ** a_json_arr_reply = (json_object **) a_str_reply;
     enum { CMD_NONE=0, CMD_CREATE, CMD_SIGN, CMD_ANCHOR, CMD_FIND, CMD_INFO };
     int arg_index = 1;
     const char *l_net_str = NULL;
@@ -3980,20 +4089,22 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
     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_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
-        return -1;
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_INVALID_PARAM_ERR,
+                                            "invalid parameter -H, valid values: -H <hex | base58>");
+        return -DAP_CHAIN_NODE_CLI_COM_DECREE_INVALID_PARAM_ERR;
     }
 
     dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-net", &l_net_str);
     // Select chain network
     if(!l_net_str) {
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "command requires parameter '-net'");
-        return -2;
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_REQUIRES_PARAM_NET_ERR,
+                                            "command requires parameter '-net'");
+        return -DAP_CHAIN_NODE_CLI_COM_DECREE_REQUIRES_PARAM_NET_ERR;
     } else {
         if((l_net = dap_chain_net_by_name(l_net_str)) == NULL) { // Can't find such network
-            dap_cli_server_cmd_set_reply_text(a_str_reply,
-                    "command requires parameter '-net' to be valid chain network name");
-            return -3;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_REQUIRES_PARAM_NET_ERR,
+                                            "command requires parameter '-net' to be valid chain network name");
+            return -DAP_CHAIN_NODE_CLI_COM_DECREE_REQUIRES_PARAM_NET_ERR;
         }
     }
 
@@ -4013,8 +4124,9 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
         // Public certifiacte of condition owner
         dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-certs", &l_certs_str);
         if (!l_certs_str) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "decree create requires parameter '-certs'");
-            return -106;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_REQUIRES_PARAM_CERT_ERR,
+                                                                "decree create requires parameter '-certs'");
+            return -DAP_CHAIN_NODE_CLI_COM_DECREE_REQUIRES_PARAM_CERT_ERR;
         }
         dap_cert_parse_str_list(l_certs_str, &l_certs, &l_certs_count);
     }
@@ -4023,9 +4135,9 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
     {
     case CMD_CREATE:{
         if(!l_certs_count) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply,
-                    "decree create command requres at least one valid certificate to sign the decree");
-            return -106;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_LEAST_VALID_CERT_ERR,
+                                "decree create command requres at least one valid certificate to sign the decree");
+            return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_LEAST_VALID_CERT_ERR;
         }
         dap_chain_datum_decree_t *l_datum_decree = NULL;
 
@@ -4035,18 +4147,20 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
         // Search chain
         if(l_chain_str) {
             if (!( l_chain = dap_chain_net_get_chain_by_name(l_net, l_chain_str) )) {
-                return dap_cli_server_cmd_set_reply_text(a_str_reply, "Invalid '-chain' parameter \"%s\", not found in net %s\n"
-                                                                   "Available chain with decree support:\n\t\"%s\"\n",
-                                                                   l_chain_str, l_net_str,
-                                                                   dap_chain_net_get_chain_by_chain_type(l_net, CHAIN_TYPE_DECREE)->name),
-                        -103;
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_INVALID_CHAIN_PARAM_ERR,
+                                                            "Invalid '-chain' parameter \"%s\", not found in net %s\n"
+                                                            "Available chain with decree support:\n\t\"%s\"\n",
+                                        l_chain_str, l_net_str, dap_chain_net_get_chain_by_chain_type(l_net, CHAIN_TYPE_DECREE)->name);
+                return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_INVALID_CHAIN_PARAM_ERR;
             } else if (l_chain != dap_chain_net_get_chain_by_chain_type(l_net, CHAIN_TYPE_DECREE)){ // check chain to support decree
-                dap_cli_server_cmd_set_reply_text(a_str_reply, "Chain %s don't support decree", l_chain->name);
-                return -104;
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_CHAIN_DONT_SUPPORT_ERR,
+                                                            "Chain %s don't support decree", l_chain->name);
+                return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_CHAIN_DONT_SUPPORT_ERR;
             }
         }else if((l_chain = dap_chain_net_get_default_chain_by_chain_type(l_net, CHAIN_TYPE_DECREE)) == NULL) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't find chain with decree support.");
-            return -105;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_CANT_FIND_CHAIN_ERR,
+                                                            "Can't find chain with decree support.");
+            return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_CANT_FIND_CHAIN_ERR;
         }
 
         dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-decree_chain", &l_decree_chain_str);
@@ -4054,20 +4168,28 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
         // Search chain
         if(l_decree_chain_str) {
             if (!( l_decree_chain = dap_chain_net_get_chain_by_name(l_net, l_decree_chain_str) )) {
-                dap_string_t *l_reply = dap_string_new("");
-                    dap_string_append_printf(l_reply, "Invalid '-chain' parameter \"%s\", not found in net %s\n"
-                                                      "Available chains:",
-                                                      l_chain_str, l_net_str);
+                    dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_INVALID_CHAIN_PARAM_ERR,
+                        "Invalid '-chain' parameter \"%s\", not found in net %s\n"
+                              "Available chains:", l_chain_str, l_net_str);
                     dap_chain_t *l_chain;
+                    json_object* json_obj_out = json_object_new_object();
+                    if (!json_obj_out) return dap_json_rpc_allocation_put_error(json_obj_out);
+                    json_object* json_obj_chains = json_object_new_array();
+                    if (!json_obj_chains) return dap_json_rpc_allocation_put_error(json_obj_out);
+                    json_object_object_add(json_obj_out, "available_chains", json_obj_chains);
                     DL_FOREACH(l_net->pub.chains, l_chain) {
-                        dap_string_append_printf(l_reply, "\n\t%s", l_chain->name);
+                        json_object* json_obj_chain = json_object_new_object();
+                        if (!json_obj_chain) return dap_json_rpc_allocation_put_error(json_obj_out);
+                        json_object_object_add(json_obj_chain, "chain", json_object_new_string(l_chain->name));
+                        json_object_array_add(json_obj_chains, json_obj_chain);
                     }
-                    char *l_str_reply = dap_string_free(l_reply, false);
-                    return dap_cli_server_cmd_set_reply_text(a_str_reply, "%s", l_str_reply), DAP_DELETE(l_str_reply), -103;
+                    json_object_array_add(*a_json_arr_reply, json_obj_out);                    
+                    return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_INVALID_CHAIN_PARAM_ERR;
             }
         } else {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "decree requires parameter -decree_chain.");
-            return -105;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_REQUIRES_PARAM_DECREE_CHAIN_ERR,
+                                                        "decree requires parameter -decree_chain.");
+            return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_REQUIRES_PARAM_DECREE_CHAIN_ERR;
         }
 
         dap_tsd_t *l_tsd = NULL;
@@ -4082,8 +4204,9 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
             l_subtype = DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_FEE;
             if (!dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-to_addr", &l_param_addr_str)){
                 if (dap_chain_addr_is_blank(&l_net->pub.fee_addr)) {
-                    dap_cli_server_cmd_set_reply_text(a_str_reply, "Use -to_addr parameter to set net fee");
-                    return -111;
+                    dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_NOT_FEE_PARAM_CHAIN_ERR,
+                                                                    "Use -to_addr parameter to set net fee");
+                    return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_NOT_FEE_PARAM_CHAIN_ERR;
                 }
             } else {
                 dap_chain_addr_t *l_addr = dap_chain_addr_from_str(l_param_addr_str);
@@ -4091,7 +4214,7 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
                 if (!l_tsd) {
                     log_it(L_CRITICAL, "%s", c_error_memory_alloc);
                     dap_list_free_full(l_tsd_list, NULL);
-                    return -1;
+                    return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_TSD_MEM_ALLOC_ERR;
                 }
                 l_tsd_list = dap_list_append(l_tsd_list, l_tsd);
                 DAP_DELETE(l_addr);
@@ -4102,7 +4225,7 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
             if (!l_tsd) {
                 log_it(L_CRITICAL, "%s", c_error_memory_alloc);
                 dap_list_free_full(l_tsd_list, NULL);
-                return -1;
+                return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_TSD_MEM_ALLOC_ERR;
             }
             l_tsd_list = dap_list_append(l_tsd_list, l_tsd);
         } else if (dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-hardfork_from", &l_param_value_str)) {
@@ -4149,7 +4272,7 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
                 if (!l_tsd) {
                     log_it(L_CRITICAL, "%s", c_error_memory_alloc);
                     dap_list_free_full(l_tsd_list, NULL);
-                    return -1;
+                    return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_TSD_MEM_ALLOC_ERR;
                 }
                 l_tsd_list = dap_list_append(l_tsd_list, l_tsd);
             }
@@ -4169,7 +4292,7 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
                         log_it(L_CRITICAL, "%s", c_error_memory_alloc);
                         dap_list_free_full(l_tsd_list, NULL);
                         dap_strfreev(l_addrs);
-                        return -1;
+                        return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_TSD_MEM_ALLOC_ERR;
                     }
                     l_tsd_list = dap_list_append(l_tsd_list, l_tsd);
                 }
@@ -4198,7 +4321,7 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
             uint16_t l_min_signs = dap_ledger_decree_get_min_num_of_signers(l_net->pub.ledger);
             if (l_new_certs_count < l_min_signs) {
                 log_it(L_WARNING,"Number of new certificates is less than minimum owner number.");
-                return -106;
+                return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_CERT_NUMBER_ERR;
             }
 
             size_t l_failed_certs = 0;
@@ -4216,7 +4339,7 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
             if(l_failed_certs)
             {
                 dap_list_free_full(l_tsd_list, NULL);
-                return -108;
+                return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_CERT_NO_PUB_KEY_ERR;
             }
         }else if (dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-signs_verify", &l_param_value_str)) {
             l_subtype = DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_OWNERS_MIN;
@@ -4224,40 +4347,43 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
             if (IS_ZERO_256(l_new_num_of_owners)) {
                 log_it(L_WARNING, "The minimum number of owners can't be zero");
                 dap_list_free_full(l_tsd_list, NULL);
-                return -112;
+                return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_NO_OWNERS_ERR;
             }
             dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
             uint256_t l_owners = GET_256_FROM_64(dap_ledger_decree_get_num_of_owners(l_net->pub.ledger));
             if (compare256(l_new_num_of_owners, l_owners) > 0) {
                 log_it(L_WARNING, "The minimum number of owners is greater than the total number of owners.");
                 dap_list_free_full(l_tsd_list, NULL);
-                return -110;
+                return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_TO_MANY_OWNERS_ERR;
             }
 
             l_tsd = dap_tsd_create(DAP_CHAIN_DATUM_DECREE_TSD_TYPE_MIN_OWNER, &l_new_num_of_owners, sizeof(l_new_num_of_owners));
             if (!l_tsd) {
                 log_it(L_CRITICAL, "%s", c_error_memory_alloc);
                 dap_list_free_full(l_tsd_list, NULL);
-                return -1;
+                return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_MEM_ALOC_ERR;
             }
             l_tsd_list = dap_list_append(l_tsd_list, l_tsd);
         } else {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "Decree subtype fail.");
-            return -111;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_SUBCOM_ERR,
+                                                        "Decree subtype fail.");
+            return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_SUBCOM_ERR;
         }
 
         if (l_subtype == DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_OWNERS ||
             l_subtype == DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_OWNERS_MIN)
         {
             if (l_decree_chain->id.uint64 != l_chain->id.uint64){
-                dap_cli_server_cmd_set_reply_text(a_str_reply, "Decree subtype %s not suppurted by chain %s",
-                                                  dap_chain_datum_decree_subtype_to_str(l_subtype), l_decree_chain_str);
-                return -107;
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_NOT_CHAIN_PARAM_ERR,
+                                                    "Decree subtype %s not suppurted by chain %s",
+                                                    dap_chain_datum_decree_subtype_to_str(l_subtype), l_decree_chain_str);
+                return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_NOT_CHAIN_PARAM_ERR;
             }
         } else if (l_decree_chain->id.uint64 == l_chain->id.uint64){
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "Decree subtype %s not suppurted by chain %s",
-                                              dap_chain_datum_decree_subtype_to_str(l_subtype), l_decree_chain_str);
-            return -107;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_NOT_CHAIN_PARAM_ERR,
+                                                    "Decree subtype %s not suppurted by chain %s",
+                                                    dap_chain_datum_decree_subtype_to_str(l_subtype), l_decree_chain_str);
+            return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_NOT_CHAIN_PARAM_ERR;
         }
         size_t l_total_tsd_size = dap_tsd_calc_list_size(l_tsd_list);
         l_datum_decree = DAP_NEW_Z_SIZE(dap_chain_datum_decree_t, sizeof(dap_chain_datum_decree_t) + l_total_tsd_size);
@@ -4280,9 +4406,9 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
             l_datum_decree = dap_chain_datum_decree_sign_in_cycle(l_certs, l_datum_decree, l_certs_count, &l_total_signs_success);
 
         if (!l_datum_decree || l_total_signs_success == 0){
-            dap_cli_server_cmd_set_reply_text(a_str_reply,
-                        "Decree creation failed. Successful count of certificate signing is 0");
-                return -108;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_NO_CERT_ERR,
+                                        "Decree creation failed. Successful count of certificate signing is 0");
+            return -DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_NO_CERT_ERR;
         }
 
         // Create datum
@@ -4293,16 +4419,18 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
         DAP_DELETE(l_datum_decree);
         char *l_key_str_out = dap_chain_mempool_datum_add(l_datum, l_chain, l_hash_out_type);
         DAP_DELETE(l_datum);
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "Datum %s is%s placed in datum pool",
-                                          l_key_str_out ? l_key_str_out : "",
-                                          l_key_str_out ? "" : " not");
+        json_object* json_obj_status = json_object_new_object();
+        if (!json_obj_status) return dap_json_rpc_allocation_put_error(json_obj_status);
+        json_object_object_add(json_obj_status, "datum_status", l_key_str_out ? json_object_new_string(l_key_str_out) :
+                                                                                json_object_new_string("not_placed"));
+        json_object_array_add(*a_json_arr_reply, json_obj_status);
         break;
     }
     case CMD_SIGN:{
         if(!l_certs_count) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply,
-                    "decree sign command requres at least one valid certificate to sign");
-            return -106;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_NO_VALID_CERT_ERR,
+                                            "decree sign command requres at least one valid certificate to sign");
+            return -DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_NO_VALID_CERT_ERR;
         }
 
         const char * l_datum_hash_str = NULL;
@@ -4314,18 +4442,21 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
             // Search chain
             if(l_chain_str) {
                 if (!( l_chain = dap_chain_net_get_chain_by_name(l_net, l_chain_str) )) {
-                    return dap_cli_server_cmd_set_reply_text(a_str_reply, "Invalid '-chain' parameter \"%s\", not found in net %s\n"
-                                                                          "Available chain with decree support:\n\t\"%s\"\n",
-                                                                          l_chain_str, l_net_str,
-                                                                          dap_chain_net_get_chain_by_chain_type(l_net, CHAIN_TYPE_DECREE)->name),
-                            -103;
+                    dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_INVALID_CHAIN_PARAM_ERR,
+                        "Invalid '-chain' parameter \"%s\", not found in net %s\n"
+                        "Available chain with decree support:\n\t\"%s\"\n",
+                        l_chain_str, l_net_str,
+                        dap_chain_net_get_chain_by_chain_type(l_net, CHAIN_TYPE_DECREE)->name);
+                    return -DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_INVALID_CHAIN_PARAM_ERR;
                 } else if (l_chain != dap_chain_net_get_chain_by_chain_type(l_net, CHAIN_TYPE_DECREE)){ // check chain to support decree
-                    dap_cli_server_cmd_set_reply_text(a_str_reply, "Chain %s don't support decree", l_chain->name);
-                    return -104;
+                    dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_CHAIN_DONT_SUPPORT_ERR,
+                                                "Chain %s don't support decree", l_chain->name);
+                    return -DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_CHAIN_DONT_SUPPORT_ERR;
                 }
-            }else if((l_chain = dap_chain_net_get_default_chain_by_chain_type(l_net, CHAIN_TYPE_DECREE)) == NULL) {
-                dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't find chain with decree support.");
-                return -105;
+            } else if((l_chain = dap_chain_net_get_default_chain_by_chain_type(l_net, CHAIN_TYPE_DECREE)) == NULL) {
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_CANT_FIND_CHAIN_ERR,
+                                                "Can't find chain with decree support.");
+                return -DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_CANT_FIND_CHAIN_ERR;
             }
 
             char * l_gdb_group_mempool = dap_chain_mempool_group_new(l_chain);
@@ -4365,9 +4496,9 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
                         l_datum_decree = dap_chain_datum_decree_sign_in_cycle(l_certs, l_datum_decree, l_certs_count, &l_total_signs_success);
 
                     if (!l_datum_decree || l_total_signs_success == 0){
-                        dap_cli_server_cmd_set_reply_text(a_str_reply,
-                                    "Decree creation failed. Successful count of certificate signing is 0");
-                            return -108;
+                        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_CREATION_ERR,
+                                                    "Decree creation failed. Successful count of certificate signing is 0");
+                        return -DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_CREATION_ERR;
                     }
                     size_t l_decree_size = dap_chain_datum_decree_get_size(l_datum_decree);
                     dap_chain_datum_t * l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_DECREE,
@@ -4376,26 +4507,30 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
 
                     char *l_key_str_out = dap_chain_mempool_datum_add(l_datum, l_chain, l_hash_out_type);
                     DAP_DELETE(l_datum);
-                    dap_cli_server_cmd_set_reply_text(a_str_reply, "Datum %s is%s placed in datum pool",
-                                                      l_key_str_out ? l_key_str_out : "",
-                                                      l_key_str_out ? "" : " not");
-
-                    }else{
-                    dap_cli_server_cmd_set_reply_text(a_str_reply,
-                            "Error! Wrong datum type. decree sign only decree datum");
-                    return -61;
+
+                    json_object* json_obj_status = json_object_new_object();
+                    if (!json_obj_status) return dap_json_rpc_allocation_put_error(json_obj_status);
+                    json_object_object_add(json_obj_status, "datum_status", l_key_str_out ? json_object_new_string(l_key_str_out) :
+                                                                                            json_object_new_string("not_placed"));
+                    json_object_array_add(*a_json_arr_reply, json_obj_status);
+                } else {
+                    dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_WRONG_DATUM_TYPE_ERR,
+                                            "Error! Wrong datum type. decree sign only decree datum");
+                    return -DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_WRONG_DATUM_TYPE_ERR;                    
                 }
-            }else{
-                dap_cli_server_cmd_set_reply_text(a_str_reply,
-                        "decree sign can't find datum with %s hash in the mempool of %s:%s",l_datum_hash_out_str,l_net? l_net->pub.name: "<undefined>",
-                        l_chain?l_chain->name:"<undefined>");
-                return -5;
+            } else{
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_CANT_FIND_DATUM_ERR,
+                    "decree sign can't find datum with %s hash in the mempool of %s:%s",
+                    l_datum_hash_out_str,l_net? l_net->pub.name: "<undefined>",
+                    l_chain?l_chain->name:"<undefined>");
+                return -DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_CANT_FIND_DATUM_ERR;
             }
             DAP_DELETE(l_datum_hash_hex_str);
             DAP_DELETE(l_datum_hash_base58_str);
         } else {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "decree sign need -datum <datum hash> argument");
-            return -2;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_NEED_SIGN_ERR,
+                                            "decree sign need -datum <datum hash> argument");
+            return -DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_NEED_SIGN_ERR;
         }
         break;
     }
@@ -4405,18 +4540,21 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
         // Search chain
         if(l_chain_str) {
             if (!( l_chain = dap_chain_net_get_chain_by_name(l_net, l_chain_str) )) {
-                return dap_cli_server_cmd_set_reply_text(a_str_reply, "Invalid '-chain' parameter \"%s\", not found in net %s\n"
-                                                                      "Available chain with anchor support:\n\t\"%s\"\n",
-                                                                      l_chain_str, l_net_str,
-                                                                      dap_chain_net_get_chain_by_chain_type(l_net, CHAIN_TYPE_ANCHOR)->name),
-                        -103;
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_INVALID_CHAIN_PARAM_ERR,
+                                            "Invalid '-chain' parameter \"%s\", not found in net %s\n"
+                                            "Available chain with anchor support:\n\t\"%s\"\n",
+                                            l_chain_str, l_net_str,
+                                            dap_chain_net_get_chain_by_chain_type(l_net, CHAIN_TYPE_ANCHOR)->name);
+                return -DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_INVALID_CHAIN_PARAM_ERR;
             } else if (l_chain != dap_chain_net_get_chain_by_chain_type(l_net, CHAIN_TYPE_ANCHOR)){ // check chain to support decree
-                dap_cli_server_cmd_set_reply_text(a_str_reply, "Chain %s don't support decree", l_chain->name);
-                return -104;
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_CHAIN_DONT_SUPPORT_ERR,
+                                            "Chain %s don't support decree", l_chain->name);
+                return -DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_CHAIN_DONT_SUPPORT_ERR;
             }
         }else if((l_chain = dap_chain_net_get_default_chain_by_chain_type(l_net, CHAIN_TYPE_ANCHOR)) == NULL) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't find chain with default anchor support.");
-            return -105;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_CANT_FIND_CHAIN_ERR,
+                                                        "Can't find chain with default anchor support.");
+            return -DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_CANT_FIND_CHAIN_ERR;
         }
 
         dap_chain_datum_anchor_t *l_datum_anchor = NULL;
@@ -4424,9 +4562,9 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
         const char * l_datum_hash_str = NULL;
         if (!dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-datum", &l_datum_hash_str))
         {
-            dap_cli_server_cmd_set_reply_text(a_str_reply,
-                        "Anchor creation failed. Cmd decree create anchor must contain -datum parameter.");
-                return -107;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_NOT_DATUM_PARAM_ERR,
+                                    "Anchor creation failed. Cmd decree create anchor must contain -datum parameter.");
+            return -DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_NOT_DATUM_PARAM_ERR;
         }
         if(l_datum_hash_str) {
             dap_chain_hash_fast_from_str(l_datum_hash_str, &l_hash);
@@ -4436,9 +4574,9 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
         dap_tsd_t *l_tsd = dap_tsd_create(DAP_CHAIN_DATUM_ANCHOR_TSD_TYPE_DECREE_HASH, &l_hash, sizeof(dap_hash_fast_t));
         if(!l_tsd)
         {
-            dap_cli_server_cmd_set_reply_text(a_str_reply,
-                        "Anchor creation failed. Memory allocation fail.");
-                return -107;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_MEMORY_ERR,
+                                        "Anchor creation failed. Memory allocation fail.");
+            return -DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_MEMORY_ERR;
         }
 
         // Create anchor datum
@@ -4455,9 +4593,9 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
             l_datum_anchor = s_sign_anchor_in_cycle(l_certs, l_datum_anchor, l_certs_count, &l_total_signs_success);
 
         if (!l_datum_anchor || !l_total_signs_success) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply,
-                        "Anchor creation failed. Successful count of certificate signing is 0");
-                return DAP_DELETE(l_datum_anchor), -108;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_CERT_SIGN_ERR,
+                                    "Anchor creation failed. Successful count of certificate signing is 0");
+            return DAP_DELETE(l_datum_anchor), -DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_CERT_SIGN_ERR;
         }
 
         // Create datum
@@ -4468,51 +4606,63 @@ int cmd_decree(int a_argc, char **a_argv, void **a_str_reply)
         DAP_DELETE(l_datum_anchor);
         char *l_key_str_out = dap_chain_mempool_datum_add(l_datum, l_chain, l_hash_out_type);
         DAP_DELETE(l_datum);
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "Datum %s is%s placed in datum pool",
-                                          l_key_str_out ? l_key_str_out : "",
-                                          l_key_str_out ? "" : " not");
+        json_object* json_obj_status = json_object_new_object();
+        if (!json_obj_status) return dap_json_rpc_allocation_put_error(json_obj_status);
+        json_object_object_add(json_obj_status, "datum_status", l_key_str_out ? json_object_new_string(l_key_str_out) :
+                                                                                json_object_new_string("not_placed"));
+        json_object_array_add(*a_json_arr_reply, json_obj_status);
         break;
     }
     case CMD_FIND: {
         const char *l_hash_str = NULL;
         dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-hash", &l_hash_str);
         if (!l_hash_str) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'decree find' requiers parameter '-hash'");
-            return -110;
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_FIND_REQ_PARAM_HASH_ERR,
+                                                            "Command 'decree find' requiers parameter '-hash'");
+            return -DAP_CHAIN_NODE_CLI_COM_DECREE_FIND_REQ_PARAM_HASH_ERR;
         }
         dap_hash_fast_t l_datum_hash;
         if (dap_chain_hash_fast_from_hex_str(l_hash_str, &l_datum_hash) &&
                 dap_chain_hash_fast_from_base58_str(l_hash_str, &l_datum_hash)) {
-            dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't convert '-hash' parameter to numeric value");
-            return -111;
+                    dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_FIND_REQ_PARAM_VALUE_ERR,
+                                                            "Can't convert '-hash' parameter to numeric value");
+                    return -DAP_CHAIN_NODE_CLI_COM_DECREE_FIND_REQ_PARAM_VALUE_ERR;
         }
         bool l_applied = false;
         dap_chain_datum_decree_t *l_decree = dap_ledger_decree_get_by_hash(l_net, &l_datum_hash, &l_applied);
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified decree is %s in decrees hash-table",
-                                          l_decree ? (l_applied ? "applied" : "not applied") : "not found");
+        json_object* json_obj_status = json_object_new_object();
+        if (!json_obj_status) return dap_json_rpc_allocation_put_error(json_obj_status);
+        json_object_object_add(json_obj_status, "find_status", l_decree ? (l_applied ? json_object_new_string("applied") :
+                                                                                       json_object_new_string("not_applied")) :
+                                                                                json_object_new_string("not_found"));
+        json_object_array_add(*a_json_arr_reply, json_obj_status);
     } break;
     case CMD_INFO: {
-        dap_string_t *l_str_owner_pkey = dap_string_new("");
+        json_object* json_obj_out = json_object_new_object();
+        if (!json_obj_out) return dap_json_rpc_allocation_put_error(json_obj_out);
+        json_object* json_obj_array = json_object_new_array();
+        if (!json_obj_array) return dap_json_rpc_allocation_put_error(json_obj_out);
+        json_object_object_add(json_obj_out, "owners", json_obj_array);
         const dap_list_t *l_decree_pkeys = dap_ledger_decree_get_owners_pkeys(l_net->pub.ledger);
         int i = 0;
         dap_hash_fast_t l_pkey_hash = {};
         for (const dap_list_t *it = l_decree_pkeys; it; it = it->next) {
             dap_pkey_t *l_pkey = it->data;
             dap_pkey_get_hash(l_pkey, &l_pkey_hash);
-            dap_string_append_printf(l_str_owner_pkey, "\t%d) %s\n", ++i, dap_hash_fast_to_str_static(&l_pkey_hash));
-        }
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "Decree info:\n"
-                                                       "\tOwners: %d\n"
-                                                       "\t=====================================================================\n"
-                                                       "%s"
-                                                       "\t=====================================================================\n"
-                                                       "\tMin owners for apply decree: %d\n",
-                                          dap_ledger_decree_get_num_of_owners(l_net->pub.ledger), l_str_owner_pkey->str,
-                                          dap_ledger_decree_get_min_num_of_signers(l_net->pub.ledger));
-        dap_string_free(l_str_owner_pkey, true);
+            json_object* json_obj_owner = json_object_new_object();
+            if (!json_obj_owner) return dap_json_rpc_allocation_put_error(json_obj_out);
+            json_object_object_add(json_obj_owner, "num", json_object_new_int(i));
+            json_object_object_add(json_obj_owner, "pkey_hash", json_object_new_string(dap_hash_fast_to_str_static(&l_pkey_hash)));
+            i++;
+            json_object_array_add(json_obj_array, json_obj_owner);
+        }
+        json_object_object_add(json_obj_out, "owners_total", json_object_new_int(dap_ledger_decree_get_num_of_owners(l_net->pub.ledger)));
+        json_object_object_add(json_obj_out, "min_owners", json_object_new_int(dap_ledger_decree_get_min_num_of_signers(l_net->pub.ledger)));
+        json_object_array_add(*a_json_arr_reply, json_obj_out);
     } break;
     default:
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "Not found decree action. Use create, sign, anchor or find parameter");
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_DECREE_NOT_FOUND_COM_ERR,
+                                    "Not found decree action. Use create, sign, anchor or find parameter");
         return -1;
     }
 
diff --git a/modules/node-cli/include/dap_chain_node_cli_cmd.h b/modules/node-cli/include/dap_chain_node_cli_cmd.h
index 9bd9f8508ac9252f750e89b973111cca98e259c4..4d026b3223a547228d49120e6747c0fa0a7d137b 100644
--- a/modules/node-cli/include/dap_chain_node_cli_cmd.h
+++ b/modules/node-cli/include/dap_chain_node_cli_cmd.h
@@ -433,6 +433,124 @@ int com_tx_cond_unspent_find(int a_argc, char **a_argv, void **reply);
  */
 
 int com_tx_verify(int a_argc, char ** a_argv, void **a_str_reply);
+typedef enum s_com_tx_node_err{
+    DAP_CHAIN_NODE_CLI_COM_NODE_OK = 0,
+    DAP_CHAIN_NODE_CLI_COM_NODE_COMMAND_NOT_RECOGNIZED_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_CANT_PARSE_NODE_ADDR_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_CANT_PARSE_HOST_PORT_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_UNRECOGNISED_SUB_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_MEMORY_ALLOC_ERR,
+
+    DAP_CHAIN_NODE_CLI_COM_NODE_ADD_HAVE_NO_ACCESS_RIGHTS_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_PARSE_HOST_STRING_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_UNSPECIFIED_PORT_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_ADDED_NOT_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_INVALID_SERVER_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_ADD_NO_SERVER_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_ADD_DIDNT_ADD_ADDRESS_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_CALCULATE_HASH_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_DO_HANDSHAKE_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_ADD_ALREADY_EXISTS_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_PROCESS_NODE_LIST_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_ADD_CANT_PROCESS_REQUEST_ERR,
+
+    DAP_CHAIN_NODE_CLI_COM_NODE_DELL_NO_ACCESS_RIGHTS_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_DELL_CANT_DEL_NODE_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_DELL_CANT_PROCESS_REQUEST_ERR,
+
+    DAP_CHAIN_NODE_CLI_COM_NODE_LIST_NODE_RECORD_CORRUPTED_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_LIST_NO_RECORDS_ERR,
+
+    DAP_CHAIN_NODE_CLI_COM_NODE_ALIAS_ADDR_NOT_FOUND_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_ALIAS_ALIAS_NOT_FOUND_ERR,
+
+    DAP_CHAIN_NODE_CLI_COM_NODE_CONNECT_NOT_IMPLEMENTED_ERR,
+
+    DAP_CHAIN_NODE_CLI_COM_NODE_HANDSHAKE_NO_FOUND_ADDR_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_HANDSHAKE_CANT_CONNECT_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_HANDSHAKE_NO_RESPONSE_ERR,
+
+    DAP_CHAIN_NODE_CLI_COM_NODE_CONNECTION_NOT_FOUND_LINKS_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_CONNECTION_CANT_PARSE_CLUSTER_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_CONNECTION_NOT_FOUND_CLUSTER_ID_ERR,
+
+    DAP_CHAIN_NODE_CLI_COM_NODE_BAN_NETWORK_DOESNOT_SUPPORT_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_BAN_INVALID_PARAMETER_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_BAN_REQUIRES_PARAMETER_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_BAN_LEAST_ONE_VALID_CERT_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_BAN_CANT_CONVERT_ADDR_VALUE_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_BAN_HOST_OPTION_WASNOT_SPECIFIED_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_BAN_DECREE_CREATION_FAILED_ERR,
+
+    DAP_CHAIN_NODE_CLI_COM_NODE_UNBAN_NETWORK_DOES_NOT_SUPPORT_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_UNBAN_INVALID_PRAMETER_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_UNBAN_REQUIRES_PARAMETER_CERT_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_UNBAN_LEAST_ONE_VALID_CERT_ERR,
+    DAP_CHAIN_NODE_CLI_COM_NODE_UNBAN_DECREE_CREATION_FAILED_ERR
+
+
+} s_com_tx_node_err_t;
+
+typedef enum s_com_decree_err{
+    DAP_CHAIN_NODE_CLI_COM_DECREE_OK = 0,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_INVALID_PARAM_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_NOT_FOUND_COM_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_REQUIRES_PARAM_NET_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_REQUIRES_PARAM_CERT_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_MEMORY_ALLOC_ERR,   
+
+    DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_LEAST_VALID_CERT_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_INVALID_CHAIN_PARAM_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_CHAIN_DONT_SUPPORT_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_CANT_FIND_CHAIN_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_REQUIRES_PARAM_DECREE_CHAIN_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_NOT_FEE_PARAM_CHAIN_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_TSD_MEM_ALLOC_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_CERT_NUMBER_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_CERT_NO_PUB_KEY_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_NO_OWNERS_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_TO_MANY_OWNERS_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_MEM_ALOC_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_SUBCOM_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_NOT_CHAIN_PARAM_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_NOT_FOUND_DECREE_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_CREATE_NO_CERT_ERR,
+
+    DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_NO_VALID_CERT_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_INVALID_CHAIN_PARAM_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_CHAIN_DONT_SUPPORT_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_CANT_FIND_CHAIN_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_CREATION_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_WRONG_DATUM_TYPE_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_CANT_FIND_DATUM_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_SIGN_NEED_SIGN_ERR,
+
+    DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_INVALID_CHAIN_PARAM_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_CHAIN_DONT_SUPPORT_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_CANT_FIND_CHAIN_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_NOT_DATUM_PARAM_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_MEMORY_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_ANCHOR_CERT_SIGN_ERR,
+
+    DAP_CHAIN_NODE_CLI_COM_DECREE_FIND_REQ_PARAM_HASH_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_FIND_REQ_PARAM_VALUE_ERR,
+
+
+    DAP_CHAIN_NODE_CLI_COM_DECREE_HASH_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_NET_PARAM_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_INCOMPATIBLE_PARAMS_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_WALLET_ADDR_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_TRESHOLD_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_LACK_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_NET_FIND_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_ID_NET_ADDR_DIF_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_HASH_GET_ERR,
+    DAP_CHAIN_NODE_CLI_COM_DECREE_TX_HASH_ERR,
+
+    /* add custom codes here */
+
+    DAP_CHAIN_NODE_CLI_COM_DECREE_UNKNOWN /* MAX */
+} s_com_decree_err_t;
 
 char *dap_chain_node_cli_com_tx_history_err(int a_code);
 
diff --git a/modules/service/datum/dap_chain_net_srv_datum.c b/modules/service/datum/dap_chain_net_srv_datum.c
index 25eb125b062b4219124385db1b2a83717683ac0e..4520a8c05231de4d6d01f2deb4b208b1e3495029 100644
--- a/modules/service/datum/dap_chain_net_srv_datum.c
+++ b/modules/service/datum/dap_chain_net_srv_datum.c
@@ -32,6 +32,12 @@
 #include "dap_chain_net_srv_datum.h"
 
 #define LOG_TAG "chain_net_srv_datum"
+typedef enum s_com_srv_datum_err{
+    DAP_CHAIN_NODE_CLI_COM_SRV_DATUM_OK = 0,
+    DAP_CHAIN_NODE_CLI_COM_SRV_DATUM_REQUIRES_PARAMETER_DATUM,
+    DAP_CHAIN_NODE_CLI_COM_SRV_DATUM_CONFIG_WASNT_LOADED,
+    DAP_CHAIN_NODE_CLI_COM_SRV_DATUM_CANT_PLACE_DATUM_TO_MEMPOOL
+}s_com_srv_datum_err_t;
 
 static dap_chain_net_srv_t *s_srv_datum = NULL;
 static int s_srv_datum_cli(int argc, char ** argv, void **a_str_reply);
@@ -106,6 +112,7 @@ char* dap_chain_net_srv_datum_custom_add(dap_chain_t * a_chain, const uint8_t *a
 
 static int s_srv_datum_cli(int argc, char ** argv, void **a_str_reply)
 {
+    json_object ** a_json_arr_reply = (json_object **) a_str_reply;
     int arg_index = 1;
     dap_chain_net_t * l_chain_net = NULL;
     dap_chain_t * l_chain = NULL;
@@ -117,14 +124,16 @@ static int s_srv_datum_cli(int argc, char ** argv, void **a_str_reply)
     const char * l_datum_hash_str = NULL;
     dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-datum", &l_datum_hash_str);
     if (!l_datum_hash_str) {
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "Command srv_datum requires parameter '-datum' <datum hash>");
-        return -4;
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_SRV_DATUM_REQUIRES_PARAMETER_DATUM,
+                                                    "Command srv_datum requires parameter '-datum' <datum hash>");
+        return -DAP_CHAIN_NODE_CLI_COM_SRV_DATUM_REQUIRES_PARAMETER_DATUM;
     }
 
     const char * l_system_datum_folder = dap_config_get_item_str(g_config, "resources", "datum_folder");
     if (!l_system_datum_folder){
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "Configuration wasn't loaded");
-        return -6;
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_SRV_DATUM_CONFIG_WASNT_LOADED,
+                                                    "Configuration wasn't loaded");
+        return -DAP_CHAIN_NODE_CLI_COM_SRV_DATUM_CONFIG_WASNT_LOADED;
     }
 
     const char * l_datum_cmd_str = NULL;
@@ -177,13 +186,16 @@ static int s_srv_datum_cli(int argc, char ** argv, void **a_str_reply)
 
             char *l_ret;
             if ((l_ret = dap_chain_net_srv_datum_custom_add(l_chain, l_datum_data, l_datum_data_size)) == NULL) {
-                dap_cli_server_cmd_set_reply_text(a_str_reply,
-                        "Can't place datum custom \"%s\" to mempool", l_datum_hash_str);
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_SRV_DATUM_CANT_PLACE_DATUM_TO_MEMPOOL,
+                                                "Can't place datum custom \"%s\" to mempool", l_datum_hash_str);
             }
             else {
-                dap_cli_server_cmd_set_reply_text(a_str_reply,
-                        "Datum custom %s was successfully placed to mempool", l_datum_hash_str); 
+                json_object* json_obj_out = json_object_new_object();
+                char *l_status = dap_strdup_printf("Datum custom %s was successfully placed to mempool", l_datum_hash_str);
+                json_object_object_add(json_obj_out, "status", json_object_new_string(l_status));
+                DAP_DELETE(l_status); 
                 DAP_DELETE(l_ret);
+                json_object_array_add(*a_json_arr_reply, json_obj_out);
                 return 0;
             }
         }